Improve user experience of StackOverflowError (like OOM works currently). Review by: spoon Issue: 4374 git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@7483 8db76d5a-ed1c-0410-87a9-c151d255dfc7

diff --git a/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java b/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java
index 375f993..caacaec 100644
--- a/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java
+++ b/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java

@@ -52,7 +52,11 @@
       } catch (OutOfMemoryError e) {
         logger.log(TreeLogger.ERROR,
             "OutOfMemoryError: Increase heap size or lower "
-                + MAX_THREADS_PROPERTY);
+                + MAX_THREADS_PROPERTY, e);
+        throw new UnableToCompleteException();
+      } catch (StackOverflowError e) {
+        logger.log(TreeLogger.ERROR, "StackOverflowError: Increase stack size",
+            e);
         throw new UnableToCompleteException();
       }
     }

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 62327ac..b725548 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/JavaToJavaScriptCompiler.java

@@ -943,9 +943,9 @@
         }
       }
       return new UnableToCompleteException();
-    } else if (e instanceof OutOfMemoryError) {
-      // Rethrow the original exception so the caller can deal with it.
-      throw (OutOfMemoryError) e;
+    } else if (e instanceof VirtualMachineError) {
+      // Always rethrow VM errors (an attempt to wrap may fail).
+      throw (VirtualMachineError) e;
     } else {
       logger.log(TreeLogger.ERROR, "Unexpected internal compiler error", e);
       return new UnableToCompleteException();

diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JVisitor.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JVisitor.java
index ba2e24c..12cd083 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/ast/JVisitor.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JVisitor.java

@@ -63,9 +63,9 @@
 
   protected static InternalCompilerException translateException(JNode node,
       Throwable e) {
-    if (e instanceof OutOfMemoryError) {
-      // Always rethrow OOMs (might have no memory to load ICE class anyway).
-      throw (OutOfMemoryError) e;
+    if (e instanceof VirtualMachineError) {
+      // Always rethrow VM errors (an attempt to wrap may fail).
+      throw (VirtualMachineError) e;
     }
     InternalCompilerException ice;
     if (e instanceof InternalCompilerException) {

diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java b/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java
index 58b0682..34c6efc 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/BuildTypeMap.java

@@ -614,8 +614,8 @@
 
         typeDecls.add(typeDeclaration);
         return true;
-      } catch (OutOfMemoryError e) {
-        // Always rethrow OOMs (might have no memory to load ICE class anyway).
+      } catch (VirtualMachineError e) {
+        // Always rethrow VM errors (an attempt to wrap may fail).
         throw e;
       } catch (InternalCompilerException ice) {
         ice.addNode(type);
@@ -684,9 +684,9 @@
 
     private InternalCompilerException translateException(
         AbstractMethodDeclaration amd, Throwable e) {
-      if (e instanceof OutOfMemoryError) {
-        // Always rethrow OOMs (might have no memory to load ICE class anyway).
-        throw (OutOfMemoryError) e;
+      if (e instanceof VirtualMachineError) {
+        // Always rethrow VM errors (an attempt to wrap may fail).
+        throw (VirtualMachineError) e;
       }
       InternalCompilerException ice;
       if (e instanceof InternalCompilerException) {
@@ -701,9 +701,9 @@
 
     private InternalCompilerException translateException(Statement stmt,
         Throwable e) {
-      if (e instanceof OutOfMemoryError) {
-        // Always rethrow OOMs (might have no memory to load ICE class anyway).
-        throw (OutOfMemoryError) e;
+      if (e instanceof VirtualMachineError) {
+        // Always rethrow VM errors (an attempt to wrap may fail).
+        throw (VirtualMachineError) e;
       }
       InternalCompilerException ice;
       if (e instanceof InternalCompilerException) {
@@ -835,9 +835,9 @@
 
     private InternalCompilerException translateException(
         TypeDeclaration typeDecl, Throwable e) {
-      if (e instanceof OutOfMemoryError) {
-        // Always rethrow OOMs (might have no memory to load ICE class anyway).
-        throw (OutOfMemoryError) e;
+      if (e instanceof VirtualMachineError) {
+        // Always rethrow VM errors (an attempt to wrap may fail).
+        throw (VirtualMachineError) e;
       }
       InternalCompilerException ice;
       if (e instanceof InternalCompilerException) {

diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
index 0b32c72..6b02a02 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GenerateJavaAST.java

@@ -229,9 +229,9 @@
   private static class JavaASTGenerationVisitor {
     private static InternalCompilerException translateException(JNode node,
         Throwable e) {
-      if (e instanceof OutOfMemoryError) {
-        // Always rethrow OOMs (might have no memory to load ICE class anyway).
-        throw (OutOfMemoryError) e;
+      if (e instanceof VirtualMachineError) {
+        // Always rethrow VM errors (an attempt to wrap may fail).
+        throw (VirtualMachineError) e;
       }
       InternalCompilerException ice;
       if (e instanceof InternalCompilerException) {
@@ -2611,9 +2611,9 @@
 
     private InternalCompilerException translateException(Object node,
         Throwable e) {
-      if (e instanceof OutOfMemoryError) {
-        // Always rethrow OOMs (might have no memory to load ICE class anyway).
-        throw (OutOfMemoryError) e;
+      if (e instanceof VirtualMachineError) {
+        // Always rethrow VM errors (an attempt to wrap may fail).
+        throw (VirtualMachineError) e;
       }
       InternalCompilerException ice;
       if (e instanceof InternalCompilerException) {

diff --git a/dev/core/src/com/google/gwt/dev/js/ast/JsVisitor.java b/dev/core/src/com/google/gwt/dev/js/ast/JsVisitor.java
index b9ecf44..ade9877 100644
--- a/dev/core/src/com/google/gwt/dev/js/ast/JsVisitor.java
+++ b/dev/core/src/com/google/gwt/dev/js/ast/JsVisitor.java

@@ -451,9 +451,9 @@
 
   private <T extends JsVisitable<T>> InternalCompilerException translateException(
       T node, Throwable e) {
-    if (e instanceof OutOfMemoryError) {
-      // Always rethrow OOMs (might have no memory to load ICE class anyway).
-      throw (OutOfMemoryError) e;
+    if (e instanceof VirtualMachineError) {
+      // Always rethrow VM errors (an attempt to wrap may fail).
+      throw (VirtualMachineError) e;
     }
     InternalCompilerException ice;
     if (e instanceof InternalCompilerException) {

diff --git a/dev/core/src/com/google/gwt/dev/util/log/AbstractTreeLogger.java b/dev/core/src/com/google/gwt/dev/util/log/AbstractTreeLogger.java
index e3b38b0..6152dc4 100644
--- a/dev/core/src/com/google/gwt/dev/util/log/AbstractTreeLogger.java
+++ b/dev/core/src/com/google/gwt/dev/util/log/AbstractTreeLogger.java

@@ -45,6 +45,10 @@
   static final String OUT_OF_MEMORY_MSG = "Out of memory; to increase the "
       + "amount of memory, use the -Xmx flag at startup (java -Xmx128M ...)";
 
+  // This message is package-protected so that the unit test can access it.
+  static final String STACK_OVERFLOW_MSG = "Stack overflow; to increase the "
+      + "stack size, use the -Xss flag at startup (java -Xss1M ...)";
+
   public static String getStackTraceAsString(Throwable e) {
     // Show the exception info for anything other than "UnableToComplete".
     if (e == null || e instanceof UnableToCompleteException) {
@@ -143,14 +147,15 @@
         helpInfo);
 
     // This logic is intertwined with log(). If a log message is associated
-    // with an out-of-memory condition, then we turn it into a branch,
+    // with a special error condition, then we turn it into a branch,
     // so this method can be called directly from log(). It is of course
     // also possible for someone to call branch() directly. In either case, we
     // (1) turn the original message into an ERROR and
     // (2) drop an extra log message that explains how to recover
-    if (causedByOutOfMemory(caught)) {
+    String specialErrorMessage = causedBySpecialError(caught);
+    if (specialErrorMessage != null) {
       type = TreeLogger.ERROR;
-      childLogger.log(type, OUT_OF_MEMORY_MSG, null);
+      childLogger.log(type, specialErrorMessage, null);
     }
 
     // Decide whether we want to log the branch message eagerly or lazily.
@@ -195,9 +200,9 @@
       msg = "(Null log message)";
     }
 
-    // If this log message is caused by being out of memory, we
+    // If this log message is caused by out of memory or stack overflow, we
     // provide a little extra help by creating a child log message.
-    if (causedByOutOfMemory(caught)) {
+    if (causedBySpecialError(caught) != null) {
       branch(TreeLogger.ERROR, msg, caught);
       return;
     }
@@ -310,22 +315,24 @@
       TreeLogger.Type type, String msg, Throwable caught, HelpInfo helpInfo);
 
   /**
-   * Scans <code>t</code> and its causes for {@link OutOfMemoryError}.
+   * Scans <code>t</code> and its causes for {@link OutOfMemoryError} or
+   * {@link StackOverflowError}.
    * 
    * @param t a possibly null {@link Throwable}
-   * @return true if {@link OutOfMemoryError} appears anywhere in the cause list
-   *         or if <code>t</code> is an {@link OutOfMemoryError}.
+   * @return true if {@link OutOfMemoryError} or {@link StackOverflowError}
+   *         appears anywhere in the cause list or if <code>t</code> is an
+   *         {@link OutOfMemoryError} or {@link StackOverflowError.
    */
-  private boolean causedByOutOfMemory(Throwable t) {
-
+  private String causedBySpecialError(Throwable t) {
     while (t != null) {
       if (t instanceof OutOfMemoryError) {
-        return true;
+        return OUT_OF_MEMORY_MSG;
+      } else if (t instanceof StackOverflowError) {
+        return STACK_OVERFLOW_MSG;
       }
       t = t.getCause();
     }
-
-    return false;
+    return null;
   }
 
   private String getLoggerId() {

diff --git a/dev/core/test/com/google/gwt/dev/util/log/AbstractTreeLoggerTest.java b/dev/core/test/com/google/gwt/dev/util/log/AbstractTreeLoggerTest.java
index 29bba38..a12d535 100644
--- a/dev/core/test/com/google/gwt/dev/util/log/AbstractTreeLoggerTest.java
+++ b/dev/core/test/com/google/gwt/dev/util/log/AbstractTreeLoggerTest.java

@@ -127,4 +127,38 @@
     assertTrue(posTstDbgStr < posTstErrStr);
     assertTrue(posTstErrStr < posOutOfMemory);
   }
+
+  /**
+   * We handle stack overflow conditions specially in the logger to provide more
+   * useful log output. It does some slightly weird stuff like turning a regular
+   * log() into a branch(), so this test makes sure that doesn't break anything.
+   */
+  public void testStackOverflowLoggerCommitOrderForLog() {
+    StringWriter sw = new StringWriter();
+    PrintWriter pw = new PrintWriter(sw, true);
+    PrintWriterTreeLogger logger = new PrintWriterTreeLogger(pw);
+    logger.setMaxDetail(TreeLogger.WARN);
+
+    final String tstDbgStr = "TEST-DEBUG-STRING";
+    final String tstErrStr = "TEST-ERROR-STRING";
+
+    // Emit something that's low-priority and wouldn't show up normally unless
+    // it had a higher-priority child log event.
+    TreeLogger branch = logger.branch(TreeLogger.DEBUG, tstDbgStr, null);
+    assertEquals(-1, sw.toString().indexOf(tstDbgStr));
+
+    // Emit something that's low-priority but that also has a OOM.
+    branch.log(TreeLogger.ERROR, tstErrStr, new StackOverflowError());
+
+    // Make sure both are now there, in the right order.
+    int posTstDbgStr = sw.toString().indexOf(tstDbgStr);
+    int posTstErrStr = sw.toString().indexOf(tstErrStr);
+    int posOutOfMemory = sw.toString().indexOf(
+        AbstractTreeLogger.STACK_OVERFLOW_MSG);
+    assertTrue(posTstDbgStr != -1);
+    assertTrue(posTstErrStr != -1);
+    assertTrue(posOutOfMemory != -1);
+    assertTrue(posTstDbgStr < posTstErrStr);
+    assertTrue(posTstErrStr < posOutOfMemory);
+  }
 }