diff --git a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
index d99c393..874fc6f 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -42,14 +42,12 @@
 import com.google.gwt.dev.jjs.ast.JClassType;
 import com.google.gwt.dev.jjs.ast.JDeclaredType;
 import com.google.gwt.dev.jjs.ast.JExpression;
-import com.google.gwt.dev.jjs.ast.JField;
 import com.google.gwt.dev.jjs.ast.JGwtCreate;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JMethodBody;
 import com.google.gwt.dev.jjs.ast.JMethodCall;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.ast.JReboundEntryPoint;
-import com.google.gwt.dev.jjs.ast.JReferenceType;
 import com.google.gwt.dev.jjs.ast.JStatement;
 import com.google.gwt.dev.jjs.impl.ArrayNormalizer;
 import com.google.gwt.dev.jjs.impl.AssertionNormalizer;
@@ -99,7 +97,6 @@
 import com.google.gwt.dev.js.JsVerboseNamer;
 import com.google.gwt.dev.js.ast.JsName;
 import com.google.gwt.dev.js.ast.JsProgram;
-import com.google.gwt.dev.js.ast.JsStatement;
 import com.google.gwt.dev.util.AbstractTextOutput;
 import com.google.gwt.dev.util.DefaultTextOutput;
 import com.google.gwt.dev.util.Empty;
@@ -120,7 +117,6 @@
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -140,7 +136,7 @@
     private final byte[] serializedSymbolMap;
     private final StatementRanges[] statementRanges;
     private final int permutationId;
-    
+
     public PermutationResultImpl(String[] js, SymbolData[] symbolMap,
         StatementRanges[] statementRanges, int permutationId) {
       byte[][] bytes = new byte[js.length][];
@@ -167,7 +163,7 @@
     public byte[][] getJs() {
       return js;
     }
-    
+
     public int getPermutationId() {
       return permutationId;
     }
@@ -270,34 +266,11 @@
         } while (didChange);
       }
 
-      // (10) Obfuscate
-      final Map<JsName, String> stringLiteralMap;
-      switch (options.getOutput()) {
-        case OBFUSCATED:
-          stringLiteralMap = JsStringInterner.exec(jsProgram);
-          JsObfuscateNamer.exec(jsProgram);
-          break;
-        case PRETTY:
-          // We don't intern strings in pretty mode to improve readability
-          stringLiteralMap = new HashMap<JsName, String>();
-          JsPrettyNamer.exec(jsProgram);
-          break;
-        case DETAILED:
-          stringLiteralMap = JsStringInterner.exec(jsProgram);
-          JsVerboseNamer.exec(jsProgram);
-          break;
-        default:
-          throw new InternalCompilerException("Unknown output mode");
-      }
-
-      JavaToJavaScriptMap postStringInterningMap = addStringLiteralMap(map,
-          stringLiteralMap);
-
-      // (10.5) Split up the program into fragments
+      // (10) Split up the program into fragments
       SoycArtifact dependencies = null;
       if (options.isAggressivelyOptimize() && options.isRunAsyncEnabled()) {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        CodeSplitter.exec(logger, jprogram, jsProgram, postStringInterningMap,
+        CodeSplitter.exec(logger, jprogram, jsProgram, map,
             chooseDependencyRecorder(options.isSoycEnabled(), baos));
         if (baos.size() > 0) {
           dependencies = new SoycArtifact("dependencies" + permutationId
@@ -305,6 +278,24 @@
         }
       }
 
+      // (10.5) Obfuscate
+      switch (options.getOutput()) {
+        case OBFUSCATED:
+          JsStringInterner.exec(jprogram, jsProgram);
+          JsObfuscateNamer.exec(jsProgram);
+          break;
+        case PRETTY:
+          // We don't intern strings in pretty mode to improve readability
+          JsPrettyNamer.exec(jsProgram);
+          break;
+        case DETAILED:
+          JsStringInterner.exec(jprogram, jsProgram);
+          JsVerboseNamer.exec(jsProgram);
+          break;
+        default:
+          throw new InternalCompilerException("Unknown output mode");
+      }
+
       // (11) Perform any post-obfuscation normalizations.
 
       // Work around an IE7 bug,
@@ -340,7 +331,8 @@
           makeSymbolMap(symbolTable), ranges, permutationId);
 
       toReturn.getArtifacts().add(
-          makeSoycArtifact(logger, permutationId, jprogram, js, sourceInfoMaps, dependencies));
+          makeSoycArtifact(logger, permutationId, jprogram, js, sourceInfoMaps,
+              dependencies));
 
       System.out.println("Permutation took "
           + (System.currentTimeMillis() - permStart) + " ms");
@@ -622,40 +614,6 @@
     return didChange;
   }
 
-  private static JavaToJavaScriptMap addStringLiteralMap(
-      final JavaToJavaScriptMap map, final Map<JsName, String> stringLiteralMap) {
-    JavaToJavaScriptMap postStringInterningMap = new JavaToJavaScriptMap() {
-      public JsName nameForMethod(JMethod method) {
-        return map.nameForMethod(method);
-      }
-
-      public JsName nameForType(JReferenceType type) {
-        return map.nameForType(type);
-      }
-
-      public JField nameToField(JsName name) {
-        return map.nameToField(name);
-      }
-
-      public JMethod nameToMethod(JsName name) {
-        return map.nameToMethod(name);
-      }
-
-      public String stringLiteralForName(JsName name) {
-        return stringLiteralMap.get(name);
-      }
-
-      public JReferenceType typeForStatement(JsStatement stat) {
-        return map.typeForStatement(stat);
-      }
-
-      public JMethod vtableInitToMethod(JsStatement stat) {
-        return map.vtableInitToMethod(stat);
-      }
-    };
-    return postStringInterningMap;
-  }
-
   private static void checkForErrors(TreeLogger logger,
       CompilationUnitDeclaration[] cuds, boolean itemizeErrors)
       throws UnableToCompleteException {
diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JProgram.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JProgram.java
index 38e7411..6ba32ab 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JProgram.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JProgram.java
@@ -24,6 +24,7 @@
 import com.google.gwt.dev.jjs.ast.js.JClassSeed;
 import com.google.gwt.dev.jjs.ast.js.JsniMethodBody;
 import com.google.gwt.dev.jjs.ast.js.JsonObject;
+import com.google.gwt.dev.jjs.impl.CodeSplitter;
 import com.google.gwt.dev.jjs.impl.ReplaceRunAsyncs.RunAsyncReplacement;
 import com.google.gwt.dev.util.collect.Lists;
 import com.google.gwt.dev.util.collect.Maps;
@@ -149,6 +150,26 @@
     return traceMethods.size() > 0;
   }
 
+  /**
+   * The same as {@link #lastFragmentLoadingBefore(int, int...)}, except that
+   * all of the parameters must be passed explicitly. The instance method should
+   * be preferred whenever a JProgram instance is available.
+   * 
+   * @param initialSeq The initial split point sequence of the program
+   * @param numSps The number of split points in the program
+   * @param firstFragment The first fragment to consider
+   * @param restFragments The rest of the fragments to consider
+   */
+  public static int lastFragmentLoadingBefore(List<Integer> initialSeq,
+      int numSps, int firstFragment, int... restFragments) {
+    int latest = firstFragment;
+    for (int frag : restFragments) {
+      latest = pairwiseLastFragmentLoadingBefore(initialSeq, numSps, latest,
+          frag);
+    }
+    return latest;
+  }
+
   private static String dotify(char[][] name) {
     StringBuffer result = new StringBuffer();
     for (int i = 0; i < name.length; ++i) {
@@ -161,6 +182,51 @@
     return result.toString();
   }
 
+  /**
+   * The main logic behind {@link #lastFragmentLoadingBefore(int, int...)} and
+   * {@link #lastFragmentLoadingBefore(List, int, int, int...)}.
+   */
+  private static int pairwiseLastFragmentLoadingBefore(
+      List<Integer> initialSeq, int numSps, int frag1, int frag2) {
+    if (frag1 == frag2) {
+      return frag1;
+    }
+
+    if (frag1 == 0) {
+      return 0;
+    }
+
+    if (frag2 == 0) {
+      return 0;
+    }
+
+    // See if either is in the initial sequence
+    int initPos1 = initialSeq.indexOf(frag1);
+    int initPos2 = initialSeq.indexOf(frag2);
+
+    // If both are in the initial sequence, then pick the earlier
+    if (initPos1 >= 0 && initPos2 >= 0) {
+      if (initPos1 < initPos2) {
+        return frag1;
+      }
+      return frag2;
+    }
+
+    // If exactly one is in the initial sequence, then it's the earlier one
+    if (initPos1 >= 0) {
+      return frag1;
+    }
+    if (initPos2 >= 0) {
+      return frag2;
+    }
+
+    assert (initPos1 < 0 && initPos2 < 0);
+    assert (frag1 != frag2);
+
+    // They are both leftovers or exclusive. Leftovers goes first in all cases.
+    return CodeSplitter.getLeftoversFragmentNumber(numSps);
+  }
+
   public final List<JClassType> codeGenTypes = new ArrayList<JClassType>();
 
   /**
@@ -1026,6 +1092,16 @@
     return staticToInstanceMap.containsKey(method);
   }
 
+  /**
+   * Given a sequence of fragment numbers, return the latest fragment number
+   * possible that does not load later than any of these. It might be one of the
+   * supplied fragments, or it might be a common predecessor.
+   */
+  public int lastFragmentLoadingBefore(int firstFragment, int... restFragments) {
+    return lastFragmentLoadingBefore(splitPointInitialSequence,
+        entryMethods.size() - 1, firstFragment, restFragments);
+  }
+
   public void putIntoTypeMap(String qualifiedBinaryName, JDeclaredType type) {
     // Make it into a source type name.
     String srcTypeName = qualifiedBinaryName.replace('$', '.');
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java b/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java
index 22bd0ce..214008f 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/CodeSplitter.java
@@ -150,10 +150,6 @@
             if (field != null) {
               System.out.println(fullNameString(field));
             }
-            String string = map.stringLiteralForName(var.getName());
-            if (string != null) {
-              System.out.println("STRING " + var.getName());
-            }
           }
         }
       }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java b/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java
index 0bfedd0..864be36 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/FragmentExtractor.java
@@ -98,8 +98,8 @@
    * 
    * <li>Instance methods depend on their enclosing type.</li>
    * 
-   * <li>Static fields that are initialized to strings depend on the string
-   * they are initialized to.</li>
+   * <li>Static fields that are initialized to strings depend on the string they
+   * are initialized to.</li>
    * </ul>
    */
   public static interface LivenessPredicate {
@@ -115,8 +115,8 @@
      * Whether miscellelaneous statements should be considered live.
      * Miscellaneous statements are any that the fragment extractor does not
      * recognize as being in any particular category. This method should almost
-     * always return <code>true</code>, but does return <code>false</code>
-     * for {@link NothingAlivePredicate}.
+     * always return <code>true</code>, but does return <code>false</code> for
+     * {@link NothingAlivePredicate}.
      */
     boolean miscellaneousStatementsAreLive();
   }
@@ -149,7 +149,8 @@
   /**
    * A logger for statements that the fragment extractor encounters. Install one
    * using
-   * {@link FragmentExtractor#setStatementLogger(com.google.gwt.fragserv.FragmentExtractor.StatementLogger)}.
+   * {@link FragmentExtractor#setStatementLogger(com.google.gwt.fragserv.FragmentExtractor.StatementLogger)}
+   * .
    */
   public static interface StatementLogger {
     void logStatement(JsStatement stat, boolean isIncluded);
@@ -204,7 +205,8 @@
 
   /**
    * Create a call to
-   * {@link com.google.gwt.core.client.impl.AsyncFragmentLoader#leftoversFragmentHasLoaded()}.
+   * {@link com.google.gwt.core.client.impl.AsyncFragmentLoader#leftoversFragmentHasLoaded()}
+   * .
    */
   public List<JsStatement> createCallToLeftoversFragmentHasLoaded() {
     JMethod loadedMethod = jprogram.getIndexedMethod("AsyncFragmentLoader.browserLoaderLeftoversFragmentHasLoaded");
@@ -315,16 +317,12 @@
    * individual vars that could be removed. If it does, then
    * {@link #removeSomeVars(JsVars, LivenessPredicate, LivenessPredicate)} is
    * sensible for this statement and should be used instead of
-   * {@link #isLive(JsStatement, com.google.gwt.fragserv.FragmentExtractor.LivenessPredicate)}.
+   * {@link #isLive(JsStatement, com.google.gwt.fragserv.FragmentExtractor.LivenessPredicate)}
+   * .
    */
   private boolean containsRemovableVars(JsStatement stat) {
     if (stat instanceof JsVars) {
       for (JsVar var : (JsVars) stat) {
-        String lit = map.stringLiteralForName(var.getName());
-        if (lit != null) {
-          // It's an intern variable for a string literal
-          return true;
-        }
 
         JField field = map.nameToField(var.getName());
         if (field != null) {
@@ -396,12 +394,6 @@
    * {@link #containsRemovableVars(JsStatement)}.
    */
   private boolean isLive(JsVar var, LivenessPredicate livenessPredicate) {
-    String lit = map.stringLiteralForName(var.getName());
-    if (lit != null) {
-      // It's an intern variable for a string literal
-      return livenessPredicate.isLive(lit);
-    }
-
     JField field = map.nameToField(var.getName());
     if (field != null) {
       // It's a field
@@ -414,9 +406,9 @@
 
   /**
    * Return the Java method corresponding to <code>stat</code>, or
-   * <code>null</code> if there isn't one. It recognizes JavaScript of the
-   * form <code>function foo(...) { ...}</code>, where <code>foo</code> is
-   * the name of the JavaScript translation of a Java method.
+   * <code>null</code> if there isn't one. It recognizes JavaScript of the form
+   * <code>function foo(...) { ...}</code>, where <code>foo</code> is the name
+   * of the JavaScript translation of a Java method.
    */
   private JMethod methodFor(JsStatement stat) {
     if (stat instanceof JsExprStmt) {
@@ -472,8 +464,8 @@
   /**
    * Compute a statement that can be used to set up for installing instance
    * methods into a vtable. It will be of the form
-   * <code>_ = foo.prototype</code>, where <code>foo</code> is the
-   * constructor function for <code>vtableType</code>.
+   * <code>_ = foo.prototype</code>, where <code>foo</code> is the constructor
+   * function for <code>vtableType</code>.
    */
   private JsStatement vtableStatFor(JReferenceType vtableType) {
     JsNameRef prototypeField = new JsNameRef(
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 b8f03dc..d56c411 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
@@ -2133,14 +2133,6 @@
         return nameToMethodMap.get(name);
       }
 
-      public String stringLiteralForName(JsName var) {
-        /*
-         * This method will be supplied non-trivially elsewhere.
-         * GenerateJavaScriptAST doesn't have the information to implement it.
-         */
-        return null;
-      }
-
       public JReferenceType typeForStatement(JsStatement stat) {
         return typeForStatMap.get(stat);
       }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/JavaToJavaScriptMap.java b/dev/core/src/com/google/gwt/dev/jjs/impl/JavaToJavaScriptMap.java
index 996fce0..7a96d82 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/JavaToJavaScriptMap.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/JavaToJavaScriptMap.java
@@ -49,12 +49,6 @@
   JMethod nameToMethod(JsName name);
 
   /**
-   * If <code>var</code> is the name of the variable used to hold an interned
-   * string literal, then return the string it interns. Otherwise, return null.
-   */
-  String stringLiteralForName(JsName var);
-
-  /**
    * If <code>stat</code> is used to set up the definition of some class, return
    * that class. Otherwise, return null.
    */
diff --git a/dev/core/src/com/google/gwt/dev/js/JsStringInterner.java b/dev/core/src/com/google/gwt/dev/js/JsStringInterner.java
index 4c10370..415737a 100644
--- a/dev/core/src/com/google/gwt/dev/js/JsStringInterner.java
+++ b/dev/core/src/com/google/gwt/dev/js/JsStringInterner.java
@@ -16,6 +16,7 @@
 package com.google.gwt.dev.js;
 
 import com.google.gwt.dev.jjs.SourceInfo;
+import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.js.ast.JsBinaryOperation;
 import com.google.gwt.dev.js.ast.JsBlock;
 import com.google.gwt.dev.js.ast.JsContext;
@@ -25,33 +26,48 @@
 import com.google.gwt.dev.js.ast.JsPostfixOperation;
 import com.google.gwt.dev.js.ast.JsPrefixOperation;
 import com.google.gwt.dev.js.ast.JsProgram;
+import com.google.gwt.dev.js.ast.JsProgramFragment;
 import com.google.gwt.dev.js.ast.JsPropertyInitializer;
 import com.google.gwt.dev.js.ast.JsScope;
 import com.google.gwt.dev.js.ast.JsStringLiteral;
 import com.google.gwt.dev.js.ast.JsVars;
 import com.google.gwt.dev.js.ast.JsVars.JsVar;
 
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.SortedMap;
+import java.util.SortedSet;
 import java.util.TreeMap;
+import java.util.TreeSet;
 
 /**
  * Interns all String literals in a JsProgram. Each unique String will be
- * assigned to a variable in the program's main block and instances of a
- * JsStringLiteral replaced with a JsNameRef. This optimization is complete in a
- * single pass, although it may be performed multiple times without duplicating
- * the intern pool.
+ * assigned to a variable in an appropriate program fragment and the
+ * JsStringLiteral will be replaced with a JsNameRef. This optimization is
+ * complete in a single pass, although it may be performed multiple times
+ * without duplicating the intern pool.
  */
 public class JsStringInterner {
-
   /**
    * Replaces JsStringLiterals with JsNameRefs, creating new JsName allocations
    * on the fly.
    */
   private static class StringVisitor extends JsModVisitor {
     /**
+     * The current fragment being visited.
+     */
+    private int currentFragment = 0;
+
+    /**
+     * This map records which program fragment the variable for this JsName
+     * should be created in.
+     */
+    private final SortedMap<JsStringLiteral, Integer> fragmentAssignment = new TreeMap<JsStringLiteral, Integer>(
+        LITERAL_COMPARATOR);
+
+    /**
      * A counter used for assigning ids to Strings. Even though it's unlikely
      * that someone would actually have two billion strings in their
      * application, it doesn't hurt to think ahead.
@@ -59,7 +75,13 @@
     private long lastId = 0;
 
     /**
-     * Records the scope in which the interned identifiers should be unique.
+     * Only used to get fragment load order so strings used in multiple
+     * fragments need only be downloaded once.
+     */
+    private final JProgram program;
+
+    /**
+     * Records the scope in which the interned identifiers are declared.
      */
     private final JsScope scope;
 
@@ -68,11 +90,7 @@
      * lexicographical ordering of the string constant.
      */
     private final SortedMap<JsStringLiteral, JsName> toCreate = new TreeMap<JsStringLiteral, JsName>(
-        new Comparator<JsStringLiteral>() {
-          public int compare(JsStringLiteral o1, JsStringLiteral o2) {
-            return o1.getValue().compareTo(o2.getValue());
-          }
-        });
+        LITERAL_COMPARATOR);
 
     /**
      * Constructor.
@@ -80,10 +98,16 @@
      * @param scope specifies the scope in which the interned strings should be
      *          created.
      */
-    public StringVisitor(JsScope scope) {
+    public StringVisitor(JProgram program, JsScope scope) {
+      this.program = program;
       this.scope = scope;
     }
 
+    @Override
+    public void endVisit(JsProgramFragment x, JsContext<JsProgramFragment> ctx) {
+      currentFragment++;
+    }
+
     /**
      * Prevents 'fixing' an otherwise illegal operation.
      */
@@ -133,6 +157,24 @@
         toCreate.put(x, name);
       }
 
+      Integer currentAssignment = fragmentAssignment.get(x);
+      if (currentAssignment == null) {
+        // Assign the JsName to the current program fragment
+        fragmentAssignment.put(x, currentFragment);
+
+      } else if (currentAssignment != currentFragment) {
+        // See if we need to move the assignment to a common ancestor
+        assert program != null : "JsStringInterner cannot be used with "
+            + "fragmented JsProgram without an accompanying JProgram";
+
+        int newAssignment = program.lastFragmentLoadingBefore(currentFragment,
+            currentAssignment);
+        if (newAssignment != currentAssignment) {
+          // Assign the JsName to the common ancestor
+          fragmentAssignment.put(x, newAssignment);
+        }
+      }
+
       ctx.replaceMe(name.makeRef(x.getSourceInfo().makeChild(
           JsStringInterner.class, "Interned reference")));
 
@@ -149,9 +191,45 @@
     }
   }
 
+  private static final Comparator<JsStringLiteral> LITERAL_COMPARATOR = new Comparator<JsStringLiteral>() {
+    public int compare(JsStringLiteral o1, JsStringLiteral o2) {
+      return o1.getValue().compareTo(o2.getValue());
+    }
+  };
+
   public static final String PREFIX = "$intern_";
 
   /**
+   * Apply interning of String literals to a JsProgram. The symbol names for the
+   * interned strings will be defined within the program's top scope and the
+   * symbol declarations will be added as the first statement in the program's
+   * global block.
+   * 
+   * @param jprogram the JProgram that has fragment dependency data for
+   *          <code>program</code>
+   * @param program the JsProgram
+   */
+  public static void exec(JProgram jprogram, JsProgram program) {
+    StringVisitor v = new StringVisitor(jprogram, program.getScope());
+    v.accept(program);
+
+    Map<Integer, SortedSet<JsStringLiteral>> bins = new HashMap<Integer, SortedSet<JsStringLiteral>>();
+    for (int i = 0, j = program.getFragmentCount(); i < j; i++) {
+      bins.put(i, new TreeSet<JsStringLiteral>(LITERAL_COMPARATOR));
+    }
+    for (Map.Entry<JsStringLiteral, Integer> entry : v.fragmentAssignment.entrySet()) {
+      SortedSet<JsStringLiteral> set = bins.get(entry.getValue());
+      assert set != null;
+      set.add(entry.getKey());
+    }
+
+    for (Map.Entry<Integer, SortedSet<JsStringLiteral>> entry : bins.entrySet()) {
+      createVars(program, program.getFragmentBlock(entry.getKey()),
+          entry.getValue(), v.toCreate);
+    }
+  }
+
+  /**
    * Intern String literals that occur within a JsBlock. The symbol declarations
    * will be added as the first statement in the block.
    * 
@@ -160,50 +238,29 @@
    * @return <code>true</code> if any changes were made to the block
    */
   public static boolean exec(JsProgram program, JsBlock block, JsScope scope) {
-    StringVisitor v = new StringVisitor(scope);
+    StringVisitor v = new StringVisitor(null, scope);
     v.accept(block);
 
-    createVars(program, block, v.toCreate);
+    createVars(program, block, v.toCreate.keySet(), v.toCreate);
 
     return v.didChange();
   }
 
   /**
-   * Apply interning of String literals to a JsProgram. The symbol names for the
-   * interned strings will be defined within the program's top scope and the
-   * symbol declarations will be added as the first statement in the program's
-   * global block.
-   * 
-   * @param program the JsProgram
-   * @return a map from each created JsName to the string it is a literal for.
+   * Create variable declarations in <code>block</code> for literal strings
+   * <code>toCreate</code> using the variable map <code>names</code>.
    */
-  public static Map<JsName, String> exec(JsProgram program) {
-    StringVisitor v = new StringVisitor(program.getScope());
-    for (int i = 0; i < program.getFragmentCount(); i++) {
-      v.accept(program.getFragmentBlock(i));
-    }
-
-    Map<JsName, String> map = new HashMap<JsName, String>();
-    for (JsStringLiteral stringLit : v.toCreate.keySet()) {
-      map.put(v.toCreate.get(stringLit), stringLit.getValue());
-    }
-
-    createVars(program, program.getGlobalBlock(), v.toCreate);
-
-    return map;
-  }
-
   private static void createVars(JsProgram program, JsBlock block,
-      SortedMap<JsStringLiteral, JsName> toCreate) {
+      Collection<JsStringLiteral> toCreate, Map<JsStringLiteral, JsName> names) {
     if (toCreate.size() > 0) {
       // Create the pool of variable names.
       JsVars vars = new JsVars(program.createSourceInfoSynthetic(
           JsStringInterner.class, "Interned string pool"));
       SourceInfo sourceInfo = program.createSourceInfoSynthetic(
           JsStringInterner.class, "Interned string assignment");
-      for (Map.Entry<JsStringLiteral, JsName> entry : toCreate.entrySet()) {
-        JsVar var = new JsVar(sourceInfo, entry.getValue());
-        var.setInitExpr(entry.getKey());
+      for (JsStringLiteral literal : toCreate) {
+        JsVar var = new JsVar(sourceInfo, names.get(literal));
+        var.setInitExpr(literal);
         vars.add(var);
       }
       block.getStatements().add(0, vars);
diff --git a/dev/core/src/com/google/gwt/dev/js/ast/JsProgram.java b/dev/core/src/com/google/gwt/dev/js/ast/JsProgram.java
index dc073f9..bc50847 100644
--- a/dev/core/src/com/google/gwt/dev/js/ast/JsProgram.java
+++ b/dev/core/src/com/google/gwt/dev/js/ast/JsProgram.java
@@ -209,9 +209,7 @@
   }
 
   /**
-   * Note: This is currently assumed not to be called after
-   * GenerateJavaScriptAST has finished. If it ever is, then GWT.runAsync needs
-   * to be updated to account for such string literals.
+   * Creates or retrieves a JsStringLiteral from an interned object pool.
    */
   public JsStringLiteral getStringLiteral(SourceInfo sourceInfo, String value) {
     JsStringLiteral lit = stringLiteralMap.get(value);
diff --git a/dev/core/test/com/google/gwt/dev/javac/JProgramLastFragmentLoadingBeforeTest.java b/dev/core/test/com/google/gwt/dev/javac/JProgramLastFragmentLoadingBeforeTest.java
new file mode 100644
index 0000000..585f38e
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/javac/JProgramLastFragmentLoadingBeforeTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.javac;
+
+import com.google.gwt.dev.jjs.ast.JProgram;
+import com.google.gwt.dev.util.collect.Lists;
+
+import junit.framework.TestCase;
+
+import java.util.List;
+
+/**
+ * Tests {@link JProgram#lastFragmentLoadingBefore(int, int...)}.
+ */
+public class JProgramLastFragmentLoadingBeforeTest extends TestCase {
+
+  public void testBasics() {
+    List<Integer> initialSeq = Lists.create(4, 3, 2);
+    int numSps = 10;
+
+    // Very simple
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0,
+        1, 2, 3));
+
+    // Equal fragments load at the same time
+    assertEquals(0,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0, 0));
+    assertEquals(1,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 1, 1));
+    assertEquals(3,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 3, 3));
+    assertEquals(6,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 6, 6));
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 11,
+        11));
+
+    // Zero loads first
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 11,
+        0));
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 10,
+        0));
+    assertEquals(0,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 3, 0));
+
+    // Initial sequence fragments load before all others
+    assertEquals(3, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 3,
+        10));
+    assertEquals(3, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 10,
+        3));
+
+    // Earlier initial sequence fragments load before the others
+    assertEquals(4, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 2,
+        3, 4));
+    assertEquals(3,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 2, 3));
+    assertEquals(4, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 4,
+        3, 2));
+
+    // For non-equal exclusive fragments, leftovers is the common predecessor
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 1,
+        7));
+
+    // Leftovers is before any exclusive
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 7,
+        11));
+  }
+
+  public void testWithEmptyInitial() {
+    List<Integer> initialSeq = Lists.create();
+    int numSps = 10;
+
+    // Simple case
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0,
+        1, 2, 3));
+
+    // Equal fragments load at the same time
+    assertEquals(0,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0, 0));
+    assertEquals(6,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 6, 6));
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 11,
+        11));
+
+    // Zero loads first
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 11,
+        0));
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 10,
+        0));
+    assertEquals(0,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 3, 0));
+
+    // For non-equal exclusive fragments, leftovers is the common predecessor
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 1,
+        7));
+
+    // Leftovers is before any exclusive
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 7,
+        11));
+
+    // With just one argument, return it
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0));
+    assertEquals(3, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 3));
+    assertEquals(11, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 11));
+  }
+
+  public void testWithNoSplitPoints() {
+    List<Integer> initialSeq = Lists.create();
+    int numSps = 0;
+
+    assertEquals(0,
+        JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0, 0));
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0,
+        0, 0));
+    assertEquals(0, JProgram.lastFragmentLoadingBefore(initialSeq, numSps, 0));
+  }
+}
diff --git a/dev/core/test/com/google/gwt/dev/javac/JavaCompilationSuite.java b/dev/core/test/com/google/gwt/dev/javac/JavaCompilationSuite.java
index c6efa75..9b0ceaa 100644
--- a/dev/core/test/com/google/gwt/dev/javac/JavaCompilationSuite.java
+++ b/dev/core/test/com/google/gwt/dev/javac/JavaCompilationSuite.java
@@ -33,6 +33,7 @@
     suite.addTestSuite(GWTProblemTest.class);
     suite.addTestSuite(JdtBehaviorTest.class);
     suite.addTestSuite(JdtCompilerTest.class);
+    suite.addTestSuite(JProgramLastFragmentLoadingBeforeTest.class);
     suite.addTestSuite(JSORestrictionsTest.class);
     suite.addTestSuite(JsniCheckerTest.class);
     suite.addTestSuite(TypeOracleMediatorTest.class);