Preparations for OptionalBinder. This fixes MapBinder's SPI so elements from different MapBinders are distinct, and also fixes ProviderLookup's Provider so it exposes its dependency, which allows MapBinder to properly find its dependencies.

-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=63811558

1 files changed, 20 insertions, 1 deletions

diff --git a/core/src/com/google/inject/spi/ProviderLookup.java b/core/src/com/google/inject/spi/ProviderLookup.java
index ee4337d5..b80932bc 100644
--- a/core/src/com/google/inject/spi/ProviderLookup.java
+++ b/core/src/com/google/inject/spi/ProviderLookup.java
@@ -21,10 +21,14 @@ import static com.google.common.base.Preconditions.checkState;
 import static com.google.inject.internal.RehashableKeys.Keys.needsRehashing;
 import static com.google.inject.internal.RehashableKeys.Keys.rehash;
 
+import com.google.common.collect.ImmutableSet;
 import com.google.inject.Binder;
 import com.google.inject.Key;
 import com.google.inject.Provider;
 import com.google.inject.internal.RehashableKeys;
+import com.google.inject.util.Types;
+
+import java.util.Set;
 
 /**
  * A lookup of the provider for a type. Lookups are created explicitly in a module using
@@ -40,6 +44,7 @@ public final class ProviderLookup<T> implements Element {
   private final Object source;
   private Key<T> key;  // effectively final, as it will not change once it escapes into user code
   private Provider<T> delegate;
+  private boolean rehashed = false;
 
   public ProviderLookup(Object source, Key<T> key) {
     this.source = checkNotNull(source, "source");
@@ -86,12 +91,25 @@ public final class ProviderLookup<T> implements Element {
    * IllegalStateException} if you try to use it beforehand.
    */
   public Provider<T> getProvider() {
-    return new Provider<T>() {
+    return new ProviderWithDependencies<T>() {
       public T get() {
         checkState(delegate != null,
             "This Provider cannot be used until the Injector has been created.");
         return delegate.get();
       }
+      
+      public Set<Dependency<?>> getDependencies() {
+        // If someone inside a Module is casting the Provider to HasDependencies
+        // in order to find its dependencies, we give them nothing (because we can't
+        // guarantee that the key is finalized yet).  However, if someone acts on
+        // a ProviderLookup or ProviderInstanceBinding, it will properly find dependencies.
+        checkState(rehashed, "Dependencies can not be retrieved until the Injector has been "
+            + "created (or Elements.getElements finishes)");
+        // We depend on Provider<T>, not T directly.  This is an important distinction
+        // for dependency analysis tools that short-circuit on providers.
+        Key<?> providerKey = key.ofType(Types.providerOf(key.getTypeLiteral().getType()));
+        return ImmutableSet.<Dependency<?>>of(Dependency.get(providerKey));
+      }
 
       @Override public String toString() {
         return "Provider<" + key.getTypeLiteral() + ">";
@@ -102,6 +120,7 @@ public final class ProviderLookup<T> implements Element {
   RehashableKeys getKeyRehasher() {
     return new RehashableKeys() {
       @Override public void rehashKeys() {
+        rehashed = true;
         if (needsRehashing(key)) {
           key = rehash(key);
         }