Removes most of the remaining JSNI in JRE

Change-Id: I03cafe1d203f6a330c1ba769390155e19055801e
Review-Link: https://gwt-review.googlesource.com/#/c/18642/

dev/core/test/com/google/gwt/dev/CompilerTest.java

@@ -2747,7 +2747,9 @@ private Set<String> getStaleTypeNames(MinimalRebuildCache relinkMinimalRebuildCa
         "java.lang.Double",
         "java.lang.HasCharSequenceTypeMarker",
         "java.lang.HasComparableTypeMarker",
+        "java.lang.Integer$NativeNumber",
         "java.lang.Number",
+        "java.lang.Number$JavaLangNumber",
         "java.lang.String",
         "java.lang.String$NativeFunction",
         "java.lang.String$NativeString",

user/super/com/google/gwt/emul/java/lang/Boolean.java

@@ -114,17 +114,13 @@ public String toString() {
 
   // CHECKSTYLE_OFF: Utility Methods for unboxed Boolean.
   protected static Boolean $create(boolean x) {
-    return createNative(x);
+    return JsUtils.uncheckedCast(x);
   }
 
   protected static Boolean $create(String x) {
-    return createNative(Boolean.parseBoolean(x));
+    return JsUtils.uncheckedCast(Boolean.parseBoolean(x));
   }
 
-  private static native Boolean createNative(boolean x) /*-{
-    return x;
-  }-*/;
-
   @JsMethod
   protected static boolean $isInstance(Object instance) {
     return "boolean".equals(JsUtils.typeOf(instance));

user/super/com/google/gwt/emul/java/lang/Double.java

@@ -379,17 +379,13 @@ public String toString() {
 
   // CHECKSTYLE_OFF: Utility Methods for unboxed Double.
   protected static Double $create(double x) {
-    return createNative(x);
+    return JsUtils.uncheckedCast(x);
   }
 
   protected static Double $create(String s) {
-    return createNative(Double.parseDouble(s));
+    return JsUtils.uncheckedCast(Double.parseDouble(s));
   }
 
-  private static native Double createNative(double x) /*-{
-    return x;
-  }-*/;
-
   @JsMethod
   protected static boolean $isInstance(Object instance) {
     return "number".equals(JsUtils.typeOf(instance));

user/super/com/google/gwt/emul/java/lang/Integer.java

@@ -15,6 +15,9 @@
  */
 package java.lang;
 
+import javaemul.internal.JsUtils;
+import jsinterop.annotations.JsType;
+
 /**
  * Wraps a primitive <code>int</code> as an object.
  */
@@ -206,17 +209,25 @@ public static int sum(int a, int b) {
   }
 
   public static String toBinaryString(int value) {
-    return toUnsignedRadixString(value, 2);
+    return toUnsignedString(value, 2);
   }
 
   public static String toHexString(int value) {
-    return toUnsignedRadixString(value, 16);
+    return toUnsignedString(value, 16);
   }
 
   public static String toOctalString(int value) {
-    return toUnsignedRadixString(value, 8);
+    return toUnsignedString(value, 8);
+  }
+
+  private static String toUnsignedString(int value, int radix) {
+    return toRadixString(toUnsigned(value), radix);
   }
 
+  private static native int toUnsigned(int value) /*-{
+    return (value >>> 0);
+  }-*/;
+
   public static String toString(int value) {
     return String.valueOf(value);
   }
@@ -228,6 +239,16 @@ public static String toString(int value, int radix) {
     return toRadixString(value, radix);
   }
 
+  private static String toRadixString(double value, int radix) {
+    NativeNumber number = JsUtils.uncheckedCast(value);
+    return number.toString(radix);
+  }
+
+  @JsType(isNative = true, name = "Number", namespace = "<window>")
+  private interface NativeNumber {
+    String toString(int radix);
+  }
+
   public static Integer valueOf(int i) {
     if (i > -129 && i < 128) {
       int rebase = i + 128;
@@ -249,15 +270,6 @@ public static Integer valueOf(String s, int radix)
     return Integer.valueOf(Integer.parseInt(s, radix));
   }
 
-  private static native String toRadixString(int value, int radix) /*-{
-    return value.toString(radix);
-  }-*/;
-
-  private static native String toUnsignedRadixString(int value, int radix) /*-{
-    // ">>> 0" converts the value to unsigned number.
-    return (value >>> 0).toString(radix);
-  }-*/;
-
   private final transient int value;
 
   public Integer(int value) {

user/super/com/google/gwt/emul/java/lang/Number.java

@@ -19,7 +19,9 @@
 
 import javaemul.internal.JsUtils;
 import javaemul.internal.NativeRegExp;
+
 import jsinterop.annotations.JsMethod;
+import jsinterop.annotations.JsType;
 
 /**
  * Abstract base class for numeric wrapper classes.
@@ -127,16 +129,14 @@ static class __ParseLong {
     }
   }
 
+  @JsType(isNative = true, name = "Number$impl", namespace = "java.lang")
+  private static class JavaLangNumber { }
+
   @JsMethod
   private static boolean $isInstance(Object instance) {
-    return "number".equals(JsUtils.typeOf(instance)) || instanceOfJavaLangNumber(instance);
+    return "number".equals(JsUtils.typeOf(instance)) || instance instanceof JavaLangNumber;
   }
 
-  private static native boolean instanceOfJavaLangNumber(Object instance) /*-{
-    // Note: The instanceof Number here refers to java.lang.Number in j2cl.
-    return instance instanceof Number;
-  }-*/;
-
   /**
    * @skip
    *

user/super/com/google/gwt/emul/java/math/BigDecimal.java

@@ -41,6 +41,8 @@
 import javaemul.internal.JsUtils;
 import javaemul.internal.NativeRegExp;
 
+import jsinterop.annotations.JsType;
+
 /**
  * This class represents immutable arbitrary precision decimal numbers. Each
  * {@code BigDecimal} instance is represented with a unscaled arbitrary
@@ -491,13 +493,18 @@ private static int toIntScale(double doubleScale) {
    * Convert a double to a string with {@code digits} precision.  The resulting
    * string may still be in exponential notation.
    *
-   * @param d double value
    * @param digits number of digits of precision to include
    * @return non-localized string representation of {@code d}
    */
-  private static native String toPrecision(double d, int digits) /*-{
-    return d.toPrecision(digits);
-  }-*/;
+  private static String toPrecision(double value, int digits) {
+    NativeNumber number = JsUtils.uncheckedCast(value);
+    return number.toPrecision(digits);
+  }
+
+  @JsType(isNative = true, name = "Number", namespace = "<window>")
+  private interface NativeNumber {
+    String toPrecision(int digits);
+  }
 
   private static BigDecimal valueOf(double smallValue, double scale) {
     return new BigDecimal(smallValue, scale);

user/super/com/google/gwt/emul/javaemul/internal/JsUtils.java

@@ -15,6 +15,7 @@
  */
 package javaemul.internal;
 
+import javaemul.internal.annotations.DoNotAutobox;
 import javaemul.internal.annotations.UncheckedCast;
 import jsinterop.annotations.JsMethod;
 import jsinterop.annotations.JsProperty;
@@ -56,7 +57,7 @@ public static native boolean unsafeCastToBoolean(Object bool) /*-{
   }-*/;
 
   @UncheckedCast
-  public static native <T> T uncheckedCast(Object o) /*-{
+  public static native <T> T uncheckedCast(@DoNotAutobox Object o) /*-{
     return o;
   }-*/;
 

user/test/com/google/gwt/emultest/java/lang/IntegerTest.java

@@ -292,18 +292,20 @@ public void testToString() {
     assertEquals("-2147483648", Integer.toString(Integer.MIN_VALUE));
     assertEquals("0", Integer.toString(0));
 
-    assertEquals("17777777777", Integer.toString(2147483647, 8));
-    assertEquals("7fffffff", Integer.toString(2147483647, 16));
-    assertEquals("1111111111111111111111111111111", Integer.toString(2147483647, 2));
-    assertEquals("2147483647", Integer.toString(2147483647, 10));
-    assertEquals("-17777777777", Integer.toString(-2147483647, 8));
-    assertEquals("-7fffffff", Integer.toString(-2147483647, 16));
-    assertEquals("-1111111111111111111111111111111", Integer.toString(-2147483647, 2));
-    assertEquals("-2147483647", Integer.toString(-2147483647, 10));
-    assertEquals("-20000000000", Integer.toString(-2147483648, 8));
-    assertEquals("-80000000", Integer.toString(-2147483648, 16));
-    assertEquals("-10000000000000000000000000000000", Integer.toString(-2147483648, 2));
-    assertEquals("-2147483648", Integer.toString(-2147483648, 10));
+    assertEquals("7fffffff", Integer.toString(Integer.MAX_VALUE, 16));
+    assertEquals("2147483647", Integer.toString(Integer.MAX_VALUE, 10));
+    assertEquals("17777777777", Integer.toString(Integer.MAX_VALUE, 8));
+    assertEquals("1111111111111111111111111111111", Integer.toString(Integer.MAX_VALUE, 2));
+
+    assertEquals("-7fffffff", Integer.toString(-Integer.MAX_VALUE, 16));
+    assertEquals("-2147483647", Integer.toString(-Integer.MAX_VALUE, 10));
+    assertEquals("-17777777777", Integer.toString(-Integer.MAX_VALUE, 8));
+    assertEquals("-1111111111111111111111111111111", Integer.toString(-Integer.MAX_VALUE, 2));
+
+    assertEquals("-80000000", Integer.toString(Integer.MIN_VALUE, 16));
+    assertEquals("-2147483648", Integer.toString(Integer.MIN_VALUE, 10));
+    assertEquals("-20000000000", Integer.toString(Integer.MIN_VALUE, 8));
+    assertEquals("-10000000000000000000000000000000", Integer.toString(Integer.MIN_VALUE, 2));
   }
 
   public void testValueOf() {