diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/CodeSplitter.java b/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/CodeSplitter.java
index 418b186..baa6e4d 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/CodeSplitter.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/CodeSplitter.java
@@ -216,7 +216,7 @@
   private final TreeLogger logger;
   private final boolean logFragmentMap;
   private final JavaToJavaScriptMap map;
-  private final Set<JMethod> methodsInJavaScript;
+  private final Set<JMethod> methodsStillInJavaScript;
 
   private final List<Fragment> fragments = Lists.newArrayList();
 
@@ -238,7 +238,7 @@
 
     initiallyLiveCfa = computeInitiallyLive(jprogram, dependencyRecorder);
 
-    methodsInJavaScript = fragmentExtractor.findAllMethodsInJavaScript();
+    methodsStillInJavaScript = fragmentExtractor.findAllMethodsStillInJavaScript();
 
     // TODO(rluble): expected fragment count is not enforced. the actual number
     // of fragments may be more or less....
@@ -341,7 +341,7 @@
         computeNotExclusiveCfaForFragments(exclusiveFragments);
     ExclusivityMap exclusivityMap =  ExclusivityMap.computeExclusivityMap(exclusiveFragments,
         completeCfa, notExclusiveCfaByFragment);
-    exclusivityMap.fixUpLoadOrderDependencies(logger, jprogram, methodsInJavaScript);
+    exclusivityMap.fixUpLoadOrderDependencies(logger, jprogram, methodsStillInJavaScript);
     return exclusivityMap;
   }
 
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/ExclusivityMap.java b/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/ExclusivityMap.java
index 02e72bd..7e13e74 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/ExclusivityMap.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/ExclusivityMap.java
@@ -25,7 +25,9 @@
 import com.google.gwt.dev.jjs.ast.JNode;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.ast.JRunAsync;
+import com.google.gwt.dev.jjs.ast.JType;
 import com.google.gwt.dev.jjs.ast.JVisitor;
+import com.google.gwt.dev.jjs.ast.js.JsniMethodRef;
 import com.google.gwt.dev.jjs.impl.ControlFlowAnalyzer;
 import com.google.gwt.dev.js.ast.JsStatement;
 import com.google.gwt.thirdparty.guava.common.base.Predicates;
@@ -156,21 +158,34 @@
   private Map<JDeclaredType, Fragment> fragmentForType = Maps.newHashMap();
 
   /**
-   * Traverse {@code exp} and find all referenced JFields.
+   * Traverse {@code exp} and find all referenced class literals.
    */
-  private static Set<JClassLiteral> classLiteralsIn(JExpression exp) {
+  private static Set<JClassLiteral> classLiteralsIn(JExpression expression) {
     final Set<JClassLiteral> literals = Sets.newHashSet();
-    class ClassLiteralFinder extends JVisitor {
+    new JVisitor() {
       @Override
       public void endVisit(JClassLiteral classLiteral, Context ctx) {
         literals.add(classLiteral);
       }
-    }
-    (new ClassLiteralFinder()).accept(exp);
+    }.accept(expression);
     return literals;
   }
 
   /**
+   * Traverse {@code exp} and find all referenced JMethods.
+   */
+  private static Set<JMethod> methodsReferencesIn(JExpression expression) {
+    final Set<JMethod> methods = Sets.newHashSet();
+    new JVisitor() {
+      @Override
+      public void endVisit(JsniMethodRef jsniMethodRef, Context ctx) {
+        methods.add(jsniMethodRef.getTarget());
+      }
+    }.accept(expression);
+    return methods;
+  }
+
+  /**
    * Map atoms to exclusive fragments. Do this by trying to find code atoms that
    * are only needed by a single split point. Such code can be moved to the
    * exclusively live fragment associated with that split point.
@@ -217,10 +232,10 @@
    * </p>
    */
   public void fixUpLoadOrderDependencies(TreeLogger logger, JProgram jprogram,
-      Set<JMethod> methodsInJavaScript) {
-    fixUpLoadOrderDependenciesForMethods(logger, jprogram, methodsInJavaScript);
+      Set<JMethod> methodsStillInJavaScript) {
+    fixUpLoadOrderDependenciesForMethods(logger, jprogram, methodsStillInJavaScript);
     fixUpLoadOrderDependenciesForTypes(logger, jprogram);
-    fixUpLoadOrderDependenciesForClassLiterals(logger, jprogram);
+    fixUpLoadOrderDependenciesForClassLiterals(logger, jprogram, methodsStillInJavaScript);
   }
 
   /**
@@ -263,7 +278,8 @@
    * Make sure that the strings are available for all class literals at the time they are
    * loaded and make sure that superclass class literals are loaded before.
    */
-  private void fixUpLoadOrderDependenciesForClassLiterals(TreeLogger logger, JProgram jprogram) {
+  private void fixUpLoadOrderDependenciesForClassLiterals(
+      TreeLogger logger, JProgram jprogram, Set<JMethod> methodsStillInJavaScript) {
     int numFixups = 0;
     /**
      * Consider all static fields of ClassLiteralHolder; the majority if not all its static
@@ -280,31 +296,61 @@
       }
 
       Fragment classLiteralFragment = fragmentForField.get(field);
+
+      // In -XenableClosureFormat creation of class literals needs to happen before or with class
+      // definition. This fixup takes care when it is not the case.
+      JType type = jprogram.getTypeByClassLiteralField(field);
+      Fragment classLiteralTypeFragment = fragmentForType.get(type);
+      if (!canReferenceAtomsFrom(classLiteralTypeFragment, classLiteralFragment)) {
+        numFixups++;
+        fragmentForField.put(field, NOT_EXCLUSIVE);
+        classLiteralFragment = NOT_EXCLUSIVE;
+      }
+
       JExpression initializer = field.getInitializer();
 
-      // Fixup the class literals.
+      // Fixup the superclass class literals.
       for (JClassLiteral superclassClassLiteral : classLiteralsIn(initializer)) {
         JField superclassClassLiteralField = superclassClassLiteral.getField();
         // Fix the super class literal and add it to the reexamined.
         Fragment superclassClassLiteralFragment = fragmentForField.get(superclassClassLiteralField);
-        if (!fragmentsAreConsistent(classLiteralFragment, superclassClassLiteralFragment)) {
+        if (!canReferenceAtomsFrom(classLiteralFragment, superclassClassLiteralFragment)) {
           numFixups++;
           fragmentForField.put(superclassClassLiteralField, NOT_EXCLUSIVE);
-          // Add the field back so that its superclass classliteral gets fixed if necessary.
+          // Add the field back so that its superclass class literal gets fixed if necessary.
           potentialClassLiteralFields.add(superclassClassLiteralField);
         }
       }
+
+      // If there are references to methods move those as well. In particular the enum class
+      // literals reference the static methods values() and valueOf() for the particular enum type
+      // those methods need to be defined before the class literal.
+      for (JMethod referencedMethod : methodsReferencesIn(initializer)) {
+        // Move the referenced methods if necessary.
+        Fragment referencedMethodFragment = fragmentForMethod.get(referencedMethod);
+        if (methodsStillInJavaScript.contains(referencedMethod)
+            && !canReferenceAtomsFrom(classLiteralFragment, referencedMethodFragment)) {
+          assert referencedMethod.isStatic();
+          numFixups++;
+          fragmentForMethod.put(referencedMethod, NOT_EXCLUSIVE);
+        }
+      }
     }
+
     logger.log(TreeLogger.DEBUG, "Fixed up load-order dependencies by moving " +
         numFixups + " fields in class literal constructors to fragment 0, out of " +
         numClassLiterals);
   }
 
   /**
-   * Fixes up the load-order dependencies from instance methods to their enclosing types.
+   * Fixes up the load-order dependencies from instance methods to their enclosing types, in some
+   * cases there is some freedom to place instance methods in one of two or more exclusive
+   * fragment. That scenario arises when an instance method is only accessible after two or
+   * more exclusive fragments have been loaded. In such scenario this fixup will move the method
+   * to the fragment where the type is instantiated.
    */
   private void fixUpLoadOrderDependenciesForMethods(TreeLogger logger, JProgram jprogram,
-      Set<JMethod> methodsInJavaScript) {
+      Set<JMethod> methodsStillInJavaScript) {
     int numFixups = 0;
 
     for (JDeclaredType type : jprogram.getDeclaredTypes()) {
@@ -313,11 +359,11 @@
         continue;
       }
       /*
-      * If the type is in an exclusive fragment, all its instance methods
-      * must be in the same one.
+      * If the type is in an exclusive fragment, all its instance methods must be in the same one;
+      * if this is not the case move the type to the NOT_EXCLUSIVE fragment.
       */
       for (JMethod method : type.getMethods()) {
-        if (method.needsDynamicDispatch() && methodsInJavaScript.contains(method)
+        if (method.needsDynamicDispatch() && methodsStillInJavaScript.contains(method)
             && typeFrag != fragmentForMethod.get(method)) {
           fragmentForType.put(type, NOT_EXCLUSIVE);
           numFixups++;
@@ -345,7 +391,7 @@
       if (type.getSuperClass() != null) {
         Fragment typeFrag = fragmentForType.get(type);
         Fragment supertypeFrag = fragmentForType.get(type.getSuperClass());
-        if (!fragmentsAreConsistent(typeFrag, supertypeFrag)) {
+        if (!canReferenceAtomsFrom(typeFrag, supertypeFrag)) {
           numFixups++;
           fragmentForType.put(type.getSuperClass(), NOT_EXCLUSIVE);
           typesToCheck.add(type.getSuperClass());
@@ -364,7 +410,7 @@
   /**
    * Returns true if atoms in thatFragment are visible from thisFragment.
    */
-  private static boolean fragmentsAreConsistent(Fragment thisFragment, Fragment thatFragment) {
+  private static boolean canReferenceAtomsFrom(Fragment thisFragment, Fragment thatFragment) {
     return thisFragment == null || thisFragment == thatFragment || !thatFragment.isExclusive();
   }
 
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/FragmentExtractor.java b/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/FragmentExtractor.java
index 507518e..19ad75f 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/FragmentExtractor.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/codesplitter/FragmentExtractor.java
@@ -261,7 +261,7 @@
    * Find all Java methods that still exist in the resulting JavaScript, even
    * after JavaScript inlining and pruning.
    */
-  public Set<JMethod> findAllMethodsInJavaScript() {
+  public Set<JMethod> findAllMethodsStillInJavaScript() {
     Set<JMethod> methodsInJs = new HashSet<JMethod>();
     for (int fragment = 0; fragment < jsprogram.getFragmentCount(); fragment++) {
       for (JsStatement statement : jsprogram.getFragmentBlock(fragment).getStatements()) {