diff --git a/user/src/com/google/gwt/core/client/debug/JsoInspector.java b/user/src/com/google/gwt/core/client/debug/JsoInspector.java
new file mode 100644
index 0000000..bad03ee
--- /dev/null
+++ b/user/src/com/google/gwt/core/client/debug/JsoInspector.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2011 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.debug;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.JavaScriptObject;
+
+/**
+ * This class provides an API for IDEs to inspect JavaScript objects and is not
+ * intended to be used in GWT applications. IDEs that allow custom value
+ * renderers for debugging can use it to box JavaScript objects into suitable
+ * Java types.
+ * 
+ * TODO: provide a way to test whether a node has children (to be used as an
+ * optimization in IntelliJ).
+ * 
+ * TODO: implement and return concrete JsoProperty subtypes (Integer, Float,
+ * etc.) to get more descriptive labels in IntelliJ.
+ */
+public class JsoInspector {
+
+  /**
+   * A simple Java object to hold a key and value pair.
+   */
+  public static class JsoProperty implements Comparable<JsoProperty> {
+    public final String key;
+    public final Object value;
+    public final boolean isOwnProperty;
+
+    private JsoProperty(String key, Object value, boolean isOwnProperty) {
+      this.key = key;
+      this.value = value;
+      this.isOwnProperty = isOwnProperty;
+    }
+
+    @Override
+    public int compareTo(JsoProperty o) {
+      int keyComparison = key.compareTo(o.key);
+
+      /*
+       * The hash code comparison is so this class's natural ordering is
+       * consistent (see Comparable interface javadoc). Ideally, we would have
+       * done value.compareTo(o.value), but value may not implement Comparable.
+       */
+      return keyComparison != 0 ? keyComparison : value.hashCode()
+          - o.value.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder s = new StringBuilder();
+
+      if (isOwnProperty) {
+        s.append('*');
+      }
+
+      s.append(key).append(": ");
+
+      if (value instanceof String) {
+        s.append('"').append(value).append('"');
+      } else {
+        s.append(value);
+      }
+
+      return s.toString();
+    }
+  }
+
+  private static class JsoBoxer extends JavaScriptObject {
+
+    protected JsoBoxer() {
+    }
+
+    /**
+     * Returns a Java object that represents this JavaScriptObject instance. The
+     * returned Java object may still contain other JavaScriptObjects. Eclipse
+     * will attempt to lazily fetch the logical structure for those children
+     * JavaScriptObjects when the user clicks on one of them.
+     */
+    public final native Object box() /*-{
+
+      // Returns a Java object for simpler JavaScript values
+      // (primitives, functions, null, undefined), or the given value
+      // if it is not a "simple" type
+      var asJavaObjectForSimpleValue = function(value) {
+        var valueType = typeof(value);
+
+        // Earlier, I had function types printing their function contents,
+        // but pure Java classes in GWT get converted to function prototypes
+        // in Javascript, so there were issues
+        if (valueType == "number") {
+          // Differentiate int from float
+          if (/[.]/.test(value + '')) {
+            return @java.lang.Float::new(F)(value);
+          } else {
+            return @java.lang.Integer::new(I)(value);
+          }
+        } else if (valueType == "boolean") {
+          return @java.lang.Boolean::new(Z)(value);
+        } else if (valueType == "string") {
+          return value;
+        } else if (valueType == "undefined" || valueType == "null") {
+          // Return the corresponding string
+          return valueType;
+        } else {
+          return value;
+        }
+      }
+
+      var asJavaObject = function(value) {
+        var valueType = typeof(value);
+
+        if (valueType == "object") {
+          if (value instanceof Array) {
+            var list = @java.util.ArrayList::new()();
+            for (i in value) {
+              list.@java.util.ArrayList::add(Ljava/lang/Object;)(asJavaObjectForSimpleValue(value[i]));
+            }
+
+            // If we return a List, Eclipse's Variables view will show one
+            // extra level unnecessarily. It does not do this for Java arrays.
+            return list.@java.util.ArrayList::toArray()();
+
+          } else {
+            var properties = @java.util.ArrayList::new()();
+
+            for (var name in value) {
+              var propertyValue;
+              try {
+                var origPropertyValue = value[name];
+                if (typeof(origPropertyValue) == "function"
+                    && !value.hasOwnProperty(name)) {
+                  // Prevent every JavaScriptObject method from appearing
+                  continue;
+                }
+
+                // Sometimes, we don't have permission to see the value
+                // and an exception is thrown
+                propertyValue = asJavaObjectForSimpleValue(origPropertyValue);
+              } catch (e) {
+                propertyValue = "ERROR: " + e.name + " - " + e.message;
+              }
+
+              // Wrap the (key, value) in our JsoProperty class
+              var jsoProperty = @com.google.gwt.core.client.debug.JsoInspector.JsoProperty::new(Ljava/lang/String;Ljava/lang/Object;Z)(name, propertyValue, value.hasOwnProperty(name));
+              properties.@java.util.ArrayList::add(Ljava/lang/Object;)(jsoProperty);
+            }
+
+            // Sort the properties
+            @java.util.Collections::sort(Ljava/util/List;)(properties);
+
+            // If we return a List, Eclipse's Variables view will show one
+            // extra level unnecessarily. It does not do this for Java arrays.
+            var propertiesAsArray = properties.@java.util.ArrayList::toArray()();
+
+            return propertiesAsArray;
+          }
+        } else {
+          return asJavaObjectForSimpleValue(value);
+        }
+      };
+
+      return asJavaObject(this);
+    }-*/;
+  }
+
+  /**
+   * Wraps a JavaScript object into a suitable inspectable type.
+   */
+  public static Object convertToInspectableObject(Object jso) {
+    try {
+      JsoBoxer boxer = (JsoBoxer) jso;
+      return boxer.box();
+    } catch (Throwable t) {
+      GWT.log("GWT could not inspect the JavaScriptObject.", t);
+      return "ERROR: Could not inspect the JavaScriptObject, see GWT log for details.";
+    }
+  }
+}