diff --git a/src/com/google/inject/BindingProcessor.java b/src/com/google/inject/BindingProcessor.java
index 78ad9f2..d141ae3 100644
--- a/src/com/google/inject/BindingProcessor.java
+++ b/src/com/google/inject/BindingProcessor.java
@@ -162,10 +162,9 @@
 
         FactoryProxy<T> factory = new FactoryProxy<T>(key, targetKey, source);
         creationListeners.add(factory);
-        InternalFactory<? extends T> scopedFactory
-            = Scopes.scope(key, injector, factory, scope);
+        InternalFactory<? extends T> scopedFactory = Scopes.scope(key, injector, factory, scope);
         putBinding(new LinkedBindingImpl<T>(
-                injector, key, source, scopedFactory, scope, targetKey, loadStrategy));
+            injector, key, source, scopedFactory, scope, targetKey, loadStrategy));
         return null;
       }
 
diff --git a/src/com/google/inject/BoundProviderFactory.java b/src/com/google/inject/BoundProviderFactory.java
index 397aeeb..705dd4e 100644
--- a/src/com/google/inject/BoundProviderFactory.java
+++ b/src/com/google/inject/BoundProviderFactory.java
@@ -20,8 +20,6 @@
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
 import com.google.inject.spi.Dependency;
-import com.google.inject.spi.Message;
-import java.util.Collection;
 
 /**
  * Delegates to a custom factory which is also bound in the injector.
@@ -49,11 +47,12 @@
 
   public T get(Errors errors, InternalContext context, Dependency<?> dependency)
       throws ErrorsException {
+    errors = errors.withSource(providerKey);
     Provider<? extends T> provider = providerFactory.get(errors, context, dependency);
     try {
       return errors.checkForNull(provider.get(), source, dependency);
     } catch(RuntimeException userException) {
-      throw errors.withSource(source).errorInProvider(userException).toException();
+      throw errors.errorInProvider(userException).toException();
     }
   }
 
diff --git a/src/com/google/inject/ConstructionProxyFactory.java b/src/com/google/inject/ConstructionProxyFactory.java
index 792645d..af404ef 100644
--- a/src/com/google/inject/ConstructionProxyFactory.java
+++ b/src/com/google/inject/ConstructionProxyFactory.java
@@ -16,8 +16,6 @@
 
 package com.google.inject;
 
-import com.google.inject.internal.Errors;
-import com.google.inject.internal.ErrorsException;
 import com.google.inject.spi.InjectionPoint;
 
 /**
@@ -32,6 +30,5 @@
    *
    * @param injectionPoint an injection point whose member is a constructor of {@code T}.
    */
-  <T> ConstructionProxy<T> get(Errors errors, InjectionPoint injectionPoint)
-      throws ErrorsException;
+  <T> ConstructionProxy<T> get(InjectionPoint injectionPoint);
 }
diff --git a/src/com/google/inject/ConstructorInjector.java b/src/com/google/inject/ConstructorInjector.java
index de36367..eb5233b 100644
--- a/src/com/google/inject/ConstructorInjector.java
+++ b/src/com/google/inject/ConstructorInjector.java
@@ -16,48 +16,48 @@
 
 package com.google.inject;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
-import com.google.inject.InjectorImpl.SingleMemberInjector;
-import com.google.inject.InjectorImpl.SingleParameterInjector;
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
 import com.google.inject.spi.InjectionPoint;
 import java.lang.reflect.InvocationTargetException;
-import java.util.List;
 
 /**
- * Injects constructors.
+ * Creates instances using an injectable constructor. After construction, all injectable fields and
+ * methods are injected.
  *
  * @author crazybob@google.com (Bob Lee)
  */
 class ConstructorInjector<T> {
 
   final Class<T> implementation;
-  final SingleMemberInjector[] memberInjectors;
-  final SingleParameterInjector<?>[] parameterInjectors;
+  final InjectionPoint injectionPoint;
+  final ImmutableList<SingleMemberInjector> memberInjectors;
+  final ImmutableList<SingleParameterInjector<?>> parameterInjectors;
   final ConstructionProxy<T> constructionProxy;
 
   ConstructorInjector(Errors errors, InjectorImpl injector, Class<T> implementation)
       throws ErrorsException {
     this.implementation = implementation;
-    constructionProxy = injector.reflection.getConstructionProxy(errors, implementation);
-    parameterInjectors = createParameterInjector(errors, injector, constructionProxy);
-    List<SingleMemberInjector> memberInjectorsList = injector.injectors.get(implementation, errors);
-    memberInjectors = memberInjectorsList.toArray(
-        new SingleMemberInjector[memberInjectorsList.size()]);
-  }
 
-  SingleParameterInjector<?>[] createParameterInjector(Errors errors,
-      InjectorImpl injector, ConstructionProxy<T> constructionProxy)
-      throws ErrorsException {
-    return injector.getParametersInjectors(constructionProxy.getInjectionPoint(), errors);
+    try {
+      this.injectionPoint = InjectionPoint.forConstructorOf(implementation);
+    } catch (ConfigurationException e) {
+      throw errors.merge(e.getErrorMessages()).toException();
+    }
+
+    constructionProxy = injector.constructionProxyFactory.get(injectionPoint);
+    parameterInjectors = injector.getParametersInjectors(injectionPoint.getDependencies(), errors);
+    memberInjectors = injector.injectors.get(implementation, errors);
   }
 
   ImmutableSet<InjectionPoint> getInjectionPoints() {
-    InjectionPoint[] injectionPoints = new InjectionPoint[memberInjectors.length + 1];
+    InjectionPoint[] injectionPoints = new InjectionPoint[memberInjectors.size() + 1];
     injectionPoints[0] = constructionProxy.getInjectionPoint();
-    for (int i = 0; i < memberInjectors.length; i++) {
-      injectionPoints[i+1] = memberInjectors[i].getInjectionPoint();
+    int i = 1;
+    for (SingleMemberInjector memberInjector : memberInjectors) {
+      injectionPoints[i++] = memberInjector.getInjectionPoint();
     }
     return ImmutableSet.of(injectionPoints);
   }
@@ -87,11 +87,10 @@
       // First time through...
       constructionContext.startConstruction();
       try {
-        Object[] parameters = InjectorImpl.getParameters(errors, context, parameterInjectors);
+        Object[] parameters = SingleParameterInjector.getAll(errors, context, parameterInjectors);
         t = constructionProxy.newInstance(parameters);
         constructionContext.setProxyDelegates(t);
-      }
-      finally {
+      } finally {
         constructionContext.finishConstruction();
       }
 
@@ -100,7 +99,7 @@
       constructionContext.setCurrentReference(t);
 
       // Inject fields and methods.
-      for (InjectorImpl.SingleMemberInjector injector : memberInjectors) {
+      for (SingleMemberInjector injector : memberInjectors) {
         injector.inject(errors, context, t);
       }
 
diff --git a/src/com/google/inject/DefaultConstructionProxyFactory.java b/src/com/google/inject/DefaultConstructionProxyFactory.java
index eaadba9..20099cf 100644
--- a/src/com/google/inject/DefaultConstructionProxyFactory.java
+++ b/src/com/google/inject/DefaultConstructionProxyFactory.java
@@ -18,7 +18,6 @@
 
 import com.google.inject.internal.BytecodeGen.Visibility;
 import static com.google.inject.internal.BytecodeGen.newFastClass;
-import com.google.inject.internal.Errors;
 import com.google.inject.spi.InjectionPoint;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
@@ -35,7 +34,7 @@
  */
 class DefaultConstructionProxyFactory implements ConstructionProxyFactory {
 
-  public <T> ConstructionProxy<T> get(Errors errors, final InjectionPoint injectionPoint) {
+  public <T> ConstructionProxy<T> get(final InjectionPoint injectionPoint) {
     @SuppressWarnings("unchecked") // the injection point is for a constructor of T
     final Constructor<T> constructor = (Constructor<T>) injectionPoint.getMember();
 
@@ -43,14 +42,13 @@
     if (!Modifier.isPublic(constructor.getModifiers())) {
       constructor.setAccessible(true);
       return new ConstructionProxy<T>() {
-        public T newInstance(Object... arguments) throws
-            InvocationTargetException {
+        public T newInstance(Object... arguments) throws InvocationTargetException {
           try {
             return constructor.newInstance(arguments);
           } catch (InstantiationException e) {
-            throw new RuntimeException(e);
+            throw new AssertionError(e); // shouldn't happen, we know this is a concrete type
           } catch (IllegalAccessException e) {
-            throw new AssertionError(e);
+            throw new AssertionError(e); // a security manager is blocking us, we're hosed
           }
         }
         public InjectionPoint getInjectionPoint() {
diff --git a/src/com/google/inject/FactoryProxy.java b/src/com/google/inject/FactoryProxy.java
index c5135c6..fef74ea 100644
--- a/src/com/google/inject/FactoryProxy.java
+++ b/src/com/google/inject/FactoryProxy.java
@@ -50,7 +50,7 @@
 
   public T get(Errors errors, InternalContext context, Dependency<?> dependency)
       throws ErrorsException {
-    return targetFactory.get(errors, context, dependency);
+    return targetFactory.get(errors.withSource(targetKey), context, dependency);
   }
 
   @Override public String toString() {
diff --git a/src/com/google/inject/Initializer.java b/src/com/google/inject/Initializer.java
index 13242a9..7003bff 100644
--- a/src/com/google/inject/Initializer.java
+++ b/src/com/google/inject/Initializer.java
@@ -22,7 +22,7 @@
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
 import com.google.inject.spi.InjectionPoint;
-import com.google.inject.InjectorImpl.SingleMemberInjector;
+import com.google.inject.SingleMemberInjector;
 import java.util.Map;
 import java.util.Set;
 import java.util.List;
diff --git a/src/com/google/inject/InjectionRequestProcessor.java b/src/com/google/inject/InjectionRequestProcessor.java
index 4c71367..39858cb 100644
--- a/src/com/google/inject/InjectionRequestProcessor.java
+++ b/src/com/google/inject/InjectionRequestProcessor.java
@@ -19,7 +19,6 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
-import com.google.inject.InjectorImpl.SingleMemberInjector;
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
 import com.google.inject.spi.InjectionPoint;
diff --git a/src/com/google/inject/InjectorBuilder.java b/src/com/google/inject/InjectorBuilder.java
index 7c67b2f..cf47351 100644
--- a/src/com/google/inject/InjectorBuilder.java
+++ b/src/com/google/inject/InjectorBuilder.java
@@ -20,7 +20,6 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import com.google.inject.Reflection.Factory;
 import static com.google.inject.Scopes.SINGLETON;
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
@@ -48,7 +47,6 @@
 
   private InjectorImpl parent = null;
   private Stage stage;
-  private Factory reflectionFactory = new RuntimeReflectionFactory();
   private final List<Module> modules = Lists.newLinkedList();
 
   private InjectorImpl injector;
@@ -68,11 +66,6 @@
     return this;
   }
 
-  InjectorBuilder usingReflectionFactory(Factory reflectionFactory) {
-    this.reflectionFactory = reflectionFactory;
-    return this;
-  }
-
   InjectorBuilder parentInjector(InjectorImpl parent) {
     this.parent = parent;
     return this;
@@ -128,8 +121,7 @@
     InterceptorBindingProcessor interceptorCommandProcessor
         = new InterceptorBindingProcessor(errors, injector.state);
     interceptorCommandProcessor.processCommands(elements);
-    ConstructionProxyFactory proxyFactory = interceptorCommandProcessor.createProxyFactory();
-    injector.reflection = reflectionFactory.create(proxyFactory);
+    injector.constructionProxyFactory = interceptorCommandProcessor.createProxyFactory();
     stopwatch.resetAndLog("Interceptors creation");
 
     new ScopeBindingProcessor(errors, injector.state).processCommands(elements);
@@ -197,17 +189,16 @@
           || binding.getLoadStrategy() == LoadStrategy.EAGER) {
         try {
           injector.callInContext(new ContextualCallable<Void>() {
+            Dependency<?> dependency = Dependency.get(binding.key);
             public Void call(InternalContext context) {
-              Dependency<?> dependency = Dependency.get(binding.key);
               context.setDependency(dependency);
-              errors.pushSource(dependency);
+              Errors errorsForBinding = errors.withSource(dependency);
               try {
-                binding.internalFactory.get(errors, context, dependency);
+                binding.internalFactory.get(errorsForBinding, context, dependency);
               } catch (ErrorsException e) {
-                errors.merge(e.getErrors());
+                errorsForBinding.merge(e.getErrors());
               } finally {
                 context.setDependency(null);
-                errors.popSource(dependency);
               }
 
               return null;
diff --git a/src/com/google/inject/InjectorImpl.java b/src/com/google/inject/InjectorImpl.java
index 6261c0d..c1691da 100644
--- a/src/com/google/inject/InjectorImpl.java
+++ b/src/com/google/inject/InjectorImpl.java
@@ -24,8 +24,6 @@
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
 import com.google.inject.internal.Annotations;
-import com.google.inject.internal.BytecodeGen.Visibility;
-import static com.google.inject.internal.BytecodeGen.newFastClass;
 import com.google.inject.internal.Classes;
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
@@ -42,15 +40,12 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Member;
-import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import net.sf.cglib.reflect.FastClass;
-import net.sf.cglib.reflect.FastMethod;
 
 /**
  * Default {@link Injector} implementation.
@@ -63,7 +58,7 @@
   final InjectorImpl parent;
   final BindingsMultimap bindingsMultimap = new BindingsMultimap();
   final Initializer initializer = new Initializer(this);
-  Reflection reflection;
+  ConstructionProxyFactory constructionProxyFactory;
 
   InjectorImpl(@Nullable InjectorImpl parent) {
     this.parent = parent;
@@ -97,10 +92,10 @@
 
   /** Returns the binding for {@code key} */
   public <T> BindingImpl<T> getBinding(Key<T> key) {
-    Errors errors = new Errors(key.getRawType());
+    Errors errors = new Errors(key);
     try {
       BindingImpl<T> result = getBindingOrThrow(key, errors);
-      errors.throwConfigurationExceptionIfNecessary();
+      errors.throwConfigurationExceptionIfErrorsExist();
       return result;
     } catch (ErrorsException e) {
       throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
@@ -209,7 +204,6 @@
   }
 
   static class ProviderBindingImpl<T> extends BindingImpl<Provider<T>> {
-
     final BindingImpl<T> providedBinding;
 
     ProviderBindingImpl(
@@ -284,11 +278,9 @@
       }
 
       return new ConvertedConstantBindingImpl<T>(this, key, converted, stringBinding);
-    }
-    catch (ErrorsException e) {
+    } catch (ErrorsException e) {
       throw e;
-    }
-    catch (Exception e) {
+    } catch (Exception e) {
       throw errors.conversionError(stringValue, source, type, matchingConverter, e)
           .toException();
     }
@@ -359,7 +351,7 @@
       LoadStrategy loadStrategy, Errors errors) throws ErrorsException {
     // Don't try to inject arrays, or enums.
     if (type.isArray() || type.isEnum()) {
-      throw errors.missingImplementation(type).toException();
+      throw errors.missingImplementation(key).toException();
     }
 
     // Handle @ImplementedBy
@@ -444,28 +436,28 @@
       throw errors.recursiveProviderType().toException();
     }
 
-    // TODO: Make sure the provided type extends type. We at least check the type at runtime below.
-
     // Assume the provider provides an appropriate type. We double check at runtime.
     @SuppressWarnings("unchecked")
-    Key<? extends Provider<T>> providerKey = (Key<? extends Provider<T>>) Key.get(providerType);
+    final Key<? extends Provider<T>> providerKey
+        = (Key<? extends Provider<T>>) Key.get(providerType);
     final BindingImpl<? extends Provider<?>> providerBinding
         = getBindingOrThrow(providerKey, errors);
 
     InternalFactory<T> internalFactory = new InternalFactory<T>() {
       public T get(Errors errors, InternalContext context, Dependency dependency)
           throws ErrorsException {
+        errors = errors.withSource(providerKey);
         Provider<?> provider = providerBinding.internalFactory.get(errors, context, dependency);
         try {
           Object o = provider.get();
           if (o != null && !type.isInstance(o)) {
-            throw errors.withSource(type).subtypeNotProvided(providerType, type).toException();
+            throw errors.subtypeNotProvided(providerType, type).toException();
           }
           @SuppressWarnings("unchecked") // protected by isInstance() check above
           T t = (T) o;
           return t;
         } catch (RuntimeException e) {
-          throw errors.withSource(type).errorInProvider(e).toException();
+          throw errors.errorInProvider(e).toException();
         }
       }
     };
@@ -497,17 +489,17 @@
       throw errors.notASubtype(implementationType, type).toException();
     }
 
-    // After the preceding check, this cast is safe.
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings("unchecked") // After the preceding check, this cast is safe.
     Class<? extends T> subclass = (Class<? extends T>) implementationType;
 
     // Look up the target binding.
-    final BindingImpl<? extends T> targetBinding = getBindingOrThrow(Key.get(subclass), errors);
+    final Key<? extends T> targetKey = Key.get(subclass);
+    final BindingImpl<? extends T> targetBinding = getBindingOrThrow(targetKey, errors);
 
     InternalFactory<T> internalFactory = new InternalFactory<T>() {
       public T get(Errors errors, InternalContext context, Dependency<?> dependency)
           throws ErrorsException {
-        return targetBinding.internalFactory.get(errors, context, dependency);
+        return targetBinding.internalFactory.get(errors.withSource(targetKey), context, dependency);
       }
     };
 
@@ -517,8 +509,7 @@
         key,
         type,
         Scopes.<T>scope(key, this, internalFactory, scope),
-        scope,
-        Key.get(subclass),
+        scope, targetKey,
         loadStrategy);
   }
 
@@ -585,9 +576,9 @@
   }
 
   /** Cached field and method injectors for a type. */
-  final FailableCache<Class<?>, List<SingleMemberInjector>> injectors
-      = new FailableCache<Class<?>, List<SingleMemberInjector>>() {
-    protected List<SingleMemberInjector> create(Class<?> type, Errors errors)
+  final FailableCache<Class<?>, ImmutableList<SingleMemberInjector>> injectors
+      = new FailableCache<Class<?>, ImmutableList<SingleMemberInjector>>() {
+    protected ImmutableList<SingleMemberInjector> create(Class<?> type, Errors errors)
         throws ErrorsException {
       List<InjectionPoint> injectionPoints = Lists.newArrayList();
       try {
@@ -609,10 +600,10 @@
       try {
         Errors errorsForMember = injectionPoint.isOptional()
             ? new Errors(injectionPoint)
-            : errors;
+            : errors.withSource(injectionPoint);
         SingleMemberInjector injector = injectionPoint.getMember() instanceof Field
-            ? new SingleFieldInjector(errorsForMember, this, injectionPoint)
-            : new SingleMethodInjector(errorsForMember, this, injectionPoint);
+            ? new SingleFieldInjector(this, injectionPoint, errorsForMember)
+            : new SingleMethodInjector(this, injectionPoint, errorsForMember);
         injectors.add(injector);
       } catch (ErrorsException ignoredForNow) {
       }
@@ -644,152 +635,35 @@
     }
   }
 
-  class SingleFieldInjector implements SingleMemberInjector {
-    final Field field;
-    final InternalFactory<?> factory;
-    final InjectionPoint injectionPoint;
-    final Dependency<?> dependency;
-
-    public SingleFieldInjector(Errors errors, InjectorImpl injector, InjectionPoint injectionPoint)
-        throws ErrorsException {
-      this.injectionPoint = injectionPoint;
-      this.field = (Field) injectionPoint.getMember();
-      this.dependency = injectionPoint.getDependencies().get(0);
-
-      // Ewwwww...
-      field.setAccessible(true);
-      factory = injector.getInternalFactory(dependency.getKey(), errors.withSource(dependency));
-    }
-
-    public InjectionPoint getInjectionPoint() {
-      return injectionPoint;
-    }
-
-    public void inject(Errors errors, InternalContext context, Object o) {
-      context.setDependency(dependency);
-      errors.pushSource(dependency);
-      try {
-        Object value = factory.get(errors, context, dependency);
-        field.set(o, value);
-      }
-      catch (IllegalAccessException e) {
-        throw new AssertionError(e);
-      }
-      catch (ErrorsException e) {
-        errors.merge(e.getErrors());
-      }
-      finally {
-        context.setDependency(null);
-        errors.popSource(dependency);
-      }
-    }
-  }
-
   /**
    * Returns parameter injectors, or {@code null} if there are no parameters.
    */
-  SingleParameterInjector<?>[] getParametersInjectors(InjectionPoint injectionPoint, Errors errors)
-      throws ErrorsException {
-    errors.pushSource(injectionPoint);
-    try {
-      Member member = injectionPoint.getMember();
-      Annotation misplacedBindingAnnotation = Annotations.findBindingAnnotation(
-          errors, member, ((AnnotatedElement) member).getAnnotations());
-      if (misplacedBindingAnnotation != null) {
-        errors.misplacedBindingAnnotation(member, misplacedBindingAnnotation);
-      }
-    } finally {
-      errors.popSource(injectionPoint);
-    }
-
-    List<Dependency<?>> parameters = injectionPoint.getDependencies();
+  ImmutableList<SingleParameterInjector<?>> getParametersInjectors(
+      List<Dependency<?>> parameters, Errors errors) throws ErrorsException {
     if (parameters.isEmpty()) {
       return null;
     }
 
-    SingleParameterInjector<?>[] parameterInjectors
-        = new SingleParameterInjector<?>[parameters.size()];
-    int index = 0;
+    SingleParameterInjector<?>[] result = new SingleParameterInjector<?>[parameters.size()];
+    int i = 0;
     for (Dependency<?> parameter : parameters) {
-      errors.pushSource(parameter);
       try {
-        parameterInjectors[index] = createParameterInjector(parameter, errors);
+        result[i++] = createParameterInjector(parameter, errors.withSource(parameter));
       } catch (ErrorsException rethrownBelow) {
         // rethrown below
-      } finally {
-        errors.popSource(parameter);
       }
-      index++;
     }
 
     errors.throwIfNecessary();
-    return parameterInjectors;
+    return ImmutableList.of(result);
   }
 
   <T> SingleParameterInjector<T> createParameterInjector(final Dependency<T> dependency,
       final Errors errors) throws ErrorsException {
-    InternalFactory<? extends T> factory
-        = getInternalFactory(dependency.getKey(), errors.withSource(dependency));
+    InternalFactory<? extends T> factory = getInternalFactory(dependency.getKey(), errors);
     return new SingleParameterInjector<T>(dependency, factory);
   }
 
-  static class SingleMethodInjector implements SingleMemberInjector {
-    final MethodInvoker methodInvoker;
-    final SingleParameterInjector<?>[] parameterInjectors;
-    final InjectionPoint injectionPoint;
-
-    public SingleMethodInjector(Errors errors, InjectorImpl injector, InjectionPoint injectionPoint)
-        throws ErrorsException {
-      this.injectionPoint = injectionPoint;
-      final Method method = (Method) injectionPoint.getMember();
-
-      // We can't use FastMethod if the method is private.
-      if (Modifier.isPrivate(method.getModifiers())
-          || Modifier.isProtected(method.getModifiers())) {
-        method.setAccessible(true);
-        methodInvoker = new MethodInvoker() {
-          public Object invoke(Object target, Object... parameters)
-              throws IllegalAccessException, InvocationTargetException {
-            return method.invoke(target, parameters);
-          }
-        };
-      } else {
-        FastClass fastClass = newFastClass(method.getDeclaringClass(),
-            Visibility.forMember(method));
-        final FastMethod fastMethod = fastClass.getMethod(method);
-
-        methodInvoker = new MethodInvoker() {
-          public Object invoke(Object target, Object... parameters)
-              throws IllegalAccessException, InvocationTargetException {
-            return fastMethod.invoke(target, parameters);
-          }
-        };
-      }
-
-      parameterInjectors = injector.getParametersInjectors(injectionPoint, errors);
-    }
-
-    public void inject(Errors errors, InternalContext context, Object o) {
-      try {
-        Object[] parameters = getParameters(errors, context, parameterInjectors);
-        methodInvoker.invoke(o, parameters);
-      } catch (IllegalAccessException e) {
-        throw new AssertionError(e);
-      } catch (InvocationTargetException userException) {
-        Throwable cause = userException.getCause() != null
-            ? userException.getCause()
-            : userException;
-        errors.withSource(injectionPoint).errorInjectingMethod(cause);
-      } catch (ErrorsException e) {
-        errors.merge(e.getErrors());
-      }
-    }
-
-    public InjectionPoint getInjectionPoint() {
-      return injectionPoint;
-    }
-  }
-
   /** Invokes a method. */
   interface MethodInvoker {
     Object invoke(Object target, Object... parameters)
@@ -800,54 +674,11 @@
   final FailableCache<Class<?>, ConstructorInjector<?>> constructors
       = new FailableCache<Class<?>, ConstructorInjector<?>>() {
     @SuppressWarnings("unchecked")
-    protected ConstructorInjector<?> create(Class<?> key, Errors errors) throws ErrorsException {
-      return new ConstructorInjector(errors, InjectorImpl.this, key);
+    protected ConstructorInjector<?> create(Class<?> type, Errors errors) throws ErrorsException {
+      return new ConstructorInjector(errors, InjectorImpl.this, type);
     }
   };
 
-  static class SingleParameterInjector<T> {
-    final Dependency<T> dependency;
-    final InternalFactory<? extends T> factory;
-
-    public SingleParameterInjector(Dependency<T> dependency,
-        InternalFactory<? extends T> factory) {
-      this.dependency = dependency;
-      this.factory = factory;
-    }
-
-    T inject(Errors errors, InternalContext context) throws ErrorsException {
-      context.setDependency(dependency);
-      errors.pushSource(dependency);
-      try {
-        return factory.get(errors, context, dependency);
-      }
-      finally {
-        errors.popSource(dependency);
-        context.setDependency(null);
-      }
-    }
-  }
-
-  /** Iterates over parameter injectors and creates an array of parameter values. */
-  static Object[] getParameters(Errors errors, InternalContext context,
-      SingleParameterInjector[] parameterInjectors) throws ErrorsException {
-    if (parameterInjectors == null) {
-      return null;
-    }
-
-    Object[] parameters = new Object[parameterInjectors.length];
-    for (int i = 0; i < parameters.length; i++) {
-      try {
-        parameters[i] = parameterInjectors[i].inject(errors, context);
-      } catch (ErrorsException e) {
-        errors.merge(e.getErrors());
-      }
-    }
-
-    errors.throwIfNecessary();
-    return parameters;
-  }
-
   void injectMembers(Errors errors, Object o, InternalContext context,
       List<SingleMemberInjector> injectors)
       throws ErrorsException {
@@ -858,7 +689,7 @@
 
   // Not test-covered
   public void injectMembers(final Object o) {
-    Errors errors = new Errors();
+    Errors errors = new Errors(o.getClass());
 
     // configuration/validation stuff throws ConfigurationException
     List<SingleMemberInjector> injectors;
@@ -899,21 +730,19 @@
 
   <T> Provider<T> getProviderOrThrow(final Key<T> key, Errors errors) throws ErrorsException {
     final InternalFactory<? extends T> factory = getInternalFactory(key, errors);
+    final Dependency<T> dependency = Dependency.get(key);
 
     return new Provider<T>() {
       public T get() {
-        final Errors errors = new Errors();
+        final Errors errors = new Errors(dependency);
         try {
           T t = callInContext(new ContextualCallable<T>() {
             public T call(InternalContext context) throws ErrorsException {
-              Dependency<T> dependency = Dependency.get(key);
               context.setDependency(dependency);
-              errors.pushSource(dependency);
               try {
                 return factory.get(errors, context, dependency);
               } finally {
                 context.setDependency(null);
-                errors.popSource(dependency);
               }
             }
           });
@@ -931,7 +760,7 @@
   }
 
   public <T> Provider<T> getProvider(final Key<T> key) {
-    Errors errors = new Errors(key.getRawType());
+    Errors errors = new Errors(key);
     try {
       Provider<T> result = getProviderOrThrow(key, errors);
       errors.throwIfNecessary();
@@ -969,12 +798,6 @@
     }
   }
 
-  /** Injects a field or method in a given object. */
-  public interface SingleMemberInjector {
-    void inject(Errors errors, InternalContext context, Object o);
-    InjectionPoint getInjectionPoint();
-  }
-
   public String toString() {
     return new ToStringBuilder(Injector.class)
         .add("bindings", state.getExplicitBindingsThisLevel())
diff --git a/src/com/google/inject/InternalFactoryToProviderAdapter.java b/src/com/google/inject/InternalFactoryToProviderAdapter.java
index df0b594..a218c1a 100644
--- a/src/com/google/inject/InternalFactoryToProviderAdapter.java
+++ b/src/com/google/inject/InternalFactoryToProviderAdapter.java
@@ -21,8 +21,6 @@
 import com.google.inject.internal.ErrorsException;
 import com.google.inject.internal.SourceProvider;
 import com.google.inject.spi.Dependency;
-import com.google.inject.spi.Message;
-import java.util.Collection;
 
 /**
  * @author crazybob@google.com (Bob Lee)
diff --git a/src/com/google/inject/ProxyFactory.java b/src/com/google/inject/ProxyFactory.java
index eef3aef..153fcc7 100644
--- a/src/com/google/inject/ProxyFactory.java
+++ b/src/com/google/inject/ProxyFactory.java
@@ -21,9 +21,7 @@
 import com.google.inject.internal.BytecodeGen.Visibility;
 import static com.google.inject.internal.BytecodeGen.newEnhancer;
 import static com.google.inject.internal.BytecodeGen.newFastClass;
-import com.google.inject.internal.Errors;
-import com.google.inject.internal.ErrorsException;
-import com.google.inject.internal.FailableCache;
+import com.google.inject.internal.ReferenceCache;
 import com.google.inject.spi.InjectionPoint;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
@@ -55,21 +53,19 @@
   }
 
   @SuppressWarnings("unchecked") // the constructed T is the same as the injection point's T
-  public <T> ConstructionProxy<T> get(Errors errors, InjectionPoint injectionPoint)
-      throws ErrorsException {
-    return (ConstructionProxy<T>) constructionProxies.get(injectionPoint, errors);
+  public <T> ConstructionProxy<T> get(InjectionPoint injectionPoint) {
+    return (ConstructionProxy<T>) constructionProxies.get(injectionPoint);
   }
 
   /** Cached construction proxies for each injection point */
-  FailableCache<InjectionPoint, ConstructionProxy> constructionProxies
-      = new FailableCache<InjectionPoint, ConstructionProxy>() {
-    protected ConstructionProxy create(InjectionPoint key, Errors errors) throws ErrorsException {
-      return createConstructionProxy(errors, key);
+  ReferenceCache<InjectionPoint, ConstructionProxy> constructionProxies
+      = new ReferenceCache<InjectionPoint, ConstructionProxy>() {
+    protected ConstructionProxy create(InjectionPoint key) {
+      return createConstructionProxy(key);
     }
   };
 
-  <T> ConstructionProxy<T> createConstructionProxy(Errors errors, InjectionPoint injectionPoint)
-      throws ErrorsException {
+  <T> ConstructionProxy<T> createConstructionProxy(InjectionPoint injectionPoint) {
     @SuppressWarnings("unchecked") // the member of injectionPoint is always a Constructor<T>
     Constructor<T> constructor = (Constructor<T>) injectionPoint.getMember();
     Class<T> declaringClass = constructor.getDeclaringClass();
@@ -82,7 +78,7 @@
       }
     }
     if (applicableAspects.isEmpty()) {
-      return defaultFactory.get(errors, injectionPoint);
+      return defaultFactory.get(injectionPoint);
     }
 
     // Get list of methods from cglib.
@@ -115,21 +111,20 @@
     }
     if (!anyMatched) {
       // not test-covered
-      return defaultFactory.get(errors, injectionPoint);
+      return defaultFactory.get(injectionPoint);
     }
 
     // Create callbacks.
     Callback[] callbacks = new Callback[methods.size()];
 
-    @SuppressWarnings("unchecked") Class<? extends Callback>[] callbackTypes = new Class[methods
-        .size()];
+    @SuppressWarnings("unchecked")
+    Class<? extends Callback>[] callbackTypes = new Class[methods.size()];
     for (int i = 0; i < methods.size(); i++) {
       MethodInterceptorsPair pair = methodInterceptorsPairs.get(i);
       if (!pair.hasInterceptors()) {
         callbacks[i] = NoOp.INSTANCE;
         callbackTypes[i] = NoOp.class;
-      }
-      else {
+      } else {
         callbacks[i] = new InterceptorStackCallback(pair.method, pair.interceptors);
         callbackTypes[i] = net.sf.cglib.proxy.MethodInterceptor.class;
       }
@@ -156,7 +151,7 @@
    * Creates a construction proxy given a class and parameter types.
    */
   private <T> ConstructionProxy<T> createConstructionProxy(final Class<?> clazz,
-      final InjectionPoint injectionPoint) throws ErrorsException {
+      final InjectionPoint injectionPoint) {
     @SuppressWarnings("unchecked") // injection point's member must be a Constructor<T>
     final Constructor<T> standardConstructor = (Constructor<T>) injectionPoint.getMember();
     FastClass fastClass = newFastClass(clazz, Visibility.PUBLIC);
diff --git a/src/com/google/inject/Reflection.java b/src/com/google/inject/Reflection.java
index f0f14c7..71f9931 100644
--- a/src/com/google/inject/Reflection.java
+++ b/src/com/google/inject/Reflection.java
@@ -17,22 +17,34 @@
 
 package com.google.inject;
 
-import com.google.inject.internal.Errors;
-import com.google.inject.internal.ErrorsException;
+import java.lang.reflect.Constructor;
 
 /**
- * Abstraction for Java's reflection APIs. This interface exists to provide a
- * single place where runtime reflection can be substituted for another
- * mechanism such as CGLib or compile-time code generation.
+ * Abstraction for Java's reflection APIs. This interface exists to provide a single place where
+ * runtime reflection can be substituted for another mechanism such as CGLib or compile-time code
+ * generation.
  *
  * @author jessewilson@google.com (Jesse Wilson)
  */
-interface Reflection {
+class Reflection {
 
-  public <T> ConstructionProxy<T> getConstructionProxy(Errors errors, Class<T> implementation)
-      throws ErrorsException;
+  /**
+   * A placeholder. This enables us to continue processing and gather more
+   * errors but blows up if you actually try to use it.
+   */
+  static class InvalidConstructor {
+    InvalidConstructor() {
+      throw new AssertionError();
+    }
+  }
 
-  interface Factory {
-    Reflection create(ConstructionProxyFactory constructionProxyFactory);
+  @SuppressWarnings("unchecked")
+  static <T> Constructor<T> invalidConstructor() {
+    try {
+      return (Constructor<T>) InvalidConstructor.class.getDeclaredConstructor();
+    }
+    catch (NoSuchMethodException e) {
+      throw new AssertionError(e);
+    }
   }
 }
diff --git a/src/com/google/inject/RuntimeReflectionFactory.java b/src/com/google/inject/RuntimeReflectionFactory.java
deleted file mode 100644
index 0bca520..0000000
--- a/src/com/google/inject/RuntimeReflectionFactory.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * 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;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import com.google.inject.internal.Errors;
-import com.google.inject.internal.ErrorsException;
-import com.google.inject.spi.InjectionPoint;
-import java.lang.reflect.Constructor;
-
-/**
- * @author jessewilson@google.com (Jesse Wilson)
- */
-class RuntimeReflectionFactory implements Reflection.Factory {
-  public Reflection create(ConstructionProxyFactory constructionProxyFactory) {
-    return new RuntimeReflection(constructionProxyFactory);
-  }
-
-  private static class RuntimeReflection implements Reflection {
-    private final ConstructionProxyFactory constructionProxyFactory;
-
-    private RuntimeReflection(ConstructionProxyFactory constructionProxyFactory) {
-      this.constructionProxyFactory
-          = checkNotNull(constructionProxyFactory, "constructionProxyFatory");
-    }
-
-    public <T> ConstructionProxy<T> getConstructionProxy(Errors errors, Class<T> implementation)
-        throws ErrorsException {
-      InjectionPoint injectionPoint;
-      try {
-        injectionPoint = InjectionPoint.forConstructorOf(implementation);
-      } catch (ConfigurationException e) {
-        throw errors.merge(e.getErrorMessages()).toException();
-      }
-
-      errors = errors.withSource(injectionPoint);
-      return constructionProxyFactory.get(errors, injectionPoint);
-    }
-
-    /**
-     * A placeholder. This enables us to continue processing and gather more
-     * errors but blows up if you actually try to use it.
-     */
-    static class InvalidConstructor {
-      InvalidConstructor() {
-        throw new AssertionError();
-      }
-    }
-
-    @SuppressWarnings("unchecked")
-    static <T> Constructor<T> invalidConstructor() {
-      try {
-        return (Constructor<T>) InvalidConstructor.class.getDeclaredConstructor();
-      }
-      catch (NoSuchMethodException e) {
-        throw new AssertionError(e);
-      }
-    }
-  }
-}
diff --git a/src/com/google/inject/SingleFieldInjector.java b/src/com/google/inject/SingleFieldInjector.java
new file mode 100644
index 0000000..cff31fb
--- /dev/null
+++ b/src/com/google/inject/SingleFieldInjector.java
@@ -0,0 +1,64 @@
+/**
+ * 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;
+
+import com.google.inject.internal.Errors;
+import com.google.inject.internal.ErrorsException;
+import com.google.inject.spi.Dependency;
+import com.google.inject.spi.InjectionPoint;
+import java.lang.reflect.Field;
+
+/**
+ * Sets an injectable field.
+ */
+class SingleFieldInjector implements SingleMemberInjector {
+  final Field field;
+  final InjectionPoint injectionPoint;
+  final Dependency<?> dependency;
+  final InternalFactory<?> factory;
+
+  public SingleFieldInjector(InjectorImpl injector, InjectionPoint injectionPoint, Errors errors)
+      throws ErrorsException {
+    this.injectionPoint = injectionPoint;
+    this.field = (Field) injectionPoint.getMember();
+    this.dependency = injectionPoint.getDependencies().get(0);
+
+    // Ewwwww...
+    field.setAccessible(true);
+    factory = injector.getInternalFactory(dependency.getKey(), errors);
+  }
+
+  public InjectionPoint getInjectionPoint() {
+    return injectionPoint;
+  }
+
+  public void inject(Errors errors, InternalContext context, Object o) {
+    errors = errors.withSource(dependency);
+
+    context.setDependency(dependency);
+    try {
+      Object value = factory.get(errors, context, dependency);
+      field.set(o, value);
+    } catch (ErrorsException e) {
+      errors.withSource(injectionPoint).merge(e.getErrors());
+    } catch (IllegalAccessException e) {
+      throw new AssertionError(e); // a security manager is blocking us, we're hosed
+    } finally {
+      context.setDependency(null);
+    }
+  }
+}
diff --git a/src/com/google/inject/SingleMemberInjector.java b/src/com/google/inject/SingleMemberInjector.java
new file mode 100644
index 0000000..7b19845
--- /dev/null
+++ b/src/com/google/inject/SingleMemberInjector.java
@@ -0,0 +1,28 @@
+/**
+ * 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;
+
+import com.google.inject.internal.Errors;
+import com.google.inject.spi.InjectionPoint;
+
+/**
+ * Injects a field or method of a given object.
+ */
+public interface SingleMemberInjector {
+  void inject(Errors errors, InternalContext context, Object o);
+  InjectionPoint getInjectionPoint();
+}
diff --git a/src/com/google/inject/SingleMethodInjector.java b/src/com/google/inject/SingleMethodInjector.java
new file mode 100644
index 0000000..56c402e
--- /dev/null
+++ b/src/com/google/inject/SingleMethodInjector.java
@@ -0,0 +1,95 @@
+/**
+ * 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;
+
+import com.google.common.collect.ImmutableList;
+import com.google.inject.InjectorImpl.MethodInvoker;
+import com.google.inject.internal.BytecodeGen;
+import com.google.inject.internal.BytecodeGen.Visibility;
+import com.google.inject.internal.Errors;
+import com.google.inject.internal.ErrorsException;
+import com.google.inject.spi.InjectionPoint;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import net.sf.cglib.reflect.FastClass;
+import net.sf.cglib.reflect.FastMethod;
+
+/**
+ * Invokes an injectable method.
+ */
+class SingleMethodInjector implements SingleMemberInjector {
+  final MethodInvoker methodInvoker;
+  final ImmutableList<SingleParameterInjector<?>> parameterInjectors;
+  final InjectionPoint injectionPoint;
+
+  public SingleMethodInjector(InjectorImpl injector, InjectionPoint injectionPoint, Errors errors)
+      throws ErrorsException {
+    this.injectionPoint = injectionPoint;
+    final Method method = (Method) injectionPoint.getMember();
+
+    // We can't use FastMethod if the method is private.
+    int modifiers = method.getModifiers();
+    if (Modifier.isPrivate(modifiers) || Modifier.isProtected(modifiers)) {
+      method.setAccessible(true);
+      methodInvoker = new MethodInvoker() {
+        public Object invoke(Object target, Object... parameters)
+            throws IllegalAccessException, InvocationTargetException {
+          return method.invoke(target, parameters);
+        }
+      };
+    } else {
+      FastClass fastClass = BytecodeGen.newFastClass(
+          method.getDeclaringClass(), Visibility.forMember(method));
+      final FastMethod fastMethod = fastClass.getMethod(method);
+
+      methodInvoker = new MethodInvoker() {
+        public Object invoke(Object target, Object... parameters)
+            throws IllegalAccessException, InvocationTargetException {
+          return fastMethod.invoke(target, parameters);
+        }
+      };
+    }
+
+    parameterInjectors = injector.getParametersInjectors(injectionPoint.getDependencies(), errors);
+  }
+
+  public InjectionPoint getInjectionPoint() {
+    return injectionPoint;
+  }
+
+  public void inject(Errors errors, InternalContext context, Object o) {
+    Object[] parameters;
+    try {
+      parameters = SingleParameterInjector.getAll(errors, context, parameterInjectors);
+    } catch (ErrorsException e) {
+      errors.merge(e.getErrors());
+      return;
+    }
+
+    try {
+      methodInvoker.invoke(o, parameters);
+    } catch (IllegalAccessException e) {
+      throw new AssertionError(e); // a security manager is blocking us, we're hosed
+    } catch (InvocationTargetException userException) {
+      Throwable cause = userException.getCause() != null
+          ? userException.getCause()
+          : userException;
+      errors.withSource(injectionPoint).errorInjectingMethod(cause);
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/com/google/inject/SingleParameterInjector.java b/src/com/google/inject/SingleParameterInjector.java
new file mode 100644
index 0000000..27b6855
--- /dev/null
+++ b/src/com/google/inject/SingleParameterInjector.java
@@ -0,0 +1,68 @@
+/**
+ * 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;
+
+import com.google.inject.spi.Dependency;
+import com.google.inject.internal.Errors;
+import com.google.inject.internal.ErrorsException;
+import java.util.List;
+
+/**
+ * Resolves a single parameter, to be used in a constructor or method invocation.
+ */
+class SingleParameterInjector<T> {
+  private final Dependency<T> dependency;
+  private final InternalFactory<? extends T> factory;
+
+  SingleParameterInjector(Dependency<T> dependency, InternalFactory<? extends T> factory) {
+    this.dependency = dependency;
+    this.factory = factory;
+  }
+
+  private T inject(Errors errors, InternalContext context) throws ErrorsException {
+    context.setDependency(dependency);
+    try {
+      return factory.get(errors.withSource(dependency), context, dependency);
+    } finally {
+      context.setDependency(null);
+    }
+  }
+
+  /**
+   * Returns an array of parameter values.
+   */
+  static Object[] getAll(Errors errors, InternalContext context,
+      List<SingleParameterInjector<?>> parameterInjectors) throws ErrorsException {
+    if (parameterInjectors == null) {
+      return null;
+    }
+
+    Object[] parameters = new Object[parameterInjectors.size()];
+
+    int i = 0;
+    for (SingleParameterInjector<?> parameterInjector : parameterInjectors) {
+      try {
+        parameters[i++] = parameterInjector.inject(errors, context);
+      } catch (ErrorsException e) {
+        errors.merge(e.getErrors());
+      }
+    }
+
+    errors.throwIfNecessary();
+    return parameters;
+  }
+}
diff --git a/src/com/google/inject/internal/Errors.java b/src/com/google/inject/internal/Errors.java
index 8ae3ad1..cb28901 100644
--- a/src/com/google/inject/internal/Errors.java
+++ b/src/com/google/inject/internal/Errors.java
@@ -16,8 +16,6 @@
 
 package com.google.inject.internal;
 
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.inject.ConfigurationException;
@@ -37,18 +35,26 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Member;
-import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Formatter;
-import java.util.Iterator;
 import java.util.List;
 
 /**
  * A collection of error messages. If this type is passed as a method parameter, the method is
  * considered to have executed succesfully only if new errors were not added to this collection.
  *
+ * <p>Errors can be chained to provide additional context. To add context, call {@link #withSource}
+ * to create a new Errors instance that contains additional context. All messages added to the
+ * returned instance will contain full context.
+ *
+ * <p>To avoid messages with redundant context, {@link #withSource} should be added sparingly. A
+ * good rule of thumb is to assume a ethod's caller has already specified enough context to
+ * identify that method. When calling a method that's defined in a different context, call that
+ * method with an errors object that includes its context.
+ *
  * @author jessewilson@google.com (Jesse Wilson)
  */
 public final class Errors implements Serializable {
@@ -57,23 +63,26 @@
   private static final boolean allowNullsBadBadBad
       = "I'm a bad hack".equals(System.getProperty("guice.allow.nulls.bad.bad.bad"));
 
-  private List<Message> errors;
-  private final List<Object> sources;
+  private final List<Message> errors;
+  private final Errors parent;
+  private final Object source;
 
   public Errors() {
-    sources = Lists.newArrayList();
-    errors = Lists.newArrayList();
+    this.errors = Lists.newArrayList();
+    this.parent = null;
+    this.source = SourceProvider.UNKNOWN_SOURCE;
   }
 
   public Errors(Object source) {
-    sources = Lists.newArrayList(source);
-    errors = Lists.newArrayList();
+    this.errors = Lists.newArrayList();
+    this.parent = null;
+    this.source = source;
   }
 
   private Errors(Errors parent, Object source) {
-    errors = parent.errors;
-    sources = Lists.newArrayList(parent.sources);
-    sources.add(source);
+    this.errors = parent.errors;
+    this.parent = parent;
+    this.source = source;
   }
 
   /**
@@ -85,15 +94,6 @@
         : new Errors(this, source);
   }
 
-  public void pushSource(Object source) {
-    sources.add(source);
-  }
-
-  public void popSource(Object source) {
-    Object popped = sources.remove(sources.size() - 1);
-    checkArgument(source == popped);
-  }
-
   /**
    * We use a fairly generic error message here. The motivation is to share the
    * same message for both bind time errors:
@@ -107,15 +107,15 @@
    * Otherwise we need to know who's calling when resolving a just-in-time
    * binding, which makes things unnecessarily complex.
    */
-  public Errors missingImplementation(Object keyOrType) {
-    return addMessage("No implementation for %s was bound.", keyOrType);
+  public Errors missingImplementation(Key key) {
+    return addMessage("No implementation for %s was bound.", key);
   }
 
   public Errors converterReturnedNull(String stringValue, Object source,
       TypeLiteral<?> type, MatcherAndConverter matchingConverter) {
     return addMessage("Received null converting '%s' (bound at %s) to %s%n"
         + " using %s.",
-        stringValue, sourceToString(source), type, matchingConverter);
+        stringValue, convert(source), type, matchingConverter);
   }
 
   public Errors conversionTypeError(String stringValue, Object source, TypeLiteral<?> type,
@@ -123,7 +123,7 @@
     return addMessage("Type mismatch converting '%s' (bound at %s) to %s%n"
         + " using %s.%n"
         + " Converter returned %s.",
-        stringValue, sourceToString(source), type, matchingConverter, converted);
+        stringValue, convert(source), type, matchingConverter, converted);
   }
 
   public Errors conversionError(String stringValue, Object source,
@@ -131,7 +131,7 @@
     return addMessage(cause, "Error converting '%s' (bound at %s) to %s%n" 
         + " using %s.%n"
         + " Reason: %s",
-        stringValue, sourceToString(source), type, matchingConverter, cause);
+        stringValue, convert(source), type, matchingConverter, cause);
   }
 
   public Errors ambiguousTypeConversion(String stringValue, Object source, TypeLiteral<?> type,
@@ -140,7 +140,7 @@
         + " %s and%n"
         + " %s.%n"
         + " Please adjust your type converter configuration to avoid overlapping matches.",
-        stringValue, sourceToString(source), type, a, b);
+        stringValue, convert(source), type, a, b);
   }
 
   public Errors bindingToProvider() {
@@ -166,7 +166,7 @@
 
   public Errors missingRuntimeRetention(Object source) {
     return addMessage("Please annotate with @Retention(RUNTIME).%n"
-        + " Bound at %s.", sourceToString(source));
+        + " Bound at %s.", convert(source));
   }
 
   public Errors missingScopeAnnotation() {
@@ -189,7 +189,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, sourceToString(source));
+        + "for abstract types.%n Bound at %s.", type, scopeAnnotation, convert(source));
   }
 
   public Errors misplacedBindingAnnotation(Member member, Annotation bindingAnnotation) {
@@ -242,7 +242,7 @@
   }
 
   public Errors bindingAlreadySet(Key<?> key, Object source) {
-    return addMessage("A binding to %s was already configured at %s.", key, sourceToString(source));
+    return addMessage("A binding to %s was already configured at %s.", key, convert(source));
   }
 
   public Errors childBindingAlreadySet(Key<?> key) {
@@ -286,12 +286,15 @@
         expectedType);
   }
 
-  public Errors makeImmutable() {
-    errors = ImmutableList.copyOf(errors);
-    return this;
+  public void throwCreationExceptionIfErrorsExist() {
+    if (!hasErrors()) {
+      return;
+    }
+
+    throw new CreationException(getMessages());
   }
 
-  public void throwConfigurationExceptionIfNecessary() {
+  public void throwConfigurationExceptionIfErrorsExist() {
     if (!hasErrors()) {
       return;
     }
@@ -307,36 +310,37 @@
     throw new ProvisionException(getMessages());
   }
 
-  public void throwCreationExceptionIfErrorsExist() {
-    if (!hasErrors()) {
-      return;
-    }
-
-    makeImmutable();
-    throw new CreationException(getMessages());
-  }
-
   private Message merge(Message message) {
     List<Object> sources = Lists.newArrayList();
-    sources.addAll(this.sources);
+    sources.addAll(getSources());
     sources.addAll(message.getSources());
-    return new Message(stripDuplicates(sources), message.getMessage(), message.getCause());
+    return new Message(sources, message.getMessage(), message.getCause());
   }
 
   public Errors merge(Collection<Message> messages) {
-    if (messages != this.errors) {
-      for (Message message : messages) {
-        errors.add(merge(message));
-      }
+    for (Message message : messages) {
+      errors.add(merge(message));
     }
     return this;
   }
 
   public Errors merge(Errors moreErrors) {
+    if (moreErrors.errors == errors) {
+      return this;
+    }
+
     merge(moreErrors.errors);
     return this;
   }
 
+  public List<Object> getSources() {
+    List<Object> sources = Lists.newArrayList();
+    for (Errors e = this; e != null; e = e.parent) {
+      sources.add(0, e.source);
+    }
+    return sources;
+  }
+
   public void throwIfNecessary() throws ErrorsException {
     if (!hasErrors()) {
       return;
@@ -359,7 +363,7 @@
 
   private Errors addMessage(Throwable cause, String messageFormat, Object... arguments) {
     String message = format(messageFormat, arguments);
-    addMessage(new Message(stripDuplicates(sources), message, cause));
+    addMessage(new Message(getSources(), message, cause));
     return this;
   }
 
@@ -399,28 +403,7 @@
       List<Object> dependencies = errorMessage.getSources();
       for (int i = dependencies.size() - 1; i >= 0; i--) {
         Object source = dependencies.get(i);
-
-        if (source instanceof Dependency) {
-          Dependency<?> dependency = (Dependency<?>) source;
-
-          InjectionPoint injectionPoint = dependency.getInjectionPoint();
-          if (injectionPoint != null) {
-            Member member = injectionPoint.getMember();
-            Class<? extends Member> memberType = MoreTypes.memberType(member);
-            if (memberType == Field.class) {
-              fmt.format("  for field at %s%n", StackTraceElements.forMember(member));
-            } else if (memberType == Method.class || memberType == Constructor.class) {
-              fmt.format("  for parameter %s at %s%n",
-                  dependency.getParameterIndex(), StackTraceElements.forMember(member));
-            } else {
-              throw new AssertionError();
-            }
-          } else {
-            fmt.format("  while locating %s%n", convert(dependency.getKey()));
-          }
-        }
-
-        fmt.format("  at %s%n", sourceToString(source));
+        formatSource(fmt, source);
       }
 
       Throwable cause = errorMessage.getCause();
@@ -506,11 +489,6 @@
   }
 
   private static final Collection<Converter<?>> converters = ImmutableList.of(
-      new Converter<MatcherAndConverter>(MatcherAndConverter.class) {
-        public String toString(MatcherAndConverter m) {
-          return m.toString();
-        }
-      },
       new Converter<Class>(Class.class) {
         public String toString(Class c) {
           return c.getName();
@@ -522,14 +500,13 @@
         }
       },
       new Converter<Key>(Key.class) {
-        public String toString(Key k) {
-          StringBuilder result = new StringBuilder();
-          result.append(k.getTypeLiteral());
-          if (k.getAnnotationType() != null) {
-            result.append(" annotated with ");
-            result.append(k.getAnnotation() != null ? k.getAnnotation() : k.getAnnotationType());
+        public String toString(Key key) {
+          if (key.getAnnotationType() != null) {
+            return key.getTypeLiteral() + " annotated with "
+                + (key.getAnnotation() != null ? key.getAnnotation() : key.getAnnotationType());
+          } else {
+            return key.getTypeLiteral().toString();
           }
-          return result.toString();
         }
       });
 
@@ -542,40 +519,58 @@
     return o;
   }
 
-  /**
-   * This method returns a String that indicates an element source. We do a
-   * best effort to include a line number in this String.
-   */
-  public static String sourceToString(Object source) {
-    checkNotNull(source, "source");
+  public static void formatSource(Formatter formatter, Object source) {
+    if (source instanceof Dependency) {
+      Dependency<?> dependency = (Dependency<?>) source;
+      InjectionPoint injectionPoint = dependency.getInjectionPoint();
+      if (injectionPoint != null) {
+        formatInjectionPoint(formatter, dependency, injectionPoint);
+      } else {
+        formatSource(formatter, dependency.getKey());
+      }
 
-    if (source instanceof InjectionPoint) {
-      return sourceToString(((InjectionPoint) source).getMember());
-    } else if (source instanceof Member) {
-      return StackTraceElements.forMember((Member) source).toString();
+    } else if (source instanceof InjectionPoint) {
+      formatInjectionPoint(formatter, null, (InjectionPoint) source);
+
     } else if (source instanceof Class) {
-      return StackTraceElements.forType(((Class<?>) source)).toString();
+      formatter.format("  at %s%n", StackTraceElements.forType((Class<?>) source));
+
+    } else if (source instanceof Member) {
+      formatter.format("  at %s%n", StackTraceElements.forMember((Member) source));
+
+    } else if (source instanceof Key) {
+      Key<?> key = (Key<?>) source;
+      Type type = key.getTypeLiteral().getType();
+      if (key.getAnnotationType() != null) {
+        formatter.format("  at binding for %s annotated with %s%n", MoreTypes.toString(type),
+            (key.getAnnotation() != null ? key.getAnnotation() : key.getAnnotationType()));
+
+      } else if (type instanceof Class) {
+        formatter.format("  at binding for %s%n", StackTraceElements.forType((Class<?>) type));
+
+      } else {
+          formatter.format("  at binding for %s%n", type);
+
+      }
     } else {
-      return convert(source).toString();
+      formatter.format("  at %s%n", source);
     }
   }
-  
-  /**
-   * Removes consecutive duplicates, so that [A B B C D A] becomes [A B C D A].
-   */
-  private <T> List<T> stripDuplicates(List<T> list) {
-    list = Lists.newArrayList(list);
 
-    Iterator i = list.iterator();
-    if (i.hasNext()) {
-      for (Object last = i.next(), current; i.hasNext(); last = current) {
-        current = i.next();
-        if (last.equals(current)) {
-          i.remove();
-        }
-      }
+  public static void formatInjectionPoint(Formatter formatter, Dependency<?> dependency,
+      InjectionPoint injectionPoint) {
+    Member member = injectionPoint.getMember();
+    Class<? extends Member> memberType = MoreTypes.memberType(member);
+
+    if (memberType == Field.class) {
+      formatter.format("  for field at %s%n", StackTraceElements.forMember(member));
+
+    } else if (dependency != null) {
+      formatter.format("  for parameter %s at %s%n",
+          dependency.getParameterIndex(), StackTraceElements.forMember(member));
+
+    } else {
+      formatSource(formatter, injectionPoint.getMember());
     }
-
-    return ImmutableList.copyOf(list);
   }
 }
diff --git a/src/com/google/inject/internal/FailableCache.java b/src/com/google/inject/internal/FailableCache.java
index 72a4bdf..b252b31 100644
--- a/src/com/google/inject/internal/FailableCache.java
+++ b/src/com/google/inject/internal/FailableCache.java
@@ -33,7 +33,7 @@
       } catch (ErrorsException e) {
         errors.merge(e.getErrors());
       }
-      return errors.hasErrors() ? errors.makeImmutable() : result;
+      return errors.hasErrors() ? errors : result;
     }
   };
 
diff --git a/src/com/google/inject/spi/InjectionPoint.java b/src/com/google/inject/spi/InjectionPoint.java
index 3376a63..f31f627 100644
--- a/src/com/google/inject/spi/InjectionPoint.java
+++ b/src/com/google/inject/spi/InjectionPoint.java
@@ -94,7 +94,7 @@
     } catch (ErrorsException e) {
       errors.merge(e.getErrors());
     }
-    errors.throwConfigurationExceptionIfNecessary();
+    errors.throwConfigurationExceptionIfErrorsExist();
 
     this.dependencies = ImmutableList.<Dependency<?>>of(
         newDependency(key, Nullability.allowsNull(annotations), -1));
@@ -118,7 +118,7 @@
       }
     }
 
-    errors.throwConfigurationExceptionIfNecessary();
+    errors.throwConfigurationExceptionIfErrorsExist();
     return ImmutableList.copyOf(dependencies);
   }
 
@@ -185,7 +185,7 @@
   public static InjectionPoint forConstructorOf(Class<?> type) {
     Errors errors = new Errors(type);
 
-    Constructor<?> found = null;
+    Constructor<?> injectableConstructor = null;
     for (Constructor<?> constructor : type.getDeclaredConstructors()) {
       Inject inject = constructor.getAnnotation(Inject.class);
       if (inject != null) {
@@ -193,33 +193,34 @@
           errors.optionalConstructor(constructor);
         }
 
-        if (found != null) {
+        if (injectableConstructor != null) {
           errors.tooManyConstructors(type);
         }
 
-        found = constructor;
+        injectableConstructor = constructor;
+        checkForMisplacedBindingAnnotations(injectableConstructor, errors);
       }
     }
 
-    errors.throwConfigurationExceptionIfNecessary();
+    errors.throwConfigurationExceptionIfErrorsExist();
 
-    if (found != null) {
-      return new InjectionPoint(found);
+    if (injectableConstructor != null) {
+      return new InjectionPoint(injectableConstructor);
     }
 
-    // If no annotated constructor is found, look for a no-arg constructor
-    // instead.
+    // If no annotated constructor is found, look for a no-arg constructor instead.
     try {
-      Constructor<?> noArgCtor = type.getDeclaredConstructor();
+      Constructor<?> noArgConstructor = type.getDeclaredConstructor();
 
       // Disallow private constructors on non-private classes (unless they have @Inject)
-      if (Modifier.isPrivate(noArgCtor.getModifiers())
+      if (Modifier.isPrivate(noArgConstructor.getModifiers())
           && !Modifier.isPrivate(type.getModifiers())) {
         errors.missingConstructor(type);
         throw new ConfigurationException(errors.getMessages());
       }
 
-      return new InjectionPoint(noArgCtor);
+      checkForMisplacedBindingAnnotations(noArgConstructor, errors);
+      return new InjectionPoint(noArgConstructor);
     } catch (NoSuchMethodException e) {
       errors.missingConstructor(type);
       throw new ConfigurationException(errors.getMessages());
@@ -239,7 +240,7 @@
     Errors errors = new Errors();
     addInjectionPoints(type, Factory.FIELDS, true, sink, errors);
     addInjectionPoints(type, Factory.METHODS, true, sink, errors);
-    errors.throwConfigurationExceptionIfNecessary();;
+    errors.throwConfigurationExceptionIfErrorsExist();
   }
 
   /**
@@ -257,7 +258,15 @@
     Errors errors = new Errors();
     addInjectionPoints(type, Factory.FIELDS, false, sink, errors);
     addInjectionPoints(type, Factory.METHODS, false, sink, errors);
-    errors.throwConfigurationExceptionIfNecessary();
+    errors.throwConfigurationExceptionIfErrorsExist();
+  }
+
+  private static void checkForMisplacedBindingAnnotations(Member member, Errors errors) {
+    Annotation misplacedBindingAnnotation = Annotations.findBindingAnnotation(
+        errors, member, ((AnnotatedElement) member).getAnnotations());
+    if (misplacedBindingAnnotation != null) {
+      errors.misplacedBindingAnnotation(member, misplacedBindingAnnotation);
+    }
   }
 
   private static <M extends Member & AnnotatedElement> void addInjectionPoints(Class<?> type,
@@ -288,7 +297,7 @@
       }
 
       try {
-        injectionPoints.add(factory.create(member));
+        injectionPoints.add(factory.create(member, errors));
       } catch (ConfigurationException ignorable) {
         if (!inject.optional()) {
           errors.merge(ignorable.getErrorMessages());
@@ -306,7 +315,7 @@
       public Field[] getMembers(Class<?> type) {
         return type.getDeclaredFields();
       }
-      public InjectionPoint create(Field member) {
+      public InjectionPoint create(Field member, Errors errors) {
         return new InjectionPoint(member);
       }
     };
@@ -315,13 +324,14 @@
       public Method[] getMembers(Class<?> type) {
         return type.getDeclaredMethods();
       }
-      public InjectionPoint create(Method member) {
+      public InjectionPoint create(Method member, Errors errors) {
+        checkForMisplacedBindingAnnotations(member, errors);
         return new InjectionPoint(member);
       }
     };
 
     M[] getMembers(Class<?> type);
-    InjectionPoint create(M member);
+    InjectionPoint create(M member, Errors errors);
   }
 
   private static final long serialVersionUID = 0;
diff --git a/src/com/google/inject/spi/Message.java b/src/com/google/inject/spi/Message.java
index f417ed3..1273e0e 100644
--- a/src/com/google/inject/spi/Message.java
+++ b/src/com/google/inject/spi/Message.java
@@ -59,7 +59,7 @@
   public String getSource() {
     return sources.isEmpty()
         ? SourceProvider.UNKNOWN_SOURCE.toString()
-        : Errors.sourceToString(sources.get(sources.size() - 1));
+        : Errors.convert(sources.get(sources.size() - 1)).toString();
   }
 
   public List<Object> getSources() {
diff --git a/test/com/google/inject/AllTests.java b/test/com/google/inject/AllTests.java
index 6c16fb7..a81be5a 100644
--- a/test/com/google/inject/AllTests.java
+++ b/test/com/google/inject/AllTests.java
@@ -53,7 +53,6 @@
     suite.addTestSuite(CircularDependencyTest.class);
     suite.addTestSuite(TypeConversionTest.class);
     // suite.addTestSuite(ErrorHandlingTest.class); not a testcase
-    suite.addTestSuite(ErrorMessagesTest.class);
     suite.addTestSuite(GenericInjectionTest.class);
     suite.addTestSuite(ImplicitBindingTest.class);
     suite.addTestSuite(InjectionPointTest.class);
diff --git a/test/com/google/inject/BinderTest.java b/test/com/google/inject/BinderTest.java
index a8f1419..54d459b 100644
--- a/test/com/google/inject/BinderTest.java
+++ b/test/com/google/inject/BinderTest.java
@@ -416,7 +416,7 @@
     } catch (ConfigurationException expected) {
       Asserts.assertContains(expected.getMessage(),
           "1) Cannot inject a Provider that has no type parameter",
-          "at " + Provider.class.getName());
+          "at binding for " + Provider.class.getName());
     }
   }
 }
diff --git a/test/com/google/inject/ErrorMessagesTest.java b/test/com/google/inject/ErrorMessagesTest.java
deleted file mode 100644
index 9043d82..0000000
--- a/test/com/google/inject/ErrorMessagesTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2007 Google Inc. All Rights Reserved.
-
-package com.google.inject;
-
-import static com.google.inject.Asserts.assertContains;
-import static java.lang.annotation.ElementType.CONSTRUCTOR;
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.ElementType.METHOD;
-import static java.lang.annotation.ElementType.PARAMETER;
-import java.lang.annotation.Retention;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-import java.lang.annotation.Target;
-import junit.framework.TestCase;
-
-/**
- * Tests the error messages produced by Guice.
- *
- * @author Kevin Bourrillion
- */
-public class ErrorMessagesTest extends TestCase {
-
-  private class InnerClass {}
-
-  public void testInjectInnerClass() throws Exception {
-    Injector injector = Guice.createInjector();
-    try {
-      injector.getInstance(InnerClass.class);
-      fail();
-    } catch (Exception expected) {
-      assertContains(expected.getMessage(),
-          "Injecting into inner classes is not supported.",
-          "at " + InnerClass.class.getName() + ".class(ErrorMessagesTest.java:");
-    }
-  }
-
-  public void testInjectLocalClass() throws Exception {
-    class LocalClass {}
-
-    Injector injector = Guice.createInjector();
-    try {
-      injector.getInstance(LocalClass.class);
-      fail();
-    } catch (Exception expected) {
-      assertContains(expected.getMessage(),
-          "Injecting into inner classes is not supported.",
-          "at " + LocalClass.class.getName() + ".class(ErrorMessagesTest.java:");
-    }
-  }
-
-  public void testBindingAnnotationsOnMethodsAndConstructors() {
-    try {
-      Guice.createInjector().getInstance(B.class);
-      fail();
-    } catch (ConfigurationException expected) {
-      assertContains(expected.getMessage(),
-          B.class.getName() + ".injectMe() is annotated with @", Green.class.getName() + "(), ",
-          "but binding annotations should be applied to its parameters instead.",
-          "at " + B.class.getName() + ".injectMe(ErrorMessagesTest.java:");
-    }
-
-    try {
-      Guice.createInjector().getInstance(C.class);
-      fail();
-    } catch (ConfigurationException expected) {
-      assertContains(expected.getMessage(),
-          C.class.getName() + ".<init>() is annotated with @", Green.class.getName() + "(), ",
-          "but binding annotations should be applied to its parameters instead.",
-          "at " + C.class.getName() + ".<init>(ErrorMessagesTest.java:");
-    }
-  }
-
-  static class B {
-    @Inject @Green void injectMe(String greenString) {}
-  }
-
-  static class C {
-    @Inject @Green C(String greenString) {}
-  }
-
-  @Retention(RUNTIME)
-  @Target({ FIELD, PARAMETER, CONSTRUCTOR, METHOD })
-  @BindingAnnotation
-  @interface Green {}
-
-
-  // TODO(kevinb): many many more
-
-}
diff --git a/test/com/google/inject/ImplicitBindingTest.java b/test/com/google/inject/ImplicitBindingTest.java
index 36cdf94..bdd9f06 100644
--- a/test/com/google/inject/ImplicitBindingTest.java
+++ b/test/com/google/inject/ImplicitBindingTest.java
@@ -90,9 +90,9 @@
       Asserts.assertContains(expected.getMessage(),
           "1) No implementation for " + I.class.getName(),
           "annotated with @" + Named.class.getName() + "(value=i) was bound.",
-          "at " + I.class.getName() + ".class(ImplicitBindingTest.java:");
+          "at binding for " + I.class.getName(),
+          " annotated with @" + Named.class.getName() + "(value=i)");
     }
-
   }
 
   static class ProvidedProvider implements Provider<Provided> {
diff --git a/test/com/google/inject/ProvisionExceptionTest.java b/test/com/google/inject/ProvisionExceptionTest.java
index 316a481..4085409 100644
--- a/test/com/google/inject/ProvisionExceptionTest.java
+++ b/test/com/google/inject/ProvisionExceptionTest.java
@@ -19,6 +19,13 @@
 import static com.google.inject.Asserts.assertContains;
 import static com.google.inject.Asserts.assertSimilarWhenReserialized;
 import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
 import junit.framework.TestCase;
 
 /**
@@ -73,34 +80,6 @@
     }
   }
 
-  public void testProviderExceptions() {
-    try {
-      Guice.createInjector(new AbstractModule() {
-        protected void configure() {
-          bind(D.class).toProvider(DProvider.class);
-        }
-      }).getInstance(D.class);
-      fail();
-    } catch (ProvisionException e) {
-      assertTrue(e.getCause() instanceof UnsupportedOperationException);
-      assertContains(e.getMessage(),
-          "1) Error in custom provider, java.lang.UnsupportedOperationException",
-          "at " + ProvisionExceptionTest.class.getName(), ".configure(ProvisionExceptionTest.java");
-    }
-  }
-
-  public void testBindToTypeExceptions() {
-    try {
-      Guice.createInjector().getInstance(D.class);
-      fail();
-    } catch (ProvisionException e) {
-      assertTrue(e.getCause() instanceof UnsupportedOperationException);
-      assertContains(e.getMessage(),
-          "1) Error injecting constructor, java.lang.UnsupportedOperationException",
-          "at " + D.class.getName() + ".<init>(ProvisionExceptionTest.java:");
-    }
-  }
-
   public void testBindToProviderInstanceExceptions() {
     try {
       Guice.createInjector(new AbstractModule() {
@@ -140,7 +119,8 @@
       fail();
     } catch (ProvisionException e) {
       assertContains(e.getMessage(), "1) User Exception",
-          "at " + ProvisionExceptionTest.class.getName(), ".configure(ProvisionExceptionTest.java");
+          "at binding for ", FProvider.class.getName(), ".class(ProvisionExceptionTest.java",
+          "at binding for ", F.class.getName(), ".class(ProvisionExceptionTest.java:");
     }
   }
 
@@ -182,6 +162,92 @@
     }
   }
 
+  public void testInjectInnerClass() throws Exception {
+    Injector injector = Guice.createInjector();
+    try {
+      injector.getInstance(InnerClass.class);
+      fail();
+    } catch (Exception expected) {
+      assertContains(expected.getMessage(),
+          "Injecting into inner classes is not supported.",
+          "at binding for " + InnerClass.class.getName() + ".class(ProvisionExceptionTest.java:");
+    }
+  }
+
+  public void testInjectLocalClass() throws Exception {
+    class LocalClass {}
+
+    Injector injector = Guice.createInjector();
+    try {
+      injector.getInstance(LocalClass.class);
+      fail();
+    } catch (Exception expected) {
+      assertContains(expected.getMessage(),
+          "Injecting into inner classes is not supported.",
+          "at binding for " + LocalClass.class.getName() + ".class(ProvisionExceptionTest.java:");
+    }
+  }
+
+  public void testBindingAnnotationsOnMethodsAndConstructors() {
+    try {
+      Guice.createInjector().getInstance(MethodWithBindingAnnotation.class);
+      fail();
+    } catch (ConfigurationException expected) {
+      assertContains(expected.getMessage(), MethodWithBindingAnnotation.class.getName()
+          + ".injectMe() is annotated with @", Green.class.getName() + "(), ",
+          "but binding annotations should be applied to its parameters instead.",
+          "at binding for " + MethodWithBindingAnnotation.class.getName() + ".class");
+    }
+
+    try {
+      Guice.createInjector().getInstance(ConstructorWithBindingAnnotation.class);
+      fail();
+    } catch (ConfigurationException expected) {
+      assertContains(expected.getMessage(), ConstructorWithBindingAnnotation.class.getName()
+          + ".<init>() is annotated with @", Green.class.getName() + "(), ",
+          "but binding annotations should be applied to its parameters instead.",
+          "at " + ConstructorWithBindingAnnotation.class.getName() + ".class",
+          "at binding for " + ConstructorWithBindingAnnotation.class.getName() + ".class");
+    }
+  }
+
+  public void testLinkedBindings() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      protected void configure() {
+        bind(D.class).to(RealD.class);
+      }
+    });
+
+    try {
+      injector.getInstance(D.class);
+      fail();
+    } catch (ProvisionException expected) {
+      assertContains(expected.getMessage(),
+          "at " + RealD.class.getName() + ".<init>(ProvisionExceptionTest.java:",
+          "at binding for " + RealD.class.getName() + ".class(ProvisionExceptionTest.java:",
+          "at binding for " + D.class.getName() + ".class(ProvisionExceptionTest.java:");
+    }
+  }
+
+  public void testProviderKeyBindings() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      protected void configure() {
+        bind(D.class).toProvider(DProvider.class);
+      }
+    });
+
+    try {
+      injector.getInstance(D.class);
+      fail();
+    } catch (ProvisionException expected) {
+      assertContains(expected.getMessage(),
+          "at binding for " + DProvider.class.getName() + ".class(ProvisionExceptionTest.java:",
+          "at binding for " + D.class.getName() + ".class(ProvisionExceptionTest.java:");
+    }
+  }
+
+  private class InnerClass {}
+
   static class A {
     @Inject
     A(B b) { }
@@ -191,21 +257,38 @@
   }
   static class C {
     @Inject
-    void setD(D d) { }
-  }
-  static class D {
-    D() {
-      throw new UnsupportedOperationException();
-    }
+    void setD(RealD d) { }
   }
   static class E {
     @Inject void setObject(Object o) {
       throw new UnsupportedOperationException();
     }
   }
+
+  static class MethodWithBindingAnnotation {
+    @Inject @Green void injectMe(String greenString) {}
+  }
+
+  static class ConstructorWithBindingAnnotation {
+    @Inject @Green ConstructorWithBindingAnnotation(String greenString) {}
+  }
+
+  @Retention(RUNTIME)
+  @Target({ FIELD, PARAMETER, CONSTRUCTOR, METHOD })
+  @BindingAnnotation
+  @interface Green {}
+
+  interface D {}
+
+  static class RealD implements D {
+    @Inject RealD() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
   static class DProvider implements Provider<D> {
     public D get() {
-      return new D();
+      throw new UnsupportedOperationException();
     }
   }
 
diff --git a/test/com/google/inject/ProxyFactoryTest.java b/test/com/google/inject/ProxyFactoryTest.java
index 4a0d214..9d0dd2e 100644
--- a/test/com/google/inject/ProxyFactoryTest.java
+++ b/test/com/google/inject/ProxyFactoryTest.java
@@ -18,7 +18,6 @@
 package com.google.inject;
 
 import com.google.common.collect.Lists;
-import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
 import static com.google.inject.matcher.Matchers.annotatedWith;
 import static com.google.inject.matcher.Matchers.any;
@@ -47,8 +46,8 @@
     aspects.add(new MethodAspect(any(), any(), interceptor));
     ProxyFactory factory = new ProxyFactory(aspects);
 
-    ConstructionProxy<Simple> constructionProxy = factory
-        .createConstructionProxy(new Errors(), InjectionPoint.forConstructorOf(Simple.class));
+    ConstructionProxy<Simple> constructionProxy
+        = factory.createConstructionProxy(InjectionPoint.forConstructorOf(Simple.class));
 
     Simple simple = constructionProxy.newInstance();
     simple.invoke();
@@ -81,9 +80,9 @@
     ProxyFactory factory = new ProxyFactory(aspects);
 
     ConstructionProxy<Foo> fooFactory =
-        factory.get(new Errors(), InjectionPoint.forConstructorOf(Foo.class));
+        factory.get(InjectionPoint.forConstructorOf(Foo.class));
     ConstructionProxy<Bar> barFactory =
-        factory.get(new Errors(), InjectionPoint.forConstructorOf(Bar.class));
+        factory.get(InjectionPoint.forConstructorOf(Bar.class));
 
     Foo foo = fooFactory.newInstance();
     Bar bar = barFactory.newInstance();
@@ -135,7 +134,7 @@
     ProxyFactory factory = new ProxyFactory(aspects);
 
     ConstructionProxy<A> constructor =
-        factory.get(new Errors(), InjectionPoint.forConstructorOf(A.class));
+        factory.get(InjectionPoint.forConstructorOf(A.class));
 
     A a = constructor.newInstance(5);
     a.a();
@@ -150,7 +149,7 @@
     ProxyFactory factory = new ProxyFactory(aspects);
 
     ConstructionProxy<A> constructor =
-        factory.get(new Errors(), InjectionPoint.forConstructorOf(A.class));
+        factory.get(InjectionPoint.forConstructorOf(A.class));
 
     A a = constructor.newInstance(5);
     assertEquals(A.class, a.getClass());
@@ -173,7 +172,7 @@
     ProxyFactory factory = new ProxyFactory(aspects);
 
     ConstructionProxy<Counter> constructor =
-        factory.get(new Errors(), InjectionPoint.forConstructorOf(Counter.class));
+        factory.get(InjectionPoint.forConstructorOf(Counter.class));
 
     Counter counter = constructor.newInstance();
     counter.inc();
diff --git a/test/com/google/inject/ScopesTest.java b/test/com/google/inject/ScopesTest.java
index f8ee633..0078a6a 100644
--- a/test/com/google/inject/ScopesTest.java
+++ b/test/com/google/inject/ScopesTest.java
@@ -306,7 +306,7 @@
     } catch (ConfigurationException expected) {
       assertContains(expected.getMessage(),
           "1) More than one scope annotation was found: ",
-          "at " + SingletonAndCustomScoped.class.getName(), ".class(ScopesTest.java:");
+          "at binding for " + SingletonAndCustomScoped.class.getName(), ".class(ScopesTest.java:");
     }
   }