diff --git a/dev/core/src/com/google/gwt/dev/javac/JsInteropUtil.java b/dev/core/src/com/google/gwt/dev/javac/JsInteropUtil.java
index cf653ef..0a0087e 100644
--- a/dev/core/src/com/google/gwt/dev/javac/JsInteropUtil.java
+++ b/dev/core/src/com/google/gwt/dev/javac/JsInteropUtil.java
@@ -42,6 +42,7 @@
   public static final String JSPROPERTY_CLASS = "com.google.gwt.core.client.js.JsProperty";
   public static final String JSTYPE_CLASS = "com.google.gwt.core.client.js.JsType";
   public static final String UNUSABLE_BY_JS = "unusable-by-js";
+  public static final String INVALID_JSNAME = "<invalid>";
 
   public static void maybeSetJsInteropProperties(JDeclaredType type, Annotation... annotations) {
     AnnotationBinding jsType = JdtUtil.getAnnotation(annotations, JSTYPE_CLASS);
@@ -172,7 +173,7 @@
       String jsName = Introspector.decapitalize(methodName.substring(2));
       method.setJsPropertyInfo(jsName, JsPropertyAccessorType.GETTER);
     } else {
-      method.setJsPropertyInfo("<invalid>", JsPropertyAccessorType.UNDEFINED);
+      method.setJsPropertyInfo(INVALID_JSNAME, JsPropertyAccessorType.UNDEFINED);
     }
   }
 
diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JMethod.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JMethod.java
index 6f3dc0f..13ae108 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JMethod.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JMethod.java
@@ -16,6 +16,7 @@
 package com.google.gwt.dev.jjs.ast;
 
 import com.google.gwt.dev.common.InliningMode;
+import com.google.gwt.dev.javac.JsInteropUtil;
 import com.google.gwt.dev.jjs.InternalCompilerException;
 import com.google.gwt.dev.jjs.SourceInfo;
 import com.google.gwt.dev.jjs.SourceOrigin;
@@ -161,7 +162,7 @@
         continue;
       }
       if (jsMemberName != null && !jsMemberName.equals(jsMemberOverrideName)) {
-        return null;
+        return JsInteropUtil.INVALID_JSNAME;
       }
       jsMemberName = jsMemberOverrideName;
     }
@@ -223,7 +224,7 @@
     return JsPropertyAccessorType.NONE;
   }
 
-  public boolean isJsPropertyAccessor() {
+  private boolean isJsPropertyAccessor() {
     return jsPropertyType != JsPropertyAccessorType.NONE;
   }
 
@@ -561,7 +562,8 @@
   }
 
   /**
-   * Returns the transitive closure of all the methods this method overrides.
+   * Returns the transitive closure of all the methods this method overrides; this set is ordered
+   * from most specific to least specific, where class methods appear before interface methods.
    */
   public Set<JMethod> getOverriddenMethods() {
     return overriddenMethods;
@@ -569,7 +571,9 @@
 
   /**
    * Returns the transitive closure of all the methods that override this method; caveat this
-   * list is only complete in monolithic compiles and should not be used in incremental compiles..
+   * list is only complete in monolithic compiles and should not be used in incremental compiles.
+   * The returned set is ordered in such a way that most specific overriding methods appear after
+   * less specific ones.
    */
   public Set<JMethod> getOverridingMethods() {
     return overridingMethods;
diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JType.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JType.java
index aa8d20a..82a40f5 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JType.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JType.java
@@ -132,7 +132,7 @@
    * "class Name { .. }"), i.e. it is a name that does not include enclosing type names nor package.
    */
   public String[] getCompoundName() {
-    return new String[] { shortName };
+    return new String[] { getShortName() };
   }
 
   /**
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 5b7a3e1..ddaec08 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
@@ -868,6 +868,12 @@
     return subclassesByClass.containsEntry(type.getName(), possibleSubType.getName());
   }
 
+  public boolean isSubType(JDeclaredType type, JDeclaredType possibleSubType) {
+    return subclassesByClass.containsEntry(type.getName(), possibleSubType.getName())
+        || classesByImplementingInterface.containsEntry(type.getName(), possibleSubType.getName())
+        || subInterfacesByInterface.containsEntry(type.getName(), possibleSubType.getName());
+  }
+
   public Iterable<String> getSubTypeNames(String typeName) {
     return Iterables.concat(classesByImplementingInterface.get(typeName),
         subclassesByClass.get(typeName), subInterfacesByInterface.get(typeName));
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java
index 1f0bd91..f8c997a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaScriptAST.java
@@ -1472,6 +1472,7 @@
         for (JField field : type.getFields()) {
           if (field.isJsInteropEntryPoint()) {
             if (!field.isFinal()) {
+              // TODO(rluble): move waring to JsInteropRestrictionChecker.
               logger.log(
                   TreeLogger.Type.WARN,
                   "Exporting effectively non-final field "
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/JavaAstVerifier.java b/dev/core/src/com/google/gwt/dev/jjs/impl/JavaAstVerifier.java
index 4d0d6c9..7537714 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/JavaAstVerifier.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/JavaAstVerifier.java
@@ -30,9 +30,11 @@
 import com.google.gwt.dev.jjs.ast.js.JsniFieldRef;
 import com.google.gwt.dev.jjs.ast.js.JsniMethodRef;
 import com.google.gwt.thirdparty.guava.common.collect.HashMultimap;
+import com.google.gwt.thirdparty.guava.common.collect.Lists;
 import com.google.gwt.thirdparty.guava.common.collect.Multimap;
 import com.google.gwt.thirdparty.guava.common.collect.Sets;
 
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -48,8 +50,10 @@
   private Set<String> seenTypeNames = Sets.newHashSet();
   private Multimap<JDeclaredType, String> seenMethodsByType = HashMultimap.create();
   private Multimap<JDeclaredType, String> seenFieldsByType = HashMultimap.create();
+  private JProgram program;
 
   JavaAstVerifier(JProgram program) {
+    this.program = program;
     for (JDeclaredType type :program.getModuleDeclaredTypes()) {
       membersByType.putAll(type, type.getMethods());
       membersByType.putAll(type, type.getFields());
@@ -65,6 +69,40 @@
     }
   }
 
+  public static void assertCorrectOverriddenOrder(JProgram program, JMethod method) {
+    // The order of in the overriden set is most specific to least.
+    List<JMethod> seenMethods = Lists.newArrayList(method);
+    JMethod lastMethod = method;
+    for (JMethod overriden : method.getOverriddenMethods()) {
+      for (JMethod seenMethod : seenMethods) {
+        assert !program.typeOracle.isSubType(
+            seenMethod.getEnclosingType(), overriden.getEnclosingType())
+            : "Superclass method '" + seenMethod.getQualifiedName()
+                + "' appeared before subclass method '" + overriden.getQualifiedName()
+                + "' in '" + method.getQualifiedName() + "' overridden list";
+      }
+      assert overriden.getEnclosingType() instanceof JInterfaceType
+          || lastMethod.getEnclosingType() instanceof JClassType
+          : "Class method '" + overriden.getQualifiedName()
+          + "' appeared before after interface method '" + lastMethod.getQualifiedName()
+          + "' in '" + method.getQualifiedName() + "' overridden list";
+    }
+  }
+
+  public static void assertCorrectOverridingOrder(JProgram program, JMethod method) {
+    // The order of in the overriden set is most specific to least.
+    List<JMethod> seenMethods = Lists.newArrayList(method);
+    for (JMethod overriden : method.getOverridingMethods()) {
+      for (JMethod seenMethod : seenMethods) {
+        assert !program.typeOracle.isSubType(
+            overriden.getEnclosingType(), seenMethod.getEnclosingType())
+            : "Subclass method '" + seenMethod.getQualifiedName()
+                + "' appeared before superclass method '" + overriden.getQualifiedName()
+                + "' in '" + method.getQualifiedName() + "' overriding list";
+      }
+    }
+  }
+
   @Override
   public void endVisit(JClassType x, Context ctx) {
     assertNotSeenBefore(x);
@@ -97,6 +135,8 @@
     assert !seenMethodsByType.containsEntry(enclosingType, methodSignature) :
         "Method " + x + " is duplicated.";
     seenMethodsByType.put(enclosingType, methodSignature);
+    assertCorrectOverriddenOrder(program, x);
+    assertCorrectOverridingOrder(program, x);
   }
 
   @Override
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java b/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java
index 003f7fb..34b776f 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/JjsUtils.java
@@ -20,6 +20,7 @@
 import com.google.gwt.dev.jjs.SourceOrigin;
 import com.google.gwt.dev.jjs.ast.HasName;
 import com.google.gwt.dev.jjs.ast.HasType;
+import com.google.gwt.dev.jjs.ast.JArrayType;
 import com.google.gwt.dev.jjs.ast.JBinaryOperation;
 import com.google.gwt.dev.jjs.ast.JBinaryOperator;
 import com.google.gwt.dev.jjs.ast.JBlock;
@@ -30,6 +31,7 @@
 import com.google.gwt.dev.jjs.ast.JDeclaredType;
 import com.google.gwt.dev.jjs.ast.JDoubleLiteral;
 import com.google.gwt.dev.jjs.ast.JExpression;
+import com.google.gwt.dev.jjs.ast.JField;
 import com.google.gwt.dev.jjs.ast.JFloatLiteral;
 import com.google.gwt.dev.jjs.ast.JIntLiteral;
 import com.google.gwt.dev.jjs.ast.JInterfaceType;
@@ -66,6 +68,7 @@
 import com.google.gwt.thirdparty.guava.common.base.Joiner;
 import com.google.gwt.thirdparty.guava.common.base.Predicate;
 import com.google.gwt.thirdparty.guava.common.base.Predicates;
+import com.google.gwt.thirdparty.guava.common.base.Strings;
 import com.google.gwt.thirdparty.guava.common.collect.Collections2;
 import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
 import com.google.gwt.thirdparty.guava.common.collect.ImmutableMap;
@@ -297,6 +300,48 @@
     return createEmptyMethodFromExample(type, superTypeMethod, true);
   }
 
+  /**
+   * Returns a description for a type suitable for reporting errors to the users.
+   */
+  public static String getReadableDescription(JType type) {
+    if (type instanceof JArrayType) {
+      JArrayType arrayType = (JArrayType) type;
+      return getReadableDescription(arrayType.getLeafType()) + Strings.repeat("[]",
+          arrayType.getDims());
+    }
+    return Joiner.on(".").join(type.getCompoundName());
+  }
+
+  /**
+   * Returns a description for a member suitable for reporting errors to the users.
+   */
+  public static String getReadableDescription(JMember member) {
+    if (member instanceof JField) {
+      return String.format("%s %s.%s",
+          getReadableDescription(member.getType()),
+          getReadableDescription(member.getEnclosingType()),
+          member.getName());
+    }
+
+    JMethod method = (JMethod) member;
+    String printableDescription = "";
+    if (!method.isConstructor()) {
+      printableDescription += getReadableDescription(method.getType()) + " ";
+    }
+    printableDescription += String.format("%s.%s(%s)",
+        getReadableDescription(method.getEnclosingType()),
+        method.getName(),
+        Joiner.on(", ").join(
+            Iterables.transform(method.getOriginalParamTypes(), new Function<JType, String>() {
+                  @Override
+                  public String apply(JType type) {
+                    return getReadableDescription(type);
+                  }
+                }
+            )));
+    return printableDescription;
+  }
+
   public static void replaceMethodBody(JMethod method, JExpression returnValue) {
     JMethodBody body = (JMethodBody) method.getBody();
     JBlock block = body.getBlock();
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/JsInteropRestrictionChecker.java b/dev/core/src/com/google/gwt/dev/jjs/impl/JsInteropRestrictionChecker.java
index 220af42..328936e 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/JsInteropRestrictionChecker.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/JsInteropRestrictionChecker.java
@@ -14,9 +14,11 @@
 package com.google.gwt.dev.jjs.impl;
 
 import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.TreeLogger.Type;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.MinimalRebuildCache;
 import com.google.gwt.dev.javac.JsInteropUtil;
+import com.google.gwt.dev.jjs.HasSourceInfo;
 import com.google.gwt.dev.jjs.ast.CanHaveSuppressedWarnings;
 import com.google.gwt.dev.jjs.ast.Context;
 import com.google.gwt.dev.jjs.ast.JClassType;
@@ -44,11 +46,14 @@
 import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
 import com.google.gwt.thirdparty.guava.common.collect.Iterables;
 import com.google.gwt.thirdparty.guava.common.collect.Maps;
+import com.google.gwt.thirdparty.guava.common.collect.Multimap;
 import com.google.gwt.thirdparty.guava.common.collect.Sets;
+import com.google.gwt.thirdparty.guava.common.collect.TreeMultimap;
 
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
+import java.util.TreeSet;
 
 /**
  * Checks and throws errors for invalid JsInterop constructs.
@@ -58,30 +63,22 @@
   public static void exec(TreeLogger logger, JProgram jprogram,
       MinimalRebuildCache minimalRebuildCache) throws UnableToCompleteException {
     JsInteropRestrictionChecker jsInteropRestrictionChecker =
-        new JsInteropRestrictionChecker(logger, jprogram, minimalRebuildCache);
-
-    jsInteropRestrictionChecker.checkProgram();
-    if (jsInteropRestrictionChecker.hasErrors) {
+        new JsInteropRestrictionChecker(jprogram, minimalRebuildCache);
+    boolean success = jsInteropRestrictionChecker.checkProgram(logger);
+    if (!success) {
       throw new UnableToCompleteException();
     }
   }
 
-  private Map<String, String> currentJsMethodNameByGetterNames;
-  private Map<String, String> currentJsMethodNameBySetterNames;
-  private Map<String, JType> currentJsPropertyTypeByName;
-  private Map<String, String> currentLocalNameByMemberNames;
-  private Set<JMethod> currentProcessedMethods;
-  private JDeclaredType currentType;
-  private boolean hasErrors;
+  private Multimap<String, String> errorsByFilename = TreeMultimap.create();
+  private Multimap<String, String> warningsByFilename = TreeMultimap.create();
   private final JProgram jprogram;
-  private final TreeLogger logger;
   private final MinimalRebuildCache minimalRebuildCache;
 
   // TODO review any use of word export
 
-  private JsInteropRestrictionChecker(TreeLogger logger, JProgram jprogram,
+  private JsInteropRestrictionChecker(JProgram jprogram,
       MinimalRebuildCache minimalRebuildCache) {
-    this.logger = logger;
     this.jprogram = jprogram;
     this.minimalRebuildCache = minimalRebuildCache;
   }
@@ -185,12 +182,16 @@
           }
         }).toList();
 
+    if (x.isJsNative()) {
+      return;
+    }
+
     if (jsConstructors.isEmpty()) {
       return;
     }
 
     if (jsConstructors.size() > 1) {
-      logError("More than one JsConstructor exists for %s.", x.getName());
+      logError(x, "More than one JsConstructor exists for %s.", JjsUtils.getReadableDescription(x));
     }
 
     final JConstructor jsConstructor = (JConstructor) jsConstructors.get(0);
@@ -204,8 +205,9 @@
     });
 
     if (anyNonDelegatingConstructor) {
-      logError("Constructor '%s' can be a JsConstructor only if all constructors in the class are "
-          + "delegating to it.", jsConstructor.getQualifiedName());
+      logError(jsConstructor,
+          "Constructor %s can be a JsConstructor only if all constructors in the class are "
+          + "delegating to it.", getMemberDescription(jsConstructor));
     }
   }
 
@@ -217,70 +219,127 @@
     return call.getTarget().equals(targetCtor);
   }
 
-  private void checkField(JField x) {
-    if (x.getEnclosingType().isJsNative()) {
-      checkMemberOfNativeJsType(x);
+  private void checkField(Map<String, JsMember> localNames, JField field) {
+    if (field.getEnclosingType().isJsNative()) {
+      checkMemberOfNativeJsType(field);
     }
-    checkUnusableByJs(x);
 
-    if (!x.isJsProperty()) {
+    checkUnusableByJs(field);
+
+    if (!field.isJsProperty()) {
       return;
     }
 
-    if (x.needsDynamicDispatch()) {
-      checkLocalName(x);
-    } else if (!x.isJsNative() && currentType == x.getEnclosingType()) {
-      checkGlobalName(x);
+    if (field.needsDynamicDispatch()) {
+      checkLocalName(localNames, field);
+    } else if (!field.isJsNative()) {
+      checkGlobalName(field);
     }
   }
 
-  private void checkMethod(JMethod x) {
-    if (!currentProcessedMethods.add(x)) {
-      return;
-    }
-    currentProcessedMethods.addAll(x.getOverriddenMethods());
-
-    if (x.getEnclosingType().isJsNative()) {
-      checkMemberOfNativeJsType(x);
+  private void checkMethod(Map<String, JsMember> localNames, JMethod method) {
+    if (method.getEnclosingType().isJsNative()) {
+      checkMemberOfNativeJsType(method);
     }
 
-    if (x.isJsOverlay()) {
-      checkJsOverlay(x);
+    if (method.isJsOverlay()) {
+      checkJsOverlay(method);
     }
 
-    checkUnusableByJs(x);
+    checkUnusableByJs(method);
 
-    if (!x.isOrOverridesJsMethod()) {
+    if (!method.isOrOverridesJsMethod()) {
       return;
     }
 
-    if (x.needsDynamicDispatch()) {
-      checkJsMethod(x);
-    } else if (!x.isJsNative() && currentType == x.getEnclosingType()) {
-      checkGlobalName(x);
+    if (method.needsDynamicDispatch()) {
+      if (!isSyntheticBridgeMethod(method)) {
+        checkLocalName(localNames, method);
+      }
+    } else if (!method.isJsNative()) {
+      checkGlobalName(method);
     }
   }
 
-  private void checkGlobalName(JMember x) {
-    if (!minimalRebuildCache.addExportedGlobalName(x.getQualifiedJsName(), currentType.getName())) {
-      logError("'%s' can't be exported because the global name '%s' is already taken.",
-          x.getQualifiedName(), x.getQualifiedJsName());
+  private void checkGlobalName(JMember member) {
+    if (!minimalRebuildCache.addExportedGlobalName(member.getQualifiedJsName(),
+        member.getEnclosingType().getName())) {
+      logError(member, "%s cannot be exported because the global name '%s' is already taken.",
+          getMemberDescription(member), member.getQualifiedJsName());
     }
   }
 
-  private void checkLocalName(JMember member) {
-    String jsName = member.getJsName();
-    if (currentLocalNameByMemberNames.put(jsName, member.getQualifiedName()) != null) {
-      logError("'%s' can't be exported in type '%s' because the name '%s' is already taken.",
-          member.getQualifiedName(), currentType.getName(), jsName);
+  private void checkLocalName(Map<String, JsMember> localNames, JMember member) {
+    if (member.getJsName().equals(JsInteropUtil.INVALID_JSNAME)) {
+      if (member instanceof JMethod
+          && ((JMethod) member).getJsPropertyAccessorType() == JsPropertyAccessorType.UNDEFINED) {
+        logError(member, "JsProperty %s doesn't follow Java Bean naming conventions.",
+            getMemberDescription(member));
+      } else {
+        logError(
+            member, "%s cannot be assigned a different JavaScript name than the method it overrides.",
+            getMemberDescription(member));
+      }
+      return;
+    }
+
+    JsMember oldMember = localNames.get(member.getJsName());
+    JsMember newMember = createOrUpdateJsMember(oldMember, member);
+
+    checkJsPropertyAccessor(member, newMember);
+
+    if (oldMember == null || newMember == oldMember) {
+      localNames.put(member.getJsName(), newMember);
+      return;
+    }
+
+    if (oldMember.isNativeMethod() && newMember.isNativeMethod()) {
+      return;
+    }
+
+    logError(member, "%s and %s cannot both use the same JavaScript name '%s'.",
+        getMemberDescription(member), getMemberDescription(oldMember.member), member.getJsName());
+  }
+
+  void checkJsPropertyAccessor(JMember x, JsMember newMember) {
+    if (newMember.setter != null) {
+      checkValidSetter(newMember.setter);
+    }
+    if (newMember.getter != null) {
+      checkValidGetter(newMember.getter);
+    }
+    if (newMember.setter != null && newMember.getter != null) {
+      checkJsPropertyGetterConsistentWithSetter(
+          x.getEnclosingType(), newMember.setter, newMember.getter);
     }
   }
 
-  private void checkJsPropertyType(String propertyName, String enclosingTypeName, JType type) {
-    JType recordedType = currentJsPropertyTypeByName.put(propertyName, type);
-    if (recordedType != null && recordedType != type) {
-      logError("The setter and getter for JsProperty '%s' in type '%s' must have consistent types.",
-          propertyName, enclosingTypeName);
+  private void checkJsPropertyGetterConsistentWithSetter(
+      JType type, JMethod setter, JMethod getter) {
+    if (setter.getParams().size() == 1
+        &&  getter.getType() != setter.getParams().get(0).getType()) {
+      logError(setter,
+          "The setter and getter for JsProperty '%s' in type '%s' must have consistent types.",
+          setter.getJsName(), JjsUtils.getReadableDescription(type));
+    }
+  }
+
+  private void checkValidSetter(JMethod setter) {
+    if (setter.getParams().size() != 1 || setter.getType() != JPrimitiveType.VOID) {
+      logError(setter, "There needs to be single parameter and void return type for the "
+          + "JsProperty setter %s.", getMemberDescription(setter));
+    }
+  }
+
+  private void checkValidGetter(JMethod getter) {
+    if (!getter.getParams().isEmpty() || getter.getType() == JPrimitiveType.VOID) {
+      logError(getter,
+          "There cannot be void return type or any parameters for the JsProperty getter"
+          + " %s.", getMemberDescription(getter));
+    }
+    if (getter.getType() != JPrimitiveType.BOOLEAN && getter.getName().startsWith("is")) {
+      logError(getter, "There cannot be non-boolean return for the JsProperty 'is' getter %s.",
+          getMemberDescription(getter));
     }
   }
 
@@ -289,19 +348,22 @@
       return;
     }
 
-    String qualifiedName = method.getQualifiedName();
+    String methodDescription = JjsUtils.getReadableDescription(method);
 
     if (!method.getEnclosingType().isJsNative()) {
-      logError("Method '%s' in non-native type cannot be @JsOverlay.", qualifiedName);
+      logError(method,
+          "Method '%s' in non-native type cannot be @JsOverlay.", methodDescription);
     }
 
     if (!method.getOverriddenMethods().isEmpty()) {
-      logError("JsOverlay method '%s' cannot override a supertype method.", qualifiedName);
+      logError(method,
+          "JsOverlay method '%s' cannot override a supertype method.", methodDescription);
       return;
     }
 
     if (method.isJsNative() || method.isJsniMethod() || method.isStatic() || !method.isFinal()) {
-      logError("JsOverlay method '%s' cannot be non-final, static, nor native.", qualifiedName);
+      logError(method,
+          "JsOverlay method '%s' cannot be non-final, static, nor native.", methodDescription);
     }
   }
 
@@ -311,96 +373,12 @@
     }
 
     if (member.getJsName() == null && !member.isJsOverlay()) {
-      logError("Native JsType member '%s' is not public or has @JsIgnore.",
-          member.getQualifiedName());
+      logError(member, "Native JsType member %s is not public or has @JsIgnore.",
+          getMemberDescription(member));
       return;
     }
   }
 
-  private void checkJsMethod(JMethod method) {
-    if (method.isSynthetic() && !method.isForwarding()) {
-      // A name slot taken up by a synthetic method, such as a bridge method for a generic method,
-      // is not the fault of the user and so should not be reported as an error. JS generation
-      // should take responsibility for ensuring that only the correct method version (in this
-      // particular set of colliding method names) is exported. Forwarding synthetic methods
-      // (such as an accidental override forwarding method that occurs when a JsType interface
-      // starts exposing a method in class B that is only ever implemented in its parent class A)
-      // though should be checked since they are exported and do take up an name slot.
-      return;
-    }
-
-    String jsMemberName = method.getJsName();
-    String qualifiedMethodName = method.getQualifiedName();
-    String typeName = method.getEnclosingType().getName();
-    JsPropertyAccessorType accessorType = method.getJsPropertyAccessorType();
-
-    if (jsMemberName == null) {
-      logError("'%s' can't be exported because the method overloads multiple methods with "
-          + "different names.", qualifiedMethodName);
-    }
-
-    if (accessorType == JsPropertyAccessorType.GETTER) {
-      if (!method.getParams().isEmpty() || method.getType() == JPrimitiveType.VOID) {
-        logError("There can't be void return type or any parameters for the JsProperty getter"
-            + " '%s'.", qualifiedMethodName);
-        return;
-      }
-      if (method.getType() != JPrimitiveType.BOOLEAN && method.getName().startsWith("is")) {
-        logError("There can't be non-boolean return for the JsProperty 'is' getter '%s'.",
-            qualifiedMethodName);
-        return;
-      }
-      if (currentJsMethodNameByGetterNames.put(jsMemberName, qualifiedMethodName) != null) {
-        // Don't allow multiple getters for the same property name.
-        logError("There can't be more than one getter for JsProperty '%s' in type '%s'.",
-            jsMemberName, typeName);
-        return;
-      }
-      checkNameCollisionForGetterAndRegular(jsMemberName, typeName);
-      checkJsPropertyType(jsMemberName, typeName, method.getOriginalReturnType());
-    } else if (accessorType == JsPropertyAccessorType.SETTER) {
-      if (method.getParams().size() != 1 || method.getType() != JPrimitiveType.VOID) {
-        logError("There needs to be single parameter and void return type for the JsProperty setter"
-            + " '%s'.", qualifiedMethodName);
-        return;
-      }
-      if (currentJsMethodNameBySetterNames.put(jsMemberName, qualifiedMethodName) != null) {
-        // Don't allow multiple setters for the same property name.
-        logError("There can't be more than one setter for JsProperty '%s' in type '%s'.",
-            jsMemberName, typeName);
-        return;
-      }
-      checkNameCollisionForSetterAndRegular(jsMemberName, typeName);
-      checkJsPropertyType(jsMemberName, typeName,
-          Iterables.getOnlyElement(method.getParams()).getType());
-    } else if (accessorType == JsPropertyAccessorType.UNDEFINED) {
-      // We couldn't extract the JsPropertyType.
-      logError("JsProperty '%s' doesn't follow Java Bean naming conventions.", qualifiedMethodName);
-    } else {
-      checkLocalName(method);
-      checkNameCollisionForGetterAndRegular(jsMemberName, typeName);
-      checkNameCollisionForSetterAndRegular(jsMemberName, typeName);
-    }
-  }
-
-  private void checkNameCollisionForGetterAndRegular(String getterName, String typeName) {
-    if (currentJsMethodNameByGetterNames.containsKey(getterName)
-        && currentLocalNameByMemberNames.containsKey(getterName)) {
-      logError("'%s' and '%s' can't both be named '%s' in type '%s'.",
-          currentLocalNameByMemberNames.get(getterName),
-          currentJsMethodNameByGetterNames.get(getterName), getterName, typeName);
-    }
-  }
-
-  private void checkNameCollisionForSetterAndRegular(String setterName, String typeName) {
-    if (currentJsMethodNameBySetterNames.containsKey(setterName)
-        && currentLocalNameByMemberNames.containsKey(setterName)) {
-      logError("'%s' and '%s' can't both be named '%s' in type '%s'.",
-          currentLocalNameByMemberNames.get(setterName),
-          currentJsMethodNameBySetterNames.get(setterName), setterName, typeName);
-    }
-  }
-
   private void checkStaticJsPropertyCalls() {
     new JVisitor() {
       @Override
@@ -412,11 +390,10 @@
       @Override
       public void endVisit(JMethodCall x, Context ctx) {
         JMethod target = x.getTarget();
-        if (x.isStaticDispatchOnly() && target.isJsPropertyAccessor()) {
-          logError("Cannot call property accessor '%s' via super (%s:%d).",
-              target.getQualifiedName(),
-              x.getSourceInfo().getFileName(),
-              x.getSourceInfo().getStartLine());
+        if (x.isStaticDispatchOnly() &&
+            target.getJsPropertyAccessorType() != JsPropertyAccessorType.NONE) {
+          logError(x, "Cannot call property accessor %s via super.",
+              getMemberDescription(target));
         }
       }
     }.accept(jprogram);
@@ -428,10 +405,8 @@
       public boolean visit(JInstanceOf x, Context ctx) {
         JReferenceType type = x.getTestType();
         if (type.isJsNative() && type instanceof JInterfaceType) {
-          logError("Cannot do instanceof against native JsType interface %s (%s:%d).",
-              type.getName(),
-              x.getSourceInfo().getFileName(),
-              x.getSourceInfo().getStartLine());
+          logError(x, "Cannot do instanceof against native JsType interface '%s'.",
+              JjsUtils.getReadableDescription(type));
         }
         return true;
       }
@@ -450,8 +425,8 @@
 
     for (JConstructor constructor : type.getConstructors()) {
       if (!isConstructorEmpty(constructor)) {
-        logError("Native JsType constructor '%s' cannot have non-empty method body.",
-            constructor.getQualifiedName());
+        logError(constructor, "Native JsType constructor %s cannot have non-empty method body.",
+            getMemberDescription(constructor));
       }
     }
   }
@@ -468,16 +443,12 @@
     if (type.isJsType()) {
       logError("'%s' cannot be both a JsFunction and a JsType at the same time.", type);
     }
-
-    Set<String> subTypes = jprogram.typeOracle.getSubInterfaceNames(type.getName());
-    if (!subTypes.isEmpty()) {
-      logError("JsFunction '%s' cannot be extended by other interfaces:%s", type, subTypes);
-    }
   }
 
   private void checkJsFunctionImplementation(JDeclaredType type) {
     if (type.getImplements().size() != 1) {
-      logError("JsFunction implementation '%s' cannot implement more than one interface.", type);
+      logError("JsFunction implementation '%s' cannot implement more than one interface.",
+          type);
     }
 
     if (type.isJsType()) {
@@ -488,29 +459,34 @@
     if (type.getSuperClass() != jprogram.getTypeJavaLangObject()) {
       logError("JsFunction implementation '%s' cannot extend a class.", type);
     }
+  }
 
-    Set<String> subTypes = jprogram.typeOracle.getSubClassNames(type.getName());
-    if (!subTypes.isEmpty()) {
-      logError("Implementation of JsFunction '%s' cannot be extended by other classes:%s", type,
-          subTypes);
+  private void checkJsFunctionSubtype(JDeclaredType type) {
+    JClassType superClass = type.getSuperClass();
+    if (superClass != null && superClass.isJsFunctionImplementation()) {
+      logError(type, "'%s' cannot extend JsFunction implementation '%s'.",
+          JjsUtils.getReadableDescription(type), JjsUtils.getReadableDescription(superClass));
+    }
+    for (JInterfaceType superInterface : type.getImplements()) {
+      if (superInterface.isJsFunction()) {
+        logError(type, "'%s' cannot extend JsFunction '%s'.",
+            JjsUtils.getReadableDescription(type), JjsUtils.getReadableDescription(superInterface));
+      }
     }
   }
 
-  private void checkProgram() {
+  private boolean checkProgram(TreeLogger logger) {
     for (JDeclaredType type : jprogram.getModuleDeclaredTypes()) {
       checkType(type);
     }
     checkStaticJsPropertyCalls();
     checkInstanceOfNativeJsTypes();
+
+    boolean hasErrors = reportErrorsAndWarnings(logger);
+    return !hasErrors;
   }
 
   private void checkType(JDeclaredType type) {
-    currentProcessedMethods = Sets.newHashSet();
-    currentLocalNameByMemberNames = Maps.newHashMap();
-    currentJsMethodNameByGetterNames = Maps.newHashMap();
-    currentJsMethodNameBySetterNames = Maps.newHashMap();
-    currentJsPropertyTypeByName = Maps.newHashMap();
-    currentType = type;
     minimalRebuildCache.removeExportedNames(type.getName());
 
     if (type.isJsNative()) {
@@ -522,16 +498,17 @@
     } else if (type.isJsFunctionImplementation()) {
       checkJsFunctionImplementation(type);
     } else {
+      checkJsFunctionSubtype(type);
       checkJsConstructors(type);
     }
 
-    for (;type != null; type = type.getSuperClass())  {
-      for (JField field : type.getFields()) {
-        checkField(field);
-      }
-      for (JMethod method : type.getMethods()) {
-        checkMethod(method);
-      }
+    Map<String, JsMember> localNames = collectNames(type.getSuperClass());
+
+    for (JField field : type.getFields()) {
+      checkField(localNames, field);
+    }
+    for (JMethod method : type.getMethods()) {
+      checkMethod(localNames, method);
     }
   }
 
@@ -540,22 +517,22 @@
         || isUnusableByJsSuppressed(method)) {
       return;
     }
-    String methodName = method.getQualifiedName();
     // check parameters.
     for (JParameter parameter : method.getParams()) {
       if (!parameter.getType().canBeReferencedExternally()
           && !isUnusableByJsSuppressed(parameter)) {
         logWarning(
-            "[unusable-by-js] Type of parameter '%s' in method '%s' is not usable by but exposed to"
-            + " JavaScript",
-            parameter.getName(), methodName);
+            parameter,
+            "[unusable-by-js] Type of parameter '%s' in method %s is not usable by but exposed to"
+            + " JavaScript.",
+            parameter.getName(), getMemberDescription(method));
       }
     }
     // check return type.
     if (!method.getType().canBeReferencedExternally()) {
       logWarning(
-          "[unusable-by-js] Return type of '%s' is not usable by but exposed to JavaScript",
-          methodName);
+          method, "[unusable-by-js] Return type of %s is not usable by but exposed to JavaScript.",
+          getMemberDescription(method));
     }
   }
 
@@ -566,35 +543,183 @@
     }
     if (!field.getType().canBeReferencedExternally()) {
       logWarning(
-          "[unusable-by-js] Type of field '%s' in type '%s' is not usable by but exposed to "
-          + "JavaScript",
-          field.getName(), field.getEnclosingType().getName());
+          field, "[unusable-by-js] Type of field '%s' in type '%s' is not usable by but exposed to "
+              + "JavaScript.",
+          field.getName(), JjsUtils.getReadableDescription(field.getEnclosingType()));
     }
   }
 
+  private static class JsMember {
+    private JMember member;
+    private JMethod setter;
+    private JMethod getter;
+
+    public JsMember(JMember member) {
+      this.member = member;
+    }
+
+    public JsMember(JMethod member, JMethod setter, JMethod getter) {
+      this.member = member;
+      this.setter = setter;
+      this.getter = getter;
+    }
+
+    public boolean isNativeMethod() {
+      return member instanceof JMethod && member.isJsNative() && !isPropertyAccessor();
+    }
+
+    public boolean isPropertyAccessor() {
+      return setter != null || getter != null;
+    }
+  }
+
+  private LinkedHashMap<String, JsMember> collectNames(JDeclaredType type) {
+    if (type == null) {
+      return Maps.newLinkedHashMap();
+    }
+
+    LinkedHashMap<String, JsMember> memberByLocalMemberNames = collectNames(type.getSuperClass());
+
+    for (JField field : type.getFields()) {
+      if (!field.isJsProperty() || !field.needsDynamicDispatch()) {
+        continue;
+      }
+      updateJsMembers(memberByLocalMemberNames, field);
+    }
+    for (JMethod method : type.getMethods()) {
+      if (!method.isOrOverridesJsMethod() || !method.needsDynamicDispatch()
+          || isSyntheticBridgeMethod(method)) {
+        continue;
+      }
+      updateJsMembers(memberByLocalMemberNames, method);
+    }
+    return memberByLocalMemberNames;
+  }
+
+  private boolean isSyntheticBridgeMethod(JMethod method) {
+    // A name slot taken up by a synthetic method, such as a bridge method for a generic method,
+    // is not the fault of the user and so should not be reported as an error. JS generation
+    // should take responsibility for ensuring that only the correct method version (in this
+    // particular set of colliding method names) is exported. Forwarding synthetic methods
+    // (such as an accidental override forwarding method that occurs when a JsType interface
+    // starts exposing a method in class B that is only ever implemented in its parent class A)
+    // though should be checked since they are exported and do take up an name slot.
+    return method.isSynthetic() && !method.isForwarding();
+  }
+
+  private void updateJsMembers(Map<String, JsMember> memberByLocalMemberNames, JMember member) {
+    JsMember oldJsMember = memberByLocalMemberNames.get(member.getJsName());
+    JsMember updatedJsMember = createOrUpdateJsMember(oldJsMember, member);
+    memberByLocalMemberNames.put(member.getJsName(), updatedJsMember);
+  }
+
+  private JsMember createOrUpdateJsMember(JsMember jsMember, JMember member) {
+    if (member instanceof JField) {
+      return new JsMember(member);
+    }
+
+    JMethod method = (JMethod) member;
+    switch (method.getJsPropertyAccessorType()) {
+      case GETTER:
+        if (jsMember != null && jsMember.isPropertyAccessor()) {
+          if (jsMember.getter == null || overrides(method, jsMember.getter)) {
+            jsMember.getter = method;
+            jsMember.member = method;
+            return jsMember;
+          }
+        }
+        return new JsMember(method, jsMember == null ? null : jsMember.setter, method);
+      case SETTER:
+        if (jsMember != null && jsMember.isPropertyAccessor()) {
+          if (jsMember.setter == null || overrides(method, jsMember.setter)) {
+            jsMember.setter = method;
+            jsMember.member = method;
+            return jsMember;
+          }
+        }
+        return new JsMember(method, method, jsMember == null ? null : jsMember.getter);
+      default:
+        if (jsMember != null) {
+          if (overrides(method, jsMember.member)) {
+            jsMember.member = method;
+            return jsMember;
+          }
+        }
+        return new JsMember(method);
+    }
+  }
+
+  private boolean overrides(JMethod method, JMember potentiallyOverriddenMember) {
+    if (potentiallyOverriddenMember instanceof JField) {
+      return false;
+    }
+    if (method.getOverriddenMethods().contains(potentiallyOverriddenMember)) {
+      return true;
+    }
+
+    // Consider methods that have the same name and parameter signature to be overrides.
+    // GWT models overrides similar to the JVM (not Java) in the sense that for a method to override
+    // another they must have identical signatures (includes parameters and return type).
+    // Methods that only differ in return types are Java overrides and need to be considered so
+    // for local name collision checking.
+    JMethod potentiallyOverriddenMethod = (JMethod) potentiallyOverriddenMember;
+    return method.getJsniSignature(false, false)
+        .equals(potentiallyOverriddenMethod.getJsniSignature(false, false));
+  }
+
+  private static String getMemberDescription(JMember member) {
+    if (member instanceof JField) {
+      return String.format("'%s'", JjsUtils.getReadableDescription(member));
+    }
+    JMethod method = (JMethod) member;
+    if ((method.isSyntheticAccidentalOverride() || method.isSynthetic())
+        // Some synthetic methods are created by JDT, it is not save to assume
+        // that they will always be overriding and crash the compiler.
+        && !method.getOverriddenMethods().isEmpty()) {
+      JMethod overridenMethod = method.getOverriddenMethods().iterator().next();
+      return String.format("'%s' (exposed by '%s')",
+          JjsUtils.getReadableDescription(overridenMethod),
+          JjsUtils.getReadableDescription(method.getEnclosingType()));
+    }
+    return String.format("'%s'", JjsUtils.getReadableDescription(method));
+  }
+
   private boolean isUnusableByJsSuppressed(CanHaveSuppressedWarnings x) {
     return x.getSuppressedWarnings() != null &&
         x.getSuppressedWarnings().contains(JsInteropUtil.UNUSABLE_BY_JS);
   }
 
   private void logError(String format, JType type) {
-    logError(format, type.getName());
+    logError(type, format, JjsUtils.getReadableDescription(type));
   }
 
-  private void logError(String format, JType type, Set<String> subTypes) {
-    StringBuilder subTypeNames = new StringBuilder();
-    for (String typeName : subTypes) {
-      subTypeNames.append("\n\t").append(typeName);
+  private void logError(HasSourceInfo hasSourceInfo, String format, Object... args) {
+    errorsByFilename.put(hasSourceInfo.getSourceInfo().getFileName(),
+        String.format("Line %d: ", hasSourceInfo.getSourceInfo().getStartLine())
+            + String.format(format, args));
+  }
+
+  private void logWarning(HasSourceInfo hasSourceInfo, String format, Object... args) {
+    warningsByFilename.put(hasSourceInfo.getSourceInfo().getFileName(),
+        String.format("Line %d: ", hasSourceInfo.getSourceInfo().getStartLine())
+            + String.format(format, args));
+  }
+
+  private boolean reportErrorsAndWarnings(TreeLogger logger) {
+    TreeSet<String> filenamesToReport = Sets.newTreeSet(
+        Iterables.concat(errorsByFilename.keySet(), warningsByFilename.keySet()));
+    for (String fileName : filenamesToReport) {
+      boolean hasErrors = !errorsByFilename.get(fileName).isEmpty();
+      TreeLogger branch = logger.branch(
+          hasErrors ? Type.ERROR : Type.WARN,
+          (hasErrors ? "Errors" : "Warnings") + " in " + fileName);
+      for (String message : errorsByFilename.get(fileName)) {
+        branch.log(Type.ERROR, message);
+      }
+      for (String message :warningsByFilename.get(fileName)) {
+        branch.log(Type.WARN, message);
+      }
     }
-    logError(format, type.getName(), subTypeNames);
-  }
-
-  private void logError(String format, Object... args) {
-    logger.log(TreeLogger.ERROR, String.format(format, args));
-    hasErrors = true;
-  }
-
-  private void logWarning(String format, Object... args) {
-    logger.log(TreeLogger.WARN, String.format(format, args));
+    return !errorsByFilename.isEmpty();
   }
 }
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/JsInteropRestrictionCheckerTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/JsInteropRestrictionCheckerTest.java
index a345792..259daaa 100644
--- a/dev/core/test/com/google/gwt/dev/jjs/impl/JsInteropRestrictionCheckerTest.java
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/JsInteropRestrictionCheckerTest.java
@@ -16,11 +16,14 @@
 package com.google.gwt.dev.jjs.impl;
 
 import com.google.gwt.core.ext.TreeLogger;
-import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.MinimalRebuildCache;
 import com.google.gwt.dev.javac.testing.impl.MockJavaResource;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JProgram;
+import com.google.gwt.thirdparty.guava.common.collect.Lists;
+
+import java.util.Arrays;
+import java.util.List;
 
 /**
  * Tests for the JsInteropRestrictionChecker.
@@ -47,8 +50,10 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.doIt(Ltest/EntryPoint$Bar;)V' can't be exported in type "
-        + "'test.EntryPoint$Buggy' because the name 'doIt' is already taken.");
+        "Line 14: 'void EntryPoint.ParentBuggy.doIt(EntryPoint.Bar)' "
+            + "(exposed by 'EntryPoint.Buggy') and "
+            + "'void EntryPoint.ParentBuggy.doIt(EntryPoint.Foo)' (exposed by 'EntryPoint.Buggy') "
+            + "cannot both use the same JavaScript name 'doIt'.");
   }
 
   public void testCollidingAccidentalOverrideAbstractMethodFails() throws Exception {
@@ -69,8 +74,9 @@
         "public static class Buggy {}  // Unrelated class");
 
     assertBuggyFails(
-        "'test.EntryPoint$Baz.doIt(Ltest/EntryPoint$Bar;)V' can't be exported in type "
-            + "'test.EntryPoint$Baz' because the name 'doIt' is already taken.");
+        "Line 14: 'void EntryPoint.Baz.doIt(EntryPoint.Bar)' and "
+            + "'void EntryPoint.Baz.doIt(EntryPoint.Foo)' cannot both use the same "
+            + "JavaScript name 'doIt'.");
   }
 
   public void testCollidingAccidentalOverrideHalfAndHalfFails() throws Exception {
@@ -93,14 +99,15 @@
         "public static class Buggy extends Parent implements Bar {}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Parent.doIt(Ltest/EntryPoint$Foo;)V' can't be exported in type "
-        + "'test.EntryPoint$Buggy' because the name 'doIt' is already taken.");
+        "Line 12: 'void EntryPoint.ParentParent.doIt(EntryPoint.Bar)' "
+            + "(exposed by 'EntryPoint.Buggy') and 'void EntryPoint.Parent.doIt(EntryPoint.Foo)' "
+            + "cannot both use the same JavaScript name 'doIt'.");
   }
 
   public void testCollidingFieldExportsFails() throws Exception {
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
-        "public static class Buggy {",
+       "public static class Buggy {",
         "  @JsProperty",
         "  public static final int show = 0;",
         "  @JsProperty(name = \"show\")",
@@ -108,8 +115,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.display' can't be exported because the "
-            + "global name 'test.EntryPoint.Buggy.show' is already taken.");
+        "Line 8: 'int EntryPoint.Buggy.display' cannot be exported because the global "
+            + "name 'test.EntryPoint.Buggy.show' is already taken.");
   }
 
   public void testJsPropertyGetterStyleSucceeds() throws Exception {
@@ -142,18 +149,20 @@
         "}");
 
     assertBuggyFails(
-        "There can't be non-boolean return for the JsProperty 'is' getter"
-            + " 'test.EntryPoint$Buggy.isX()I'.",
-        "There can't be void return type or any parameters for the JsProperty getter"
-            + " 'test.EntryPoint$Buggy.getY(I)I'.",
-        "There can't be void return type or any parameters for the JsProperty getter"
-            + " 'test.EntryPoint$Buggy.getZ()V'.",
-        "There needs to be single parameter and void return type for the JsProperty setter"
-            + " 'test.EntryPoint$Buggy.setX(II)V'.",
-        "There needs to be single parameter and void return type for the JsProperty setter"
-            + " 'test.EntryPoint$Buggy.setY()V'.",
-        "There needs to be single parameter and void return type for the JsProperty setter"
-            + " 'test.EntryPoint$Buggy.setZ(I)I'.");
+        "Line 10: There needs to be single parameter and void return type for the JsProperty "
+            + "setter 'void EntryPoint.Buggy.setX(int, int)'.",
+        "Line 8: There cannot be void return type or any parameters for the JsProperty getter "
+            + "'int EntryPoint.Buggy.getY(int)'.",
+        "Line 9: There cannot be void return type or any parameters for the JsProperty getter "
+            + "'void EntryPoint.Buggy.getZ()'.",
+        "Line 7: There cannot be non-boolean return for the JsProperty 'is' "
+            + "getter 'int EntryPoint.Buggy.isX()'.",
+        "Line 11: There needs to be single parameter and void return type for the JsProperty "
+            + "setter 'void EntryPoint.Buggy.setY()'.",
+        "Line 12: There needs to be single parameter and void return type for the JsProperty "
+            + "setter 'int EntryPoint.Buggy.setZ(int)'.",
+        "Line 12: The setter and getter for JsProperty 'z' in type 'EntryPoint.Buggy' must "
+            + "have consistent types.");
   }
 
   public void testJsPropertyNonGetterStyleFails() throws Exception {
@@ -168,9 +177,12 @@
         "}");
 
     assertBuggyFails(
-        "JsProperty 'test.EntryPoint$Buggy.hasX()Z' doesn't follow Java Bean naming conventions.",
-        "JsProperty 'test.EntryPoint$Buggy.x()I' doesn't follow Java Bean naming conventions.",
-        "JsProperty 'test.EntryPoint$Buggy.x(I)V' doesn't follow Java Bean naming conventions.");
+        "Line 7: JsProperty 'boolean EntryPoint.Buggy.hasX()' doesn't follow Java Bean "
+            + "naming conventions.",
+        "Line 8: JsProperty 'int EntryPoint.Buggy.x()' doesn't follow Java Bean naming"
+            + " conventions.",
+        "Line 9: JsProperty 'void EntryPoint.Buggy.x(int)' doesn't follow Java Bean naming "
+            + "conventions.");
   }
 
   public void testCollidingJsPropertiesTwoGettersFails() throws Exception {
@@ -178,20 +190,16 @@
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
         "@JsType",
-        "public static interface IBuggy {",
+        "public static interface Buggy {",
         "  @JsProperty",
         "  boolean isX();",
         "  @JsProperty",
         "  boolean getX();",
-        "}",
-        "public static class Buggy implements IBuggy {",
-        "  public boolean isX() {return false;}",
-        "  public boolean getX() {return false;}",
         "}");
 
     assertBuggyFails(
-        "There can't be more than one getter for JsProperty 'x' in type 'test.EntryPoint$IBuggy'.",
-        "There can't be more than one getter for JsProperty 'x' in type 'test.EntryPoint$Buggy'.");
+        "Line 10: 'boolean EntryPoint.Buggy.getX()' and 'boolean EntryPoint.Buggy.isX()' "
+            + "cannot both use the same JavaScript name 'x'.");
   }
 
   public void testCollidingJsPropertiesTwoSettersFails() throws Exception {
@@ -199,23 +207,18 @@
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
         "@JsType",
-        "public static interface IBuggy {",
+        "public static interface Buggy {",
         "  @JsProperty",
         "  void setX(boolean x);",
         "  @JsProperty",
         "  void setX(int x);",
-        "}",
-        "public static class Buggy implements IBuggy {",
-        "  public void setX(boolean x) {}",
-        "  public void setX(int x) {}",
         "}");
 
     assertBuggyFails(
-        "There can't be more than one setter for JsProperty 'x' in type 'test.EntryPoint$IBuggy'.",
-        "There can't be more than one setter for JsProperty 'x' in type 'test.EntryPoint$Buggy'.");
+        "Line 10: 'void EntryPoint.Buggy.setX(int)' and 'void EntryPoint.Buggy.setX(boolean)' "
+            + "cannot both use the same JavaScript name 'x'.");
   }
 
-  // TODO: duplicate this check with two @JsType interfaces.
   public void testCollidingJsTypeAndJsPropertyGetterFails() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsProperty");
@@ -232,10 +235,10 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$IBuggy.x(Z)Z' and 'test.EntryPoint$IBuggy.getX()I' "
-        + "can't both be named 'x' in type 'test.EntryPoint$IBuggy'.",
-        "'test.EntryPoint$Buggy.x(Z)Z' and 'test.EntryPoint$Buggy.getX()I' "
-        + "can't both be named 'x' in type 'test.EntryPoint$Buggy'.");
+        "Line 9: 'int EntryPoint.IBuggy.getX()' and 'boolean EntryPoint.IBuggy.x(boolean)' "
+            + "cannot both use the same JavaScript name 'x'.",
+        "Line 13: 'int EntryPoint.Buggy.getX()' and 'boolean EntryPoint.Buggy.x(boolean)' "
+            + "cannot both use the same JavaScript name 'x'.");
   }
 
   public void testCollidingJsTypeAndJsPropertySetterFails() throws Exception {
@@ -254,10 +257,10 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$IBuggy.x(Z)Z' and 'test.EntryPoint$IBuggy.setX(I)V' "
-        + "can't both be named 'x' in type 'test.EntryPoint$IBuggy'.",
-        "'test.EntryPoint$Buggy.x(Z)Z' and 'test.EntryPoint$Buggy.setX(I)V' "
-        + "can't both be named 'x' in type 'test.EntryPoint$Buggy'.");
+        "Line 9: 'void EntryPoint.IBuggy.setX(int)' and 'boolean EntryPoint.IBuggy.x(boolean)' "
+            + "cannot both use the same JavaScript name 'x'.",
+        "Line 13: 'void EntryPoint.Buggy.setX(int)' and 'boolean EntryPoint.Buggy.x(boolean)' "
+            + "cannot both use the same JavaScript name 'x'.");
   }
 
   public void testCollidingMethodExportsFails() throws Exception {
@@ -271,8 +274,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.display()V' can't be exported "
-            + "because the global name 'test.EntryPoint.Buggy.show' is already taken.");
+        "Line 8: 'void EntryPoint.Buggy.display()' cannot be exported because the global name "
+            + "'test.EntryPoint.Buggy.show' is already taken.");
   }
 
   public void testCollidingMethodToFieldExportsFails() throws Exception {
@@ -287,8 +290,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.show()V' can't be exported because the "
-            + "global name 'test.EntryPoint.Buggy.show' is already taken.");
+        "Line 7: 'void EntryPoint.Buggy.show()' cannot be exported because the global name "
+            + "'test.EntryPoint.Buggy.show' is already taken.");
   }
 
   public void testCollidingMethodToFieldJsTypeFails() throws Exception {
@@ -301,8 +304,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.show()V' can't be exported in type "
-            + "'test.EntryPoint$Buggy' because the name 'show' is already taken.");
+        "Line 6: 'void EntryPoint.Buggy.show()' and 'int EntryPoint.Buggy.show' cannot both use "
+            + "the same JavaScript name 'show'.");
   }
 
   public void testCollidingMethodToMethodJsTypeFails() throws Exception {
@@ -315,8 +318,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.show()V' can't be exported in type "
-            + "'test.EntryPoint$Buggy' because the name 'show' is already taken.");
+        "Line 7: 'void EntryPoint.Buggy.show()' and 'void EntryPoint.Buggy.show(int)' cannot both "
+            + "use the same JavaScript name 'show'.");
   }
 
   public void testCollidingSubclassExportedFieldToFieldJsTypeSucceeds() throws Exception {
@@ -402,8 +405,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$ParentBuggy.foo' can't be exported in type "
-            + "'test.EntryPoint$Buggy' because the name 'foo' is already taken.");
+        "Line 10: 'int EntryPoint.Buggy.foo' and 'int EntryPoint.ParentBuggy.foo' cannot both use "
+            + "the same JavaScript name 'foo'.");
   }
 
   public void testCollidingSubclassFieldToMethodJsTypeFails() throws Exception {
@@ -419,8 +422,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$ParentBuggy.foo' can't be exported in type "
-            + "'test.EntryPoint$Buggy' because the name 'foo' is already taken.");
+        "Line 10: 'void EntryPoint.Buggy.foo(int)' and 'int EntryPoint.ParentBuggy.foo' cannot "
+            + "both use the same JavaScript name 'foo'.");
   }
 
   public void testCollidingSubclassMethodToExportedMethodJsTypeSucceeds() throws Exception {
@@ -456,8 +459,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.show()V' can't be exported in type "
-            + "'test.EntryPoint$Buggy2' because the name 'show' is already taken.");
+        "Line 16: 'void EntryPoint.Buggy2.show(boolean)' and 'void EntryPoint.Buggy.show()' cannot "
+            + "both use the same JavaScript name 'show'.");
   }
 
   public void testCollidingSubclassMethodToMethodJsTypeFails() throws Exception {
@@ -473,8 +476,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$ParentBuggy.foo()V' can't be exported in type "
-            + "'test.EntryPoint$Buggy' because the name 'foo' is already taken.");
+        "Line 10: 'void EntryPoint.Buggy.foo(int)' and 'void EntryPoint.ParentBuggy.foo()' "
+            + "cannot both use the same JavaScript name 'foo'.");
   }
 
   public void testCollidingSubclassMethodToMethodTwoLayerInterfaceJsTypeFails() throws Exception {
@@ -500,11 +503,11 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy.show()V' can't be exported in type "
-            + "'test.EntryPoint$Buggy2' because the name 'show' is already taken.");
+        "Line 20: 'void EntryPoint.Buggy2.show(boolean)' and 'void EntryPoint.Buggy.show()' "
+            + "cannot both use the same JavaScript name 'show'.");
   }
 
-  public void testCollidingSyntheticBridgeMethodSucceeds() throws Exception {
+  public void testNonCollidingSyntheticBridgeMethodSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
@@ -520,6 +523,52 @@
     assertBuggySucceeds();
   }
 
+  public void testCollidingSyntheticBridgeMethodSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@JsType",
+        "public static interface Comparable<T> {",
+        "  int compareTo(T other);",
+        "}",
+        "@JsType",
+        "public static class Enum<E extends Enum<E>> implements Comparable<E> {",
+        "  public int compareTo(E other) {return 0;}",
+        "}",
+        "public static class Buggy {}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testSpecializeReturnTypeInImplementorSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@JsType",
+        "interface I {",
+        "  I m();",
+        "}",
+        "@JsType",
+        "public static class Buggy implements I {",
+        "  public Buggy m() { return null; } ",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testSpecializeReturnTypeInSubclassSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@JsType",
+        "public static class S {",
+        "  public S m() { return null; }",
+        "}",
+        "@JsType",
+        "public static class Buggy extends S {",
+        "  public Buggy m() { return null; } ",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
   public void testCollidingTwoLayerSubclassFieldToFieldJsTypeFails() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
@@ -536,8 +585,93 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$ParentParentBuggy.foo' can't be exported in type "
-            + "'test.EntryPoint$Buggy' because the name 'foo' is already taken.");
+        "Line 13: 'int EntryPoint.Buggy.foo' and 'int EntryPoint.ParentParentBuggy.foo' cannot "
+            + "both use the same JavaScript name 'foo'.");
+  }
+
+  public void testRenamedSuperclassJsMethodFails() {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetImport("jsinterop.annotations.JsMethod");
+    addSnippetClassDecl(
+        "@JsType",
+        "public static class ParentBuggy {",
+        "  public void foo() {}",
+        "}",
+        "public static class Buggy extends ParentBuggy {",
+        "  @JsMethod(name = \"bar\") public void foo() {}",
+        "}");
+
+    assertBuggyFails("Line 10: 'void EntryPoint.Buggy.foo()' cannot be assigned a different "
+        + "JavaScript name than the method it overrides.");
+  }
+
+  public void testRenamedSuperInterfaceJsMethodFails() {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetImport("jsinterop.annotations.JsMethod");
+    addSnippetClassDecl(
+        "@JsType",
+        "public interface ParentBuggy {",
+        "  void foo();;",
+        "}",
+        "public interface Buggy extends ParentBuggy {",
+        "  @JsMethod(name = \"bar\") void foo();",
+        "}");
+
+    assertBuggyFails("Line 10: 'void EntryPoint.Buggy.foo()' cannot be assigned a different "
+        + "JavaScript name than the method it overrides.");
+  }
+
+  public void testAccidentallyRenamedSuperInterfaceJsMethodFails() {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetImport("jsinterop.annotations.JsMethod");
+    addSnippetClassDecl(
+        "@JsType",
+        "public interface IBuggy {",
+        "  void foo();",
+        "}",
+        "@JsType",
+        "public static class ParentBuggy {",
+        "  @JsMethod(name = \"bar\") public void foo() {}",
+        "}",
+        "public static class Buggy extends ParentBuggy implements IBuggy {",
+        "}");
+
+    assertBuggyFails("Line 11: 'void EntryPoint.ParentBuggy.foo()' (exposed by 'EntryPoint.Buggy') "
+        + "cannot be assigned a different JavaScript name than the method it overrides.");
+  }
+
+  // TODO(goktug): enable once the property names are handled.
+  public void __disabled__testRenamedSuperclassJsPropertyFails() {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetImport("jsinterop.annotations.JsProperty");
+    addSnippetClassDecl(
+        "@JsType",
+        "public static class ParentBuggy {",
+        "  @JsProperty public int getFoo() { return 0; }",
+        "}",
+        "public static class Buggy extends ParentBuggy {",
+        "  @JsProperty(name = \"bar\") public int getFoo() { return 0;}",
+        "}");
+
+    assertBuggyFails("'EntryPoint.Buggy.getFoo()I' cannot be exported because the method "
+        + "overrides a method with different name.");
+  }
+
+  public void testJsPropertyDifferentFlavourInSubclassFails() {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetImport("jsinterop.annotations.JsProperty");
+    addSnippetClassDecl(
+        "@JsType",
+        "public static class ParentBuggy {",
+        "  @JsProperty public boolean isFoo() { return false; }",
+        "}",
+        "public static class Buggy extends ParentBuggy {",
+        "  @JsProperty public boolean getFoo() { return false;}",
+        "}");
+
+    assertBuggyFails(
+        "Line 10: 'boolean EntryPoint.Buggy.getFoo()' and 'boolean EntryPoint.ParentBuggy.isFoo()' "
+            + "cannot both use the same JavaScript name 'foo'.");
   }
 
   public void testConsistentPropertyTypeSucceeds() throws Exception {
@@ -576,9 +710,9 @@
         "}");
 
     assertBuggyFails(
-        "The setter and getter for JsProperty 'foo' in type 'test.EntryPoint$IBuggy' "
+        "Line 10: The setter and getter for JsProperty 'foo' in type 'EntryPoint.IBuggy' "
             + "must have consistent types.",
-        "The setter and getter for JsProperty 'foo' in type 'test.EntryPoint$Buggy' "
+        "Line 14: The setter and getter for JsProperty 'foo' in type 'EntryPoint.Buggy' "
             + "must have consistent types.");
   }
 
@@ -599,14 +733,13 @@
         "}");
 
     assertBuggyFails(
-        "The setter and getter for JsProperty 'foo' in type 'test.EntryPoint$IBuggy' "
+        "Line 10: The setter and getter for JsProperty 'foo' in type 'EntryPoint.IBuggy' "
             + "must have consistent types.",
-        "The setter and getter for JsProperty 'foo' in type 'test.EntryPoint$Buggy' "
+        "Line 14: The setter and getter for JsProperty 'foo' in type 'EntryPoint.Buggy' "
             + "must have consistent types.");
   }
 
-  public void testJsPropertySuperCallFails()
-      throws UnableToCompleteException {
+  public void testJsPropertySuperCallFails() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
@@ -618,12 +751,10 @@
         "}");
 
     assertBuggyFails(
-        "Cannot call property accessor 'test.EntryPoint$Super.getX()I' via super "
-            + "(test/EntryPoint.java:9).");
+        "Line 9: Cannot call property accessor 'int EntryPoint.Super.getX()' via super.");
   }
 
-  public void testJsPropertyCallSucceeds()
-      throws UnableToCompleteException {
+  public void testJsPropertyCallSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
@@ -638,7 +769,7 @@
   }
 
   public void testJsPropertyAccidentalSuperCallSucceeds()
-      throws UnableToCompleteException {
+      throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsProperty");
     addSnippetClassDecl(
@@ -655,6 +786,23 @@
     assertBuggySucceeds();
   }
 
+  public void testJsPropertyOverrideSucceeds()
+      throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetImport("jsinterop.annotations.JsProperty");
+    addSnippetClassDecl(
+        "@JsType public static class Super {",
+        "  @JsProperty public void setX(int x) {  }",
+        "  @JsProperty public int getX() { return 5; }",
+        "}",
+
+        "@JsType public static class Buggy extends Super {",
+        "  @JsProperty public void setX(int x) {  }",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
   public void testMultiplePrivateConstructorsExportSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
@@ -667,8 +815,7 @@
     assertBuggySucceeds();
   }
 
-  public void testMultiplePublicConstructorsAllDelegatesToJsConstructorSucceeds()
-      throws Exception {
+  public void testMultiplePublicConstructorsAllDelegatesToJsConstructorSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsIgnore");
     addSnippetClassDecl(
@@ -697,8 +844,8 @@
         "}");
 
     assertBuggyFails(
-        "Constructor 'test.EntryPoint$Buggy.EntryPoint$Buggy() <init>' can be a JsConstructor only "
-            + "if all constructors in the class are delegating to it.");
+        "Line 6: Constructor 'EntryPoint.Buggy.EntryPoint$Buggy()' can be a JsConstructor only if "
+            + "all constructors in the class are delegating to it.");
   }
 
   public void testMultiplePublicConstructorsExportFails() throws Exception {
@@ -713,9 +860,9 @@
         "}");
 
     assertBuggyFails(
-        "More than one JsConstructor exists for test.EntryPoint$Buggy.",
-        "'test.EntryPoint$Buggy.EntryPoint$Buggy(I) <init>' can't be "
-            + "exported because the global name 'test.EntryPoint.Buggy' is already taken.");
+        "Line 5: More than one JsConstructor exists for EntryPoint.Buggy.",
+        "Line 7: 'EntryPoint.Buggy.EntryPoint$Buggy(int)' cannot be exported because the global "
+            + "name 'test.EntryPoint.Buggy' is already taken.");
   }
 
   public void testNonCollidingAccidentalOverrideSucceeds() throws Exception {
@@ -768,7 +915,7 @@
         "  void foo();",
         "}");
 
-    assertBuggyFails("JsFunction 'test.EntryPoint$Buggy' cannot extend other interfaces.");
+    assertBuggyFails("Line 6: JsFunction 'EntryPoint.Buggy' cannot extend other interfaces.");
   }
 
   public void testJsFunctionExtendedByInterfaceFails() throws Exception {
@@ -776,8 +923,8 @@
 
     addSnippetClassDecl("public interface Buggy extends MyJsFunctionInterface {}");
 
-    assertBuggyFails("JsFunction 'test.MyJsFunctionInterface' cannot be extended by other "
-        + "interfaces:\n\ttest.EntryPoint$Buggy");
+    assertBuggyFails(
+        "Line 3: 'EntryPoint.Buggy' cannot extend JsFunction 'MyJsFunctionInterface'.");
   }
 
   public void testJsFunctionMarkedAsJsTypeFails() throws Exception {
@@ -790,7 +937,7 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy' cannot be both a JsFunction and a JsType at the same time.");
+        "Line 6: 'EntryPoint.Buggy' cannot be both a JsFunction and a JsType at the same time.");
   }
 
   public void testJsFunctionImplementationWithSingleInterfaceSucceeds() throws Exception {
@@ -812,8 +959,8 @@
         "  public int bar(int x) { return 0; }",
         "}");
 
-    assertBuggyFails("JsFunction implementation 'test.EntryPoint$Buggy' cannot implement more than "
-        + "one interface.");
+    assertBuggyFails("Line 4: JsFunction implementation 'EntryPoint.Buggy' cannot "
+        + "implement more than one interface.");
   }
 
   public void testJsFunctionImplementationWithSuperClassFails() throws Exception {
@@ -824,7 +971,8 @@
         "  public int foo(int x) { return 0; }",
         "}");
 
-    assertBuggyFails("JsFunction implementation 'test.EntryPoint$Buggy' cannot extend a class.");
+    assertBuggyFails("Line 4: JsFunction implementation 'EntryPoint.Buggy' cannot "
+        + "extend a class.");
   }
 
   public void testJsFunctionImplementationWithSubclassesFails() throws Exception {
@@ -836,8 +984,8 @@
         "public static class Buggy extends BaseClass  {",
         "}");
 
-    assertBuggyFails("Implementation of JsFunction 'test.EntryPoint$BaseClass' cannot be extended "
-        + "by other classes:\n\ttest.EntryPoint$Buggy");
+    assertBuggyFails("Line 6: 'EntryPoint.Buggy' cannot extend "
+        + "JsFunction implementation 'EntryPoint.BaseClass'.");
   }
 
   public void testJsFunctionImplementationMarkedAsJsTypeFails() throws Exception {
@@ -850,8 +998,8 @@
         "}");
 
     assertBuggyFails(
-        "'test.EntryPoint$Buggy' cannot be both a JsFunction implementation and a JsType at the "
-            + "same time.");
+        "Line 5: 'EntryPoint.Buggy' cannot be both a JsFunction implementation and a JsType "
+            + "at the same time.");
   }
 
   public void testJsFunctionStaticInitializerFails() {
@@ -865,7 +1013,7 @@
         "}");
 
     assertBuggyFails(
-        "JsFunction 'test.EntryPoint$Buggy' cannot have static initializer.");
+        "Line 6: JsFunction 'EntryPoint.Buggy' cannot have static initializer.");
   }
 
   public void testNativeJsTypeStaticInitializerFails() {
@@ -877,7 +1025,7 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType 'test.EntryPoint$Buggy' cannot have static initializer.");
+        "Line 4: Native JsType 'EntryPoint.Buggy' cannot have static initializer.");
   }
 
   public void testNativeJsTypeNonEmptyConstructorFails() {
@@ -890,8 +1038,8 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType constructor 'test.EntryPoint$Buggy.EntryPoint$Buggy(I) <init>' "
-            + "cannot have non-empty method body.");
+        "Line 5: Native JsType constructor 'EntryPoint.Buggy.EntryPoint$Buggy(int)' cannot have "
+            + "non-empty method body.");
   }
 
   public void testNativeJsTypeInstanceInitializerFails() {
@@ -904,11 +1052,11 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType constructor 'test.EntryPoint$Buggy.EntryPoint$Buggy(I) <init>' "
+        "Line 6: Native JsType constructor 'EntryPoint.Buggy.EntryPoint$Buggy(int)' "
             + "cannot have non-empty method body.");
   }
 
-  public void testNativeJsTypeImplicitSuperSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeImplicitSuperSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
@@ -923,7 +1071,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeExplicitSuperSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeExplicitSuperSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
@@ -939,7 +1087,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeExplicitSuperWithEffectSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeExplicitSuperWithEffectSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
@@ -963,7 +1111,7 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType 'test.EntryPoint$Buggy' cannot have static initializer.");
+        "Line 4: Native JsType 'EntryPoint.Buggy' cannot have static initializer.");
   }
 
   public void testNativeJsTypeInterfaceInlineInitializerFails() {
@@ -974,10 +1122,10 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType 'test.EntryPoint$Buggy' cannot have static initializer.");
+        "Line 4: Native JsType 'EntryPoint.Buggy' cannot have static initializer.");
   }
 
-  public void testNativeJsTypeCompileTimeConstantSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeCompileTimeConstantSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Buggy {",
@@ -995,8 +1143,8 @@
         "  public Buggy() { if (new Object() instanceof IBuggy) {} }",
         "}");
 
-    assertBuggyFails("Cannot do instanceof against native JsType interface test.EntryPoint$IBuggy "
-        + "(test/EntryPoint.java:6).");
+    assertBuggyFails("Line 6: Cannot do instanceof against native JsType interface "
+        + "'EntryPoint.IBuggy'.");
   }
 
   public void testNativeJsTypeEnumFails() {
@@ -1005,11 +1153,10 @@
         "@JsType(isNative=true) public enum Buggy { A, B }");
 
     assertBuggyFails(
-        "Enum 'test.EntryPoint$Buggy' cannot be a native JsType.");
+        "Line 4: Enum 'EntryPoint.Buggy' cannot be a native JsType.");
   }
 
-  public void testNativeJsTypeInterfaceCompileTimeConstantSucceeds()
-      throws UnableToCompleteException {
+  public void testNativeJsTypeInterfaceCompileTimeConstantSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Buggy {",
@@ -1019,7 +1166,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeExtendsNativeJsTypeSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeExtendsNativeJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
@@ -1030,7 +1177,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeImplementsNativeJsTypeSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeImplementsNativeJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Super {",
@@ -1041,8 +1188,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeInterfaceImplementsNativeJsTypeSucceeds()
-      throws UnableToCompleteException {
+  public void testNativeJsTypeInterfaceImplementsNativeJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Super {",
@@ -1053,7 +1199,7 @@
     assertBuggySucceeds();
   }
 
-  public void testJsOverlayOnNativeJsTypeMemberSucceeds() throws UnableToCompleteException {
+  public void testJsOverlayOnNativeJsTypeMemberSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsOverlay");
     addSnippetClassDecl(
@@ -1075,8 +1221,8 @@
         "  @JsOverlay public static final void m() { }",
         "}");
 
-    assertBuggyFails(
-        "JsOverlay method 'test.EntryPoint$Buggy.m()V' cannot be non-final, static, nor native.");
+    assertBuggyFails("Line 6: JsOverlay method 'void EntryPoint.Buggy.m()' cannot be "
+        + "non-final, static, nor native.");
   }
 
   public void testJsOverlayImplementingInterfaceMethodFails() {
@@ -1090,8 +1236,8 @@
         "  @JsOverlay public void m() { }",
         "}");
 
-    assertBuggyFails(
-        "JsOverlay method 'test.EntryPoint$Buggy.m()V' cannot override a supertype method.");
+    assertBuggyFails("Line 9: JsOverlay method 'void EntryPoint.Buggy.m()' cannot override a "
+        + "supertype method.");
   }
 
   public void testJsOverlayOverridingSuperclassMethodFails() {
@@ -1106,7 +1252,7 @@
         "}");
 
     assertBuggyFails(
-        "JsOverlay method 'test.EntryPoint$Buggy.m()V' cannot override a supertype method.");
+        "Line 9: JsOverlay method 'void EntryPoint.Buggy.m()' cannot override a supertype method.");
   }
 
   public void testJsOverlayOnNonFinalFails() {
@@ -1118,7 +1264,7 @@
         "}");
 
     assertBuggyFails(
-        "JsOverlay method 'test.EntryPoint$Buggy.m()V' cannot be non-final, static, nor native.");
+        "Line 6: JsOverlay method 'void EntryPoint.Buggy.m()' cannot be non-final, static, nor native.");
   }
 
   public void testJsOverlayOnNativeMethodFails() {
@@ -1130,10 +1276,10 @@
         "}");
 
     assertBuggyFails(
-        "JsOverlay method 'test.EntryPoint$Buggy.m()V' cannot be non-final, static, nor native.");
+        "Line 6: JsOverlay method 'void EntryPoint.Buggy.m()' cannot be non-final, static, nor native.");
   }
 
-  public void testJsOverlayOnJsoMethodSucceeds() throws UnableToCompleteException {
+  public void testJsOverlayOnJsoMethodSucceeds() throws Exception {
     addSnippetImport("com.google.gwt.core.client.JavaScriptObject");
     addSnippetImport("jsinterop.annotations.JsOverlay");
     addSnippetClassDecl(
@@ -1145,7 +1291,7 @@
     assertBuggySucceeds();
   }
 
-  public void testImplicitJsOverlayOnJsoMethodSucceeds() throws UnableToCompleteException {
+  public void testImplicitJsOverlayOnJsoMethodSucceeds() throws Exception {
     addSnippetImport("com.google.gwt.core.client.JavaScriptObject");
     addSnippetImport("jsinterop.annotations.JsOverlay");
     addSnippetClassDecl(
@@ -1166,7 +1312,7 @@
         "}");
 
     assertBuggyFails(
-        "Method 'test.EntryPoint$Buggy.m()V' in non-native type cannot be @JsOverlay.");
+        "Line 6: Method 'void EntryPoint.Buggy.m()' in non-native type cannot be @JsOverlay.");
   }
 
   public void testJsOverlayOnNonJsTypeFails() {
@@ -1177,10 +1323,10 @@
         "}");
 
     assertBuggyFails(
-        "Method 'test.EntryPoint$Buggy.m()V' in non-native type cannot be @JsOverlay.");
+        "Line 5: Method 'void EntryPoint.Buggy.m()' in non-native type cannot be @JsOverlay.");
   }
 
-  public void testJsTypeExtendsNativeJsTypeSucceeds() throws UnableToCompleteException {
+  public void testJsTypeExtendsNativeJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
@@ -1191,7 +1337,7 @@
     assertBuggySucceeds();
   }
 
-  public void testJsTypeExtendsNonJsTypeSucceeds() throws UnableToCompleteException {
+  public void testJsTypeExtendsNonJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "public static class Super {",
@@ -1202,7 +1348,7 @@
     assertBuggySucceeds();
   }
 
-  public void testJsTypeImplementsNativeJsTypeInterfaceSucceeds() throws UnableToCompleteException {
+  public void testJsTypeImplementsNativeJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Interface {",
@@ -1213,7 +1359,7 @@
     assertBuggySucceeds();
   }
 
-  public void testJsTypeImplementsNonJsTypeInterfaceSucceeds() throws UnableToCompleteException {
+  public void testJsTypeImplementsNonJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "public interface Interface {",
@@ -1224,8 +1370,7 @@
     assertBuggySucceeds();
   }
 
-  public void testJsTypeIntefaceExtendsNativeJsTypeInterfaceSucceeds()
-      throws UnableToCompleteException {
+  public void testJsTypeIntefaceExtendsNativeJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Interface {",
@@ -1237,7 +1382,7 @@
   }
 
   public void testJsTypeInterfaceExtendsNonJsTypeInterfaceSucceeds()
-      throws UnableToCompleteException {
+      throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "public interface Interface {",
@@ -1248,7 +1393,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeExtendsNaiveJsTypeSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeExtendsNaiveJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
@@ -1267,7 +1412,7 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType member 'test.EntryPoint$Buggy.f' is not public or has @JsIgnore.");
+        "Line 5: Native JsType member 'int EntryPoint.Buggy.f' is not public or has @JsIgnore.");
   }
 
   public void testNativeJsTypeJsIgnoredFieldFails() {
@@ -1279,7 +1424,7 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType member 'test.EntryPoint$Buggy.x' is not public or has @JsIgnore.");
+        "Line 6: Native JsType member 'int EntryPoint.Buggy.x' is not public or has @JsIgnore.");
   }
 
   public void testNativeJsTypeNonPublicMethodFails() {
@@ -1290,7 +1435,7 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType member 'test.EntryPoint$Buggy.m()V' is not public or has @JsIgnore.");
+        "Line 5: Native JsType member 'void EntryPoint.Buggy.m()' is not public or has @JsIgnore.");
   }
 
   public void testNativeJsTypeJsIgnoredMethodFails() {
@@ -1302,7 +1447,7 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType member 'test.EntryPoint$Buggy.m()V' is not public or has @JsIgnore.");
+        "Line 6: Native JsType member 'void EntryPoint.Buggy.m()' is not public or has @JsIgnore.");
   }
 
   public void testNativeJsTypeJsIgnoredConstructorFails() {
@@ -1314,11 +1459,22 @@
         "}");
 
     assertBuggyFails(
-        "Native JsType member 'test.EntryPoint$Buggy.EntryPoint$Buggy() <init>' "
-          + "is not public or has @JsIgnore.");
+        "Line 6: Native JsType member 'EntryPoint.Buggy.EntryPoint$Buggy()' is not public or "
+            + "has @JsIgnore.");
   }
 
-  public void testNativeJsTypeNonPublicConstructorSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeMutlipleConstructorSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@JsType(isNative=true) static class Buggy {",
+        "  public Buggy(int i) { }",
+        "  public Buggy() { }",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testNativeJsTypeNonPublicConstructorSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) static class Buggy {",
@@ -1328,7 +1484,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNativeJsTypeDefaultConstructorSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeDefaultConstructorSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) static class Buggy {",
@@ -1337,7 +1493,86 @@
     assertBuggySucceeds();
   }
 
-  public void testNonJsTypeExtendsJsTypeSucceeds() throws UnableToCompleteException {
+  public void testNativeJsTypeInstanceMethodOverloadSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@SuppressWarnings(\"unusable-by-js\")",
+        "@JsType(isNative=true) public static class Buggy {",
+        "  public native void m(Object o);",
+        "  public native void m(Object[] o);",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testNativeJsTypeStaticMethodOverloadSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@SuppressWarnings(\"unusable-by-js\")",
+        "@JsType(isNative=true) public static class Buggy {",
+        "  public static native void m(Object o);",
+        "  public static native void m(Object[] o);",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testNonJsTypeExtendingNativeJsTypeWithInstanceMethodSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@SuppressWarnings(\"unusable-by-js\")",
+        "@JsType(isNative=true) public static class Super {",
+        "  public native void m(Object o);",
+        "  public native void m(Object[] o);",
+        "}",
+        "@JsType public static class Buggy extends Super {",
+        "  public void n(Object o) { }",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testNonJsTypeExtendingNativeJsTypeWithInstanceMethodOverloadsFails() {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@JsType(isNative=true) public static class Super {",
+        "  public native void m(Object o);",
+        "  public native void m(int o);",
+        "}",
+        "public static class Buggy extends Super {",
+        "  public void m(Object o) { }",
+        "}");
+
+    assertBuggyFails(
+        "Line 9: 'void EntryPoint.Buggy.m(Object)' and 'void EntryPoint.Super.m(int)' "
+            + "cannot both use the same JavaScript name 'm'.");
+  }
+
+  public void testNonJsTypeWithNativeStaticMethodOverloadsSucceeds() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsMethod");
+    addSnippetClassDecl(
+        "public static class Buggy {",
+        "  @JsMethod public static native void m(Object o);",
+        "  @JsMethod public static native void m(int o);",
+        "}");
+
+    assertBuggySucceeds();
+  }
+
+  public void testNonJsTypeWithNativeInstanceMethodOverloadsFails() throws Exception {
+    addSnippetImport("jsinterop.annotations.JsMethod");
+    addSnippetClassDecl(
+        "public static class Buggy {",
+        "  @JsMethod public native void m(Object o);",
+        "  @JsMethod public void m(int o) { }",
+        "}");
+
+    assertBuggyFails(
+        "Line 6: 'void EntryPoint.Buggy.m(int)' and 'void EntryPoint.Buggy.m(Object)' "
+            + "cannot both use the same JavaScript name 'm'.");
+  }
+
+  public void testNonJsTypeExtendsJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType public static class Super {",
@@ -1348,7 +1583,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNonJsTypeImplementsJsTypeInterfaceSucceeds() throws UnableToCompleteException {
+  public void testNonJsTypeImplementsJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType public interface Interface {",
@@ -1359,8 +1594,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNonJsTypeInterfaceExtendsJsTypeInterfaceSucceeds()
-      throws UnableToCompleteException {
+  public void testNonJsTypeInterfaceExtendsJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType public interface Interface {",
@@ -1371,20 +1605,20 @@
     assertBuggySucceeds();
   }
 
-  public void testNonJsTypeExtendsNativeJsTypeSucceeds()
-      throws UnableToCompleteException {
+  public void testNonJsTypeExtendsNativeJsTypeSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public static class Super {",
+        "  public native void m();",
         "}",
         "public static class Buggy extends Super {",
+        "  public void m() { }",
         "}");
 
     assertBuggySucceeds();
   }
 
-  public void testNonJsTypeImplementsNativeJsTypeInterfaceSucceeds()
-      throws UnableToCompleteException {
+  public void testNonJsTypeImplementsNativeJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Interface {",
@@ -1395,8 +1629,7 @@
     assertBuggySucceeds();
   }
 
-  public void testNonJsTypeInterfaceExtendsNativeJsTypeInterfaceSucceeds()
-      throws UnableToCompleteException {
+  public void testNonJsTypeInterfaceExtendsNativeJsTypeInterfaceSucceeds() throws Exception {
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetClassDecl(
         "@JsType(isNative=true) public interface Interface {",
@@ -1469,7 +1702,7 @@
     assertBuggySucceeds();
   }
 
-  public void testUnusuableByJsFails() throws Exception {
+  public void testUnusuableByJsWarns() throws Exception {
     addSnippetImport("jsinterop.annotations.JsFunction");
     addSnippetImport("jsinterop.annotations.JsType");
     addSnippetImport("jsinterop.annotations.JsMethod");
@@ -1499,44 +1732,59 @@
         "}");
 
     assertBuggySucceeds(
-        "[unusable-by-js] Return type of "
-            + "'test.EntryPoint$Buggy.f1(Ltest/EntryPoint$A;)Ltest/EntryPoint$A;' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Return type of "
-            + "'test.EntryPoint$Buggy.f2([Ltest/EntryPoint$A;)[Ltest/EntryPoint$A;' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Return type of "
-            + "'test.EntryPoint$Buggy.f3(J)J' is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Return type of "
-            + "'test.EntryPoint$Buggy.f4(Ltest/EntryPoint$B;)Ltest/EntryPoint$B;' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of field 'field' in type 'test.EntryPoint$Buggy' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method "
-            + "'test.EntryPoint$Buggy.f1(Ltest/EntryPoint$A;)Ltest/EntryPoint$A;' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method "
-            + "'test.EntryPoint$Buggy.f2([Ltest/EntryPoint$A;)[Ltest/EntryPoint$A;' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method 'test.EntryPoint$Buggy.f3(J)J' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method "
-            + "'test.EntryPoint$Buggy.f4(Ltest/EntryPoint$B;)Ltest/EntryPoint$B;' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method "
-            + "'test.EntryPoint$Buggy.f5([[Ljava/lang/Object;)V' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method "
-            + "'test.EntryPoint$Buggy.f6([Ljava/lang/Object;)V' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method " // JsFunction method
-            + "'test.EntryPoint$FI.f(Ltest/EntryPoint$A;)V' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of parameter 'a' in method " // JsMethod in non-jstype class.
-            + "'test.EntryPoint$C.fc1(Ltest/EntryPoint$A;)V' "
-            + "is not usable by but exposed to JavaScript",
-        "[unusable-by-js] Type of field 'a' in type " // JsProperty in non-jstype class.
-            + "'test.EntryPoint$D' is not usable by but exposed to JavaScript");
+        "Line 21: [unusable-by-js] Return type of 'EntryPoint.A EntryPoint.Buggy.f1(EntryPoint.A)' "
+            + "is not usable by but exposed to JavaScript.",
+        "Line 22: [unusable-by-js] Return type of "
+            + "'EntryPoint.A[] EntryPoint.Buggy.f2(EntryPoint.A[])' is not usable by but "
+            + "exposed to JavaScript.",
+        "Line 23: [unusable-by-js] Return type of 'long EntryPoint.Buggy.f3(long)' is not "
+            + "usable by but exposed to JavaScript.",
+        "Line 24: [unusable-by-js] Return type of 'EntryPoint.B EntryPoint.Buggy.f4(EntryPoint.B)' "
+            + "is not usable by but exposed to JavaScript.",
+        "Line 20: [unusable-by-js] Type of field 'field' in type 'EntryPoint.Buggy' "
+            + "is not usable by but exposed to JavaScript.",
+        "Line 21: [unusable-by-js] Type of parameter 'a' in method "
+            + "'EntryPoint.A EntryPoint.Buggy.f1(EntryPoint.A)' is not usable by but "
+            + "exposed to JavaScript.",
+        "Line 22: [unusable-by-js] Type of parameter 'a' in method "
+            + "'EntryPoint.A[] EntryPoint.Buggy.f2(EntryPoint.A[])' is not usable by but "
+            + "exposed to JavaScript.",
+        "Line 23: [unusable-by-js] Type of parameter 'a' in method "
+            + "'long EntryPoint.Buggy.f3(long)' is not usable by but exposed to JavaScript.",
+        "Line 24: [unusable-by-js] Type of parameter 'a' in method "
+            + "'EntryPoint.B EntryPoint.Buggy.f4(EntryPoint.B)' is not usable by but "
+            + "exposed to JavaScript.",
+        "Line 25: [unusable-by-js] Type of parameter 'a' in method "
+            + "'void EntryPoint.Buggy.f5(Object[][])' is not usable by but exposed to JavaScript.",
+        "Line 26: [unusable-by-js] Type of parameter 'a' in method "
+            + "'void EntryPoint.Buggy.f6(Object[])' is not usable by but exposed to JavaScript.",
+        "Line 18: [unusable-by-js] Type of parameter 'a' in method "
+            + "'void EntryPoint.FI.f(EntryPoint.A)' is not usable by but exposed to JavaScript.",
+        "Line 12: [unusable-by-js] Type of parameter 'a' in method "
+            // JsMethod in non-jstype class.
+            + "'void EntryPoint.C.fc1(EntryPoint.A)' is not usable by but exposed to JavaScript.",
+        "Line 16: [unusable-by-js] Type of field 'a' in type " // JsProperty in non-jstype class.
+            + "'EntryPoint.D' is not usable by but exposed to JavaScript.");
+  }
+
+  public void testUnusableByJsAccidentalOverrideSuppressionWarns()
+      throws Exception {
+    addSnippetImport("jsinterop.annotations.JsType");
+    addSnippetClassDecl(
+        "@JsType",
+        "public static interface Foo {",
+        "  @SuppressWarnings(\"unusable-by-js\") ",
+        "  void doIt(Class foo);",
+        "}",
+        "public static class Parent {",
+        "  public void doIt(Class x) {}",
+        "}",
+        "public static class Buggy extends Parent implements Foo {}");
+
+    assertBuggySucceeds(
+        "Line 10: [unusable-by-js] Type of parameter 'x' in method "
+            + "'void EntryPoint.Parent.doIt(Class)' (exposed by 'EntryPoint.Buggy') is not usable "
+            + "by but exposed to JavaScript.");
   }
 
   private static final MockJavaResource jsFunctionInterface = new MockJavaResource(
@@ -1554,21 +1802,31 @@
   };
 
   public final void assertBuggySucceeds(String... expectedWarnings)
-      throws UnableToCompleteException {
-    Result result = assertCompileSucceeds("Buggy buggy = null;", expectedWarnings);
+      throws Exception {
+    List<String> allWarnings = Lists.newArrayList();
+    if (expectedWarnings.length > 0) {
+      allWarnings.add("Warnings in test/EntryPoint.java");
+      allWarnings.addAll(Arrays.asList(expectedWarnings));
+    }
+    Result result = assertCompileSucceeds("Buggy buggy = null;",
+        allWarnings.toArray(new String[0]));
     assertNotNull(result.findClass("test.EntryPoint$Buggy"));
   }
 
   public final void assertBuggyFails(String... expectedErrors) {
     assertTrue(expectedErrors.length > 0);
-    assertCompileFails("Buggy buggy = null;", expectedErrors);
+
+    List<String> allErrors = Lists.newArrayList();
+    allErrors.add("Errors in test/EntryPoint.java");
+    allErrors.addAll(Arrays.asList(expectedErrors));
+    assertCompileFails("Buggy buggy = null;", allErrors.toArray(new String[0]));
   }
 
   @Override
   protected boolean doOptimizeMethod(TreeLogger logger, JProgram program, JMethod method) {
     try {
       JsInteropRestrictionChecker.exec(logger, program, new MinimalRebuildCache());
-    } catch (UnableToCompleteException e) {
+    } catch (Exception e) {
       throw new RuntimeException(e);
     }
     return false;
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/UnifyAstTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/UnifyAstTest.java
index 305e3f1..9938f40 100644
--- a/dev/core/test/com/google/gwt/dev/jjs/impl/UnifyAstTest.java
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/UnifyAstTest.java
@@ -20,6 +20,7 @@
 import com.google.gwt.dev.javac.testing.impl.JavaResourceBase;
 import com.google.gwt.dev.javac.testing.impl.MockJavaResource;
 import com.google.gwt.dev.jjs.ast.JClassType;
+import com.google.gwt.dev.jjs.ast.JDeclaredType;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.util.arg.SourceLevel;
@@ -92,6 +93,28 @@
     assertOverrides(result, "b.E.m1()Lb/E;");
   }
 
+  public void testOverrides_orderInOverriddenSet() throws Exception {
+    addAll(A_A, A_I, A_J, A_B, B_C, B_D, B_E);
+    Result result = optimize("void", "");
+
+    for (JDeclaredType type : result.getOptimizedProgram().getDeclaredTypes()) {
+      for (JMethod method : type.getMethods()) {
+        JavaAstVerifier.assertCorrectOverriddenOrder(result.getOptimizedProgram(), method);
+      }
+    }
+  }
+
+  public void testOverrides_orderInOverridingnSet() throws Exception {
+    addAll(A_A, A_I, A_J, A_B, B_C, B_D, B_E);
+    Result result = optimize("void", "");
+
+    for (JDeclaredType type : result.getOptimizedProgram().getDeclaredTypes()) {
+      for (JMethod method : type.getMethods()) {
+        JavaAstVerifier.assertCorrectOverridingOrder(result.getOptimizedProgram(), method);
+      }
+    }
+  }
+
   public void testOverrides_packagePrivate() throws Exception {
     addAll(A_A, A_I, A_J, A_B, B_C, B_D, B_E);
     Result result = optimize("void", "");
diff --git a/dev/core/test/com/google/gwt/dev/util/UnitTestTreeLogger.java b/dev/core/test/com/google/gwt/dev/util/UnitTestTreeLogger.java
index 7e38525..b57a254 100644
--- a/dev/core/test/com/google/gwt/dev/util/UnitTestTreeLogger.java
+++ b/dev/core/test/com/google/gwt/dev/util/UnitTestTreeLogger.java
@@ -17,6 +17,7 @@
 
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.thirdparty.guava.common.collect.ComparisonChain;
+import com.google.gwt.thirdparty.guava.common.collect.Lists;
 
 import junit.framework.Assert;
 
@@ -148,6 +149,17 @@
       return type;
     }
 
+    public boolean equals(Object other) {
+      if (!(other instanceof LogEntry)) {
+        return false;
+      }
+      return this.toString().equals(other.toString());
+    }
+
+    public int hashCode() {
+      return toString().hashCode();
+    }
+
     @Override
     public String toString() {
       StringBuilder sb = new StringBuilder();
@@ -248,7 +260,11 @@
     Collections.sort(actualEntries);
 
     if (expectedEntries.size() != actualEntries.size()) {
-      Assert.fail("Wrong log count: expected=" + expectedEntries + ", actual=" + actualEntries);
+      List<LogEntry> missingEntries = Lists.newArrayList(expectedEntries);
+      missingEntries.removeAll(actualEntries);
+      List<LogEntry> unexpectedEntries = Lists.newArrayList(actualEntries);
+      unexpectedEntries.removeAll(expectedEntries);
+      Assert.fail("Wrong log count: missing=" + missingEntries + ", unexpected=" + unexpectedEntries);
     }
 
     for (int i = 0; i < expectedEntries.size(); ++i) {