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 e326756..201394f 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,6 +15,8 @@
  */
 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;
@@ -93,6 +95,12 @@
   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) {
@@ -286,7 +294,7 @@
    * Determines if the class can be constructed using a simple <code>new</code>
    * operation. Specifically, the class must
    * <ul>
-   * <li>be a class rather than an interface, </li>
+   * <li>be a class rather than an interface,</li>
    * <li>have either no constructors or a parameterless constructor, and</li>
    * <li>be a top-level class or a static nested class.</li>
    * </ul>
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 424a3ca..cda9804 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
@@ -23,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -198,6 +199,8 @@
 
   private final Map<String, List<JWildcardType>> wildcardTypes = new HashMap<String, List<JWildcardType>>();
 
+  private final Set<JRealClassType> singleJsoImplTypes = new HashSet<JRealClassType>();
+
   public TypeOracle() {
     // Always create the default package.
     //
@@ -216,10 +219,10 @@
 
   /**
    * Finds a class or interface given its fully-qualified name.
-   *
-   * @param name fully-qualified class/interface name -  for nested
-   * classes, use its source name rather than its binary name (that is, use a
-   * "." rather than a "$")
+   * 
+   * @param name fully-qualified class/interface name - for nested classes, use
+   *          its source name rather than its binary name (that is, use a "."
+   *          rather than a "$")
    * 
    * @return <code>null</code> if the type is not found
    */
@@ -434,6 +437,14 @@
   }
 
   /**
+   * Returns an unmodifiable, live view of all interface types annotated with
+   * the SingleJsoImpl annotation.
+   */
+  public Set<JRealClassType> getSingleJsoImplTypes() {
+    return Collections.unmodifiableSet(singleJsoImplTypes);
+  }
+
+  /**
    * Finds a type given its fully qualified name. For nested classes, use its
    * source name rather than its binary name (that is, use a "." rather than a
    * "$").
@@ -605,6 +616,12 @@
     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);
   }
@@ -983,7 +1000,7 @@
       JRealClassType classType = iter.next();
       String fqcn = classType.getQualifiedSourceName();
       allTypes.remove(fqcn);
-
+      singleJsoImplTypes.remove(classType);
       JPackage pkg = classType.getPackage();
       if (pkg != null) {
         pkg.remove(classType);
diff --git a/dev/core/src/com/google/gwt/dev/javac/CompilationState.java b/dev/core/src/com/google/gwt/dev/javac/CompilationState.java
index 3ada290..5abfa26 100644
--- a/dev/core/src/com/google/gwt/dev/javac/CompilationState.java
+++ b/dev/core/src/com/google/gwt/dev/javac/CompilationState.java
@@ -82,6 +82,8 @@
    */
   private final JavaSourceOracle sourceOracle;
 
+  private CompilationUnitInvalidator.InvalidatorState invalidatorState = new CompilationUnitInvalidator.InvalidatorState();
+
   /**
    * Construct a new {@link CompilationState}.
    * 
@@ -170,6 +172,19 @@
     CompilationUnitInvalidator.invalidateUnitsWithInvalidRefs(TreeLogger.NULL,
         getCompilationUnits());
 
+    /*
+     * Only retain state for units marked as CHECKED; because CHECKED units
+     * won't be revalidated.
+     */
+    Set<CompilationUnit> toRetain = new HashSet<CompilationUnit>(exposedUnits);
+    for (Iterator<CompilationUnit> it = toRetain.iterator(); it.hasNext();) {
+      CompilationUnit unit = it.next();
+      if (unit.getState() != State.CHECKED) {
+        it.remove();
+      }
+    }
+    invalidatorState.retainAll(toRetain);
+
     jdtCompiler = new JdtCompiler();
     compile(logger, getCompilationUnits());
     mediator.refresh(logger, getCompilationUnits());
@@ -188,8 +203,8 @@
           logger, newUnits);
 
       // Check all units using our custom checks.
-      CompilationUnitInvalidator.validateCompilationUnits(newUnits,
-          jdtCompiler.getBinaryTypeNames());
+      CompilationUnitInvalidator.validateCompilationUnits(invalidatorState,
+          newUnits, jdtCompiler.getBinaryTypeNames());
 
       // More units may have errors now.
       anyErrors |= CompilationUnitInvalidator.invalidateUnitsWithErrors(logger,
diff --git a/dev/core/src/com/google/gwt/dev/javac/CompilationUnitInvalidator.java b/dev/core/src/com/google/gwt/dev/javac/CompilationUnitInvalidator.java
index 9ff8499..e5afa2a 100644
--- a/dev/core/src/com/google/gwt/dev/javac/CompilationUnitInvalidator.java
+++ b/dev/core/src/com/google/gwt/dev/javac/CompilationUnitInvalidator.java
@@ -24,6 +24,7 @@
 import org.eclipse.jdt.internal.compiler.CompilationResult;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
@@ -32,12 +33,23 @@
  * Helper class to invalidate units in a set based on errors or references to
  * other invalidate units.
  * 
- * TODO: {@link ClassFileReader#hasStructuralChanges(byte[])} could help us
- * optimize this process!
+ * TODO: ClassFileReader#hasStructuralChanges(byte[]) could help us optimize
+ * this process!
  */
 public class CompilationUnitInvalidator {
 
   /**
+   * Maintain cross-validation state.
+   */
+  public static class InvalidatorState {
+    private final JSORestrictionsChecker.CheckerState jsoState = new JSORestrictionsChecker.CheckerState();
+
+    public void retainAll(Collection<CompilationUnit> toRetain) {
+      jsoState.retainAll(toRetain);
+    }
+  }
+
+  /**
    * For all units containing one or more errors whose state is currently
    * {@link State#COMPILED}, each unit's error(s) will be logged to
    * <code>logger</code> and each unit's state will be set to
@@ -129,16 +141,17 @@
     } while (changed);
   }
 
-  public static void validateCompilationUnits(Set<CompilationUnit> units,
-      Set<String> validBinaryTypeNames) {
+  public static void validateCompilationUnits(InvalidatorState state,
+      Set<CompilationUnit> units, Set<String> validBinaryTypeNames) {
     for (CompilationUnit unit : units) {
       if (unit.getState() == State.COMPILED) {
         CompilationUnitDeclaration jdtCud = unit.getJdtCud();
-        JSORestrictionsChecker.check(jdtCud);
+        JSORestrictionsChecker.check(state.jsoState, jdtCud);
         LongFromJSNIChecker.check(jdtCud);
         BinaryTypeReferenceRestrictionsChecker.check(jdtCud,
             validBinaryTypeNames);
       }
     }
+    state.jsoState.finalCheck();
   }
 }
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 b6c7390..e1c3dff 100644
--- a/dev/core/src/com/google/gwt/dev/javac/JSORestrictionsChecker.java
+++ b/dev/core/src/com/google/gwt/dev/javac/JSORestrictionsChecker.java
@@ -15,11 +15,14 @@
  */
 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;
@@ -33,32 +36,263 @@
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 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;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
 import java.util.Stack;
 
 /**
  * Check a compilation unit for violations of
  * {@link com.google.gwt.core.client.JavaScriptObject JavaScriptObject} (JSO)
- * restrictions. The restrictions are:
+ * restrictions. The restrictions are summarized in
+ * <code>jsoRestrictions.html</code>.
  * 
- * <ul>
- * <li> All instance methods on JSO classes must be one of: final, private, or a
- * member of a final class.
- * <li> JSO classes cannot implement interfaces that define methods.
- * <li> No instance methods on JSO classes may override another method. (This
- * catches accidents where JSO itself did not finalize some method from its
- * superclass.)
- * <li> JSO classes cannot have instance fields.
- * <li> "new" operations cannot be used with JSO classes.
- * <li> Every JSO class must have precisely one constructor, and it must be
- * protected, empty, and no-argument.
- * <li> Nested JSO classes must be static.
- * </ul>
  * 
  * Any violations found are attached as errors on the
  * CompilationUnitDeclaration.
+ * 
+ * @see <a
+ *      href="http://code.google.com/p/google-web-toolkit/wiki/OverlayTypes">Overlay
+ *      types design doc</a>
+ * @see jsoRestrictions.html
  */
 public class JSORestrictionsChecker {
 
+  /**
+   * The order in which the checker will process types is undefined, so this
+   * type accumulates the information necessary for sanity-checking the JSO
+   * types.
+   */
+  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.
+     */
+    private final Map<TypeDeclaration, Set<String>> jsoImplsToInterfaces = new HashMap<TypeDeclaration, Set<String>>();
+
+    /**
+     * Used for error reporting.
+     */
+    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.
+       */
+      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);
+          } else {
+            /*
+             * Emit an error if the previously-defined type is neither a
+             * supertype nor subtype of the current type
+             */
+            TypeDeclaration previous = singleImplementations.get(intfName);
+            if (!(hasSupertypeNamed(node, previous.binding.compoundName) || hasSupertypeNamed(
+                previous, node.binding.compoundName))) {
+              String nodeName = CharOperation.toString(node.binding.compoundName);
+              String previousName = CharOperation.toString(previous.binding.compoundName);
+
+              // Provide consistent reporting, regardless of visitation order
+              if (nodeName.compareTo(previousName) < 0) {
+                String msg = errAlreadyImplemented(intfName, nodeName,
+                    previousName);
+                errorOn(node, nodesToCuds.get(node), msg);
+                errorOn(previous, nodesToCuds.get(previous), msg);
+              } else {
+                String msg = errAlreadyImplemented(intfName, previousName,
+                    nodeName);
+                errorOn(previous, nodesToCuds.get(previous), msg);
+                errorOn(node, nodesToCuds.get(node), msg);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    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;
+      }
+
+      // Build up a list of the types that should be retained
+      Set<String> retainedTypeNames = new HashSet<String>();
+
+      for (CompilationUnit u : units) {
+        for (CompiledClass c : u.getCompiledClasses()) {
+          // Can't rely on getJdtCud() because those are pruned
+          retainedTypeNames.add(c.getSourceName());
+        }
+      }
+
+      // Loop over all TypeDeclarations that we have
+      for (Iterator<TypeDeclaration> it = nodesToCuds.keySet().iterator(); it.hasNext();) {
+        TypeDeclaration decl = it.next();
+
+        // Remove the TypeDeclaration if it's not in the list of retained types
+        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,
+        TypeDeclaration key, String value) {
+      Set<String> set = map.get(key);
+      if (set == null) {
+        map.put(key, set = new HashSet<String>());
+      }
+      set.add(value);
+    }
+
+    private void addJsoInterface(TypeDeclaration jsoType,
+        CompilationUnitDeclaration cud, String interfaceName) {
+      nodesToCuds.put(jsoType, cud);
+      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) {
+        if (CharOperation.equals(b.compoundName, qType)) {
+          return true;
+        }
+        b = b.superclass();
+      }
+      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
       ClassFileConstants {
 
@@ -153,6 +387,61 @@
     }
 
     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;
       }
@@ -163,12 +452,17 @@
       ReferenceBinding[] interfaces = type.binding.superInterfaces();
       if (interfaces != null) {
         for (ReferenceBinding interf : interfaces) {
-          if (interf.methods() != null && interf.methods().length > 0) {
-            String intfName = String.copyValueOf(interf.shortReadableName());
-            errorOn(type, errInterfaceWithMethods(intfName));
+          if (interf.methods() == null) {
+            continue;
+          }
+
+          if (interf.methods().length > 0) {
+            String intfName = CharOperation.toString(interf.compoundName);
+            state.addJsoInterface(type, cud, intfName);
           }
         }
       }
+
       return true;
     }
 
@@ -188,32 +482,52 @@
   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
    * {@link org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration}.
    * 
    */
-  public static void check(CompilationUnitDeclaration cud) {
-    JSORestrictionsChecker checker = new JSORestrictionsChecker(cud);
+  public static void check(CheckerState state, CompilationUnitDeclaration cud) {
+    JSORestrictionsChecker checker = new JSORestrictionsChecker(state, cud);
     checker.check();
   }
 
-  static String errInterfaceWithMethods(String intfName) {
+  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
+        + ") is implemented by both (" + impl1 + ") and (" + impl2 + ")";
+  }
+
+  static String errInterfaceWithMethodsNoAnnotation(String intfName) {
     return "JavaScriptObject classes cannot implement interfaces with methods ("
-        + intfName + ")";
+        + 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(
+        "jsoRestrictions.html"));
   }
 
   private final CompilationUnitDeclaration cud;
 
-  private JSORestrictionsChecker(CompilationUnitDeclaration cud) {
+  private final CheckerState state;
+
+  private JSORestrictionsChecker(CheckerState state,
+      CompilationUnitDeclaration cud) {
     this.cud = cud;
+    this.state = state;
   }
 
   private void check() {
@@ -221,8 +535,7 @@
   }
 
   private void errorOn(ASTNode node, String error) {
-    GWTProblem.recordInCud(node, cud, error, new InstalledHelpInfo(
-        "jsoRestrictions.html"));
+    errorOn(node, cud, error);
   }
 
   private boolean isJsoSubclass(TypeBinding typeBinding) {
diff --git a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
index 1dd2a9a..ff003f3 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -174,7 +174,7 @@
       Pruner.exec(jprogram, false);
 
       // (7) Generate a JavaScript code DOM from the Java type declarations
-      jprogram.typeOracle.recomputeClinits();
+      jprogram.typeOracle.recomputeAfterOptimizations();
       final JavaToJavaScriptMap map = GenerateJavaScriptAST.exec(jprogram,
           jsProgram, options.getOutput());
 
@@ -420,7 +420,7 @@
       }
 
       // Recompute clinits each time, they can become empty.
-      jprogram.typeOracle.recomputeClinits();
+      jprogram.typeOracle.recomputeAfterOptimizations();
       didChange = false;
 
       // Remove unreferenced types, fields, methods, [params, locals]
@@ -457,7 +457,7 @@
        * Ensure that references to dead clinits are removed. Otherwise, the
        * application won't run reliably.
        */
-      jprogram.typeOracle.recomputeClinits();
+      jprogram.typeOracle.recomputeAfterOptimizations();
       DeadCodeElimination.exec(jprogram);
     }
   }
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 508b62b..c23140d 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
@@ -19,9 +19,11 @@
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -203,6 +205,8 @@
 
   private final Map<JClassType, Set<JInterfaceType>> couldImplementMap = new IdentityHashMap<JClassType, Set<JInterfaceType>>();
 
+  private final Set<JInterfaceType> dualImpl = new HashSet<JInterfaceType>();
+
   private final Set<JReferenceType> hasClinitSet = new HashSet<JReferenceType>();
 
   private final Map<JClassType, Set<JInterfaceType>> implementsMap = new IdentityHashMap<JClassType, Set<JInterfaceType>>();
@@ -213,6 +217,8 @@
 
   private JClassType javaLangObject = null;
 
+  private final Map<JInterfaceType, JClassType> jsoSingleImpls = new IdentityHashMap<JInterfaceType, JClassType>();
+
   private final JProgram program;
 
   private final Map<JClassType, Set<JClassType>> subClassMap = new IdentityHashMap<JClassType, Set<JClassType>>();
@@ -229,6 +235,29 @@
     this.program = program;
   }
 
+  /**
+   * Collect all supertypes and superinterfaces for a type.
+   */
+  public Set<JReferenceType> allAssignableFrom(JReferenceType type) {
+    Set<JReferenceType> toReturn = new HashSet<JReferenceType>();
+    List<JReferenceType> q = new LinkedList<JReferenceType>();
+    q.add(type);
+
+    while (!q.isEmpty()) {
+      JReferenceType t = q.remove(0);
+
+      if (toReturn.add(t)) {
+        if (t.extnds != null) {
+          q.add(t.extnds);
+        }
+
+        q.addAll(t.implments);
+      }
+    }
+
+    return toReturn;
+  }
+
   public boolean canTheoreticallyCast(JReferenceType type, JReferenceType qType) {
     JClassType jlo = program.getTypeJavaLangObject();
     if (type == qType || type == jlo) {
@@ -409,6 +438,8 @@
         computeVirtualUpRefs((JClassType) type);
       }
     }
+
+    computeSingleJsoImplData();
   }
 
   /**
@@ -418,6 +449,18 @@
     return getOrCreate(superInterfaceMap, type).contains(qType);
   }
 
+  public JMethod findConcreteImplementation(JMethod method,
+      JClassType concreteType) {
+    for (JMethod m : concreteType.methods) {
+      if (getAllOverrides(m).contains(method)) {
+        if (!m.isAbstract()) {
+          return m;
+        }
+      }
+    }
+    return null;
+  }
+
   public Set<JMethod> getAllOverrides(JMethod method) {
     return getAllOverrides(method, instantiatedTypes);
   }
@@ -457,6 +500,14 @@
     return results;
   }
 
+  public Set<JInterfaceType> getInterfacesWithJavaAndJsoImpls() {
+    return Collections.unmodifiableSet(dualImpl);
+  }
+
+  public Map<JInterfaceType, JClassType> getSingleJsoImpls() {
+    return Collections.unmodifiableMap(jsoSingleImpls);
+  }
+
   public boolean hasClinit(JReferenceType type) {
     return hasClinitSet.contains(type);
   }
@@ -487,13 +538,19 @@
     return getOrCreate(superClassMap, type).contains(qType);
   }
 
-  public void recomputeClinits() {
+  /**
+   * This method should be called after altering the types that are live in the
+   * associated JProgram.
+   */
+  public void recomputeAfterOptimizations() {
     hasClinitSet.clear();
     Set<JReferenceType> computed = new HashSet<JReferenceType>();
     for (int i = 0; i < program.getDeclaredTypes().size(); ++i) {
       JReferenceType type = program.getDeclaredTypes().get(i);
       computeHasClinit(type, computed);
     }
+
+    computeSingleJsoImplData();
   }
 
   public void setInstantiatedTypes(Set<JReferenceType> instantiatedTypes) {
@@ -591,6 +648,52 @@
     }
   }
 
+  private void computeSingleJsoImplData() {
+    dualImpl.clear();
+    jsoSingleImpls.clear();
+
+    for (JReferenceType type : program.getDeclaredTypes()) {
+      if (!program.isJavaScriptObject(type)) {
+        if (type instanceof JClassType) {
+          dualImpl.addAll(type.implments);
+        }
+        continue;
+      }
+
+      for (JReferenceType refType : allAssignableFrom(type)) {
+        if (!(refType instanceof JInterfaceType)) {
+          continue;
+        }
+        JInterfaceType intr = (JInterfaceType) refType;
+        if (intr.methods.size() <= 1) {
+          // Ignore tag interfaces
+          assert intr.methods.size() == 0
+              || intr.methods.get(0).getName().equals("$clinit");
+          continue;
+        }
+
+        if (jsoSingleImpls.containsKey(intr)) {
+          // See if we're looking at a supertype
+          JClassType alreadySeen = jsoSingleImpls.get(intr);
+
+          if (allAssignableFrom(alreadySeen).contains(type)) {
+            jsoSingleImpls.put(intr, (JClassType) type);
+          } else {
+            assert allAssignableFrom(type).contains(alreadySeen) : "Already recorded "
+                + alreadySeen.getName()
+                + " as single impl for "
+                + intr.getName()
+                + " while looking at unrelated type "
+                + type.getName();
+          }
+        } else {
+          jsoSingleImpls.put(intr, (JClassType) type);
+        }
+      }
+    }
+    dualImpl.retainAll(jsoSingleImpls.keySet());
+  }
+
   /**
    * WEIRD: Suppose class Foo declares void f(){} and unrelated interface I also
    * declares void f(). Then suppose Bar extends Foo implements I and doesn't
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/CastNormalizer.java b/dev/core/src/com/google/gwt/dev/jjs/impl/CastNormalizer.java
index b1f061c..7fd3680 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/CastNormalizer.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/CastNormalizer.java
@@ -27,6 +27,7 @@
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JInstanceOf;
 import com.google.gwt.dev.jjs.ast.JIntLiteral;
+import com.google.gwt.dev.jjs.ast.JInterfaceType;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JMethodCall;
 import com.google.gwt.dev.jjs.ast.JModVisitor;
@@ -412,6 +413,12 @@
    */
   private class ReplaceTypeChecksVisitor extends JModVisitor {
 
+    private final Set<JInterfaceType> dualImpls;
+
+    public ReplaceTypeChecksVisitor(JProgram program) {
+      dualImpls = program.typeOracle.getInterfacesWithJavaAndJsoImpls();
+    }
+
     @Override
     public void endVisit(JCastOperation x, Context ctx) {
       JExpression replaceExpr;
@@ -441,9 +448,19 @@
           // just remove the cast
           replaceExpr = curExpr;
         } else {
+
+          JMethod method;
           boolean isJsoCast = program.isJavaScriptObject(toType);
-          JMethod method = program.getIndexedMethod(isJsoCast
-              ? "Cast.dynamicCastJso" : "Cast.dynamicCast");
+          if (isJsoCast) {
+            // A cast to JSO
+            method = program.getIndexedMethod("Cast.dynamicCastJso");
+          } else if (dualImpls.contains(toType)) {
+            // A cast that may succeed when the object is a JSO
+            method = program.getIndexedMethod("Cast.dynamicCastAllowJso");
+          } else {
+            // A regular cast
+            method = program.getIndexedMethod("Cast.dynamicCast");
+          }
           // override the type of the called method with the target cast type
           JMethodCall call = new JMethodCall(program, x.getSourceInfo(), null,
               method, toType);
@@ -548,9 +565,15 @@
             x.getExpr(), nullLit);
         ctx.replaceMe(eq);
       } else {
+        JMethod method;
         boolean isJsoCast = program.isJavaScriptObject(toType);
-        JMethod method = program.getIndexedMethod(isJsoCast
-            ? "Cast.instanceOfJso" : "Cast.instanceOf");
+        if (isJsoCast) {
+          method = program.getIndexedMethod("Cast.instanceOfJso");
+        } else if (dualImpls.contains(toType)) {
+          method = program.getIndexedMethod("Cast.instanceOfOrJso");
+        } else {
+          method = program.getIndexedMethod("Cast.instanceOf");
+        }
         JMethodCall call = new JMethodCall(program, x.getSourceInfo(), null,
             method);
         call.getArgs().add(x.getExpr());
@@ -590,7 +613,7 @@
       assigner.computeTypeIds();
     }
     {
-      ReplaceTypeChecksVisitor replacer = new ReplaceTypeChecksVisitor();
+      ReplaceTypeChecksVisitor replacer = new ReplaceTypeChecksVisitor(program);
       replacer.accept(program);
     }
   }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
index afda14a..466eb00 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
@@ -2943,7 +2943,15 @@
           JMethod method, JsContext<JsExpression> ctx) {
         JReferenceType enclosingType = method.getEnclosingType();
         if (enclosingType != null) {
-          if (method.isStatic() && nameRef.getQualifier() != null) {
+          JClassType jsoImplType = program.typeOracle.getSingleJsoImpls().get(
+              enclosingType);
+          if (jsoImplType != null) {
+            reportJsniError(info, methodDecl, "Illegal reference to method '"
+                + method.getName() + "' in type '" + enclosingType.getName()
+                + "', which is implemented by an overlay type '"
+                + jsoImplType.getName() + "'. Use a stronger type in the JSNI "
+                + "identifier or a Java trampoline method.");
+          } else if (method.isStatic() && nameRef.getQualifier() != null) {
             reportJsniError(info, methodDecl,
                 "Cannot make a qualified reference to the static method "
                     + method.getName());
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/JavaScriptObjectNormalizer.java b/dev/core/src/com/google/gwt/dev/jjs/impl/JavaScriptObjectNormalizer.java
index 5fc544d..56fe60a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/JavaScriptObjectNormalizer.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/JavaScriptObjectNormalizer.java
@@ -15,31 +15,59 @@
  */
 package com.google.gwt.dev.jjs.impl;
 
+import com.google.gwt.dev.jjs.SourceInfo;
 import com.google.gwt.dev.jjs.ast.Context;
 import com.google.gwt.dev.jjs.ast.JArrayType;
 import com.google.gwt.dev.jjs.ast.JCastOperation;
 import com.google.gwt.dev.jjs.ast.JClassLiteral;
+import com.google.gwt.dev.jjs.ast.JClassType;
+import com.google.gwt.dev.jjs.ast.JConditional;
+import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JField;
 import com.google.gwt.dev.jjs.ast.JInstanceOf;
+import com.google.gwt.dev.jjs.ast.JInterfaceType;
 import com.google.gwt.dev.jjs.ast.JLocal;
+import com.google.gwt.dev.jjs.ast.JLocalRef;
 import com.google.gwt.dev.jjs.ast.JMethod;
+import com.google.gwt.dev.jjs.ast.JMethodBody;
+import com.google.gwt.dev.jjs.ast.JMethodCall;
 import com.google.gwt.dev.jjs.ast.JModVisitor;
 import com.google.gwt.dev.jjs.ast.JNewArray;
 import com.google.gwt.dev.jjs.ast.JParameter;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.ast.JReferenceType;
 import com.google.gwt.dev.jjs.ast.JType;
+import com.google.gwt.dev.jjs.ast.JVisitor;
+import com.google.gwt.dev.jjs.ast.js.JMultiExpression;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
 
 /**
  * Replace references to JSO subtypes with JSO itself.
  */
 public class JavaScriptObjectNormalizer {
+  private class Collector extends JVisitor {
 
+    @Override
+    public void endVisit(JClassType x, Context ctx) {
+      if (program.isJavaScriptObject(x)) {
+        for (JInterfaceType intr : x.implments) {
+          if (isTagInterface(intr) && !jsoType.implments.contains(intr)) {
+            jsoType.implments.add(intr);
+          }
+        }
+      }
+    }
+  }
   /**
    * Map types from JSO subtypes to JSO itself.
    */
   private class NormalizeVisitor extends JModVisitor {
 
+    private final Stack<JMethodBody> currentMethodBody = new Stack<JMethodBody>();
+
     @Override
     public void endVisit(JCastOperation x, Context ctx) {
       JType newType = translate(x.getCastType());
@@ -82,6 +110,71 @@
     }
 
     @Override
+    public void endVisit(JMethodBody x, Context ctx) {
+      if (currentMethodBody.pop() != x) {
+        throw new RuntimeException("Unexpected JMethodBody popped");
+      }
+    }
+
+    /**
+     * Polymorphic dispatches to interfaces implemented by both a JSO and a
+     * regular type require special dispatch handling. If the instance is not a
+     * Java-derived object, the method from the single JSO implementation will
+     * be invoked. Otherwise, a polymorphic dispatch to the Java-derived object
+     * is made.
+     */
+    @Override
+    public void endVisit(JMethodCall x, Context ctx) {
+      JType targetClass = x.getTarget().getEnclosingType();
+      if (jsoSingleImpls.containsKey(targetClass)) {
+
+        SourceInfo info = x.getSourceInfo().makeChild(
+            JavaScriptObjectNormalizer.class,
+            "Polymorphic invocation of SingleJsoImpl interface");
+
+        // Find the method in the JSO type
+        JMethod jsoMethod = findJsoMethod(x.getTarget());
+        assert jsoMethod != null;
+
+        if (dualImpl.contains(targetClass)) {
+          /*
+           * This is the special-case code to handle interfaces.
+           */
+          JMultiExpression multi = new JMultiExpression(program, info);
+          JExpression instance = maybeMakeTempAssignment(multi, x.getInstance());
+
+          // instance.method(arg, arg)
+          JMethodCall localCall = new JMethodCall(program, info, instance,
+              x.getTarget());
+          localCall.getArgs().addAll(x.getArgs());
+
+          // instance.jsoMethod(arg, arg)
+          JMethodCall jsoCall = new JMethodCall(program, info, instance,
+              jsoMethod);
+          jsoCall.getArgs().addAll(x.getArgs());
+
+          // Cast.isJavaScriptObject() ? instance.jsoMethod() :
+          // instance.method();
+          JConditional newExpr = makeIsJsoConditional(info, instance,
+              x.getType(), jsoCall, localCall);
+
+          multi.exprs.add(newExpr);
+          // We may only have the ternary operation if there's no side-effect
+          ctx.replaceMe(multi.exprs.size() == 1 ? multi.exprs.get(0) : multi);
+        } else {
+          /*
+           * ... otherwise, if there's only a JSO implementation, we'll just
+           * call that directly.
+           */
+          JMethodCall jsoCall = new JMethodCall(program, info, x.getInstance(),
+              jsoMethod);
+          jsoCall.getArgs().addAll(x.getArgs());
+          ctx.replaceMe(jsoCall);
+        }
+      }
+    }
+
+    @Override
     public void endVisit(JNewArray x, Context ctx) {
       x.setType(translate(x.getType()));
     }
@@ -91,14 +184,74 @@
       x.setType(translate(x.getType()));
     }
 
+    @Override
+    public boolean visit(JMethodBody x, Context ctx) {
+      currentMethodBody.push(x);
+      return true;
+    }
+
+    private JMethod findJsoMethod(JMethod interfaceMethod) {
+      JClassType jsoClass = jsoSingleImpls.get(interfaceMethod.getEnclosingType());
+      assert program.isJavaScriptObject(jsoClass);
+      assert jsoClass != null;
+
+      JMethod toReturn = program.typeOracle.findConcreteImplementation(
+          interfaceMethod, jsoClass);
+      assert toReturn != null;
+      assert !toReturn.isAbstract();
+      assert jsoClass.isFinal() || toReturn.isFinal();
+
+      return toReturn;
+    }
+
+    private JConditional makeIsJsoConditional(SourceInfo info,
+        JExpression instance, JType conditionalType, JExpression isJsoExpr,
+        JExpression notJsoExpr) {
+      // Cast.isJavaScriptObjectOrString(instance)
+      JMethod isJavaScriptObjectMethod = program.getIndexedMethod("Cast.isJavaScriptObjectOrString");
+      JMethodCall isJavaScriptObjectExpr = new JMethodCall(program, info, null,
+          isJavaScriptObjectMethod);
+      isJavaScriptObjectExpr.getArgs().add(instance);
+      return new JConditional(program, info, conditionalType,
+          isJavaScriptObjectExpr, isJsoExpr, notJsoExpr);
+    }
+
+    private JExpression maybeMakeTempAssignment(JMultiExpression multi,
+        JExpression instance) {
+      if (instance.hasSideEffects()) {
+        /*
+         * It may be necessary to save off the instance expression into a local
+         * variable if its evaluation would produce side-effects. The
+         * multi-expression is used for this purpose.
+         */
+        SourceInfo info = instance.getSourceInfo().makeChild(
+            JavaScriptObjectNormalizer.class,
+            "Temporary assignment for instance with side-effects");
+        JLocal local = program.createLocal(info,
+            "maybeJsoInvocation".toCharArray(), instance.getType(), true,
+            currentMethodBody.peek());
+        multi.exprs.add(program.createAssignmentStmt(info,
+            new JLocalRef(program, info, local), instance).getExpr());
+
+        instance = new JLocalRef(program, info, local);
+      }
+      return instance;
+    }
+
     private JType translate(JType type) {
       if (program.isJavaScriptObject(type)) {
         return program.getJavaScriptObject();
+
+      } else if (jsoSingleImpls.containsKey(type) && !dualImpl.contains(type)) {
+        // Narrow to JSO when possible
+        return program.getJavaScriptObject();
+
       } else if (type instanceof JArrayType) {
         JArrayType arrayType = (JArrayType) type;
-        if (program.isJavaScriptObject(arrayType.getLeafType())) {
-          return program.getTypeArray(program.getJavaScriptObject(),
-              arrayType.getDims());
+        JType leafType = arrayType.getLeafType();
+        JType replacement = translate(leafType);
+        if (leafType != replacement) {
+          return program.getTypeArray(replacement, arrayType.getDims());
         }
       }
       return type;
@@ -109,15 +262,53 @@
     new JavaScriptObjectNormalizer(program).execImpl();
   }
 
+  /**
+   * Interfaces implemented both by a JSO type and a regular Java type.
+   */
+  private final Set<JInterfaceType> dualImpl;
+
+  /**
+   * Maps SingleJsoImpl interfaces onto the single JSO implementation.
+   */
+  private final Map<JInterfaceType, JClassType> jsoSingleImpls;
+
+  private final JClassType jsoType;
+
   private final JProgram program;
 
   private JavaScriptObjectNormalizer(JProgram program) {
     this.program = program;
+    dualImpl = program.typeOracle.getInterfacesWithJavaAndJsoImpls();
+    jsoSingleImpls = program.typeOracle.getSingleJsoImpls();
+
+    jsoType = program.getJavaScriptObject();
+    jsoType.implments.addAll(dualImpl);
   }
 
   private void execImpl() {
+    new Collector().accept(program);
+
     NormalizeVisitor visitor = new NormalizeVisitor();
     visitor.accept(program);
   }
 
+  private boolean isTagInterface(JReferenceType intr) {
+    if (!(intr instanceof JInterfaceType)) {
+      return false;
+    }
+
+    if (intr.methods.size() > 1) {
+      assert intr.methods.size() == 0
+          || intr.methods.get(0).getName().equals("$clinit");
+      return false;
+    }
+
+    for (JInterfaceType t : intr.implments) {
+      if (!isTagInterface(t)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
 }
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 f40bfe9..95b748a 100644
--- a/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
+++ b/dev/core/src/com/google/gwt/dev/shell/CompilingClassLoader.java
@@ -18,9 +18,12 @@
 import com.google.gwt.core.client.GWTBridge;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.TreeLogger.Type;
 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.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;
@@ -50,13 +53,15 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.SortedMap;
 import java.util.Stack;
+import java.util.TreeMap;
 import java.util.regex.Pattern;
 
 /**
  * An isolated {@link ClassLoader} for running all user code. All user files are
- * compiled from source code byte a {@link ByteCodeCompiler}. After
- * compilation, some byte code rewriting is performed to support
+ * compiled from source code byte a {@link ByteCodeCompiler}. After compilation,
+ * some byte code rewriting is performed to support
  * <code>JavaScriptObject</code> and its subtypes.
  * 
  * TODO: we should refactor this class to move the getClassInfoByDispId,
@@ -131,6 +136,23 @@
       DispatchClassInfo dispClassInfo = getClassInfoFromClassName(className);
       if (dispClassInfo != null) {
         String memberName = parsed.memberSignature();
+
+        /*
+         * Disallow the use of JSNI references to SingleJsoImpl interface
+         * methods. This policy is due to web-mode dispatch implementation
+         * details; resolving the JSNI reference wouldn't be just be a name
+         * replacement, instead it would be necessary to significantly alter the
+         * semantics of the hand-written JS.
+         */
+        if (singleJsoImplTypes.contains(canonicalizeClassName(parsed.className()))) {
+          logger.log(TreeLogger.WARN,
+              "Invalid JSNI reference to SingleJsoImpl interface ("
+                  + parsed.className() + "); consider using a trampoline. "
+                  + "Expect subsequent failures.", new NoSuchFieldError(
+                  jsniMemberRef));
+          return -1;
+        }
+
         int memberId = dispClassInfo.getMemberId(memberName);
         if (memberId < 0) {
           logger.log(TreeLogger.WARN, "Member '" + memberName
@@ -352,9 +374,10 @@
   private static final Class<?>[] BRIDGE_CLASSES = new Class<?>[] {
       ShellJavaScriptHost.class, GWTBridge.class};
 
-  private static final boolean CLASS_DUMP = false;
+  private static final boolean CLASS_DUMP = Boolean.getBoolean("gwt.dev.classDump");
 
-  private static final String CLASS_DUMP_PATH = "rewritten-classes";
+  private static final String CLASS_DUMP_PATH = System.getProperty(
+      "gwt.dev.classDumpPath", "rewritten-classes");
 
   private static boolean emmaAvailable = false;
 
@@ -503,6 +526,7 @@
 
   private ShellJavaScriptHost shellJavaScriptHost;
 
+  private final Set<String> singleJsoImplTypes = new HashSet<String>();
   /**
    * Used by {@link #findClass(String)} to prevent reentrant JSNI injection.
    */
@@ -543,17 +567,28 @@
       jsoTypes.add(jsoType);
 
       Set<String> jsoTypeNames = new HashSet<String>();
-      Map<String, String> jsoSuperTypes = new HashMap<String, String>();
+      Map<String, List<String>> jsoSuperTypes = new HashMap<String, List<String>>();
       for (JClassType type : jsoTypes) {
+        List<String> types = new ArrayList<String>();
+        types.add(getBinaryName(type.getSuperclass()));
+        for (JClassType impl : type.getImplementedInterfaces()) {
+          types.add(getBinaryName(impl));
+        }
+
         String binaryName = getBinaryName(type);
         jsoTypeNames.add(binaryName);
-        jsoSuperTypes.put(binaryName, getBinaryName(type.getSuperclass()));
+        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);
+
       MyInstanceMethodOracle mapper = new MyInstanceMethodOracle(jsoTypes,
           typeOracle.getJavaLangObject());
       classRewriter = new HostedModeClassRewriter(jsoTypeNames, jsoSuperTypes,
-          mapper);
+          mangledNamesToImplementations, singleJsoImplTypes, mapper);
     } else {
       // If we couldn't find the JSO class, we don't need to do any rewrites.
       classRewriter = null;
@@ -598,8 +633,8 @@
    * was previously cached and has not been garbage collected.
    * 
    * @param javaObject the Object being wrapped
-   * @return the mapped wrapper, or <code>null</code> if the Java object
-   *         mapped or if the wrapper has been garbage collected
+   * @return the mapped wrapper, or <code>null</code> if the Java object mapped
+   *         or if the wrapper has been garbage collected
    */
   public Object getWrapperForObject(Object javaObject) {
     return weakJavaWrapperCache.get(javaObject);
@@ -727,6 +762,111 @@
     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.getSingleJsoImplTypes()) {
+      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 interited from interfaces A and B must be dispatched to their
+         * respective JSO implementations.
+         */
+        JClassType implementingType = findImplementingJsoType(m,
+            m.getEnclosingType().getSubtypes());
+
+        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();
+
+        /*
+         * 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 = m.getReturnType().getParameterizedQualifiedSourceName()
+            + " " + m.getName() + "$ (" + getBinaryName(implementingType);
+        for (JParameter p : m.getParameters()) {
+          decl += ",";
+          decl += p.getType().getParameterizedQualifiedSourceName();
+        }
+        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.
@@ -735,7 +875,11 @@
 
     if (classRewriter != null && classRewriter.isJsoIntf(className)) {
       // Generate a synthetic JSO interface class.
-      return classRewriter.writeJsoIntf(className);
+      byte[] newBytes = classRewriter.writeJsoIntf(className);
+      if (CLASS_DUMP) {
+        classDump(className, newBytes);
+      }
+      return newBytes;
     }
 
     // A JSO impl class needs the class bytes for the original class.
@@ -812,6 +956,35 @@
     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('.', '$');
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 393c364..7b88173 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
@@ -19,13 +19,17 @@
 import com.google.gwt.dev.asm.ClassVisitor;
 import com.google.gwt.dev.asm.ClassWriter;
 import com.google.gwt.dev.asm.Opcodes;
+import com.google.gwt.dev.asm.commons.Method;
 import com.google.gwt.dev.shell.JsValueGlue;
 
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
+import java.util.ListIterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.SortedMap;
 
 /**
  * This class performs any and all byte code rewriting needed to make hosted
@@ -87,7 +91,7 @@
   static final String JAVASCRIPTOBJECT_IMPL_DESC = JsValueGlue.JSO_IMPL_CLASS.replace(
       '.', '/');
 
-  static final String REFERENCE_FIELD = JsValueGlue.HOSTED_MODE_REFERENCE;;
+  static final String REFERENCE_FIELD = JsValueGlue.HOSTED_MODE_REFERENCE;
 
   static String addSyntheticThisParam(String owner, String methodDescriptor) {
     return "(L" + owner + ";" + methodDescriptor.substring(1);
@@ -112,13 +116,17 @@
   /**
    * Records the superclass of every JSO for generating empty JSO interfaces.
    */
-  private final Map<String, String> jsoSuperDescs;
+  private final Map<String, List<String>> jsoSuperDescs;
 
   /**
    * Maps methods to the class in which they are declared.
    */
   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.
@@ -128,21 +136,31 @@
    * @param mapper maps methods to the class in which they are declared
    */
   public HostedModeClassRewriter(Set<String> jsoSubtypes,
-      Map<String, String> jsoSuperTypes, InstanceMethodOracle mapper) {
+      Map<String, List<String>> jsoSuperTypes,
+      SortedMap<String, Method> mangledNamesToImplementations,
+      Set<String> singleJsoImplTypes, InstanceMethodOracle mapper) {
     Set<String> buildJsoIntfDescs = new HashSet<String>();
     Set<String> buildJsoImplDescs = new HashSet<String>();
-    Map<String, String> buildJsoSuperDescs = new HashMap<String, String>();
+    Map<String, List<String>> buildJsoSuperDescs = new HashMap<String, List<String>>();
     for (String jsoSubtype : jsoSubtypes) {
       String desc = toDescriptor(jsoSubtype);
       buildJsoIntfDescs.add(desc);
       buildJsoImplDescs.add(desc + "$");
-      String superType = jsoSuperTypes.get(jsoSubtype);
-      assert (superType != null);
-      buildJsoSuperDescs.put(desc, toDescriptor(superType));
+
+      List<String> superTypes = jsoSuperTypes.get(jsoSubtype);
+      assert (superTypes != null);
+      assert (superTypes.size() > 0);
+      for (ListIterator<String> i = superTypes.listIterator(); i.hasNext();) {
+        i.set(toDescriptor(i.next()));
+      }
+      buildJsoSuperDescs.put(desc, Collections.unmodifiableList(superTypes));
     }
+
     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.mapper = mapper;
   }
 
@@ -182,10 +200,14 @@
     // v = new CheckClassAdapter(v);
     // v = new TraceClassVisitor(v, new PrintWriter(System.out));
 
+    v = new RewriteSingleJsoImplDispatches(v, singleJsoImplTypes,
+        mangledNamesToImplementations);
+
     v = new RewriteRefsToJsoClasses(v, jsoIntfDescs, mapper);
 
     if (jsoImplDescs.contains(desc)) {
-      v = new WriteJsoImpl(v, jsoIntfDescs, mapper);
+      v = WriteJsoImpl.create(v, desc, jsoIntfDescs, mapper,
+          mangledNamesToImplementations);
     }
 
     v = new RewriteJsniMethods(v, anonymousClassMap);
@@ -202,8 +224,9 @@
     String desc = toDescriptor(className);
     assert (jsoIntfDescs.contains(desc));
     assert (jsoSuperDescs.containsKey(desc));
-    String superDesc = jsoSuperDescs.get(desc);
-    assert (superDesc != null);
+    List<String> superDescs = jsoSuperDescs.get(desc);
+    assert (superDescs != null);
+    assert (superDescs.size() > 0);
 
     // The ASM model is to chain a bunch of visitors together.
     ClassWriter writer = new ClassWriter(0);
@@ -213,10 +236,11 @@
     // v = new TraceClassVisitor(v, new PrintWriter(System.out));
 
     String[] interfaces;
-    if ("java/lang/Object".equals(superDesc)) {
+    // TODO(bov): something better than linear?
+    if (superDescs.contains("java/lang/Object")) {
       interfaces = null;
     } else {
-      interfaces = new String[] {superDesc};
+      interfaces = superDescs.toArray(new String[superDescs.size()]);
     }
     v.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_INTERFACE, desc,
         null, "java/lang/Object", interfaces);
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
new file mode 100644
index 0000000..adb6326
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
@@ -0,0 +1,232 @@
+/*
+ * 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.dev.shell.rewrite;
+
+import com.google.gwt.dev.asm.ClassAdapter;
+import com.google.gwt.dev.asm.ClassVisitor;
+import com.google.gwt.dev.asm.MethodAdapter;
+import com.google.gwt.dev.asm.MethodVisitor;
+import com.google.gwt.dev.asm.Opcodes;
+import com.google.gwt.dev.asm.Type;
+import com.google.gwt.dev.asm.commons.Method;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * Effects the renaming of {@code @SingleJsoImpl} methods from their original
+ * name to their mangled name. Let us call the original method an "unmangled
+ * method" and the new method a "mangled method". There are three steps in this
+ * process:
+ * <ol>
+ * <li>Within {@code @SingleJsoImpl} interfaces rename all unmangled methods to
+ * become mangled methods.</li>
+ * <li>Within non-JSO classes containing a concrete implementation of an
+ * unmangled method, add a mangled method which is implemented as a simple
+ * trampoline to the unmangled method. (We don't do this in JSO classes here
+ * because the one-and-only trampoline lives in JavaScriptObject$ and is emitted
+ * in {@link WriteJsoImpl}).
+ * <li>Update all call sites targeting unmangled methods to target mangled
+ * methods instead, provided the caller is binding to the interface rather than
+ * a concrete type.</li>
+ * </ol>
+ */
+public class RewriteSingleJsoImplDispatches extends ClassAdapter {
+  private class MyMethodVisitor extends MethodAdapter {
+    public MyMethodVisitor(MethodVisitor mv) {
+      super(mv);
+    }
+
+    /*
+     * Implements objective #3: updates call sites to unmangled methods.
+     */
+    @Override
+    public void visitMethodInsn(int opcode, String owner, String name,
+        String desc) {
+      if (singleJsoImplTypes.contains(owner)) {
+        name = owner.replace('/', '_') + "_" + name;
+      }
+
+      super.visitMethodInsn(opcode, owner, name, desc);
+    }
+  }
+
+  private String currentTypeName;
+  private final Set<String> implementedMethods = new HashSet<String>();
+  private final SortedMap<String, Method> mangledNamesToImplementations;
+  private final Set<String> singleJsoImplTypes;
+  private boolean inSingleJsoImplInterfaceType;
+
+  public RewriteSingleJsoImplDispatches(ClassVisitor v,
+      Set<String> singleJsoImplTypes,
+      SortedMap<String, Method> mangledNamesToImplementations) {
+    super(v);
+    this.singleJsoImplTypes = Collections.unmodifiableSet(singleJsoImplTypes);
+    this.mangledNamesToImplementations = Collections.unmodifiableSortedMap(mangledNamesToImplementations);
+  }
+
+  @Override
+  public void visit(int version, int access, String name, String signature,
+      String superName, String[] interfaces) {
+    assert currentTypeName == null;
+    super.visit(version, access, name, signature, superName, interfaces);
+
+    currentTypeName = name;
+    inSingleJsoImplInterfaceType = singleJsoImplTypes.contains(name);
+
+    /*
+     * Implements objective #2: non-JSO types that implement a SingleJsoImpl
+     * interface don't have their original instance methods altered. Instead, we
+     * add trampoline methods with mangled names that simply call over to the
+     * original methods.
+     */
+    if (interfaces != null && (access & Opcodes.ACC_INTERFACE) == 0) {
+      List<String> toStub = new ArrayList<String>();
+      Collections.addAll(toStub, interfaces);
+      toStub.retainAll(singleJsoImplTypes);
+
+      for (String stubIntr : toStub) {
+        writeTrampoline(stubIntr);
+      }
+    }
+  }
+
+  @Override
+  public void visitEnd() {
+    /*
+     * Add any missing methods that are defined by a super-interface, but that
+     * may be referenced via a more specific interface.
+     */
+    if (inSingleJsoImplInterfaceType) {
+      for (Map.Entry<String, Method> entry : toImplement(currentTypeName).entrySet()) {
+        writeEmptyMethod(entry.getKey(), entry.getValue());
+      }
+    }
+    super.visitEnd();
+  }
+
+  @Override
+  public MethodVisitor visitMethod(int access, String name, String desc,
+      String signature, String[] exceptions) {
+
+    /*
+     * Implements objective #2: Rename unmangled methods in a @SingleJsoImpl
+     * into mangled methods (except for clinit, LOL).
+     */
+    if (inSingleJsoImplInterfaceType && !"<clinit>".equals(name)) {
+      name = currentTypeName.replace('/', '_') + "_" + name;
+      implementedMethods.add(name);
+    }
+
+    MethodVisitor mv = super.visitMethod(access, name, desc, signature,
+        exceptions);
+    if (mv == null) {
+      return null;
+    }
+
+    return new MyMethodVisitor(mv);
+  }
+
+  /**
+   * Given a resource name of a class, find all mangled method names that must
+   * be implemented.
+   */
+  private SortedMap<String, Method> toImplement(String typeName) {
+    String name = typeName.replace('/', '_');
+    String prefix = name + "_";
+    String suffix = name + "`";
+    SortedMap<String, Method> toReturn = new TreeMap<String, Method>(
+        mangledNamesToImplementations.subMap(prefix, suffix));
+    toReturn.keySet().removeAll(implementedMethods);
+    return toReturn;
+  }
+
+  private void writeEmptyMethod(String mangledMethodName, Method method) {
+    assert method.getArgumentTypes().length > 0;
+    // Remove the first argument, which would be the implementing JSO type
+    String descriptor = "("
+        + method.getDescriptor().substring(
+            1 + method.getArgumentTypes()[0].getDescriptor().length());
+
+    // Create the stub method entry in the interface
+    MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC
+        | Opcodes.ACC_ABSTRACT, mangledMethodName, descriptor, null, null);
+    mv.visitEnd();
+  }
+
+  /**
+   * For regular Java objects that implement a SingleJsoImpl interface, write
+   * instance trampoline dispatchers for mangled method names to the
+   * implementing method.
+   */
+  private void writeTrampoline(String stubIntr) {
+    /*
+     * This is almost the same kind of trampoline as the ones generated in
+     * WriteJsoImpl, however there are enough small differences between the
+     * semantics of the dispatches that would make a common implementation far
+     * more awkward than the duplication of code.
+     */
+    for (Map.Entry<String, Method> entry : toImplement(stubIntr).entrySet()) {
+      String mangledName = entry.getKey();
+      Method method = entry.getValue();
+
+      String descriptor = "("
+          + method.getDescriptor().substring(
+              1 + method.getArgumentTypes()[0].getDescriptor().length());
+      String localName = method.getName().substring(0,
+          method.getName().length() - 1);
+      Method toCall = new Method(localName, descriptor);
+
+      // Must not be final
+      MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC
+          | Opcodes.ACC_SYNTHETIC, mangledName, descriptor, null, null);
+      if (mv != null) {
+        mv.visitCode();
+
+        /*
+         * It just so happens that the stack and local variable sizes are the
+         * same, but they're kept distinct to aid in clarity should the dispatch
+         * logic change.
+         * 
+         * These start at 1 because we need to load "this" onto the stack
+         */
+        int var = 1;
+        int size = 1;
+
+        // load this
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+
+        // then the rest of the arguments
+        for (Type t : toCall.getArgumentTypes()) {
+          size += t.getSize();
+          mv.visitVarInsn(t.getOpcode(Opcodes.ILOAD), var);
+          var += t.getSize();
+        }
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, currentTypeName,
+            toCall.getName(), toCall.getDescriptor());
+        mv.visitInsn(toCall.getReturnType().getOpcode(Opcodes.IRETURN));
+        mv.visitMaxs(size, var);
+        mv.visitEnd();
+      }
+    }
+  }
+}
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 54bced6..4f1e265 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
@@ -20,36 +20,201 @@
 import com.google.gwt.dev.asm.FieldVisitor;
 import com.google.gwt.dev.asm.MethodVisitor;
 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.InstanceMethodOracle;
 
 import java.util.ArrayList;
+import java.util.Map;
 import java.util.Set;
 
 /**
- * Writes the implementation class for a JSO type.
+ * Writes the implementation classes for JSO and its subtypes.
  * 
+ * Changes made by the base class:
  * <ol>
  * <li>The new type has the same name as the old type with a '$' appended.</li>
- * <li>The new type's superclass is Object.</li>
- * <li>All instance methods in the original type become static methods taking
- * an explicit <code>this</code> parameter. Such methods have the same stack
+ * <li>All instance methods in the original type become static methods taking an
+ * explicit <code>this</code> parameter. Such methods have the same stack
  * behavior as the original.</li>
- * <li>JavaScriptObject itself gets a new synthetic field to store the
- * underlying hosted mode reference.</li>
  * </ol>
  */
-class WriteJsoImpl extends ClassAdapter {
+abstract class WriteJsoImpl extends ClassAdapter {
 
   /**
-   * An unmodifiable set of descriptors containing <code>JavaScriptObject</code>
-   * and all subclasses.
+   * This type implements JavaScriptObject.
+   * 
+   * <ol>
+   * <li>JavaScriptObject itself gets a new synthetic field to store the
+   * underlying hosted mode reference.</li>
+   * <li>Instance methods are added so that JavaScriptObject implements all
+   * SingleJsoImpl interfaces.</li>
+   * </ol>
+   * 
    */
-  protected final Set<String> jsoDescriptors;
+  private static class ForJsoDollar extends WriteJsoImpl {
+    /**
+     * An unmodifiable set of descriptors containing
+     * <code>JavaScriptObject</code> and all subclasses.
+     */
+    private final Set<String> jsoDescriptors;
+    private final Map<String, Method> methodsToImplement;
+
+    public ForJsoDollar(ClassVisitor cv, Set<String> jsoDescriptors,
+        InstanceMethodOracle mapper, Map<String, Method> methodsToImplement) {
+      super(cv, mapper);
+      this.jsoDescriptors = jsoDescriptors;
+      this.methodsToImplement = methodsToImplement;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature,
+        String superName, String[] interfaces) {
+
+      ArrayList<String> jsoDescList = new ArrayList<String>();
+      jsoDescList.addAll(jsoDescriptors);
+      interfaces = jsoDescList.toArray(new String[jsoDescList.size()]);
+
+      super.visit(version, access, name, signature, superName, interfaces);
+
+      /*
+       * Generate the synthetic "hostedModeReferece" field to contain the
+       * underlying real reference to the JavaScript object.
+       */
+      FieldVisitor fv = visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC,
+          HostedModeClassRewriter.REFERENCE_FIELD, "Ljava/lang/Object;", null,
+          null);
+      if (fv != null) {
+        fv.visitEnd();
+      }
+
+      // Implement the trampoline methods
+      for (Map.Entry<String, Method> entry : methodsToImplement.entrySet()) {
+        writeTrampoline(entry.getKey(), entry.getValue());
+      }
+    }
+
+    /**
+     * JSO methods are implemented as flyweight style, with the instance being
+     * passed as the first parameter. This loop create instance methods on JSO$
+     * for all of the mangled SingleJsoImpl interface method names. These
+     * instance methods simply turn around and call the static-dispatch methods.
+     * 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);
+     * }
+     * </pre>
+     * 
+     * @param mangledName {@code com_google_gwt_sample_hello_client_Interface_a}
+     * @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.
+       */
+      assert implementingMethod.getArgumentTypes().length > 0;
+      String localDescriptor = "("
+          + implementingMethod.getDescriptor().substring(
+              1 + implementingMethod.getArgumentTypes()[0].getDescriptor().length());
+      Method localMethod = new Method(mangledName, localDescriptor);
+
+      /*
+       * We also use the first argument to know which type to statically
+       * dispatch to.
+       */
+      Type implementingType = Type.getType("L"
+          + implementingMethod.getArgumentTypes()[0].getInternalName() + "$;");
+
+      // Maybe create the method. This is marked final as a sanity check
+      MethodVisitor mv = visitMethodNoRewrite(Opcodes.ACC_PUBLIC
+          | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, localMethod.getName(),
+          localMethod.getDescriptor(), null, null);
+
+      if (mv != null) {
+        mv.visitCode();
+
+        /*
+         * It just so happens that the stack and local variable sizes are the
+         * same, but they're kept distinct to aid in clarity should the dispatch
+         * logic change.
+         */
+        int var = 0;
+        int size = 0;
+
+        for (Type t : implementingMethod.getArgumentTypes()) {
+          size += t.getSize();
+          mv.visitVarInsn(t.getOpcode(Opcodes.ILOAD), var);
+          var += t.getSize();
+        }
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC,
+            implementingType.getInternalName(), implementingMethod.getName(),
+            implementingMethod.getDescriptor());
+        mv.visitInsn(localMethod.getReturnType().getOpcode(Opcodes.IRETURN));
+        mv.visitMaxs(size, var);
+        mv.visitEnd();
+      }
+    }
+  }
+
+  /**
+   * This type is used to implement subtypes of JSO.
+   * 
+   * <ol>
+   * <li>The new type's superclass is mangled by adding $.</li>
+   * <li>Constructors are deleted.</li>
+   * </ol>
+   */
+  private static class ForJsoInterface extends WriteJsoImpl {
+    public ForJsoInterface(ClassVisitor cv, InstanceMethodOracle mapper) {
+      super(cv, mapper);
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature,
+        String superName, String[] interfaces) {
+      // Reference the old superclass's implementation class.
+      superName += '$';
+      interfaces = null;
+
+      super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc,
+        String signature, String[] exceptions) {
+      boolean isCtor = isCtor(name);
+      if (isCtor) {
+        // Don't copy over constructors except for JavaScriptObject itself.
+        return null;
+      }
+      return super.visitMethod(access, name, desc, signature, exceptions);
+    }
+  }
+
+  /**
+   * Creates a ClassVisitor to implement a JavaScriptObject subtype. This will
+   * select between a simple implementation for user-defined JSO subtypes and
+   * the complex implementation for implementing JavaScriptObject$.
+   */
+  public static ClassVisitor create(ClassVisitor cv, String classDescriptor,
+      Set<String> jsoDescriptors, InstanceMethodOracle mapper,
+      Map<String, Method> methodsToImplement) {
+
+    if (classDescriptor.equals(HostedModeClassRewriter.JAVASCRIPTOBJECT_IMPL_DESC)) {
+      return new ForJsoDollar(cv, jsoDescriptors, mapper, methodsToImplement);
+    } else {
+      return new ForJsoInterface(cv, mapper);
+    }
+  }
 
   /**
    * Maps methods to the class in which they are declared.
    */
-  private InstanceMethodOracle mapper;
+  private final InstanceMethodOracle mapper;
 
   /**
    * The original name of the class being visited.
@@ -64,67 +229,60 @@
    *          <code>JavaScriptObject</code> and all subclasses
    * @param mapper maps methods to the class in which they are declared
    */
-  public WriteJsoImpl(ClassVisitor cv, Set<String> jsoDescriptors,
-      InstanceMethodOracle mapper) {
+  private WriteJsoImpl(ClassVisitor cv, InstanceMethodOracle mapper) {
     super(cv);
-    this.jsoDescriptors = jsoDescriptors;
     this.mapper = mapper;
   }
 
+  /**
+   * Records the original name and resets access opcodes.
+   */
   @Override
   public void visit(int version, int access, String name, String signature,
       String superName, String[] interfaces) {
     originalName = name;
-
-    // JavaScriptObject$ must implement all JSO interface types.
-    if (isJavaScriptObject()) {
-      ArrayList<String> jsoDescList = new ArrayList<String>();
-      jsoDescList.addAll(jsoDescriptors);
-      interfaces = jsoDescList.toArray(new String[jsoDescList.size()]);
-    } else {
-      // Reference the old superclass's implementation class.
-      superName += '$';
-      interfaces = null;
-    }
-
-    super.visit(version, access, name + '$', signature, superName, interfaces);
-
-    if (isJavaScriptObject()) {
-      FieldVisitor fv = visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC,
-          HostedModeClassRewriter.REFERENCE_FIELD, "Ljava/lang/Object;", null,
-          null);
-      if (fv != null) {
-        fv.visitEnd();
-      }
-    }
+    super.visit(version, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC
+        | Opcodes.ACC_SYNTHETIC, name + '$', signature, superName, interfaces);
   }
 
+  /**
+   * Mangle all instance methods declared in JavaScriptObject types.
+   */
   @Override
   public MethodVisitor visitMethod(int access, String name, String desc,
       String signature, String[] exceptions) {
-    boolean isCtor = "<init>".equals(name);
-    if (!isJavaScriptObject() && isCtor) {
-      // Don't copy over constructors except for JavaScriptObject itself.
-      return null;
-    }
+    boolean isCtor = isCtor(name);
     if (!isCtor && !isStatic(access) && !isObjectMethod(name + desc)) {
       access |= Opcodes.ACC_STATIC;
-      desc = HostedModeClassRewriter.addSyntheticThisParam(originalName, desc);
+      desc = HostedModeClassRewriter.addSyntheticThisParam(getOriginalName(),
+          desc);
       name = name + "$";
     }
     return super.visitMethod(access, name, desc, signature, exceptions);
   }
 
-  private boolean isJavaScriptObject() {
-    return originalName.equals(HostedModeClassRewriter.JAVASCRIPTOBJECT_DESC);
+  protected String getOriginalName() {
+    return originalName;
   }
 
-  private boolean isObjectMethod(String signature) {
-    return "java/lang/Object".equals(mapper.findOriginalDeclaringClass(originalName,
-        signature));
+  protected boolean isCtor(String name) {
+    return "<init>".equals(name);
   }
 
-  private boolean isStatic(int access) {
+  protected boolean isObjectMethod(String signature) {
+    return "java/lang/Object".equals(mapper.findOriginalDeclaringClass(
+        originalName, signature));
+  }
+
+  protected boolean isStatic(int access) {
     return (access & Opcodes.ACC_STATIC) != 0;
   }
+
+  /**
+   * Allows access to an unmodified visitMethod call.
+   */
+  protected MethodVisitor visitMethodNoRewrite(int access, String name,
+      String desc, String signature, String[] exceptions) {
+    return super.visitMethod(access, name, desc, signature, exceptions);
+  }
 }
diff --git a/dev/core/super/com/google/gwt/core/client/SingleJsoImpl.java b/dev/core/super/com/google/gwt/core/client/SingleJsoImpl.java
new file mode 100644
index 0000000..bbc2a55
--- /dev/null
+++ b/dev/core/super/com/google/gwt/core/client/SingleJsoImpl.java
@@ -0,0 +1,38 @@
+/*
+ * 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/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Cast.java b/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Cast.java
index 6e4e378..6310a50 100644
--- a/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Cast.java
+++ b/dev/core/super/com/google/gwt/dev/jjs/intrinsic/com/google/gwt/lang/Cast.java
@@ -52,6 +52,17 @@
   }
 
   /**
+   * Allow a dynamic cast to an object, always succeeding if it's a JSO.
+   */
+  static Object dynamicCastAllowJso(Object src, int dstId) {
+    if (src != null && !isJavaScriptObject(src) &&
+        !canCastUnsafe(Util.getTypeId(src), dstId)) {
+      throw new ClassCastException();
+    }
+    return src;
+  }
+  
+  /**
    * Allow a cast to JSO only if there's no type ID.
    */
   static Object dynamicCastJso(Object src) {
@@ -72,6 +83,15 @@
     return (src != null) && isJavaScriptObject(src);
   }
 
+  /**
+   * Returns true if the object is a Java object and can be cast, or if it's a
+   * non-null JSO.
+   */
+  static boolean instanceOfOrJso(Object src, int dstId) {
+    return (src != null) &&
+        (isJavaScriptObject(src) || canCast(Util.getTypeId(src), dstId));
+  }
+
   static boolean isJavaObject(Object src) {
     return Util.getTypeMarker(src) == getNullMethod() || Util.getTypeId(src) == 2;
   }
@@ -80,6 +100,10 @@
     return Util.getTypeMarker(src) != getNullMethod() && Util.getTypeId(src) != 2;
   }
 
+  static boolean isJavaScriptObjectOrString(Object src) {
+    return Util.getTypeMarker(src) != getNullMethod();
+  }
+
   /**
    * Uses the not operator to perform a null-check; do NOT use on anything that
    * could be a String.
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 b8eb521..836dca5 100644
--- a/dev/core/test/com/google/gwt/dev/javac/JSORestrictionsTest.java
+++ b/dev/core/test/com/google/gwt/dev/javac/JSORestrictionsTest.java
@@ -20,8 +20,34 @@
 
 import junit.framework.TestCase;
 
+/**
+ * Tests the JSORestrictionsChecker.
+ */
 public class JSORestrictionsTest extends TestCase {
 
+  static {
+    // Mac -XstartOnFirstThread bug
+    if (Thread.currentThread().getContextClassLoader() == null) {
+      Thread.currentThread().setContextClassLoader(
+          JSORestrictionsTest.class.getClassLoader());
+    }
+  }
+
+  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");
@@ -33,6 +59,33 @@
     shouldGenerateNoError(code);
   }
 
+  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");
+    goodCode.append("  }\n");
+    goodCode.append("  static class Squeaker extends JavaScriptObject implements Squeaks {\n");
+    goodCode.append("    public final void squeak() { }\n");
+    goodCode.append("    protected Squeaker() { }\n");
+    goodCode.append("  }\n");
+    goodCode.append("  static class Squeaker2 extends Squeaker implements Squeaks, Squeaks2 {\n");
+    goodCode.append("    public final void squeak2() { }\n");
+    goodCode.append("    protected Squeaker2() { }\n");
+    goodCode.append("  }\n");
+    goodCode.append("}\n");
+
+    shouldGenerateNoError(goodCode);
+  }
+
   public void testInstanceField() {
     StringBuffer buggyCode = new StringBuffer();
     buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
@@ -56,6 +109,32 @@
         + JSORestrictionsChecker.ERR_CONSTRUCTOR_WITH_PARAMETERS);
   }
 
+  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");
+    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("  static class Squeaker2 extends JavaScriptObject implements Squeaks {\n");
+    buggyCode.append("    public final void squeak() { }\n");
+    buggyCode.append("    protected Squeaker2() { }\n");
+    buggyCode.append("  }\n");
+    buggyCode.append("}\n");
+
+    shouldGenerateError(buggyCode, "Line 8: "
+        + JSORestrictionsChecker.errAlreadyImplemented("Buggy$Squeaks",
+            "Buggy$Squeaker", "Buggy$Squeaker2"), "Line 12: "
+        + JSORestrictionsChecker.errAlreadyImplemented("Buggy$Squeaks",
+            "Buggy$Squeaker", "Buggy$Squeaker2"));
+  }
+
   public void testNew() {
     StringBuffer buggyCode = new StringBuffer();
     buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
@@ -70,18 +149,65 @@
         + JSORestrictionsChecker.ERR_NEW_JSO);
   }
 
-  public void testNoConstructor() {
-    StringBuffer buggyCode = new StringBuffer();
-    buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
-    buggyCode.append("public class Buggy extends JavaScriptObject {\n");
-    buggyCode.append("}\n");
+  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");
 
-    // The public constructor is implicit.
-    shouldGenerateError(buggyCode, "Line 2: "
-        + JSORestrictionsChecker.ERR_NONPROTECTED_CONSTRUCTOR);
+    shouldGenerateNoError(goodCode);
   }
 
-  public void testNoInterfaces() {
+  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");
@@ -94,8 +220,46 @@
     buggyCode.append("  }\n");
     buggyCode.append("}\n");
 
-    shouldGenerateError(buggyCode, "Line 6: "
-        + JSORestrictionsChecker.errInterfaceWithMethods("Buggy.Squeaks"));
+    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");
+    buggyCode.append("public class Buggy extends JavaScriptObject {\n");
+    buggyCode.append("}\n");
+
+    // The public constructor is implicit.
+    shouldGenerateError(buggyCode, "Line 2: "
+        + JSORestrictionsChecker.ERR_NONPROTECTED_CONSTRUCTOR);
   }
 
   public void testNonEmptyConstructor() {
@@ -121,6 +285,32 @@
         + JSORestrictionsChecker.ERR_INSTANCE_METHOD_NONFINAL);
   }
 
+  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");
+    goodCode.append("  static interface Squeaks2 extends Squeaks {\n");
+    goodCode.append("    public void squeak2();\n");
+    goodCode.append("  }\n");
+    goodCode.append("  static class JsoSqueaker extends JavaScriptObject implements Squeaks {\n");
+    goodCode.append("    protected JsoSqueaker() {}\n");
+    goodCode.append("    public final void squeak() {}\n");
+    goodCode.append("  }\n");
+    goodCode.append("  static class JavaSqueaker2 implements Squeaks2 {\n");
+    goodCode.append("    protected JavaSqueaker2() {}\n");
+    goodCode.append("    public void squeak() {}\n");
+    goodCode.append("    public void squeak2() {}\n");
+    goodCode.append("  }\n");
+    goodCode.append("}\n");
+
+    shouldGenerateNoError(goodCode);
+  }
+
   public void testNonProtectedConstructor() {
     StringBuffer buggyCode = new StringBuffer();
     buggyCode.append("import com.google.gwt.core.client.JavaScriptObject;\n");
@@ -168,18 +358,48 @@
     shouldGenerateNoError(code);
   }
 
+  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");
+    goodCode.append("  static class Squeaker3 extends JavaScriptObject implements Tag {\n");
+    goodCode.append("    public final void squeak() { }\n");
+    goodCode.append("    protected Squeaker3() { }\n");
+    goodCode.append("  }\n");
+    goodCode.append("  static class Squeaker4 extends JavaScriptObject implements Tag2 {\n");
+    goodCode.append("    public final void squeak() { }\n");
+    goodCode.append("    protected Squeaker4() { }\n");
+    goodCode.append("  }\n");
+    goodCode.append("  static class Squeaker5 extends JavaScriptObject implements IntrExtendsTag {\n");
+    goodCode.append("    public final void intrExtendsTag() { }\n");
+    goodCode.append("    protected Squeaker5() { }\n");
+    goodCode.append("  }\n");
+    goodCode.append("}\n");
+
+    shouldGenerateNoError(goodCode);
+  }
+
   /**
    * Test that when compiling buggyCode, the TypeOracleBuilder emits
    * expectedError somewhere in its output. The code should define a class named
    * Buggy.
    */
   private void shouldGenerateError(CharSequence buggyCode,
-      final String expectedError) {
+      String... expectedErrors) {
     UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
     builder.setLowestLogLevel(TreeLogger.ERROR);
-    if (expectedError != null) {
+    if (expectedErrors != null) {
       builder.expectError("Errors in \'/mock/Buggy\'", null);
-      builder.expectError(expectedError, null);
+      for (String e : expectedErrors) {
+        builder.expectError(e, null);
+      }
     }
     UnitTestTreeLogger logger = builder.createLogger();
     CompilationUnit buggyCup = new MockCompilationUnit("Buggy",
@@ -189,6 +409,6 @@
   }
 
   private void shouldGenerateNoError(StringBuffer buggyCode) {
-    shouldGenerateError(buggyCode, null);
+    shouldGenerateError(buggyCode, (String[]) null);
   }
 }
diff --git a/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java b/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java
index 48c34b3..20468c7 100644
--- a/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java
+++ b/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java
@@ -55,7 +55,8 @@
         validBinaryTypeNames.add(compiledClass.getBinaryName());
       }
     }
-    CompilationUnitInvalidator.validateCompilationUnits(units,
+    CompilationUnitInvalidator.InvalidatorState state = new CompilationUnitInvalidator.InvalidatorState();
+    CompilationUnitInvalidator.validateCompilationUnits(state, units,
         validBinaryTypeNames);
     if (CompilationUnitInvalidator.invalidateUnitsWithErrors(logger, units)) {
       CompilationUnitInvalidator.invalidateUnitsWithInvalidRefs(logger, units);
diff --git a/distro-source/core/src/doc/helpInfo/jsoRestrictions.html b/distro-source/core/src/doc/helpInfo/jsoRestrictions.html
index aed2d81..0354e56 100644
--- a/distro-source/core/src/doc/helpInfo/jsoRestrictions.html
+++ b/distro-source/core/src/doc/helpInfo/jsoRestrictions.html
@@ -4,50 +4,58 @@
 <title>Restrictions on subclasses of JavaScriptObject</title>
 </head>
 <body>
-
-<p>Subclasses of JavaScriptObject  represent a view of a JavaScript object
-from Java.  Such classes must conform to a number of restrictions so
-that the compiler can implement them.  This page lists those restrictions.
-
-<p>In the following,  "JSO class" means any subclass of
-<code>JavaScriptObject</code>.  Rationales are written <em>like
-this</em>.
-
+<p>Subclasses of JavaScriptObject represent a view of a JavaScript
+object from Java. Such classes must conform to a number of restrictions
+so that the compiler can implement them. This page lists those
+restrictions.</p>
+<p>In the following, "JSO class" means any subclass of <code>JavaScriptObject</code>.
+Rationales are written <em>like this</em>.</p>
 <ol>
-
-  <li>  All instance methods on JSO classes must be one of: 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> JSO classes cannot implement interfaces that define
-  methods. <em>This prevents virtual calls that would arise by
-  upcasting to the interface and then calling through the interface.
-  The programmer should instead use a wrapper, for example using
-  <code>Comparator</code> instead of implementing
-  <code>Comparable</code>.</em>
-
-  <li> No instance methods on JSO classes may override another
-  method. <em>This catches accidents where JSO itself did not finalize
-  some method from its superclass.</em>
-
-  <li> JSO classes cannot have instance fields.  <em>The fields would
-  have no place to live in web mode.  Programmers should instead make
-  an explicit wrapper class and put the fields there.</em>
-
-  <li> Nested JSO classes must be static.  <em>The implicit
-  <code>this</code> fields of a non-static inner class has the same
-  problems as an explicit field.</em>
-
-  <li> "new" operations cannot be used with JSO classes.  <em>This
-  avoids ever being able to try to instantiate JSO objects using the
-  new keyword. New JSO instances can only come from JSNI, as in
-  previous versions of GWT.</em>
-
-  <li> Every JSO class must have precisely one constructor, and it must
-  be protected, empty, and no-argument.
-
+  <li>All instance methods on JSO classes must be one of:
+  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>
+  <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>
+    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>
+  </ol>
+  </li>
+  <li>No instance methods on JSO classes may override another
+  method. <em>This catches accidents where JSO itself did not
+  finalize some method from its superclass.</em></li>
+  <li>JSO classes cannot have instance fields. <em>The fields
+  would have no place to live in web mode. Programmers should instead
+  make an explicit wrapper class and put the fields there.</em></li>
+  <li>Nested JSO classes must be static. <em>The implicit <code>this</code>
+  fields of a non-static inner class has the same problems as an
+  explicit field.</em></li>
+  <li>"new" operations cannot be used with JSO classes. <em>This
+  avoids ever being able to try to instantiate JSO objects using the new
+  keyword. New JSO instances can only come from JSNI, as in previous
+  versions of GWT.</em></li>
+  <li>JSNI methods may not refer to instance methods defined within
+  a <code>JavaScriptObject</code>.</li>
+  <li>Every JSO class must have precisely one constructor, and it
+  must be protected, empty, and no-argument.</li>
 </ol>
-
 </body>
 </html>
diff --git a/user/src/com/google/gwt/junit/rebind/GWTRunnerGenerator.java b/user/src/com/google/gwt/junit/rebind/GWTRunnerGenerator.java
index b4ed8af..7058dd5 100644
--- a/user/src/com/google/gwt/junit/rebind/GWTRunnerGenerator.java
+++ b/user/src/com/google/gwt/junit/rebind/GWTRunnerGenerator.java
@@ -166,6 +166,8 @@
     sw.println();
     sw.println("protected final GWTTestCase createNewTestCase(String testClass) {");
     sw.indent();
+    sw.println("try {");
+    sw.indent();
     boolean isFirst = true;
     for (String className : testClasses) {
       if (isFirst) {
@@ -178,6 +180,11 @@
       sw.indentln("return GWT.create(" + className + ".class);");
       sw.println("}");
     }
+    sw.outdent();
+    sw.println("} catch (Throwable t) {");
+    sw.indentln("// Crash in a useful manner");
+    sw.indentln("GWT.log(\"Unable to construct TestCase: \" + testClass, t);");
+    sw.println("}");
     sw.println("return null;");
     sw.outdent();
     sw.println("}");
diff --git a/user/test/com/google/gwt/dev/jjs/CompilerSuite.java b/user/test/com/google/gwt/dev/jjs/CompilerSuite.java
index fea18ff..9f0c603 100644
--- a/user/test/com/google/gwt/dev/jjs/CompilerSuite.java
+++ b/user/test/com/google/gwt/dev/jjs/CompilerSuite.java
@@ -40,6 +40,7 @@
 import com.google.gwt.dev.jjs.test.NativeLongTest;
 import com.google.gwt.dev.jjs.test.ObjectIdentityTest;
 import com.google.gwt.dev.jjs.test.RunAsyncTest;
+import com.google.gwt.dev.jjs.test.SingleJsoImplTest;
 import com.google.gwt.dev.jjs.test.UnstableGeneratorTest;
 import com.google.gwt.dev.jjs.test.VarargsTest;
 import com.google.gwt.junit.tools.GWTTestSuite;
@@ -80,6 +81,7 @@
     suite.addTestSuite(NativeLongTest.class);
     suite.addTestSuite(ObjectIdentityTest.class);
     suite.addTestSuite(RunAsyncTest.class);
+    suite.addTestSuite(SingleJsoImplTest.class);
     suite.addTestSuite(UnstableGeneratorTest.class);
     suite.addTestSuite(VarargsTest.class);
     // $JUnit-END$
diff --git a/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java b/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java
new file mode 100644
index 0000000..0914f54
--- /dev/null
+++ b/user/test/com/google/gwt/dev/jjs/test/SingleJsoImplTest.java
@@ -0,0 +1,406 @@
+/*
+ * 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.dev.jjs.test;
+
+import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.core.client.SingleJsoImpl;
+import com.google.gwt.junit.client.GWTTestCase;
+
+import java.io.IOException;
+
+/**
+ * Ensures that JavaScriptObjects may implement interfaces with methods.
+ */
+public class SingleJsoImplTest extends GWTTestCase {
+
+  @SingleJsoImpl
+  interface Adder {
+    int ADDER_CONST = 6;
+
+    /**
+     * @see SameDescriptors#SAME_NAME
+     */
+    String SAME_NAME = "Same Name";
+
+    Object DIFFERENT_OBJECT = new Object();
+    Object SAME_OBJECT = new Object();
+    Object SAME_OBJECT2 = SAME_OBJECT;
+
+    /*
+     * NB: Picking a mix of double and int because doubles have size 2 on the
+     * stack, so this ensures that we're handling that case correctly.
+     */
+    double add(double a, int b);
+  }
+
+  @SingleJsoImpl
+  interface Divider extends Multiplier {
+    int divide(int a, int b);
+  }
+
+  static class JavaAdder implements Adder {
+    public double add(double a, int b) {
+      return a + b;
+    }
+  }
+
+  /**
+   * The extra declaration of implementing Multiplier should still be legal.
+   */
+  static class JavaDivider extends JavaMultiplier implements Divider,
+      Multiplier {
+    public int divide(int a, int b) {
+      return a / b;
+    }
+  }
+
+  /**
+   * Ensure that SingleJsoImpl interfaces can be extended and implemented by
+   * regular Java types.
+   */
+  static class JavaLog2 extends JavaDivider implements Log2 {
+    public double log2(int a) {
+      return Math.log(a) / Math.log(2);
+    }
+  }
+
+  static class JavaMultiplier implements Multiplier {
+    public int multiply(int a, int b) {
+      return a * b;
+    }
+  }
+
+  static class JsoAdder extends JavaScriptObject implements Adder {
+    protected JsoAdder() {
+    }
+
+    public final native double add(double a, int b) /*-{return this.offset * (a + b);}-*/;
+  }
+
+  static class JsoDivider extends JsoMultiplier implements Divider {
+    protected JsoDivider() {
+    }
+
+    public final native int divide(int a, int b) /*-{return this.offset * a / b;}-*/;
+  }
+
+  static class JsoMultiplier extends JavaScriptObject implements Multiplier {
+    protected JsoMultiplier() {
+    }
+
+    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 {
+    protected JsoRandom() {
+    }
+
+    public int add(int a, int b) {
+      return -1;
+    }
+
+    public int divide(int a, int b) {
+      return -1;
+    }
+
+    public int multiply(int a, int b) {
+      return -1;
+    }
+
+    String b() {
+      return "b";
+    }
+  }
+
+  final static class JsoSimple extends JavaScriptObject implements Simple {
+    protected JsoSimple() {
+    }
+
+    public String a() {
+      return "a";
+    }
+
+    public String ex() throws IOException {
+      throw new IOException();
+    }
+
+    public String rte() {
+      throw new IllegalArgumentException();
+    }
+  }
+
+  /**
+   * Ensure that SingleJsoImpl interfaces can be extended and implemented by
+   * regular Java types.
+   */
+  interface Log2 extends Divider {
+    double log2(int a);
+  }
+
+  @SingleJsoImpl
+  interface Multiplier {
+    int multiply(int a, int b);
+  }
+
+  /**
+   * This interface makes sure that types with identical method signatures will
+   * still dispatch correctly.
+   */
+  @SingleJsoImpl
+  interface SameDescriptors {
+    int SAME_NAME = 6;
+
+    int add(int a, int b);
+
+    int divide(int a, int b);
+
+    int multiply(int a, int b);
+  }
+
+  @SingleJsoImpl
+  interface Simple {
+    String a();
+
+    String ex() throws IOException;
+
+    String rte();
+  }
+
+  /**
+   * Ensure that a Java-only implementation of a SingleJsoImpl interface works.
+   */
+  static class SimpleOnlyJava implements SimpleOnlyJavaInterface {
+    public String simpleOnlyJava() {
+      return "simpleOnlyJava";
+    }
+  }
+
+  @SingleJsoImpl
+  interface SimpleOnlyJavaInterface {
+    String simpleOnlyJava();
+  }
+
+  private static native JsoAdder makeAdder(int offset) /*-{return {offset:offset};}-*/;
+
+  private static native JsoDivider makeDivider(int offset) /*-{return {offset:offset};}-*/;
+
+  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 testDualCase() {
+    // Direct dispatch
+    {
+      JavaAdder java = new JavaAdder();
+      assertEquals(2.0, java.add(1, 1));
+
+      JsoAdder jso = makeAdder(2);
+      assertEquals(4.0, jso.add(1, 1));
+    }
+
+    // Just check dispatch via the interface
+    {
+      Adder a = new JavaAdder();
+      assertEquals(2.0, a.add(1, 1));
+
+      a = makeAdder(2);
+      assertEquals(4.0, a.add(1, 1));
+    }
+
+    // Check casting
+    {
+      Object a = new JavaAdder();
+      assertEquals(2.0, ((Adder) a).add(1, 1));
+      assertEquals(2.0, ((JavaAdder) a).add(1, 1));
+      assertTrue(a instanceof JavaAdder);
+      assertFalse(a instanceof JsoAdder);
+      try {
+        ((JsoAdder) a).add(1, 1);
+        fail("Should have thrown CCE");
+      } catch (ClassCastException e) {
+        // OK
+      }
+
+      a = makeAdder(2);
+      assertEquals(4.0, ((Adder) a).add(1, 1));
+      assertEquals(4.0, ((JsoAdder) a).add(1, 1));
+      assertTrue(a instanceof JsoAdder);
+      assertFalse(a instanceof JavaAdder);
+      try {
+        ((JavaAdder) a).add(1, 1);
+        fail("Should have thrown CCE");
+      } catch (ClassCastException e) {
+        // OK
+      }
+    }
+  }
+
+  public void testFields() {
+    assertEquals(6, Adder.ADDER_CONST);
+    assertEquals("Same Name", Adder.SAME_NAME);
+    assertEquals(6, SameDescriptors.SAME_NAME);
+    assertSame(Adder.SAME_OBJECT, Adder.SAME_OBJECT2);
+    assertNotSame(Adder.DIFFERENT_OBJECT, Adder.SAME_OBJECT);
+  }
+
+  @SuppressWarnings("cast")
+  public void testSimpleCase() {
+    {
+      JsoSimple asJso = makeSimple();
+      assertTrue(asJso instanceof Object);
+      assertTrue(asJso instanceof Simple);
+      assertEquals("a", asJso.a());
+      try {
+        asJso.ex();
+        fail("Should have thrown IOException");
+      } catch (IOException e) {
+        // OK
+      }
+      try {
+        asJso.rte();
+        fail("Should have thrown IllegalArgumentException");
+      } catch (IllegalArgumentException e) {
+        // OK
+      }
+    }
+
+    {
+      Simple asSimple = makeSimple();
+      assertTrue(asSimple instanceof Object);
+      assertTrue(asSimple instanceof JavaScriptObject);
+      assertTrue(asSimple instanceof JsoSimple);
+      assertEquals("a", asSimple.a());
+      assertEquals("a", ((JsoSimple) asSimple).a());
+      try {
+        asSimple.ex();
+        fail("Should have thrown IOException");
+      } catch (IOException e) {
+        // OK
+      }
+      try {
+        asSimple.rte();
+        fail("Should have thrown IllegalArgumentException");
+      } catch (IllegalArgumentException e) {
+        // OK
+      }
+    }
+
+    {
+      Object asObject = "Defeat type-tightening";
+      assertTrue(asObject instanceof String);
+
+      asObject = makeSimple();
+      assertTrue(asObject instanceof Object);
+      assertTrue(asObject instanceof JavaScriptObject);
+      assertTrue(asObject instanceof JsoSimple);
+      assertTrue(asObject instanceof Simple);
+      assertEquals("a", ((Simple) asObject).a());
+      assertEquals("a", ((JsoSimple) asObject).a());
+
+      // Test a cross-cast that's normally not allowed by the type system
+      assertTrue(asObject instanceof JsoRandom);
+      assertEquals("b", ((JsoRandom) asObject).b());
+      assertEquals(-1, ((JsoRandom) asObject).add(1, 1));
+    }
+
+    {
+      Object o = "Defeat type-tightening";
+      assertTrue(o instanceof String);
+      o = new SimpleOnlyJava();
+      assertTrue(o instanceof SimpleOnlyJavaInterface);
+      assertEquals("simpleOnlyJava", ((SimpleOnlyJava) o).simpleOnlyJava());
+    }
+  }
+
+  @SuppressWarnings("cast")
+  public void testSubclassing() {
+    {
+      JsoDivider d = makeDivider(1);
+      assertTrue(d instanceof Divider);
+      assertTrue(d instanceof Multiplier);
+      assertEquals(5, d.divide(10, 2));
+      assertEquals(10, d.multiply(5, 2));
+      assertEquals(10, ((JsoMultiplier) d).multiply(5, 2));
+    }
+
+    {
+      Object d = makeDivider(1);
+      assertTrue(d instanceof Divider);
+      assertTrue(d instanceof Multiplier);
+      assertTrue(d instanceof JsoDivider);
+      assertTrue(d instanceof JsoMultiplier);
+      assertFalse(d instanceof JavaDivider);
+      assertFalse(d instanceof JavaMultiplier);
+
+      assertEquals(5, ((Divider) d).divide(10, 2));
+      assertEquals(10, ((Divider) d).multiply(5, 2));
+      assertEquals(10, ((Multiplier) d).multiply(5, 2));
+      assertEquals(5, ((JsoDivider) d).divide(10, 2));
+      assertEquals(10, ((JsoMultiplier) d).multiply(5, 2));
+
+      d = new JavaDivider();
+      assertTrue(d instanceof Divider);
+      assertTrue(d instanceof Multiplier);
+      assertTrue(d instanceof JavaDivider);
+      assertTrue(d instanceof JavaMultiplier);
+      assertFalse(d instanceof JsoDivider);
+      assertFalse(d instanceof JsoMultiplier);
+
+      assertEquals(5, ((Divider) d).divide(10, 2));
+      assertEquals(10, ((Divider) d).multiply(5, 2));
+      assertEquals(10, ((Multiplier) d).multiply(5, 2));
+      assertEquals(5, ((JavaDivider) d).divide(10, 2));
+      assertEquals(10, ((JavaMultiplier) d).multiply(5, 2));
+    }
+
+    {
+      Object m = makeMultiplier(1);
+      // This only works because JSO$ implements every SingleJsoImpl interface
+      assertTrue(m instanceof Divider);
+      assertEquals(2, ((Divider) m).divide(10, 5));
+
+      m = new JavaMultiplier();
+      // but this should fail, since there's proper type information
+      assertFalse(m instanceof Divider);
+      try {
+        assertEquals(2, ((Divider) m).divide(10, 5));
+        fail("Should have thrown CCE");
+      } catch (ClassCastException e) {
+        // OK
+      }
+    }
+
+    {
+      Object l2 = "Prevent type-tightening";
+      assertTrue(l2 instanceof String);
+
+      l2 = new JavaLog2();
+      assertTrue(l2 instanceof Log2);
+      assertTrue(l2 instanceof Multiplier);
+      assertTrue(l2 instanceof Divider);
+      assertEquals(4.0, ((Log2) l2).log2(16));
+    }
+  }
+}