Fixes a bug in JavaScriptObject support in DevMode that prevents dispatching
through an interface to a method defined in a super-interface. The change
also includes a new test to serve as a regression test.

Review at http://gwt-code-reviews.appspot.com/1287801
Review by: bobv, scottb, cromwellian


git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@9542 8db76d5a-ed1c-0410-87a9-c151d255dfc7

dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java

diff --git a/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java b/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
index e676987..215dcc6 100644
--- a/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
+++ b/dev/core/src/com/google/gwt/dev/shell/rewrite/RewriteSingleJsoImplDispatches.java
@@ -34,8 +34,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.SortedMap;
-import java.util.TreeMap;
+import java.util.SortedSet;
+import java.util.TreeSet;
 
 /**
  * Effects the renaming of {@code @SingleJsoImpl} methods from their original
@@ -181,9 +181,9 @@
      * may be referenced via a more specific interface.
      */
     if (inSingleJsoImplInterfaceType) {
-      for (Map.Entry<String, List<Method>> entry : toImplement(currentTypeName).entrySet()) {
-        for (Method method : entry.getValue()) {
-          writeEmptyMethod(entry.getKey(), method);
+      for (String mangledName : toImplement(currentTypeName)) {
+        for (Method method : jsoData.getDeclarations(mangledName)) {
+          writeEmptyMethod(mangledName, method);
         }
       }
     }
@@ -265,29 +265,23 @@
    * Given a resource name of a class, find all mangled method names that must
    * be implemented.
    */
-  private SortedMap<String, List<Method>> toImplement(String typeName) {
+  private SortedSet<String> toImplement(String typeName) {
     String name = typeName.replace('/', '_');
     String prefix = name + "_";
     String suffix = name + "`";
-    SortedMap<String, List<Method>> toReturn = new TreeMap<String, List<Method>>();
-
+    SortedSet<String> toReturn = new TreeSet<String>();
     for (String mangledName : jsoData.getMangledNames().subSet(prefix, suffix)) {
-      toReturn.put(mangledName, jsoData.getImplementations(mangledName));
+      if (!implementedMethods.contains(mangledName)) {
+        toReturn.add(mangledName);
+      }
     }
-    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
+  
+  private void writeEmptyMethod(String mangledMethodName, Method declMethod) {
     MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC
-        | Opcodes.ACC_ABSTRACT, mangledMethodName, descriptor, null, null);
+        | Opcodes.ACC_ABSTRACT, mangledMethodName, declMethod.getDescriptor(),
+        null, null);
     mv.visitEnd();
   }
 
@@ -303,20 +297,14 @@
      * semantics of the dispatches that would make a common implementation far
      * more awkward than the duplication of code.
      */
-    for (Map.Entry<String, List<Method>> entry : toImplement(stubIntr).entrySet()) {
-      for (Method method : entry.getValue()) {
-        String mangledName = entry.getKey();
+    for (String mangledName : toImplement(stubIntr)) {
+      for (Method method : jsoData.getDeclarations(mangledName)) {
 
-        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);
+        Method toCall = new Method(method.getName(), method.getDescriptor());
 
         // Must not be final
         MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC
-            | Opcodes.ACC_SYNTHETIC, mangledName, descriptor, null, null);
+            | Opcodes.ACC_SYNTHETIC, mangledName, method.getDescriptor(), null, null);
         if (mv != null) {
           mv.visitCode();
 

user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java

diff --git a/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java b/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java
index c0f93d4..03d38ac 100644
--- a/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/singlejso/TypeHierarchyTest.java
@@ -123,6 +123,45 @@
   static class Wide {
   }
 
+  private interface Element extends Node {
+  }
+
+  private static class JvmNode implements Node {
+    @Override
+    public JvmNode appendChild(Node node) {
+      return (JvmNode)node;
+    }
+  }
+  
+  private final static class JvmElement extends JvmNode implements Element {
+    static Element create() {
+      return new JvmElement();
+    }
+  }
+  
+  private final static class JsElement extends JsNode implements Element {
+    static Element create() {
+      return (Element) JavaScriptObject.createObject();
+    }
+
+    protected JsElement() {
+    }
+  }
+
+  private static class JsNode extends JavaScriptObject implements Node {
+    @Override
+    public final native JsNode appendChild(Node node) /*-{
+      return node;
+    }-*/;
+
+    protected JsNode() {
+    }
+  }
+
+  private interface Node {
+    Node appendChild(Node node);
+  }
+
   @Override
   public String getModuleName() {
     return "com.google.gwt.dev.jjs.CompilerSuite";
@@ -149,7 +188,7 @@
     IA b2 = new B2();
     assertEquals("B2", b2.whoAmI());
   }
-
+  
   public void testCase3() {
     IA a = A.create();
     assertEquals("A", a.whoAmI());
@@ -171,6 +210,17 @@
     IDiamond2B d2b = DiamondImpl.create();
     assertEquals(42, d2b.size());
   }
+  
+  /**
+   * Tests that dispatches through a hierarchy of interfaces works properly.
+   */
+  public void testInterfaceHierarchyDispatch() {
+    Element jsElement = JsElement.create();
+    assertEquals(jsElement, jsElement.appendChild(jsElement));
+    
+    Element jvmElement = JvmElement.create();
+    assertEquals(jvmElement, jvmElement.appendChild(jvmElement));
+  }
 
   public void testVirtualOverrides() {
     Arrayish array = PlainJsoWithInterface.create();