diff --git a/dev/core/src/com/google/gwt/core/ext/linker/CompilationResult.java b/dev/core/src/com/google/gwt/core/ext/linker/CompilationResult.java
index 093f578..c9f3e3e 100644
--- a/dev/core/src/com/google/gwt/core/ext/linker/CompilationResult.java
+++ b/dev/core/src/com/google/gwt/core/ext/linker/CompilationResult.java
@@ -34,12 +34,12 @@
    * Returns the JavaScript compilation. The first element of the array contains
    * the code that should be run when the application starts up. The remaining
    * elements are loaded via
-   * {@link com.google.gwt.core.client.GWT#runAsync(com.google.gwt.core.client.RunAsyncCallback) GWT.runAsync}.
-   * The linker should provide a function named
-   * <code>__gwtStartLoadingFragment</code> that can takes an integer as argument
-   * and loads that specified code segment. To see how this function is used,
-   * see
-   * {@link com.google.gwt.core.client.AsyncFragmentLoader AsyncFragmentLoader}.
+   * {@link com.google.gwt.core.client.GWT#runAsync(com.google.gwt.core.client.RunAsyncCallback)
+   * GWT.runAsync}. The linker should provide a function named
+   * <code>__gwtStartLoadingFragment</code> that can takes an integer as
+   * argument and loads that specified code segment. To see how this function is
+   * used, see {@link com.google.gwt.core.client.AsyncFragmentLoader
+   * AsyncFragmentLoader}.
    */
   public abstract String[] getJavaScript();
 
@@ -52,11 +52,19 @@
   public abstract SortedSet<SortedMap<SelectionProperty, String>> getPropertyMap();
 
   /**
-   * Return a string that uniquely identifies this compilation result.  Typically
+   * Return a string that uniquely identifies this compilation result. Typically
    * this is a cryptographic hash of the compiled data.
    */
   public abstract String getStrongName();
 
+  /**
+   * Returns a map of obfuscated symbol names in the compilation to JSNI-style
+   * identifiers. This data can allow for on-the-fly deobfuscation of stack
+   * trace information or to allow server components to have in-depth knowledge
+   * of the runtime structure of compiled objects.
+   */
+  public abstract SortedMap<String, String> getSymbolMap();
+
   @Override
   public final int hashCode() {
     int hash = 17;
diff --git a/dev/core/src/com/google/gwt/core/ext/linker/impl/SelectionScriptLinker.java b/dev/core/src/com/google/gwt/core/ext/linker/impl/SelectionScriptLinker.java
index c7e3a69..6485c5d 100644
--- a/dev/core/src/com/google/gwt/core/ext/linker/impl/SelectionScriptLinker.java
+++ b/dev/core/src/com/google/gwt/core/ext/linker/impl/SelectionScriptLinker.java
@@ -64,8 +64,7 @@
    * Determines whether or not the URL is relative.
    * 
    * @param src the test url
-   * @return <code>true</code> if the URL is relative, <code>false</code> if
-   *         not
+   * @return <code>true</code> if the URL is relative, <code>false</code> if not
    */
   @SuppressWarnings("unused")
   protected static boolean isRelativeURL(String src) {
@@ -351,8 +350,8 @@
   /**
    * Get the partial path on which a CompilationResult has been emitted.
    * 
-   * @return the partial path, or <code>null</code> if the CompilationResult
-   *         has not been emitted.
+   * @return the partial path, or <code>null</code> if the CompilationResult has
+   *         not been emitted.
    */
   protected String getCompilationStrongName(CompilationResult result) {
     return compilationStrongNames.get(result);
@@ -372,8 +371,8 @@
    * {@link #getModulePrefix(TreeLogger, LinkerContext, String)}.
    * 
    * @param strongName strong name of the module being emitted
-   * @param numFragments the number of fragments for this module, including
-   *        the main fragment (fragment 0)
+   * @param numFragments the number of fragments for this module, including the
+   *          main fragment (fragment 0)
    */
   protected String getModulePrefix(TreeLogger logger, LinkerContext context,
       String strongName, int numFragments) throws UnableToCompleteException {
diff --git a/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java b/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java
index bf4306b..62be9ce 100644
--- a/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java
+++ b/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java
@@ -70,9 +70,12 @@
    */
   public static final Comparator<SortedMap<SelectionProperty, String>> MAP_COMPARATOR = new MapComparator();
 
-  private final FileBackedObject<PermutationResult> resultFile;
   private transient SoftReference<String[]> js;
 
+  private final FileBackedObject<PermutationResult> resultFile;
+
+  private transient SoftReference<SortedMap<String, String>> symbolMap;
+
   private final SortedSet<SortedMap<SelectionProperty, String>> propertyValues = new TreeSet<SortedMap<SelectionProperty, String>>(
       MAP_COMPARATOR);
   private final String strongName;
@@ -104,16 +107,11 @@
     }
 
     if (toReturn == null) {
-      PermutationResult result;
-      try {
-        result = resultFile.newInstance(TreeLogger.NULL);
-        toReturn = result.getJs();
-        js = new SoftReference<String[]>(toReturn);
-      } catch (UnableToCompleteException e) {
-        throw new RuntimeException(
-            "Unexpectedly unable to read PermutationResult");
-      }
+      PermutationResult result = loadPermutationResult();
+      toReturn = result.getJs();
+      js = new SoftReference<String[]>(toReturn);
     }
+
     return toReturn;
   }
 
@@ -126,4 +124,29 @@
   public String getStrongName() {
     return strongName;
   }
+
+  @Override
+  public SortedMap<String, String> getSymbolMap() {
+    SortedMap<String, String> toReturn = null;
+    if (symbolMap != null) {
+      toReturn = symbolMap.get();
+    }
+
+    if (toReturn == null) {
+      PermutationResult result = loadPermutationResult();
+      toReturn = result.getSymbolMap();
+      symbolMap = new SoftReference<SortedMap<String, String>>(toReturn);
+    }
+
+    return toReturn;
+  }
+
+  private PermutationResult loadPermutationResult() {
+    try {
+      return resultFile.newInstance(TreeLogger.NULL);
+    } catch (UnableToCompleteException e) {
+      throw new RuntimeException(
+          "Unexpectedly unable to read PermutationResult");
+    }
+  }
 }
diff --git a/dev/core/src/com/google/gwt/core/linker/IFrameLinker.java b/dev/core/src/com/google/gwt/core/linker/IFrameLinker.java
index f5787fc..a02d487 100644
--- a/dev/core/src/com/google/gwt/core/linker/IFrameLinker.java
+++ b/dev/core/src/com/google/gwt/core/linker/IFrameLinker.java
@@ -132,7 +132,7 @@
 
   /**
    * This is the real implementation of <code>getModulePrefix</code> for this
-   * linker.  The other versions forward to this one.
+   * linker. The other versions forward to this one.
    */
   private String getModulePrefix(LinkerContext context, String strongName,
       boolean supportRunAsync) {
@@ -151,6 +151,8 @@
     out.newlineOpt();
     out.print("var $moduleName, $moduleBase;");
     out.newlineOpt();
+    out.print("var $strongName = '" + strongName + "';");
+    out.newlineOpt();
     if (supportRunAsync) {
       out.print("function __gwtStartLoadingFragment(frag) {");
       out.newlineOpt();
diff --git a/dev/core/src/com/google/gwt/core/linker/SingleScriptLinker.java b/dev/core/src/com/google/gwt/core/linker/SingleScriptLinker.java
index b31ff09..044e68b 100644
--- a/dev/core/src/com/google/gwt/core/linker/SingleScriptLinker.java
+++ b/dev/core/src/com/google/gwt/core/linker/SingleScriptLinker.java
@@ -103,6 +103,9 @@
     }
     CompilationResult result = results.iterator().next();
 
+    out.print("var $strongName = '" + result.getStrongName() + "';");
+    out.newlineOpt();
+
     String[] js = result.getJavaScript();
     if (js.length != 1) {
       logger = logger.branch(TreeLogger.ERROR,
diff --git a/dev/core/src/com/google/gwt/core/linker/SymbolMapsLinker.java b/dev/core/src/com/google/gwt/core/linker/SymbolMapsLinker.java
new file mode 100644
index 0000000..a449bed
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/linker/SymbolMapsLinker.java
@@ -0,0 +1,118 @@
+/*
+ * 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.core.linker;
+
+import com.google.gwt.core.ext.LinkerContext;
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.linker.AbstractLinker;
+import com.google.gwt.core.ext.linker.ArtifactSet;
+import com.google.gwt.core.ext.linker.CompilationResult;
+import com.google.gwt.core.ext.linker.EmittedArtifact;
+import com.google.gwt.core.ext.linker.LinkerOrder;
+import com.google.gwt.core.ext.linker.SelectionProperty;
+import com.google.gwt.core.ext.linker.LinkerOrder.Order;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+import java.util.Map;
+import java.util.SortedMap;
+
+/**
+ * This Linker exports the symbol maps associated with each compilation result
+ * as a private file. The names of the symbol maps files are computed by
+ * appending {@value #STRONG_NAME_SUFFIX} to the value returned by
+ * {@link CompilationResult#getStrongName()}.
+ */
+@LinkerOrder(Order.POST)
+public class SymbolMapsLinker extends AbstractLinker {
+
+  /**
+   * This value is appended to the strong name of the CompilationResult to form
+   * the symbol map's filename.
+   */
+  public static final String STRONG_NAME_SUFFIX = "_sybolMap.properties";
+
+  @Override
+  public String getDescription() {
+    return "Export CompilationResult symbol maps";
+  }
+
+  @Override
+  public ArtifactSet link(TreeLogger logger, LinkerContext context,
+      ArtifactSet artifacts) throws UnableToCompleteException {
+
+    artifacts = new ArtifactSet(artifacts);
+
+    for (CompilationResult result : artifacts.find(CompilationResult.class)) {
+      ByteArrayOutputStream out = new ByteArrayOutputStream();
+      PrintWriter pw = new PrintWriter(out);
+
+      doWriteSymbolMap(logger, result, pw);
+      pw.close();
+
+      doEmitSymbolMap(logger, artifacts, result, out);
+    }
+
+    return artifacts;
+  }
+
+  /**
+   * Override to change the manner in which the symbol map is emitted.
+   */
+  protected void doEmitSymbolMap(TreeLogger logger, ArtifactSet artifacts,
+      CompilationResult result, ByteArrayOutputStream out)
+      throws UnableToCompleteException {
+    EmittedArtifact symbolMapArtifact = emitBytes(logger, out.toByteArray(),
+        result.getStrongName() + STRONG_NAME_SUFFIX);
+    symbolMapArtifact.setPrivate(true);
+    artifacts.add(symbolMapArtifact);
+  }
+
+  /**
+   * Override to change the format of the symbol map.
+   */
+  protected void doWriteSymbolMap(TreeLogger logger, CompilationResult result,
+      PrintWriter pw) throws UnableToCompleteException {
+    for (SortedMap<SelectionProperty, String> map : result.getPropertyMap()) {
+      pw.print("# { ");
+
+      boolean needsComma = false;
+      for (Map.Entry<SelectionProperty, String> entry : map.entrySet()) {
+        if (needsComma) {
+          pw.print(" , ");
+        } else {
+          needsComma = true;
+        }
+
+        pw.print("'");
+        pw.print(entry.getKey().getName());
+        pw.print("' : '");
+        pw.print(entry.getValue());
+        pw.print("'");
+      }
+      pw.println(" }");
+    }
+
+    for (Map.Entry<String, String> entry : result.getSymbolMap().entrySet()) {
+      // Don't use an actual Properties object because it emits a timestamp
+      pw.print(entry.getKey());
+      pw.print(" = ");
+      pw.print(entry.getValue());
+      pw.println();
+    }
+  }
+}
diff --git a/dev/core/src/com/google/gwt/core/linker/XSLinker.java b/dev/core/src/com/google/gwt/core/linker/XSLinker.java
index 6d551fe..8f3a486 100644
--- a/dev/core/src/com/google/gwt/core/linker/XSLinker.java
+++ b/dev/core/src/com/google/gwt/core/linker/XSLinker.java
@@ -75,6 +75,8 @@
     out.newlineOpt();
     out.print("var $moduleName, $moduleBase;");
     out.newlineOpt();
+    out.print("var $strongName = '" + strongName + "';");
+    out.newlineOpt();
     out.print("var $stats = $wnd.__gwtStatsEvent ? function(a) {return $wnd.__gwtStatsEvent(a);} : null;");
     out.newlineOpt();
     out.print("$stats && $stats({moduleName:'" + context.getModuleName()
diff --git a/dev/core/src/com/google/gwt/dev/PermutationResult.java b/dev/core/src/com/google/gwt/dev/PermutationResult.java
index 41fe2b0..67e7da8 100644
--- a/dev/core/src/com/google/gwt/dev/PermutationResult.java
+++ b/dev/core/src/com/google/gwt/dev/PermutationResult.java
@@ -18,6 +18,7 @@
 import com.google.gwt.core.ext.linker.ArtifactSet;
 
 import java.io.Serializable;
+import java.util.SortedMap;
 
 /**
  * An extensible return type for the results of compiling a single permutation.
@@ -33,4 +34,9 @@
    * The compiled JavaScript code.
    */
   String[] getJs();
+
+  /**
+   * The symbol map for the permutation.
+   */
+  SortedMap<String, String> getSymbolMap();
 }
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 c64996e..0f934f9 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
@@ -100,6 +100,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
 import java.util.TreeSet;
 
 /**
@@ -111,9 +113,12 @@
   private static class PermutationResultImpl implements PermutationResult {
     private final ArtifactSet artifacts = new ArtifactSet();
     private final String[] js;
+    private final SortedMap<String, String> symbolMap;
 
-    public PermutationResultImpl(String[] js) {
+    public PermutationResultImpl(String[] js,
+        SortedMap<String, String> symbolMap) {
       this.js = js;
+      this.symbolMap = symbolMap;
     }
 
     public ArtifactSet getArtifacts() {
@@ -123,6 +128,10 @@
     public String[] getJs() {
       return js;
     }
+
+    public SortedMap<String, String> getSymbolMap() {
+      return symbolMap;
+    }
   }
 
   /**
@@ -151,6 +160,7 @@
       JProgram jprogram = ast.getJProgram();
       JsProgram jsProgram = ast.getJsProgram();
       JJSOptions options = unifiedAst.getOptions();
+      Map<String, JsName> symbolTable = new HashMap<String, JsName>();
 
       ResolveRebinds.exec(jprogram, rebindAnswers);
 
@@ -175,8 +185,8 @@
 
       // (7) Generate a JavaScript code DOM from the Java type declarations
       jprogram.typeOracle.recomputeAfterOptimizations();
-      final JavaToJavaScriptMap map = GenerateJavaScriptAST.exec(jprogram,
-          jsProgram, options.getOutput());
+      JavaToJavaScriptMap map = GenerateJavaScriptAST.exec(jprogram, jsProgram,
+          options.getOutput(), symbolTable);
 
       // (8) Normalize the JS AST.
       // Fix invalid constructs created during JS AST gen.
@@ -261,7 +271,9 @@
         }
       }
 
-      PermutationResult toReturn = new PermutationResultImpl(js);
+      SortedMap<String, String> symbolMap = makeSymbolMap(symbolTable);
+
+      PermutationResult toReturn = new PermutationResultImpl(js, symbolMap);
       if (sourceInfoMaps != null) {
         toReturn.getArtifacts().add(
             new StandardCompilationAnalysis(logger, sourceInfoMaps,
@@ -752,4 +764,15 @@
     return amp.makeStatement();
   }
 
+  private static SortedMap<String, String> makeSymbolMap(
+      Map<String, JsName> symbolTable) {
+
+    SortedMap<String, String> toReturn = new TreeMap<String, String>();
+
+    for (Map.Entry<String, JsName> entry : symbolTable.entrySet()) {
+      toReturn.put(entry.getKey(), entry.getValue().getShortIdent());
+    }
+
+    return toReturn;
+  }
 }
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 9ae265b..079e17f 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
@@ -165,6 +165,7 @@
         JsName jsName = topScope.declareName(mangleName, name);
         x.getSourceInfo().addCorrelation(Correlation.by(jsName));
         names.put(x, jsName);
+        recordSymbol(x, jsName);
       } else {
         JsName jsName;
         if (x == arrayLengthField) {
@@ -178,6 +179,7 @@
         }
         x.getSourceInfo().addCorrelation(Correlation.by(jsName));
         names.put(x, jsName);
+        recordSymbol(x, jsName);
       }
     }
 
@@ -245,6 +247,7 @@
       JsName jsName = topScope.declareName(getNameString(x), x.getShortName());
       x.getSourceInfo().addCorrelation(Correlation.by(jsName));
       names.put(x, jsName);
+      recordSymbol(x, jsName);
 
       // My class scope
       if (x.extnds == null) {
@@ -313,6 +316,7 @@
       globalName = topScope.declareName(mangleName, name);
       x.getSourceInfo().addCorrelation(Correlation.by(globalName));
       names.put(x, globalName);
+      recordSymbol(x, globalName);
 
       JsFunction jsFunction;
       if (x.isNative()) {
@@ -371,6 +375,45 @@
     private void push(JsScope scope) {
       scopeStack.push(scope);
     }
+
+    private void recordSymbol(JReferenceType x, JsName jsName) {
+      assert !symbolTable.containsKey(x.getName());
+      symbolTable.put(x.getName(), jsName);
+    }
+
+    private <T extends HasEnclosingType & HasName> void recordSymbol(T x,
+        JsName jsName) {
+      StringBuilder sb = new StringBuilder();
+      sb.append(x.getEnclosingType().getName());
+      sb.append("::");
+
+      /*
+       * NB: The use of x.getName() can produce confusion in cases where a type
+       * has both polymorphic and static dispatch for a method, because you
+       * might see HashSet::$add() and HashSet::add(). Logically, these methods
+       * should be treated equally, however they will be implemented with
+       * separate global functions and must be recorded independently.
+       * 
+       * Automated systems that process the symbol information can easily map
+       * the statically-dispatched function by looking for method names that
+       * begin with a dollar-sign and whose first parameter is the enclosing
+       * type.
+       */
+      sb.append(x.getName());
+
+      if (x instanceof JMethod) {
+        sb.append('(');
+        for (JType t : ((JMethod) x).getOriginalParamTypes()) {
+          sb.append(t.getJsniSignatureName());
+        }
+        sb.append(')');
+      }
+
+      assert !symbolTable.containsKey(sb.toString()) : "Duplicate symbol "
+          + "recorded " + jsName.getIdent() + " for " + x.getName()
+          + " and key " + sb.toString();
+      symbolTable.put(sb.toString(), jsName);
+    }
   }
 
   private class GenerateJavaScriptVisitor extends GenerateJavaScriptLiterals {
@@ -388,8 +431,9 @@
     private JsFunction[] entryFunctions;
 
     /**
-     * A reverse index for the entry methods of the program ({@link JProgram#getAllEntryMethods()}).
-     * Each entry method is mapped to its integer index.
+     * A reverse index for the entry methods of the program (
+     * {@link JProgram#getAllEntryMethods()}). Each entry method is mapped to
+     * its integer index.
      */
     private Map<JMethod, Integer> entryMethodToIndex;
 
@@ -1450,7 +1494,6 @@
           JsNew newExpr = new JsNew(sourceInfo);
           JsNameRef superPrototypeRef = names.get(x.extnds).makeRef(sourceInfo);
           newExpr.setConstructorExpression(superPrototypeRef);
-          JsNode<?> staticRef = superPrototypeRef.getName().getStaticRef();
           rhs = newExpr;
         } else {
           rhs = new JsObjectLiteral(sourceInfo);
@@ -1760,9 +1803,9 @@
   }
 
   public static JavaToJavaScriptMap exec(JProgram program, JsProgram jsProgram,
-      JsOutputOption output) {
+      JsOutputOption output, Map<String, JsName> symbolTable) {
     GenerateJavaScriptAST generateJavaScriptAST = new GenerateJavaScriptAST(
-        program, jsProgram, output);
+        program, jsProgram, output, symbolTable);
     return generateJavaScriptAST.execImpl();
   }
 
@@ -1831,8 +1874,13 @@
 
   private final Map<JsStatement, JMethod> vtableInitForMethodMap = new HashMap<JsStatement, JMethod>();
 
+  /**
+   * Maps JsNames to machine-usable identifiers.
+   */
+  private final Map<String, JsName> symbolTable;
+
   private GenerateJavaScriptAST(JProgram program, JsProgram jsProgram,
-      JsOutputOption output) {
+      JsOutputOption output, Map<String, JsName> symbolTable) {
     this.program = program;
     typeOracle = program.typeOracle;
     this.jsProgram = jsProgram;
@@ -1840,6 +1888,7 @@
     objectScope = jsProgram.getObjectScope();
     interfaceScope = new JsScope(objectScope, "Interfaces");
     this.output = output;
+    this.symbolTable = symbolTable;
 
     /*
      * Because we modify String's prototype, all fields and polymorphic methods
diff --git a/user/src/com/google/gwt/core/Core.gwt.xml b/user/src/com/google/gwt/core/Core.gwt.xml
index 7448eca..b207319 100644
--- a/user/src/com/google/gwt/core/Core.gwt.xml
+++ b/user/src/com/google/gwt/core/Core.gwt.xml
@@ -20,12 +20,15 @@
 <module>
   <inherits name="com.google.gwt.dev.jjs.intrinsic.Intrinsic" />
   <inherits name="com.google.gwt.emul.Emulation" />
-  <define-linker name="std" class="com.google.gwt.core.linker.IFrameLinker" />
-  <define-linker name="xs" class="com.google.gwt.core.linker.XSLinker" />
+
+  <define-linker name="soycReport" class="com.google.gwt.core.linker.soyc.SoycReportLinker" />
   <define-linker name="sso" class="com.google.gwt.core.linker.SingleScriptLinker" />
-  
+  <define-linker name="std" class="com.google.gwt.core.linker.IFrameLinker" />
+  <define-linker name="symbolMaps" class="com.google.gwt.core.linker.SymbolMapsLinker" />
+  <define-linker name="xs" class="com.google.gwt.core.linker.XSLinker" />
+
   <add-linker name="std" />
-  
-  <define-linker class="com.google.gwt.core.linker.soyc.SoycReportLinker" name="soycReport" />
   <add-linker name="soycReport" />
+  <add-linker name="symbolMaps" />
+
 </module>
diff --git a/user/src/com/google/gwt/core/CoreWithUserAgent.gwt.xml b/user/src/com/google/gwt/core/CoreWithUserAgent.gwt.xml
new file mode 100644
index 0000000..f6a87e2
--- /dev/null
+++ b/user/src/com/google/gwt/core/CoreWithUserAgent.gwt.xml
@@ -0,0 +1,33 @@
+<!--                                                                        -->
+<!-- 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   -->
+<!-- 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. License for the specific language governing permissions and   -->
+<!-- limitations under the License.                                         -->
+
+<!-- Deferred binding rules for core classes based on user agent. -->
+<module>
+  <inherits name="com.google.gwt.core.Core"/>
+  
+  <replace-with class="com.google.gwt.core.client.impl.StackTraceCreator.CollectorMoz">
+    <when-type-is class="com.google.gwt.core.client.impl.StackTraceCreator.Collector" />
+    <any>
+      <when-property-is name="user.agent" value="gecko" />
+      <when-property-is name="user.agent" value="gecko1_8" />
+    </any>
+  </replace-with>
+
+  <replace-with class="com.google.gwt.core.client.impl.StackTraceCreator.CollectorOpera">
+    <when-type-is class="com.google.gwt.core.client.impl.StackTraceCreator.Collector" />
+    <any>
+      <when-property-is name="user.agent" value="opera" />
+    </any>
+  </replace-with>
+</module>
\ No newline at end of file
diff --git a/user/src/com/google/gwt/core/client/GWT.java b/user/src/com/google/gwt/core/client/GWT.java
index 6062bd1..bd27959 100644
--- a/user/src/com/google/gwt/core/client/GWT.java
+++ b/user/src/com/google/gwt/core/client/GWT.java
@@ -50,6 +50,12 @@
   }
 
   /**
+   * This constant is used by {@link #getPermutationStrongName} when running in
+   * hosted mode.
+   */
+  public static final String HOSTED_MODE_PERMUTATION_STRONG_NAME = "HostedMode";
+
+  /**
    * Always <code>null</code> in web mode; in hosted mode provides the
    * implementation for certain methods.
    */
@@ -123,6 +129,19 @@
   }
 
   /**
+   * Returns the permutation's strong name. This can be used to distinguish
+   * between different permutations of the same module. In hosted mode, this
+   * method will return {@value #HOSTED_MODE_PERMUTATION_ID}.
+   */
+  public static String getPermutationStrongName() {
+    if (GWT.isScript()) {
+      return Impl.getPermutationStrongName();
+    } else {
+      return HOSTED_MODE_PERMUTATION_STRONG_NAME;
+    }
+  }
+
+  /**
    * @deprecated Use {@link Object#getClass()}, {@link Class#getName()}.
    */
   @Deprecated
diff --git a/user/src/com/google/gwt/core/client/HttpThrowableReporter.java b/user/src/com/google/gwt/core/client/HttpThrowableReporter.java
new file mode 100644
index 0000000..5088667
--- /dev/null
+++ b/user/src/com/google/gwt/core/client/HttpThrowableReporter.java
@@ -0,0 +1,109 @@
+/*
+ * 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.core.client;
+
+import com.google.gwt.core.client.GWT.UncaughtExceptionHandler;
+import com.google.gwt.xhr.client.XMLHttpRequest;
+
+/**
+ * This is a utility class which can report Throwables to the server via a
+ * JSON-formatted payload.
+ */
+public final class HttpThrowableReporter {
+
+  private static class MyHandler implements UncaughtExceptionHandler {
+    private final String url;
+
+    public MyHandler(String url) {
+      this.url = url;
+    }
+
+    public void onUncaughtException(Throwable e) {
+      report(url, e);
+    }
+  }
+
+  /**
+   * Installs an {@link UncaughtExceptionHandler} that will automatically invoke
+   * {@link #report(String, Throwable)}.
+   * 
+   * @param url A URL that is suitable for use with {@link XMLHttpRequest}
+   */
+  public static void installUncaughtExceptionHandler(String url) {
+    GWT.setUncaughtExceptionHandler(new MyHandler(url));
+  }
+
+  /**
+   * Report a Throwable to the server. This method will sent an HTTP
+   * <code>POST</code> request with a JSON-formatted payload. The payload will
+   * consist of a single JSON object with the following keys:
+   * <dl>
+   * <dt>strongName</dt>
+   * <dd>The result of calling {@link GWT#getPermutationStrongName()}</dd>
+   * <dt>message</dt>
+   * <dd>The result of calling {@link Throwable#getMessage()}</dd>
+   * <dt>stackTrace</dt>
+   * <dd>A list of the methods names in the Throwable's stack trace, derived
+   * from {@link StackTraceElement#getMethodName()}.</dd>
+   * </dl>
+   * 
+   * The response from the server is ignored.
+   * 
+   * @param url A URL that is suitable for use with {@link XMLHttpRequest}
+   * @param t The Throwable to report
+   * @return <code>true</code> if the request was successfully initiated
+   * @see com.google.gwt.core.linker.SymbolMapsLinker
+   */
+  public static boolean report(String url, Throwable t) {
+    try {
+      XMLHttpRequest xhr = XMLHttpRequest.create();
+      xhr.open("POST", url);
+      xhr.send(buildPayload(t));
+      return true;
+    } catch (Throwable t2) {
+      return false;
+    }
+  }
+
+  /**
+   * Visible for testing.
+   */
+  static String buildPayload(Throwable t) {
+    StringBuilder sb = new StringBuilder();
+    sb.append("{\"strongName\" : ");
+    sb.append(JsonUtils.escapeValue(GWT.getPermutationStrongName()));
+    sb.append(",\"message\" : ");
+    sb.append(JsonUtils.escapeValue(t.getMessage()));
+
+    sb.append(",\"stackTrace\" : [");
+    boolean needsComma = false;
+    for (StackTraceElement e : t.getStackTrace()) {
+      if (needsComma) {
+        sb.append(",");
+      } else {
+        needsComma = true;
+      }
+
+      sb.append(JsonUtils.escapeValue(e.getMethodName()));
+    }
+    sb.append("]}");
+
+    return sb.toString();
+  }
+
+  private HttpThrowableReporter() {
+  }
+}
diff --git a/user/src/com/google/gwt/core/client/JavaScriptException.java b/user/src/com/google/gwt/core/client/JavaScriptException.java
index 8bb9b72..c319838 100644
--- a/user/src/com/google/gwt/core/client/JavaScriptException.java
+++ b/user/src/com/google/gwt/core/client/JavaScriptException.java
@@ -15,12 +15,33 @@
  */
 package com.google.gwt.core.client;
 
+import com.google.gwt.core.client.impl.StackTraceCreator;
+
 /**
  * Any JavaScript exceptions occurring within JSNI methods are wrapped as this
  * class when caught in Java code. The wrapping does not occur until the
  * exception passes out of JSNI into Java. Before that, the thrown object
  * remains a native JavaScript exception object, and can be caught in JSNI as
  * normal.
+ * <p>
+ * The return value of {@link #getStackTrace()} may vary between browsers due to
+ * variations in the underlying error-reporting capabilities. When possible, the
+ * stack trace will be the stack trace of the underlying error object. If it is
+ * not possible to accurately report a stack trace, a zero-length array will be
+ * returned. In those cases where the underlying stack trace cannot be
+ * determined, {@link #fillInStackTrace()} can be called in the associated catch
+ * block to create a stack trace corresponding to the location where the
+ * JavaScriptException object was created.
+ * 
+ * <pre>
+ * try {
+ *   nativeMethod();
+ * } catch (JavaScriptException e) {
+ *   if (e.getStackTrace().length == 0) {
+ *     e.fillInStackTrace();
+ *   }
+ * }
+ * </pre>
  */
 public final class JavaScriptException extends RuntimeException {
 
@@ -105,6 +126,17 @@
    */
   public JavaScriptException(Object e) {
     this.e = e;
+    /*
+     * In hosted mode, JavaScriptExceptions are created exactly when the native
+     * method returns and their stack traces are fixed-up by the hosted-mode
+     * plumbing.
+     * 
+     * In web mode, we'll attempt to infer the stack trace from the thrown
+     * object, although this is not possible in all browsers.
+     */
+    if (GWT.isScript()) {
+      StackTraceCreator.createStackTrace(this);
+    }
   }
 
   public JavaScriptException(String name, String description) {
@@ -163,7 +195,7 @@
     }
     return name;
   }
-  
+
   private void init() {
     name = getName(e);
     description = getDescription(e);
diff --git a/user/src/com/google/gwt/core/client/JsonUtils.java b/user/src/com/google/gwt/core/client/JsonUtils.java
new file mode 100644
index 0000000..c205ece
--- /dev/null
+++ b/user/src/com/google/gwt/core/client/JsonUtils.java
@@ -0,0 +1,76 @@
+/*
+ * 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.core.client;
+
+/**
+ * Provides JSON-related utility methods.
+ */
+public class JsonUtils {
+  @SuppressWarnings("unused")
+  private static JavaScriptObject escapeTable = initEscapeTable();
+
+  /**
+   * Returns a quoted, escaped JSON String.
+   */
+  public static native String escapeValue(String toEscape) /*-{
+    var s = toEscape.replace(/[\x00-\x1F\u2028\u2029"\\]/g, function(x) {
+      return @com.google.gwt.core.client.JsonUtils::escapeChar(Ljava/lang/String;)(x);
+    });
+    return "\"" + s + "\"";
+  }-*/;
+
+  /*
+   * TODO: Implement safeEval using a proper parser.
+   */
+
+  /**
+   * Evaluates a JSON expression. This method does not validate the JSON text
+   * and should only be used on JSON from trusted sources.
+   * 
+   * @param <T> The type of JavaScriptObject that should be returned
+   * @param json The source JSON text
+   * @return The evaluated object
+   */
+  public static native <T extends JavaScriptObject> T unsafeEval(String json) /*-{
+    return eval('(' + json + ')');
+  }-*/;
+
+  @SuppressWarnings("unused")
+  private static native String escapeChar(String c) /*-{
+    var lookedUp = @com.google.gwt.core.client.JsonUtils::escapeTable[c.charCodeAt(0)];
+    return (lookedUp == null) ? c : lookedUp;
+  }-*/;
+
+  private static native JavaScriptObject initEscapeTable() /*-{
+    var out = [
+      "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005",
+      "\\u0006", "\\u0007", "\\b", "\\t", "\\n", "\\u000B",
+      "\\f", "\\r", "\\u000E", "\\u000F", "\\u0010", "\\u0011",
+      "\\u0012", "\\u0013", "\\u0014", "\\u0015", "\\u0016", "\\u0017",
+      "\\u0018", "\\u0019", "\\u001A", "\\u001B", "\\u001C", "\\u001D",
+      "\\u001E", "\\u001F"];
+    out[34] = '\\"';
+    out[92] = '\\\\';
+
+    // Unicode line separator chars
+    out[0x2028] = '\\u2028';
+    out[0x2029] = '\\u2029';
+    return out;
+  }-*/;
+
+  private JsonUtils() {
+  }
+}
diff --git a/user/src/com/google/gwt/core/client/impl/Impl.java b/user/src/com/google/gwt/core/client/impl/Impl.java
index c8426c7..2bbeb48 100644
--- a/user/src/com/google/gwt/core/client/impl/Impl.java
+++ b/user/src/com/google/gwt/core/client/impl/Impl.java
@@ -66,6 +66,10 @@
     return $moduleName;
   }-*/;
 
+  public static native String getPermutationStrongName() /*-{
+    return $strongName;
+  }-*/;
+
   /**
    * Called from JSNI. Do not change this implementation without updating:
    * <ul>
diff --git a/user/src/com/google/gwt/core/client/impl/StackTraceCreator.java b/user/src/com/google/gwt/core/client/impl/StackTraceCreator.java
new file mode 100644
index 0000000..559a58e
--- /dev/null
+++ b/user/src/com/google/gwt/core/client/impl/StackTraceCreator.java
@@ -0,0 +1,221 @@
+/*
+ * 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.core.client.impl;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.JavaScriptException;
+import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.core.client.JsArrayString;
+
+/**
+ * Encapsulates logic to create a stack trace. This class should only be used in
+ * web mode.
+ */
+public class StackTraceCreator {
+  /**
+   * This class acts as a deferred-binding hook point to allow more optimal
+   * versions to be substituted. This base version simply crawls
+   * <code>arguments.callee.caller</code>.
+   */
+  static class Collector {
+    public native JsArrayString collect() /*-{
+      var seen = {};
+      var toReturn = [];
+
+      // Ignore the collect() and fillInStackTrace call
+      var callee = arguments.callee.caller.caller;
+      while (callee) {
+        var name = this.@com.google.gwt.core.client.impl.StackTraceCreator.Collector::extractName(Ljava/lang/String;)(callee.toString());
+        toReturn.push(name);
+
+        // Avoid infinite loop by associating names to function objects.  We
+        // record each caller in the withThisName variable to handle functions
+        // with identical names but separate identity (such as 'anonymous')
+        var keyName = ':' + name;
+        var withThisName = seen[keyName];
+        if (withThisName) {
+          var i, j;
+          for (i = 0, j = withThisName.length; i < j; i++) {
+            if (withThisName[i] === callee) {
+              return toReturn;
+            }
+          }
+        }
+
+        (withThisName || (seen[keyName] = [])).push(callee);
+        callee = callee.caller;
+      }
+      return toReturn;
+    }-*/;
+
+    /**
+     * Attempt to infer the stack from an unknown JavaScriptObject that had been
+     * thrown. The default implementation just returns an empty array.
+     */
+    public JsArrayString inferFrom(JavaScriptObject e) {
+      return JavaScriptObject.createArray().cast();
+    }
+
+    /**
+     * Extract the name of a function from it's toString() representation.
+     * Package-access for testing.
+     */
+    protected String extractName(String fnToString) {
+      return extractNameFromToString(fnToString);
+    }
+
+    /**
+     * Raise an exception and return it.
+     */
+    protected native JavaScriptObject makeException() /*-{
+      try {
+        null.a();
+      } catch (e) {
+        return e;
+      }
+    }-*/;
+  }
+
+  /**
+   * Mozilla provides a <code>stack</code> property in thrown objects.
+   */
+  static class CollectorMoz extends Collector {
+    /**
+     * This implementation doesn't suffer from the limitations of crawling
+     * <code>caller</code> since Mozilla provides proper activation records.
+     */
+    @Override
+    public JsArrayString collect() {
+      return splice(inferFrom(makeException()), toSplice());
+    }
+
+    @Override
+    public JsArrayString inferFrom(JavaScriptObject e) {
+      JsArrayString stack = getStack(e);
+      for (int i = 0, j = stack.length(); i < j; i++) {
+        stack.set(i, extractName(stack.get(i)));
+      }
+      return stack;
+    }
+
+    protected native JsArrayString getStack(JavaScriptObject e) /*-{
+      return !!e.stack ? e.stack.split('\n') : [];
+    }-*/;
+
+    protected int toSplice() {
+      return 2;
+    }
+  }
+
+  /**
+   * Opera encodes stack trace information in the error's message.
+   */
+  static class CollectorOpera extends CollectorMoz {
+    /**
+     * We have much a much simpler format to work with.
+     */
+    @Override
+    protected String extractName(String fnToString) {
+      return fnToString.length() == 0 ? "anonymous" : fnToString;
+    }
+
+    /**
+     * Opera has the function name on every-other line.
+     */
+    @Override
+    protected JsArrayString getStack(JavaScriptObject e) {
+      JsArrayString toReturn = getMessage(e);
+      assert toReturn.length() % 2 == 0 : "Expecting an even number of lines";
+
+      int i, i2, j;
+      for (i = 0, i2 = 0, j = toReturn.length(); i2 < j; i++, i2 += 2) {
+        int idx = toReturn.get(i2).lastIndexOf("function ");
+        if (idx == -1) {
+          toReturn.set(i, "");
+        } else {
+          toReturn.set(i, toReturn.get(i2).substring(idx + 9).trim());
+        }
+      }
+      setLength(toReturn, i);
+
+      return toReturn;
+    }
+
+    @Override
+    protected int toSplice() {
+      return 3;
+    }
+
+    private native JsArrayString getMessage(JavaScriptObject e) /*-{
+      return !!e.message ? e.message.split('\n') : [];
+    }-*/;
+
+    private native void setLength(JsArrayString obj, int length) /*-{
+      obj.length = length;
+    }-*/;
+  }
+
+  /**
+   * Create a stack trace based on the current execution stack. This method
+   * should only be called in web mode.
+   */
+  public static JsArrayString createStackTrace() {
+    if (!GWT.isScript()) {
+      throw new RuntimeException(
+          "StackTraceCreator should only be called in web mode");
+    }
+
+    return GWT.<Collector> create(Collector.class).collect();
+  }
+
+  /**
+   * Create a stack trace based on a JavaScriptException. This method should
+   * only be called in web mode.
+   */
+  public static void createStackTrace(JavaScriptException e) {
+    if (!GWT.isScript()) {
+      throw new RuntimeException(
+          "StackTraceCreator should only be called in web mode");
+    }
+
+    JsArrayString stack = GWT.<Collector> create(Collector.class).inferFrom(
+        e.getException());
+
+    StackTraceElement[] stackTrace = new StackTraceElement[stack.length()];
+    for (int i = 0, j = stackTrace.length; i < j; i++) {
+      stackTrace[i] = new StackTraceElement("Unknown", stack.get(i),
+          "Unknown source", 0);
+    }
+    e.setStackTrace(stackTrace);
+  }
+
+  static String extractNameFromToString(String fnToString) {
+    String toReturn = "";
+
+    int index = fnToString.indexOf("(");
+    if (index != -1) {
+      int start = fnToString.startsWith("function") ? 8 : 0;
+      toReturn = fnToString.substring(start, index).trim();
+    }
+
+    return toReturn.length() > 0 ? toReturn : "anonymous";
+  }
+
+  private static native JsArrayString splice(JsArrayString arr, int length) /*-{
+    arr.splice(0, length);
+    return arr;
+  }-*/;
+}
diff --git a/user/src/com/google/gwt/json/client/JSONObject.java b/user/src/com/google/gwt/json/client/JSONObject.java
index bb6867a..77080a3 100644
--- a/user/src/com/google/gwt/json/client/JSONObject.java
+++ b/user/src/com/google/gwt/json/client/JSONObject.java
@@ -17,6 +17,7 @@
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.core.client.JsonUtils;
 
 import java.util.AbstractSet;
 import java.util.ArrayList;
@@ -178,7 +179,7 @@
       } else {
         sb.append(", ");
       }
-      sb.append(JSONString.escapeValue(key));
+      sb.append(JsonUtils.escapeValue(key));
       sb.append(":");
       sb.append(get(key));
     }
diff --git a/user/src/com/google/gwt/json/client/JSONString.java b/user/src/com/google/gwt/json/client/JSONString.java
index 5ad02d0..abdb44d 100644
--- a/user/src/com/google/gwt/json/client/JSONString.java
+++ b/user/src/com/google/gwt/json/client/JSONString.java
@@ -16,39 +16,13 @@
 package com.google.gwt.json.client;
 
 import com.google.gwt.core.client.JavaScriptObject;
+import com.google.gwt.core.client.JsonUtils;
 
 /**
  * Represents a JSON string.
  */
 public class JSONString extends JSONValue {
 
-  static JavaScriptObject escapeTable = initEscapeTable();
-
-  static native String escapeChar(String c) /*-{
-    var lookedUp = @com.google.gwt.json.client.JSONString::escapeTable[c.charCodeAt(0)];
-    return (lookedUp == null) ? c : lookedUp;
-  }-*/;
-
-  static native String escapeValue(String toEscape) /*-{
-    var s = toEscape.replace(/[\x00-\x1F"\\]/g, function(x) {
-      return @com.google.gwt.json.client.JSONString::escapeChar(Ljava/lang/String;)(x);
-    });
-    return "\"" + s + "\"";
-  }-*/;
-
-  private static native JavaScriptObject initEscapeTable() /*-{
-    var out = [
-      "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005",
-      "\\u0006", "\\u0007", "\\b", "\\t", "\\n", "\\u000B",
-      "\\f", "\\r", "\\u000E", "\\u000F", "\\u0010", "\\u0011",
-      "\\u0012", "\\u0013", "\\u0014", "\\u0015", "\\u0016", "\\u0017",
-      "\\u0018", "\\u0019", "\\u001A", "\\u001B", "\\u001C", "\\u001D",
-      "\\u001E", "\\u001F"];
-    out[34] = '\\"';
-    out[92] = '\\\\';
-    return out;
-  }-*/;
-
   /**
    * Called from {@link #getUnwrapper()}. 
    */
@@ -107,7 +81,7 @@
    */
   @Override
   public String toString() {
-    return escapeValue(value);
+    return JsonUtils.escapeValue(value);
   }
 
   @Override
diff --git a/user/src/com/google/gwt/user/UserAgent.gwt.xml b/user/src/com/google/gwt/user/UserAgent.gwt.xml
index 6e4a49f..d073cd7 100644
--- a/user/src/com/google/gwt/user/UserAgent.gwt.xml
+++ b/user/src/com/google/gwt/user/UserAgent.gwt.xml
@@ -51,4 +51,5 @@
 
   <!-- Deferred binding to optimize JRE classes based on user agent. -->
   <inherits name="com.google.gwt.emul.EmulationWithUserAgent"/>
+  <inherits name="com.google.gwt.core.CoreWithUserAgent"/>
 </module>
diff --git a/user/super/com/google/gwt/emul/java/lang/StackTraceElement.java b/user/super/com/google/gwt/emul/java/lang/StackTraceElement.java
index 9f3c915..90abbba 100644
--- a/user/super/com/google/gwt/emul/java/lang/StackTraceElement.java
+++ b/user/super/com/google/gwt/emul/java/lang/StackTraceElement.java
@@ -32,6 +32,17 @@
 
   private String methodName;
 
+  public StackTraceElement() {
+  }
+
+  public StackTraceElement(String className, String methodName, String fileName,
+      int lineNumber) {
+    this.className = className;
+    this.methodName = methodName;
+    this.fileName = fileName;
+    this.lineNumber = lineNumber;
+  }
+
   public String getClassName() {
     return className;
   }
diff --git a/user/super/com/google/gwt/emul/java/lang/Throwable.java b/user/super/com/google/gwt/emul/java/lang/Throwable.java
index f212156..b41223c 100644
--- a/user/super/com/google/gwt/emul/java/lang/Throwable.java
+++ b/user/super/com/google/gwt/emul/java/lang/Throwable.java
@@ -15,6 +15,9 @@
  */
 package java.lang;
 
+import com.google.gwt.core.client.JsArrayString;
+import com.google.gwt.core.client.impl.StackTraceCreator;
+
 import java.io.PrintStream;
 import java.io.Serializable;
 
@@ -40,6 +43,10 @@
   private String detailMessage;
   private transient StackTraceElement[] stackTrace;
 
+  {
+    fillInStackTrace();
+  }
+
   public Throwable() {
   }
 
@@ -58,11 +65,17 @@
   }
 
   /**
-   * Stack traces are not currently populated by GWT. This method does nothing.
+   * Populates the stack trace information for the Throwable.
    * 
    * @return this
    */
   public Throwable fillInStackTrace() {
+    JsArrayString stack = StackTraceCreator.createStackTrace();
+    stackTrace = new StackTraceElement[stack.length()];
+    for (int i = 0, j = stackTrace.length; i < j; i++) {
+      stackTrace[i] = new StackTraceElement("Unknown", stack.get(i),
+          "Unknown source", 0);
+    }
     return this;
   }
 
diff --git a/user/test/com/google/gwt/core/CoreSuite.java b/user/test/com/google/gwt/core/CoreSuite.java
index 0bc8039..18e67ad 100644
--- a/user/test/com/google/gwt/core/CoreSuite.java
+++ b/user/test/com/google/gwt/core/CoreSuite.java
@@ -16,8 +16,10 @@
 package com.google.gwt.core;
 
 import com.google.gwt.core.client.GWTTest;
+import com.google.gwt.core.client.HttpThrowableReporterTest;
 import com.google.gwt.core.client.JavaScriptExceptionTest;
 import com.google.gwt.core.client.JsArrayTest;
+import com.google.gwt.core.client.impl.StackTraceCreatorTest;
 import com.google.gwt.junit.tools.GWTTestSuite;
 
 import junit.framework.Test;
@@ -30,9 +32,11 @@
     GWTTestSuite suite = new GWTTestSuite("All core tests");
 
     // $JUnit-BEGIN$
+    suite.addTestSuite(HttpThrowableReporterTest.class);
     suite.addTestSuite(JavaScriptExceptionTest.class);
     suite.addTestSuite(JsArrayTest.class);
     suite.addTestSuite(GWTTest.class);
+    suite.addTestSuite(StackTraceCreatorTest.class);
     // $JUnit-END$
 
     return suite;
diff --git a/user/test/com/google/gwt/core/client/HttpThrowableReporterTest.java b/user/test/com/google/gwt/core/client/HttpThrowableReporterTest.java
new file mode 100644
index 0000000..58ccfa0
--- /dev/null
+++ b/user/test/com/google/gwt/core/client/HttpThrowableReporterTest.java
@@ -0,0 +1,70 @@
+/*
+ * 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.core.client;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests the HttpThrowableReporter.
+ */
+public class HttpThrowableReporterTest extends GWTTestCase {
+  private static final class Payload extends JavaScriptObject {
+    protected Payload() {
+    }
+
+    public native String getMessage() /*-{
+      return this.message;
+    }-*/;
+
+    public native JsArrayString getStackTrace() /*-{
+      return this.stackTrace;
+    }-*/;
+
+    public native String getStrongName() /*-{
+      return this.strongName;
+    }-*/;
+  }
+
+  public String getModuleName() {
+    return "com.google.gwt.core.Core";
+  }
+
+  public void testPayload() {
+    String payload;
+    Throwable e;
+
+    try {
+      throw new RuntimeException("foo");
+    } catch (Throwable t) {
+      e = t;
+      payload = HttpThrowableReporter.buildPayload(t);
+    }
+
+    assertNotNull(payload);
+    Payload p = JsonUtils.unsafeEval(payload);
+
+    assertEquals("foo", p.getMessage());
+    assertEquals(GWT.getPermutationStrongName(), p.getStrongName());
+
+    JsArrayString stack = p.getStackTrace();
+    assertNotNull(stack);
+    assertEquals(e.getStackTrace().length, stack.length());
+
+    for (int i = 0, j = e.getStackTrace().length; i < j; i++) {
+      assertEquals(e.getStackTrace()[i].getMethodName(), stack.get(i));
+    }
+  }
+}
diff --git a/user/test/com/google/gwt/core/client/impl/StackTraceCreatorTest.java b/user/test/com/google/gwt/core/client/impl/StackTraceCreatorTest.java
new file mode 100644
index 0000000..d61492b
--- /dev/null
+++ b/user/test/com/google/gwt/core/client/impl/StackTraceCreatorTest.java
@@ -0,0 +1,148 @@
+/*
+ * 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.core.client.impl;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.JavaScriptException;
+import com.google.gwt.core.client.JsArrayString;
+import com.google.gwt.core.client.impl.StackTraceCreator.Collector;
+import com.google.gwt.core.client.impl.StackTraceCreator.CollectorMoz;
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests StackTraceCreator in web mode. The methods in this test class are
+ * static so that their names can be reliably determined in web mode.
+ */
+public class StackTraceCreatorTest extends GWTTestCase {
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.core.Core";
+  }
+
+  public static void testJavaScriptException() {
+    StackTraceElement[] stack = null;
+    try {
+      throwNative();
+    } catch (JavaScriptException e) {
+      /*
+       * Some browsers may or may not be able to implement this at all, so we'll
+       * at least make sure that an array is returned;
+       */
+      stack = e.getStackTrace();
+    }
+    assertNotNull(stack);
+
+    String myName = null;
+    if (!GWT.isScript()) {
+      myName = "testJavaScriptException";
+    } else if (GWT.<Collector> create(Collector.class) instanceof CollectorMoz) {
+      myName = throwNativeName();
+    }
+
+    if (myName != null) {
+      boolean found = false;
+      for (StackTraceElement elt : stack) {
+        if (elt.getMethodName().equals(myName)) {
+          found = true;
+          break;
+        }
+      }
+      assertTrue("Did not find " + myName + " in the stack " + stack, found);
+    }
+  }
+
+  /**
+   * Just make sure that reentrant behavior doesn't fail.
+   */
+  public static void testReentrantCalls() {
+    if (!GWT.isScript()) {
+      // StackTraceCreator.createStackTrace() is useless in hosted mode
+      return;
+    }
+
+    JsArrayString stack = countDown(5);
+    assertNotNull(stack);
+    assertTrue(stack.length() > 0);
+  }
+
+  public static void testStackTraces() {
+    if (!GWT.isScript()) {
+      // StackTraceCreator.createStackTrace() is useless in hosted mode
+      return;
+    }
+
+    // Since we're in web mode, we can find the name of this method's function
+    String myName = testStackTracesName();
+
+    StackTraceElement[] stack;
+    try {
+      throw new RuntimeException();
+    } catch (Throwable t) {
+      stack = t.getStackTrace();
+    }
+
+    assertNotNull(stack);
+    assertTrue(stack.length > 0);
+
+    boolean found = false;
+    for (int i = 0, j = stack.length; i < j; i++) {
+      StackTraceElement elt = stack[i];
+      String value = elt.getMethodName();
+      assertNotNull(value);
+      assertTrue(value.length() > 0);
+      assertEquals(value.length(), value.trim().length());
+
+      found |= myName.equals(value);
+    }
+
+    assertTrue("Did not find " + myName + " in the stack " + stack, found);
+  }
+
+  private static JsArrayString countDown(int count) {
+    if (count > 0) {
+      return countDown(count - 1);
+    } else {
+      return StackTraceCreator.createStackTrace();
+    }
+  }
+
+  private static native String testStackTracesName() /*-{
+    var fn = @com.google.gwt.core.client.impl.StackTraceCreatorTest::testStackTraces();
+    return @com.google.gwt.core.client.impl.StackTraceCreator::extractNameFromToString(Ljava/lang/String;)(fn.toString());
+  }-*/;
+
+  private static native void throwNative() /*-{
+    throw new Error();
+  }-*/;
+
+  private static native String throwNativeName() /*-{
+    var fn = @com.google.gwt.core.client.impl.StackTraceCreatorTest::throwNative();
+    return @com.google.gwt.core.client.impl.StackTraceCreator::extractNameFromToString(Ljava/lang/String;)(fn.toString());
+  }-*/;
+
+  public void testExtractName() {
+    assertEquals("anonymous",
+        StackTraceCreator.extractNameFromToString("function(){}"));
+    assertEquals("anonymous",
+        StackTraceCreator.extractNameFromToString("function (){}"));
+    assertEquals("anonymous",
+        StackTraceCreator.extractNameFromToString("function  (){}"));
+    assertEquals("foo",
+        StackTraceCreator.extractNameFromToString("function foo(){}"));
+    assertEquals("foo",
+        StackTraceCreator.extractNameFromToString("function foo (){}"));
+  }
+}
diff --git a/user/test/com/google/gwt/json/client/JSONTest.java b/user/test/com/google/gwt/json/client/JSONTest.java
index c10751f..ba639cd 100644
--- a/user/test/com/google/gwt/json/client/JSONTest.java
+++ b/user/test/com/google/gwt/json/client/JSONTest.java
@@ -205,7 +205,7 @@
   // Null characters do not work in hosted mode
   public void testEscaping() {
     JSONObject o = new JSONObject();
-    char[] charsToEscape = new char[40];
+    char[] charsToEscape = new char[42];
     for (char i = 1; i < 32; i++) {
       charsToEscape[i] = i;
     }
@@ -217,7 +217,9 @@
     charsToEscape[37] = '\r';
     charsToEscape[38] = '\t';
     charsToEscape[39] = '/';
-    for (int i = 1; i < 40; i++) {
+    charsToEscape[40] = '\u2028';
+    charsToEscape[41] = '\u2029';
+    for (int i = 1; i < charsToEscape.length; i++) {
       o.put("c" + i, new JSONString(new Character(charsToEscape[i]).toString()));
     }
     assertEquals("{\"c1\":\"\\u0001\", \"c2\":\"\\u0002\", "
@@ -233,7 +235,7 @@
         + "\"c30\":\"\\u001E\", \"c31\":\"\\u001F\", \"c32\":\"\\\"\", "
         + "\"c33\":\"\\\\\", \"c34\":\"\\b\", \"c35\":\"\\f\", "
         + "\"c36\":\"\\n\", \"c37\":\"\\r\", \"c38\":\"\\t\", "
-        + "\"c39\":\"/\"}", o.toString());
+        + "\"c39\":\"/\", \"c40\":\"\\u2028\", \"c41\":\"\\u2029\"}", o.toString());
   }
 
   public void testLargeArrays() {