diff --git a/extensions/privatemodules/src/com/google/inject/privatemodules/Exposed.java b/extensions/privatemodules/src/com/google/inject/privatemodules/Exposed.java
new file mode 100644
index 0000000..264af8c
--- /dev/null
+++ b/extensions/privatemodules/src/com/google/inject/privatemodules/Exposed.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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 com.google.inject.privatemodules;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+import java.lang.annotation.Target;
+import java.lang.annotation.Documented;
+
+/**
+ * Acccompanies a {@literal @}{@link com.google.inject.Provides Provides} method annotation in a
+ * private module to indicate that the provided binding is exposed.
+ *
+ * @author jessewilson@google.com (Jesse Wilson)
+ */
+@Target(ElementType.METHOD) @Retention(RUNTIME) @Documented
+public @interface Exposed {}
diff --git a/extensions/privatemodules/src/com/google/inject/privatemodules/PrivateModule.java b/extensions/privatemodules/src/com/google/inject/privatemodules/PrivateModule.java
index e6660b1..f469e41 100644
--- a/extensions/privatemodules/src/com/google/inject/privatemodules/PrivateModule.java
+++ b/extensions/privatemodules/src/com/google/inject/privatemodules/PrivateModule.java
@@ -20,27 +20,33 @@
 import static com.google.common.base.Preconditions.checkState;
 import com.google.common.collect.Sets;
 import com.google.inject.Binder;
+import com.google.inject.Binding;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
 import com.google.inject.Key;
 import com.google.inject.Module;
 import com.google.inject.Provider;
 import com.google.inject.Scope;
-import com.google.inject.Scopes;
 import com.google.inject.Stage;
 import com.google.inject.TypeLiteral;
 import com.google.inject.binder.AnnotatedBindingBuilder;
 import com.google.inject.binder.AnnotatedConstantBindingBuilder;
 import com.google.inject.binder.LinkedBindingBuilder;
+import com.google.inject.internal.ProviderMethod;
+import com.google.inject.internal.ProviderMethodsModule;
 import com.google.inject.internal.SourceProvider;
 import com.google.inject.internal.UniqueAnnotations;
 import com.google.inject.matcher.Matcher;
+import com.google.inject.spi.DefaultElementVisitor;
+import com.google.inject.spi.Element;
+import com.google.inject.spi.ElementVisitor;
 import com.google.inject.spi.Elements;
 import com.google.inject.spi.Message;
 import com.google.inject.spi.ModuleWriter;
 import com.google.inject.spi.TypeConverter;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
+import java.util.List;
 import java.util.Set;
 import org.aopalliance.intercept.MethodInterceptor;
 
@@ -69,15 +75,24 @@
     // otherwise we're being run for the private injector
     } else {
       checkState(this.privateBinder == null, "Re-entry is not allowed.");
-      this.privateBinder = binder.skipSources(PrivateModule.class);
+      privateBinder = binder.skipSources(PrivateModule.class);
       try {
         configurePrivateBindings();
 
+        ProviderMethodsModule providerMethodsModule = ProviderMethodsModule.forPrivateModule(this);
+        for (ProviderMethod<?> providerMethod
+            : providerMethodsModule.getProviderMethods(privateBinder)) {
+          providerMethod.configure(privateBinder);
+          if (providerMethod.getMethod().isAnnotationPresent(Exposed.class)) {
+            expose(providerMethod.getKey());
+          }
+        }
+
         for (Expose<?> expose : exposes) {
           expose.initPrivateProvider(binder);
         }
       } finally {
-        this.privateBinder = null;
+        privateBinder = null;
       }
     }
   }
@@ -87,10 +102,17 @@
     Key<Ready> readyKey = Key.get(Ready.class, UniqueAnnotations.create());
     readyProvider = publicBinder.getProvider(readyKey);
     try {
-      // gather elements and exposes from the private module by being re-entrant on configure()
-      final Module privateModule = new ModuleWriter().create(Elements.getElements(this));
+      List<Element> privateElements = Elements.getElements(this); // reentrant on configure()
+      Set<Key<?>> privatelyBoundKeys = getBoundKeys(privateElements);
+      final Module privateModule = new ModuleWriter().create(privateElements);
+
       for (Expose<?> expose : exposes) {
-        expose.configure(publicBinder);
+        if (!privatelyBoundKeys.contains(expose.key)) {
+          publicBinder.addError("Could not expose() at %s%n %s must be explicitly bound.", 
+              expose.source, expose.key);
+        } else {
+          expose.configure(publicBinder);
+        }
       }
 
       // create the private injector while the public injector is injecting its members
@@ -101,7 +123,7 @@
           publicInjector.createChildInjector(privateModule);
           return new Ready();
         }
-      }).in(Scopes.SINGLETON);
+      }).asEagerSingleton();
 
     } finally {
       readyProvider = null;
@@ -113,19 +135,19 @@
 
   public abstract void configurePrivateBindings();
 
-  protected <T> void expose(Key<T> key) {
+  protected final <T> void expose(Key<T> key) {
     checkState(exposes != null, "Cannot expose %s, private module is not ready");
     exposes.add(new Expose<T>(sourceProvider.get(), readyProvider, key));
   }
 
-  protected <T> ExposedKeyBuilder expose(Class<T> type) {
+  protected final <T> ExposedKeyBuilder expose(Class<T> type) {
     checkState(exposes != null, "Cannot expose %s, private module is not ready");
     Expose<T> expose = new Expose<T>(sourceProvider.get(), readyProvider, Key.get(type));
     exposes.add(expose);
     return expose;
   }
 
-  protected <T> ExposedKeyBuilder expose(TypeLiteral<T> type) {
+  protected final <T> ExposedKeyBuilder expose(TypeLiteral<T> type) {
     checkState(exposes != null, "Cannot expose %s, private module is not ready");
     Expose<T> expose = new Expose<T>(sourceProvider.get(), readyProvider, Key.get(type));
     exposes.add(expose);
@@ -164,7 +186,7 @@
 
     /** Sets the provider in the private injector, to be used by the public injector */
     private void initPrivateProvider(Binder privateBinder) {
-      privateProvider = privateBinder.getProvider(key);
+      privateProvider = privateBinder.withSource(source).getProvider(key);
     }
 
     /** Creates a binding in the public binder */
@@ -178,83 +200,102 @@
     }
   }
 
+  /**
+   * Returns the set of keys bound by {@code elements}.
+   */
+  private Set<Key<?>> getBoundKeys(Iterable<? extends Element> elements) {
+    final Set<Key<?>> privatelyBoundKeys = Sets.newHashSet();
+    ElementVisitor<Void> visitor = new DefaultElementVisitor<Void>() {
+      public <T> Void visitBinding(Binding<T> command) {
+        privatelyBoundKeys.add(command.getKey());
+        return null;
+      }
+    };
+
+    for (Element element : elements) {
+      element.acceptVisitor(visitor);
+    }
+
+    return privatelyBoundKeys;
+  }
+
   // everything below is copied from AbstractModule
 
-  protected Binder binder() {
+  protected final Binder binder() {
     return privateBinder;
   }
 
-  protected void bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope) {
+  protected final void bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope) {
     privateBinder.bindScope(scopeAnnotation, scope);
   }
 
-  protected <T> LinkedBindingBuilder<T> bind(Key<T> key) {
+  protected final <T> LinkedBindingBuilder<T> bind(Key<T> key) {
     return privateBinder.bind(key);
   }
 
-  protected <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) {
+  protected final <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) {
     return privateBinder.bind(typeLiteral);
   }
 
-  protected <T> AnnotatedBindingBuilder<T> bind(Class<T> clazz) {
+  protected final <T> AnnotatedBindingBuilder<T> bind(Class<T> clazz) {
     return privateBinder.bind(clazz);
   }
 
-  protected AnnotatedConstantBindingBuilder bindConstant() {
+  protected final AnnotatedConstantBindingBuilder bindConstant() {
     return privateBinder.bindConstant();
   }
 
-  protected void install(Module module) {
+  protected final void install(Module module) {
     privateBinder.install(module);
   }
 
-  protected void addError(String message, Object... arguments) {
+  protected final void addError(String message, Object... arguments) {
     privateBinder.addError(message, arguments);
   }
 
-  protected void addError(Throwable t) {
+  protected final void addError(Throwable t) {
     privateBinder.addError(t);
   }
 
-  protected void addError(Message message) {
+  protected final void addError(Message message) {
     privateBinder.addError(message);
   }
 
-  protected void requestInjection(Object... objects) {
+  protected final void requestInjection(Object... objects) {
     privateBinder.requestInjection(objects);
   }
 
-  protected void requestStaticInjection(Class<?>... types) {
+  protected final void requestStaticInjection(Class<?>... types) {
     privateBinder.requestStaticInjection(types);
   }
 
-  protected void bindInterceptor(Matcher<? super Class<?>> classMatcher,
+  protected final void bindInterceptor(Matcher<? super Class<?>> classMatcher,
       Matcher<? super Method> methodMatcher, MethodInterceptor... interceptors) {
     privateBinder.bindInterceptor(classMatcher, methodMatcher, interceptors);
   }
 
-  protected void requireBinding(Key<?> key) {
+  protected final void requireBinding(Key<?> key) {
     privateBinder.getProvider(key);
   }
 
-  protected void requireBinding(Class<?> type) {
+  protected final void requireBinding(Class<?> type) {
     privateBinder.getProvider(type);
   }
 
-  protected <T> Provider<T> getProvider(Key<T> key) {
+  protected final <T> Provider<T> getProvider(Key<T> key) {
     return privateBinder.getProvider(key);
   }
 
-  protected <T> Provider<T> getProvider(Class<T> type) {
+  protected final <T> Provider<T> getProvider(Class<T> type) {
     return privateBinder.getProvider(type);
   }
 
-  protected void convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher,
+  protected final void convertToTypes(Matcher<? super TypeLiteral<?>> typeMatcher,
       TypeConverter converter) {
     privateBinder.convertToTypes(typeMatcher, converter);
   }
 
-  protected Stage currentStage() {
+  protected final Stage currentStage() {
     return privateBinder.currentStage();
   }
 }
diff --git a/extensions/privatemodules/test/com/google/inject/privatemodules/PrivateModuleTest.java b/extensions/privatemodules/test/com/google/inject/privatemodules/PrivateModuleTest.java
index 913f7a8..3fcf1d4 100644
--- a/extensions/privatemodules/test/com/google/inject/privatemodules/PrivateModuleTest.java
+++ b/extensions/privatemodules/test/com/google/inject/privatemodules/PrivateModuleTest.java
@@ -17,10 +17,13 @@
 package com.google.inject.privatemodules;
 
 import com.google.inject.AbstractModule;
+import static com.google.inject.Asserts.assertContains;
+import com.google.inject.CreationException;
 import com.google.inject.Guice;
 import com.google.inject.Inject;
 import com.google.inject.Injector;
 import com.google.inject.Key;
+import com.google.inject.Provides;
 import com.google.inject.name.Named;
 import static com.google.inject.name.Names.named;
 import junit.framework.TestCase;
@@ -64,6 +67,120 @@
     assertEquals("ii", ab2.b);
   }
 
+  public void testPrivateModulesAndProvidesMethods() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      protected void configure() {
+        install(new PrivateModule() {
+          public void configurePrivateBindings() {
+            expose(String.class).annotatedWith(named("a"));
+          }
+
+          @Provides @Named("a") String providePublicA() {
+            return "i";
+          }
+
+          @Provides @Named("b") String providePrivateB() {
+            return "private";
+          }
+        });
+
+        install(new PrivateModule() {
+          public void configurePrivateBindings() {}
+
+          @Provides @Named("a") String providePrivateA() {
+            return "private";
+          }
+
+          @Provides @Exposed @Named("b") String providePublicB() {
+            return "ii";
+          }
+        });
+      }
+    });
+
+    assertEquals("i", injector.getInstance(Key.get(String.class, named("a"))));
+    assertEquals("ii", injector.getInstance(Key.get(String.class, named("b"))));
+  }
+
+  public void testCannotBindAKeyExportedByASibling() {
+    try {
+      Guice.createInjector(new AbstractModule() {
+        protected void configure() {
+          install(new PrivateModule() {
+            public void configurePrivateBindings() {
+              bind(String.class).toInstance("public");
+              expose(String.class);
+            }
+          });
+
+          install(new PrivateModule() {
+            public void configurePrivateBindings() {
+              bind(String.class).toInstance("private");
+            }
+          });
+        }
+      });
+      fail("KNOWN ISSUE: Binding to 'private' should conflict with binding to 'public'");
+    } catch (CreationException expected) {
+      assertContains(expected.getMessage(), "Cannot bind String");
+    }
+  }
+
+  public void testExposeButNoBind() {
+    try {
+      Guice.createInjector(new AbstractModule() {
+        protected void configure() {
+          bind(String.class).annotatedWith(named("a")).toInstance("a");
+          bind(String.class).annotatedWith(named("b")).toInstance("b");
+
+          install(new PrivateModule() {
+            public void configurePrivateBindings() {
+              expose(AB.class);
+            }
+          });
+        }
+      });
+      fail("AB was exposed but not bound");
+    } catch (CreationException expected) {
+      assertContains(expected.getMessage(), "Could not expose() at ",
+          PrivateModuleTest.class.getName(), ".configurePrivateBindings(PrivateModuleTest.java:",
+          Key.get(AB.class).toString(), " must be explicitly bound.");
+    }
+  }
+
+  public void testNestedPrivateInjectors() {
+    Injector injector = Guice.createInjector(new PrivateModule() {
+      public void configurePrivateBindings() {
+        expose(String.class);
+
+        install(new PrivateModule() {
+          public void configurePrivateBindings() {
+            bind(String.class).toInstance("nested");
+            expose(String.class);
+          }
+        });
+      }
+    });
+
+    assertEquals("nested", injector.getInstance(String.class));
+  }
+
+  public void testInstallingRegularModulesFromPrivateModules() {
+    Injector injector = Guice.createInjector(new PrivateModule() {
+      public void configurePrivateBindings() {
+        expose(String.class);
+
+        install(new AbstractModule() {
+          protected void configure() {
+            bind(String.class).toInstance("nested");
+          }
+        });
+      }
+    });
+
+    assertEquals("nested", injector.getInstance(String.class));
+  }
+
   static class AB {
     @Inject @Named("a") String a;
     @Inject @Named("b") String b;
diff --git a/src/com/google/inject/BindingProcessor.java b/src/com/google/inject/BindingProcessor.java
index 18d1617..78ad9f2 100644
--- a/src/com/google/inject/BindingProcessor.java
+++ b/src/com/google/inject/BindingProcessor.java
@@ -39,11 +39,11 @@
  */
 class BindingProcessor extends AbstractProcessor {
 
-  private BindingTargetVisitor<Object, Object> GET_BINDING_PROVIDER
-      = new DefaultBindingTargetVisitor<Object, Object>() {
-    public Object visitProvider(
-        Provider<?> provider, Set<InjectionPoint> injectionPoints) {
-      return provider;
+  /** Returns the class name of the bound provider, or null */
+  private BindingTargetVisitor<Object, String> GET_BOUND_PROVIDER_CLASS_NAME
+      = new DefaultBindingTargetVisitor<Object, String>() {
+    public String visitProvider(Provider<?> provider, Set<InjectionPoint> injectionPoints) {
+      return provider.getClass().getName();
     }
   };
 
@@ -257,8 +257,8 @@
 
     Binding<?> original = state.getExplicitBinding(key);
     if (original != null && !"com.google.inject.privatemodules.PrivateModule$Expose"
-        .equals(original.acceptTargetVisitor(GET_BINDING_PROVIDER).getClass().getName())) {
-      // the hard-coded class name is certainly lame, but it avoids an even lamer dependency... 
+        .equals(original.acceptTargetVisitor(GET_BOUND_PROVIDER_CLASS_NAME))) {
+      // the hard-coded class name is certainly lame, but it avoids an even lamer dependency...
       errors.bindingAlreadySet(key, original.getSource());
       return;
     }
@@ -277,12 +277,13 @@
       AbstractModule.class,
       Binder.class,
       Binding.class,
+      Injector.class,
       Key.class,
       Module.class,
       Provider.class, 
       Scope.class,
       TypeLiteral.class);
-  // TODO(jessewilson): fix BuiltInModule, then add Injector and Stage
+  // TODO(jessewilson): fix BuiltInModule, then add Stage
 
   interface CreationListener {
     void notify(InjectorImpl injector, Errors errors);
diff --git a/src/com/google/inject/internal/Errors.java b/src/com/google/inject/internal/Errors.java
index e3a3cb3..e3689b7 100644
--- a/src/com/google/inject/internal/Errors.java
+++ b/src/com/google/inject/internal/Errors.java
@@ -111,7 +111,7 @@
       TypeLiteral<?> type, MatcherAndConverter matchingConverter) {
     return addMessage("Received null converting '%s' (bound at %s) to %s%n"
         + " using %s.",
-        stringValue, source, type, matchingConverter);
+        stringValue, sourceToString(source), type, matchingConverter);
   }
 
   public Errors conversionTypeError(String stringValue, Object source, TypeLiteral<?> type,
@@ -119,7 +119,7 @@
     return addMessage("Type mismatch converting '%s' (bound at %s) to %s%n"
         + " using %s.%n"
         + " Converter returned %s.",
-        stringValue, source, type, matchingConverter, converted);
+        stringValue, sourceToString(source), type, matchingConverter, converted);
   }
 
   public Errors conversionError(String stringValue, Object source,
@@ -127,7 +127,7 @@
     return addMessage(cause, "Error converting '%s' (bound at %s) to %s%n" 
         + " using %s.%n"
         + " Reason: %s",
-        stringValue, source, type, matchingConverter, cause);
+        stringValue, sourceToString(source), type, matchingConverter, cause);
   }
 
   public Errors ambiguousTypeConversion(String stringValue, Object source, TypeLiteral<?> type,
@@ -136,7 +136,7 @@
         + " %s and%n"
         + " %s.%n"
         + " Please adjust your type converter configuration to avoid overlapping matches.",
-        stringValue, source, type, a, b);
+        stringValue, sourceToString(source), type, a, b);
   }
 
   public Errors bindingToProvider() {
@@ -162,7 +162,7 @@
 
   public Errors missingRuntimeRetention(Object source) {
     return addMessage("Please annotate with @Retention(RUNTIME).%n"
-        + " Bound at %s.", source);
+        + " Bound at %s.", sourceToString(source));
   }
 
   public Errors missingScopeAnnotation() {
@@ -185,7 +185,7 @@
   public Errors scopeAnnotationOnAbstractType(
       Class<? extends Annotation> scopeAnnotation, Class<?> type, Object source) {
     return addMessage("%s is annotated with %s, but scope annotations are not supported "
-        + "for abstract types.%n Bound at %s.", type, scopeAnnotation, source);
+        + "for abstract types.%n Bound at %s.", type, scopeAnnotation, sourceToString(source));
   }
 
   public Errors misplacedBindingAnnotation(Member member, Annotation bindingAnnotation) {
@@ -238,7 +238,7 @@
   }
 
   public Errors bindingAlreadySet(Key<?> key, Object source) {
-    return addMessage("A binding to %s was already configured at %s.", key, source);
+    return addMessage("A binding to %s was already configured at %s.", key, sourceToString(source));
   }
 
   public Errors childBindingAlreadySet(Key<?> key) {
diff --git a/src/com/google/inject/internal/ProviderMethod.java b/src/com/google/inject/internal/ProviderMethod.java
new file mode 100644
index 0000000..a371f8a
--- /dev/null
+++ b/src/com/google/inject/internal/ProviderMethod.java
@@ -0,0 +1,88 @@
+/**
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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 com.google.inject.internal;
+
+import com.google.inject.Provider;
+import com.google.inject.Key;
+import com.google.inject.Binder;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+/**
+ * A provider that invokes a method and returns its result.
+ *
+ * @author jessewilson@google.com (Jesse Wilson)
+ */
+public class ProviderMethod<T> implements Provider<T> {
+  // TODO: this should be a top-level implementation of Binding
+
+  private final Key<T> key;
+  private final Class<? extends Annotation> scopeAnnotation;
+  private final Object instance;
+  private final Method method;
+  private final List<Provider<?>> parameterProviders;
+
+  /**
+   * @param method the method to invoke. It's return type must be the same type as {@code key}.
+   */
+  ProviderMethod(Key<T> key, Method method, Object instance,
+      List<Provider<?>> parameterProviders, Class<? extends Annotation> scopeAnnotation) {
+    this.key = key;
+    this.scopeAnnotation = scopeAnnotation;
+    this.instance = instance;
+    this.method = method;
+    this.parameterProviders = parameterProviders;
+
+    method.setAccessible(true);
+  }
+
+  public Key<T> getKey() {
+    return key;
+  }
+
+  public Method getMethod() {
+    return method;
+  }
+
+  public void configure(Binder binder) {
+    if (scopeAnnotation != null) {
+      binder.bind(key).toProvider(this).in(scopeAnnotation);
+    } else {
+      binder.bind(key).toProvider(this);
+    }
+  }
+
+  public T get() {
+    Object[] parameters = new Object[parameterProviders.size()];
+    for (int i = 0; i < parameters.length; i++) {
+      parameters[i] = parameterProviders.get(i).get();
+    }
+
+    try {
+      // We know this cast is safe becase T is the method's return type.
+      @SuppressWarnings({ "unchecked", "UnnecessaryLocalVariable" })
+      T result = (T) method.invoke(instance, parameters);
+      return result;
+    } catch (IllegalAccessException e) {
+      throw new AssertionError(e);
+    } catch (InvocationTargetException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}
diff --git a/src/com/google/inject/internal/ProviderMethodsModule.java b/src/com/google/inject/internal/ProviderMethodsModule.java
new file mode 100644
index 0000000..d102d63
--- /dev/null
+++ b/src/com/google/inject/internal/ProviderMethodsModule.java
@@ -0,0 +1,136 @@
+/**
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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 com.google.inject.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.collect.Lists;
+import com.google.inject.Binder;
+import com.google.inject.Key;
+import com.google.inject.Module;
+import com.google.inject.Provider;
+import com.google.inject.Provides;
+import com.google.inject.TypeLiteral;
+import com.google.inject.spi.Message;
+import com.google.inject.util.Modules;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.List;
+
+/**
+ * Creates bindings to methods annotated with {@literal @}{@link Provides}. Use the scope and
+ * binding annotations on the provider method to configure the binding.
+ *
+ * @author crazybob@google.com (Bob Lee)
+ */
+public final class ProviderMethodsModule implements Module {
+  private final Module delegate;
+  private final TypeResolver typeResolver;
+
+  private ProviderMethodsModule(Module delegate) {
+    this.delegate = checkNotNull(delegate, "delegate");
+    this.typeResolver = new TypeResolver(this.delegate.getClass());
+  }
+
+  /**
+   * Returns a module which creates bindings for provider methods from the given module.
+   */
+  public static Module forModule(Module module) {
+    // avoid infinite recursion, since installing a module always installs itself
+    if (module instanceof ProviderMethodsModule) {
+      return Modules.EMPTY_MODULE;
+    }
+
+    // don't install provider methods for private modules, they take care of that manually
+    for (Class<?> c = module.getClass(); c != Object.class; c = c.getSuperclass()) {
+      // use the ugly class name to avoid an even uglier dependency. If private modules ever get
+      // incorporated into core, we could use a single instanceof instead of this loop
+      if (c.getName().equals("com.google.inject.privatemodules.PrivateModule")) {
+        return Modules.EMPTY_MODULE;
+      }
+    }
+
+    return new ProviderMethodsModule(module);
+  }
+
+  /** See {@link com.google.inject.privatemodules.PrivateModule}. */
+  public static ProviderMethodsModule forPrivateModule(Module privateModule) {
+    return new ProviderMethodsModule(privateModule);
+  }
+
+  public synchronized void configure(Binder binder) {
+    for (ProviderMethod<?> providerMethod : getProviderMethods(binder)) {
+      providerMethod.configure(binder);
+    }
+  }
+
+  public List<ProviderMethod<?>> getProviderMethods(Binder binder) {
+    List<ProviderMethod<?>> result = Lists.newArrayList();
+    for (Class c = delegate.getClass(); c != Object.class; c = c.getSuperclass()) {
+      for (Method method : c.getDeclaredMethods()) {
+        if (method.isAnnotationPresent(Provides.class)) {
+          result.add(createProviderMethod(binder, method));
+        }
+      }
+    }
+    return result;
+  }
+
+  <T> ProviderMethod<T> createProviderMethod(Binder binder, final Method method) {
+    binder = binder.withSource(method);
+    Errors errors = new Errors(method);
+
+    // prepare the parameter providers
+    List<Provider<?>> parameterProviders = Lists.newArrayList();
+    List<Type> parameterTypes = typeResolver.getParameterTypes(method);
+    Annotation[][] parameterAnnotations = method.getParameterAnnotations();
+    for (int i = 0; i < parameterTypes.size(); i++) {
+      Key<?> key = getKey(errors, TypeLiteral.get(parameterTypes.get(i)),
+          method, parameterAnnotations[i]);
+      parameterProviders.add(binder.getProvider(key));
+    }
+
+    // Define T as the method's return type.
+    @SuppressWarnings("unchecked") TypeLiteral<T> returnType
+        = (TypeLiteral<T>) TypeLiteral.get(typeResolver.getReturnType(method));
+
+    Key<T> key = getKey(errors, returnType, method, method.getAnnotations());
+    Class<? extends Annotation> scopeAnnotation
+        = Annotations.findScopeAnnotation(errors, method.getAnnotations());
+
+    for (Message message : errors.getMessages()) {
+      binder.addError(message);
+    }
+
+    return new ProviderMethod<T>(key, method, delegate, parameterProviders, scopeAnnotation);
+  }
+
+  <T> Key<T> getKey(Errors errors, TypeLiteral<T> type, Member member, Annotation[] annotations) {
+    Annotation bindingAnnotation = Annotations.findBindingAnnotation(errors, member, annotations);
+    return bindingAnnotation == null ? Key.get(type) : Key.get(type, bindingAnnotation);
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof ProviderMethodsModule
+        && ((ProviderMethodsModule) o).delegate == delegate;
+  }
+
+  @Override public int hashCode() {
+    return delegate.hashCode();
+  }
+}
diff --git a/src/com/google/inject/spi/Elements.java b/src/com/google/inject/spi/Elements.java
index 025674c..1b66e7a 100644
--- a/src/com/google/inject/spi/Elements.java
+++ b/src/com/google/inject/spi/Elements.java
@@ -32,6 +32,7 @@
 import com.google.inject.binder.AnnotatedBindingBuilder;
 import com.google.inject.binder.AnnotatedConstantBindingBuilder;
 import com.google.inject.internal.ModuleBinding;
+import com.google.inject.internal.ProviderMethodsModule;
 import com.google.inject.internal.SourceProvider;
 import com.google.inject.matcher.Matcher;
 import java.lang.annotation.Annotation;
@@ -157,7 +158,7 @@
         } catch (RuntimeException e) {
           addError(e);
         }
-        install(ProviderMethods.from(module));
+        install(ProviderMethodsModule.forModule(module));
       }
     }