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

java/dagger/internal/AbstractMapFactory.java

@@ -22,7 +22,6 @@
 
 import java.util.LinkedHashMap;
 import java.util.Map;
-import javax.inject.Provider;
 
 /**
  * An {@code abstract} {@link Factory} implementation used to implement {@link Map} bindings.

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> {
@@ -43,19 +42,44 @@ public void setDelegatedProvider(Provider<T> delegate) {
     setDelegate(this, delegate);
   }
 
+  /**
+   * 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 @@ Provider<T> getDelegate() {
     return checkNotNull(delegate);
   }
 }
-

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 @@ private static Object reentrantCheck(Object currentInstance, Object newInstance)
   /** 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 static <P extends Provider<T>, T> Provider<T> provider(P delegate) {
     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 static <P extends Provider<T>, T> Lazy<T> lazy(P provider) {
     }
     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));
+  }
 }

java/dagger/internal/Factory.java

@@ -18,7 +18,6 @@
 
 import dagger.Provides;
 import javax.inject.Inject;
-import javax.inject.Provider;
 import javax.inject.Scope;
 
 /**

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 Builder<K, V> put(K key, Provider<V> providerOfValue) {
       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);

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 Builder<K, V> put(K key, Provider<V> providerOfValue) {
       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);

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> {
+}

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 Lazy<T> get() {
   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));
+  }
 }

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() {}
+}

java/dagger/internal/SetFactory.java

@@ -20,14 +20,14 @@
 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;
 
 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 Builder<T> addProvider(Provider<? extends T> individualProvider) {
       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 Builder<T> addCollectionProvider(
       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";