Add a dagger.internal.Provider in order to in the future help with adding support for jakarta.inject.Provider.

RELNOTES=Unavoidable breaking change for AssistedInject factories built at a previous version PiperOrigin-RevId: 588500546
author: Eric Chang <erichang@google.com> 2023-12-06 11:59:43 -0800
committer: Dagger Team <dagger-dev+copybara@google.com> 2023-12-06 12:01:45 -0800
commit: 75d3cbcf95f1b540faac46f87bc8d018e254bd4e (patch)
tree: 19000996ae508acee4e196df6c909d35936b5fa7
parent: 668269ddfec64dad8685b2f38f66cc8227dd3c8a (diff)
download: dagger2-75d3cbcf95f1b540faac46f87bc8d018e254bd4e.tar.gz
158 files changed, 866 insertions, 425 deletions
diff --git a/java/dagger/internal/AbstractMapFactory.java b/java/dagger/internal/AbstractMapFactory.java
index 1cf83fa1d..22512e9d3 100644
--- a/java/dagger/internal/AbstractMapFactory.java
+++ b/java/dagger/internal/AbstractMapFactory.java
@@ -22,7 +22,6 @@ import static java.util.Collections.unmodifiableMap;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
-import javax.inject.Provider;
 
 /**
  * An {@code abstract} {@link Factory} implementation used to implement {@link Map} bindings.
diff --git a/java/dagger/internal/DelegateFactory.java b/java/dagger/internal/DelegateFactory.java
index 3b4a30f23..bc5cd9a29 100644
--- a/java/dagger/internal/DelegateFactory.java
+++ b/java/dagger/internal/DelegateFactory.java
@@ -17,12 +17,11 @@
 package dagger.internal;
 
 import static dagger.internal.Preconditions.checkNotNull;
-
-import javax.inject.Provider;
+import static dagger.internal.Providers.asDaggerProvider;
 
 /**
  * A DelegateFactory that is used to stitch Provider/Lazy indirection based dependency cycles.
- * 
+ *
  * @since 2.0.1
  */
 public final class DelegateFactory<T> implements Factory<T> {
@@ -44,18 +43,43 @@ public final class DelegateFactory<T> implements Factory<T> {
   }
 
   /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  public void setDelegatedProvider(javax.inject.Provider<T> delegate) {
+    setDelegatedProvider(asDaggerProvider(delegate));
+  }
+
+  /**
    * Sets {@code delegateFactory}'s delegate provider to {@code delegate}.
    *
    * <p>{@code delegateFactory} must be an instance of {@link DelegateFactory}, otherwise this
    * method will throw a {@link ClassCastException}.
    */
   public static <T> void setDelegate(Provider<T> delegateFactory, Provider<T> delegate) {
-    checkNotNull(delegate);
     DelegateFactory<T> asDelegateFactory = (DelegateFactory<T>) delegateFactory;
-    if (asDelegateFactory.delegate != null) {
+    setDelegateInternal(asDelegateFactory, delegate);
+  }
+
+  /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  public static <T> void setDelegate(
+      javax.inject.Provider<T> delegateFactory, javax.inject.Provider<T> delegate) {
+    DelegateFactory<T> asDelegateFactory = (DelegateFactory<T>) delegateFactory;
+    setDelegateInternal(asDelegateFactory, asDaggerProvider(delegate));
+  }
+
+  private static <T> void setDelegateInternal(
+      DelegateFactory<T> delegateFactory, Provider<T> delegate) {
+    checkNotNull(delegate);
+    if (delegateFactory.delegate != null) {
       throw new IllegalStateException();
     }
-    asDelegateFactory.delegate = delegate;
+    delegateFactory.delegate = delegate;
   }
 
   /**
@@ -67,4 +91,3 @@ public final class DelegateFactory<T> implements Factory<T> {
     return checkNotNull(delegate);
   }
 }
-
diff --git a/java/dagger/internal/DoubleCheck.java b/java/dagger/internal/DoubleCheck.java
index af7d7f69a..2c2e3ab9c 100644
--- a/java/dagger/internal/DoubleCheck.java
+++ b/java/dagger/internal/DoubleCheck.java
@@ -17,9 +17,9 @@
 package dagger.internal;
 
 import static dagger.internal.Preconditions.checkNotNull;
+import static dagger.internal.Providers.asDaggerProvider;
 
 import dagger.Lazy;
-import javax.inject.Provider;
 
 /**
  * A {@link Lazy} and {@link Provider} implementation that memoizes the value returned from a
@@ -73,7 +73,8 @@ public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
   /** Returns a {@link Provider} that caches the value from the given delegate provider. */
   // This method is declared this way instead of "<T> Provider<T> provider(Provider<T> delegate)"
   // to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
-  public static <P extends Provider<T>, T> Provider<T> provider(P delegate) {
+  public static <P extends dagger.internal.Provider<T>, T> dagger.internal.Provider<T> provider(
+      P delegate) {
     checkNotNull(delegate);
     if (delegate instanceof DoubleCheck) {
       /* This should be a rare case, but if we have a scoped @Binds that delegates to a scoped
@@ -83,6 +84,16 @@ public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
     return new DoubleCheck<T>(delegate);
   }
 
+  /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  public static <P extends javax.inject.Provider<T>, T> javax.inject.Provider<T> provider(
+      P delegate) {
+    return provider(asDaggerProvider(delegate));
+  }
+
   /** Returns a {@link Lazy} that caches the value from the given provider. */
   // This method is declared this way instead of "<T> Lazy<T> lazy(Provider<T> delegate)"
   // to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
@@ -99,4 +110,13 @@ public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
     }
     return new DoubleCheck<T>(checkNotNull(provider));
   }
+
+  /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  public static <P extends javax.inject.Provider<T>, T> Lazy<T> lazy(P provider) {
+    return lazy(asDaggerProvider(provider));
+  }
 }
diff --git a/java/dagger/internal/Factory.java b/java/dagger/internal/Factory.java
index 9c03f81aa..73bcfbc13 100644
--- a/java/dagger/internal/Factory.java
+++ b/java/dagger/internal/Factory.java
@@ -18,7 +18,6 @@ package dagger.internal;
 
 import dagger.Provides;
 import javax.inject.Inject;
-import javax.inject.Provider;
 import javax.inject.Scope;
 
 /**
diff --git a/java/dagger/internal/MapFactory.java b/java/dagger/internal/MapFactory.java
index 39748c9ad..376cfdc1c 100644
--- a/java/dagger/internal/MapFactory.java
+++ b/java/dagger/internal/MapFactory.java
@@ -17,12 +17,12 @@
 package dagger.internal;
 
 import static dagger.internal.DaggerCollections.newLinkedHashMapWithExpectedSize;
+import static dagger.internal.Providers.asDaggerProvider;
 import static java.util.Collections.unmodifiableMap;
 
 import java.util.Collections;
 import java.util.Map;
 import java.util.Map.Entry;
-import javax.inject.Provider;
 
 /**
  * A {@link Factory} implementation used to implement {@link Map} bindings. This factory returns a
@@ -72,12 +72,30 @@ public final class MapFactory<K, V> extends AbstractMapFactory<K, V, V> {
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> put(K key, javax.inject.Provider<V> providerOfValue) {
+      return put(key, asDaggerProvider(providerOfValue));
+    }
+
     @Override
     public Builder<K, V> putAll(Provider<Map<K, V>> mapFactory) {
       super.putAll(mapFactory);
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> putAll(javax.inject.Provider<Map<K, V>> mapFactory) {
+      return putAll(asDaggerProvider(mapFactory));
+    }
+
     /** Returns a new {@link MapProviderFactory}. */
     public MapFactory<K, V> build() {
       return new MapFactory<>(map);
diff --git a/java/dagger/internal/MapProviderFactory.java b/java/dagger/internal/MapProviderFactory.java
index 1fe478856..8491ffc85 100644
--- a/java/dagger/internal/MapProviderFactory.java
+++ b/java/dagger/internal/MapProviderFactory.java
@@ -16,9 +16,12 @@
 
 package dagger.internal;
 
+import static dagger.internal.DaggerCollections.newLinkedHashMapWithExpectedSize;
+import static dagger.internal.Providers.asDaggerProvider;
+
 import dagger.Lazy;
+import java.util.Collections;
 import java.util.Map;
-import javax.inject.Provider;
 
 /**
  * A {@link Factory} implementation used to implement {@link Map} bindings. This factory returns a
@@ -57,12 +60,43 @@ public final class MapProviderFactory<K, V> extends AbstractMapFactory<K, V, Pro
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> put(K key, javax.inject.Provider<V> providerOfValue) {
+      return put(key, asDaggerProvider(providerOfValue));
+    }
+
     @Override
     public Builder<K, V> putAll(Provider<Map<K, Provider<V>>> mapProviderFactory) {
       super.putAll(mapProviderFactory);
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> putAll(
+        final javax.inject.Provider<Map<K, javax.inject.Provider<V>>> mapProviderFactory) {
+      return putAll(new Provider<Map<K, Provider<V>>>() {
+          @Override public Map<K, Provider<V>> get() {
+            Map<K, javax.inject.Provider<V>> javaxMap = mapProviderFactory.get();
+            if (javaxMap.isEmpty()) {
+              return Collections.emptyMap();
+            }
+            Map<K, Provider<V>> daggerMap = newLinkedHashMapWithExpectedSize(javaxMap.size());
+            for (Map.Entry<K, javax.inject.Provider<V>> e : javaxMap.entrySet()) {
+              daggerMap.put(e.getKey(), asDaggerProvider(e.getValue()));
+            }
+            return Collections.unmodifiableMap(daggerMap);
+          }
+      });
+    }
+
     /** Returns a new {@link MapProviderFactory}. */
     public MapProviderFactory<K, V> build() {
       return new MapProviderFactory<>(map);
diff --git a/java/dagger/internal/Provider.java b/java/dagger/internal/Provider.java
new file mode 100644
index 000000000..e38860187
--- /dev/null
+++ b/java/dagger/internal/Provider.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2023 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal;
+
+/**
+ * Internal Provider interface to make support for {@code javax.inject.Provider} and
+ * {@code jakarta.inject.Provider} easier. Do not use outside of Dagger implementation code.
+ */
+// TODO(erichang): Make this also extend the Jakarta Provider
+public interface Provider<T> extends javax.inject.Provider<T> {
+}
diff --git a/java/dagger/internal/ProviderOfLazy.java b/java/dagger/internal/ProviderOfLazy.java
index 23b6afd75..0430cbd6e 100644
--- a/java/dagger/internal/ProviderOfLazy.java
+++ b/java/dagger/internal/ProviderOfLazy.java
@@ -17,9 +17,9 @@
 package dagger.internal;
 
 import static dagger.internal.Preconditions.checkNotNull;
+import static dagger.internal.Providers.asDaggerProvider;
 
 import dagger.Lazy;
-import javax.inject.Provider;
 
 /**
  * A {@link Provider} of {@link Lazy} instances that each delegate to a given {@link Provider}.
@@ -51,4 +51,13 @@ public final class ProviderOfLazy<T> implements Provider<Lazy<T>> {
   public static <T> Provider<Lazy<T>> create(Provider<T> provider) {
     return new ProviderOfLazy<T>(checkNotNull(provider));
   }
+
+  /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  public static <T> Provider<Lazy<T>> create(javax.inject.Provider<T> provider) {
+    return create(asDaggerProvider(provider));
+  }
 }
diff --git a/java/dagger/internal/Providers.java b/java/dagger/internal/Providers.java
new file mode 100644
index 000000000..60ec83fa4
--- /dev/null
+++ b/java/dagger/internal/Providers.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal;
+
+import static dagger.internal.Preconditions.checkNotNull;
+
+/** Helper class for utility functions dealing with Providers. */
+public final class Providers {
+
+  /** Converts a javax provider to a Dagger internal provider. */
+  public static <T> Provider<T> asDaggerProvider(final javax.inject.Provider<T> provider) {
+    checkNotNull(provider);
+    return new Provider<T>() {
+        @Override public T get() {
+          return provider.get();
+        }
+    };
+  }
+
+  private Providers() {}
+}
diff --git a/java/dagger/internal/SetFactory.java b/java/dagger/internal/SetFactory.java
index 349399b3e..f16076708 100644
--- a/java/dagger/internal/SetFactory.java
+++ b/java/dagger/internal/SetFactory.java
@@ -20,6 +20,7 @@ import static dagger.internal.DaggerCollections.hasDuplicates;
 import static dagger.internal.DaggerCollections.newHashSetWithExpectedSize;
 import static dagger.internal.DaggerCollections.presizedList;
 import static dagger.internal.Preconditions.checkNotNull;
+import static dagger.internal.Providers.asDaggerProvider;
 import static java.util.Collections.emptySet;
 import static java.util.Collections.unmodifiableSet;
 
@@ -27,7 +28,6 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
-import javax.inject.Provider;
 
 /**
  * A {@link Factory} implementation used to implement {@link Set} bindings. This factory always
@@ -73,6 +73,15 @@ public final class SetFactory<T> implements Factory<Set<T>> {
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<T> addProvider(javax.inject.Provider<? extends T> individualProvider) {
+      return addProvider(asDaggerProvider(individualProvider));
+    }
+
     @SuppressWarnings("unchecked")
     public Builder<T> addCollectionProvider(
         Provider<? extends Collection<? extends T>> collectionProvider) {
@@ -81,6 +90,16 @@ public final class SetFactory<T> implements Factory<Set<T>> {
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<T> addCollectionProvider(
+        javax.inject.Provider<? extends Collection<? extends T>> collectionProvider) {
+      return addCollectionProvider(asDaggerProvider(collectionProvider));
+    }
+
     public SetFactory<T> build() {
       assert !hasDuplicates(individualProviders)
           : "Codegen error?  Duplicates in the provider list";
diff --git a/java/dagger/internal/SingleCheck.java b/java/dagger/internal/SingleCheck.java
index 41280699d..32ba83a6f 100644
--- a/java/dagger/internal/SingleCheck.java
+++ b/java/dagger/internal/SingleCheck.java
@@ -17,8 +17,7 @@
 package dagger.internal;
 
 import static dagger.internal.Preconditions.checkNotNull;
-
-import javax.inject.Provider;
+import static dagger.internal.Providers.asDaggerProvider;
 
 /**
  * A {@link Provider} implementation that memoizes the result of another {@link Provider} using
@@ -58,7 +57,7 @@ public final class SingleCheck<T> implements Provider<T> {
   }
 
   /** Returns a {@link Provider} that caches the value from the given delegate provider. */
-  // This method is declared this way instead of "<T> Provider<T> provider(Provider<T> provider)" 
+  // This method is declared this way instead of "<T> Provider<T> provider(Provider<T> provider)"
   // to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
   public static <P extends Provider<T>, T> Provider<T> provider(P provider) {
     // If a scoped @Binds delegates to a scoped binding, don't cache the value again.
@@ -67,4 +66,13 @@ public final class SingleCheck<T> implements Provider<T> {
     }
     return new SingleCheck<T>(checkNotNull(provider));
   }
+
+  /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  public static <P extends javax.inject.Provider<T>, T> javax.inject.Provider<T> provider(
+      P delegate) {
+    return provider(asDaggerProvider(delegate));
+  }
 }
diff --git a/java/dagger/internal/codegen/base/FrameworkTypes.java b/java/dagger/internal/codegen/base/FrameworkTypes.java
index 59588caf5..e39aeabea 100644
--- a/java/dagger/internal/codegen/base/FrameworkTypes.java
+++ b/java/dagger/internal/codegen/base/FrameworkTypes.java
@@ -29,6 +29,7 @@ import java.util.Set;
  * type that the framework itself defines.
  */
 public final class FrameworkTypes {
+  // TODO(erichang): Add the Jakarta Provider here
   private static final ImmutableSet<ClassName> PROVISION_TYPES =
       ImmutableSet.of(TypeNames.PROVIDER, TypeNames.LAZY, TypeNames.MEMBERS_INJECTOR);
 
diff --git a/java/dagger/internal/codegen/base/MapType.java b/java/dagger/internal/codegen/base/MapType.java
index 00401ed72..c4ba838e8 100644
--- a/java/dagger/internal/codegen/base/MapType.java
+++ b/java/dagger/internal/codegen/base/MapType.java
@@ -115,6 +115,13 @@ public abstract class MapType {
     return isMap(key.type().xprocessing());
   }
 
+  public static boolean isMapOfProvider(XType keyType) {
+    if (MapType.isMap(keyType)) {
+      return MapType.from(keyType).valuesAreTypeOf(TypeNames.PROVIDER);
+    }
+    return false;
+  }
+
   /**
    * Returns a {@link MapType} for {@code type}.
    *
diff --git a/java/dagger/internal/codegen/base/OptionalType.java b/java/dagger/internal/codegen/base/OptionalType.java
index 79b638d4a..5544eaeba 100644
--- a/java/dagger/internal/codegen/base/OptionalType.java
+++ b/java/dagger/internal/codegen/base/OptionalType.java
@@ -20,6 +20,7 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static dagger.internal.codegen.extension.DaggerStreams.toImmutableMap;
 import static dagger.internal.codegen.extension.DaggerStreams.valuesOf;
 import static dagger.internal.codegen.xprocessing.XTypes.isDeclared;
+import static dagger.internal.codegen.xprocessing.XTypes.isTypeOf;
 
 import androidx.room.compiler.processing.XType;
 import androidx.room.compiler.processing.XTypeElement;
@@ -155,4 +156,14 @@ public abstract class OptionalType {
   public static OptionalType from(Key key) {
     return from(key.type().xprocessing());
   }
+
+  public static boolean isOptionalProviderType(XType type) {
+    if (OptionalType.isOptional(type)) {
+      OptionalType optionalType = OptionalType.from(type);
+      if (isTypeOf(optionalType.valueType(), TypeNames.PROVIDER)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
diff --git a/java/dagger/internal/codegen/binding/FrameworkField.java b/java/dagger/internal/codegen/binding/FrameworkField.java
index b1d1cf91b..a9f3bbfbd 100644
--- a/java/dagger/internal/codegen/binding/FrameworkField.java
+++ b/java/dagger/internal/codegen/binding/FrameworkField.java
@@ -24,12 +24,14 @@ import static dagger.internal.codegen.model.BindingKind.MEMBERS_INJECTOR;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
 
 import androidx.room.compiler.processing.XElement;
-import androidx.room.compiler.processing.XType;
 import com.google.auto.value.AutoValue;
 import com.google.common.base.CaseFormat;
+import com.google.common.base.Preconditions;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.ParameterizedTypeName;
 import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.javapoet.TypeNames;
 import java.util.Optional;
 
 /**
@@ -49,16 +51,17 @@ public abstract class FrameworkField {
   /**
    * Creates a framework field.
    *
-   * @param frameworkClassName the name of the framework class (e.g., {@link javax.inject.Provider})
-   * @param valueTypeName the name of the type parameter of the framework class (e.g., {@code Foo}
-   *     for {@code Provider<Foo>}
-   * @param fieldName the name of the field
+   * @param fieldType the type of the framework field (e.g., {@code Provider<Foo>}).
+   * @param fieldName the base name of the field. The name of the raw type of the field will be
+   *     added as a suffix
    */
-  public static FrameworkField create(
-      ClassName frameworkClassName, TypeName valueTypeName, String fieldName) {
-    String suffix = frameworkClassName.simpleName();
+  public static FrameworkField create(TypeName fieldType, String fieldName) {
+    Preconditions.checkState(
+        fieldType instanceof ClassName || fieldType instanceof ParameterizedTypeName,
+        "Can only create a field with a class name or parameterized type name");
+    String suffix = ((ClassName) TypeNames.rawTypeName(fieldType)).simpleName();
     return new AutoValue_FrameworkField(
-        ParameterizedTypeName.get(frameworkClassName, valueTypeName),
+        fieldType,
         fieldName.endsWith(suffix) ? fieldName : fieldName + suffix);
   }
 
@@ -71,15 +74,26 @@ public abstract class FrameworkField {
   public static FrameworkField forBinding(
       ContributionBinding binding, Optional<ClassName> frameworkClassName) {
     return create(
-        frameworkClassName.orElse(binding.frameworkType().frameworkClassName()),
-        fieldValueType(binding).getTypeName(),
+        fieldType(binding, frameworkClassName.orElse(binding.frameworkType().frameworkClassName())),
         frameworkFieldName(binding));
   }
 
-  private static XType fieldValueType(ContributionBinding binding) {
-    return binding.contributionType().isMultibinding()
-        ? binding.contributedType()
-        : binding.key().type().xprocessing();
+  private static TypeName fieldType(ContributionBinding binding, ClassName frameworkClassName) {
+    if (binding.contributionType().isMultibinding()) {
+      return ParameterizedTypeName.get(frameworkClassName, binding.contributedType().getTypeName());
+    }
+
+    // If the binding key type is a Map<K, Provider<V>>, we need to change field type to a raw
+    // type. This is because it actually needs to be changed to Map<K, dagger.internal.Provider<V>>,
+    // but that gets into assignment issues when the field is passed to methods that expect
+    // Map<K, javax.inject.Provider<V>>. We could add casts everywhere, but it is easier to just
+    // make the field itself a raw type.
+    if (MapType.isMapOfProvider(binding.contributedType())) {
+      return frameworkClassName;
+    }
+
+    return ParameterizedTypeName.get(
+        frameworkClassName, binding.key().type().xprocessing().getTypeName());
   }
 
   private static String frameworkFieldName(ContributionBinding binding) {
@@ -104,7 +118,7 @@ public abstract class FrameworkField {
     }
   }
 
-  public abstract ParameterizedTypeName type();
+  public abstract TypeName type();
 
   public abstract String name();
 }
diff --git a/java/dagger/internal/codegen/binding/FrameworkType.java b/java/dagger/internal/codegen/binding/FrameworkType.java
index ce3b149bc..c99594892 100644
--- a/java/dagger/internal/codegen/binding/FrameworkType.java
+++ b/java/dagger/internal/codegen/binding/FrameworkType.java
@@ -96,7 +96,8 @@ public enum FrameworkType {
 
         case PROVIDER_OF_LAZY:
           return Expression.create(
-              from.type().rewrapType(TypeNames.LAZY).wrapType(TypeNames.PROVIDER), codeBlock);
+              from.type().rewrapType(TypeNames.LAZY).wrapType(TypeNames.DAGGER_PROVIDER),
+              codeBlock);
 
         case FUTURE:
           return Expression.create(from.type().rewrapType(TypeNames.LISTENABLE_FUTURE), codeBlock);
@@ -178,7 +179,7 @@ public enum FrameworkType {
   public ClassName frameworkClassName() {
     switch (this) {
       case PROVIDER:
-        return TypeNames.PROVIDER;
+        return TypeNames.DAGGER_PROVIDER;
       case PRODUCER_NODE:
         // TODO(cgdecker): Replace this with new class for representing internal producer nodes.
         // Currently the new class is CancellableProducer, but it may be changed to ProducerNode and
diff --git a/java/dagger/internal/codegen/binding/SourceFiles.java b/java/dagger/internal/codegen/binding/SourceFiles.java
index 19d316f3d..e8a10753d 100644
--- a/java/dagger/internal/codegen/binding/SourceFiles.java
+++ b/java/dagger/internal/codegen/binding/SourceFiles.java
@@ -95,11 +95,23 @@ public final class SourceFiles {
 
     return Maps.toMap(
         binding.dependencies(),
-        dependency ->
-            FrameworkField.create(
-                frameworkTypeMapper.getFrameworkType(dependency.kind()).frameworkClassName(),
-                dependency.key().type().xprocessing().getTypeName(),
-                DependencyVariableNamer.name(dependency)));
+        dependency -> {
+          ClassName frameworkClassName =
+              frameworkTypeMapper.getFrameworkType(dependency.kind()).frameworkClassName();
+          // Remap factory fields back to javax.inject.Provider to maintain backwards compatibility
+          // for now. In a future release, we should change this to Dagger Provider. This will still
+          // be a breaking change, but keeping compatibility for a while should reduce the
+          // likelihood of breakages as it would require components built at much older versions
+          // using factories built at newer versions to break.
+          if (frameworkClassName.equals(TypeNames.DAGGER_PROVIDER)) {
+            frameworkClassName = TypeNames.PROVIDER;
+          }
+          return FrameworkField.create(
+              ParameterizedTypeName.get(
+                  frameworkClassName,
+                  dependency.key().type().xprocessing().getTypeName()),
+              DependencyVariableNamer.name(dependency));
+        });
   }
 
   public CodeBlock frameworkTypeUsageStatement(
diff --git a/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar b/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar
index 69e859d4c..6e4b0a96f 100644
--- a/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar
+++ b/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar
diff --git a/java/dagger/internal/codegen/javapoet/CodeBlocks.java b/java/dagger/internal/codegen/javapoet/CodeBlocks.java
index 912dc71b8..29457e267 100644
--- a/java/dagger/internal/codegen/javapoet/CodeBlocks.java
+++ b/java/dagger/internal/codegen/javapoet/CodeBlocks.java
@@ -18,7 +18,7 @@ package dagger.internal.codegen.javapoet;
 
 import static com.squareup.javapoet.MethodSpec.methodBuilder;
 import static com.squareup.javapoet.TypeSpec.anonymousClassBuilder;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.daggerProviderOf;
 import static java.util.stream.StreamSupport.stream;
 import static javax.lang.model.element.Modifier.PUBLIC;
 
@@ -87,7 +87,7 @@ public final class CodeBlocks {
     return CodeBlock.of(
         "$L",
         anonymousClassBuilder("")
-            .superclass(providerOf(providedType))
+            .superclass(daggerProviderOf(providedType))
             .addMethod(
                 methodBuilder("get")
                     .addAnnotation(Override.class)
diff --git a/java/dagger/internal/codegen/javapoet/TypeNames.java b/java/dagger/internal/codegen/javapoet/TypeNames.java
index 814022254..251ddbe3f 100644
--- a/java/dagger/internal/codegen/javapoet/TypeNames.java
+++ b/java/dagger/internal/codegen/javapoet/TypeNames.java
@@ -69,6 +69,8 @@ public final class TypeNames {
   public static final ClassName MEMBERS_INJECTORS =
       ClassName.get("dagger.internal", "MembersInjectors");
   public static final ClassName PROVIDER = ClassName.get("javax.inject", "Provider");
+  public static final ClassName DAGGER_PROVIDER = ClassName.get("dagger.internal", "Provider");
+  public static final ClassName DAGGER_PROVIDERS = ClassName.get("dagger.internal", "Providers");
   public static final ClassName PROVIDER_OF_LAZY =
       ClassName.get("dagger.internal", "ProviderOfLazy");
   public static final ClassName SCOPE_METADATA = ClassName.get("dagger.internal", "ScopeMetadata");
@@ -217,6 +219,10 @@ public final class TypeNames {
     return ParameterizedTypeName.get(PROVIDER, typeName);
   }
 
+  public static ParameterizedTypeName daggerProviderOf(TypeName typeName) {
+    return ParameterizedTypeName.get(DAGGER_PROVIDER, typeName);
+  }
+
   public static ParameterizedTypeName setOf(TypeName elementType) {
     return ParameterizedTypeName.get(SET, elementType);
   }
diff --git a/java/dagger/internal/codegen/processingstep/AssistedFactoryProcessingStep.java b/java/dagger/internal/codegen/processingstep/AssistedFactoryProcessingStep.java
index 3f714b047..ebd5d106d 100644
--- a/java/dagger/internal/codegen/processingstep/AssistedFactoryProcessingStep.java
+++ b/java/dagger/internal/codegen/processingstep/AssistedFactoryProcessingStep.java
@@ -23,6 +23,7 @@ import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForB
 import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
 import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
 import static dagger.internal.codegen.javapoet.TypeNames.INSTANCE_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.daggerProviderOf;
 import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
 import static dagger.internal.codegen.langmodel.Accessibility.accessibleTypeName;
 import static dagger.internal.codegen.xprocessing.MethodSpecs.overriding;
@@ -314,6 +315,10 @@ final class AssistedFactoryProcessingStep extends TypeCheckingProcessingStep<XTy
                           .map(param -> CodeBlock.of("$L", param.getJvmName()))
                           .collect(toParametersCodeBlock()))
                   .build())
+          // In a future release, we should delete this javax method. This will still be a breaking
+          // change, but keeping compatibility for a while should reduce the likelihood of breakages
+          // as it would require components built at much older versions using factories built at
+          // newer versions to break.
           .addMethod(
               MethodSpec.methodBuilder("create")
                   .addModifiers(PUBLIC, STATIC)
@@ -331,6 +336,27 @@ final class AssistedFactoryProcessingStep extends TypeCheckingProcessingStep<XTy
                           : CodeBlock.of(""),
                       name,
                       delegateFactoryParam)
+                  .build())
+          // Normally we would have called this just "create", but because of backwards
+          // compatibility we can't have two methods with the same name/arguments returning
+          // different Provider types.
+          .addMethod(
+              MethodSpec.methodBuilder("createFactoryProvider")
+                  .addModifiers(PUBLIC, STATIC)
+                  .addParameter(delegateFactoryParam)
+                  .addTypeVariables(typeVariableNames(metadata.assistedInjectElement()))
+                  .returns(daggerProviderOf(factory.getType().getTypeName()))
+                  .addStatement(
+                      "return $T.$Lcreate(new $T($N))",
+                      INSTANCE_FACTORY,
+                      // Java 7 type inference requires the method call provide the exact type here.
+                      isPreJava8SourceVersion(processingEnv)
+                          ? CodeBlock.of(
+                              "<$T>",
+                              accessibleTypeName(metadata.factoryType(), name, processingEnv))
+                          : CodeBlock.of(""),
+                      name,
+                      delegateFactoryParam)
                   .build());
       return ImmutableList.of(builder);
     }
diff --git a/java/dagger/internal/codegen/writing/ComponentRequestRepresentations.java b/java/dagger/internal/codegen/writing/ComponentRequestRepresentations.java
index 922fcb489..dd343168a 100644
--- a/java/dagger/internal/codegen/writing/ComponentRequestRepresentations.java
+++ b/java/dagger/internal/codegen/writing/ComponentRequestRepresentations.java
@@ -27,13 +27,17 @@ import static dagger.internal.codegen.langmodel.Accessibility.isRawTypeAccessibl
 import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
 import static dagger.internal.codegen.xprocessing.MethodSpecs.overriding;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
+import static dagger.internal.codegen.xprocessing.XProcessingEnvs.isPreJava8SourceVersion;
 
 import androidx.room.compiler.processing.XMethodElement;
+import androidx.room.compiler.processing.XProcessingEnv;
 import androidx.room.compiler.processing.XType;
 import com.google.common.collect.ImmutableList;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
 import com.squareup.javapoet.MethodSpec;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.OptionalType;
 import dagger.internal.codegen.binding.Binding;
 import dagger.internal.codegen.binding.BindingGraph;
 import dagger.internal.codegen.binding.BindingRequest;
@@ -69,6 +73,7 @@ public final class ComponentRequestRepresentations {
   private final ProvisionBindingRepresentation.Factory provisionBindingRepresentationFactory;
   private final ProductionBindingRepresentation.Factory productionBindingRepresentationFactory;
   private final Map<Binding, BindingRepresentation> representations = new HashMap<>();
+  private final XProcessingEnv processingEnv;
 
   @Inject
   ComponentRequestRepresentations(
@@ -78,7 +83,8 @@ public final class ComponentRequestRepresentations {
       ComponentRequirementExpressions componentRequirementExpressions,
       MembersInjectionBindingRepresentation.Factory membersInjectionBindingRepresentationFactory,
       ProvisionBindingRepresentation.Factory provisionBindingRepresentationFactory,
-      ProductionBindingRepresentation.Factory productionBindingRepresentationFactory) {
+      ProductionBindingRepresentation.Factory productionBindingRepresentationFactory,
+      XProcessingEnv processingEnv) {
     this.parent = parent;
     this.graph = graph;
     this.componentImplementation = componentImplementation;
@@ -87,6 +93,7 @@ public final class ComponentRequestRepresentations {
     this.provisionBindingRepresentationFactory = provisionBindingRepresentationFactory;
     this.productionBindingRepresentationFactory = productionBindingRepresentationFactory;
     this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
+    this.processingEnv = processingEnv;
   }
 
   /**
@@ -232,6 +239,15 @@ public final class ComponentRequestRepresentations {
         componentMethod.methodElement()
             .asMemberOf(componentImplementation.graph().componentTypeElement().getType())
             .getReturnType();
+
+    // When compiling with -source 7, javac's type inference isn't strong enough to match things
+    // like Optional<javax.inject.Provider<T>> to Optional<dagger.internal.Provider<T>>.
+    if (isPreJava8SourceVersion(processingEnv)
+        && (MapType.isMapOfProvider(returnType)
+            || OptionalType.isOptionalProviderType(returnType))) {
+      return expression.castTo(returnType.getRawType());
+    }
+
     return !isVoid(returnType) && !expression.type().isAssignableTo(returnType)
         ? expression.castTo(returnType)
         : expression;
diff --git a/java/dagger/internal/codegen/writing/DelegateRequestRepresentation.java b/java/dagger/internal/codegen/writing/DelegateRequestRepresentation.java
index 673a659fd..82c01cfe2 100644
--- a/java/dagger/internal/codegen/writing/DelegateRequestRepresentation.java
+++ b/java/dagger/internal/codegen/writing/DelegateRequestRepresentation.java
@@ -36,7 +36,9 @@ import dagger.internal.codegen.binding.BindingGraph;
 import dagger.internal.codegen.binding.BindsTypeChecker;
 import dagger.internal.codegen.binding.ContributionBinding;
 import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.javapoet.TypeNames;
 import dagger.internal.codegen.model.RequestKind;
+import dagger.internal.codegen.xprocessing.XTypes;
 
 /** A {@link dagger.internal.codegen.writing.RequestRepresentation} for {@code @Binds} methods. */
 final class DelegateRequestRepresentation extends RequestRepresentation {
@@ -88,8 +90,14 @@ final class DelegateRequestRepresentation extends RequestRepresentation {
             ? delegateExpression.castTo(contributedType)
             : delegateExpression;
       default:
-        return castToRawTypeIfNecessary(
-            delegateExpression, requestType(requestKind, contributedType, processingEnv));
+        XType requestedType = requestType(requestKind, contributedType, processingEnv);
+        if (XTypes.isTypeOf(requestedType, TypeNames.PROVIDER)) {
+          // Even though the user may have requested a javax Provider, our generated code and
+          // factories only work in the Dagger Provider type, so swap to that one before doing
+          // a cast.
+          requestedType = XTypes.rewrapType(requestedType, TypeNames.DAGGER_PROVIDER);
+        }
+        return castToRawTypeIfNecessary(delegateExpression, requestedType);
     }
   }
 
diff --git a/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java b/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java
index 71bf1a79a..c54b03cc4 100644
--- a/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java
+++ b/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java
@@ -24,7 +24,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
 import static com.squareup.javapoet.MethodSpec.constructorBuilder;
 import static com.squareup.javapoet.MethodSpec.methodBuilder;
 import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.daggerProviderOf;
 import static dagger.internal.codegen.writing.ComponentImplementation.TypeSpecKind.COMPONENT_PROVISION_FACTORY;
 import static dagger.internal.codegen.xprocessing.XElements.asMethod;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
@@ -121,7 +121,7 @@ final class DependencyMethodProviderCreationExpression
     componentShard.addType(
         COMPONENT_PROVISION_FACTORY,
         classBuilder(factoryClassName)
-            .addSuperinterface(providerOf(keyType))
+            .addSuperinterface(daggerProviderOf(keyType))
             .addModifiers(PRIVATE, STATIC, FINAL)
             .addField(dependencyClassName, dependency().variableName(), PRIVATE, FINAL)
             .addMethod(
diff --git a/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceRequestRepresentation.java b/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceRequestRepresentation.java
index 4095a600d..f054e6a7e 100644
--- a/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceRequestRepresentation.java
+++ b/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceRequestRepresentation.java
@@ -24,11 +24,13 @@ import com.squareup.javapoet.ClassName;
 import dagger.assisted.Assisted;
 import dagger.assisted.AssistedFactory;
 import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.base.MapType;
 import dagger.internal.codegen.binding.BindsTypeChecker;
 import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
 import dagger.internal.codegen.binding.ContributionBinding;
 import dagger.internal.codegen.binding.FrameworkType;
 import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.javapoet.TypeNames;
 import dagger.internal.codegen.model.BindingKind;
 import dagger.internal.codegen.model.RequestKind;
 
@@ -59,30 +61,61 @@ final class DerivedFromFrameworkInstanceRequestRepresentation extends RequestRep
 
   @Override
   Expression getDependencyExpression(ClassName requestingClass) {
-    Expression expression =
-        frameworkType.to(
-            requestKind,
-            frameworkRequestRepresentation.getDependencyExpression(requestingClass),
-            processingEnv);
-    return requiresTypeCast(expression, requestingClass)
-        ? expression.castTo(binding.contributedType())
-        : expression;
+    return getDependencyExpressionFromFrameworkExpression(
+        frameworkRequestRepresentation.getDependencyExpression(requestingClass),
+        requestingClass);
   }
 
   @Override
   Expression getDependencyExpressionForComponentMethod(
       ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+    return getDependencyExpressionFromFrameworkExpression(
+        frameworkRequestRepresentation
+            .getDependencyExpressionForComponentMethod(componentMethod, component),
+        component.name());
+  }
+
+  private Expression getDependencyExpressionFromFrameworkExpression(
+      Expression frameworkExpression, ClassName requestingClass) {
     Expression expression =
         frameworkType.to(
             requestKind,
-            frameworkRequestRepresentation.getDependencyExpressionForComponentMethod(
-                componentMethod, component),
+            frameworkExpression,
             processingEnv);
-    return requiresTypeCast(expression, component.name())
+
+    // If it is a map type we need to do a raw type cast. This is because a user requested field
+    // type like dagger.internal.Provider<Map<K, javax.inject.Provider<V>>> isn't always assignable
+    // from something like dagger.internal.Provider<Map<K, dagger.internal.Provider<V>>> just due
+    // to variance issues.
+    if (MapType.isMapOfProvider(binding.contributedType())) {
+      return castMapOfProvider(expression, binding);
+    }
+
+    return requiresTypeCast(expression, requestingClass)
         ? expression.castTo(binding.contributedType())
         : expression;
   }
 
+  private Expression castMapOfProvider(Expression expression, ContributionBinding binding) {
+    switch (requestKind) {
+      case INSTANCE:
+        return expression.castTo(binding.contributedType());
+      case PROVIDER:
+      case PROVIDER_OF_LAZY:
+        return expression.castTo(processingEnv.requireType(TypeNames.DAGGER_PROVIDER).getRawType());
+      case LAZY:
+        return expression.castTo(processingEnv.requireType(TypeNames.LAZY).getRawType());
+      case PRODUCER:
+      case FUTURE:
+        return expression.castTo(processingEnv.requireType(TypeNames.PRODUCER).getRawType());
+      case PRODUCED:
+        return expression.castTo(processingEnv.requireType(TypeNames.PRODUCED).getRawType());
+
+      case MEMBERS_INJECTION: // fall through
+    }
+    throw new IllegalStateException("Unexpected request kind: " + requestKind);
+  }
+
   private boolean requiresTypeCast(Expression expression, ClassName requestingClass) {
     return binding.kind().equals(BindingKind.DELEGATE)
         && requestKind.equals(RequestKind.INSTANCE)
diff --git a/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java b/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java
index 5a981773e..32f0dde04 100644
--- a/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java
+++ b/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java
@@ -142,8 +142,9 @@ class FrameworkFieldInitializer implements FrameworkInstanceSupplier {
         FrameworkField.forBinding(
             binding, frameworkInstanceCreationExpression.alternativeFrameworkClass());
 
-    TypeName fieldType =
-        useRawType ? contributionBindingField.type().rawType : contributionBindingField.type();
+    TypeName fieldType = useRawType
+        ? TypeNames.rawTypeName(contributionBindingField.type())
+        : contributionBindingField.type();
 
     if (binding.kind() == BindingKind.ASSISTED_INJECTION) {
       // An assisted injection factory doesn't extend Provider, so we reference the generated
diff --git a/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java b/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java
index d32531bef..27e017dba 100644
--- a/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java
+++ b/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java
@@ -18,8 +18,15 @@ package dagger.internal.codegen.writing;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.extension.DaggerCollectors.toOptional;
+import static dagger.internal.codegen.model.BindingKind.ASSISTED_FACTORY;
 import static dagger.internal.codegen.model.BindingKind.INJECTION;
+import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
 
+import androidx.room.compiler.processing.XMethodElement;
+import androidx.room.compiler.processing.XProcessingEnv;
+import androidx.room.compiler.processing.XTypeElement;
+import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
 import dagger.assisted.Assisted;
 import dagger.assisted.AssistedFactory;
@@ -29,6 +36,7 @@ import dagger.internal.codegen.javapoet.CodeBlocks;
 import dagger.internal.codegen.javapoet.TypeNames;
 import dagger.internal.codegen.writing.ComponentImplementation.ShardImplementation;
 import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import java.util.Optional;
 import javax.inject.Provider;
 
 /**
@@ -42,32 +50,64 @@ final class InjectionOrProvisionProviderCreationExpression
   private final ContributionBinding binding;
   private final ShardImplementation shardImplementation;
   private final ComponentRequestRepresentations componentRequestRepresentations;
+  private final XProcessingEnv processingEnv;
 
   @AssistedInject
   InjectionOrProvisionProviderCreationExpression(
       @Assisted ContributionBinding binding,
       ComponentImplementation componentImplementation,
-      ComponentRequestRepresentations componentRequestRepresentations) {
+      ComponentRequestRepresentations componentRequestRepresentations,
+      XProcessingEnv processingEnv) {
     this.binding = checkNotNull(binding);
     this.shardImplementation = componentImplementation.shardImplementation(binding);
     this.componentRequestRepresentations = componentRequestRepresentations;
+    this.processingEnv = processingEnv;
   }
 
   @Override
   public CodeBlock creationExpression() {
+    ClassName factoryImpl = generatedClassNameForBinding(binding);
     CodeBlock createFactory =
         CodeBlock.of(
-            "$T.create($L)",
-            generatedClassNameForBinding(binding),
+            "$T.$L($L)",
+            factoryImpl,
+            // A different name is used for assisted factories due to backwards compatibility
+            // issues when migrating from the javax Provider.
+            binding.kind().equals(ASSISTED_FACTORY) ? "createFactoryProvider" : "create",
             componentRequestRepresentations.getCreateMethodArgumentsCodeBlock(
                 binding, shardImplementation.name()));
 
+    // If this is for an AssistedFactory, then we may need to change the call in case we're building
+    // against a library built at an older version of Dagger before the changes to make factories
+    // return a Dagger Provider instead of a javax.inject.Provider.
+    if (binding.kind().equals(ASSISTED_FACTORY)) {
+      XTypeElement factoryType = processingEnv.findTypeElement(factoryImpl);
+      // If we can't find the factory, then assume it is being generated this run, which means
+      // it should be the newer version and not need wrapping. If it is missing for some other
+      // reason, then that likely means there will just be some other compilation failure.
+      if (factoryType != null) {
+        Optional<XMethodElement> createMethod = factoryType.getDeclaredMethods().stream()
+            .filter(method -> method.isStatic()
+                && getSimpleName(method).equals("createFactoryProvider"))
+            .collect(toOptional());
+        // Only convert it if the newer method doesn't exist.
+        if (createMethod.isEmpty()) {
+          createFactory = CodeBlock.of(
+            "$T.asDaggerProvider($T.create($L))",
+            TypeNames.DAGGER_PROVIDERS,
+            factoryImpl,
+            componentRequestRepresentations.getCreateMethodArgumentsCodeBlock(
+                binding, shardImplementation.name()));
+        }
+      }
+    }
+
     // When scoping a parameterized factory for an @Inject class, Java 7 cannot always infer the
     // type properly, so cast to a raw framework type before scoping.
     if (binding.kind().equals(INJECTION)
         && binding.unresolved().isPresent()
         && binding.scope().isPresent()) {
-      return CodeBlocks.cast(createFactory, TypeNames.PROVIDER);
+      return CodeBlocks.cast(createFactory, TypeNames.DAGGER_PROVIDER);
     } else {
       return createFactory;
     }
diff --git a/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java b/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java
index ea2233c44..36a991591 100644
--- a/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java
+++ b/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java
@@ -147,7 +147,9 @@ public final class MembersInjectorGenerator extends SourceFileGenerator<MembersI
               dependency.key().type().xprocessing(), generatedTypeName.packageName());
 
       String fieldName = fieldNames.getUniqueName(bindingField.name());
-      TypeName fieldType = useRawFrameworkType ? bindingField.type().rawType : bindingField.type();
+      TypeName fieldType = useRawFrameworkType
+          ? TypeNames.rawTypeName(bindingField.type())
+          : bindingField.type();
       FieldSpec.Builder fieldBuilder = FieldSpec.builder(fieldType, fieldName, PRIVATE, FINAL);
       ParameterSpec.Builder parameterBuilder = ParameterSpec.builder(fieldType, fieldName);
 
diff --git a/java/dagger/internal/codegen/writing/OptionalFactories.java b/java/dagger/internal/codegen/writing/OptionalFactories.java
index 446f231e0..3c327e8bc 100644
--- a/java/dagger/internal/codegen/writing/OptionalFactories.java
+++ b/java/dagger/internal/codegen/writing/OptionalFactories.java
@@ -28,8 +28,8 @@ import static dagger.internal.codegen.base.RequestKinds.requestTypeName;
 import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
 import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
 import static dagger.internal.codegen.javapoet.TypeNames.abstractProducerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.daggerProviderOf;
 import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
 import static dagger.internal.codegen.writing.ComponentImplementation.FieldSpecKind.ABSENT_OPTIONAL_FIELD;
 import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.ABSENT_OPTIONAL_METHOD;
 import static dagger.internal.codegen.writing.ComponentImplementation.TypeSpecKind.PRESENT_FACTORY;
@@ -147,15 +147,15 @@ final class OptionalFactories {
                 "absent%sProvider", UPPER_UNDERSCORE.to(UPPER_CAMEL, optionalKind.name())))
         .addModifiers(PRIVATE, STATIC)
         .addTypeVariable(typeVariable)
-        .returns(providerOf(optionalKind.of(typeVariable)))
+        .returns(daggerProviderOf(optionalKind.of(typeVariable)))
         .addJavadoc(
             "Returns a {@link $T} that returns {@code $L}.",
-            TypeNames.PROVIDER,
+            TypeNames.DAGGER_PROVIDER,
             optionalKind.absentValueExpression())
         .addCode("$L // safe covariant cast\n", AnnotationSpecs.suppressWarnings(UNCHECKED))
         .addStatement(
             "$1T provider = ($1T) $2N",
-            providerOf(optionalKind.of(typeVariable)),
+            daggerProviderOf(optionalKind.of(typeVariable)),
             perGeneratedFileCache.absentOptionalProviderFields.computeIfAbsent(
                 optionalKind,
                 kind -> {
@@ -173,7 +173,7 @@ final class OptionalFactories {
    */
   private FieldSpec absentOptionalProviderField(OptionalKind optionalKind) {
     return FieldSpec.builder(
-            TypeNames.PROVIDER,
+            TypeNames.DAGGER_PROVIDER,
             String.format("ABSENT_%s_PROVIDER", optionalKind.name()),
             PRIVATE,
             STATIC,
@@ -182,7 +182,7 @@ final class OptionalFactories {
         .initializer("$T.create($L)", InstanceFactory.class, optionalKind.absentValueExpression())
         .addJavadoc(
             "A {@link $T} that returns {@code $L}.",
-            TypeNames.PROVIDER,
+            TypeNames.DAGGER_PROVIDER,
             optionalKind.absentValueExpression())
         .build();
   }
diff --git a/java/dagger/internal/codegen/writing/OptionalRequestRepresentation.java b/java/dagger/internal/codegen/writing/OptionalRequestRepresentation.java
index ab6bb41fc..8c9219197 100644
--- a/java/dagger/internal/codegen/writing/OptionalRequestRepresentation.java
+++ b/java/dagger/internal/codegen/writing/OptionalRequestRepresentation.java
@@ -33,6 +33,7 @@ import dagger.internal.codegen.base.OptionalType.OptionalKind;
 import dagger.internal.codegen.binding.ProvisionBinding;
 import dagger.internal.codegen.javapoet.Expression;
 import dagger.internal.codegen.model.DependencyRequest;
+import dagger.internal.codegen.model.RequestKind;
 
 /** A binding expression for optional bindings. */
 final class OptionalRequestRepresentation extends RequestRepresentation {
@@ -79,8 +80,11 @@ final class OptionalRequestRepresentation extends RequestRepresentation {
             .getDependencyExpression(bindingRequest(dependency), requestingClass)
             .codeBlock();
 
-    return isTypeAccessibleFrom(
-            dependency.key().type().xprocessing(), requestingClass.packageName())
+    boolean needsObjectExpression = !isTypeAccessibleFrom(
+        dependency.key().type().xprocessing(), requestingClass.packageName())
+        || (isPreJava8SourceVersion(processingEnv) && dependency.kind() == RequestKind.PROVIDER);
+
+    return !needsObjectExpression
         ? Expression.create(
             binding.key().type().xprocessing(),
             optionalKind.presentExpression(dependencyExpression))
diff --git a/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java b/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java
index b68c1be51..1d8ab02f7 100644
--- a/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java
+++ b/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java
@@ -160,7 +160,7 @@ public final class ProducerFactoryGenerator extends SourceFileGenerator<Producti
             addFieldAndConstructorParameter(
                 factoryBuilder, constructorBuilder, fieldName, bindingField.type());
         fieldsBuilder.put(dependency, field);
-        frameworkFieldAssignments.add(fieldAssignment(field, bindingField.type()));
+        frameworkFieldAssignments.add(fieldAssignment(field, bindingField));
       }
     }
     ImmutableMap<DependencyRequest, FieldSpec> fields = fieldsBuilder.build();
@@ -257,9 +257,10 @@ public final class ProducerFactoryGenerator extends SourceFileGenerator<Producti
     return field;
   }
 
-  private static CodeBlock fieldAssignment(FieldSpec field, ParameterizedTypeName type) {
+  private static CodeBlock fieldAssignment(FieldSpec field, FrameworkField frameworkField) {
     CodeBlock.Builder statement = CodeBlock.builder();
-    if (type != null && type.rawType.equals(TypeNames.PRODUCER)) {
+    if (frameworkField.type() != null
+        && TypeNames.rawTypeName(frameworkField.type()).equals(TypeNames.PRODUCER)) {
       statement.addStatement(
           "this.$1N = $2T.nonCancellationPropagatingViewOf($1N)", field, TypeNames.PRODUCERS);
     } else {
diff --git a/java/dagger/internal/codegen/writing/StaticMemberSelects.java b/java/dagger/internal/codegen/writing/StaticMemberSelects.java
index 3fea6173f..a1ea63c03 100644
--- a/java/dagger/internal/codegen/writing/StaticMemberSelects.java
+++ b/java/dagger/internal/codegen/writing/StaticMemberSelects.java
@@ -22,11 +22,11 @@ import static dagger.internal.codegen.binding.SourceFiles.bindingTypeElementType
 import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
 import static dagger.internal.codegen.binding.SourceFiles.setFactoryClassName;
 import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.DAGGER_PROVIDER;
 import static dagger.internal.codegen.javapoet.TypeNames.FACTORY;
 import static dagger.internal.codegen.javapoet.TypeNames.MAP_FACTORY;
 import static dagger.internal.codegen.javapoet.TypeNames.PRODUCER;
 import static dagger.internal.codegen.javapoet.TypeNames.PRODUCERS;
-import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER;
 import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
 import static dagger.internal.codegen.xprocessing.XTypes.isDeclared;
 
@@ -52,7 +52,7 @@ final class StaticMemberSelects {
         ? new ParameterizedStaticMethod(
             PRODUCERS, typeParameters, CodeBlock.of("emptyMapProducer()"), PRODUCER)
         : new ParameterizedStaticMethod(
-            MAP_FACTORY, typeParameters, CodeBlock.of("emptyMapProvider()"), PROVIDER);
+            MAP_FACTORY, typeParameters, CodeBlock.of("emptyMapProvider()"), DAGGER_PROVIDER);
   }
 
   /**
diff --git a/java/dagger/internal/codegen/writing/SwitchingProviders.java b/java/dagger/internal/codegen/writing/SwitchingProviders.java
index e6c3bbf52..736f51529 100644
--- a/java/dagger/internal/codegen/writing/SwitchingProviders.java
+++ b/java/dagger/internal/codegen/writing/SwitchingProviders.java
@@ -24,7 +24,7 @@ import static com.squareup.javapoet.TypeSpec.classBuilder;
 import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
 import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
 import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.daggerProviderOf;
 import static javax.lang.model.element.Modifier.FINAL;
 import static javax.lang.model.element.Modifier.PRIVATE;
 import static javax.lang.model.element.Modifier.PUBLIC;
@@ -172,7 +172,7 @@ final class SwitchingProviders {
           classBuilder(switchingProviderType)
               .addModifiers(PRIVATE, FINAL, STATIC)
               .addTypeVariable(T)
-              .addSuperinterface(providerOf(T))
+              .addSuperinterface(daggerProviderOf(T))
               .addMethods(getMethods());
 
       // The SwitchingProvider constructor lists all component parameters first and switch id last.
diff --git a/java/dagger/producers/internal/AbstractMapProducer.java b/java/dagger/producers/internal/AbstractMapProducer.java
index c60f0cb07..360f1eb8e 100644
--- a/java/dagger/producers/internal/AbstractMapProducer.java
+++ b/java/dagger/producers/internal/AbstractMapProducer.java
@@ -17,12 +17,13 @@
 package dagger.producers.internal;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.Providers.asDaggerProvider;
 import static dagger.producers.internal.Producers.producerFromProvider;
 
 import com.google.common.collect.ImmutableMap;
+import dagger.internal.Provider;
 import dagger.producers.Producer;
 import java.util.Map;
-import javax.inject.Provider;
 
 /**
  * An {@code abstract} {@link Producer} implementation used to implement {@link Map} bindings.
@@ -76,6 +77,15 @@ abstract class AbstractMapProducer<K, V, V2> extends AbstractProducer<Map<K, V2>
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    Builder<K, V, V2> put(K key, javax.inject.Provider<V> providerOfValue) {
+      return put(key, asDaggerProvider(providerOfValue));
+    }
+
     /** Adds contributions from a super-implementation of a component into this builder. */
     Builder<K, V, V2> putAll(Producer<Map<K, V2>> mapOfProducers) {
       if (mapOfProducers instanceof DelegateProducer) {
diff --git a/java/dagger/producers/internal/AbstractProducesMethodProducer.java b/java/dagger/producers/internal/AbstractProducesMethodProducer.java
index 0cf36ca53..95b8f8340 100644
--- a/java/dagger/producers/internal/AbstractProducesMethodProducer.java
+++ b/java/dagger/producers/internal/AbstractProducesMethodProducer.java
@@ -17,15 +17,16 @@
 package dagger.producers.internal;
 
 import static dagger.internal.Preconditions.checkNotNull;
+import static dagger.internal.Providers.asDaggerProvider;
 
 import com.google.common.util.concurrent.AsyncFunction;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import dagger.internal.Provider;
 import dagger.producers.monitoring.ProducerMonitor;
 import dagger.producers.monitoring.ProducerToken;
 import dagger.producers.monitoring.ProductionComponentMonitor;
 import java.util.concurrent.Executor;
-import javax.inject.Provider;
 import org.checkerframework.checker.nullness.compatqual.NullableDecl;
 
 /**
@@ -54,6 +55,18 @@ public abstract class AbstractProducesMethodProducer<D, T> extends AbstractProdu
     this.executorProvider = checkNotNull(executorProvider);
   }
 
+  /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  protected AbstractProducesMethodProducer(
+      javax.inject.Provider<ProductionComponentMonitor> monitorProvider,
+      @NullableDecl ProducerToken token,
+      javax.inject.Provider<Executor> executorProvider) {
+    this(asDaggerProvider(monitorProvider), token, asDaggerProvider(executorProvider));
+  }
+
   @Override
   protected final ListenableFuture<T> compute() {
     monitor = monitorProvider.get().producerMonitorFor(token);
diff --git a/java/dagger/producers/internal/DelegateProducer.java b/java/dagger/producers/internal/DelegateProducer.java
index 6cc7547c3..de29234ac 100644
--- a/java/dagger/producers/internal/DelegateProducer.java
+++ b/java/dagger/producers/internal/DelegateProducer.java
@@ -20,8 +20,8 @@ import static dagger.internal.Preconditions.checkNotNull;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.producers.Producer;
-import javax.inject.Provider;
 
 /**
  * A DelegateProducer that is used to stitch Producer indirection during initialization across
diff --git a/java/dagger/producers/internal/MapOfProducedProducer.java b/java/dagger/producers/internal/MapOfProducedProducer.java
index bd9f1bfcc..3db774094 100644
--- a/java/dagger/producers/internal/MapOfProducedProducer.java
+++ b/java/dagger/producers/internal/MapOfProducedProducer.java
@@ -18,6 +18,7 @@ package dagger.producers.internal;
 
 import static com.google.common.util.concurrent.Futures.transform;
 import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static dagger.internal.Providers.asDaggerProvider;
 
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableMap;
@@ -25,11 +26,11 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Produced;
 import dagger.producers.Producer;
 import java.util.List;
 import java.util.Map;
-import javax.inject.Provider;
 
 /**
  * A {@link Producer} implementation used to implement {@link Map} bindings. This producer returns a
@@ -108,6 +109,15 @@ public final class MapOfProducedProducer<K, V> extends AbstractMapProducer<K, V,
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> put(K key, javax.inject.Provider<V> providerOfValue) {
+      return put(key, asDaggerProvider(providerOfValue));
+    }
+
     @Override
     public Builder<K, V> putAll(Producer<Map<K, Produced<V>>> mapOfProducedProducer) {
       super.putAll(mapOfProducedProducer);
diff --git a/java/dagger/producers/internal/MapOfProducerProducer.java b/java/dagger/producers/internal/MapOfProducerProducer.java
index 064cf7499..145ea6db6 100644
--- a/java/dagger/producers/internal/MapOfProducerProducer.java
+++ b/java/dagger/producers/internal/MapOfProducerProducer.java
@@ -16,6 +16,7 @@
 
 package dagger.producers.internal;
 
+import static dagger.internal.Providers.asDaggerProvider;
 import static dagger.producers.internal.Producers.entryPointViewOf;
 import static dagger.producers.internal.Producers.nonCancellationPropagatingViewOf;
 
@@ -24,9 +25,9 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Producer;
 import java.util.Map;
-import javax.inject.Provider;
 
 /**
  * A {@link Producer} implementation used to implement {@link Map} bindings. This factory returns an
@@ -65,6 +66,15 @@ public final class MapOfProducerProducer<K, V> extends AbstractMapProducer<K, V,
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> put(K key, javax.inject.Provider<V> providerOfValue) {
+      return put(key, asDaggerProvider(providerOfValue));
+    }
+
     @Override
     public Builder<K, V> putAll(Producer<Map<K, Producer<V>>> mapOfProducerProducer) {
       super.putAll(mapOfProducerProducer);
diff --git a/java/dagger/producers/internal/MapProducer.java b/java/dagger/producers/internal/MapProducer.java
index 8caeb45cb..c832ef402 100644
--- a/java/dagger/producers/internal/MapProducer.java
+++ b/java/dagger/producers/internal/MapProducer.java
@@ -17,18 +17,19 @@
 package dagger.producers.internal;
 
 import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static dagger.internal.Providers.asDaggerProvider;
 
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Producer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-import javax.inject.Provider;
 
 /**
  * A {@link Producer} implementation used to implement {@link Map} bindings. This producer returns a
@@ -62,6 +63,15 @@ public final class MapProducer<K, V> extends AbstractMapProducer<K, V, V> {
       return this;
     }
 
+    /**
+     * Legacy javax version of the method to support libraries compiled with an older version of
+     * Dagger. Do not use directly.
+     */
+    @Deprecated
+    public Builder<K, V> put(K key, javax.inject.Provider<V> providerOfValue) {
+      return put(key, asDaggerProvider(providerOfValue));
+    }
+
     @Override
     public Builder<K, V> putAll(Producer<Map<K, V>> mapProducer) {
       super.putAll(mapProducer);
diff --git a/java/dagger/producers/internal/Producers.java b/java/dagger/producers/internal/Producers.java
index 54e4d5ee3..9385ee326 100644
--- a/java/dagger/producers/internal/Producers.java
+++ b/java/dagger/producers/internal/Producers.java
@@ -20,6 +20,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.util.concurrent.Futures.catchingAsync;
 import static com.google.common.util.concurrent.Futures.transform;
 import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static dagger.internal.Providers.asDaggerProvider;
 
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableMap;
@@ -27,12 +28,12 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.AsyncFunction;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Produced;
 import dagger.producers.Producer;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import javax.inject.Provider;
 
 /**
  * Utility methods for use in generated producer code.
@@ -135,6 +136,15 @@ public final class Producers {
   }
 
   /**
+   * Legacy javax version of the method to support libraries compiled with an older version of
+   * Dagger. Do not use directly.
+   */
+  @Deprecated
+  public static <T> Producer<T> producerFromProvider(final javax.inject.Provider<T> provider) {
+    return producerFromProvider(asDaggerProvider(provider));
+  }
+
+  /**
    * Returns a producer that succeeds with the given value.
    *
    * @deprecated Prefer the non-internal version of this method: {@link
diff --git a/javatests/dagger/functional/kotlinsrc/membersinject/MembersInjectTest.kt b/javatests/dagger/functional/kotlinsrc/membersinject/MembersInjectTest.kt
index 2fc44258f..e7a751f27 100644
--- a/javatests/dagger/functional/kotlinsrc/membersinject/MembersInjectTest.kt
+++ b/javatests/dagger/functional/kotlinsrc/membersinject/MembersInjectTest.kt
@@ -23,8 +23,8 @@ import dagger.MembersInjector
 import dagger.functional.kotlinsrc.membersinject.subpackage.a.AGrandchild
 import dagger.functional.kotlinsrc.membersinject.subpackage.a.AParent
 import dagger.functional.kotlinsrc.membersinject.subpackage.b.BChild
+import dagger.internal.Provider
 import javax.inject.Inject
-import javax.inject.Provider
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
@@ -85,7 +85,9 @@ class MembersInjectTest {
   }
 
   class A : B() // No injected members
+
   open class B : C() // No injected members
+
   open class C {
     @Inject lateinit var value: String
   }
diff --git a/javatests/dagger/functional/membersinject/MembersInjectTest.java b/javatests/dagger/functional/membersinject/MembersInjectTest.java
index 06e17f9e6..c6a13dd0d 100644
--- a/javatests/dagger/functional/membersinject/MembersInjectTest.java
+++ b/javatests/dagger/functional/membersinject/MembersInjectTest.java
@@ -24,8 +24,8 @@ import dagger.MembersInjector;
 import dagger.functional.membersinject.subpackage.a.AGrandchild;
 import dagger.functional.membersinject.subpackage.a.AParent;
 import dagger.functional.membersinject.subpackage.b.BChild;
+import dagger.internal.Provider;
 import javax.inject.Inject;
-import javax.inject.Provider;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
diff --git a/javatests/dagger/functional/producers/ProducerFactoryTest.java b/javatests/dagger/functional/producers/ProducerFactoryTest.java
index 6df526e25..f821ab9c1 100644
--- a/javatests/dagger/functional/producers/ProducerFactoryTest.java
+++ b/javatests/dagger/functional/producers/ProducerFactoryTest.java
@@ -25,6 +25,7 @@ import static org.mockito.Mockito.when;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Producer;
 import dagger.producers.internal.AbstractProducer;
 import dagger.producers.internal.CancellableProducer;
@@ -33,7 +34,6 @@ import dagger.producers.monitoring.ProducerToken;
 import dagger.producers.monitoring.ProductionComponentMonitor;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
-import javax.inject.Provider;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -55,7 +55,6 @@ public class ProducerFactoryTest {
     MockitoAnnotations.initMocks(this);
     monitor = Mockito.mock(ProducerMonitor.class, Mockito.CALLS_REAL_METHODS);
     when(componentMonitor.producerMonitorFor(any(ProducerToken.class))).thenReturn(monitor);
-    // TODO(beder): Use Providers.of when available.
     executorProvider =
         new Provider<Executor>() {
           @Override
diff --git a/javatests/dagger/internal/DoubleCheckTest.java b/javatests/dagger/internal/DoubleCheckTest.java
index e36c1bcee..6bf220d36 100644
--- a/javatests/dagger/internal/DoubleCheckTest.java
+++ b/javatests/dagger/internal/DoubleCheckTest.java
@@ -32,7 +32,6 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
-import javax.inject.Provider;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
diff --git a/javatests/dagger/internal/MapProviderFactoryTest.java b/javatests/dagger/internal/MapProviderFactoryTest.java
index c55bee3ab..e64df8dad 100644
--- a/javatests/dagger/internal/MapProviderFactoryTest.java
+++ b/javatests/dagger/internal/MapProviderFactoryTest.java
@@ -21,7 +21,6 @@ import static com.google.common.truth.Truth.assertThat;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
-import javax.inject.Provider;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
diff --git a/javatests/dagger/internal/SetFactoryTest.java b/javatests/dagger/internal/SetFactoryTest.java
index 0032578c6..5e109ddb6 100644
--- a/javatests/dagger/internal/SetFactoryTest.java
+++ b/javatests/dagger/internal/SetFactoryTest.java
@@ -23,7 +23,6 @@ import java.util.Arrays;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
-import javax.inject.Provider;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
diff --git a/javatests/dagger/internal/codegen/FrameworkFieldTest.java b/javatests/dagger/internal/codegen/FrameworkFieldTest.java
index be495d79b..ba5b88f8c 100644
--- a/javatests/dagger/internal/codegen/FrameworkFieldTest.java
+++ b/javatests/dagger/internal/codegen/FrameworkFieldTest.java
@@ -24,6 +24,7 @@ import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
 
 import com.google.testing.compile.CompilationRule;
 import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.ParameterizedTypeName;
 import dagger.internal.codegen.binding.FrameworkField;
 import javax.inject.Inject;
 import org.junit.Before;
@@ -47,16 +48,20 @@ public class FrameworkFieldTest {
   }
 
   @Test public void frameworkType() {
-    assertThat(FrameworkField.create(PROVIDER, xTypeName, "test").type())
+    assertThat(FrameworkField.create(ParameterizedTypeName.get(PROVIDER, xTypeName), "test").type())
         .isEqualTo(providerOf(xTypeName));
-    assertThat(FrameworkField.create(MEMBERS_INJECTOR, xTypeName, "test").type())
+    assertThat(
+            FrameworkField.create(ParameterizedTypeName.get(MEMBERS_INJECTOR, xTypeName), "test")
+                .type())
         .isEqualTo(membersInjectorOf(xTypeName));
   }
 
   @Test public void nameSuffix() {
-    assertThat(FrameworkField.create(PROVIDER, xTypeName, "foo").name())
+    assertThat(FrameworkField.create(ParameterizedTypeName.get(PROVIDER, xTypeName), "foo").name())
         .isEqualTo("fooProvider");
-    assertThat(FrameworkField.create(PROVIDER, xTypeName, "fooProvider").name())
+    assertThat(
+            FrameworkField.create(ParameterizedTypeName.get(PROVIDER, xTypeName), "fooProvider")
+                .name())
         .isEqualTo("fooProvider");
   }
 
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent
index 20f38ddd0..1dc3731de 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -52,7 +52,7 @@ final class DaggerTestComponent {
     @SuppressWarnings("unchecked")
     private void initialize() {
       this.fooProvider = Foo_Factory.create(Bar_Factory.create());
-      this.fooFactoryProvider = FooFactory_Impl.create(fooProvider);
+      this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider);
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent
index c76a5fbdd..2b7fd7dd9 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,9 +1,9 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent
index 7b22b0018..5e232098e 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -57,7 +57,7 @@ final class DaggerTestComponent {
       this.fooFactoryProvider = new DelegateFactory<>();
       this.barProvider = Bar_Factory.create(fooFactoryProvider);
       this.fooProvider = Foo_Factory.create(barProvider);
-      DelegateFactory.setDelegate(fooFactoryProvider, FooFactory_Impl.create(fooProvider));
+      DelegateFactory.setDelegate(fooFactoryProvider, FooFactory_Impl.createFactoryProvider(fooProvider));
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent
index 48f517401..9d274ee88 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent
index 20f38ddd0..1dc3731de 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -52,7 +52,7 @@ final class DaggerTestComponent {
     @SuppressWarnings("unchecked")
     private void initialize() {
       this.fooProvider = Foo_Factory.create(Bar_Factory.create());
-      this.fooFactoryProvider = FooFactory_Impl.create(fooProvider);
+      this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider);
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent
index 72f16729c..dad9b81cc 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,9 +1,9 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent
index 4e5de7ad7..8c3febe03 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -55,7 +55,7 @@ final class DaggerMyComponent {
     @SuppressWarnings("unchecked")
     private void initialize() {
       this.myAssistedClassProvider = MyAssistedClass_Factory.create(Baz_Factory.create());
-      this.mySubcomponentAssistedFactoryProvider = MySubcomponentAssistedFactory_Impl.create(myAssistedClassProvider);
+      this.mySubcomponentAssistedFactoryProvider = MySubcomponentAssistedFactory_Impl.createFactoryProvider(myAssistedClassProvider);
     }
 
     @Override
@@ -80,7 +80,7 @@ final class DaggerMyComponent {
     @SuppressWarnings("unchecked")
     private void initialize() {
       this.myAssistedClassProvider = MyAssistedClass_Factory.create(Baz_Factory.create());
-      this.myComponentAssistedFactoryProvider = MyComponentAssistedFactory_Impl.create(myAssistedClassProvider);
+      this.myComponentAssistedFactoryProvider = MyComponentAssistedFactory_Impl.createFactoryProvider(myAssistedClassProvider);
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent
index 315ebc43c..c3ff04960 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent
@@ -1,9 +1,9 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent
index da1f53e75..49ca94f50 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -52,7 +52,7 @@ final class DaggerTestComponent {
     @SuppressWarnings("unchecked")
     private void initialize() {
       this.fooProvider = Foo_Factory.create();
-      this.fooFactoryProvider = FooFactory_Impl.create(fooProvider);
+      this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider);
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent
index a56b3e084..1c1014d01 100644
--- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,9 +1,9 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent
index a3127fbf0..907c44dc0 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent
index bb09e8b6e..a6dcfd18b 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent
index eb9476a7b..9d190e568 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent
index 7a97ba515..a287b3a0e 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent
index e32f689d6..93991fa36 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.InstanceFactory;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -59,7 +59,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SimpleComponent> selfProvider() {
+    public javax.inject.Provider<SimpleComponent> selfProvider() {
       return simpleComponentProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent
index 4f9289e45..8e3e2692f 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.InstanceFactory;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -59,7 +59,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SimpleComponent> selfProvider() {
+    public javax.inject.Provider<SimpleComponent> selfProvider() {
       return simpleComponentProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent
index 1d5bc09cb..0f527b83b 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent
index af0cdb92e..b64571460 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent
index 76f413869..227861301 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -65,7 +65,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SomeInjectableType> someInjectableTypeProvider() {
+    public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() {
       return someInjectableTypeProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent
index 20d695da5..c639d30f5 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -65,7 +65,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SomeInjectableType> someInjectableTypeProvider() {
+    public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() {
       return someInjectableTypeProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent
index b8284979d..5c703f1e1 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import pkg1.A;
 import pkg1.AComponent;
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent
index 99a7e4271..0cb77ec60 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import pkg1.A;
 import pkg1.AComponent;
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent
index 755b402f9..6e03f68ec 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent
index 6ce1e2451..b4d65253a 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent
index f26d8a5bb..43e67a221 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent
index 5edc873ff..a63363616 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent
index 19c4c90bf..3f46d70e6 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent
index 0af158555..f7fb49313 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent
index d92a70e85..76ff2823e 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -65,7 +65,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SomeInjectableType> someInjectableTypeProvider() {
+    public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() {
       return someInjectableTypeProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent
index 98c9ea783..a67f5e29b 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import test.sub.TestComponentBase_Dep_Factory;
 import test.sub.TestComponentBase_ProtectedType_Factory;
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent
index 441b713d4..7efcca34d 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import test.sub.TestComponentBase_Dep_Factory;
 import test.sub.TestComponentBase_ProtectedType_Factory;
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent
index 78ff25e66..5745e81c9 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,10 +2,10 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import dagger.internal.SetFactory;
 import java.util.Set;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -72,7 +72,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> dependsOnMultibinding() {
+    public javax.inject.Provider<Object> dependsOnMultibinding() {
       return reliesOnMultibindingProvider;
     }
   }
@@ -99,7 +99,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> dependsOnMultibinding() {
+    public javax.inject.Provider<Object> dependsOnMultibinding() {
       return reliesOnMultibindingProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent
index 5eb16adf8..11e09d156 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableSet;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Set;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -73,7 +73,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> dependsOnMultibinding() {
+    public javax.inject.Provider<Object> dependsOnMultibinding() {
       return reliesOnMultibindingProvider;
     }
 
@@ -127,7 +127,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> dependsOnMultibinding() {
+    public javax.inject.Provider<Object> dependsOnMultibinding() {
       return reliesOnMultibindingProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
index d5a2af096..3aa359ea8 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
@@ -3,8 +3,8 @@ package dagger.internal.codegen;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -81,17 +81,17 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding1> providerBinding1() {
+    public javax.inject.Provider<Binding1> providerBinding1() {
       return binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> providerBinding2() {
+    public javax.inject.Provider<Binding2> providerBinding2() {
       return binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> providerBinding3() {
+    public javax.inject.Provider<Binding3> providerBinding3() {
       return testComponentImpl.testComponentImplShard.binding3Provider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
index e09bb44be..42805ad73 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
@@ -3,8 +3,8 @@ package dagger.internal.codegen;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -81,17 +81,17 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding1> providerBinding1() {
+    public javax.inject.Provider<Binding1> providerBinding1() {
       return binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> providerBinding2() {
+    public javax.inject.Provider<Binding2> providerBinding2() {
       return binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> providerBinding3() {
+    public javax.inject.Provider<Binding3> providerBinding3() {
       return testComponentImpl.testComponentImplShard.binding3Provider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
index de033d5dc..d72266523 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
@@ -3,8 +3,8 @@ package dagger.internal.codegen;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -98,37 +98,37 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding1> providerBinding1() {
+    public javax.inject.Provider<Binding1> providerBinding1() {
       return testComponentImpl.testComponentImplShard2.binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> providerBinding2() {
+    public javax.inject.Provider<Binding2> providerBinding2() {
       return testComponentImpl.testComponentImplShard.binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> providerBinding3() {
+    public javax.inject.Provider<Binding3> providerBinding3() {
       return testComponentImpl.testComponentImplShard.binding3Provider;
     }
 
     @Override
-    public Provider<Binding4> providerBinding4() {
+    public javax.inject.Provider<Binding4> providerBinding4() {
       return testComponentImpl.testComponentImplShard.binding4Provider;
     }
 
     @Override
-    public Provider<Binding5> providerBinding5() {
+    public javax.inject.Provider<Binding5> providerBinding5() {
       return testComponentImpl.testComponentImplShard.binding5Provider;
     }
 
     @Override
-    public Provider<Binding6> providerBinding6() {
+    public javax.inject.Provider<Binding6> providerBinding6() {
       return binding6Provider;
     }
 
     @Override
-    public Provider<Binding7> providerBinding7() {
+    public javax.inject.Provider<Binding7> providerBinding7() {
       return binding7Provider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
index 81056e24f..588a26111 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
@@ -3,8 +3,8 @@ package dagger.internal.codegen;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -98,37 +98,37 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding1> providerBinding1() {
+    public javax.inject.Provider<Binding1> providerBinding1() {
       return testComponentImpl.testComponentImplShard2.binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> providerBinding2() {
+    public javax.inject.Provider<Binding2> providerBinding2() {
       return testComponentImpl.testComponentImplShard.binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> providerBinding3() {
+    public javax.inject.Provider<Binding3> providerBinding3() {
       return testComponentImpl.testComponentImplShard.binding3Provider;
     }
 
     @Override
-    public Provider<Binding4> providerBinding4() {
+    public javax.inject.Provider<Binding4> providerBinding4() {
       return testComponentImpl.testComponentImplShard.binding4Provider;
     }
 
     @Override
-    public Provider<Binding5> providerBinding5() {
+    public javax.inject.Provider<Binding5> providerBinding5() {
       return testComponentImpl.testComponentImplShard.binding5Provider;
     }
 
     @Override
-    public Provider<Binding6> providerBinding6() {
+    public javax.inject.Provider<Binding6> providerBinding6() {
       return binding6Provider;
     }
 
     @Override
-    public Provider<Binding7> providerBinding7() {
+    public javax.inject.Provider<Binding7> providerBinding7() {
       return binding7Provider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
index 86b5db46d..35ede527c 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent
@@ -2,8 +2,8 @@ package dagger.internal.codegen;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -77,17 +77,17 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding1> providerBinding1() {
+    public javax.inject.Provider<Binding1> providerBinding1() {
       return binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> providerBinding2() {
+    public javax.inject.Provider<Binding2> providerBinding2() {
       return binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> providerBinding3() {
+    public javax.inject.Provider<Binding3> providerBinding3() {
       return testSubcomponentImpl.testSubcomponentImplShard.binding3Provider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
index 5a675bae8..1049977a6 100644
--- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent
@@ -2,8 +2,8 @@ package dagger.internal.codegen;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -77,17 +77,17 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding1> providerBinding1() {
+    public javax.inject.Provider<Binding1> providerBinding1() {
       return binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> providerBinding2() {
+    public javax.inject.Provider<Binding2> providerBinding2() {
       return binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> providerBinding3() {
+    public javax.inject.Provider<Binding3> providerBinding3() {
       return testSubcomponentImpl.testSubcomponentImplShard.binding3Provider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent
index d92a70e85..76ff2823e 100644
--- a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -65,7 +65,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SomeInjectableType> someInjectableTypeProvider() {
+    public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() {
       return someInjectableTypeProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent
index d92a70e85..76ff2823e 100644
--- a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -65,7 +65,7 @@ final class DaggerSimpleComponent {
     }
 
     @Override
-    public Provider<SomeInjectableType> someInjectableTypeProvider() {
+    public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() {
       return someInjectableTypeProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent
index 87f55ab41..5cac6ce4d 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.Subtype_Factory;
 import other.Supertype;
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent
index 06e4298ff..ee87e0351 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.Subtype_Factory;
 import other.Supertype;
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent
index 6bdd833da..dda65b874 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent
@@ -46,7 +46,7 @@ final class DaggerTestComponent {
 
     @Override
     public Provider<CharSequence> charSequence() {
-      return ((Provider) TestModule_ProvideStringFactory.create());
+      return ((dagger.internal.Provider) TestModule_ProvideStringFactory.create());
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent
index f186b844c..b5494f344 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -53,7 +53,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<CharSequence> charSequence() {
+    public javax.inject.Provider<CharSequence> charSequence() {
       return ((Provider) provideStringProvider);
     }
 
@@ -63,7 +63,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<String> namedString() {
+    public javax.inject.Provider<String> namedString() {
       return provideStringProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent
index 578eaf46f..e98925e23 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent
@@ -46,12 +46,12 @@ final class DaggerTestComponent {
 
     @Override
     public Provider<CharSequence> charSequence() {
-      return ((Provider) TestModule_ProvideStringFactory.create());
+      return ((dagger.internal.Provider) TestModule_ProvideStringFactory.create());
     }
 
     @Override
     public Provider<Object> object() {
-      return ((Provider) TestModule_ProvideStringFactory.create());
+      return ((dagger.internal.Provider) TestModule_ProvideStringFactory.create());
     }
   }
 }
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent
index 310f8a1d8..00012762b 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -53,12 +53,12 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<CharSequence> charSequence() {
+    public javax.inject.Provider<CharSequence> charSequence() {
       return ((Provider) provideStringProvider);
     }
 
     @Override
-    public Provider<Object> object() {
+    public javax.inject.Provider<Object> object() {
       return ((Provider) provideStringProvider);
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider
index 193724a41..f2043f661 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider
@@ -48,7 +48,7 @@ final class DaggerRequestsSubtypeAsProvider {
 
     @Override
     public Provider<Supertype> supertypeProvider() {
-      return ((Provider) Subtype_Factory.create());
+      return ((dagger.internal.Provider) Subtype_Factory.create());
     }
   }
 }
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider
index 0d3233a98..137a98d3a 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.Subtype_Factory;
 import other.Supertype;
 
@@ -56,7 +56,7 @@ final class DaggerRequestsSubtypeAsProvider {
     }
 
     @Override
-    public Provider<Supertype> supertypeProvider() {
+    public javax.inject.Provider<Supertype> supertypeProvider() {
       return subtypeProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent
index b1c1c2c87..3743b5c96 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.Subtype_Factory;
 import other.UsesSupertype;
 import other.UsesSupertype_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent
index e076a1dc6..460550ae5 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.Subtype_Factory;
 import other.UsesSupertype;
 import other.UsesSupertype_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent
index 149a5fe68..492cfcb2f 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -58,7 +58,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> object() {
+    public javax.inject.Provider<Object> object() {
       return bindStringProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent
index 09600ed69..832a83080 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -58,7 +58,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> object() {
+    public javax.inject.Provider<Object> object() {
       return bindStringProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent
index 61f28ddf7..772f290bb 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent
index 323f241f2..095596880 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent
index ccbf8fc06..112948e87 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent
index 1b7c50552..c1775b63a 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent
index 227bed0a8..097f1acea 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent
index dea546e94..500b4579f 100644
--- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.internal.SingleCheck;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent
index cb7a35d2c..194275af3 100644
--- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent
index 94c174c71..92822a55c 100644
--- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent
index 32382c8cf..b3662e51c 100644
--- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent
index 381eeebf9..152ecdd2f 100644
--- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
index 9e10117e4..def1244dc 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
@@ -71,4 +71,4 @@ final class DaggerTestComponent {
       return OtherEntryPoint_Factory.newInstance(fooImpl());
     }
   }
-}
-\ No newline at end of file
+}
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent
index 9c2506681..df4e53b6a 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
index 9642f3381..836ddbdc6 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
@@ -93,4 +93,4 @@ final class DaggerTestComponent {
       }
     }
   }
-}
-\ No newline at end of file
+}
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent
index a18b8a4c4..cfe84a52e 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,8 +3,8 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
index e377365d4..b92d68e2c 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
+import dagger.internal.Provider;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
@@ -67,4 +67,4 @@ final class DaggerTestComponent {
       return OtherEntryPoint_Factory.newInstance(fooImpl());
     }
   }
-}
-\ No newline at end of file
+}
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent
index c1345ad1c..4e663c8ac 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
index c6db8da9b..45aac8a6a 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
+import dagger.internal.Provider;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
@@ -89,4 +89,4 @@ final class DaggerTestComponent {
       }
     }
   }
-}
-\ No newline at end of file
+}
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent
index 8e2e95981..5e4e1811b 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DelegateFactory;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 import other.OtherEntryPoint;
 import other.OtherEntryPoint_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
index d39656c9b..d964156bb 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 
 @DaggerGenerated
@@ -59,4 +59,4 @@ final class DaggerTestComponent {
       return bindProvider.get();
     }
   }
-}
-\ No newline at end of file
+}
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent
index 73dda53a9..40fa32728 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 
 @DaggerGenerated
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
index 7c0c68df2..0697fe79e 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 
 @DaggerGenerated
@@ -85,4 +85,4 @@ final class DaggerTestComponent {
       }
     }
   }
-}
-\ No newline at end of file
+}
diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent
index 84ae12fed..a2a46234b 100644
--- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.FooImpl_Factory;
 
 @DaggerGenerated
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent
index 88153bcb5..f3a76f55e 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapProviderFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -66,7 +66,7 @@ final class DaggerTestComponent {
 
     private Provider<Handler> provideLoginHandlerProvider;
 
-    private Provider<Map<PathEnum, Provider<Handler>>> mapOfPathEnumAndProviderOfHandlerProvider;
+    private Provider mapOfPathEnumAndProviderOfHandlerProvider;
 
     private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) {
 
@@ -83,7 +83,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<PathEnum, Provider<Handler>>> dispatcher() {
+    public javax.inject.Provider<Map<PathEnum, javax.inject.Provider<Handler>>> dispatcher() {
       return mapOfPathEnumAndProviderOfHandlerProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent
index ac0e74e19..4321b6cad 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -70,7 +70,7 @@ final class DaggerTestComponent {
 
     private Provider<Handler> provideLoginHandlerProvider;
 
-    private Provider<Map<PathEnum, Provider<Handler>>> mapOfPathEnumAndProviderOfHandlerProvider;
+    private Provider mapOfPathEnumAndProviderOfHandlerProvider;
 
     private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) {
       this.mapModuleOne = mapModuleOneParam;
@@ -88,7 +88,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<PathEnum, Provider<Handler>>> dispatcher() {
+    public javax.inject.Provider<Map<PathEnum, javax.inject.Provider<Handler>>> dispatcher() {
       return mapOfPathEnumAndProviderOfHandlerProvider;
     }
 
@@ -107,7 +107,7 @@ final class DaggerTestComponent {
       public T get() {
         switch (id) {
           case 0: // java.util.Map<test.PathEnum,javax.inject.Provider<test.Handler>> 
-          return (T) ImmutableMap.<PathEnum, Provider<Handler>>of(PathEnum.ADMIN, testComponentImpl.provideAdminHandlerProvider, PathEnum.LOGIN, testComponentImpl.provideLoginHandlerProvider);
+          return (T) ImmutableMap.<PathEnum, javax.inject.Provider<Handler>>of(PathEnum.ADMIN, testComponentImpl.provideAdminHandlerProvider, PathEnum.LOGIN, testComponentImpl.provideLoginHandlerProvider);
 
           case 1: // java.util.Map<test.PathEnum,javax.inject.Provider<test.Handler>> test.MapModuleOne#provideAdminHandler 
           return (T) MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(testComponentImpl.mapModuleOne);
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent
index 1d9618dd2..849d90529 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapFactory;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import mapkeys.MapKeys;
 import mapkeys.MapModule;
 import mapkeys.MapModule_ClassKeyFactory;
@@ -84,7 +84,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<Class<?>, Integer>> classKeyProvider() {
+    public javax.inject.Provider<Map<Class<?>, Integer>> classKeyProvider() {
       return mapOfClassOfAndIntegerProvider;
     }
 
@@ -94,7 +94,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> inaccessibleEnumProvider() {
+    public javax.inject.Provider<Object> inaccessibleEnumProvider() {
       return mapOfPackagePrivateEnumAndIntegerProvider;
     }
 
@@ -104,7 +104,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() {
+    public javax.inject.Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() {
       return mapOfComplexKeyAndIntegerProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent
index 1d9618dd2..849d90529 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapFactory;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import mapkeys.MapKeys;
 import mapkeys.MapModule;
 import mapkeys.MapModule_ClassKeyFactory;
@@ -84,7 +84,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<Class<?>, Integer>> classKeyProvider() {
+    public javax.inject.Provider<Map<Class<?>, Integer>> classKeyProvider() {
       return mapOfClassOfAndIntegerProvider;
     }
 
@@ -94,7 +94,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> inaccessibleEnumProvider() {
+    public javax.inject.Provider<Object> inaccessibleEnumProvider() {
       return mapOfPackagePrivateEnumAndIntegerProvider;
     }
 
@@ -104,7 +104,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() {
+    public javax.inject.Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() {
       return mapOfComplexKeyAndIntegerProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent
index b2e7cf5fd..056ff5afe 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -83,7 +83,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<PathEnum, Handler>> dispatcher() {
+    public javax.inject.Provider<Map<PathEnum, Handler>> dispatcher() {
       return mapOfPathEnumAndHandlerProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent
index 4e898edfa..ae80b854b 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -82,7 +82,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<PathEnum, Handler>> dispatcher() {
+    public javax.inject.Provider<Map<PathEnum, Handler>> dispatcher() {
       return mapOfPathEnumAndHandlerProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent
index 0b463f566..e353cdbd8 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapProviderFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -66,7 +66,7 @@ final class DaggerTestComponent {
 
     private Provider<Handler> provideLoginHandlerProvider;
 
-    private Provider<Map<String, Provider<Handler>>> mapOfStringAndProviderOfHandlerProvider;
+    private Provider mapOfStringAndProviderOfHandlerProvider;
 
     private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) {
 
@@ -83,7 +83,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<String, Provider<Handler>>> dispatcher() {
+    public javax.inject.Provider<Map<String, javax.inject.Provider<Handler>>> dispatcher() {
       return mapOfStringAndProviderOfHandlerProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent
index 65513bb7e..4e83239d0 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -70,7 +70,7 @@ final class DaggerTestComponent {
 
     private Provider<Handler> provideLoginHandlerProvider;
 
-    private Provider<Map<String, Provider<Handler>>> mapOfStringAndProviderOfHandlerProvider;
+    private Provider mapOfStringAndProviderOfHandlerProvider;
 
     private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) {
       this.mapModuleOne = mapModuleOneParam;
@@ -88,7 +88,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<String, Provider<Handler>>> dispatcher() {
+    public javax.inject.Provider<Map<String, javax.inject.Provider<Handler>>> dispatcher() {
       return mapOfStringAndProviderOfHandlerProvider;
     }
 
@@ -107,7 +107,7 @@ final class DaggerTestComponent {
       public T get() {
         switch (id) {
           case 0: // java.util.Map<java.lang.String,javax.inject.Provider<test.Handler>> 
-          return (T) ImmutableMap.<String, Provider<Handler>>of("Admin", testComponentImpl.provideAdminHandlerProvider, "Login", testComponentImpl.provideLoginHandlerProvider);
+          return (T) ImmutableMap.<String, javax.inject.Provider<Handler>>of("Admin", testComponentImpl.provideAdminHandlerProvider, "Login", testComponentImpl.provideLoginHandlerProvider);
 
           case 1: // java.util.Map<java.lang.String,javax.inject.Provider<test.Handler>> test.MapModuleOne#provideAdminHandler 
           return (T) MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(testComponentImpl.mapModuleOne);
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent
index 47847a7dc..5611344d9 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapProviderFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -66,7 +66,7 @@ final class DaggerTestComponent {
 
     private Provider<Handler> provideLoginHandlerProvider;
 
-    private Provider<Map<WrappedClassKey, Provider<Handler>>> mapOfWrappedClassKeyAndProviderOfHandlerProvider;
+    private Provider mapOfWrappedClassKeyAndProviderOfHandlerProvider;
 
     private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) {
 
@@ -83,7 +83,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<WrappedClassKey, Provider<Handler>>> dispatcher() {
+    public javax.inject.Provider<Map<WrappedClassKey, javax.inject.Provider<Handler>>> dispatcher(
+        ) {
       return mapOfWrappedClassKeyAndProviderOfHandlerProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent
index 3180571c2..2b87e633b 100644
--- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -70,7 +70,7 @@ final class DaggerTestComponent {
 
     private Provider<Handler> provideLoginHandlerProvider;
 
-    private Provider<Map<WrappedClassKey, Provider<Handler>>> mapOfWrappedClassKeyAndProviderOfHandlerProvider;
+    private Provider mapOfWrappedClassKeyAndProviderOfHandlerProvider;
 
     private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) {
       this.mapModuleOne = mapModuleOneParam;
@@ -88,7 +88,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Map<WrappedClassKey, Provider<Handler>>> dispatcher() {
+    public javax.inject.Provider<Map<WrappedClassKey, javax.inject.Provider<Handler>>> dispatcher(
+        ) {
       return mapOfWrappedClassKeyAndProviderOfHandlerProvider;
     }
 
@@ -107,7 +108,7 @@ final class DaggerTestComponent {
       public T get() {
         switch (id) {
           case 0: // java.util.Map<test.WrappedClassKey,javax.inject.Provider<test.Handler>> 
-          return (T) ImmutableMap.<WrappedClassKey, Provider<Handler>>of(WrappedClassKeyCreator.createWrappedClassKey(Integer.class), testComponentImpl.provideAdminHandlerProvider, WrappedClassKeyCreator.createWrappedClassKey(Long.class), testComponentImpl.provideLoginHandlerProvider);
+          return (T) ImmutableMap.<WrappedClassKey, javax.inject.Provider<Handler>>of(WrappedClassKeyCreator.createWrappedClassKey(Integer.class), testComponentImpl.provideAdminHandlerProvider, WrappedClassKeyCreator.createWrappedClassKey(Long.class), testComponentImpl.provideLoginHandlerProvider);
 
           case 1: // java.util.Map<test.WrappedClassKey,javax.inject.Provider<test.Handler>> test.MapModuleOne#provideAdminHandler 
           return (T) MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(testComponentImpl.mapModuleOne);
diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent
index 0010e588c..1db8ff8df 100644
--- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,10 +2,10 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.MapBuilder;
+import dagger.internal.Provider;
 import java.util.Collections;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -70,8 +70,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<String, Provider<String>> providerStrings() {
-      return Collections.<String, Provider<String>>emptyMap();
+    public Map<String, javax.inject.Provider<String>> providerStrings() {
+      return Collections.<String, javax.inject.Provider<String>>emptyMap();
     }
 
     @Override
@@ -80,8 +80,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<Integer, Provider<Integer>> providerInts() {
-      return Collections.<Integer, Provider<Integer>>singletonMap(0, provideIntProvider);
+    public Map<Integer, javax.inject.Provider<Integer>> providerInts() {
+      return Collections.<Integer, javax.inject.Provider<Integer>>singletonMap(0, provideIntProvider);
     }
 
     @Override
@@ -90,8 +90,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<Long, Provider<Long>> providerLongs() {
-      return MapBuilder.<Long, Provider<Long>>newMapBuilder(3).put(0L, provideLong0Provider).put(1L, provideLong1Provider).put(2L, provideLong2Provider).build();
+    public Map<Long, javax.inject.Provider<Long>> providerLongs() {
+      return MapBuilder.<Long, javax.inject.Provider<Long>>newMapBuilder(3).put(0L, provideLong0Provider).put(1L, provideLong1Provider).put(2L, provideLong2Provider).build();
     }
 
     private static final class SwitchingProvider<T> implements Provider<T> {
diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent
index e99a9639e..97cb73481 100644
--- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import com.google.common.collect.ImmutableMap;
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import java.util.Map;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -69,8 +69,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<Long, Provider<Long>> providerLongs() {
-      return ImmutableMap.<Long, Provider<Long>>builderWithExpectedSize(6).put(0L, testComponentImpl.provideLong0Provider).put(1L, testComponentImpl.provideLong1Provider).put(2L, testComponentImpl.provideLong2Provider).put(3L, provideLong3Provider).put(4L, provideLong4Provider).put(5L, provideLong5Provider).build();
+    public Map<Long, javax.inject.Provider<Long>> providerLongs() {
+      return ImmutableMap.<Long, javax.inject.Provider<Long>>builderWithExpectedSize(6).put(0L, testComponentImpl.provideLong0Provider).put(1L, testComponentImpl.provideLong1Provider).put(2L, testComponentImpl.provideLong2Provider).put(3L, provideLong3Provider).put(4L, provideLong4Provider).put(5L, provideLong5Provider).build();
     }
 
     private static final class SwitchingProvider<T> implements Provider<T> {
@@ -136,8 +136,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<String, Provider<String>> providerStrings() {
-      return ImmutableMap.<String, Provider<String>>of();
+    public Map<String, javax.inject.Provider<String>> providerStrings() {
+      return ImmutableMap.<String, javax.inject.Provider<String>>of();
     }
 
     @Override
@@ -146,8 +146,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<Integer, Provider<Integer>> providerInts() {
-      return ImmutableMap.<Integer, Provider<Integer>>of(0, provideIntProvider);
+    public Map<Integer, javax.inject.Provider<Integer>> providerInts() {
+      return ImmutableMap.<Integer, javax.inject.Provider<Integer>>of(0, provideIntProvider);
     }
 
     @Override
@@ -156,8 +156,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Map<Long, Provider<Long>> providerLongs() {
-      return ImmutableMap.<Long, Provider<Long>>of(0L, provideLong0Provider, 1L, provideLong1Provider, 2L, provideLong2Provider);
+    public Map<Long, javax.inject.Provider<Long>> providerLongs() {
+      return ImmutableMap.<Long, javax.inject.Provider<Long>>of(0L, provideLong0Provider, 1L, provideLong1Provider, 2L, provideLong2Provider);
     }
 
     @Override
diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent
index f8228a181..e322e4276 100644
--- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import java.util.List;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.InaccessiblesModule_InaccessiblesFactory;
 import other.UsesInaccessibles;
 import other.UsesInaccessibles_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent
index fd1c93050..ee997892a 100644
--- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import java.util.List;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.InaccessiblesModule_InaccessiblesFactory;
 import other.UsesInaccessibles;
 import other.UsesInaccessibles_Factory;
diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
index 9636b1a62..24a86c515 100644
--- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent
@@ -57,7 +57,7 @@ final class DaggerTestComponent {
 
     @Override
     public Optional<Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() {
-      return Optional.of(ProviderOfLazy.create(Maybe_MaybeModule_ProvideMaybeFactory.create()));
+      return (Optional) Optional.of(ProviderOfLazy.create(Maybe_MaybeModule_ProvideMaybeFactory.create()));
     }
 
     @Override
@@ -67,7 +67,7 @@ final class DaggerTestComponent {
 
     @Override
     public Optional<Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() {
-      return Optional.<Provider<Lazy<DefinitelyNot>>>absent();
+      return (Optional) Optional.<Provider<Lazy<DefinitelyNot>>>absent();
     }
   }
 }
diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
index 88631be0e..06503d984 100644
--- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.base.Optional;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import dagger.internal.ProviderOfLazy;
 import javax.annotation.Generated;
-import javax.inject.Provider;
 import other.DefinitelyNot;
 import other.Maybe;
 import other.Maybe_MaybeModule_ProvideMaybeFactory;
@@ -64,8 +64,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Optional<Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() {
-      return Optional.of(ProviderOfLazy.create(provideMaybeProvider));
+    public Optional<javax.inject.Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() {
+      return (Optional) Optional.of(ProviderOfLazy.create(provideMaybeProvider));
     }
 
     @Override
@@ -74,8 +74,8 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Optional<Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() {
-      return Optional.<Provider<Lazy<DefinitelyNot>>>absent();
+    public Optional<javax.inject.Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() {
+      return (Optional) Optional.<javax.inject.Provider<Lazy<DefinitelyNot>>>absent();
     }
 
     private static final class SwitchingProvider<T> implements Provider<T> {
diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent
index bc2d8aa72..54068ac6b 100644
--- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import com.google.common.base.Optional;
 import dagger.Lazy;
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import dagger.internal.ProviderOfLazy;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 import other.DefinitelyNot;
 import other.Maybe;
 import other.Maybe_MaybeModule_ProvideMaybeFactory;
@@ -64,7 +64,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Optional<Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() {
+    public Optional<javax.inject.Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() {
       return Optional.of(ProviderOfLazy.create(provideMaybeProvider));
     }
 
@@ -74,7 +74,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Optional<Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() {
+    public Optional<javax.inject.Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() {
       return Optional.absent();
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent
index 11af50c5f..8be0f98b0 100644
--- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent
+++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.producers.internal.CancellationListener;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent
index 5d0b797d5..cf5ae455e 100644
--- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent
+++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import dagger.producers.internal.CancellationListener;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent
index d55cd3735..6123ca470 100644
--- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent
@@ -5,6 +5,7 @@ import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
 import dagger.internal.InstanceFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import dagger.internal.SetFactory;
 import dagger.producers.Producer;
 import dagger.producers.internal.CancellationListener;
@@ -12,7 +13,6 @@ import dagger.producers.internal.Producers;
 import dagger.producers.monitoring.ProductionComponentMonitor;
 import java.util.concurrent.Executor;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent
index 9ad6e6fa2..cf9c52436 100644
--- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent
+++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent
@@ -5,6 +5,7 @@ import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
 import dagger.internal.InstanceFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import dagger.internal.SetFactory;
 import dagger.producers.Producer;
 import dagger.producers.internal.CancellationListener;
@@ -12,7 +13,6 @@ import dagger.producers.internal.Producers;
 import dagger.producers.monitoring.ProductionComponentMonitor;
 import java.util.concurrent.Executor;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent
index b05b85f06..007872810 100644
--- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent
+++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent
@@ -3,8 +3,8 @@ package test;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent
index 6311a200c..36c5032d1 100644
--- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent
+++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent
@@ -3,8 +3,8 @@ package test;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent
index e0230e0c7..95ce23a3c 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent
@@ -4,8 +4,8 @@ import dagger.MembersInjector;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.InstanceFactory;
 import dagger.internal.MembersInjectors;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -56,7 +56,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<MembersInjector<Foo>> providerOfMembersInjector() {
+    public javax.inject.Provider<MembersInjector<Foo>> providerOfMembersInjector() {
       return fooMembersInjectorProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent
index e0230e0c7..95ce23a3c 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent
@@ -4,8 +4,8 @@ import dagger.MembersInjector;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.InstanceFactory;
 import dagger.internal.MembersInjectors;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -56,7 +56,7 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<MembersInjector<Foo>> providerOfMembersInjector() {
+    public javax.inject.Provider<MembersInjector<Foo>> providerOfMembersInjector() {
       return fooMembersInjectorProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent
index 904fb4aea..dd50b770e 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent
@@ -3,9 +3,9 @@ package test;
 import dagger.internal.DaggerGenerated;
 import dagger.internal.InstanceFactory;
 import dagger.internal.Preconditions;
+import dagger.internal.Provider;
 import java.util.Optional;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -94,12 +94,12 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Optional<Present>> providerOfOptionalOfPresent() {
+    public javax.inject.Provider<Optional<Present>> providerOfOptionalOfPresent() {
       return optionalOfPresentProvider;
     }
 
     @Override
-    public Provider<Optional<Absent>> providerOfOptionalOfAbsent() {
+    public javax.inject.Provider<Optional<Absent>> providerOfOptionalOfAbsent() {
       return optionalOfAbsentProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent
index 1e46fdee1..26462e468 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,9 +2,9 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.InstanceFactory;
+import dagger.internal.Provider;
 import java.util.Optional;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -73,12 +73,12 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Optional<Present>> providerOfOptionalOfPresent() {
+    public javax.inject.Provider<Optional<Present>> providerOfOptionalOfPresent() {
       return optionalOfPresentProvider;
     }
 
     @Override
-    public Provider<Optional<Absent>> providerOfOptionalOfAbsent() {
+    public javax.inject.Provider<Optional<Absent>> providerOfOptionalOfAbsent() {
       return optionalOfAbsentProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent
index d3f68be07..e7c8b4f65 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -54,12 +54,12 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> objectProvider() {
+    public javax.inject.Provider<Object> objectProvider() {
       return ((Provider) cProvider);
     }
 
     @Override
-    public Provider<CharSequence> charSequenceProvider() {
+    public javax.inject.Provider<CharSequence> charSequenceProvider() {
       return cProvider;
     }
   }
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent
index 440def076..b8603ec1a 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent
@@ -2,8 +2,8 @@ package test;
 
 import dagger.internal.DaggerGenerated;
 import dagger.internal.DoubleCheck;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -57,12 +57,12 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> objectProvider() {
+    public javax.inject.Provider<Object> objectProvider() {
       return ((Provider) cProvider);
     }
 
     @Override
-    public Provider<CharSequence> charSequenceProvider() {
+    public javax.inject.Provider<CharSequence> charSequenceProvider() {
       return cProvider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent
index c2bcf9116..39ded9383 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -358,507 +358,507 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Binding0> getBinding0Provider() {
+    public javax.inject.Provider<Binding0> getBinding0Provider() {
       return binding0Provider;
     }
 
     @Override
-    public Provider<Binding1> getBinding1Provider() {
+    public javax.inject.Provider<Binding1> getBinding1Provider() {
       return binding1Provider;
     }
 
     @Override
-    public Provider<Binding2> getBinding2Provider() {
+    public javax.inject.Provider<Binding2> getBinding2Provider() {
       return binding2Provider;
     }
 
     @Override
-    public Provider<Binding3> getBinding3Provider() {
+    public javax.inject.Provider<Binding3> getBinding3Provider() {
       return binding3Provider;
     }
 
     @Override
-    public Provider<Binding4> getBinding4Provider() {
+    public javax.inject.Provider<Binding4> getBinding4Provider() {
       return binding4Provider;
     }
 
     @Override
-    public Provider<Binding5> getBinding5Provider() {
+    public javax.inject.Provider<Binding5> getBinding5Provider() {
       return binding5Provider;
     }
 
     @Override
-    public Provider<Binding6> getBinding6Provider() {
+    public javax.inject.Provider<Binding6> getBinding6Provider() {
       return binding6Provider;
     }
 
     @Override
-    public Provider<Binding7> getBinding7Provider() {
+    public javax.inject.Provider<Binding7> getBinding7Provider() {
       return binding7Provider;
     }
 
     @Override
-    public Provider<Binding8> getBinding8Provider() {
+    public javax.inject.Provider<Binding8> getBinding8Provider() {
       return binding8Provider;
     }
 
     @Override
-    public Provider<Binding9> getBinding9Provider() {
+    public javax.inject.Provider<Binding9> getBinding9Provider() {
       return binding9Provider;
     }
 
     @Override
-    public Provider<Binding10> getBinding10Provider() {
+    public javax.inject.Provider<Binding10> getBinding10Provider() {
       return binding10Provider;
     }
 
     @Override
-    public Provider<Binding11> getBinding11Provider() {
+    public javax.inject.Provider<Binding11> getBinding11Provider() {
       return binding11Provider;
     }
 
     @Override
-    public Provider<Binding12> getBinding12Provider() {
+    public javax.inject.Provider<Binding12> getBinding12Provider() {
       return binding12Provider;
     }
 
     @Override
-    public Provider<Binding13> getBinding13Provider() {
+    public javax.inject.Provider<Binding13> getBinding13Provider() {
       return binding13Provider;
     }
 
     @Override
-    public Provider<Binding14> getBinding14Provider() {
+    public javax.inject.Provider<Binding14> getBinding14Provider() {
       return binding14Provider;
     }
 
     @Override
-    public Provider<Binding15> getBinding15Provider() {
+    public javax.inject.Provider<Binding15> getBinding15Provider() {
       return binding15Provider;
     }
 
     @Override
-    public Provider<Binding16> getBinding16Provider() {
+    public javax.inject.Provider<Binding16> getBinding16Provider() {
       return binding16Provider;
     }
 
     @Override
-    public Provider<Binding17> getBinding17Provider() {
+    public javax.inject.Provider<Binding17> getBinding17Provider() {
       return binding17Provider;
     }
 
     @Override
-    public Provider<Binding18> getBinding18Provider() {
+    public javax.inject.Provider<Binding18> getBinding18Provider() {
       return binding18Provider;
     }
 
     @Override
-    public Provider<Binding19> getBinding19Provider() {
+    public javax.inject.Provider<Binding19> getBinding19Provider() {
       return binding19Provider;
     }
 
     @Override
-    public Provider<Binding20> getBinding20Provider() {
+    public javax.inject.Provider<Binding20> getBinding20Provider() {
       return binding20Provider;
     }
 
     @Override
-    public Provider<Binding21> getBinding21Provider() {
+    public javax.inject.Provider<Binding21> getBinding21Provider() {
       return binding21Provider;
     }
 
     @Override
-    public Provider<Binding22> getBinding22Provider() {
+    public javax.inject.Provider<Binding22> getBinding22Provider() {
       return binding22Provider;
     }
 
     @Override
-    public Provider<Binding23> getBinding23Provider() {
+    public javax.inject.Provider<Binding23> getBinding23Provider() {
       return binding23Provider;
     }
 
     @Override
-    public Provider<Binding24> getBinding24Provider() {
+    public javax.inject.Provider<Binding24> getBinding24Provider() {
       return binding24Provider;
     }
 
     @Override
-    public Provider<Binding25> getBinding25Provider() {
+    public javax.inject.Provider<Binding25> getBinding25Provider() {
       return binding25Provider;
     }
 
     @Override
-    public Provider<Binding26> getBinding26Provider() {
+    public javax.inject.Provider<Binding26> getBinding26Provider() {
       return binding26Provider;
     }
 
     @Override
-    public Provider<Binding27> getBinding27Provider() {
+    public javax.inject.Provider<Binding27> getBinding27Provider() {
       return binding27Provider;
     }
 
     @Override
-    public Provider<Binding28> getBinding28Provider() {
+    public javax.inject.Provider<Binding28> getBinding28Provider() {
       return binding28Provider;
     }
 
     @Override
-    public Provider<Binding29> getBinding29Provider() {
+    public javax.inject.Provider<Binding29> getBinding29Provider() {
       return binding29Provider;
     }
 
     @Override
-    public Provider<Binding30> getBinding30Provider() {
+    public javax.inject.Provider<Binding30> getBinding30Provider() {
       return binding30Provider;
     }
 
     @Override
-    public Provider<Binding31> getBinding31Provider() {
+    public javax.inject.Provider<Binding31> getBinding31Provider() {
       return binding31Provider;
     }
 
     @Override
-    public Provider<Binding32> getBinding32Provider() {
+    public javax.inject.Provider<Binding32> getBinding32Provider() {
       return binding32Provider;
     }
 
     @Override
-    public Provider<Binding33> getBinding33Provider() {
+    public javax.inject.Provider<Binding33> getBinding33Provider() {
       return binding33Provider;
     }
 
     @Override
-    public Provider<Binding34> getBinding34Provider() {
+    public javax.inject.Provider<Binding34> getBinding34Provider() {
       return binding34Provider;
     }
 
     @Override
-    public Provider<Binding35> getBinding35Provider() {
+    public javax.inject.Provider<Binding35> getBinding35Provider() {
       return binding35Provider;
     }
 
     @Override
-    public Provider<Binding36> getBinding36Provider() {
+    public javax.inject.Provider<Binding36> getBinding36Provider() {
       return binding36Provider;
     }
 
     @Override
-    public Provider<Binding37> getBinding37Provider() {
+    public javax.inject.Provider<Binding37> getBinding37Provider() {
       return binding37Provider;
     }
 
     @Override
-    public Provider<Binding38> getBinding38Provider() {
+    public javax.inject.Provider<Binding38> getBinding38Provider() {
       return binding38Provider;
     }
 
     @Override
-    public Provider<Binding39> getBinding39Provider() {
+    public javax.inject.Provider<Binding39> getBinding39Provider() {
       return binding39Provider;
     }
 
     @Override
-    public Provider<Binding40> getBinding40Provider() {
+    public javax.inject.Provider<Binding40> getBinding40Provider() {
       return binding40Provider;
     }
 
     @Override
-    public Provider<Binding41> getBinding41Provider() {
+    public javax.inject.Provider<Binding41> getBinding41Provider() {
       return binding41Provider;
     }
 
     @Override
-    public Provider<Binding42> getBinding42Provider() {
+    public javax.inject.Provider<Binding42> getBinding42Provider() {
       return binding42Provider;
     }
 
     @Override
-    public Provider<Binding43> getBinding43Provider() {
+    public javax.inject.Provider<Binding43> getBinding43Provider() {
       return binding43Provider;
     }
 
     @Override
-    public Provider<Binding44> getBinding44Provider() {
+    public javax.inject.Provider<Binding44> getBinding44Provider() {
       return binding44Provider;
     }
 
     @Override
-    public Provider<Binding45> getBinding45Provider() {
+    public javax.inject.Provider<Binding45> getBinding45Provider() {
       return binding45Provider;
     }
 
     @Override
-    public Provider<Binding46> getBinding46Provider() {
+    public javax.inject.Provider<Binding46> getBinding46Provider() {
       return binding46Provider;
     }
 
     @Override
-    public Provider<Binding47> getBinding47Provider() {
+    public javax.inject.Provider<Binding47> getBinding47Provider() {
       return binding47Provider;
     }
 
     @Override
-    public Provider<Binding48> getBinding48Provider() {
+    public javax.inject.Provider<Binding48> getBinding48Provider() {
       return binding48Provider;
     }
 
     @Override
-    public Provider<Binding49> getBinding49Provider() {
+    public javax.inject.Provider<Binding49> getBinding49Provider() {
       return binding49Provider;
     }
 
     @Override
-    public Provider<Binding50> getBinding50Provider() {
+    public javax.inject.Provider<Binding50> getBinding50Provider() {
       return binding50Provider;
     }
 
     @Override
-    public Provider<Binding51> getBinding51Provider() {
+    public javax.inject.Provider<Binding51> getBinding51Provider() {
       return binding51Provider;
     }
 
     @Override
-    public Provider<Binding52> getBinding52Provider() {
+    public javax.inject.Provider<Binding52> getBinding52Provider() {
       return binding52Provider;
     }
 
     @Override
-    public Provider<Binding53> getBinding53Provider() {
+    public javax.inject.Provider<Binding53> getBinding53Provider() {
       return binding53Provider;
     }
 
     @Override
-    public Provider<Binding54> getBinding54Provider() {
+    public javax.inject.Provider<Binding54> getBinding54Provider() {
       return binding54Provider;
     }
 
     @Override
-    public Provider<Binding55> getBinding55Provider() {
+    public javax.inject.Provider<Binding55> getBinding55Provider() {
       return binding55Provider;
     }
 
     @Override
-    public Provider<Binding56> getBinding56Provider() {
+    public javax.inject.Provider<Binding56> getBinding56Provider() {
       return binding56Provider;
     }
 
     @Override
-    public Provider<Binding57> getBinding57Provider() {
+    public javax.inject.Provider<Binding57> getBinding57Provider() {
       return binding57Provider;
     }
 
     @Override
-    public Provider<Binding58> getBinding58Provider() {
+    public javax.inject.Provider<Binding58> getBinding58Provider() {
       return binding58Provider;
     }
 
     @Override
-    public Provider<Binding59> getBinding59Provider() {
+    public javax.inject.Provider<Binding59> getBinding59Provider() {
       return binding59Provider;
     }
 
     @Override
-    public Provider<Binding60> getBinding60Provider() {
+    public javax.inject.Provider<Binding60> getBinding60Provider() {
       return binding60Provider;
     }
 
     @Override
-    public Provider<Binding61> getBinding61Provider() {
+    public javax.inject.Provider<Binding61> getBinding61Provider() {
       return binding61Provider;
     }
 
     @Override
-    public Provider<Binding62> getBinding62Provider() {
+    public javax.inject.Provider<Binding62> getBinding62Provider() {
       return binding62Provider;
     }
 
     @Override
-    public Provider<Binding63> getBinding63Provider() {
+    public javax.inject.Provider<Binding63> getBinding63Provider() {
       return binding63Provider;
     }
 
     @Override
-    public Provider<Binding64> getBinding64Provider() {
+    public javax.inject.Provider<Binding64> getBinding64Provider() {
       return binding64Provider;
     }
 
     @Override
-    public Provider<Binding65> getBinding65Provider() {
+    public javax.inject.Provider<Binding65> getBinding65Provider() {
       return binding65Provider;
     }
 
     @Override
-    public Provider<Binding66> getBinding66Provider() {
+    public javax.inject.Provider<Binding66> getBinding66Provider() {
       return binding66Provider;
     }
 
     @Override
-    public Provider<Binding67> getBinding67Provider() {
+    public javax.inject.Provider<Binding67> getBinding67Provider() {
       return binding67Provider;
     }
 
     @Override
-    public Provider<Binding68> getBinding68Provider() {
+    public javax.inject.Provider<Binding68> getBinding68Provider() {
       return binding68Provider;
     }
 
     @Override
-    public Provider<Binding69> getBinding69Provider() {
+    public javax.inject.Provider<Binding69> getBinding69Provider() {
       return binding69Provider;
     }
 
     @Override
-    public Provider<Binding70> getBinding70Provider() {
+    public javax.inject.Provider<Binding70> getBinding70Provider() {
       return binding70Provider;
     }
 
     @Override
-    public Provider<Binding71> getBinding71Provider() {
+    public javax.inject.Provider<Binding71> getBinding71Provider() {
       return binding71Provider;
     }
 
     @Override
-    public Provider<Binding72> getBinding72Provider() {
+    public javax.inject.Provider<Binding72> getBinding72Provider() {
       return binding72Provider;
     }
 
     @Override
-    public Provider<Binding73> getBinding73Provider() {
+    public javax.inject.Provider<Binding73> getBinding73Provider() {
       return binding73Provider;
     }
 
     @Override
-    public Provider<Binding74> getBinding74Provider() {
+    public javax.inject.Provider<Binding74> getBinding74Provider() {
       return binding74Provider;
     }
 
     @Override
-    public Provider<Binding75> getBinding75Provider() {
+    public javax.inject.Provider<Binding75> getBinding75Provider() {
       return binding75Provider;
     }
 
     @Override
-    public Provider<Binding76> getBinding76Provider() {
+    public javax.inject.Provider<Binding76> getBinding76Provider() {
       return binding76Provider;
     }
 
     @Override
-    public Provider<Binding77> getBinding77Provider() {
+    public javax.inject.Provider<Binding77> getBinding77Provider() {
       return binding77Provider;
     }
 
     @Override
-    public Provider<Binding78> getBinding78Provider() {
+    public javax.inject.Provider<Binding78> getBinding78Provider() {
       return binding78Provider;
     }
 
     @Override
-    public Provider<Binding79> getBinding79Provider() {
+    public javax.inject.Provider<Binding79> getBinding79Provider() {
       return binding79Provider;
     }
 
     @Override
-    public Provider<Binding80> getBinding80Provider() {
+    public javax.inject.Provider<Binding80> getBinding80Provider() {
       return binding80Provider;
     }
 
     @Override
-    public Provider<Binding81> getBinding81Provider() {
+    public javax.inject.Provider<Binding81> getBinding81Provider() {
       return binding81Provider;
     }
 
     @Override
-    public Provider<Binding82> getBinding82Provider() {
+    public javax.inject.Provider<Binding82> getBinding82Provider() {
       return binding82Provider;
     }
 
     @Override
-    public Provider<Binding83> getBinding83Provider() {
+    public javax.inject.Provider<Binding83> getBinding83Provider() {
       return binding83Provider;
     }
 
     @Override
-    public Provider<Binding84> getBinding84Provider() {
+    public javax.inject.Provider<Binding84> getBinding84Provider() {
       return binding84Provider;
     }
 
     @Override
-    public Provider<Binding85> getBinding85Provider() {
+    public javax.inject.Provider<Binding85> getBinding85Provider() {
       return binding85Provider;
     }
 
     @Override
-    public Provider<Binding86> getBinding86Provider() {
+    public javax.inject.Provider<Binding86> getBinding86Provider() {
       return binding86Provider;
     }
 
     @Override
-    public Provider<Binding87> getBinding87Provider() {
+    public javax.inject.Provider<Binding87> getBinding87Provider() {
       return binding87Provider;
     }
 
     @Override
-    public Provider<Binding88> getBinding88Provider() {
+    public javax.inject.Provider<Binding88> getBinding88Provider() {
       return binding88Provider;
     }
 
     @Override
-    public Provider<Binding89> getBinding89Provider() {
+    public javax.inject.Provider<Binding89> getBinding89Provider() {
       return binding89Provider;
     }
 
     @Override
-    public Provider<Binding90> getBinding90Provider() {
+    public javax.inject.Provider<Binding90> getBinding90Provider() {
       return binding90Provider;
     }
 
     @Override
-    public Provider<Binding91> getBinding91Provider() {
+    public javax.inject.Provider<Binding91> getBinding91Provider() {
       return binding91Provider;
     }
 
     @Override
-    public Provider<Binding92> getBinding92Provider() {
+    public javax.inject.Provider<Binding92> getBinding92Provider() {
       return binding92Provider;
     }
 
     @Override
-    public Provider<Binding93> getBinding93Provider() {
+    public javax.inject.Provider<Binding93> getBinding93Provider() {
       return binding93Provider;
     }
 
     @Override
-    public Provider<Binding94> getBinding94Provider() {
+    public javax.inject.Provider<Binding94> getBinding94Provider() {
       return binding94Provider;
     }
 
     @Override
-    public Provider<Binding95> getBinding95Provider() {
+    public javax.inject.Provider<Binding95> getBinding95Provider() {
       return binding95Provider;
     }
 
     @Override
-    public Provider<Binding96> getBinding96Provider() {
+    public javax.inject.Provider<Binding96> getBinding96Provider() {
       return binding96Provider;
     }
 
     @Override
-    public Provider<Binding97> getBinding97Provider() {
+    public javax.inject.Provider<Binding97> getBinding97Provider() {
       return binding97Provider;
     }
 
     @Override
-    public Provider<Binding98> getBinding98Provider() {
+    public javax.inject.Provider<Binding98> getBinding98Provider() {
       return binding98Provider;
     }
 
     @Override
-    public Provider<Binding99> getBinding99Provider() {
+    public javax.inject.Provider<Binding99> getBinding99Provider() {
       return binding99Provider;
     }
 
     @Override
-    public Provider<Binding100> getBinding100Provider() {
+    public javax.inject.Provider<Binding100> getBinding100Provider() {
       return binding100Provider;
     }
 
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent
index 00679b417..939d6cda1 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent
@@ -46,12 +46,12 @@ final class DaggerTestComponent {
 
     @Override
     public Provider<Object> objectProvider() {
-      return ((Provider) TestModule_SFactory.create());
+      return ((dagger.internal.Provider) TestModule_SFactory.create());
     }
 
     @Override
     public Provider<CharSequence> charSequenceProvider() {
-      return ((Provider) TestModule_SFactory.create());
+      return ((dagger.internal.Provider) TestModule_SFactory.create());
     }
   }
 }
diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent
index 2970ba6f6..f0d4e0d61 100644
--- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent
+++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent
@@ -1,8 +1,8 @@
 package test;
 
 import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
 import javax.annotation.processing.Generated;
-import javax.inject.Provider;
 
 @DaggerGenerated
 @Generated(
@@ -53,12 +53,12 @@ final class DaggerTestComponent {
     }
 
     @Override
-    public Provider<Object> objectProvider() {
+    public javax.inject.Provider<Object> objectProvider() {
       return ((Provider) sProvider);
     }
 
     @Override
-    public Provider<CharSequence> charSequenceProvider() {
+    public javax.inject.Provider<CharSequence> charSequenceProvider() {
       return ((Provider) sProvider);
     }
 
diff --git a/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java b/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java
index cc4f5a155..b430dcda4 100644
--- a/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java
+++ b/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java
@@ -230,8 +230,8 @@ public final class KspComponentProcessorTest {
                         "package test;",
                         "",
                         "import dagger.internal.DaggerGenerated;",
+                        "import dagger.internal.Provider;",
                         "import javax.annotation.processing.Generated;",
-                        "import javax.inject.Provider;",
                         "",
                         "@DaggerGenerated",
                         "@Generated(",
@@ -283,7 +283,7 @@ public final class KspComponentProcessorTest {
                         "    }",
                         "",
                         "    @Override",
-                        "    public Provider<Foo> foo() {",
+                        "    public javax.inject.Provider<Foo> foo() {",
                         "      return fooProvider;",
                         "    }",
                         "  }",
diff --git a/javatests/dagger/producers/BUILD b/javatests/dagger/producers/BUILD
index 025379996..6c7685614 100644
--- a/javatests/dagger/producers/BUILD
+++ b/javatests/dagger/producers/BUILD
@@ -31,6 +31,7 @@ GenJavaTests(
     functional = 0,
     javacopts = JAVA_RELEASE_MIN + DOCLINT_REFERENCES + DOCLINT_HTML_AND_SYNTAX,
     deps = [
+        "//java/dagger:core",
         "//java/dagger/producers",
         "//third_party/java/guava:testlib",
         "//third_party/java/guava/collect",
diff --git a/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java b/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java
index af1350447..0b32d7170 100644
--- a/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java
+++ b/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java
@@ -28,13 +28,13 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Producer;
 import dagger.producers.monitoring.ProducerMonitor;
 import dagger.producers.monitoring.ProducerToken;
 import dagger.producers.monitoring.ProductionComponentMonitor;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
-import javax.inject.Provider;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
diff --git a/javatests/dagger/producers/internal/ProducersTest.java b/javatests/dagger/producers/internal/ProducersTest.java
index 1cfe12106..5b2d9c103 100644
--- a/javatests/dagger/producers/internal/ProducersTest.java
+++ b/javatests/dagger/producers/internal/ProducersTest.java
@@ -23,12 +23,12 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
+import dagger.internal.Provider;
 import dagger.producers.Produced;
 import dagger.producers.Producer;
 import java.util.Set;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.ExecutionException;
-import javax.inject.Provider;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
author	Eric Chang <erichang@google.com>	2023-12-06 11:59:43 -0800
committer	Dagger Team <dagger-dev+copybara@google.com>	2023-12-06 12:01:45 -0800
commit	75d3cbcf95f1b540faac46f87bc8d018e254bd4e (patch)
tree	19000996ae508acee4e196df6c909d35936b5fa7
parent	668269ddfec64dad8685b2f38f66cc8227dd3c8a (diff)
download	dagger2-75d3cbcf95f1b540faac46f87bc8d018e254bd4e.tar.gz