diff --git a/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java b/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
index 14f1a4c..61e9cea 100644
--- a/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
+++ b/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
@@ -35,7 +35,9 @@
 import com.google.gwt.dev.shell.rewrite.HasAnnotation;
 import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter;
 import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.InstanceMethodOracle;
+import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.SingleJsoImplData;
 import com.google.gwt.dev.util.JsniRef;
+import com.google.gwt.dev.util.Name;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.Name.InternalName;
 import com.google.gwt.dev.util.Name.SourceOrBinaryName;
@@ -61,9 +63,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.SortedMap;
+import java.util.SortedSet;
 import java.util.Stack;
-import java.util.TreeMap;
+import java.util.TreeSet;
 
 /**
  * An isolated {@link ClassLoader} for running all user code. All user files are
@@ -360,21 +362,34 @@
     private final Map<String, Set<JClassType>> signatureToDeclaringClasses = new HashMap<String, Set<JClassType>>();
 
     public MyInstanceMethodOracle(Set<JClassType> jsoTypes,
-        JClassType javaLangObject) {
-      // Populate the map.
+        JClassType javaLangObject, SingleJsoImplData jsoData) {
+
+      // Record that the JSO implements its own methods
       for (JClassType type : jsoTypes) {
         for (JMethod method : type.getMethods()) {
           if (!method.isStatic()) {
-            String signature = createSignature(method);
-            Set<JClassType> declaringClasses = signatureToDeclaringClasses.get(signature);
-            if (declaringClasses == null) {
-              declaringClasses = new HashSet<JClassType>();
-              signatureToDeclaringClasses.put(signature, declaringClasses);
-            }
-            declaringClasses.add(type);
+            assert !method.isAbstract() : "Abstract method in JSO type "
+                + method;
+            add(type, method);
           }
         }
       }
+
+      /*
+       * Record the implementing types for methods defined in SingleJsoImpl
+       * interfaces. We have to make this pass because of possible variance in
+       * the return types between the abstract method declaration in the
+       * interface and the concrete method.
+       */
+      for (String intfName : jsoData.getSingleJsoIntfTypes()) {
+        // We only store the name in the data block to keep it lightweight
+        JClassType intf = typeOracle.findType(Name.InternalName.toSourceName(intfName));
+        JClassType jso = typeOracle.getSingleJsoImpl(intf);
+        for (JMethod method : intf.getMethods()) {
+          add(jso, method);
+        }
+      }
+
       // Object clobbers everything.
       for (JMethod method : javaLangObject.getMethods()) {
         if (!method.isStatic()) {
@@ -389,6 +404,7 @@
     public String findOriginalDeclaringClass(String desc, String signature) {
       // Lookup the method.
       Set<JClassType> declaringClasses = signatureToDeclaringClasses.get(signature);
+      assert declaringClasses != null : "No classes for " + signature;
       if (declaringClasses.size() == 1) {
         // Shortcut: if there's only one answer, it must be right.
         return createDescriptor(declaringClasses.iterator().next());
@@ -413,6 +429,20 @@
           + signature + "' from class '" + desc + "'");
     }
 
+    /**
+     * Record that a given JSO type contains the concrete implementation of a
+     * (possibly abstract) method.
+     */
+    private void add(JClassType type, JMethod method) {
+      String signature = createSignature(method);
+      Set<JClassType> declaringClasses = signatureToDeclaringClasses.get(signature);
+      if (declaringClasses == null) {
+        declaringClasses = new HashSet<JClassType>();
+        signatureToDeclaringClasses.put(signature, declaringClasses);
+      }
+      declaringClasses.add(type);
+    }
+
     private String createDescriptor(JClassType type) {
       String jniSignature = type.getJNISignature();
       return jniSignature.substring(1, jniSignature.length() - 1);
@@ -432,6 +462,177 @@
   }
 
   /**
+   * Cook up the data we need to support JSO subtypes that implement interfaces
+   * with methods. This includes the set of SingleJsoImpl interfaces actually
+   * implemented by a JSO type, the mangled method names, and the names of the
+   * Methods that should actually implement the virtual functions.
+   * 
+   * Given the current implementation of JSO$ and incremental execution of
+   * rebinds, it's not possible for Generators to produce additional
+   * JavaScriptObject subtypes, so this data can remain static.
+   */
+  private class MySingleJsoImplData implements SingleJsoImplData {
+    private final SortedSet<String> mangledNames = new TreeSet<String>();
+    private final Map<String, com.google.gwt.dev.asm.commons.Method> mangledNamesToDeclarations = new HashMap<String, com.google.gwt.dev.asm.commons.Method>();
+    private final Map<String, com.google.gwt.dev.asm.commons.Method> mangledNamesToImplementations = new HashMap<String, com.google.gwt.dev.asm.commons.Method>();
+    private final SortedSet<String> unmodifiableNames = Collections.unmodifiableSortedSet(mangledNames);
+    private final Set<String> unmodifiableIntfNames = Collections.unmodifiableSet(singleJsoImplTypes);
+
+    public MySingleJsoImplData() {
+      // Loop over all interfaces with JSO implementations
+      typeLoop : for (JClassType type : typeOracle.getSingleJsoImplInterfaces()) {
+        assert type.isInterface() == type : "Expecting interfaces only";
+
+        /*
+         * By preemptively adding all possible mangled names by which a method
+         * could be called, we greatly simplify the logic necessary to rewrite
+         * the call-site.
+         * 
+         * interface A {void m();}
+         * 
+         * interface B extends A {void z();}
+         * 
+         * becomes
+         * 
+         * c_g_p_A_m() -> JsoA$.m$()
+         * 
+         * c_g_p_B_m() -> JsoA$.m$()
+         * 
+         * c_g_p_B_z() -> JsoB$.z$()
+         */
+        for (JMethod intfMethod : type.getOverridableMethods()) {
+          assert intfMethod.isAbstract() : "Expecting only abstract methods";
+
+          /*
+           * It is necessary to locate the implementing type on a per-method
+           * basis. Consider the case of
+           * 
+           * @SingleJsoImpl interface C extends A, B {}
+           * 
+           * Methods inherited from interfaces A and B must be dispatched to
+           * their respective JSO implementations.
+           */
+          JClassType implementingType = typeOracle.getSingleJsoImpl(intfMethod.getEnclosingType());
+
+          if (implementingType == null) {
+            /*
+             * This means that there is no concrete implementation of the
+             * interface by a JSO. Any implementation that might be created by a
+             * Generator won't be a JSO subtype, so we'll just ignore it as an
+             * actionable type. Were Generators ever able to create new JSO
+             * subtypes, we'd have to speculatively rewrite the callsite.
+             */
+            continue typeLoop;
+          }
+
+          /*
+           * Record the type as being actionable.
+           */
+          singleJsoImplTypes.add(canonicalizeClassName(getBinaryName(type)));
+
+          /*
+           * The mangled name adds the current interface like
+           * 
+           * com_foo_Bar_methodName
+           */
+          String mangledName = getBinaryName(type).replace('.', '_') + "_"
+              + intfMethod.getName();
+          mangledNames.add(mangledName);
+
+          JType[] parameterTypes = new JType[intfMethod.getParameters().length];
+          for (int i = 0; i < parameterTypes.length; i++) {
+            parameterTypes[i] = intfMethod.getParameters()[i].getType();
+          }
+
+          /*
+           * Handle virtual overrides by finding the method that we would
+           * normally invoke and using its declaring class as the dispatch
+           * target.
+           */
+          JMethod implementingMethod;
+          while ((implementingMethod = implementingType.findMethod(
+              intfMethod.getName(), parameterTypes)) == null) {
+            implementingType = implementingType.getSuperclass();
+          }
+          assert implementingMethod != null && implementingType != null : "Unable to find virtual override for "
+              + intfMethod.toString();
+
+          /*
+           * Create a pseudo-method declaration for the interface method. This
+           * should look something like
+           * 
+           * ReturnType method$ (ParamType, ParamType)
+           * 
+           * This must be kept in sync with the WriteJsoImpl class.
+           */
+          {
+            String decl = getBinaryOrPrimitiveName(intfMethod.getReturnType())
+                + " " + intfMethod.getName() + "(";
+            for (JType paramType : parameterTypes) {
+              decl += ",";
+              decl += getBinaryOrPrimitiveName(paramType);
+            }
+            decl += ")";
+
+            com.google.gwt.dev.asm.commons.Method declaration = com.google.gwt.dev.asm.commons.Method.getMethod(decl);
+            mangledNamesToDeclarations.put(mangledName, declaration);
+          }
+
+          /*
+           * Cook up the a pseudo-method declaration for the concrete type. This
+           * should look something like
+           * 
+           * ReturnType method$ (JsoType, ParamType, ParamType)
+           * 
+           * This must be kept in sync with the WriteJsoImpl class.
+           */
+          {
+            String returnName = getBinaryOrPrimitiveName(implementingMethod.getReturnType());
+            String jsoName = getBinaryOrPrimitiveName(implementingType);
+
+            String decl = returnName + " " + intfMethod.getName() + "$ ("
+                + jsoName;
+            for (JType paramType : parameterTypes) {
+              decl += ",";
+              decl += getBinaryOrPrimitiveName(paramType);
+            }
+            decl += ")";
+
+            com.google.gwt.dev.asm.commons.Method toImplement = com.google.gwt.dev.asm.commons.Method.getMethod(decl);
+            mangledNamesToImplementations.put(mangledName, toImplement);
+          }
+        }
+      }
+
+      if (logger.isLoggable(Type.SPAM)) {
+        TreeLogger dumpLogger = logger.branch(Type.SPAM,
+            "SingleJsoImpl method mappings");
+        for (Map.Entry<String, com.google.gwt.dev.asm.commons.Method> entry : mangledNamesToImplementations.entrySet()) {
+          dumpLogger.log(Type.SPAM, entry.getKey() + " -> " + entry.getValue());
+        }
+      }
+    }
+
+    public com.google.gwt.dev.asm.commons.Method getDeclaration(
+        String mangledName) {
+      return mangledNamesToDeclarations.get(mangledName);
+    }
+
+    public com.google.gwt.dev.asm.commons.Method getImplementation(
+        String mangledName) {
+      return mangledNamesToImplementations.get(mangledName);
+    }
+
+    public SortedSet<String> getMangledNames() {
+      return unmodifiableNames;
+    }
+
+    public Set<String> getSingleJsoIntfTypes() {
+      return unmodifiableIntfNames;
+    }
+  }
+
+  /**
    * The names of the bridge classes.
    */
   private static final Map<String, Class<?>> BRIDGE_CLASS_NAMES = new HashMap<String, Class<?>>();
@@ -643,15 +844,12 @@
         jsoSuperTypes.put(binaryName, types);
       }
 
-      // computeSingleJsoImplData has two out parameters
-      SortedMap<String, com.google.gwt.dev.asm.commons.Method> mangledNamesToImplementations = new TreeMap<String, com.google.gwt.dev.asm.commons.Method>();
-      computeSingleJsoImplData(singleJsoImplTypes,
-          mangledNamesToImplementations);
+      SingleJsoImplData singleJsoImplData = new MySingleJsoImplData();
 
       MyInstanceMethodOracle mapper = new MyInstanceMethodOracle(jsoTypes,
-          typeOracle.getJavaLangObject());
+          typeOracle.getJavaLangObject(), singleJsoImplData);
       classRewriter = new HostedModeClassRewriter(jsoTypeNames, jsoSuperTypes,
-          mangledNamesToImplementations, singleJsoImplTypes, mapper);
+          singleJsoImplData, mapper);
     } else {
       // If we couldn't find the JSO class, we don't need to do any rewrites.
       classRewriter = null;
@@ -838,125 +1036,6 @@
     return lookupClassName;
   }
 
-  /**
-   * Cook up the data we need to support JSO subtypes that implement interfaces
-   * with methods. This includes the set of SingleJsoImpl interfaces actually
-   * implemented by a JSO type, the mangled method names, and the names of the
-   * Methods that should actually implement the virtual functions.
-   * 
-   * Given the current implementation of JSO$ and incremental execution of
-   * rebinds, it's not possible for Generators to produce additional
-   * JavaScriptObject subtypes, so this data can remain static.
-   */
-  private void computeSingleJsoImplData(
-      Set<String> singleJsoImplTypes,
-      SortedMap<String, com.google.gwt.dev.asm.commons.Method> mangledNamesToImplementations) {
-
-    // Loop over all types declared with the SingleJsoImpl annotation
-    typeLoop : for (JClassType type : typeOracle.getSingleJsoImplInterfaces()) {
-      assert type.isInterface() == type : "Expecting interfaces only";
-
-      /*
-       * By preemptively adding all possible mangled names by which a method
-       * could be called, we greatly simplify the logic necessary to rewrite the
-       * call-site.
-       * 
-       * interface A {void m();}
-       * 
-       * interface B extends A {void z();}
-       * 
-       * becomes
-       * 
-       * c_g_p_A_m() -> JsoA$.m$()
-       * 
-       * c_g_p_B_m() -> JsoA$.m$()
-       * 
-       * c_g_p_B_z() -> JsoB$.z$()
-       */
-      for (JMethod m : type.getOverridableMethods()) {
-        assert m.isAbstract() : "Expecting only abstract methods";
-
-        /*
-         * It is necessary to locate the implementing type on a per-method
-         * basis. Consider the case of
-         * 
-         * @SingleJsoImpl interface C extends A, B {}
-         * 
-         * Methods inherited from interfaces A and B must be dispatched to their
-         * respective JSO implementations.
-         */
-        JClassType implementingType = typeOracle.getSingleJsoImpl(m.getEnclosingType());
-
-        if (implementingType == null) {
-          /*
-           * This means that there is no concrete implementation of the
-           * interface by a JSO. Any implementation that might be created by a
-           * Generator won't be a JSO subtype, so we'll just ignore it as an
-           * actionable type. Were Generators ever able to create new JSO
-           * subtypes, we'd have to speculatively rewrite the callsite.
-           */
-          continue typeLoop;
-        }
-
-        /*
-         * Record the type as being actionable.
-         */
-        singleJsoImplTypes.add(canonicalizeClassName(getBinaryName(type)));
-
-        /*
-         * The mangled name adds the current interface like
-         * 
-         * com_foo_Bar_methodName
-         */
-        String mangledName = getBinaryName(type).replace('.', '_') + "_"
-            + m.getName();
-
-        JType[] parameterTypes = new JType[m.getParameters().length];
-        for (int i = 0; i < parameterTypes.length; i++) {
-          parameterTypes[i] = m.getParameters()[i].getType();
-        }
-
-        /*
-         * Handle virtual overrides by finding the method that we would normally
-         * invoke and using its declaring class as the dispatch target.
-         */
-        while (implementingType.findMethod(m.getName(), parameterTypes) == null) {
-          implementingType = implementingType.getSuperclass();
-        }
-        assert implementingType != null : "Unable to find virtual override for "
-            + m.toString();
-
-        /*
-         * Cook up the a pseudo-method declaration for the concrete type. This
-         * should look something like
-         * 
-         * ReturnType method$ (JsoType, ParamType, ParamType)
-         * 
-         * This must be kept in sync with the WriteJsoImpl class.
-         */
-        String decl = getBinaryOrPrimitiveName(m.getReturnType()) + " "
-            + m.getName() + "$ (" + getBinaryOrPrimitiveName(implementingType);
-        for (JType paramType : parameterTypes) {
-          decl += ",";
-          decl += getBinaryOrPrimitiveName(paramType);
-        }
-        decl += ")";
-
-        com.google.gwt.dev.asm.commons.Method toImplement = com.google.gwt.dev.asm.commons.Method.getMethod(decl);
-
-        mangledNamesToImplementations.put(mangledName, toImplement);
-      }
-    }
-
-    if (logger.isLoggable(Type.SPAM)) {
-      TreeLogger dumpLogger = logger.branch(Type.SPAM,
-          "SingleJsoImpl method mappings");
-      for (Map.Entry<String, com.google.gwt.dev.asm.commons.Method> entry : mangledNamesToImplementations.entrySet()) {
-        dumpLogger.log(Type.SPAM, entry.getKey() + " -> " + entry.getValue());
-      }
-    }
-  }
-
   private byte[] findClassBytes(String className) {
     if (JavaScriptHost.class.getName().equals(className)) {
       // No need to rewrite.
diff --git a/dev/core/src/com/google/gwt/dev/shell/rewrite/HostedModeClassRewriter.java b/dev/core/src/com/google/gwt/dev/shell/rewrite/HostedModeClassRewriter.java
index 03c32d5..79fc500 100644
--- a/dev/core/src/com/google/gwt/dev/shell/rewrite/HostedModeClassRewriter.java
+++ b/dev/core/src/com/google/gwt/dev/shell/rewrite/HostedModeClassRewriter.java
@@ -30,7 +30,7 @@
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
-import java.util.SortedMap;
+import java.util.SortedSet;
 
 /**
  * This class performs any and all byte code rewriting needed to make hosted
@@ -86,6 +86,33 @@
     String findOriginalDeclaringClass(String declaredClass, String signature);
   }
 
+  /**
+   * Contains data about how SingleJsoImpl methods are to be dispatched.
+   */
+  public interface SingleJsoImplData {
+    /**
+     * Returns a Method corresponding to the declaration of the abstract method
+     * in an interface type.
+     */
+    Method getDeclaration(String mangledName);
+
+    /**
+     * Return a Method corresponding to the concrete implementation of the
+     * method in a JSO type.
+     */
+    Method getImplementation(String mangledName);
+
+    /**
+     * Returns all of the mangled method names for SingleJsoImpl methods.
+     */
+    SortedSet<String> getMangledNames();
+
+    /**
+     * Returns the internal names of all interface types implemented by JSOs.
+     */
+    Set<String> getSingleJsoIntfTypes();
+  }
+
   static final String JAVASCRIPTOBJECT_DESC = JsValueGlue.JSO_CLASS.replace(
       '.', '/');
 
@@ -114,6 +141,8 @@
    */
   private final Set<String> jsoIntfDescs;
 
+  private final SingleJsoImplData jsoData;
+
   /**
    * Records the superclass of every JSO for generating empty JSO interfaces.
    */
@@ -124,10 +153,6 @@
    */
   private InstanceMethodOracle mapper;
 
-  private final SortedMap<String, Method> mangledNamesToImplementations;
-
-  private final Set<String> singleJsoImplTypes;
-
   /**
    * Creates a new {@link HostedModeClassRewriter} for a specified set of
    * subclasses of JavaScriptObject.
@@ -137,9 +162,8 @@
    * @param mapper maps methods to the class in which they are declared
    */
   public HostedModeClassRewriter(Set<String> jsoSubtypes,
-      Map<String, List<String>> jsoSuperTypes,
-      SortedMap<String, Method> mangledNamesToImplementations,
-      Set<String> singleJsoImplTypes, InstanceMethodOracle mapper) {
+      Map<String, List<String>> jsoSuperTypes, SingleJsoImplData jsoData,
+      InstanceMethodOracle mapper) {
     Set<String> buildJsoIntfDescs = new HashSet<String>();
     Set<String> buildJsoImplDescs = new HashSet<String>();
     Map<String, List<String>> buildJsoSuperDescs = new HashMap<String, List<String>>();
@@ -160,8 +184,7 @@
     this.jsoIntfDescs = Collections.unmodifiableSet(buildJsoIntfDescs);
     this.jsoImplDescs = Collections.unmodifiableSet(buildJsoImplDescs);
     this.jsoSuperDescs = Collections.unmodifiableMap(buildJsoSuperDescs);
-    this.mangledNamesToImplementations = Collections.unmodifiableSortedMap(mangledNamesToImplementations);
-    this.singleJsoImplTypes = Collections.unmodifiableSet(singleJsoImplTypes);
+    this.jsoData = jsoData;
     this.mapper = mapper;
   }
 
@@ -202,14 +225,12 @@
     // v = new CheckClassAdapter(v);
     // v = new TraceClassVisitor(v, new PrintWriter(System.out));
 
-    v = new RewriteSingleJsoImplDispatches(v, typeOracle, singleJsoImplTypes,
-        mangledNamesToImplementations);
+    v = new RewriteSingleJsoImplDispatches(v, typeOracle, jsoData);
 
     v = new RewriteRefsToJsoClasses(v, jsoIntfDescs, mapper);
 
     if (jsoImplDescs.contains(desc)) {
-      v = WriteJsoImpl.create(v, desc, jsoIntfDescs, mapper,
-          mangledNamesToImplementations);
+      v = WriteJsoImpl.create(v, desc, jsoIntfDescs, mapper, jsoData);
     }
 
     v = new RewriteJsniMethods(v, anonymousClassMap);
diff --git a/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java b/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
index 00bdca1..717a975 100644
--- a/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
+++ b/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
@@ -24,6 +24,7 @@
 import com.google.gwt.dev.asm.Opcodes;
 import com.google.gwt.dev.asm.Type;
 import com.google.gwt.dev.asm.commons.Method;
+import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.SingleJsoImplData;
 import com.google.gwt.dev.util.collect.Maps;
 import com.google.gwt.dev.util.collect.Sets;
 
@@ -67,11 +68,10 @@
     public void visitMethodInsn(int opcode, String owner, String name,
         String desc) {
       if (opcode == Opcodes.INVOKEINTERFACE) {
-        if (singleJsoImplTypes.contains(owner)) {
+        if (jsoData.getSingleJsoIntfTypes().contains(owner)) {
           // Simple case; referring directly to a SingleJso interface.
           name = owner.replace('/', '_') + "_" + name;
-          assert mangledNamesToImplementations.containsKey(name) : "Missing "
-              + name;
+          assert jsoData.getMangledNames().contains(name) : "Missing " + name;
 
         } else {
           /*
@@ -86,7 +86,7 @@
            * void bar() { ((IB) object).foo(); }
            */
           for (String intf : computeAllInterfaces(owner)) {
-            if (singleJsoImplTypes.contains(intf)) {
+            if (jsoData.getSingleJsoIntfTypes().contains(intf)) {
               /*
                * Check that it really should be mangled and is not a reference
                * to a method defined in a non-singleJso super-interface. If
@@ -95,7 +95,7 @@
                * is undefined.
                */
               String maybeMangled = intf.replace('/', '_') + "_" + name;
-              Method method = mangledNamesToImplementations.get(maybeMangled);
+              Method method = jsoData.getImplementation(maybeMangled);
               if (method != null) {
                 /*
                  * Found a method with the right name, but we need to check the
@@ -127,17 +127,14 @@
   private final Set<String> implementedMethods = new HashSet<String>();
   private boolean inSingleJsoImplInterfaceType;
   private Map<String, Set<String>> intfNamesToAllInterfaces = Maps.create();
-  private final SortedMap<String, Method> mangledNamesToImplementations;
-  private final Set<String> singleJsoImplTypes;
+  private final SingleJsoImplData jsoData;
   private final TypeOracle typeOracle;
 
   public RewriteSingleJsoImplDispatches(ClassVisitor v, TypeOracle typeOracle,
-      Set<String> singleJsoImplTypes,
-      SortedMap<String, Method> mangledNamesToImplementations) {
+      SingleJsoImplData jsoData) {
     super(v);
     this.typeOracle = typeOracle;
-    this.singleJsoImplTypes = Collections.unmodifiableSet(singleJsoImplTypes);
-    this.mangledNamesToImplementations = Collections.unmodifiableSortedMap(mangledNamesToImplementations);
+    this.jsoData = jsoData;
   }
 
   @Override
@@ -156,7 +153,8 @@
     }
 
     currentTypeName = name;
-    inSingleJsoImplInterfaceType = singleJsoImplTypes.contains(name);
+    inSingleJsoImplInterfaceType = jsoData.getSingleJsoIntfTypes().contains(
+        name);
 
     /*
      * Implements objective #2: non-JSO types that implement a SingleJsoImpl
@@ -166,7 +164,7 @@
      */
     if (interfaces != null && (access & Opcodes.ACC_INTERFACE) == 0) {
       Set<String> toStub = computeAllInterfaces(interfaces);
-      toStub.retainAll(singleJsoImplTypes);
+      toStub.retainAll(jsoData.getSingleJsoIntfTypes());
 
       for (String stubIntr : toStub) {
         writeTrampoline(stubIntr);
@@ -261,8 +259,11 @@
     String name = typeName.replace('/', '_');
     String prefix = name + "_";
     String suffix = name + "`";
-    SortedMap<String, Method> toReturn = new TreeMap<String, Method>(
-        mangledNamesToImplementations.subMap(prefix, suffix));
+    SortedMap<String, Method> toReturn = new TreeMap<String, Method>();
+
+    for (String mangledName : jsoData.getMangledNames().subSet(prefix, suffix)) {
+      toReturn.put(mangledName, jsoData.getImplementation(mangledName));
+    }
     toReturn.keySet().removeAll(implementedMethods);
     return toReturn;
   }
diff --git a/dev/core/src/com/google/gwt/dev/shell/rewrite/WriteJsoImpl.java b/dev/core/src/com/google/gwt/dev/shell/rewrite/WriteJsoImpl.java
index 1054421..28081f1 100644
--- a/dev/core/src/com/google/gwt/dev/shell/rewrite/WriteJsoImpl.java
+++ b/dev/core/src/com/google/gwt/dev/shell/rewrite/WriteJsoImpl.java
@@ -23,9 +23,9 @@
 import com.google.gwt.dev.asm.Type;
 import com.google.gwt.dev.asm.commons.Method;
 import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.InstanceMethodOracle;
+import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.SingleJsoImplData;
 
 import java.util.ArrayList;
-import java.util.Map;
 import java.util.Set;
 
 /**
@@ -58,13 +58,13 @@
      * <code>JavaScriptObject</code> and all subclasses.
      */
     private final Set<String> jsoDescriptors;
-    private final Map<String, Method> methodsToImplement;
+    private final SingleJsoImplData jsoData;
 
     public ForJsoDollar(ClassVisitor cv, Set<String> jsoDescriptors,
-        InstanceMethodOracle mapper, Map<String, Method> methodsToImplement) {
+        InstanceMethodOracle mapper, SingleJsoImplData jsoData) {
       super(cv, mapper);
       this.jsoDescriptors = jsoDescriptors;
-      this.methodsToImplement = methodsToImplement;
+      this.jsoData = jsoData;
     }
 
     @Override
@@ -89,8 +89,9 @@
       }
 
       // Implement the trampoline methods
-      for (Map.Entry<String, Method> entry : methodsToImplement.entrySet()) {
-        writeTrampoline(entry.getKey(), entry.getValue());
+      for (String mangledName : jsoData.getMangledNames()) {
+        writeTrampoline(mangledName, jsoData.getDeclaration(mangledName),
+            jsoData.getImplementation(mangledName));
       }
     }
 
@@ -113,24 +114,31 @@
      * In Java, it might look like:
      * 
      * <pre>
-     * public String com_google_Interface_someMethod(int a, double b) {
-     *   return com.google.MyJso$.someMethod$(this, a, b);
+     * interface Interface {
+     *   String someMethod(int a, double b);
+     * }
+     * 
+     * class J extends JSO implements I {
+     *   public String com_google_Interface_someMethod(int a, double b) {
+     *     return com.google.MyJso$.someMethod$(this, a, b);
+     *   }
      * }
      * </pre>
      * 
      * @param mangledName {@code com_google_gwt_sample_hello_client_Interface_a}
+     * @param interfaceMethod {@code java.lang.String a(int, double)}
      * @param implementingMethod {@code static final java.lang.String
      *          a$(com.google.gwt.sample.hello.client.Jso, ...);}
      */
-    private void writeTrampoline(String mangledName, Method implementingMethod) {
-      /*
-       * We derive the local descriptor by simply removing the first argument
-       * from the static method we want to call.
-       */
+    private void writeTrampoline(String mangledName, Method interfaceMethod,
+        Method implementingMethod) {
       assert implementingMethod.getArgumentTypes().length > 0;
-      String localDescriptor = "("
-          + implementingMethod.getDescriptor().substring(
-              1 + implementingMethod.getArgumentTypes()[0].getDescriptor().length());
+
+      /*
+       * The local descriptor is the same as the descriptor from the abstract
+       * method in the interface.
+       */
+      String localDescriptor = interfaceMethod.getDescriptor();
       Method localMethod = new Method(mangledName, localDescriptor);
 
       /*
@@ -217,10 +225,10 @@
    */
   public static ClassVisitor create(ClassVisitor cv, String classDescriptor,
       Set<String> jsoDescriptors, InstanceMethodOracle mapper,
-      Map<String, Method> methodsToImplement) {
+      SingleJsoImplData singleJsoImplData) {
 
     if (classDescriptor.equals(HostedModeClassRewriter.JAVASCRIPTOBJECT_IMPL_DESC)) {
-      return new ForJsoDollar(cv, jsoDescriptors, mapper, methodsToImplement);
+      return new ForJsoDollar(cv, jsoDescriptors, mapper, singleJsoImplData);
     } else {
       return new ForJsoInterface(cv, mapper);
     }
diff --git a/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java b/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java
index 80966f5..c0f93d4 100644
--- a/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java
@@ -31,6 +31,12 @@
     int getLength();
 
     JavaScriptObject getObject(int i);
+
+    /**
+     * Used to test virtual override where the implementation has a narrower
+     * return type.
+     */
+    Wide wide();
   }
 
   /**
@@ -70,6 +76,15 @@
   }
 
   /**
+   * Used for testing virtual overrides.
+   */
+  static class Narrow extends Wide {
+    public String toString() {
+      return "Narrow";
+    }
+  }
+
+  /**
    * This is a base class that is used to test adding interfaces to a JSO via a
    * subclass.
    */
@@ -84,6 +99,10 @@
     public final native JavaScriptObject getObject(int i) /*-{
       return this[i];
     }-*/;
+
+    public final Narrow wide() {
+      return new Narrow();
+    }
   }
 
   /**
@@ -98,6 +117,12 @@
     }
   }
 
+  /**
+   * Used for testing virtual overrides.
+   */
+  static class Wide {
+  }
+
   @Override
   public String getModuleName() {
     return "com.google.gwt.dev.jjs.CompilerSuite";
@@ -151,5 +176,6 @@
     Arrayish array = PlainJsoWithInterface.create();
     assertEquals(0, array.getLength());
     assertNull(array.getObject(0));
+    assertEquals("Narrow", array.wide().toString());
   }
 }