diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
index 201394f..26c4ab0 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
@@ -15,8 +15,6 @@
  */
 package com.google.gwt.core.ext.typeinfo;
 
-import com.google.gwt.core.client.SingleJsoImpl;
-
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -95,12 +93,6 @@
   public void addAnnotations(
       Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
     annotations.addAnnotations(declaredAnnotations);
-    for (Class<? extends Annotation> clazz : declaredAnnotations.keySet()) {
-      if (SingleJsoImpl.class.equals(clazz)) {
-        oracle.addSingleJsoInterface(this);
-        break;
-      }
-    }
   }
 
   public void addImplementedInterface(JClassType intf) {
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
index cda9804..0de6e96 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
@@ -18,6 +18,7 @@
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.generator.GenUtil;
+import com.google.gwt.dev.shell.JsValueGlue;
 
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
@@ -199,7 +200,10 @@
 
   private final Map<String, List<JWildcardType>> wildcardTypes = new HashMap<String, List<JWildcardType>>();
 
-  private final Set<JRealClassType> singleJsoImplTypes = new HashSet<JRealClassType>();
+  /**
+   * Maps SingleJsoImpl interfaces to the implementing JSO subtype.
+   */
+  private final Map<JClassType, JClassType> jsoSingleImpls = new IdentityHashMap<JClassType, JClassType>();
 
   public TypeOracle() {
     // Always create the default package.
@@ -256,6 +260,7 @@
   public void finish(TreeLogger logger) {
     JClassType[] newTypes = recentTypes.toArray(NO_JCLASSES);
     computeHierarchyRelationships(newTypes);
+    computeSingleJsoImplData(logger, newTypes);
     consumeTypeArgMetaData(logger, newTypes);
     recentTypes.clear();
   }
@@ -437,11 +442,21 @@
   }
 
   /**
-   * Returns an unmodifiable, live view of all interface types annotated with
-   * the SingleJsoImpl annotation.
+   * Returns the single implementation type for an interface returned via
+   * {@link #getSingleJsoImplInterfaces()} or <code>null</code> if no JSO
+   * implementation is defined.
    */
-  public Set<JRealClassType> getSingleJsoImplTypes() {
-    return Collections.unmodifiableSet(singleJsoImplTypes);
+  public JClassType getSingleJsoImpl(JClassType intf) {
+    assert intf.isInterface() == intf;
+    return jsoSingleImpls.get(intf);
+  }
+
+  /**
+   * Returns an unmodifiable, live view of all interface types that are
+   * implemented by exactly one JSO subtype.
+   */
+  public Set<JClassType> getSingleJsoImplInterfaces() {
+    return Collections.unmodifiableSet(jsoSingleImpls.keySet());
   }
 
   /**
@@ -616,12 +631,6 @@
     recentTypes.add(newType);
   }
 
-  void addSingleJsoInterface(JRealClassType singleJsoImplType) {
-    assert singleJsoImplType.isInterface() == singleJsoImplType : singleJsoImplType.getName()
-        + " has SingleJsoImpl, but is not an interface";
-    singleJsoImplTypes.add(singleJsoImplType);
-  }
-
   void invalidate(JRealClassType realClassType) {
     invalidatedTypes.add(realClassType);
   }
@@ -635,6 +644,61 @@
     }
   }
 
+  /**
+   * Updates the list of jsoSingleImpl types from recently-added types.
+   */
+  private void computeSingleJsoImplData(TreeLogger logger, JClassType[] newTypes) {
+    JClassType jsoType = findType(JsValueGlue.JSO_CLASS);
+    if (jsoType == null) {
+      return;
+    }
+
+    for (JClassType type : newTypes) {
+      if (!jsoType.isAssignableFrom(type)) {
+        continue;
+      }
+
+      for (JClassType intf : JClassType.getFlattenedSuperTypeHierarchy(type)) {
+        if (intf.isInterface() == null) {
+          // Not an interface
+          continue;
+        }
+
+        if (intf.getOverridableMethods().length == 0) {
+          /*
+           * Record a tag interface as being implemented by JSO, since they
+           * don't actually have any methods and we want to avoid spurious
+           * messages about multiple JSO types implementing a common interface.
+           */
+          jsoSingleImpls.put(intf, jsoType);
+          continue;
+        }
+
+        /*
+         * If the previously-registered implementation type for a SingleJsoImpl
+         * interface is a subtype of the type we're currently looking at, we
+         * want to choose the least-derived class.
+         */
+        JClassType previousType = jsoSingleImpls.get(intf);
+        if (previousType == null) {
+          jsoSingleImpls.put(intf, type);
+        } else if (type.isAssignableFrom(previousType)) {
+          jsoSingleImpls.put(intf, type);
+        } else if (type.isAssignableTo(previousType)) {
+          // Do nothing
+        } else {
+          // This should have been taken care of by JSORetrictionsChecker
+          logger.log(TreeLogger.ERROR,
+              "Already seen an implementing JSO subtype ("
+                  + previousType.getName() + ") for interface ("
+                  + intf.getName() + ") while examining newly-added type ("
+                  + type.getName() + "). This is a bug in "
+                  + "JSORestrictionsChecker.");
+        }
+      }
+    }
+  }
+
   private void consumeTypeArgMetaData(TreeLogger logger, JClassType[] types) {
     if (GenUtil.warnAboutMetadata()) {
       logger = logger.branch(
@@ -1000,7 +1064,7 @@
       JRealClassType classType = iter.next();
       String fqcn = classType.getQualifiedSourceName();
       allTypes.remove(fqcn);
-      singleJsoImplTypes.remove(classType);
+      jsoSingleImpls.remove(classType);
       JPackage pkg = classType.getPackage();
       if (pkg != null) {
         pkg.remove(classType);
diff --git a/dev/core/src/com/google/gwt/dev/javac/JSORestrictionsChecker.java b/dev/core/src/com/google/gwt/dev/javac/JSORestrictionsChecker.java
index e1c3dff..1d56076 100644
--- a/dev/core/src/com/google/gwt/dev/javac/JSORestrictionsChecker.java
+++ b/dev/core/src/com/google/gwt/dev/javac/JSORestrictionsChecker.java
@@ -15,14 +15,12 @@
  */
 package com.google.gwt.dev.javac;
 
-import com.google.gwt.core.client.SingleJsoImpl;
 import com.google.gwt.dev.util.InstalledHelpInfo;
 
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
-import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
@@ -37,7 +35,6 @@
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
@@ -71,13 +68,6 @@
   public static class CheckerState {
 
     /**
-     * This maps interfaces tagged with the SingleJsoImpl annotation to the
-     * names of their declared super-interfaces.
-     */
-    private final Map<TypeDeclaration, Set<String>> interfacesToSuperInterfaces = new HashMap<TypeDeclaration, Set<String>>();
-    private final Map<TypeDeclaration, Set<String>> trivialToSuperInterfaces = new HashMap<TypeDeclaration, Set<String>>();
-
-    /**
      * This maps JSO implementation types to their implemented SingleJsoImpl
      * interfaces.
      */
@@ -89,63 +79,17 @@
     private final Map<TypeDeclaration, CompilationUnitDeclaration> nodesToCuds = new IdentityHashMap<TypeDeclaration, CompilationUnitDeclaration>();
 
     /**
-     * A convenience for validity checking.
-     */
-    private final Set<String> singleJsoImplInterfaceNames = new HashSet<String>();
-    private final Set<String> trivialInterfaceNames = new HashSet<String>();
-
-    /**
-     * Just used for sanity checking. Not populated unless assertions are on.
-     */
-    private final Set<String> regularInterfaceNames = getClass().desiredAssertionStatus()
-        ? new HashSet<String>() : null;
-
-    /**
      * This method should be called after all CUDs are passed into check().
      */
     public void finalCheck() {
       /*
-       * Compute all interfaces that are completely trivial.
-       */
-      Set<String> tagInterfaceNames = new HashSet<String>();
-      for (Map.Entry<TypeDeclaration, Set<String>> entry : trivialToSuperInterfaces.entrySet()) {
-        if (entry.getValue().isEmpty()
-            || trivialInterfaceNames.containsAll(entry.getValue())) {
-          tagInterfaceNames.add(CharOperation.toString(entry.getKey().binding.compoundName));
-        }
-      }
-
-      /*
-       * Make sure that all SingleJsoImpl interfaces extends only SingleJsoImpl
-       * interfaces or tag interfaces.
-       */
-      for (Map.Entry<TypeDeclaration, Set<String>> entry : interfacesToSuperInterfaces.entrySet()) {
-        TypeDeclaration node = entry.getKey();
-
-        for (String intfName : entry.getValue()) {
-          if (tagInterfaceNames.contains(intfName)
-              || singleJsoImplInterfaceNames.contains(intfName)) {
-            continue;
-          } else {
-            assert regularInterfaceNames.contains(intfName);
-            errorOn(node, nodesToCuds.get(node), ERR_INTF_EXTENDS_BAD_INTF);
-          }
-        }
-      }
-
-      /*
-       * Make sure that any interfaces implemented by the JSO types have the
-       * SingleJsoImpl annotation. Also, check the one-and-only JSO
-       * implementation of the interface types.
+       * Ensure that every interfaces has exactly zero or one JSO subtype that
+       * implements it.
        */
       Map<String, TypeDeclaration> singleImplementations = new HashMap<String, TypeDeclaration>();
       for (Map.Entry<TypeDeclaration, Set<String>> entry : jsoImplsToInterfaces.entrySet()) {
         TypeDeclaration node = entry.getKey();
         for (String intfName : entry.getValue()) {
-          if (!singleJsoImplInterfaceNames.contains(intfName)) {
-            errorOn(node, nodesToCuds.get(node),
-                errInterfaceWithMethodsNoAnnotation(intfName));
-          }
 
           if (!singleImplementations.containsKey(intfName)) {
             singleImplementations.put(intfName, node);
@@ -181,15 +125,8 @@
     public void retainAll(Collection<CompilationUnit> units) {
       // Fast-path for removing everything
       if (units.isEmpty()) {
-        interfacesToSuperInterfaces.clear();
-        trivialToSuperInterfaces.clear();
         jsoImplsToInterfaces.clear();
         nodesToCuds.clear();
-        singleJsoImplInterfaceNames.clear();
-        trivialInterfaceNames.clear();
-        if (regularInterfaceNames != null) {
-          regularInterfaceNames.clear();
-        }
         return;
       }
 
@@ -211,23 +148,9 @@
         if (!retainedTypeNames.contains(CharOperation.toString(decl.binding.compoundName))) {
           it.remove();
 
-          assert interfacesToSuperInterfaces.containsKey(decl)
-              || trivialToSuperInterfaces.containsKey(decl)
-              || jsoImplsToInterfaces.containsKey(decl) : "TypeDeclaration "
-              + CharOperation.toString(decl.binding.compoundName)
-              + " in nodesToCuds, but not in any of the maps";
-
-          interfacesToSuperInterfaces.remove(decl);
-          trivialToSuperInterfaces.remove(decl);
           jsoImplsToInterfaces.remove(decl);
         }
       }
-
-      singleJsoImplInterfaceNames.retainAll(retainedTypeNames);
-      trivialInterfaceNames.retainAll(retainedTypeNames);
-      if (regularInterfaceNames != null) {
-        regularInterfaceNames.retainAll(retainedTypeNames);
-      }
     }
 
     private void add(Map<TypeDeclaration, Set<String>> map,
@@ -245,12 +168,6 @@
       add(jsoImplsToInterfaces, jsoType, interfaceName);
     }
 
-    private void empty(Map<TypeDeclaration, Set<String>> map,
-        TypeDeclaration key) {
-      assert !map.containsKey(key);
-      map.put(key, Collections.<String> emptySet());
-    }
-
     private boolean hasSupertypeNamed(TypeDeclaration type, char[][] qType) {
       ReferenceBinding b = type.binding;
       while (b != null) {
@@ -261,36 +178,6 @@
       }
       return false;
     }
-
-    private void jsoSingleImplInterface(TypeDeclaration type,
-        CompilationUnitDeclaration cud, String superInterface) {
-      nodesToCuds.put(type, cud);
-      singleJsoImplInterfaceNames.add(CharOperation.toString(type.binding.compoundName));
-      if (superInterface == null) {
-        empty(interfacesToSuperInterfaces, type);
-      } else {
-        add(interfacesToSuperInterfaces, type, superInterface);
-      }
-    }
-
-    private void regularInterface(TypeDeclaration intfType,
-        CompilationUnitDeclaration cud, String superInterfaceName) {
-      // Just used for sanity checking
-      if (getClass().desiredAssertionStatus()) {
-        regularInterfaceNames.add(CharOperation.toString(intfType.binding.compoundName));
-      }
-    }
-
-    private void trivialInterface(TypeDeclaration intfType,
-        CompilationUnitDeclaration cud, String superInterfaceName) {
-      nodesToCuds.put(intfType, cud);
-      trivialInterfaceNames.add(CharOperation.toString(intfType.binding.compoundName));
-      if (superInterfaceName == null) {
-        empty(trivialToSuperInterfaces, intfType);
-      } else {
-        add(trivialToSuperInterfaces, intfType, superInterfaceName);
-      }
-    }
   }
 
   private class JSORestrictionsVisitor extends ASTVisitor implements
@@ -387,64 +274,10 @@
     }
 
     private boolean checkType(TypeDeclaration type) {
-      /*
-       * See if we're looking at something tagged with a SingleJsoImpl
-       * annotation.
-       */
-      if (type.annotations != null) {
-        for (Annotation a : type.annotations) {
-          if (!(a.resolvedType instanceof ReferenceBinding)) {
-            continue;
-          }
-
-          ReferenceBinding refBinding = (ReferenceBinding) a.resolvedType;
-          if (!SINGLE_JSO_IMPL_CLASS.equals(new String(
-              refBinding.readableName()))) {
-            continue;
-          }
-
-          if (!type.binding.isInterface()) {
-            errorOn(type, ERR_ONLY_INTERFACES);
-            continue;
-          }
-
-          // Interfaces should not have superclasses, just super-interfaces
-          assert type.superclass == null;
-
-          if (type.superInterfaces != null) {
-            for (ReferenceBinding ref : type.binding.superInterfaces) {
-              String superInterfaceName = CharOperation.toString(ref.compoundName);
-              state.jsoSingleImplInterface(type, cud, superInterfaceName);
-            }
-          } else {
-            state.jsoSingleImplInterface(type, cud, null);
-          }
-        }
-      }
-
-      if (type.binding.isInterface()) {
-        boolean isTrivial = type.methods == null || type.methods.length == 0;
-        if (type.superInterfaces != null) {
-          for (ReferenceBinding ref : type.binding.superInterfaces) {
-            String superInterfaceName = CharOperation.toString(ref.compoundName);
-            if (isTrivial) {
-              state.trivialInterface(type, cud, superInterfaceName);
-            } else {
-              state.regularInterface(type, cud, superInterfaceName);
-            }
-          }
-        } else {
-          if (isTrivial) {
-            state.trivialInterface(type, cud, null);
-          } else {
-            state.regularInterface(type, cud, null);
-          }
-        }
-      }
-
       if (!isJsoSubclass(type.binding)) {
         return false;
       }
+
       if (type.enclosingType != null && !type.binding.isStatic()) {
         errorOn(type, ERR_IS_NONSTATIC_NESTED);
       }
@@ -482,15 +315,12 @@
   static final String ERR_CONSTRUCTOR_WITH_PARAMETERS = "Constructors must not have parameters in subclasses of JavaScriptObject";
   static final String ERR_INSTANCE_FIELD = "Instance fields cannot be used in subclasses of JavaScriptObject";
   static final String ERR_INSTANCE_METHOD_NONFINAL = "Instance methods must be 'final' in non-final subclasses of JavaScriptObject";
-  static final String ERR_INTF_EXTENDS_BAD_INTF = "SingleJsoImpl interfaces must only extend other SingleJsoImpl interfaces or tag interfaces";
   static final String ERR_IS_NONSTATIC_NESTED = "Nested classes must be 'static' if they extend JavaScriptObject";
   static final String ERR_NEW_JSO = "'new' cannot be used to create instances of JavaScriptObject subclasses; instances must originate in JavaScript";
   static final String ERR_NONEMPTY_CONSTRUCTOR = "Constructors must be totally empty in subclasses of JavaScriptObject";
   static final String ERR_NONPROTECTED_CONSTRUCTOR = "Constructors must be 'protected' in subclasses of JavaScriptObject";
-  static final String ERR_ONLY_INTERFACES = "SingleJsoImpl may only be applied to interface types";
   static final String ERR_OVERRIDDEN_METHOD = "Methods cannot be overridden in JavaScriptObject subclasses";
   static final String JSO_CLASS = "com/google/gwt/core/client/JavaScriptObject";
-  static final String SINGLE_JSO_IMPL_CLASS = SingleJsoImpl.class.getName();
 
   /**
    * Checks an entire
@@ -504,16 +334,11 @@
 
   static String errAlreadyImplemented(String intfName, String impl1,
       String impl2) {
-    return "Only one JavaScriptObject type may implement the methods of a "
-        + "@SingleJsoImpl type interface. The interface (" + intfName
+    return "Only one JavaScriptObject type may implement the methods of an "
+        + "interface that declared methods. The interface (" + intfName
         + ") is implemented by both (" + impl1 + ") and (" + impl2 + ")";
   }
 
-  static String errInterfaceWithMethodsNoAnnotation(String intfName) {
-    return "JavaScriptObject classes cannot implement interfaces with methods ("
-        + intfName + ") that do not define the @SingleJsoImpl annotation";
-  }
-
   private static void errorOn(ASTNode node, CompilationUnitDeclaration cud,
       String error) {
     GWTProblem.recordInCud(node, cud, error, new InstalledHelpInfo(
diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java
index c23140d..cdbd1de 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java
@@ -665,10 +665,16 @@
           continue;
         }
         JInterfaceType intr = (JInterfaceType) refType;
+
         if (intr.methods.size() <= 1) {
-          // Ignore tag interfaces
+          /*
+           * Record a tag interface as being implemented by JSO, since they
+           * don't actually have any methods and we want to avoid spurious
+           * messages about multiple JSO types implementing a common interface.
+           */
           assert intr.methods.size() == 0
               || intr.methods.get(0).getName().equals("$clinit");
+          jsoSingleImpls.put(intr, program.getJavaScriptObject());
           continue;
         }
 
@@ -678,6 +684,7 @@
 
           if (allAssignableFrom(alreadySeen).contains(type)) {
             jsoSingleImpls.put(intr, (JClassType) type);
+
           } else {
             assert allAssignableFrom(type).contains(alreadySeen) : "Already recorded "
                 + alreadySeen.getName()
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 eaa4575..48a46d5 100644
--- a/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
+++ b/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
@@ -22,13 +22,14 @@
 import com.google.gwt.core.ext.typeinfo.JClassType;
 import com.google.gwt.core.ext.typeinfo.JMethod;
 import com.google.gwt.core.ext.typeinfo.JParameter;
+import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
 import com.google.gwt.core.ext.typeinfo.JType;
-import com.google.gwt.core.ext.typeinfo.NotFoundException;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.dev.javac.CompilationState;
 import com.google.gwt.dev.javac.CompilationUnit;
 import com.google.gwt.dev.javac.CompiledClass;
 import com.google.gwt.dev.javac.JsniMethod;
+import com.google.gwt.dev.jjs.InternalCompilerException;
 import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter;
 import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.InstanceMethodOracle;
 import com.google.gwt.dev.util.JsniRef;
@@ -813,7 +814,7 @@
       SortedMap<String, com.google.gwt.dev.asm.commons.Method> mangledNamesToImplementations) {
 
     // Loop over all types declared with the SingleJsoImpl annotation
-    typeLoop : for (JClassType type : typeOracle.getSingleJsoImplTypes()) {
+    typeLoop : for (JClassType type : typeOracle.getSingleJsoImplInterfaces()) {
       assert type.isInterface() == type : "Expecting interfaces only";
 
       /*
@@ -842,11 +843,10 @@
          * 
          * @SingleJsoImpl interface C extends A, B {}
          * 
-         * Methods interited from interfaces A and B must be dispatched to their
+         * Methods inherited from interfaces A and B must be dispatched to their
          * respective JSO implementations.
          */
-        JClassType implementingType = findImplementingJsoType(m,
-            m.getEnclosingType().getSubtypes());
+        JClassType implementingType = typeOracle.getSingleJsoImpl(m.getEnclosingType());
 
         if (implementingType == null) {
           /*
@@ -880,11 +880,11 @@
          * 
          * This must be kept in sync with the WriteJsoImpl class.
          */
-        String decl = m.getReturnType().getParameterizedQualifiedSourceName()
-            + " " + m.getName() + "$ (" + getBinaryName(implementingType);
+        String decl = getBinaryOrPrimitiveName(m.getReturnType()) + " "
+            + m.getName() + "$ (" + getBinaryOrPrimitiveName(implementingType);
         for (JParameter p : m.getParameters()) {
           decl += ",";
-          decl += p.getType().getParameterizedQualifiedSourceName();
+          decl += getBinaryOrPrimitiveName(p.getType());
         }
         decl += ")";
 
@@ -992,41 +992,25 @@
     return classBytes;
   }
 
-  private JClassType findImplementingJsoType(JMethod toImplement,
-      JClassType[] types) {
-    JClassType jsoType = typeOracle.findType(JsValueGlue.JSO_CLASS);
-    JType[] paramTypes = new JType[toImplement.getParameters().length];
-    for (int i = 0, j = paramTypes.length; i < j; i++) {
-      paramTypes[i] = toImplement.getParameters()[i].getType();
-    }
-
-    for (JClassType type : types) {
-      if (type == null) {
-        continue;
-      } else if (type.isAbstract()) {
-        continue;
-      } else if (!type.isAssignableTo(jsoType)) {
-        continue;
-      } else {
-        try {
-          JMethod m = type.getMethod(toImplement.getName(), paramTypes);
-          if (!m.isAbstract()) {
-            return type;
-          }
-        } catch (NotFoundException e) {
-          // Ignore
-        }
-      }
-    }
-    return null;
-  }
-
   private String getBinaryName(JClassType type) {
     String name = type.getPackage().getName() + '.';
     name += type.getName().replace('.', '$');
     return name;
   }
 
+  private String getBinaryOrPrimitiveName(JType type) {
+    JClassType asClass = type.isClassOrInterface();
+    JPrimitiveType asPrimitive = type.isPrimitive();
+    if (asClass != null) {
+      return getBinaryName(asClass);
+    } else if (asPrimitive != null) {
+      return asPrimitive.getQualifiedSourceName();
+    } else {
+      throw new InternalCompilerException("Cannot create binary name for "
+          + type.getQualifiedSourceName());
+    }
+  }
+
   /**
    * Returns the compilationUnit corresponding to the className. For nested
    * classes, the unit corresponding to the top level type is returned.
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 adb6326..b08e667 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
@@ -221,6 +221,10 @@
           mv.visitVarInsn(t.getOpcode(Opcodes.ILOAD), var);
           var += t.getSize();
         }
+
+        // Make sure there's enough room for the return value
+        size = Math.max(size, toCall.getReturnType().getSize());
+
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, currentTypeName,
             toCall.getName(), toCall.getDescriptor());
         mv.visitInsn(toCall.getReturnType().getOpcode(Opcodes.IRETURN));
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 4f1e265..4adf11c 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
@@ -150,6 +150,10 @@
           mv.visitVarInsn(t.getOpcode(Opcodes.ILOAD), var);
           var += t.getSize();
         }
+
+        // Make sure there's enough room for the return value
+        size = Math.max(size, implementingMethod.getReturnType().getSize());
+
         mv.visitMethodInsn(Opcodes.INVOKESTATIC,
             implementingType.getInternalName(), implementingMethod.getName(),
             implementingMethod.getDescriptor());
diff --git a/dev/core/super/com/google/gwt/core/client/SingleJsoImpl.java b/dev/core/super/com/google/gwt/core/client/SingleJsoImpl.java
deleted file mode 100644
index bbc2a55..0000000
--- a/dev/core/super/com/google/gwt/core/client/SingleJsoImpl.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 2009 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.gwt.core.client;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Target;
-
-/**
- * The presence of this annotation on an interface type allows one
- * JavaScriptObject subclass to implement the interface. Any number of types
- * that are not derived from JavaScriptObject may also implement the interface.
- * <p>
- * The use of the SingleJsoImpl annotation is subject to the following
- * restrictions:
- * <ul>
- * <li>Must be applied only to interface types</li>
- * <li>Any super-interfaces of the annotated interface must also be annotated
- * with the SingleJsoImpl</li>
- * </ul>
- */
-@Documented
-@Target(ElementType.TYPE)
-public @interface SingleJsoImpl {
-}
\ No newline at end of file
diff --git a/dev/core/test/com/google/gwt/dev/javac/JSORestrictionsTest.java b/dev/core/test/com/google/gwt/dev/javac/JSORestrictionsTest.java
index 836dca5..34acec3 100644
--- a/dev/core/test/com/google/gwt/dev/javac/JSORestrictionsTest.java
+++ b/dev/core/test/com/google/gwt/dev/javac/JSORestrictionsTest.java
@@ -33,21 +33,6 @@
     }
   }
 
-  public void testAnnotationOnClass() {
-    StringBuffer buggyCode = new StringBuffer();
-    buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
-    buggyCode.append("public class Buggy {\n");
-    buggyCode.append("  @SingleJsoImpl \n");
-    buggyCode.append("  static class Squeaks {\n");
-    buggyCode.append("    public void squeak() {}\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("}\n");
-
-    shouldGenerateError(buggyCode, "Line 5: "
-        + JSORestrictionsChecker.ERR_ONLY_INTERFACES);
-  }
-
   public void testFinalClass() {
     StringBuffer code = new StringBuffer();
     code.append("import com.google.gwt.core.client.JavaScriptObject;\n");
@@ -62,13 +47,10 @@
   public void testImplementsInterfaces() {
     StringBuffer goodCode = new StringBuffer();
     goodCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    goodCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
     goodCode.append("public class Buggy {\n");
-    goodCode.append("  @SingleJsoImpl\n");
     goodCode.append("  static interface Squeaks {\n");
     goodCode.append("    public void squeak();\n");
     goodCode.append("  }\n");
-    goodCode.append("  @SingleJsoImpl \n");
     goodCode.append("  static interface Squeaks2 extends Squeaks {\n");
     goodCode.append("    public void squeak();\n");
     goodCode.append("    public void squeak2();\n");
@@ -112,9 +94,7 @@
   public void testMultipleImplementations() {
     StringBuffer buggyCode = new StringBuffer();
     buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
     buggyCode.append("public class Buggy {\n");
-    buggyCode.append("  @SingleJsoImpl\n");
     buggyCode.append("  static interface Squeaks {\n");
     buggyCode.append("    public void squeak();\n");
     buggyCode.append("  }\n");
@@ -128,9 +108,9 @@
     buggyCode.append("  }\n");
     buggyCode.append("}\n");
 
-    shouldGenerateError(buggyCode, "Line 8: "
+    shouldGenerateError(buggyCode, "Line 6: "
         + JSORestrictionsChecker.errAlreadyImplemented("Buggy$Squeaks",
-            "Buggy$Squeaker", "Buggy$Squeaker2"), "Line 12: "
+            "Buggy$Squeaker", "Buggy$Squeaker2"), "Line 10: "
         + JSORestrictionsChecker.errAlreadyImplemented("Buggy$Squeaks",
             "Buggy$Squeaker", "Buggy$Squeaker2"));
   }
@@ -152,13 +132,10 @@
   public void testNoAnnotationOnInterfaceSubtype() {
     StringBuffer goodCode = new StringBuffer();
     goodCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    goodCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
     goodCode.append("public class Buggy {\n");
-    goodCode.append("  @SingleJsoImpl\n");
     goodCode.append("  static interface Squeaks {\n");
     goodCode.append("    public void squeak();\n");
     goodCode.append("  }\n");
-    goodCode.append("  /* @SingleJsoImpl */\n");
     goodCode.append("  static interface Sub extends Squeaks {\n");
     goodCode.append("  }\n");
     goodCode.append("}\n");
@@ -166,91 +143,6 @@
     shouldGenerateNoError(goodCode);
   }
 
-  public void testNoAnnotationOnInterfaceSupertype() {
-    StringBuffer buggyCode = new StringBuffer();
-    buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
-    buggyCode.append("public class Buggy {\n");
-    buggyCode.append("  /* @SingleJsoImpl */ \n");
-    buggyCode.append("  static interface Squeaks {\n");
-    buggyCode.append("    public void squeak();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("  @SingleJsoImpl \n");
-    buggyCode.append("  static interface Sub extends Squeaks {\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("}\n");
-
-    shouldGenerateError(buggyCode, "Line 9: "
-        + JSORestrictionsChecker.ERR_INTF_EXTENDS_BAD_INTF);
-  }
-
-  public void testNoAnnotationOnInterfaceSupertypeSandwich() {
-    StringBuffer buggyCode = new StringBuffer();
-    buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
-    buggyCode.append("public class Buggy {\n");
-    buggyCode.append("  @SingleJsoImpl\n");
-    buggyCode.append("  static interface Squeaks {\n");
-    buggyCode.append("    public void squeak();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("  /* @SingleJsoImpl */\n");
-    buggyCode.append("  static interface Squeaks2 extends Squeaks {\n");
-    buggyCode.append("    public void squeak2();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("  @SingleJsoImpl\n");
-    buggyCode.append("  static interface Squeaks3 extends Squeaks2 {\n");
-    buggyCode.append("    public void squeak3();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("}\n");
-
-    shouldGenerateError(buggyCode, "Line 13: "
-        + JSORestrictionsChecker.ERR_INTF_EXTENDS_BAD_INTF);
-  }
-
-  public void testNoAnnotationOnOtherwiseValidInterfaces() {
-    StringBuffer buggyCode = new StringBuffer();
-    buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("public class Buggy {\n");
-    buggyCode.append("  static interface Squeaks {\n");
-    buggyCode.append("    public void squeak();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("  static class Squeaker extends JavaScriptObject implements Squeaks {\n");
-    buggyCode.append("    public final void squeak() { }\n");
-    buggyCode.append("    protected Squeaker() { }\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("}\n");
-
-    shouldGenerateError(
-        buggyCode,
-        "Line 6: "
-            + JSORestrictionsChecker.errInterfaceWithMethodsNoAnnotation(("Buggy$Squeaks")));
-  }
-
-  public void testNoAnnotationOnOtherwiseValidDerivedInterfaces() {
-    StringBuffer buggyCode = new StringBuffer();
-    buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
-    buggyCode.append("public class Buggy {\n");
-    buggyCode.append("  @SingleJsoImpl\n");
-    buggyCode.append("  static interface Squeaks {\n");
-    buggyCode.append("    public void squeak();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("  static interface Squeaks2 extends Squeaks {\n");
-    buggyCode.append("    public void squeak2();\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("  static class Squeaker extends JavaScriptObject implements Squeaks2 {\n");
-    buggyCode.append("    public final void squeak() { }\n");
-    buggyCode.append("    public final void squeak2() { }\n");
-    buggyCode.append("    protected Squeaker() { }\n");
-    buggyCode.append("  }\n");
-    buggyCode.append("}\n");
-
-    shouldGenerateError(
-        buggyCode,
-        "Line 11: "
-            + JSORestrictionsChecker.errInterfaceWithMethodsNoAnnotation(("Buggy$Squeaks2")));
-  }
-
   public void testNoConstructor() {
     StringBuffer buggyCode = new StringBuffer();
     buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
@@ -288,9 +180,7 @@
   public void testNonJsoInterfaceExtension() {
     StringBuffer goodCode = new StringBuffer();
     goodCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    goodCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
     goodCode.append("public class Buggy {\n");
-    goodCode.append("  @SingleJsoImpl\n");
     goodCode.append("  static interface Squeaks {\n");
     goodCode.append("    public void squeak();\n");
     goodCode.append("  }\n");
@@ -361,11 +251,9 @@
   public void testTagInterfaces() {
     StringBuffer goodCode = new StringBuffer();
     goodCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    goodCode.append("import com.google.gwt.core.client.SingleJsoImpl;\n");
     goodCode.append("public class Buggy {\n");
     goodCode.append("  static interface Tag {}\n");
     goodCode.append("  static interface Tag2 extends Tag {}\n");
-    goodCode.append("  @SingleJsoImpl \n");
     goodCode.append("  static interface IntrExtendsTag extends Tag2 {\n");
     goodCode.append("    public void intrExtendsTag();\n");
     goodCode.append("  }\n");
diff --git a/distro-source/core/src/doc/helpInfo/jsoRestrictions.html b/distro-source/core/src/doc/helpInfo/jsoRestrictions.html
index 0354e56..b3ef73f 100644
--- a/distro-source/core/src/doc/helpInfo/jsoRestrictions.html
+++ b/distro-source/core/src/doc/helpInfo/jsoRestrictions.html
@@ -15,28 +15,21 @@
   explicitly final, a member of a final class, or private. <em>Methods
   of JSO classes cannot be overridden, because calls to such methods
   could require dynamic dispatch.</em></li>
-  <li>JSO classes may implement interfaces that define methods, but
-  only if those interfaces are annotated with <code>@SingleJsoImpl</code>.
-  <em>This ensures that polymorphic dispatch via a <code>@SingleJsoImpl</code>
-  interface can be statically resolved to exactly one implementing JSO
-  subtype.</em>
+  <li>An interface type may be implemented by at most one JSO
+  subtype. <em>This ensures that polymorphic dispatch via a
+  "SingleJsoImpl" interface can be statically resolved to exactly one
+  implementing JSO subtype.</em>
   <ol>
-    <li>A <code>@SingleJsoImpl</code> interface may only extend
-    "tag" interfaces that declare no methods or other interfaces
-    annotated with <code>@SingleJsoImpl</code>.</li>
-    <li>It is valid for a <code>@SingleJsoImpl</code> interface to
-    be extended by an interface that is not annotated in this fashion,
-    however the sub-interface may not be implemented by any <code>JavaScriptObjects</code>.</li>
-    <li>A <code>JavaScriptObject</code> that implements a <code>@SingleJsoImpl</code>
-    interface may be further extended. The subclasses may implement
-    additional <code>@SingleJsoImpl</code> interfaces. <em>The
-    methods on a JSO must be effectively final, so each <code>@SingleJsoImpl</code>
+    <li>A <code>JavaScriptObject</code> that implements a
+    "SingleJsoImpl" interface may be further extended. The subclasses
+    may implement additional "SingleJsoImpl" interfaces. <em>The
+    methods on a JSO must be effectively final, so each "SingleJsoImpl"
     method still has a 1:1 mapping to a method defined within a JSO
     subtype.</em></li>
     <li>It is valid for any number of any non-<code>JavaScriptObject</code>
-    types to implement a <code>@SingleJsoImpl</code> interface. <em>There
-    is a runtime dispatch penalty when a <code>@SingleJsoImpl</code>
-    interface is implemented by both JSO and non-JSO types.</em></li>
+    types to implement a "SingleJsoImpl" interface. <em>There is a
+    slight runtime dispatch penalty when a "SingleJsoImpl" interface is
+    implemented by both JSO and non-JSO types.</em></li>
   </ol>
   </li>
   <li>No instance methods on JSO classes may override another
diff --git a/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java b/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java
index 0914f54..7edef96 100644
--- a/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java
@@ -16,7 +16,7 @@
 package com.google.gwt.dev.jjs.test;
 
 import com.google.gwt.core.client.JavaScriptObject;
-import com.google.gwt.core.client.SingleJsoImpl;
+import com.google.gwt.dev.jjs.test.SingleJsoImplTest.JsoHasInnerJsoType.InnerType;
 import com.google.gwt.junit.client.GWTTestCase;
 
 import java.io.IOException;
@@ -26,7 +26,6 @@
  */
 public class SingleJsoImplTest extends GWTTestCase {
 
-  @SingleJsoImpl
   interface Adder {
     int ADDER_CONST = 6;
 
@@ -44,9 +43,28 @@
      * stack, so this ensures that we're handling that case correctly.
      */
     double add(double a, int b);
+
+    /*
+     * Ensure that we can return types whose sizes are larger than the size of
+     * the arguments.
+     */
+    long returnLong();
   }
 
-  @SingleJsoImpl
+  interface CallsMethodInInnerType {
+    interface InnerInterface {
+      void call(int a);
+
+      int get();
+    }
+
+    InnerInterface call(InnerInterface o, int a);
+  }
+
+  interface CallsStaticMethodInSubclass {
+    String call(int a, int b);
+  }
+
   interface Divider extends Multiplier {
     int divide(int a, int b);
   }
@@ -55,13 +73,17 @@
     public double add(double a, int b) {
       return a + b;
     }
+
+    public long returnLong() {
+      return 5L;
+    }
   }
 
   /**
    * The extra declaration of implementing Multiplier should still be legal.
    */
   static class JavaDivider extends JavaMultiplier implements Divider,
-      Multiplier {
+      Multiplier, Tag {
     public int divide(int a, int b) {
       return a / b;
     }
@@ -87,28 +109,82 @@
     protected JsoAdder() {
     }
 
-    public final native double add(double a, int b) /*-{return this.offset * (a + b);}-*/;
+    public final native double add(double a, int b) /*-{
+      return this.offset * (a + b);
+    }-*/;
+
+    public final long returnLong() {
+      return 5L;
+    }
   }
 
-  static class JsoDivider extends JsoMultiplier implements Divider {
+  static class JsoCallsStaticMethodInSubclass extends JavaScriptObject
+      implements CallsStaticMethodInSubclass {
+    protected JsoCallsStaticMethodInSubclass() {
+    }
+
+    public final native String call(int a, int b) /*-{
+      return "foo" + @com.google.gwt.dev.jjs.test.SingleJsoImplTest.JsoCallsStaticMethodInSubclassSubclass::actual(II)(a, b);
+    }-*/;
+  }
+
+  static class JsoCallsStaticMethodInSubclassSubclass extends
+      JsoCallsStaticMethodInSubclass {
+    public static String actual(int a, int b) {
+      return String.valueOf(a + b);
+    }
+
+    protected JsoCallsStaticMethodInSubclassSubclass() {
+    }
+  }
+
+  static class JsoDivider extends JsoMultiplier implements Divider, Tag {
     protected JsoDivider() {
     }
 
-    public final native int divide(int a, int b) /*-{return this.offset * a / b;}-*/;
+    public final native int divide(int a, int b) /*-{
+      return this.offset * a / b;
+    }-*/;
+  }
+
+  static class JsoHasInnerJsoType extends JavaScriptObject implements
+      CallsMethodInInnerType {
+    static class InnerType extends JavaScriptObject implements InnerInterface {
+      protected InnerType() {
+      }
+
+      public final native void call(int a) /*-{
+        this.foo = a;
+      }-*/;
+
+      public final native int get() /*-{
+        return this.foo;
+      }-*/;
+    }
+
+    protected JsoHasInnerJsoType() {
+    }
+
+    public final InnerInterface call(InnerInterface o, int a) {
+      o.call(a);
+      return o;
+    }
   }
 
   static class JsoMultiplier extends JavaScriptObject implements Multiplier {
     protected JsoMultiplier() {
     }
 
-    public final native int multiply(int a, int b) /*-{return this.offset * a * b;}-*/;
+    public final native int multiply(int a, int b) /*-{
+      return this.offset * a * b;
+    }-*/;
   }
 
   /**
    * Just a random JSO type for testing cross-casting.
    */
   final static class JsoRandom extends JavaScriptObject implements
-      SameDescriptors {
+      SameDescriptors, Tag {
     protected JsoRandom() {
     }
 
@@ -154,7 +230,6 @@
     double log2(int a);
   }
 
-  @SingleJsoImpl
   interface Multiplier {
     int multiply(int a, int b);
   }
@@ -163,7 +238,6 @@
    * This interface makes sure that types with identical method signatures will
    * still dispatch correctly.
    */
-  @SingleJsoImpl
   interface SameDescriptors {
     int SAME_NAME = 6;
 
@@ -174,7 +248,6 @@
     int multiply(int a, int b);
   }
 
-  @SingleJsoImpl
   interface Simple {
     String a();
 
@@ -192,24 +265,41 @@
     }
   }
 
-  @SingleJsoImpl
   interface SimpleOnlyJavaInterface {
     String simpleOnlyJava();
   }
 
-  private static native JsoAdder makeAdder(int offset) /*-{return {offset:offset};}-*/;
+  interface Tag {
+  }
 
-  private static native JsoDivider makeDivider(int offset) /*-{return {offset:offset};}-*/;
+  private static native JsoAdder makeAdder(int offset) /*-{
+    return {offset:offset};
+  }-*/;
 
-  private static native JsoMultiplier makeMultiplier(int offset) /*-{return {offset:offset};}-*/;
+  private static native JsoDivider makeDivider(int offset) /*-{
+    return {offset:offset};
+  }-*/;
 
-  private static native JsoSimple makeSimple() /*-{return {};}-*/;
+  private static native JsoMultiplier makeMultiplier(int offset) /*-{
+    return {offset:offset};
+  }-*/;
+
+  private static native JsoSimple makeSimple() /*-{
+    return {};
+  }-*/;
 
   @Override
   public String getModuleName() {
     return "com.google.gwt.dev.jjs.CompilerSuite";
   }
 
+  public void testCallsToInnerTypes() {
+    CallsMethodInInnerType a = (CallsMethodInInnerType) JavaScriptObject.createObject();
+    InnerType i = (InnerType) JavaScriptObject.createObject();
+    assertEquals(5, a.call(i, 5).get());
+    assertEquals(5, i.get());
+  }
+
   public void testDualCase() {
     // Direct dispatch
     {
@@ -218,6 +308,7 @@
 
       JsoAdder jso = makeAdder(2);
       assertEquals(4.0, jso.add(1, 1));
+      assertEquals(5L, jso.returnLong());
     }
 
     // Just check dispatch via the interface
@@ -227,6 +318,7 @@
 
       a = makeAdder(2);
       assertEquals(4.0, a.add(1, 1));
+      assertEquals(5L, a.returnLong());
     }
 
     // Check casting
@@ -234,8 +326,11 @@
       Object a = new JavaAdder();
       assertEquals(2.0, ((Adder) a).add(1, 1));
       assertEquals(2.0, ((JavaAdder) a).add(1, 1));
+      assertEquals(5L, ((Adder) a).returnLong());
+      assertEquals(5L, ((JavaAdder) a).returnLong());
       assertTrue(a instanceof JavaAdder);
       assertFalse(a instanceof JsoAdder);
+      assertFalse(a instanceof Tag);
       try {
         ((JsoAdder) a).add(1, 1);
         fail("Should have thrown CCE");
@@ -246,8 +341,12 @@
       a = makeAdder(2);
       assertEquals(4.0, ((Adder) a).add(1, 1));
       assertEquals(4.0, ((JsoAdder) a).add(1, 1));
+      assertEquals(5L, ((Adder) a).returnLong());
+      assertEquals(5L, ((JsoAdder) a).returnLong());
       assertTrue(a instanceof JsoAdder);
       assertFalse(a instanceof JavaAdder);
+      // NB: This is unexpected until you consider JSO$ as a roll-up type
+      assertTrue(a instanceof Tag);
       try {
         ((JavaAdder) a).add(1, 1);
         fail("Should have thrown CCE");
@@ -334,12 +433,21 @@
     }
   }
 
+  public void testStaticCallsToSubclasses() {
+    Object o = "String";
+    assertEquals(String.class, o.getClass());
+    o = JavaScriptObject.createObject();
+    assertTrue(o instanceof CallsStaticMethodInSubclass);
+    assertEquals("foo5", ((CallsStaticMethodInSubclass) o).call(2, 3));
+  }
+
   @SuppressWarnings("cast")
   public void testSubclassing() {
     {
       JsoDivider d = makeDivider(1);
       assertTrue(d instanceof Divider);
       assertTrue(d instanceof Multiplier);
+      assertTrue(d instanceof Tag);
       assertEquals(5, d.divide(10, 2));
       assertEquals(10, d.multiply(5, 2));
       assertEquals(10, ((JsoMultiplier) d).multiply(5, 2));
@@ -353,6 +461,7 @@
       assertTrue(d instanceof JsoMultiplier);
       assertFalse(d instanceof JavaDivider);
       assertFalse(d instanceof JavaMultiplier);
+      assertTrue(d instanceof Tag);
 
       assertEquals(5, ((Divider) d).divide(10, 2));
       assertEquals(10, ((Divider) d).multiply(5, 2));
@@ -367,6 +476,7 @@
       assertTrue(d instanceof JavaMultiplier);
       assertFalse(d instanceof JsoDivider);
       assertFalse(d instanceof JsoMultiplier);
+      assertTrue(d instanceof Tag);
 
       assertEquals(5, ((Divider) d).divide(10, 2));
       assertEquals(10, ((Divider) d).multiply(5, 2));