diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/ImplementClassLiteralsAsFields.java b/dev/core/src/com/google/gwt/dev/jjs/impl/ImplementClassLiteralsAsFields.java
index eabb035..11d373a 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/ImplementClassLiteralsAsFields.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/ImplementClassLiteralsAsFields.java
@@ -328,7 +328,8 @@
         return;
       }
 
-      JsniMethodBody newBody = new JsniMethodBody(jsniMethodBody.getSourceInfo(), jsniMethodBody.getFunc(),
+      JsniMethodBody newBody =
+          new JsniMethodBody(jsniMethodBody.getSourceInfo(), jsniMethodBody.getFunc(),
           Lists.newArrayList(newClassRefs), jsniMethodBody.getJsniFieldRefs(),
           jsniMethodBody.getJsniMethodRefs(), jsniMethodBody.getUsedStrings());
 
@@ -356,7 +357,8 @@
   private ImplementClassLiteralsAsFields(JProgram program, boolean shouldOptimize) {
     this.program = program;
     this.typeClassLiteralHolder = program.getTypeClassLiteralHolder();
-    this.classLiteralHolderClinitBody = (JMethodBody) typeClassLiteralHolder.getClinitMethod().getBody();
+    this.classLiteralHolderClinitBody =
+        (JMethodBody) typeClassLiteralHolder.getClinitMethod().getBody();
     this.shouldOptimize = shouldOptimize;
     assert program.getDeclaredTypes().contains(typeClassLiteralHolder);
   }
@@ -365,7 +367,17 @@
     if (!(type instanceof JClassType) ||  ((JClassType) type).getSuperClass() == null) {
       return JNullLiteral.INSTANCE;
     }
-    return createDependentClassLiteral(info, ((JClassType) type).getSuperClass());
+
+    JClassType superClass = ((JClassType) type).getSuperClass();
+
+    if (superClass.isJsNative()) {
+      // Class object for subclasses of native JsType will return Object.class as their super class
+      // class literal; this is done so that in invariant that "super" class literals are literals
+      // of a actual superclass.
+      superClass = program.getTypeJavaLangObject();
+    }
+
+    return createDependentClassLiteral(info, superClass);
   }
 
   private JClassLiteral createDependentClassLiteral(SourceInfo info, JType type) {
diff --git a/dev/core/src/com/google/gwt/dev/js/ast/JavaScriptVerifier.java b/dev/core/src/com/google/gwt/dev/js/ast/JavaScriptVerifier.java
index 834d70f..221658e 100644
--- a/dev/core/src/com/google/gwt/dev/js/ast/JavaScriptVerifier.java
+++ b/dev/core/src/com/google/gwt/dev/js/ast/JavaScriptVerifier.java
@@ -18,6 +18,10 @@
 
 import com.google.gwt.dev.jjs.impl.JavaToJavaScriptMap;
 import com.google.gwt.dev.js.JsUtils;
+import com.google.gwt.dev.js.ast.JsVars.JsVar;
+import com.google.gwt.thirdparty.guava.common.collect.Sets;
+
+import java.util.Set;
 
 /**
  * Verifies that the JavaScript AST and the map are consistent.
@@ -28,6 +32,68 @@
     if (!JavaScriptVerifier.class.desiredAssertionStatus()) {
       return;
     }
+    verifyTopLevelMethodMapping(jsProgram, map);
+    verifyGlobalNameOrdering(jsProgram, map);
+  }
+
+  private static void verifyGlobalNameOrdering(JsProgram jsProgram, final JavaToJavaScriptMap map) {
+    final Set<JsName> declaredEntities = Sets.newHashSet();
+    new JsVisitor() {
+      @Override
+      public boolean visit(JsFunction x, JsContext ctx) {
+        declaredEntities.add(x.getName());
+        // Do not examine function bodies.
+        return false;
+      }
+    }.accept(jsProgram);
+
+    new JsVisitor() {
+      @Override
+      public boolean visit(JsFunction x, JsContext ctx) {
+        // Do not examine function bodies.
+        return false;
+      }
+
+      @Override
+      public boolean visit(JsVars x, JsContext ctx) {
+        for (JsVar var : x) {
+          declaredEntities.add(var.getName());
+        }
+        return true;
+      }
+
+      @Override
+      public boolean visit(JsBinaryOperation x, JsContext ctx) {
+        if (x.getOperator().isAssignment()) {
+          JsNameRef nameRef = (JsNameRef) x.getArg1();
+          if (nameRef.getQualifier() == null) {
+            declaredEntities.add(nameRef.getName());
+          }
+        }
+        return true;
+      }
+
+      @Override
+      public boolean visit(JsObjectLiteral x, JsContext ctx) {
+        for (JsPropertyInitializer propertyInitializer : x.getPropertyInitializers()) {
+          accept(propertyInitializer.getValueExpr());
+        }
+        return false;
+      }
+
+      @Override
+      public void endVisit(JsNameRef x, JsContext ctx) {
+        if (x.getQualifier() != null || !x.getName().isObfuscatable()) {
+          return;
+        }
+        assert declaredEntities.contains(x.getName()) : x.getName() + " reference found before " +
+            " definition.";
+        map.nameToField(x.getName());
+      }
+    }.accept(jsProgram);
+  }
+
+  public static void verifyTopLevelMethodMapping(JsProgram jsProgram, JavaToJavaScriptMap map) {
     for (JsProgramFragment fragment : jsProgram.getFragments()) {
       for (JsStatement statement : fragment.getGlobalBlock().getStatements()) {
         JsFunction function = JsUtils.isFunctionDeclaration(statement);
diff --git a/dev/core/test/com/google/gwt/dev/CompilerTest.java b/dev/core/test/com/google/gwt/dev/CompilerTest.java
index d5f5848..8ee48b2 100644
--- a/dev/core/test/com/google/gwt/dev/CompilerTest.java
+++ b/dev/core/test/com/google/gwt/dev/CompilerTest.java
@@ -1028,7 +1028,7 @@
         Lists.newArrayList(moduleResource, testEntryPoint, someJsFunction,
             jsFunctionInterfaceImplementation, someInterface),
         new MinimalRebuildCache(), emptySet, JsOutputOption.DETAILED);
-    // Make sure the referenced class literals ends up beign included in the resulting JS.
+    // Make sure the referenced class literals ends up being included in the resulting JS.
     String classliteralHolderVarName =
         JjsUtils.mangleMemberName("com.google.gwt.lang.ClassLiteralHolder",
             JjsUtils.classLiteralFieldNameFromJavahTypeSignatureName(
@@ -1422,6 +1422,55 @@
     assertDeterministicBuild(HELLO_MODULE, 9);
   }
 
+  public void testSuccessfulCompile_jsoClassLiteralOrder() throws Exception {
+    // Crafted resource to make sure the a native subclass is compiled before the JSO class,
+    // In the case of native sublcasses the class hierarchy does not match the class literal
+    // hierarchy.
+    MockJavaResource nativeClassAndSubclass =
+        JavaResourceBase.createMockJavaResource(
+            "com.foo.MyNativeSubclass",
+            "package com.foo;",
+            "import jsinterop.annotations.JsType;",
+            "@JsType(isNative=true)",
+            "class NativeClass {",
+            "}",
+            "public class MyNativeSubclass extends NativeClass {",
+            "}");
+
+    MockJavaResource testEntryPoint =
+        JavaResourceBase.createMockJavaResource(
+            "com.foo.MyEntryPoint",
+            "package com.foo;",
+            "import com.foo.MyNativeSubclass;",
+            "public class MyEntryPoint extends MyNativeSubclass {",
+            "  public void onModuleLoad() {",
+            "    Object o = new Object();",
+            "    if (MyNativeSubclass.class.getName() == null) ",
+            "      o = new MyNativeSubclass();",
+            // Make .clazz reachable so that class literals are emmitted with the respective
+            // classses.
+            "    o.getClass();",
+            "  }",
+            "}");
+
+    MockResource moduleResource =
+        JavaResourceBase.createMockResource(
+            "com/foo/MyEntryPoint.gwt.xml",
+            "<module>",
+            "  <source path=''/>",
+            "  <entry-point class='com.foo.MyEntryPoint'/>",
+            "</module>");
+
+    CompilerOptions compilerOptions = new CompilerOptionsImpl();
+    // Make sure it compiles successfully with no assertions
+    compilerOptions.setEnableAssertions(true);
+    compilerOptions.setGenerateJsInteropExports(true);
+    compilerOptions.setOutput(JsOutputOption.PRETTY);
+    compilerOptions.setOptimizationLevel(9);
+    assertCompileSucceeds(compilerOptions, testEntryPoint.getTypeName(),
+        Lists.newArrayList(moduleResource, nativeClassAndSubclass, testEntryPoint));
+  }
+
   // TODO(stalcup): add recompile tests for file deletion.
 
   public void testIncrementalRecompile_noop() throws UnableToCompleteException, IOException,
@@ -2245,6 +2294,64 @@
             "com.foo.FooReplacementTwo"), outputOption);
   }
 
+  private void assertCompileSucceeds(CompilerOptions options, String moduleName,
+      List<MockResource> applicationResources) throws Exception {
+    File compileWorkDir = Utility.makeTemporaryDirectory(null, moduleName);
+    final CompilerOptionsImpl compilerOptions = new CompilerOptionsImpl(options);
+    PrintWriterTreeLogger logger = new PrintWriterTreeLogger();
+    logger.setMaxDetail(TreeLogger.ERROR);
+
+    String oldPersistentUnitCacheValue =
+        System.setProperty(UnitCacheSingleton.GWT_PERSISTENTUNITCACHE, "false");
+    try {
+
+      File applicationDir = Files.createTempDir();
+      Thread.sleep(1001);
+      // We might be reusing the same application dir but we want to make sure that the output dir
+      // is clean to avoid confusion when returning the output JS.
+      File outputDir = new File(applicationDir.getPath() + File.separator + moduleName);
+      if (outputDir.exists()) {
+        Util.recursiveDelete(outputDir, true);
+      }
+
+      // Fake out the resource loader to read resources both from the normal classpath as well as
+      // this new application directory.
+      ResourceLoader resourceLoader = ResourceLoaders.forClassLoader(Thread.currentThread());
+      resourceLoader =
+          ResourceLoaders.forPathAndFallback(ImmutableList.of(applicationDir), resourceLoader);
+
+      // Setup options to perform a per-file compile, output to this new application directory and
+      // compile the given module.
+      compilerOptions.setGenerateJsInteropExports(true);
+      compilerOptions.setWarDir(applicationDir);
+      compilerOptions.setModuleNames(ImmutableList.of(moduleName));
+
+      // Write the Java/XML/etc resources that make up the test application.
+      for (MockResource applicationResource : applicationResources) {
+        writeResourceTo(applicationResource, applicationDir);
+      }
+
+      // Cause the module to be cached with a reference to the prefixed resource loader so that the
+      // compile process will see those resources.
+      ModuleDefLoader.clearModuleCache();
+      ModuleDefLoader.loadFromResources(logger, moduleName, resourceLoader, true);
+
+      options.addModuleName(moduleName);
+      options.setWarDir(new File(compileWorkDir, "war"));
+      options.setExtraDir(new File(compileWorkDir, "extra"));
+
+      // Run the compiler once here.
+      new Compiler(options).run(logger);
+    } finally {
+      Util.recursiveDelete(compileWorkDir, false);
+      if (oldPersistentUnitCacheValue == null) {
+        System.clearProperty(UnitCacheSingleton.GWT_PERSISTENTUNITCACHE);
+      } else {
+        System.setProperty(UnitCacheSingleton.GWT_PERSISTENTUNITCACHE, oldPersistentUnitCacheValue);
+      }
+    }
+  }
+
   private void assertDeterministicBuild(String topLevelModule, int optimizationLevel)
       throws UnableToCompleteException, IOException {