diff --git a/dev/core/src/com/google/gwt/core/ext/soyc/impl/SplitPointRecorder.java b/dev/core/src/com/google/gwt/core/ext/soyc/impl/SplitPointRecorder.java
index 7826574..597ad33 100644
--- a/dev/core/src/com/google/gwt/core/ext/soyc/impl/SplitPointRecorder.java
+++ b/dev/core/src/com/google/gwt/core/ext/soyc/impl/SplitPointRecorder.java
@@ -80,7 +80,7 @@
         htmlOut.printRaw(curLine);
         htmlOut.newline();
       }
-      
+
       if (!jprogram.getSplitPointInitialSequence().isEmpty()) {
         curLine = "<initialseq>";
         htmlOut.printRaw(curLine);
@@ -92,7 +92,7 @@
           htmlOut.printRaw(curLine);
           htmlOut.newline();
         }
-        
+
         htmlOut.indentOut();
         curLine = "</initialseq>";
         htmlOut.printRaw(curLine);
@@ -127,13 +127,19 @@
     Map<String, Integer> counts = new HashMap<String, Integer>();
     for (RunAsyncReplacement replacement : program.getRunAsyncReplacements().values()) {
       int entryNumber = replacement.getNumber();
-      String methodDescription = fullMethodDescription(replacement.getEnclosingMethod());
-      if (counts.containsKey(methodDescription)) {
-        counts.put(methodDescription, counts.get(methodDescription) + 1);
-        methodDescription += "#"
-            + Integer.toString(counts.get(methodDescription));
+      String methodDescription;
+      if (replacement.getName() != null) {
+        methodDescription = replacement.getName();
       } else {
-        counts.put(methodDescription, 1);
+        methodDescription = "@"
+            + fullMethodDescription(replacement.getEnclosingMethod());
+        if (counts.containsKey(methodDescription)) {
+          counts.put(methodDescription, counts.get(methodDescription) + 1);
+          methodDescription += "#"
+              + Integer.toString(counts.get(methodDescription));
+        } else {
+          counts.put(methodDescription, 1);
+        }
       }
 
       names.put(entryNumber, methodDescription);
diff --git a/dev/core/src/com/google/gwt/dev/jdt/FindDeferredBindingSitesVisitor.java b/dev/core/src/com/google/gwt/dev/jdt/FindDeferredBindingSitesVisitor.java
index e4baf2c..62e035b 100644
--- a/dev/core/src/com/google/gwt/dev/jdt/FindDeferredBindingSitesVisitor.java
+++ b/dev/core/src/com/google/gwt/dev/jdt/FindDeferredBindingSitesVisitor.java
@@ -59,8 +59,7 @@
   public static final String REBIND_MAGIC_METHOD = "create";
   public static final String ASYNC_MAGIC_METHOD = "runAsync";
 
-  public static void reportRebindProblem(MessageSendSite site,
-      String message) {
+  public static void reportRebindProblem(MessageSendSite site, String message) {
     MessageSend messageSend = site.messageSend;
     Scope scope = site.scope;
     // Safe since CUS.referenceContext is set in its constructor.
@@ -111,11 +110,18 @@
       }
     } else {
       assert asyncMagicMethod;
-      if (args.length != 1) {
+      if (args.length != 1 && args.length != 2) {
         reportRebindProblem(site,
-            "GWT.runAsync() should take exactly one argument");
+            "GWT.runAsync() should take one or two arguments");
         return;
       }
+      if (args.length == 2) {
+        if (!(args[0] instanceof ClassLiteralAccess)) {
+          reportRebindProblem(site,
+              "Only class literals may be used to name a call to GWT.runAsync()");
+          return;
+        }
+      }
     }
 
     if (asyncMagicMethod) {
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 8b8a4a1..0c0d090 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
@@ -260,6 +260,74 @@
     dependencyRecorder.close();
   }
 
+  /**
+   * Find a split point as designated in the {@link #PROP_INITIAL_SEQUENCE}
+   * configuration property.
+   */
+  public static int findSplitPoint(String refString, JProgram program,
+      TreeLogger branch) throws UnableToCompleteException {
+    Map<JMethod, List<Integer>> methodToSplitPoint = reverseByEnclosingMethod(program.getRunAsyncReplacements());
+    Map<String, List<Integer>> nameToSplitPoint = reverseByName(program.getRunAsyncReplacements());
+
+    if (refString.startsWith("@")) {
+      JsniRef jsniRef = JsniRef.parse(refString);
+      if (jsniRef == null) {
+        branch.log(TreeLogger.ERROR, "Badly formatted JSNI reference in "
+            + PROP_INITIAL_SEQUENCE + ": " + refString);
+        throw new UnableToCompleteException();
+      }
+      final String lookupErrorHolder[] = new String[1];
+      HasEnclosingType referent = JsniRefLookup.findJsniRefTarget(jsniRef,
+          program, new JsniRefLookup.ErrorReporter() {
+            public void reportError(String error) {
+              lookupErrorHolder[0] = error;
+            }
+          });
+      if (referent == null) {
+        TreeLogger resolveLogger = branch.branch(TreeLogger.ERROR,
+            "Could not resolve JSNI reference: " + jsniRef);
+        resolveLogger.log(TreeLogger.ERROR, lookupErrorHolder[0]);
+        throw new UnableToCompleteException();
+      }
+
+      if (!(referent instanceof JMethod)) {
+        branch.log(TreeLogger.ERROR, "Not a method: " + referent);
+        throw new UnableToCompleteException();
+      }
+
+      JMethod method = (JMethod) referent;
+      List<Integer> splitPoints = methodToSplitPoint.get(method);
+      if (splitPoints == null) {
+        branch.log(TreeLogger.ERROR,
+            "Method does not enclose a runAsync call: " + jsniRef);
+        throw new UnableToCompleteException();
+      }
+      if (splitPoints.size() > 1) {
+        branch.log(TreeLogger.ERROR,
+            "Method includes multiple runAsync calls, "
+                + "so it's ambiguous which one is meant: " + jsniRef);
+        throw new UnableToCompleteException();
+      }
+
+      return splitPoints.get(0);
+    }
+
+    // Assume it's a raw class name
+    List<Integer> splitPoints = nameToSplitPoint.get(refString);
+    if (splitPoints == null || splitPoints.size() == 0) {
+      branch.log(TreeLogger.ERROR, "No runAsync call is labelled with class "
+          + refString);
+      throw new UnableToCompleteException();
+    }
+    if (splitPoints.size() > 1) {
+      branch.log(TreeLogger.ERROR,
+          "More than one runAsync call is labelled with class " + refString);
+      throw new UnableToCompleteException();
+    }
+
+    return splitPoints.get(0);
+  }
+
   public static int getExclusiveFragmentNumber(int splitPoint,
       int numSplitPoints) {
     return splitPoint;
@@ -295,8 +363,6 @@
       JProgram program, Properties properties) throws UnableToCompleteException {
     TreeLogger branch = logger.branch(TreeLogger.TRACE,
         "Looking up initial load sequence for split points");
-    Map<JMethod, List<Integer>> reversedRunAsyncMap = reverse(program.getRunAsyncReplacements());
-
     LinkedHashSet<Integer> initialLoadSequence = new LinkedHashSet<Integer>();
 
     ConfigurationProperty prop;
@@ -314,8 +380,7 @@
     }
 
     for (String refString : prop.getValues()) {
-      int splitPoint = findSplitPoint(refString, program, branch,
-          reversedRunAsyncMap);
+      int splitPoint = findSplitPoint(refString, program, branch);
       if (initialLoadSequence.contains(splitPoint)) {
         branch.log(TreeLogger.ERROR, "Split point specified more than once: "
             + refString);
@@ -323,8 +388,6 @@
       initialLoadSequence.add(splitPoint);
     }
 
-    // TODO(spoon) create an artifact in the aux dir describing the choice, so
-    // that SOYC can use it
     logInitialLoadSequence(logger, initialLoadSequence);
     installInitialLoadSequenceField(program, initialLoadSequence);
     program.setSplitPointInitialSequence(new ArrayList<Integer>(
@@ -395,63 +458,6 @@
     return cfa;
   }
 
-  /**
-   * Find a split point as designated in the {@link #PROP_INITIAL_SEQUENCE}
-   * configuration property.
-   * 
-   * TODO(spoon) accept a labeled runAsync call, once runAsyncs can be labeled
-   */
-  private static int findSplitPoint(String refString, JProgram program,
-      TreeLogger branch, Map<JMethod, List<Integer>> reversedRunAsyncMap)
-      throws UnableToCompleteException {
-    if (refString.startsWith("@")) {
-      JsniRef jsniRef = JsniRef.parse(refString);
-      if (jsniRef == null) {
-        branch.log(TreeLogger.ERROR, "Badly formatted JSNI reference in "
-            + PROP_INITIAL_SEQUENCE + ": " + refString);
-        throw new UnableToCompleteException();
-      }
-      final String lookupErrorHolder[] = new String[1];
-      HasEnclosingType referent = JsniRefLookup.findJsniRefTarget(jsniRef,
-          program, new JsniRefLookup.ErrorReporter() {
-            public void reportError(String error) {
-              lookupErrorHolder[0] = error;
-            }
-          });
-      if (referent == null) {
-        TreeLogger resolveLogger = branch.branch(TreeLogger.ERROR,
-            "Could not resolve JSNI reference: " + jsniRef);
-        resolveLogger.log(TreeLogger.ERROR, lookupErrorHolder[0]);
-        throw new UnableToCompleteException();
-      }
-
-      if (!(referent instanceof JMethod)) {
-        branch.log(TreeLogger.ERROR, "Not a method: " + referent);
-        throw new UnableToCompleteException();
-      }
-
-      JMethod method = (JMethod) referent;
-      List<Integer> splitPoints = reversedRunAsyncMap.get(method);
-      if (splitPoints == null) {
-        branch.log(TreeLogger.ERROR,
-            "Method does not enclose a runAsync call: " + jsniRef);
-        throw new UnableToCompleteException();
-      }
-      if (splitPoints.size() != 1) {
-        branch.log(TreeLogger.ERROR,
-            "Method includes multiple runAsync calls, "
-                + "so it's ambiguous which one is meant: " + jsniRef);
-        throw new UnableToCompleteException();
-      }
-
-      return splitPoints.get(0);
-    }
-
-    branch.log(TreeLogger.ERROR, "Unrecognized designation of a split point: "
-        + refString);
-    throw new UnableToCompleteException();
-  }
-
   private static String fullNameString(JField field) {
     return field.getEnclosingType().getName() + "." + field.getName();
   }
@@ -527,7 +533,7 @@
    * Reverses a runAsync map, returning a map from methods to the split point
    * numbers invoked from within that method.
    */
-  private static Map<JMethod, List<Integer>> reverse(
+  private static Map<JMethod, List<Integer>> reverseByEnclosingMethod(
       Map<Integer, RunAsyncReplacement> runAsyncMap) {
     Map<JMethod, List<Integer>> revmap = new HashMap<JMethod, List<Integer>>();
     for (RunAsyncReplacement replacement : runAsyncMap.values()) {
@@ -542,6 +548,23 @@
     return revmap;
   }
 
+  private static Map<String, List<Integer>> reverseByName(
+      Map<Integer, RunAsyncReplacement> runAsyncReplacements) {
+    Map<String, List<Integer>> revmap = new HashMap<String, List<Integer>>();
+    for (RunAsyncReplacement replacement : runAsyncReplacements.values()) {
+      String name = replacement.getName();
+      if (name != null) {
+        List<Integer> list = revmap.get(name);
+        if (list == null) {
+          list = new ArrayList<Integer>();
+          revmap.put(name, list);
+        }
+        list.add(replacement.getNumber());
+      }
+    }
+    return revmap;
+  }
+
   /**
    * Traverse all code in the program that is reachable via split point
    * <code>splitPoint</code>.
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java b/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java
index 8c341da..f47edb6 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/ReplaceRunAsyncs.java
@@ -16,7 +16,9 @@
 package com.google.gwt.dev.jjs.impl;
 
 import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.dev.jjs.InternalCompilerException;
 import com.google.gwt.dev.jjs.ast.Context;
+import com.google.gwt.dev.jjs.ast.JClassLiteral;
 import com.google.gwt.dev.jjs.ast.JClassType;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JField;
@@ -34,6 +36,8 @@
 /**
  * Replaces calls to
  * {@link com.google.gwt.core.client.GWT#runAsync(com.google.gwt.core.client.RunAsyncCallback)}
+ * and
+ * {@link com.google.gwt.core.client.GWT#runAsync(Class, com.google.gwt.core.client.RunAsyncCallback)
  * by calls to a fragment loader.
  */
 public class ReplaceRunAsyncs {
@@ -44,12 +48,15 @@
   public static class RunAsyncReplacement implements Serializable {
     private final JMethod enclosingMethod;
     private final JMethod loadMethod;
+    private final String name;
     private final int number;
 
-    RunAsyncReplacement(int number, JMethod enclosingMethod, JMethod loadMethod) {
+    RunAsyncReplacement(int number, JMethod enclosingMethod,
+        JMethod loadMethod, String name) {
       this.number = number;
       this.enclosingMethod = enclosingMethod;
       this.loadMethod = loadMethod;
+      this.name = name;
     }
 
     /**
@@ -68,6 +75,15 @@
     }
 
     /**
+     * Return the name of this runAsync, which is specified by a class literal
+     * in the two-argument version of runAsync(). Returns <code>null</code> if
+     * there is no name for the call.
+     */
+    public String getName() {
+      return name;
+    }
+
+    /**
      * The index of this runAsync, numbered from 1 to n.
      */
     public int getNumber() {
@@ -87,16 +103,29 @@
     @Override
     public void endVisit(JMethodCall x, Context ctx) {
       JMethod method = x.getTarget();
-      if (method == program.getIndexedMethod("GWT.runAsync")) {
-        assert (x.getArgs().size() == 1);
-        JExpression asyncCallback = x.getArgs().get(0);
+      if (isRunAsyncMethod(method)) {
+        JExpression asyncCallback;
+        String name;
+        switch (x.getArgs().size()) {
+          case 1:
+            name = null;
+            asyncCallback = x.getArgs().get(0);
+            break;
+          case 2:
+            name = ((JClassLiteral) x.getArgs().get(0)).getRefType().getName();
+            asyncCallback = x.getArgs().get(1);
+            break;
+          default:
+            throw new InternalCompilerException(
+                "runAsync call found with neither 1 nor 2 arguments: " + x);
+        }
 
         int entryNumber = entryCount++;
         JClassType loader = getFragmentLoader(entryNumber);
         JMethod loadMethod = getRunAsyncMethod(loader);
         assert loadMethod != null;
         runAsyncReplacements.put(entryNumber, new RunAsyncReplacement(
-            entryNumber, currentMethod, loadMethod));
+            entryNumber, currentMethod, loadMethod, name));
 
         JMethodCall methodCall = new JMethodCall(x.getSourceInfo(), null,
             loadMethod);
@@ -113,6 +142,14 @@
       currentMethod = x;
       return true;
     }
+
+    private boolean isRunAsyncMethod(JMethod method) {
+      /*
+       * The method is overloaded, so check the enclosing type plus the name.
+       */
+      return method.getEnclosingType() == program.getIndexedType("GWT")
+          && method.getName().equals("runAsync");
+    }
   }
 
   public static void exec(TreeLogger logger, JProgram program) {
@@ -133,6 +170,7 @@
   }
 
   private JProgram program;
+
   private Map<Integer, RunAsyncReplacement> runAsyncReplacements = new HashMap<Integer, RunAsyncReplacement>();
 
   private ReplaceRunAsyncs(JProgram program) {
diff --git a/dev/core/test/com/google/gwt/dev/javac/RunAsyncNameTest.java b/dev/core/test/com/google/gwt/dev/javac/RunAsyncNameTest.java
new file mode 100644
index 0000000..ad433e5
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/javac/RunAsyncNameTest.java
@@ -0,0 +1,81 @@
+/*
+ * 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.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.javac.impl.MockJavaResource;
+import com.google.gwt.dev.jjs.impl.OptimizerTestBase;
+import com.google.gwt.dev.util.UnitTestTreeLogger;
+
+/**
+ * This class tests naming of runAsync calls. Mostly it tests names that are
+ * invalid.
+ */
+public class RunAsyncNameTest extends OptimizerTestBase {
+  @Override
+  public void setUp() {
+    sourceOracle.addOrReplace(new MockJavaResource("test.CallRunAsync") {
+      @Override
+      protected CharSequence getContent() {
+        StringBuffer code = new StringBuffer();
+        code.append("package test;\n");
+        code.append("import com.google.gwt.core.client.GWT;\n");
+        code.append("public class CallRunAsync {\n");
+        code.append("  public static int notAmethod;");
+        code.append("  public static void call0() { }\n");
+        code.append("  public static void call1() {\n");
+        code.append("    GWT.runAsync(null);\n");
+        code.append("  }\n");
+        code.append("  public static void call2() {\n");
+        code.append("    GWT.runAsync(null);\n");
+        code.append("    GWT.runAsync(null);\n");
+        code.append("  }\n");
+        code.append("}\n");
+        return code;
+      }
+    });
+  }
+
+  /**
+   * Tests that it's an error to call the 2-argument version of GWT.runAsync
+   * with anything but a class literal.
+   */
+  public void testNonLiteralInCall() throws UnableToCompleteException {
+    UnitTestTreeLogger logger;
+    {
+      UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
+      builder.setLowestLogLevel(TreeLogger.ERROR);
+      builder.expectError("Errors in /mock/test/EntryPoint.java", null);
+      builder.expectError(
+          "Line 5:  Only class literals may be used to name a call to GWT.runAsync()",
+          null);
+      builder.expectError("Cannot proceed due to previous errors", null);
+      logger = builder.createLogger();
+      this.logger = logger;
+    }
+
+    addSnippetImport("com.google.gwt.core.client.GWT");
+    try {
+      compileSnippet("void", "GWT.runAsync((new Object()).getClass(), null);");
+      fail("Expected compilation to fail");
+    } catch (UnableToCompleteException e) {
+      // expected
+    }
+
+    logger.assertCorrectLogEntries();
+  }
+}
diff --git a/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java b/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java
index 2684691..8a6e49e 100644
--- a/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java
+++ b/dev/core/test/com/google/gwt/dev/jjs/JavaAstConstructor.java
@@ -21,6 +21,7 @@
 import com.google.gwt.dev.javac.impl.JavaResourceBase;
 import com.google.gwt.dev.javac.impl.MockJavaResource;
 import com.google.gwt.dev.jdt.BasicWebModeCompiler;
+import com.google.gwt.dev.jdt.FindDeferredBindingSitesVisitor;
 import com.google.gwt.dev.jjs.CorrelationFactory.DummyCorrelationFactory;
 import com.google.gwt.dev.jjs.ast.JDeclaredType;
 import com.google.gwt.dev.jjs.ast.JMethod;
@@ -98,6 +99,8 @@
       code.append("public final class GWT {\n");
       code.append("  public boolean isClient() { return true; };\n");
       code.append("  public boolean isScript() { return true; };\n");
+      code.append("  public static void runAsync(Object callback) { }\n");
+      code.append("  public static void runAsync(Class<?> name, Object callback) { }\n");
       code.append("}\n");
       return code;
     }
@@ -131,6 +134,16 @@
     //
     JavaToJavaScriptCompiler.checkForErrors(logger, goldenCuds, false);
 
+    /*
+     * FindDeferredBindingSitesVisitor detects errors in usage of magic methods
+     * in the GWT class.
+     */
+    for (CompilationUnitDeclaration jdtCud : goldenCuds) {
+      jdtCud.traverse(new FindDeferredBindingSitesVisitor(), jdtCud.scope);
+    }
+
+    JavaToJavaScriptCompiler.checkForErrors(logger, goldenCuds, true);
+    
     CorrelationFactory correlator = new DummyCorrelationFactory();
     JProgram jprogram = new JProgram(correlator);
     JsProgram jsProgram = new JsProgram(correlator);
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java b/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java
index 9ef05dc..50cf016 100644
--- a/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.java
@@ -77,8 +77,8 @@
 
   /**
    * Finds a type by name. The type name may be short, e.g. <code>"Foo"</code>,
-   * or fully-qualified, e.g. <code>"com.google.example.Foo"</code>. If a
-   * short name is used, it must be unambiguous.
+   * or fully-qualified, e.g. <code>"com.google.example.Foo"</code>. If a short
+   * name is used, it must be unambiguous.
    */
   public static JDeclaredType findType(JProgram program, String typeName) {
     JDeclaredType type = program.getFromTypeMap(typeName);
@@ -117,9 +117,9 @@
     return TreeLogger.NULL;
   }
 
-  protected final MockResourceOracle sourceOracle = new MockResourceOracle();
+  protected TreeLogger logger = createTreeLogger();
 
-  private final TreeLogger logger = createTreeLogger();
+  protected final MockResourceOracle sourceOracle = new MockResourceOracle();
 
   private final Set<String> snippetClassDecls = new TreeSet<String>();
 
@@ -133,6 +133,15 @@
   }
 
   /**
+   * Adds a snippet of code, for example a field declaration, to the class that
+   * encloses the snippet subsequently passed to
+   * {@link #compileSnippet(String, String)}.
+   */
+  protected void addSnippetClassDecl(String fieldDecl) {
+    snippetClassDecls.add(fieldDecl);
+  }
+
+  /**
    * Adds an import statement for any code subsequently passed to
    * {@link #compileSnippet(String, String)}.
    */
@@ -141,14 +150,6 @@
   }
 
   /**
-   * Adds a local field declaration for code subsequently passed to
-   * {@link #compileSnippet(String, String)}.
-   */
-  protected void addSnippetClassDecl(String fieldDecl) {
-    snippetClassDecls.add(fieldDecl);
-  }
-
-  /**
    * Returns the program that results from compiling the specified code snippet
    * as the body of an entry point method.
    * 
diff --git a/user/src/com/google/gwt/core/client/GWT.java b/user/src/com/google/gwt/core/client/GWT.java
index f58ce85..2028019 100644
--- a/user/src/com/google/gwt/core/client/GWT.java
+++ b/user/src/com/google/gwt/core/client/GWT.java
@@ -204,34 +204,20 @@
   }
 
   /**
+   * The same as {@link #runAsync(RunAsyncCallback)}, except with an extra
+   * parameter to provide a name for the call. The name parameter should be
+   * supplied with a class literal. No two runAsync calls in the same program
+   * should use the same name.
+   */
+  public static void runAsync(Class<?> name, RunAsyncCallback callback) {
+    runAsyncWithoutCodeSplitting(callback);
+  }
+
+  /**
    * Run the specified callback once the necessary code for it has been loaded.
    */
   public static void runAsync(RunAsyncCallback callback) {
-    /*
-     * By default, just call the callback. This allows using
-     * <code>runAsync</code> in code that might or might not run in a web
-     * browser.
-     */
-    if (isScript()) {
-      /*
-       * It's possible that the code splitter does not run, even for a
-       * production build. Signal a lightweight event, anyway, just so that
-       * there isn't a complete lack of lightweight events for runAsync.
-       */
-      AsyncFragmentLoader.BROWSER_LOADER.logEventProgress("noDownloadNeeded", "begin");
-      AsyncFragmentLoader.BROWSER_LOADER.logEventProgress("noDownloadNeeded", "end");
-    }
-
-    UncaughtExceptionHandler handler = sUncaughtExceptionHandler;
-    if (handler == null) {
-      callback.onSuccess();
-    } else {
-      try {
-        callback.onSuccess();
-      } catch (Throwable e) {
-        handler.onUncaughtException(e);
-      }
-    }
+    runAsyncWithoutCodeSplitting(callback);
   }
 
   /**
@@ -261,4 +247,36 @@
   private static native String getVersion0() /*-{
     return $gwt_version;
   }-*/;
+
+  /**
+   * This implementation of runAsync simply calls the callback. It is only used
+   * when no code splitting has occurred.
+   */
+  private static void runAsyncWithoutCodeSplitting(RunAsyncCallback callback) {
+    /*
+     * By default, just call the callback. This allows using
+     * <code>runAsync</code> in code that might or might not run in a web
+     * browser.
+     */
+    if (isScript()) {
+      /*
+       * It's possible that the code splitter does not run, even for a
+       * production build. Signal a lightweight event, anyway, just so that
+       * there isn't a complete lack of lightweight events for runAsync.
+       */
+      AsyncFragmentLoader.BROWSER_LOADER.logEventProgress("noDownloadNeeded", "begin");
+      AsyncFragmentLoader.BROWSER_LOADER.logEventProgress("noDownloadNeeded", "end");
+    }
+
+    UncaughtExceptionHandler handler = sUncaughtExceptionHandler;
+    if (handler == null) {
+      callback.onSuccess();
+    } else {
+      try {
+        callback.onSuccess();
+      } catch (Throwable e) {
+        handler.onUncaughtException(e);
+      }
+    }
+  }
 }
diff --git a/user/test/com/google/gwt/dev/jjs/InitialLoadSequence.gwt.xml b/user/test/com/google/gwt/dev/jjs/InitialLoadSequence.gwt.xml
index 5c8a752..7dcb746 100644
--- a/user/test/com/google/gwt/dev/jjs/InitialLoadSequence.gwt.xml
+++ b/user/test/com/google/gwt/dev/jjs/InitialLoadSequence.gwt.xml
@@ -21,5 +21,5 @@
   <extend-configuration-property name="compiler.splitpoint.initial.sequence"
     value="@com.google.gwt.dev.jjs.test.InitialLoadSequenceTest::callback1()" />
   <extend-configuration-property name="compiler.splitpoint.initial.sequence"
-    value="@com.google.gwt.dev.jjs.test.InitialLoadSequenceTest::callback2()" />
+    value="com.google.gwt.dev.jjs.test.InitialLoadSequenceTest$Callback2Marker" />
 </module>
diff --git a/user/test/com/google/gwt/dev/jjs/test/InitialLoadSequenceTest.java b/user/test/com/google/gwt/dev/jjs/test/InitialLoadSequenceTest.java
index 478727e..39a2ff7 100644
--- a/user/test/com/google/gwt/dev/jjs/test/InitialLoadSequenceTest.java
+++ b/user/test/com/google/gwt/dev/jjs/test/InitialLoadSequenceTest.java
@@ -26,6 +26,13 @@
  */
 public class InitialLoadSequenceTest extends GWTTestCase {
   private static final int TIMEOUT = 10000;
+
+  /**
+   * This class is used to mark the second runAsync call.
+   */
+  public static class Callback2Marker {
+  }
+
   /**
    * The number of callbacks outstanding. When this gets to zero, the test
    * finishes.
@@ -58,7 +65,7 @@
   }
 
   private void callback2() {
-    GWT.runAsync(new RunAsyncCallback() {
+    GWT.runAsync(Callback2Marker.class, new RunAsyncCallback() {
       public void onFailure(Throwable reason) {
         fail(reason.toString());
       }