diff --git a/build.xml b/build.xml
index 28620b7..e9dcaff 100644
--- a/build.xml
+++ b/build.xml
@@ -21,9 +21,9 @@
       <zipfileset src="lib/build/asm-3.1.jar"/>
       <zipfileset src="lib/build/google-collect-snapshot-20080530.jar"/>
       <rule pattern="com.google.common.**" result="com.google.inject.internal.@1"/>
-      <rule pattern="net.sf.cglib.**" result="com.google.inject.cglib.@1"/>
-      <rule pattern="org.objectweb.asm.**" result="com.google.inject.asm.@1"/>
-      <keep pattern="com.google.**"/>
+      <rule pattern="net.sf.cglib.**" result="com.google.inject.internal.cglib.@1"/>
+      <rule pattern="org.objectweb.asm.**" result="com.google.inject.internal.asm.@1"/>
+      <keep pattern="com.google.inject.**"/>
     </jarjar>
   </target>
 
@@ -89,8 +89,12 @@
         <pathelement location="lib/build/junit.jar"/>
         <pathelement location="lib/build/servlet-api-2.5.jar"/>
         <pathelement location="lib/build/easymock.jar"/>
+        <pathelement location="lib/build/google-collect-snapshot-20080530.jar"/>
       </classpath>
       <arg value="com.google.inject.AllTests"/>    
+      <syspropertyset>
+        <propertyref name="guice.custom.loader"/>
+      </syspropertyset>
     </java>
   </target>
   
diff --git a/common.xml b/common.xml
index 402e54d..cc7287c 100644
--- a/common.xml
+++ b/common.xml
@@ -41,7 +41,7 @@
     <property name="exclude.imports" value=""/>
     <property name="guice.imports" value="com.google.inject.*;version=${api.version}"/>
     <property name="Import-Package" value="${exclude.imports},${guice.imports},*;resolution:=optional"/>
-    <property name="Export-Package" value="${module}.*;version=${api.version}"/>
+    <property name="Export-Package" value="!${module}.internal.*,${module}.*;version=${api.version}"/>
     <property name="-nouses" value="true"/>
     <property name="-removeheaders" value="Bnd-LastModified,Ignore-Package,Include-Resource,Private-Package,Tool"/>
 
diff --git a/guice.iml b/guice.iml
index f4d0954..cb08b03 100644
--- a/guice.iml
+++ b/guice.iml
@@ -72,7 +72,9 @@
           <root url="file://$MODULE_DIR$/lib/build" />
         </CLASSES>
         <JAVADOC />
-        <SOURCES />
+        <SOURCES>
+          <root url="jar://$MODULE_DIR$/lib/build/cglib-src-2.2.jar!/src/proxy" />
+        </SOURCES>
         <jarDirectory url="file://$MODULE_DIR$/lib/build" recursive="false" />
       </library>
     </orderEntry>
diff --git a/src/com/google/inject/ConstructionContext.java b/src/com/google/inject/ConstructionContext.java
index 55c2b45..bbcb335 100644
--- a/src/com/google/inject/ConstructionContext.java
+++ b/src/com/google/inject/ConstructionContext.java
@@ -16,6 +16,7 @@
 
 package com.google.inject;
 
+import com.google.inject.internal.BytecodeGen;
 import com.google.inject.internal.Errors;
 import com.google.inject.internal.ErrorsException;
 import java.lang.reflect.InvocationHandler;
@@ -79,9 +80,9 @@
         = new DelegatingInvocationHandler<T>();
     invocationHandlers.add(invocationHandler);
 
-    Object object = Proxy.newProxyInstance(expectedType.getClassLoader(),
-        new Class[] { expectedType }, invocationHandler);
-    return expectedType.cast(object);
+    ClassLoader classLoader = BytecodeGen.getClassLoader(expectedType);
+    return expectedType.cast(Proxy.newProxyInstance(classLoader,
+        new Class[] { expectedType }, invocationHandler));
   }
 
   void setProxyDelegates(T delegate) {
diff --git a/src/com/google/inject/DefaultConstructionProxyFactory.java b/src/com/google/inject/DefaultConstructionProxyFactory.java
index 33bfdc8..ace1f93 100644
--- a/src/com/google/inject/DefaultConstructionProxyFactory.java
+++ b/src/com/google/inject/DefaultConstructionProxyFactory.java
@@ -16,9 +16,9 @@
 
 package com.google.inject;
 
+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.GuiceFastClass;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
@@ -67,7 +67,7 @@
 
     return new ConstructionProxy<T>() {
       Class<T> classToConstruct = constructor.getDeclaringClass();
-      FastClass fastClass = GuiceFastClass.create(classToConstruct);
+      FastClass fastClass = newFastClass(classToConstruct);
       final FastConstructor fastConstructor = fastClass.getConstructor(constructor);
 
       @SuppressWarnings("unchecked")
diff --git a/src/com/google/inject/InjectorImpl.java b/src/com/google/inject/InjectorImpl.java
index f2180f0..d337d85 100644
--- a/src/com/google/inject/InjectorImpl.java
+++ b/src/com/google/inject/InjectorImpl.java
@@ -23,10 +23,10 @@
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
 import com.google.common.collect.Sets;
+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;
-import com.google.inject.internal.GuiceFastClass;
 import com.google.inject.internal.Keys;
 import com.google.inject.internal.MatcherAndConverter;
 import com.google.inject.internal.Nullability;
@@ -883,9 +883,8 @@
             return method.invoke(target, parameters);
           }
         };
-      }
-      else {
-        FastClass fastClass = GuiceFastClass.create(method.getDeclaringClass());
+      } else {
+        FastClass fastClass = newFastClass(method.getDeclaringClass());
         final FastMethod fastMethod = fastClass.getMethod(method);
 
         methodInvoker = new MethodInvoker() {
@@ -1099,10 +1098,9 @@
       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;
+        localContext.remove();
       }
     }
     else {
diff --git a/src/com/google/inject/ProxyFactory.java b/src/com/google/inject/ProxyFactory.java
index 48fc94f..13bb646 100644
--- a/src/com/google/inject/ProxyFactory.java
+++ b/src/com/google/inject/ProxyFactory.java
@@ -18,10 +18,10 @@
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+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.GuiceFastClass;
-import com.google.inject.internal.GuiceNamingPolicy;
 import com.google.inject.internal.ReferenceCache;
 import com.google.inject.internal.StackTraceElements;
 import java.lang.reflect.Constructor;
@@ -147,17 +147,13 @@
     }
 
     // Create the proxied class.
-    Enhancer enhancer = new Enhancer();
-    enhancer.setSuperclass(declaringClass);
-    enhancer.setUseCache(false); // We do enough caching.
+    Enhancer enhancer = newEnhancer(declaringClass);
     enhancer.setCallbackFilter(new CallbackFilter() {
       public int accept(Method method) {
         return indices.get(method);
       }
     });
     enhancer.setCallbackTypes(callbackTypes);
-    enhancer.setUseFactory(false);
-    enhancer.setNamingPolicy(new GuiceNamingPolicy());
 
     Class<?> proxied = enhancer.createClass();
 
@@ -172,7 +168,7 @@
    */
   private <T> ConstructionProxy<T> createConstructionProxy(Errors errors, final Class<?> clazz,
       final Constructor standardConstructor) throws ErrorsException {
-    FastClass fastClass = GuiceFastClass.create(clazz);
+    FastClass fastClass = newFastClass(clazz);
     final FastConstructor fastConstructor
         = fastClass.getConstructor(standardConstructor.getParameterTypes());
     final List<Parameter<?>> parameters = Parameter.forConstructor(standardConstructor, errors);
diff --git a/src/com/google/inject/internal/BytecodeGen.java b/src/com/google/inject/internal/BytecodeGen.java
new file mode 100644
index 0000000..47a5ef2
--- /dev/null
+++ b/src/com/google/inject/internal/BytecodeGen.java
@@ -0,0 +1,179 @@
+/**
+ * Copyright (C) 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject.internal;
+
+import static com.google.inject.internal.ReferenceType.WEAK;
+import static java.lang.reflect.Modifier.PROTECTED;
+import static java.lang.reflect.Modifier.PUBLIC;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import net.sf.cglib.core.DefaultNamingPolicy;
+import net.sf.cglib.core.NamingPolicy;
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.reflect.FastClass;
+
+/**
+ * Utility methods for runtime code generation and class loading. We use this stuff for faster
+ * reflection ({@link FastClass}), method interceptors ({@link Enhancer}) and to proxy circular
+ * dependencies.
+ *
+ * <p>When loading classes, we need to be careful of:
+ * <ul>
+ *   <li><strong>Memory leaks.</strong> Generated classes need to be garbage collected in long-lived
+ *       applications. Once an injector and any instances it created can be garbage collected, the
+ *       corresponding generated classes should be collectable.
+ *   <li><strong>Visibility.</strong> Containers like <code>OSGi</code> use class loader boundaries
+ *       to enforce modularity at runtime.
+ * </ul>
+ *
+ * <p>For each generated class, there's multiple class loaders involved:
+ * <ul>
+ *    <li><strong>The related class's class loader.</strong> Every generated class services exactly
+ *        one user-supplied class. This class loader must be used to access members with private and
+ *        package visibility.
+ *    <li><strong>Guice's class loader.</strong>
+ *    <li><strong>Our bridge class loader.</strong> This is a child of the user's class loader. It
+ *        selectively delegates to either the user's class loader (for user classes) or the Guice
+ *        class loader (for internal classes that are used by the generated classes). This class
+ *        loader that owns the classes generated by Guice.
+ * </ul>
+ *
+ * @author mcculls@gmail.com (Stuart McCulloch)
+ * @author jessewilson@google.com (Jesse Wilson)
+ */
+public final class BytecodeGen {
+
+  static final ClassLoader GUICE_CLASS_LOADER = BytecodeGen.class.getClassLoader();
+
+  /** ie. "com.google.inject.internal" */
+  private static final String GUICE_INTERNAL_PACKAGE
+      = BytecodeGen.class.getName().replaceFirst("\\.internal\\..*$", ".internal");
+
+  /** either "net.sf.cglib", or "com.google.inject.internal.cglib" */
+  private static final String CGLIB_PACKAGE
+      = Enhancer.class.getName().replaceFirst("\\.cglib\\..*$", ".cglib");
+
+  static final NamingPolicy NAMING_POLICY = new DefaultNamingPolicy() {
+    @Override protected String getTag() {
+      return "ByGuice";
+    }
+  };
+
+  /** Use "-Dguice.custom.loader=false" to disable custom classloading. */
+  static final boolean HOOK_ENABLED
+      = "true".equals(System.getProperty("guice.custom.loader", "true"));
+
+  /**
+   * Weak cache of bridge class loaders that make the Guice implementation
+   * classes visible to various code-generated proxies of client classes.
+   */
+  private static final ReferenceCache<ClassLoader, ClassLoader> CLASS_LOADER_CACHE
+      = new ReferenceCache<ClassLoader, ClassLoader>(WEAK, WEAK) {
+        @Override protected ClassLoader create(final ClassLoader typeClassLoader) {
+          return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+            public ClassLoader run() {
+              return new BridgeClassLoader(typeClassLoader);
+            }
+          });
+        }
+      };
+
+  /**
+   * Returns true if {@code type} can be loaded from our custom class loader.
+   * Private/implementation classes are not visible to classes loaded by other
+   * class loaders, even when they are in the same package. Therefore we cannot
+   * intercept classloading requests for such types.
+   */
+  private static boolean isHookable(Class<?> type) {
+    return (type.getModifiers() & (PROTECTED | PUBLIC)) != 0;
+  }
+
+  /**
+   * For class loaders, {@code null}, is always an alias to the
+   * {@link ClassLoader#getSystemClassLoader() system class loader}.
+   */
+  private static ClassLoader canonicalize(ClassLoader classLoader) {
+    return classLoader != null
+        ? classLoader
+        : ClassLoader.getSystemClassLoader();
+  }
+
+  /**
+   * Returns the class loader to host generated classes for {@code type}.
+   */
+  public static ClassLoader getClassLoader(Class<?> type) {
+    return getClassLoader(type, type.getClassLoader());
+  }
+
+  private static ClassLoader getClassLoader(Class<?> type, ClassLoader delegate) {
+    delegate = canonicalize(delegate);
+
+    if (HOOK_ENABLED && isHookable(type)) {
+      return CLASS_LOADER_CACHE.get(delegate);
+    }
+
+    return delegate;
+  }
+
+  public static FastClass newFastClass(Class<?> type) {
+    FastClass.Generator generator = new FastClass.Generator();
+    generator.setType(type);
+    generator.setClassLoader(getClassLoader(type));
+    generator.setNamingPolicy(NAMING_POLICY);
+    return generator.create();
+  }
+
+  public static Enhancer newEnhancer(Class<?> type) {
+    Enhancer enhancer = new Enhancer();
+    enhancer.setSuperclass(type);
+    enhancer.setUseCache(false); // We do enough caching.
+    enhancer.setUseFactory(false);
+    enhancer.setNamingPolicy(NAMING_POLICY);
+    enhancer.setClassLoader(getClassLoader(type));
+    return enhancer;
+  }
+
+  /**
+   * Loader for Guice-generated classes. For referenced classes, this delegates to either either the
+   * user's classloader (which is the parent of this classloader) or Guice's class loader.
+   */
+  private static class BridgeClassLoader extends ClassLoader {
+
+    public BridgeClassLoader(ClassLoader usersClassLoader) {
+      super(usersClassLoader);
+    }
+
+    @Override protected Class<?> loadClass(String name, boolean resolve)
+        throws ClassNotFoundException {
+
+      // delegate internal requests to Guice class space
+      if (name.startsWith(GUICE_INTERNAL_PACKAGE) || name.startsWith(CGLIB_PACKAGE)) {
+        try {
+          Class<?> clazz = GUICE_CLASS_LOADER.loadClass(name);
+          if (resolve) {
+            resolveClass(clazz);
+          }
+          return clazz;
+        } catch (Exception e) {
+          // fall back to classic delegation
+        }
+      }
+
+      return super.loadClass(name, resolve);
+    }
+  }
+}
diff --git a/src/com/google/inject/internal/GuiceFastClass.java b/src/com/google/inject/internal/GuiceFastClass.java
deleted file mode 100644
index 4495ae8..0000000
--- a/src/com/google/inject/internal/GuiceFastClass.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Copyright (C) 2006 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.inject.internal;
-
-import net.sf.cglib.reflect.FastClass;
-
-/**
- * Gives Guice classes custom names.
- *
- * @author crazybob@google.com (Bob Lee)
- */
-public class GuiceFastClass {
-
-  public static FastClass create(Class type) {
-    return create(type.getClassLoader(), type);
-  }
-
-  public static FastClass create(ClassLoader loader, Class type) {
-    FastClass.Generator generator = new FastClass.Generator();
-    generator.setType(type);
-    generator.setClassLoader(loader);
-    generator.setNamingPolicy(new GuiceNamingPolicy());
-    return generator.create();
-  }
-}
diff --git a/src/com/google/inject/internal/GuiceNamingPolicy.java b/src/com/google/inject/internal/GuiceNamingPolicy.java
deleted file mode 100644
index c4d38ed..0000000
--- a/src/com/google/inject/internal/GuiceNamingPolicy.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Copyright (C) 2006 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.google.inject.internal;
-
-import net.sf.cglib.core.DefaultNamingPolicy;
-import net.sf.cglib.core.Predicate;
-
-/**
- * Cglib class naming policy for Guice.
- *
- * @author crazybob@google.com (Bob Lee)
- */
-public class GuiceNamingPolicy extends DefaultNamingPolicy {
-
-  @Override protected String getTag() {
-    return "ByGuice";
-  }
-}
diff --git a/test/com/google/inject/AllTests.java b/test/com/google/inject/AllTests.java
index 2c447d4..81added 100644
--- a/test/com/google/inject/AllTests.java
+++ b/test/com/google/inject/AllTests.java
@@ -19,6 +19,7 @@
 import com.google.inject.commands.CommandRecorderTest;
 import com.google.inject.commands.CommandReplayerTest;
 import com.google.inject.commands.CommandRewriteTest;
+import com.google.inject.internal.BytecodeGenTest;
 import com.google.inject.internal.FinalizableReferenceQueueTest;
 import com.google.inject.internal.LineNumbersTest;
 import com.google.inject.internal.ReferenceCacheTest;
@@ -84,6 +85,7 @@
     suite.addTestSuite(ReferenceMapTest.class);
     suite.addTestSuite(TypesTest.class);
     suite.addTestSuite(UniqueAnnotationsTest.class);
+    suite.addTestSuite(BytecodeGenTest.class);
 
     // matcher
     suite.addTestSuite(MatcherTest.class);
diff --git a/test/com/google/inject/internal/BytecodeGenTest.java b/test/com/google/inject/internal/BytecodeGenTest.java
new file mode 100644
index 0000000..a930f56
--- /dev/null
+++ b/test/com/google/inject/internal/BytecodeGenTest.java
@@ -0,0 +1,182 @@
+/**
+ * Copyright (C) 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject.internal;
+
+import com.google.inject.Binder;
+import com.google.inject.Guice;
+import com.google.inject.Module;
+import static com.google.inject.matcher.Matchers.any;
+import java.io.File;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import junit.framework.TestCase;
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+/**
+ * @author mcculls@gmail.com (Stuart McCulloch)
+ */
+public class BytecodeGenTest extends TestCase {
+
+  /**
+   * Custom URL classloader with basic visibility rules
+   */
+  static class TestVisibilityClassLoader
+      extends URLClassLoader {
+
+    public TestVisibilityClassLoader() {
+      super(new URL[0]);
+
+      final String[] classpath = System.getProperty("java.class.path").split(File.pathSeparator);
+      for (final String element : classpath) {
+        try {
+          // is it a remote/local URL?
+          addURL(new URL(element));
+        } catch (final MalformedURLException e1) {
+          try {
+            // nope - perhaps it's a filename?
+            addURL(new File(element).toURI().toURL());
+          } catch (final MalformedURLException e2) {
+            throw new RuntimeException(e1);
+          }
+        }
+      }
+    }
+
+    /**
+     * Classic parent-delegating classloaders are meant to override findClass.
+     * However, non-delegating classloaders (as used in OSGi) instead override
+     * loadClass to provide support for "class-space" separation.
+     */
+    @Override
+    protected Class<?> loadClass(final String name, final boolean resolve)
+        throws ClassNotFoundException {
+
+      if (name.startsWith("java.")) {
+
+        // standard bootdelegation of java.*
+        return super.loadClass(name, resolve);
+
+      } else if ((!name.contains(".internal.") && !name.contains(".cglib."))
+          || name.contains("Test")) {
+
+        /*
+         * load public and test classes directly from the classpath - we don't
+         * delegate to our parent because then the loaded classes would also be
+         * able to see private internal Guice classes, as they are also loaded
+         * by the parent classloader.
+         */
+        final Class<?> clazz = findClass(name);
+        if (resolve) {
+          resolveClass(clazz);
+        }
+        return clazz;
+      }
+
+      // hide internal non-test classes
+      throw new ClassNotFoundException();
+    }
+  }
+
+  interface ProxyTest {
+    String sayHello();
+  }
+
+  /**
+   * Note: this class must be marked as public or protected so that the Guice
+   * custom classloader will intercept it. Private and implementation classes
+   * are not intercepted by the custom classloader.
+   * 
+   * @see BytecodeGen#isHookable(Class)
+   */
+  protected static class ProxyTestImpl
+      implements ProxyTest {
+
+    public String sayHello() {
+      return "HELLO";
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  public void testProxyClassLoading() {
+    final ClassLoader testClassLoader = new TestVisibilityClassLoader();
+
+    final Class<ProxyTest> testAPIClazz;
+    final Class<ProxyTest> testImplClazz;
+
+    try {
+      testAPIClazz = (Class<ProxyTest>) testClassLoader.loadClass(ProxyTest.class.getName());
+      testImplClazz = (Class<ProxyTest>) testClassLoader.loadClass(ProxyTestImpl.class.getName());
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
+    }
+
+    final ProxyTest test = Guice.createInjector(new Module() {
+      public void configure(Binder binder) {
+
+        binder.bind(testAPIClazz).to(testImplClazz);
+
+        // Force proxy...
+        binder.bindInterceptor(any(), any(), new MethodInterceptor() {
+          public Object invoke(MethodInvocation chain)
+              throws Throwable {
+            return chain.proceed() + " WORLD";
+          }
+        });
+      }
+    }).getInstance(testAPIClazz);
+
+    // verify method interception still works
+    assertEquals("HELLO WORLD", test.sayHello());
+  }
+
+  public void testProxyClassUnloading() {
+
+    ProxyTest testProxy = Guice.createInjector(new Module() {
+      public void configure(Binder binder) {
+        binder.bind(ProxyTest.class).to(ProxyTestImpl.class);
+        binder.bindInterceptor(any(), any(), new MethodInterceptor() {
+          public Object invoke(MethodInvocation chain)
+              throws Throwable {
+            return chain.proceed() + " WORLD";
+          }
+        });
+      }
+    }).getInstance(ProxyTest.class);
+
+    // take a weak reference to the generated proxy class
+    Reference<Class<?>> clazzRef = new WeakReference<Class<?>>(testProxy.getClass());
+
+    assertNotNull(clazzRef.get());
+
+    // null the proxy
+    testProxy = null;
+
+    /*
+     * this should be enough to queue the weak reference
+     * unless something is holding onto it accidentally.
+     */
+    System.gc();
+    System.gc();
+    System.gc();
+
+    assertNull(clazzRef.get());
+  }
+}