diff --git a/src/com/google/inject/AbstractErrorHandler.java b/src/com/google/inject/AbstractErrorHandler.java
index 7c038ec..d84e66a 100644
--- a/src/com/google/inject/AbstractErrorHandler.java
+++ b/src/com/google/inject/AbstractErrorHandler.java
@@ -60,8 +60,7 @@
       },
       new Converter<Field>(Field.class) {
         public String toString(Field f) {
-          return "field " + f.getDeclaringClass().getName() + "."
-              + f.getName();
+          return "field " + f.getDeclaringClass().getName() + "." + f.getName();
         }
       },
       new Converter<Class>(Class.class) {
diff --git a/src/com/google/inject/AbstractModule.java b/src/com/google/inject/AbstractModule.java
index d9b612f..8251ac1 100644
--- a/src/com/google/inject/AbstractModule.java
+++ b/src/com/google/inject/AbstractModule.java
@@ -17,12 +17,11 @@
 package com.google.inject;
 
 import com.google.inject.util.Objects;
-
 import java.util.Map;
 import java.util.Properties;
 
 /**
- * A support class for {@link Module}s which reduces repetition and
+ * A support class for {@link Module Modules} which reduces repetition and
  * results in a more readable configuration. Simply extends this class,
  * implement {@link #configure()}, and call the inherited methods which mirror
  * those found in {@link ContainerBuilder}. For example:
@@ -53,7 +52,8 @@
 
       configure();
 
-    } finally {
+    }
+    finally {
       this.builder = null;
     }
   }
diff --git a/src/com/google/inject/Binding.java b/src/com/google/inject/Binding.java
index 299b1a1..0326c92 100644
--- a/src/com/google/inject/Binding.java
+++ b/src/com/google/inject/Binding.java
@@ -30,8 +30,8 @@
   final Object source;
   final InternalFactory<? extends T> internalFactory;
 
-  Binding(ContainerImpl container, Key<T> key,
-      Object source, InternalFactory<? extends T> internalFactory) {
+  Binding(ContainerImpl container, Key<T> key, Object source,
+      InternalFactory<? extends T> internalFactory) {
     this.container = container;
     this.key = key;
     this.source = source;
diff --git a/src/com/google/inject/ConstructionContext.java b/src/com/google/inject/ConstructionContext.java
index eb82ee5..fde3206 100644
--- a/src/com/google/inject/ConstructionContext.java
+++ b/src/com/google/inject/ConstructionContext.java
@@ -17,11 +17,11 @@
 package com.google.inject;
 
 import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
-import java.util.List;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Context of a dependency construction. Used to manage circular references.
@@ -75,22 +75,18 @@
       invocationHandlers = new ArrayList<DelegatingInvocationHandler<T>>();
     }
 
-    DelegatingInvocationHandler<T> invocationHandler =
-        new DelegatingInvocationHandler<T>();
+    DelegatingInvocationHandler<T> invocationHandler
+        = new DelegatingInvocationHandler<T>();
     invocationHandlers.add(invocationHandler);
 
-    return Proxy.newProxyInstance(
-      expectedType.getClassLoader(),
-      new Class[] { expectedType },
-      invocationHandler
-    );
+    return Proxy.newProxyInstance(expectedType.getClassLoader(),
+        new Class[] { expectedType }, invocationHandler);
   }
 
   void setProxyDelegates(T delegate) {
     if (invocationHandlers != null) {
-      for (DelegatingInvocationHandler<T> invocationHandler
-          : invocationHandlers) {
-        invocationHandler.setDelegate(delegate);
+      for (DelegatingInvocationHandler<T> handler : invocationHandlers) {
+        handler.setDelegate(delegate);
       }
     }
   }
@@ -109,11 +105,14 @@
 
       try {
         return method.invoke(delegate, args);
-      } catch (IllegalAccessException e) {
+      }
+      catch (IllegalAccessException e) {
         throw new RuntimeException(e);
-      } catch (IllegalArgumentException e) {
+      }
+      catch (IllegalArgumentException e) {
         throw new RuntimeException(e);
-      } catch (InvocationTargetException e) {
+      }
+      catch (InvocationTargetException e) {
         throw e.getTargetException();
       }
     }
diff --git a/src/com/google/inject/ConstructorInjector.java b/src/com/google/inject/ConstructorInjector.java
index d384742..d242b91 100644
--- a/src/com/google/inject/ConstructorInjector.java
+++ b/src/com/google/inject/ConstructorInjector.java
@@ -23,7 +23,7 @@
  * Injects constructors.
  *
  * @author crazybob@google.com (Bob Lee)
-*/
+ */
 class ConstructorInjector<T> implements Factory<T> {
 
   final Class<T> implementation;
@@ -55,17 +55,18 @@
               constructor.getGenericParameterTypes(),
               inject.value()
           );
-    } catch (ContainerImpl.MissingDependencyException e) {
+    }
+    catch (ContainerImpl.MissingDependencyException e) {
       e.handle(container.errorHandler);
       return null;
     }
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   private Constructor<T> findConstructorIn(Class<T> implementation) {
     Constructor<T> found = null;
-    for (Constructor<T> constructor
-        : implementation.getDeclaredConstructors()) {
+    for (Constructor<T> constructor : implementation.getDeclaredConstructors())
+    {
       if (constructor.getAnnotation(Inject.class) != null) {
         if (found != null) {
           container.errorHandler.handle(
@@ -83,19 +84,21 @@
     // instead.
     try {
       return implementation.getDeclaredConstructor();
-    } catch (NoSuchMethodException e) {
-      container.errorHandler.handle(ErrorMessages.MISSING_CONSTRUCTOR, implementation);
+    }
+    catch (NoSuchMethodException e) {
+      container.errorHandler.handle(
+          ErrorMessages.MISSING_CONSTRUCTOR, implementation);
       return ContainerImpl.invalidConstructor();
     }
   }
 
   /**
-   * Construct an instance. Returns {@code Object} instead of {@code T}
-   * because it may return a proxy.
+   * Construct an instance. Returns {@code Object} instead of {@code T} because
+   * it may return a proxy.
    */
   Object construct(InternalContext context, Class<? super T> expectedType) {
-    ConstructionContext<T> constructionContext =
-        context.getConstructionContext(this);
+    ConstructionContext<T> constructionContext
+        = context.getConstructionContext(this);
 
     // We have a circular reference between constructors. Return a proxy.
     if (constructionContext.isConstructing()) {
@@ -115,11 +118,12 @@
       // First time through...
       constructionContext.startConstruction();
       try {
-        Object[] parameters =
-            ContainerImpl.getParameters(context, parameterInjectors);
+        Object[] parameters
+            = ContainerImpl.getParameters(context, parameterInjectors);
         t = newInstance(parameters);
         constructionContext.setProxyDelegates(t);
-      } finally {
+      }
+      finally {
         constructionContext.finishConstruction();
       }
 
@@ -128,35 +132,38 @@
       constructionContext.setCurrentReference(t);
 
       // Inject fields and methods.
-      for (int i = 0; i < injectors.length; i++) {
-        injectors[i].inject(context, t);
+      for (ContainerImpl.Injector injector : injectors) {
+        injector.inject(context, t);
       }
 
       return t;
-    } catch (InvocationTargetException e) {
+    }
+    catch (InvocationTargetException e) {
       throw new RuntimeException(e);
-    } finally {
+    }
+    finally {
       constructionContext.removeCurrentReference();
     }
   }
 
-  @SuppressWarnings({"unchecked"})
-  private T newInstance(Object[] parameters)
-      throws InvocationTargetException {
-    return (T) constructionProxy.newInstance(parameters);
+  @SuppressWarnings("unchecked")
+  private T newInstance(Object[] parameters) throws InvocationTargetException {
+    return constructionProxy.newInstance(parameters);
   }
 
   public T get() {
     try {
       return container.callInContext(new ContextualCallable<T>() {
-        @SuppressWarnings({"unchecked"})
+        @SuppressWarnings("unchecked")
         public T call(InternalContext context) {
           return (T) construct(context, implementation);
         }
       });
-    } catch (RuntimeException e) {
+    }
+    catch (RuntimeException e) {
       throw e;
-    } catch (Exception e) {
+    }
+    catch (Exception e) {
       throw new RuntimeException(e);
     }
   }
diff --git a/src/com/google/inject/Container.java b/src/com/google/inject/Container.java
index f7c43ba..8b4eae4 100644
--- a/src/com/google/inject/Container.java
+++ b/src/com/google/inject/Container.java
@@ -16,17 +16,17 @@
 
 package com.google.inject;
 
-import java.util.Map;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Injects dependencies into constructors, methods and fields annotated with
  * &#64;{@link Inject}.
  *
- * <p>When injecting a method or constructor, you can additionally annotate
- * its parameters with &#64;{@link Inject} and specify a dependency name. When
- * a parameter has no annotation, the container uses the name from the method
- * or constructor's &#64;{@link Inject} annotation respectively.
+ * <p>When injecting a method or constructor, you can additionally annotate its
+ * parameters with &#64;{@link Inject} and specify a dependency name. When a
+ * parameter has no annotation, the container uses the name from the method or
+ * constructor's &#64;{@link Inject} annotation respectively.
  *
  * <p>For example:
  *
@@ -64,8 +64,8 @@
  *  Foo foo = fooFactory.get();
  * </pre>
  *
- * @see ContainerBuilder
  * @author crazybob@google.com (Bob Lee)
+ * @see ContainerBuilder
  */
 public interface Container {
 
@@ -75,8 +75,8 @@
   void injectMembers(Object o);
 
   /**
-   * Gets a factory which injects the given class's constructor and creates
-   * new instances of {@code T}.
+   * Gets a factory which injects the given class's constructor and creates new
+   * instances of {@code T}.
    */
   <T> Factory<T> getCreator(Class<T> implementation);
 
diff --git a/src/com/google/inject/ContainerBuilder.java b/src/com/google/inject/ContainerBuilder.java
index c2163ba..f3d6ca3 100644
--- a/src/com/google/inject/ContainerBuilder.java
+++ b/src/com/google/inject/ContainerBuilder.java
@@ -16,6 +16,7 @@
 
 package com.google.inject;
 
+import com.google.inject.ContainerImpl.Injector;
 import static com.google.inject.Scopes.CONTAINER;
 import static com.google.inject.Scopes.CONTAINER_NAME;
 import static com.google.inject.Scopes.DEFAULT;
@@ -27,9 +28,6 @@
 import static com.google.inject.util.Objects.nonNull;
 import com.google.inject.util.Stopwatch;
 import com.google.inject.util.ToStringBuilder;
-
-import org.aopalliance.intercept.MethodInterceptor;
-
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
@@ -41,6 +39,7 @@
 import java.util.Properties;
 import java.util.Set;
 import java.util.logging.Logger;
+import org.aopalliance.intercept.MethodInterceptor;
 
 /**
  * Builds a dependency injection {@link Container}. Binds {@link Key}s to
@@ -52,31 +51,31 @@
  * <p>Default bindings include:
  *
  * <ul>
- *   <li>A {@code Factory<T>} for each binding of type {@code T}
- *   <li>The {@link Container} iself
- *   <li>The {@link Logger} for the class being injected
+ * <li>A {@code Factory<T>} for each binding of type {@code T}
+ * <li>The {@link Container} iself
+ * <li>The {@link Logger} for the class being injected
  * </ul>
  *
- * <p>Converts constants as needed from {@code String} to any primitive type
- * in addition to {@code enum} and {@code Class<?>}.
+ * <p>Converts constants as needed from {@code String} to any primitive type in
+ * addition to {@code enum} and {@code Class<?>}.
  *
  * @author crazybob@google.com (Bob Lee)
  */
 public final class ContainerBuilder extends SourceConsumer {
 
-  private static final Logger logger =
-      Logger.getLogger(ContainerBuilder.class.getName());
+  private static final Logger logger
+      = Logger.getLogger(ContainerBuilder.class.getName());
 
-  final List<BindingBuilder<?>> bindingBuilders =
-      new ArrayList<BindingBuilder<?>>();
-  final List<ConstantBindingBuilder> constantBindingBuilders =
-      new ArrayList<ConstantBindingBuilder>();
-  final List<LinkedBindingBuilder<?>> linkedBindingBuilders =
-      new ArrayList<LinkedBindingBuilder<?>>();
+  final List<BindingBuilder<?>> bindingBuilders
+      = new ArrayList<BindingBuilder<?>>();
+  final List<ConstantBindingBuilder> constantBindingBuilders
+      = new ArrayList<ConstantBindingBuilder>();
+  final List<LinkedBindingBuilder<?>> linkedBindingBuilders
+      = new ArrayList<LinkedBindingBuilder<?>>();
   final Map<String, Scope> scopes = new HashMap<String, Scope>();
 
-  final List<StaticInjection> staticInjections =
-      new ArrayList<StaticInjection>();
+  final List<StaticInjection> staticInjections
+      = new ArrayList<StaticInjection>();
 
   ContainerImpl container;
 
@@ -85,21 +84,22 @@
    */
   final Set<Message> errorMessages = new LinkedHashSet<Message>();
 
-  private static final InternalFactory<Container> CONTAINER_FACTORY =
-      new InternalFactory<Container>() {
-        public Container get(InternalContext context) {
-          return context.getContainer();
-        }
-      };
+  private static final InternalFactory<Container> CONTAINER_FACTORY
+      = new InternalFactory<Container>() {
+    public Container get(InternalContext context) {
+      return context.getContainer();
+    }
+  };
 
-  private static final InternalFactory<Logger> LOGGER_FACTORY =
-      new InternalFactory<Logger>() {
-        public Logger get(InternalContext context) {
-          Member member = context.getExternalContext().getMember();
-          return member == null ? Logger.getAnonymousLogger()
-              : Logger.getLogger(member.getDeclaringClass().getName());
-        }
-      };
+  private static final InternalFactory<Logger> LOGGER_FACTORY
+      = new InternalFactory<Logger>() {
+    public Logger get(InternalContext context) {
+      Member member = context.getExternalContext().getMember();
+      return member == null
+          ? Logger.getAnonymousLogger()
+          : Logger.getLogger(member.getDeclaringClass().getName());
+    }
+  };
 
   static final String UNKNOWN_SOURCE = "[unknown source]";
 
@@ -150,9 +150,9 @@
    * and method queries.
    *
    * @param classQuery matches classes the interceptor should apply to. For
-   *  example: {@code only(Runnable.class)}.
+   *     example: {@code only(Runnable.class)}.
    * @param methodQuery matches methods the interceptor should apply to. For
-   *  example: {@code annotatedWith(Transactional.class)}.
+   *     example: {@code annotatedWith(Transactional.class)}.
    * @param interceptors to apply
    */
   public void intercept(Query<? super Class<?>> classQuery,
@@ -168,7 +168,8 @@
   public void scope(String name, Scope scope) {
     if (scopes.containsKey(nonNull(name, "name"))) {
       addError(source(), ErrorMessages.DUPLICATE_SCOPES, name);
-    } else {
+    }
+    else {
       scopes.put(nonNull(name, "name"), nonNull(scope, "scope"));
     }
   }
@@ -292,12 +293,11 @@
    * which were registered using {@link #requestStaticInjection(Class...)}.
    *
    * @param preload If true, the container will load all container-scoped
-   *  bindings now. If false, the container will lazily load them. Eager
-   *  loading is appropriate for production use (catch errors early and take
-   *  any performance hit up front) while lazy loading can speed development.
-   *
+   *     bindings now. If false, the container will lazily load them. Eager
+   *     loading is appropriate for production use (catch errors early and take
+   *     any performance hit up front) while lazy loading can speed development.
    * @throws ContainerCreationException if configuration errors are found. The
-   *  expectation is that the application will log this exception and exit.
+   *     expectation is that the application will log this exception and exit.
    * @throws IllegalStateException if called more than once
    */
   public synchronized Container create(boolean preload)
@@ -306,16 +306,14 @@
 
     // Create the container.
     ensureNotCreated();
-    Map<Key<?>, Binding<?>> bindings =
-        new HashMap<Key<?>, Binding<?>>();
-    container = new ContainerImpl(
-        proxyFactoryBuilder.create(), bindings);
+    Map<Key<?>, Binding<?>> bindings = new HashMap<Key<?>, Binding<?>>();
+    container = new ContainerImpl(proxyFactoryBuilder.create(), bindings);
 
     createConstantBindings();
 
     // Commands to execute before returning the Container instance.
-    final List<ContextualCallable<Void>> preloaders =
-        new ArrayList<ContextualCallable<Void>>();
+    final List<ContextualCallable<Void>> preloaders
+        = new ArrayList<ContextualCallable<Void>>();
 
     createBindings(preload, preloaders);
     createLinkedBindings();
@@ -380,8 +378,7 @@
     }
   }
 
-  private <T> void createLinkedBinding(
-      LinkedBindingBuilder<T> builder) {
+  private <T> void createLinkedBinding(LinkedBindingBuilder<T> builder) {
     // TODO: Support linking to a later-declared link?
     Key<? extends T> destinationKey = builder.getDestination();
     if (destinationKey == null) {
@@ -396,14 +393,13 @@
       return;
     }
 
-    Binding<?> binding =
-        Binding.newInstance(container, builder.getKey(), builder.getSource(),
-            destination.getInternalFactory());
+    Binding<?> binding = Binding.newInstance(container, builder.getKey(),
+        builder.getSource(), destination.getInternalFactory());
 
     putBinding(binding);
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   private <T> Binding<T> getBinding(Key<T> destinationKey) {
     return (Binding<T>) container.internalBindings().get(destinationKey);
   }
@@ -415,13 +411,13 @@
     }
   }
 
-  private <T> void createBinding(BindingBuilder<T> builder,
-      boolean preload, List<ContextualCallable<Void>> preloaders) {
+  private <T> void createBinding(BindingBuilder<T> builder, boolean preload,
+      List<ContextualCallable<Void>> preloaders) {
     final Key<T> key = builder.getKey();
-    final InternalFactory<? extends T> factory =
-        builder.getInternalFactory(container);
-    Binding<?> binding = Binding.newInstance(
-        container, key, builder.getSource(), factory);
+    final InternalFactory<? extends T> factory
+        = builder.getInternalFactory(container);
+    Binding<?> binding
+        = Binding.newInstance(container, key, builder.getSource(), factory);
 
     putBinding(binding);
 
@@ -430,7 +426,8 @@
       if (preload || builder.shouldPreload()) {
         preloaders.add(new BindingPreloader(key, factory));
       }
-    } else {
+    }
+    else {
       if (builder.shouldPreload()) {
         addError(builder.getSource(), ErrorMessages.PRELOAD_NOT_ALLOWED);
       }
@@ -443,16 +440,17 @@
     }
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   private <T> void createConstantBinding(ConstantBindingBuilder builder) {
     if (builder.hasValue()) {
       Key<T> key = (Key<T>) builder.getKey();
-      InternalFactory<? extends T> factory =
-          (InternalFactory<? extends T>) builder.getInternalFactory();
-      Binding<?> binding =
-          Binding.newInstance(container, key, builder.getSource(), factory);
+      InternalFactory<? extends T> factory
+          = (InternalFactory<? extends T>) builder.getInternalFactory();
+      Binding<?> binding
+          = Binding.newInstance(container, key, builder.getSource(), factory);
       putBinding(binding);
-    } else {
+    }
+    else {
       addError(builder.getSource(), ErrorMessages.MISSING_CONSTANT_VALUE);
     }
   }
@@ -461,7 +459,8 @@
       Key<?> key, InternalFactory<?> factory) {
     if (factories.containsKey(key)) {
       addError(source, ErrorMessages.BINDING_ALREADY_SET, key);
-    } else {
+    }
+    else {
       factories.put(key, factory);
     }
   }
@@ -473,18 +472,18 @@
     if (bindings.containsKey(key)) {
       addError(binding.getSource(), ErrorMessages.BINDING_ALREADY_SET, key,
           original.getSource());
-    } else {
+    }
+    else {
       bindings.put(key, binding);
     }
   }
 
   /**
-   * Currently we only support creating one Container instance per builder.
-   * If we want to support creating more than one container per builder,
-   * we should move to a "factory factory" model where we create a factory
-   * instance per Container. Right now, one factory instance would be
-   * shared across all the containers, which means container-scoped objects
-   * would be shared, etc.
+   * Currently we only support creating one Container instance per builder. If
+   * we want to support creating more than one container per builder, we should
+   * move to a "factory factory" model where we create a factory instance per
+   * Container. Right now, one factory instance would be shared across all the
+   * containers, which means container-scoped objects would be shared, etc.
    */
   private void ensureNotCreated() {
     if (container != null) {
@@ -528,15 +527,14 @@
       if (!this.key.hasDefaultName()) {
         addError(source, ErrorMessages.NAME_ALREADY_SET);
       }
-
       this.key = this.key.named(name);
       return this;
     }
 
     /**
-     * Binds to instances of the given implementation class. The {@link
-     * Container} will inject the implementation instances as well. Sets the
-     * scope based on the @{@link Scoped} annotation on the implementation
+     * Binds to instances of the given implementation class. The
+     * {@link Container} will inject the implementation instances as well. Sets
+     * the scope based on the @{@link Scoped} annotation on the implementation
      * class if present.
      */
     public <I extends T> BindingBuilder<T> to(Class<I> implementation) {
@@ -544,9 +542,9 @@
     }
 
     /**
-     * Binds to instances of the given implementation type. The {@link
-     * Container} will inject the implementation instances as well. Sets the
-     * scope based on the @{@link Scoped} annotation on the implementation
+     * Binds to instances of the given implementation type. The
+     * {@link Container} will inject the implementation instances as well. Sets
+     * the scope based on the @{@link Scoped} annotation on the implementation
      * class if present.
      */
     public <I extends T> BindingBuilder<T> to(TypeLiteral<I> implementation) {
@@ -559,11 +557,12 @@
 
     private void setScopeFromType(Class<?> implementation) {
       for (Annotation annotation : implementation.getAnnotations()) {
-        Class<? extends Annotation> annotationType =
-            annotation.annotationType();
+        Class<? extends Annotation> annotationType
+            = annotation.annotationType();
         if (annotationType == Scoped.class) {
           in(((Scoped) annotation).value());
-        } else {
+        }
+        else {
           Scoped scoped = annotationType.getAnnotation(Scoped.class);
           if (scoped != null) {
             in(scoped.value());
@@ -622,8 +621,7 @@
     }
 
     /**
-     * Specifies the scope. References the name passed to {@link
-     * ContainerBuilder#scope(String, Scope)}.
+     * Specifies the scope. References the name passed to {@link #scope}.
      */
     public BindingBuilder<T> in(String scopeName) {
       ensureScopeNotSet();
@@ -662,9 +660,9 @@
     }
 
     /**
-     * Instructs the builder to eagerly load this binding when it creates
-     * the container. Useful for application initialization logic. Currently
-     * only supported for container-scoped bindings.
+     * Instructs the builder to eagerly load this binding when it creates the
+     * container. Useful for application initialization logic. Currently only
+     * supported for container-scoped bindings.
      */
     public BindingBuilder<T> preload() {
       this.preload = true;
@@ -715,8 +713,8 @@
     @SuppressWarnings("unchecked")
     public T get(InternalContext context) {
       if (constructor == null) {
-        this.constructor =
-            context.getContainerImpl().getConstructor(implementation);
+        this.constructor
+            = context.getContainerImpl().getConstructor(implementation);
       }
       return (T) constructor.construct(context, key.getRawType());
     }
@@ -929,8 +927,7 @@
 
     final Object source;
     final Class<?>[] types;
-    final List<ContainerImpl.Injector> injectors =
-        new ArrayList<ContainerImpl.Injector>();
+    final List<Injector> injectors = new ArrayList<Injector>();
 
     public StaticInjection(Object source, Class<?>[] types) {
       this.source = source;
@@ -954,7 +951,7 @@
     void runInjectors(ContainerImpl container) {
       container.callInContext(new ContextualCallable<Void>() {
         public Void call(InternalContext context) {
-          for (ContainerImpl.Injector injector : injectors) {
+          for (Injector injector : injectors) {
             injector.inject(context, null);
           }
           return null;
@@ -963,8 +960,7 @@
     }
   }
 
-  static class BindingPreloader
-      implements ContextualCallable<Void> {
+  static class BindingPreloader implements ContextualCallable<Void> {
 
     private final Key<?> key;
     private final InternalFactory<?> factory;
@@ -975,13 +971,14 @@
     }
 
     public Void call(InternalContext context) {
-      ExternalContext<?> externalContext =
-          ExternalContext.newInstance(null, key, context.getContainerImpl());
+      ExternalContext<?> externalContext
+          = ExternalContext.newInstance(null, key, context.getContainerImpl());
       context.setExternalContext(externalContext);
       try {
         factory.get(context);
         return null;
-      } finally {
+      }
+      finally {
         context.setExternalContext(null);
       }
     }
diff --git a/src/com/google/inject/ContainerCreationException.java b/src/com/google/inject/ContainerCreationException.java
index 647d7e3..9976a0f 100644
--- a/src/com/google/inject/ContainerCreationException.java
+++ b/src/com/google/inject/ContainerCreationException.java
@@ -17,15 +17,14 @@
 package com.google.inject;
 
 import com.google.inject.spi.Message;
-
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Formatter;
 
 /**
- * Thrown when errors occur while creating a {@link Container}. Includes a
- * list of encountered errors. Typically, a client should catch this exception,
- * log it, and stop execution.
+ * Thrown when errors occur while creating a {@link Container}. Includes a list
+ * of encountered errors. Typically, a client should catch this exception, log
+ * it, and stop execution.
  *
  * @author crazybob@google.com (Bob Lee)
  */
diff --git a/src/com/google/inject/ContainerImpl.java b/src/com/google/inject/ContainerImpl.java
index e67d0f0..432d924 100644
--- a/src/com/google/inject/ContainerImpl.java
+++ b/src/com/google/inject/ContainerImpl.java
@@ -16,13 +16,11 @@
 
 package com.google.inject;
 
+import static com.google.inject.ConstantConversionException.createMessage;
 import com.google.inject.util.GuiceFastClass;
 import com.google.inject.util.ReferenceCache;
 import com.google.inject.util.Strings;
 import com.google.inject.util.ToStringBuilder;
-
-import net.sf.cglib.reflect.FastMethod;
-
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.AnnotatedElement;
@@ -41,12 +39,14 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import net.sf.cglib.reflect.FastClass;
+import net.sf.cglib.reflect.FastMethod;
 
 /**
  * Default {@link Container} implementation.
  *
- * @see ContainerBuilder
  * @author crazybob@google.com (Bob Lee)
+ * @see ContainerBuilder
  */
 class ContainerImpl implements Container {
 
@@ -78,13 +78,13 @@
     PRIMITIVE_COUNTERPARTS = Collections.unmodifiableMap(counterparts);
   }
 
-  private static final Map<Class<?>, Converter<?>> PRIMITIVE_CONVERTERS =
-      new PrimitiveConverters();
+  private static final Map<Class<?>, Converter<?>> PRIMITIVE_CONVERTERS
+      = new PrimitiveConverters();
 
   final ConstructionProxyFactory constructionProxyFactory;
   final Map<Key<?>, Binding<?>> bindings;
-  final Map<TypeLiteral<?>, List<Binding<?>>> bindingsByType =
-      new HashMap<TypeLiteral<?>, List<Binding<?>>>();
+  final Map<TypeLiteral<?>, List<Binding<?>>> bindingsByType
+      = new HashMap<TypeLiteral<?>, List<Binding<?>>>();
 
   ErrorHandler errorHandler = new InvalidErrorHandler();
 
@@ -116,7 +116,7 @@
   public <T> List<Binding<T>> findBindingsByType(TypeLiteral<T> type) {
     // IntelliJ doesn't understand that the below is "correct"
     //noinspection RedundantCast,RawUseOfParameterizedType
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     List<Binding<T>> bindingsForThisType = (List) bindingsByType.get(type);
     if (bindingsForThisType == null) {
       return Collections.emptyList();
@@ -137,7 +137,8 @@
     this.errorHandler = errorHandler;
     try {
       runnable.run();
-    } finally {
+    }
+    finally {
       this.errorHandler = previous;
     }
   }
@@ -161,19 +162,20 @@
       if (!(factoryType instanceof ParameterizedType)) {
         return null;
       }
-      Type entryType =
-          ((ParameterizedType) factoryType).getActualTypeArguments()[0];
+      Type entryType
+          = ((ParameterizedType) factoryType).getActualTypeArguments()[0];
 
       try {
-        final Factory<?> factory =
-            getFactory(Key.get(entryType, key.getName()));
+        final Factory<?> factory
+            = getFactory(Key.get(entryType, key.getName()));
         return new InternalFactory<T>() {
-          @SuppressWarnings({"unchecked"})
+          @SuppressWarnings("unchecked")
           public T get(InternalContext context) {
             return (T) factory;
           }
         };
-      } catch (ConfigurationException e) {
+      }
+      catch (ConfigurationException e) {
         ErrorMessages.handleMissingBinding(errorHandler, member, key,
             getNamesOfBindingsTo(key.getType()));
         return invalidFactory();
@@ -181,11 +183,11 @@
     }
 
     // Auto[un]box primitives.
-    Class<?> primitiveCounterpart =
-        PRIMITIVE_COUNTERPARTS.get(key.getType().getRawType());
+    Class<?> primitiveCounterpart
+        = PRIMITIVE_COUNTERPARTS.get(key.getType().getRawType());
     if (primitiveCounterpart != null) {
-      Binding<?> counterpartBinding =
-          getBinding(Key.get(primitiveCounterpart, key.getName()));
+      Binding<?> counterpartBinding
+          = getBinding(Key.get(primitiveCounterpart, key.getName()));
       if (counterpartBinding != null) {
         return (InternalFactory<? extends T>)
             counterpartBinding.getInternalFactory();
@@ -193,8 +195,8 @@
     }
 
     // Do we have a constant String factory of the same name?
-    Binding<String> stringBinding =
-        getBinding(Key.get(String.class, key.getName()));
+    Binding<String> stringBinding
+        = getBinding(Key.get(String.class, key.getName()));
     if (stringBinding == null || !stringBinding.isConstant()) {
       return null;
     }
@@ -214,7 +216,8 @@
       try {
         T t = converter.convert(member, key, value);
         return new ConstantFactory<T>(t);
-      } catch (ConstantConversionException e) {
+      }
+      catch (ConstantConversionException e) {
         errorHandler.handle(e);
         return null;
       }
@@ -222,13 +225,12 @@
 
     // Do we need an enum?
     if (Enum.class.isAssignableFrom(type)) {
-      T t = null;
+      T t;
       try {
         t = (T) Enum.valueOf((Class) type, value);
-      } catch (IllegalArgumentException e) {
-        errorHandler.handle(
-            ConstantConversionException.createMessage(
-                value, key, member, e.toString()));
+      }
+      catch (IllegalArgumentException e) {
+        errorHandler.handle(createMessage(value, key, member, e.toString()));
         return invalidFactory();
       }
       return new ConstantFactory<T>(t);
@@ -238,10 +240,9 @@
     if (type == Class.class) {
       try {
         return new ConstantFactory<T>((T) Class.forName(value));
-      } catch (ClassNotFoundException e) {
-        errorHandler.handle(
-            ConstantConversionException.createMessage(
-                value, key, member, e.toString()));
+      }
+      catch (ClassNotFoundException e) {
+        errorHandler.handle(createMessage(value, key, member, e.toString()));
         return invalidFactory();
       }
     }
@@ -258,19 +259,19 @@
   /**
    * Field and method injectors.
    */
-  final Map<Class<?>, List<Injector>> injectors =
-      new ReferenceCache<Class<?>, List<Injector>>() {
-        protected List<Injector> create(Class<?> key) {
-          if (key.isInterface()) {
-            errorHandler.handle(ErrorMessages.CANNOT_INJECT_INTERFACE, key);
-            return Collections.emptyList();
-          }
+  final Map<Class<?>, List<Injector>> injectors
+      = new ReferenceCache<Class<?>, List<Injector>>() {
+    protected List<Injector> create(Class<?> key) {
+      if (key.isInterface()) {
+        errorHandler.handle(ErrorMessages.CANNOT_INJECT_INTERFACE, key);
+        return Collections.emptyList();
+      }
 
-          List<Injector> injectors = new ArrayList<Injector>();
-          addInjectors(key, injectors);
-          return injectors;
-        }
-      };
+      List<Injector> injectors = new ArrayList<Injector>();
+      addInjectors(key, injectors);
+      return injectors;
+    }
+  };
 
   /**
    * Recursively adds injectors for fields and methods from the given class to
@@ -320,7 +321,8 @@
         if (inject != null) {
           try {
             injectors.add(injectorFactory.create(this, member, inject.value()));
-          } catch (MissingDependencyException e) {
+          }
+          catch (MissingDependencyException e) {
             if (inject.required()) {
               // TODO: Report errors for more than one parameter per member.
               e.handle(errorHandler);
@@ -339,7 +341,7 @@
     return Collections.unmodifiableMap(bindings);
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <T> Binding<T> getBinding(Key<T> key) {
     return (Binding<T>) bindings.get(key);
   }
@@ -380,9 +382,11 @@
       context.setExternalContext(externalContext);
       try {
         field.set(o, factory.get(context));
-      } catch (IllegalAccessException e) {
+      }
+      catch (IllegalAccessException e) {
         throw new AssertionError(e);
-      } finally {
+      }
+      finally {
         context.setExternalContext(previous);
       }
     }
@@ -396,8 +400,8 @@
    * @param parameterTypes parameter types
    * @return injections
    */
-  <M extends AccessibleObject & Member> ParameterInjector<?>[]
-      getParametersInjectors(M member,
+  <M extends AccessibleObject & Member>
+  ParameterInjector<?>[] getParametersInjectors(M member,
       Annotation[][] annotations, Type[] parameterTypes, String defaultName)
       throws MissingDependencyException {
     boolean defaultNameOverridden = !defaultName.equals(Key.DEFAULT_NAME);
@@ -409,11 +413,10 @@
           ErrorMessages.NAME_ON_MEMBER_WITH_MULTIPLE_PARAMS, member);
     }
 
-    List<ParameterInjector<?>> parameterInjectors =
-        new ArrayList<ParameterInjector<?>>();
-
-    Iterator<Annotation[]> annotationsIterator =
-        Arrays.asList(annotations).iterator();
+    ParameterInjector<?>[] parameterInjectors
+        = new ParameterInjector<?>[parameterTypes.length];
+    Iterator<Annotation[]> annotationsIterator
+        = Arrays.asList(annotations).iterator();
     int index = 0;
     for (Type parameterType : parameterTypes) {
       Inject annotation = findInject(annotationsIterator.next());
@@ -425,36 +428,31 @@
           errorHandler.handle(
               ErrorMessages.NAME_ON_MEMBER_AND_PARAMETER, member);
         }
-      } else {
+      }
+      else {
         name = annotation == null ? defaultName : annotation.value();
       }
 
       Key<?> key = Key.get(parameterType, name);
-      parameterInjectors.add(createParameterInjector(key, member, index++));
+      parameterInjectors[index] = createParameterInjector(key, member, index);
+      index++;
     }
 
-    return toArray(parameterInjectors);
+    return parameterInjectors;
   }
 
-  <T> ParameterInjector<T> createParameterInjector(
-      Key<T> key, Member member, int index) throws MissingDependencyException {
+  <T> ParameterInjector<T> createParameterInjector(Key<T> key, Member member,
+      int index) throws MissingDependencyException {
     InternalFactory<? extends T> factory = getFactory(member, key);
     if (factory == null) {
       throw new MissingDependencyException(key, member);
     }
 
-    ExternalContext<T> externalContext =
-        ExternalContext.newInstance(member, index, key, this);
+    ExternalContext<T> externalContext
+        = ExternalContext.newInstance(member, index, key, this);
     return new ParameterInjector<T>(externalContext, factory);
   }
 
-  @SuppressWarnings("unchecked")
-  private ParameterInjector<?>[] toArray(
-      List<ParameterInjector<?>> parameterInjections) {
-    return parameterInjections.toArray(
-        new ParameterInjector[parameterInjections.size()]);
-  }
-
   /**
    * Finds the {@link Inject} annotation in an array of annotations.
    */
@@ -474,8 +472,8 @@
 
     public MethodInjector(ContainerImpl container, Method method, String name)
         throws MissingDependencyException {
-      this.fastMethod =
-          GuiceFastClass.create(method.getDeclaringClass()).getMethod(method);
+      FastClass fastClass = GuiceFastClass.create(method.getDeclaringClass());
+      this.fastMethod = fastClass.getMethod(method);
       Type[] parameterTypes = method.getGenericParameterTypes();
       parameterInjectors = parameterTypes.length > 0
           ? container.getParametersInjectors(
@@ -486,24 +484,25 @@
     public void inject(InternalContext context, Object o) {
       try {
         fastMethod.invoke(o, getParameters(context, parameterInjectors));
-      } catch (Exception e) {
+      }
+      catch (Exception e) {
         throw new RuntimeException(e);
       }
     }
   }
 
-  final Map<Class<?>, ConstructorInjector> constructors =
-      new ReferenceCache<Class<?>, ConstructorInjector>() {
-        @SuppressWarnings("unchecked")
-        protected ConstructorInjector<?> create(Class<?> implementation) {
-          if (implementation.isInterface()) {
-            errorHandler.handle(ErrorMessages.CANNOT_INJECT_INTERFACE,
-                implementation);
-          }
+  final Map<Class<?>, ConstructorInjector> constructors
+      = new ReferenceCache<Class<?>, ConstructorInjector>() {
+    @SuppressWarnings("unchecked")
+    protected ConstructorInjector<?> create(Class<?> implementation) {
+      if (implementation.isInterface()) {
+        errorHandler.handle(
+            ErrorMessages.CANNOT_INJECT_INTERFACE, implementation);
+      }
 
-          return new ConstructorInjector(ContainerImpl.this, implementation);
-        }
-      };
+      return new ConstructorInjector(ContainerImpl.this, implementation);
+    }
+  };
 
   /**
    * A placeholder. This enables us to continue processing and gather more
@@ -515,11 +514,12 @@
     }
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   static <T> Constructor<T> invalidConstructor() {
     try {
       return (Constructor<T>) InvalidConstructor.class.getDeclaredConstructor();
-    } catch (NoSuchMethodException e) {
+    }
+    catch (NoSuchMethodException e) {
       throw new AssertionError(e);
     }
   }
@@ -540,7 +540,8 @@
       context.setExternalContext(externalContext);
       try {
         return factory.get(context);
-      } finally {
+      }
+      finally {
         context.setExternalContext(previous);
       }
     }
@@ -623,8 +624,8 @@
     final InternalFactory<? extends T> factory = getFactory(null, key);
 
     if (factory == null) {
-      throw new ConfigurationException("Missing binding to " +
-          AbstractErrorHandler.convert(key) + ".");
+      throw new ConfigurationException(
+          "Missing binding to " + AbstractErrorHandler.convert(key) + ".");
     }
 
     return new Factory<T>() {
@@ -636,7 +637,8 @@
                 ExternalContext.newInstance(null, key, ContainerImpl.this));
             try {
               return factory.get(context);
-            } finally {
+            }
+            finally {
               context.setExternalContext(previous);
             }
           }
@@ -645,12 +647,12 @@
     };
   }
 
-  final ThreadLocal<InternalContext[]> localContext =
-      new ThreadLocal<InternalContext[]>() {
-        protected InternalContext[] initialValue() {
-          return new InternalContext[1];
-        }
-      };
+  final ThreadLocal<InternalContext[]> localContext
+      = new ThreadLocal<InternalContext[]>() {
+    protected InternalContext[] initialValue() {
+      return new InternalContext[1];
+    }
+  };
 
   /**
    * Looks up thread local context. Creates (and removes) a new context if
@@ -662,11 +664,13 @@
       reference[0] = new InternalContext(this);
       try {
         return callable.call(reference[0]);
-      } finally {
+      }
+      finally {
         // Only remove the context if this call created it.
         reference[0] = null;
       }
-    } else {
+    }
+    else {
       // Someone else will clean up this context.
       return callable.call(reference[0]);
     }
@@ -741,17 +745,19 @@
     <T> void putParser(final Class<T> primitive) {
       try {
         Class<?> wrapper = PRIMITIVE_COUNTERPARTS.get(primitive);
-        final Method parser = wrapper.getMethod("parse" +
-            Strings.capitalize(primitive.getName()), String.class);
+        final Method parser = wrapper.getMethod(
+            "parse" + Strings.capitalize(primitive.getName()), String.class);
         Converter<T> converter = new Converter<T>() {
-          @SuppressWarnings({"unchecked"})
+          @SuppressWarnings("unchecked")
           public T convert(Member member, Key<T> key, String value)
               throws ConstantConversionException {
             try {
               return (T) parser.invoke(null, value);
-            } catch (IllegalAccessException e) {
+            }
+            catch (IllegalAccessException e) {
               throw new AssertionError(e);
-            } catch (InvocationTargetException e) {
+            }
+            catch (InvocationTargetException e) {
               throw new ConstantConversionException(member, key, value,
                   e.getTargetException());
             }
@@ -759,7 +765,8 @@
         };
         put(wrapper, converter);
         put(primitive, converter);
-      } catch (NoSuchMethodException e) {
+      }
+      catch (NoSuchMethodException e) {
         throw new AssertionError(e);
       }
     }
@@ -777,14 +784,14 @@
         throws ConstantConversionException;
   }
 
-  private static final InternalFactory<?> INVALID_FACTORY =
-      new InternalFactory<Object>() {
-        public Object get(InternalContext context) {
-          throw new AssertionError();
-        }
-      };
+  private static final InternalFactory<?> INVALID_FACTORY
+      = new InternalFactory<Object>() {
+    public Object get(InternalContext context) {
+      throw new AssertionError();
+    }
+  };
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   static <T> InternalFactory<T> invalidFactory() {
     return (InternalFactory<T>) INVALID_FACTORY;
   }
diff --git a/src/com/google/inject/ContainerScoped.java b/src/com/google/inject/ContainerScoped.java
index 7d1408e..8a6175d 100644
--- a/src/com/google/inject/ContainerScoped.java
+++ b/src/com/google/inject/ContainerScoped.java
@@ -16,10 +16,10 @@
 
 package com.google.inject;
 
-import java.lang.annotation.Target;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
+import java.lang.annotation.Target;
 
 /**
  * Apply this to implementation classes when you want one instance per
@@ -27,7 +27,7 @@
  *
  * @author crazybob@google.com (Bob Lee)
  */
-@Target(ElementType.TYPE)
-@Retention(RUNTIME)
-@Scoped(Scopes.CONTAINER_NAME)
-public @interface ContainerScoped {}
+@Target(ElementType.TYPE) @Retention(RUNTIME) @Scoped(Scopes.CONTAINER_NAME)
+public @interface ContainerScoped {
+
+}
diff --git a/src/com/google/inject/Context.java b/src/com/google/inject/Context.java
index 536ea50..52265cf 100644
--- a/src/com/google/inject/Context.java
+++ b/src/com/google/inject/Context.java
@@ -38,8 +38,8 @@
   Member getMember();
 
   /**
-   * Gets the index of the parameter which is being injected. Returns
-   * {@code -1} if a parameter isn't being injected.
+   * Gets the index of the parameter which is being injected. Returns {@code -1}
+   * if a parameter isn't being injected.
    */
   int getParameterIndex();
 
diff --git a/src/com/google/inject/DefaultConstructionProxyFactory.java b/src/com/google/inject/DefaultConstructionProxyFactory.java
index 02c8266..d414a53 100644
--- a/src/com/google/inject/DefaultConstructionProxyFactory.java
+++ b/src/com/google/inject/DefaultConstructionProxyFactory.java
@@ -17,12 +17,10 @@
 package com.google.inject;
 
 import com.google.inject.util.GuiceFastClass;
-
-import net.sf.cglib.reflect.FastClass;
-import net.sf.cglib.reflect.FastConstructor;
-
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import net.sf.cglib.reflect.FastClass;
+import net.sf.cglib.reflect.FastConstructor;
 
 /**
  * Default {@link ConstructionProxyFactory} implementation. Simply invokes the
@@ -31,16 +29,15 @@
  *
  * @author crazybob@google.com (Bob Lee)
  */
-class DefaultConstructionProxyFactory
-    implements ConstructionProxyFactory {
+class DefaultConstructionProxyFactory implements ConstructionProxyFactory {
 
   public <T> ConstructionProxy<T> get(Constructor<T> constructor) {
-    FastClass fastClass =
-        GuiceFastClass.create(constructor.getDeclaringClass());
-    final FastConstructor fastConstructor =
-        fastClass.getConstructor(constructor);
+    Class<T> classToConstruct = constructor.getDeclaringClass();
+    FastClass fastClass = GuiceFastClass.create(classToConstruct);
+    final FastConstructor fastConstructor
+        = fastClass.getConstructor(constructor);
     return new ConstructionProxy<T>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public T newInstance(Object... arguments)
           throws InvocationTargetException {
         return (T) fastConstructor.newInstance(arguments);
diff --git a/src/com/google/inject/ErrorMessages.java b/src/com/google/inject/ErrorMessages.java
index fe5ef5f..904fe77 100644
--- a/src/com/google/inject/ErrorMessages.java
+++ b/src/com/google/inject/ErrorMessages.java
@@ -38,9 +38,10 @@
       Key<?> key, List<String> otherNames) {
     if (otherNames.isEmpty()) {
       errorHandler.handle(MISSING_BINDING, key, member);
-    } else {
-      errorHandler.handle(MISSING_BINDING_BUT_OTHERS_EXIST,
-          key, member, otherNames);
+    }
+    else {
+      errorHandler.handle(
+          MISSING_BINDING_BUT_OTHERS_EXIST, key, member, otherNames);
     }
   }
 
@@ -54,8 +55,7 @@
   static final String TOO_MANY_CONSTRUCTORS = "More than one constructor"
       + " annotated with @Inject found in %s. " + CONSTRUCTOR_RULES;
 
-  static final String DUPLICATE_SCOPES =
-      "A scope named '%s' already exists.";
+  static final String DUPLICATE_SCOPES = "A scope named '%s' already exists.";
 
   static final String MISSING_CONSTANT_VALUE = "Missing constant value. Please"
       + " call to(...).";
@@ -70,8 +70,8 @@
 
   static final String NAME_ALREADY_SET = "Binding name is set more than once.";
 
-  static final String IMPLEMENTATION_ALREADY_SET =
-      "Implementation is set more than once.";
+  static final String IMPLEMENTATION_ALREADY_SET = "Implementation is set more"
+      + " than once.";
 
   static final String SCOPE_NOT_FOUND = "Scope named '%s' not found."
       + " Available scope names: %s";
@@ -82,8 +82,8 @@
       + " implementation with with an annotation which is annotated with"
       + " @Scoped.";
 
-  static final String CONSTANT_VALUE_ALREADY_SET =
-      "Constant value is set more than once.";
+  static final String CONSTANT_VALUE_ALREADY_SET = "Constant value is set more"
+      + " than once.";
 
   static final String LINK_DESTINATION_ALREADY_SET = "Link destination is"
       + " set more than once.";
diff --git a/src/com/google/inject/ExternalContext.java b/src/com/google/inject/ExternalContext.java
index abea51d..e299652 100644
--- a/src/com/google/inject/ExternalContext.java
+++ b/src/com/google/inject/ExternalContext.java
@@ -20,8 +20,8 @@
 import java.util.LinkedHashMap;
 
 /**
- * An immutable snapshot of the current context which is safe to
- * expose to client code.
+ * An immutable snapshot of the current context which is safe to expose to
+ * client code.
  *
  * @author crazybob@google.com (Bob Lee)
  */
@@ -64,8 +64,8 @@
     }}.toString();
   }
 
-  static <T> ExternalContext<T> newInstance(Member member,
-      Key<T> key, ContainerImpl container) {
+  static <T> ExternalContext<T> newInstance(
+      Member member, Key<T> key, ContainerImpl container) {
     return new ExternalContext<T>(member, -1, key, container);
   }
 
diff --git a/src/com/google/inject/FactoryToInternalFactoryAdapter.java b/src/com/google/inject/FactoryToInternalFactoryAdapter.java
index ec975f8..6f4149c 100644
--- a/src/com/google/inject/FactoryToInternalFactoryAdapter.java
+++ b/src/com/google/inject/FactoryToInternalFactoryAdapter.java
@@ -18,7 +18,7 @@
 
 /**
  * @author crazybob@google.com (Bob Lee)
-*/
+ */
 class FactoryToInternalFactoryAdapter<T> implements Factory<T> {
 
   private final ContainerImpl container;
@@ -32,8 +32,7 @@
   }
 
   public T get() {
-    return container.callInContext(
-        new ContextualCallable<T>() {
+    return container.callInContext(new ContextualCallable<T>() {
       public T call(InternalContext context) {
         return internalFactory.get(context);
       }
diff --git a/src/com/google/inject/Inject.java b/src/com/google/inject/Inject.java
index ea04dbf..087d6ca 100644
--- a/src/com/google/inject/Inject.java
+++ b/src/com/google/inject/Inject.java
@@ -16,9 +16,12 @@
 
 package com.google.inject;
 
-import static java.lang.annotation.ElementType.*;
+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.*;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
 import java.lang.annotation.Target;
 
 /**
@@ -27,7 +30,7 @@
  *
  * @author crazybob@google.com (Bob Lee)
  */
-@Target({METHOD, CONSTRUCTOR, FIELD, PARAMETER})
+@Target({ METHOD, CONSTRUCTOR, FIELD, PARAMETER })
 @Retention(RUNTIME)
 public @interface Inject {
 
@@ -37,8 +40,8 @@
   String value() default Key.DEFAULT_NAME;
 
   /**
-   * Whether or not injection is required. Applicable only to methods and
-   * fields (not constructors or parameters).
+   * Whether or not injection is required. Applicable only to methods and fields
+   * (not constructors or parameters).
    */
   boolean required() default true;
 }
diff --git a/src/com/google/inject/InterceptorStackCallback.java b/src/com/google/inject/InterceptorStackCallback.java
index 015a045..ad74e69 100644
--- a/src/com/google/inject/InterceptorStackCallback.java
+++ b/src/com/google/inject/InterceptorStackCallback.java
@@ -16,15 +16,13 @@
 
 package com.google.inject;
 
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Method;
+import java.util.List;
 import net.sf.cglib.proxy.MethodProxy;
-
 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
 
-import java.lang.reflect.Method;
-import java.lang.reflect.AccessibleObject;
-import java.util.List;
-
 /**
  * Intercepts a method with a stack of interceptors.
  *
@@ -38,14 +36,14 @@
   public InterceptorStackCallback(Method method,
       List<MethodInterceptor> interceptors) {
     this.method = method;
-    this.interceptors = interceptors.toArray(
-        new MethodInterceptor[interceptors.size()]);
+    this.interceptors
+        = interceptors.toArray(new MethodInterceptor[interceptors.size()]);
   }
 
   public Object intercept(Object proxy, Method method, Object[] arguments,
       MethodProxy methodProxy) throws Throwable {
-    return new InterceptedMethodInvocation(
-        proxy, methodProxy, arguments).proceed();
+    return new InterceptedMethodInvocation(proxy, methodProxy, arguments)
+        .proceed();
   }
 
   class InterceptedMethodInvocation implements MethodInvocation {
@@ -66,9 +64,10 @@
       try {
         index++;
         return index == interceptors.length
-          ? methodProxy.invokeSuper(proxy, arguments)
-          : interceptors[index].invoke(this);
-      } finally {
+            ? methodProxy.invokeSuper(proxy, arguments)
+            : interceptors[index].invoke(this);
+      }
+      finally {
         index--;
       }
     }
diff --git a/src/com/google/inject/InternalContext.java b/src/com/google/inject/InternalContext.java
index e8184f9..4b35c39 100644
--- a/src/com/google/inject/InternalContext.java
+++ b/src/com/google/inject/InternalContext.java
@@ -16,8 +16,8 @@
 
 package com.google.inject;
 
-import java.util.Map;
 import java.util.HashMap;
+import java.util.Map;
 
 /**
  * Internal context. Used to coordinate injections and support circular
@@ -50,9 +50,10 @@
       ConstructionContext<T> constructionContext = new ConstructionContext<T>();
       constructionContexts.put(key, constructionContext);
       return constructionContext;
-    } else {
-      ConstructionContext<T> constructionContext =
-          (ConstructionContext<T>) constructionContexts.get(key);
+    }
+    else {
+      ConstructionContext<T> constructionContext
+          = (ConstructionContext<T>) constructionContexts.get(key);
       if (constructionContext == null) {
         constructionContext = new ConstructionContext<T>();
         constructionContexts.put(key, constructionContext);
diff --git a/src/com/google/inject/InternalToContextualFactoryAdapter.java b/src/com/google/inject/InternalToContextualFactoryAdapter.java
index 1f916d3..6256829 100644
--- a/src/com/google/inject/InternalToContextualFactoryAdapter.java
+++ b/src/com/google/inject/InternalToContextualFactoryAdapter.java
@@ -19,8 +19,7 @@
 /**
  * @author crazybob@google.com (Bob Lee)
 */
-class InternalToContextualFactoryAdapter<T> 
-    implements InternalFactory<T> {
+class InternalToContextualFactoryAdapter<T> implements InternalFactory<T> {
 
   private final ContextualFactory<? extends T> factory;
 
diff --git a/src/com/google/inject/Key.java b/src/com/google/inject/Key.java
index 3902a63..bc40e75 100644
--- a/src/com/google/inject/Key.java
+++ b/src/com/google/inject/Key.java
@@ -17,17 +17,16 @@
 package com.google.inject;
 
 import static com.google.inject.util.Objects.nonNull;
-
 import java.lang.reflect.Type;
 
 /**
- * Binding key consisting of a type and a name. Matches the type and
- * name ({@link Inject#value()}) at a point of injection.
+ * Binding key consisting of a type and a name. Matches the type and name
+ * ({@link Inject#value()}) at a point of injection.
  *
- * <p>For example, <tt>new Key&lt;List&lt;String>>("cities") {}</tt> will match:
+ * <p>For example, {@code new Key<List<String>>("cities") {}} will match:
  *
  * <pre>
- *   &#64;Inject("cities")
+ *   {@literal @}Inject("cities")
  *   public void setList(List&lt;String> cities) {
  *     ...
  *   }
@@ -50,17 +49,17 @@
    * Constructs a new key. Derives the type from this class's type parameter.
    *
    * <p>Clients create an empty anonymous subclass. Doing so embeds the type
-   * parameter in the anonymous class's type hierarchy so we can reconstitute
-   * it at runtime despite erasure.
+   * parameter in the anonymous class's type hierarchy so we can reconstitute it
+   * at runtime despite erasure.
    *
    * <p>Example usage for a binding of type {@code Foo} named "bar":
    * {@code new Key<Foo>("bar") {}}.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   protected Key(String name) {
     this.name = nonNull(name, "name");
-    this.typeLiteral =
-        (TypeLiteral<T>) TypeLiteral.fromSuperclassTypeParameter(getClass());
+    this.typeLiteral
+        = (TypeLiteral<T>) TypeLiteral.fromSuperclassTypeParameter(getClass());
     this.hashCode = computeHashCode();
   }
 
@@ -75,16 +74,14 @@
   /**
    * Unsafe. Constructs a key from a manually specified type.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   private Key(Type type, String name) {
     this.name = nonNull(name, "name");
     this.typeLiteral = (TypeLiteral<T>) TypeLiteral.get(type);
     this.hashCode = computeHashCode();
   }
 
-  /**
-   * Constructs a key from a manually specified type.
-   */
+  /** Constructs a key from a manually specified type. */
   private Key(TypeLiteral<T> typeLiteral, String name) {
     this.name = nonNull(name, "name");
     this.typeLiteral = typeLiteral;
@@ -119,7 +116,7 @@
   /**
    * Gets the binding name.
    */
-  public String getName() {
+ public String getName() {
     return name;
   }
 
diff --git a/src/com/google/inject/MethodAspect.java b/src/com/google/inject/MethodAspect.java
index 2d71add..19bcd31 100644
--- a/src/com/google/inject/MethodAspect.java
+++ b/src/com/google/inject/MethodAspect.java
@@ -16,14 +16,12 @@
 
 package com.google.inject;
 
-import com.google.inject.util.Objects;
 import com.google.inject.query.Query;
-
-import org.aopalliance.intercept.MethodInterceptor;
-
+import com.google.inject.util.Objects;
 import java.lang.reflect.Method;
-import java.util.List;
 import java.util.Arrays;
+import java.util.List;
+import org.aopalliance.intercept.MethodInterceptor;
 
 /**
  * Ties a query to a method interceptor.
@@ -36,12 +34,12 @@
   final Query<? super Method> methodQuery;
   final List<MethodInterceptor> interceptors;
 
-  MethodAspect(Query<? super Class<?>> classQuery, Query<? super Method> methodQuery,
-      MethodInterceptor... interceptors) {
+  MethodAspect(Query<? super Class<?>> classQuery,
+      Query<? super Method> methodQuery, MethodInterceptor... interceptors) {
     this.classQuery = Objects.nonNull(classQuery, "class query");
     this.methodQuery = Objects.nonNull(methodQuery, "method query");
-    this.interceptors =
-        Arrays.asList(Objects.nonNull(interceptors, "interceptors"));
+    this.interceptors
+        = Arrays.asList(Objects.nonNull(interceptors, "interceptors"));
   }
 
   boolean matches(Class<?> clazz) {
diff --git a/src/com/google/inject/ProxyFactory.java b/src/com/google/inject/ProxyFactory.java
index 8ec4f9a..55eb5e1 100644
--- a/src/com/google/inject/ProxyFactory.java
+++ b/src/com/google/inject/ProxyFactory.java
@@ -19,16 +19,6 @@
 import com.google.inject.util.GuiceFastClass;
 import com.google.inject.util.GuiceNamingPolicy;
 import com.google.inject.util.ReferenceCache;
-
-import net.sf.cglib.proxy.Callback;
-import net.sf.cglib.proxy.CallbackFilter;
-import net.sf.cglib.proxy.Enhancer;
-import net.sf.cglib.proxy.NoOp;
-import net.sf.cglib.reflect.FastClass;
-import net.sf.cglib.reflect.FastConstructor;
-
-import org.aopalliance.intercept.MethodInterceptor;
-
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -36,6 +26,13 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import net.sf.cglib.proxy.Callback;
+import net.sf.cglib.proxy.CallbackFilter;
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.NoOp;
+import net.sf.cglib.reflect.FastClass;
+import net.sf.cglib.reflect.FastConstructor;
+import org.aopalliance.intercept.MethodInterceptor;
 
 /**
  * Proxies classes applying interceptors to methods as specified in
@@ -46,15 +43,15 @@
 class ProxyFactory implements ConstructionProxyFactory {
 
   final List<MethodAspect> methodAspects;
-  final ConstructionProxyFactory defaultFactory =
-      new DefaultConstructionProxyFactory();
+  final ConstructionProxyFactory defaultFactory
+      = new DefaultConstructionProxyFactory();
 
   ProxyFactory(List<MethodAspect> methodAspects) {
     this.methodAspects = methodAspects;
   }
 
-  Map<Constructor<?>, ConstructionProxy<?>> constructionProxies =
-      new ReferenceCache<Constructor<?>, ConstructionProxy<?>>() {
+  Map<Constructor<?>, ConstructionProxy<?>> constructionProxies
+      = new ReferenceCache<Constructor<?>, ConstructionProxy<?>>() {
     protected ConstructionProxy<?> create(Constructor<?> constructor) {
       return createConstructionProxy(constructor);
     }
@@ -62,17 +59,18 @@
 
   /**
    * Gets a factory for the given type. Uses the zero-arg constructor. Wraps
-   * exceptions in {@code RuntimeException} including
-   * {@code InvocationTargetException}.
+   * exceptions in {@link RuntimeException} including
+   * {@link InvocationTargetException}.
    */
   public <T> Factory<T> getFactory(Class<T> type) throws NoSuchMethodException {
-    final ConstructionProxy<T> constructionProxy =
-        createConstructionProxy(type.getDeclaredConstructor());
+    final ConstructionProxy<T> constructionProxy
+        = createConstructionProxy(type.getDeclaredConstructor());
     return new Factory<T>() {
       public T get() {
         try {
           return constructionProxy.newInstance();
-        } catch (InvocationTargetException e) {
+        }
+        catch (InvocationTargetException e) {
           throw new RuntimeException(e);
         }
       }
@@ -99,22 +97,20 @@
     final Map<Method, Integer> indices = new HashMap<Method, Integer>();
 
     // Create method/interceptor holders and record indices.
-    List<MethodInterceptorsPair> methodInterceptorsPairs =
-        new ArrayList<MethodInterceptorsPair>();
+    List<MethodInterceptorsPair> methodInterceptorsPairs
+        = new ArrayList<MethodInterceptorsPair>();
     for (int i = 0; i < methods.size(); i++) {
       Method method = methods.get(i);
       methodInterceptorsPairs.add(new MethodInterceptorsPair(method));
       indices.put(method, i);
     }
 
-    // Iterate over aspects and add interceptors for the methods they apply
-    // to.
+    // Iterate over aspects and add interceptors for the methods they apply to
     boolean anyMatched = false;
     for (MethodAspect methodAspect : applicableAspects) {
-      for (MethodInterceptorsPair methodInterceptorsPair
-          : methodInterceptorsPairs) {
-        if (methodAspect.matches(methodInterceptorsPair.method)) {
-          methodInterceptorsPair.addAll(methodAspect.interceptors());
+      for (MethodInterceptorsPair pair : methodInterceptorsPairs) {
+        if (methodAspect.matches(pair.method)) {
+          pair.addAll(methodAspect.interceptors());
           anyMatched = true;
         }
       }
@@ -128,14 +124,14 @@
     // noinspection unchecked
     Class<? extends Callback>[] callbackTypes = new Class[methods.size()];
     for (int i = 0; i < methods.size(); i++) {
-      MethodInterceptorsPair methodInterceptorsPair =
-          methodInterceptorsPairs.get(i);
-      if (!methodInterceptorsPair.hasInterceptors()) {
+      MethodInterceptorsPair pair = methodInterceptorsPairs.get(i);
+      if (!pair.hasInterceptors()) {
         callbacks[i] = NoOp.INSTANCE;
         callbackTypes[i] = NoOp.class;
-      } else {
+      }
+      else {
         callbacks[i] = new InterceptorStackCallback(
-            methodInterceptorsPair.method, methodInterceptorsPair.interceptors);
+            pair.method, pair.interceptors);
         callbackTypes[i] = net.sf.cglib.proxy.MethodInterceptor.class;
       }
     }
@@ -167,10 +163,10 @@
   <T> ConstructionProxy<T> createConstructionProxy(Class<?> clazz,
       Class[] parameterTypes) {
     FastClass fastClass = GuiceFastClass.create(clazz);
-    final FastConstructor fastConstructor =
-        fastClass.getConstructor(parameterTypes);
+    final FastConstructor fastConstructor
+        = fastClass.getConstructor(parameterTypes);
     return new ConstructionProxy<T>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public T newInstance(Object... arguments)
           throws InvocationTargetException {
         return (T) fastConstructor.newInstance(arguments);
@@ -199,7 +195,7 @@
     }
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <T> ConstructionProxy<T> get(Constructor<T> constructor) {
     return (ConstructionProxy<T>) constructionProxies.get(constructor);
   }
diff --git a/src/com/google/inject/ProxyFactoryBuilder.java b/src/com/google/inject/ProxyFactoryBuilder.java
index 597b047..99810e1 100644
--- a/src/com/google/inject/ProxyFactoryBuilder.java
+++ b/src/com/google/inject/ProxyFactoryBuilder.java
@@ -17,12 +17,10 @@
 package com.google.inject;
 
 import com.google.inject.query.Query;
-
-import org.aopalliance.intercept.MethodInterceptor;
-
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
+import org.aopalliance.intercept.MethodInterceptor;
 
 /**
  * Creates a {@link ProxyFactory}.
@@ -38,9 +36,9 @@
    * and method queries.
    *
    * @param classQuery matches classes the interceptor should apply to. For
-   *  example: {@code only(Runnable.class)}.
+   *     example: {@code only(Runnable.class)}.
    * @param methodQuery matches methods the interceptor should apply to. For
-   *  example: {@code annotatedWith(Transactional.class)}.
+   *     example: {@code annotatedWith(Transactional.class)}.
    * @param interceptors to apply
    */
   public ProxyFactoryBuilder intercept(Query<? super Class<?>> classQuery,
diff --git a/src/com/google/inject/Scope.java b/src/com/google/inject/Scope.java
index bd94191..9b62f81 100644
--- a/src/com/google/inject/Scope.java
+++ b/src/com/google/inject/Scope.java
@@ -17,26 +17,25 @@
 package com.google.inject;
 
 /**
- * A scope which bound objects can reside in. Add a new scope using {@link
- * com.google.inject.ContainerBuilder#scope(String, Scope)} and reference it from
- * bindings using its name.
+ * A scope which bound objects can reside in. Add a new scope using
+ * {@link ContainerBuilder#scope} and reference it from bindings using its name.
  *
- * <p>Scope implementations should override {@code toString()} and include the
- * creator's {@code toString()} output. Doing so aids debugging.
+ * <p>Scope implementations should override {@link #toString} and include the
+ * creator's {#toString} output. Doing so aids debugging.
  *
  * @author crazybob@google.com (Bob Lee)
  */
 public interface Scope {
 
   /**
-   * Scopes a factory. The returned factory returns objects from this scope.
-   * If an object does not exist in this scope, the factory can use the given
+   * Scopes a factory. The returned factory returns objects from this scope. If
+   * an object does not exist in this scope, the factory can use the given
    * creator to create one.
    *
    * @param key binding key
    * @param creator creates new instances as needed
    * @return a new factory which only delegates to the given factory when an
-   *  instance of the requested object doesn't already exist in the scope
+   *     instance of the requested object doesn't already exist in the scope
    */
   public <T> Factory<T> scope(Key<T> key, Factory<T> creator);
 }
diff --git a/src/com/google/inject/Scoped.java b/src/com/google/inject/Scoped.java
index c3dae5e..b6da7a3 100644
--- a/src/com/google/inject/Scoped.java
+++ b/src/com/google/inject/Scoped.java
@@ -25,13 +25,12 @@
  * Annotates an implementation class with the name of its scope.
  *
  * <p>If you apply {@code Scoped} to another annotation, that annotation will
- * act as an alias and the user will not have to explicitly specify a name.
- * See {@link com.google.inject.ContainerScoped} for an example.
+ * act as an alias and the user will not have to explicitly specify a name. See
+ * {@link ContainerScoped} for an example.
  *
- * @see com.google.inject.ContainerBuilder#scope(String, Scope)
  * @author crazybob
  */
-@Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
+@Target({ ElementType.TYPE, ElementType.ANNOTATION_TYPE })
 @Retention(RUNTIME)
 public @interface Scoped {
 
diff --git a/src/com/google/inject/Scopes.java b/src/com/google/inject/Scopes.java
index b0b634c..86a6ca3 100644
--- a/src/com/google/inject/Scopes.java
+++ b/src/com/google/inject/Scopes.java
@@ -23,7 +23,8 @@
  */
 public class Scopes {
 
-  private Scopes() {}
+  private Scopes() {
+  }
 
   /**
    * Name of the default scope.
@@ -53,14 +54,16 @@
 
         private volatile T instance;
 
-        // DCL is safe as of Java 5, which we obviously require
+        // DCL on a volatile is safe as of Java 5, which we obviously require
         @SuppressWarnings("DoubleCheckedLocking")
         public T get() {
           if (instance == null) {
-            // Use a pretty coarse lock. We don't want to run into deadlocks
-            // when two threads try to load circularly-dependent objects.
-            // Maybe one of these days we will identify independent graphs of
-            // objects and offer to load them in parallel.
+            /*
+             * Use a pretty coarse lock. We don't want to run into deadlocks
+             * when two threads try to load circularly-dependent objects.
+             * Maybe one of these days we will identify independent graphs of
+             * objects and offer to load them in parallel.
+             */
             synchronized (Container.class) {
               if (instance == null) {
                 instance = creator.get();
@@ -76,4 +79,4 @@
       };
     }
   };
-}
\ No newline at end of file
+}
diff --git a/src/com/google/inject/TypeLiteral.java b/src/com/google/inject/TypeLiteral.java
index 391c256..3ae040f 100644
--- a/src/com/google/inject/TypeLiteral.java
+++ b/src/com/google/inject/TypeLiteral.java
@@ -17,26 +17,23 @@
 package com.google.inject;
 
 import static com.google.inject.util.Objects.nonNull;
-
-import java.lang.reflect.Type;
 import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 
 /**
  * Represents a generic type {@code T}. Java doesn't yet provide a way to
  * represent generic types, so this class does. Forces clients to create a
- * subclass of this class which enables retrieval the type information
- * even at runtime.
+ * subclass of this class which enables retrieval the type information even at
+ * runtime.
  *
- * <p>For example, to create a {@code TypeLiteral} for {@code List<String>},
- * you can create an empty anonymous inner class:
+ * <p>For example, to create a type literal for {@code List<String>}, you can
+ * create an empty anonymous inner class:
  *
- * <pre>
- * TypeLiteral&lt;List&lt;String>> listOfString =
- *   new TypeLiteral&lt;List&lt;String>>() {};
- * </pre>
+ * <p>
+ * {@code TypeLiteral<List<String>> list = new TypeLiteral<List<String>>() {};}
  *
- * <p>Assumes {@code Type} implements {@code equals()} and {@code hashCode()}
- * as a value (as opposed to identity) comparison.
+ * <p>Assumes that type {@code T} implements {@link Object#equals} and
+ * {@link Object#hashCode()} as value (as opposed to identity) comparison.
  *
  * @author crazybob@google.com (Bob Lee)
  */
@@ -50,13 +47,10 @@
    * parameter.
    *
    * <p>Clients create an empty anonymous subclass. Doing so embeds the type
-   * parameter in the anonymous class's type hierarchy so we can reconstitute
-   * it at runtime despite erasure.
-   *
-   * <p>For example: {@code TypeLiteral<List<String>> t = new
-   * TypeLiteral<List<String>>() {};}
+   * parameter in the anonymous class's type hierarchy so we can reconstitute it
+   * at runtime despite erasure.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   protected TypeLiteral() {
     this.type = getSuperclassTypeParameter(getClass());
     this.rawType = (Class<? super T>) getRawType(type);
@@ -65,7 +59,7 @@
   /**
    * Unsafe. Constructs a type literal manually.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   private TypeLiteral(Type type) {
     this.rawType = (Class<? super T>) getRawType(nonNull(type, "type"));
     this.type = type;
@@ -89,12 +83,13 @@
     return new SimpleTypeLiteral<Object>(getSuperclassTypeParameter(subclass));
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings({ "unchecked" })
   private static Class<?> getRawType(Type type) {
     if (type instanceof Class<?>) {
       // type is a normal class.
       return (Class<?>) type;
-    } else {
+    }
+    else {
       // type is a parameterized type.
       if (!(type instanceof ParameterizedType)) {
         unexpectedType(type, ParameterizedType.class);
@@ -143,8 +138,8 @@
 
   public String toString() {
     return type instanceof Class<?>
-          ? ((Class<?>) type).getName()
-          : type.toString();
+        ? ((Class<?>) type).getName()
+        : type.toString();
   }
 
   static void unexpectedType(Type type, Class<?> expected) {