Switch to native JsTypes for String and Math.
This also fixes the problem where J2CL gets upset due
to JSNI referring to native types that are shadowed
by enclosing class names or imports.
(e.g. j.l.String vs. js String).
Change-Id: I599929b079daecee2b8878d11ffcdeb321975a2a
Review-Link: https://gwt-review.googlesource.com/#/c/13977/
diff --git a/dev/core/super/javaemul/internal/ArrayHelper.java b/dev/core/super/javaemul/internal/ArrayHelper.java
index 9f466f3..1fc2a0e 100644
--- a/dev/core/super/javaemul/internal/ArrayHelper.java
+++ b/dev/core/super/javaemul/internal/ArrayHelper.java
@@ -31,7 +31,7 @@
* Unlike clone, this method returns a copy of the array that is not type marked. This is only
* safe for temp arrays as returned array will not do any type checks.
*/
- public static native Object unsafeClone(Object array, int fromIndex, int toIndex) /*-{
+ public static native Object[] unsafeClone(Object array, int fromIndex, int toIndex) /*-{
return array.slice(fromIndex, toIndex);
}-*/;
diff --git a/user/super/com/google/gwt/emul/java/lang/Character.java b/user/super/com/google/gwt/emul/java/lang/Character.java
index dad1b41..e699e2c 100644
--- a/user/super/com/google/gwt/emul/java/lang/Character.java
+++ b/user/super/com/google/gwt/emul/java/lang/Character.java
@@ -18,6 +18,7 @@
import static javaemul.internal.InternalPreconditions.checkCriticalArgument;
import java.io.Serializable;
+import java.lang.String.NativeRegExp;
/**
* Wraps a native <code>char</code> as an object.
@@ -227,8 +228,12 @@
/*
* TODO: correct Unicode handling.
*/
- public static native boolean isDigit(char c) /*-{
- return (null != String.fromCharCode(c).match(/\d/));
+ public static boolean isDigit(char c) {
+ return String.valueOf(c).nativeMatches(digitRegex());
+ }
+
+ private static native NativeRegExp digitRegex() /*-{
+ return /\d/;
}-*/;
public static boolean isHighSurrogate(char ch) {
@@ -238,15 +243,23 @@
/*
* TODO: correct Unicode handling.
*/
- public static native boolean isLetter(char c) /*-{
- return (null != String.fromCharCode(c).match(/[A-Z]/i));
+ public static boolean isLetter(char c) {
+ return String.valueOf(c).nativeMatches(leterRegex());
+ }
+
+ private static native NativeRegExp leterRegex() /*-{
+ return /[A-Z]/i;
}-*/;
/*
* TODO: correct Unicode handling.
*/
- public static native boolean isLetterOrDigit(char c) /*-{
- return (null != String.fromCharCode(c).match(/[A-Z\d]/i));
+ public static boolean isLetterOrDigit(char c) {
+ return String.valueOf(c).nativeMatches(leterOrDigitRegex());
+ }
+
+ private static native NativeRegExp leterOrDigitRegex() /*-{
+ return /[A-Z\d]/i;
}-*/;
/*
@@ -282,15 +295,17 @@
}
public static boolean isWhitespace(char ch) {
- return isWhitespace((int) ch);
+ return String.valueOf(ch).nativeMatches(whitespaceRegex());
+ }
+
+ public static boolean isWhitespace(int codePoint) {
+ return String.fromCodePoint(codePoint).nativeMatches(whitespaceRegex());
}
// The regex would just be /\s/, but browsers handle non-breaking spaces inconsistently. Also,
// the Java definition includes separators.
- public static native boolean isWhitespace(int codePoint) /*-{
- return (null !== String.fromCharCode(codePoint).match(
- /[\t-\r \u1680\u180E\u2000-\u2006\u2008-\u200A\u2028\u2029\u205F\u3000\uFEFF]|[\x1C-\x1F]/
- ));
+ private static native NativeRegExp whitespaceRegex() /*-{
+ return /[\t-\r \u1680\u180E\u2000-\u2006\u2008-\u200A\u2028\u2029\u205F\u3000\uFEFF]|[\x1C-\x1F]/;
}-*/;
public static boolean isSupplementaryCodePoint(int codePoint) {
@@ -381,17 +396,17 @@
return MIN_SUPPLEMENTARY_CODE_POINT + ((highSurrogate & 1023) << 10) + (lowSurrogate & 1023);
}
- public static native char toLowerCase(char c) /*-{
- return String.fromCharCode(c).toLowerCase().charCodeAt(0);
- }-*/;
+ public static char toLowerCase(char c) {
+ return String.valueOf(c).toLowerCase().charAt(0);
+ }
public static String toString(char x) {
return String.valueOf(x);
}
- public static native char toUpperCase(char c) /*-{
- return String.fromCharCode(c).toUpperCase().charCodeAt(0);
- }-*/;
+ public static char toUpperCase(char c) {
+ return String.valueOf(c).toUpperCase().charAt(0);
+ }
public static Character valueOf(char c) {
if (c < 128) {
diff --git a/user/super/com/google/gwt/emul/java/lang/Math.java b/user/super/com/google/gwt/emul/java/lang/Math.java
index 620e617..fc59cdc 100644
--- a/user/super/com/google/gwt/emul/java/lang/Math.java
+++ b/user/super/com/google/gwt/emul/java/lang/Math.java
@@ -16,6 +16,8 @@
package java.lang;
import javaemul.internal.JsUtils;
+import jsinterop.annotations.JsPackage;
+import jsinterop.annotations.JsType;
/**
* Math utility methods and constants.
@@ -62,29 +64,29 @@
return x < 0 ? -x : x;
}
- public static native double acos(double x) /*-{
- return Math.acos(x);
- }-*/;
+ public static double acos(double x) {
+ return NativeMath.acos(x);
+ }
- public static native double asin(double x) /*-{
- return Math.asin(x);
- }-*/;
+ public static double asin(double x) {
+ return NativeMath.asin(x);
+ }
- public static native double atan(double x) /*-{
- return Math.atan(x);
- }-*/;
+ public static double atan(double x) {
+ return NativeMath.atan(x);
+ }
- public static native double atan2(double y, double x) /*-{
- return Math.atan2(y, x);
- }-*/;
+ public static double atan2(double y, double x) {
+ return NativeMath.atan2(y, x);
+ }
public static double cbrt(double x) {
return Math.pow(x, 1.0 / 3.0);
}
- public static native double ceil(double x) /*-{
- return Math.ceil(x);
- }-*/;
+ public static double ceil(double x) {
+ return NativeMath.ceil(x);
+ }
public static double copySign(double magnitude, double sign) {
if (sign < 0) {
@@ -98,17 +100,17 @@
return (float) (copySign((double) magnitude, (double) sign));
}
- public static native double cos(double x) /*-{
- return Math.cos(x);
- }-*/;
+ public static double cos(double x) {
+ return NativeMath.cos(x);
+ }
public static double cosh(double x) {
return (Math.exp(x) + Math.exp(-x)) / 2.0;
}
- public static native double exp(double x) /*-{
- return Math.exp(x);
- }-*/;
+ public static double exp(double x) {
+ return NativeMath.exp(x);
+ }
public static double expm1(double d) {
if (d == 0.0 || Double.isNaN(d)) {
@@ -123,21 +125,21 @@
return exp(d) + 1.0d;
}
- public static native double floor(double x) /*-{
- return Math.floor(x);
- }-*/;
+ public static double floor(double x) {
+ return NativeMath.floor(x);
+ }
public static double hypot(double x, double y) {
return sqrt(x * x + y * y);
}
- public static native double log(double x) /*-{
- return Math.log(x);
- }-*/;
+ public static double log(double x) {
+ return NativeMath.log(x);
+ }
- public static native double log10(double x) /*-{
- return Math.log(x) * Math.LOG10E;
- }-*/;
+ public static double log10(double x) {
+ return NativeMath.log(x) * NativeMath.LOG10E;
+ }
public static double log1p(double x) {
return Math.log(x + 1.0d);
@@ -175,13 +177,13 @@
return x < y ? x : y;
}
- public static native double pow(double x, double exp) /*-{
- return Math.pow(x, exp);
- }-*/;
+ public static double pow(double x, double exp) {
+ return NativeMath.pow(x, exp);
+ }
- public static native double random() /*-{
- return Math.random();
- }-*/;
+ public static double random() {
+ return NativeMath.random();
+ }
public static double rint(double d) {
if (Double.isNaN(d)) {
@@ -196,11 +198,11 @@
}
public static long round(double x) {
- return (long) round0(x);
+ return (long) NativeMath.round(x);
}
public static int round(float x) {
- double roundedValue = round0(x);
+ double roundedValue = NativeMath.round(x);
return unsafeCastToInt(roundedValue);
}
@@ -252,21 +254,21 @@
}
}
- public static native double sin(double x) /*-{
- return Math.sin(x);
- }-*/;
+ public static double sin(double x) {
+ return NativeMath.sin(x);
+ }
public static double sinh(double x) {
return (Math.exp(x) - Math.exp(-x)) / 2.0d;
}
- public static native double sqrt(double x) /*-{
- return Math.sqrt(x);
- }-*/;
+ public static double sqrt(double x) {
+ return NativeMath.sqrt(x);
+ }
- public static native double tan(double x) /*-{
- return Math.tan(x);
- }-*/;
+ public static double tan(double x) {
+ return NativeMath.tan(x);
+ }
public static double tanh(double x) {
if (x == JsUtils.getInfinity()) {
@@ -287,7 +289,23 @@
return x * PI_OVER_180;
}
- private static native double round0(double x) /*-{
- return Math.round(x);
- }-*/;
+ @JsType(isNative = true, name = "Math", namespace = JsPackage.GLOBAL)
+ private static class NativeMath {
+ public static double LOG10E;
+ public static native double acos(double x);
+ public static native double asin(double x);
+ public static native double atan(double x);
+ public static native double atan2(double y, double x);
+ public static native double ceil(double x);
+ public static native double cos(double x);
+ public static native double exp(double x);
+ public static native double floor(double x);
+ public static native double log(double x);
+ public static native double pow(double x, double exp);
+ public static native double random();
+ public static native double round(double x);
+ public static native double sin(double x);
+ public static native double sqrt(double x);
+ public static native double tan(double x);
+ }
}
diff --git a/user/super/com/google/gwt/emul/java/lang/String.java b/user/super/com/google/gwt/emul/java/lang/String.java
index fdb7270..c254a8a 100644
--- a/user/super/com/google/gwt/emul/java/lang/String.java
+++ b/user/super/com/google/gwt/emul/java/lang/String.java
@@ -30,8 +30,10 @@
import javaemul.internal.HashCodes;
import javaemul.internal.JsUtils;
import javaemul.internal.annotations.DoNotInline;
-
import jsinterop.annotations.JsMethod;
+import jsinterop.annotations.JsPackage;
+import jsinterop.annotations.JsProperty;
+import jsinterop.annotations.JsType;
/**
* Intrinsic string class.
@@ -111,9 +113,9 @@
return "" + x;
}
- public static native String valueOf(char x) /*-{
- return String.fromCharCode(x);
- }-*/;
+ public static String valueOf(char x) {
+ return NativeString.fromCharCode(x);
+ }
public static String valueOf(char x[], int offset, int count) {
int end = offset + count;
@@ -131,9 +133,17 @@
return s;
}
- private static native String fromCharCode(Object array) /*-{
- return String.fromCharCode.apply(null, array);
- }-*/;
+ private static String fromCharCode(Object[] array) {
+ return getFromCharCodeFunction().apply(null, array);
+ }
+
+ @JsType(isNative = true, name = "Function", namespace = JsPackage.GLOBAL)
+ private static class NativeFunction<T> {
+ public native T apply(Object thisContext, Object[] argsArray);
+ }
+
+ @JsProperty(name = "fromCharCode", namespace = "String")
+ private static native NativeFunction<String> getFromCharCodeFunction();
public static String valueOf(char[] x) {
return valueOf(x, 0, x.length);
@@ -161,12 +171,6 @@
return x == null ? "null" : x.toString();
}
- // CHECKSTYLE_OFF: This class has special needs.
-
- static native String __substr(String str, int beginIndex, int len) /*-{
- return str.substr(beginIndex, len);
- }-*/;
-
/**
* This method converts Java-escaped dollar signs "\$" into JavaScript-escaped
* dollar signs "$$", and removes all other lone backslashes, which serve as
@@ -187,8 +191,6 @@
return replaceStr;
}
- // CHECKSTYLE_ON
-
private static native int compareTo(String thisStr, String otherStr) /*-{
if (thisStr == otherStr) {
return 0;
@@ -204,7 +206,7 @@
}
}
- private static String fromCodePoint(int codePoint) {
+ static String fromCodePoint(int codePoint) {
if (codePoint >= Character.MIN_SUPPLEMENTARY_CODE_POINT) {
char hiSurrogate = Character.getHighSurrogate(codePoint);
char loSurrogate = Character.getLowSurrogate(codePoint);
@@ -335,14 +337,18 @@
$createString(sb);
}
+ private NativeString asNativeString() {
+ return toNative(this);
+ }
+
+ private static native NativeString toNative(String str) /*-{
+ return str;
+ }-*/;
+
@Override
public char charAt(int index) {
- return charAt(this, index);
+ return asNativeString().charCodeAt(index);
}
-
- private static native char charAt(String s, int index) /*-{
- return s.charCodeAt(index);
- }-*/;
public int codePointAt(int index) {
return Character.codePointAt(this, index, length());
@@ -366,12 +372,8 @@
}
public String concat(String str) {
- return concat(this, str);
+ return this + str;
}
-
- private static native String concat(String s, String str) /*-{
- return s + str;
- }-*/;
public boolean contains(CharSequence s) {
return indexOf(s.toString()) != -1;
@@ -388,7 +390,7 @@
public boolean endsWith(String suffix) {
// If IE8 supported negative start index, we could have just used "-suffixlength".
int suffixlength = suffix.length();
- return __substr(this, length() - suffixlength, suffixlength).equals(suffix);
+ return asNativeString().substr(length() - suffixlength, suffixlength).equals(suffix);
}
// Marked with @DoNotInline because we don't have static eval for "==" yet.
@@ -403,7 +405,7 @@
public boolean equalsIgnoreCase(String other) {
return equalsIgnoreCase(this, other);
}
-
+
private static native boolean equalsIgnoreCase(String s, String other) /*-{
if (other == null) {
return false;
@@ -447,21 +449,13 @@
}
public int indexOf(String str) {
- return indexOf(this, str);
+ return asNativeString().indexOf(str);
}
- private static native int indexOf(String s, String str) /*-{
- return s.indexOf(str);
- }-*/;
-
public int indexOf(String str, int startIndex) {
- return indexOf(this, str, startIndex);
+ return asNativeString().indexOf(str, startIndex);
}
- private static native int indexOf(String s, String str, int startIndex) /*-{
- return s.indexOf(str, startIndex);
- }-*/;
-
public String intern() {
return this;
}
@@ -479,30 +473,18 @@
}
public int lastIndexOf(String str) {
- return lastIndexOf(this, str);
+ return asNativeString().lastIndexOf(str);
}
- private static native int lastIndexOf(String s, String str) /*-{
- return s.lastIndexOf(str);
- }-*/;
-
public int lastIndexOf(String str, int start) {
- return lastIndexOf(this, str, start);
+ return asNativeString().lastIndexOf(str, start);
}
- private static native int lastIndexOf(String s, String str, int start) /*-{
- return s.lastIndexOf(str, start);
- }-*/;
-
@Override
public int length() {
- return length(this);
+ return asNativeString().length;
}
- private static native int length(String s) /*-{
- return s.length;
- }-*/;
-
/**
* Regular expressions vary from the standard implementation. The
* <code>regex</code> parameter is interpreted by JavaScript as a JavaScript
@@ -512,14 +494,13 @@
* TODO(jat): properly handle Java regex syntax
*/
public boolean matches(String regex) {
- return matches(this, regex);
+ // We surround the regex with '^' and '$' because it must match the entire string.
+ return nativeMatches(new NativeRegExp("^(" + regex + ")$"));
}
-
- private static native boolean matches(String s, String regex) /*-{
- // We surround the regex with '^' and '$' because it must match
- // the entire string.
- return new RegExp('^(' + regex + ')$').test(s);
- }-*/;
+
+ boolean nativeMatches(NativeRegExp regex) {
+ return regex.test(this);
+ }
public int offsetByCodePoints(int index, int codePointOffset) {
return Character.offsetByCodePoints(this, index, codePointOffset);
@@ -537,8 +518,8 @@
return false;
}
- String left = __substr(this, toffset, len);
- String right = __substr(other, ooffset, len);
+ String left = asNativeString().substr(toffset, len);
+ String right = other.asNativeString().substr(ooffset, len);
return ignoreCase ? left.equalsIgnoreCase(right) : left.equals(right);
}
@@ -552,15 +533,10 @@
// in order to escape regexp special characters (e.g. '.').
String hex = Integer.toHexString(from);
String regex = "\\u" + "0000".substring(hex.length()) + hex;
- Object jsRegEx = createRegExp(regex, "g");
- String replace = fromCharCode(to);
- return replace(this, jsRegEx, replace);
+ String replace = NativeString.fromCharCode(to);
+ return nativeReplaceAll(regex, replace);
}
- private static native String fromCharCode(char to) /*-{
- return String.fromCharCode(to);
- }-*/;
-
public String replace(CharSequence from, CharSequence to) {
// Implementation note: This uses a regex replacement instead of
// a string literal replacement because Safari does not
@@ -587,8 +563,11 @@
*/
public String replaceAll(String regex, String replace) {
replace = translateReplaceString(replace);
- Object jsRegEx = createRegExp(regex, "g");
- return replace(this, jsRegEx, replace);
+ return nativeReplaceAll(regex, replace);
+ }
+
+ String nativeReplaceAll(String regex, String replace) {
+ return asNativeString().replace(new NativeRegExp(regex, "g"), replace);
}
/**
@@ -601,26 +580,10 @@
*/
public String replaceFirst(String regex, String replace) {
replace = translateReplaceString(replace);
- Object jsRegEx = createRegExp(regex, "");
- return replace(this, jsRegEx, replace);
+ NativeRegExp jsRegEx = new NativeRegExp(regex);
+ return asNativeString().replace(jsRegEx, replace);
}
- private static native Object createRegExp(String regex, String mode) /*-{
- return RegExp(regex, mode);
- }-*/;
-
- private static native Object execRegExp(Object regex, String value) /*-{
- return regex.exec(value);
- }-*/;
-
- private static native int resetRegExpLastIndex(Object compiledRegEx) /*-{
- compiledRegEx.lastIndex = 0;
- }-*/;
-
- private static native String replace(String s, Object regex, String replace) /*-{
- return s.replace(regex, replace);
- }-*/;
-
private static native int getMatchIndex(Object matchObject) /*-{
return matchObject.index;
}-*/;
@@ -649,7 +612,7 @@
*/
public String[] split(String regex, int maxMatch) {
// The compiled regular expression created from the string
- Object compiled = createRegExp(regex, "g");
+ NativeRegExp compiled = new NativeRegExp(regex, "g");
// the Javascipt array to hold the matches prior to conversion
String[] out = new String[0];
// how many matches performed so far
@@ -664,7 +627,7 @@
while (true) {
// None of the information in the match returned are useful as we have no
// subgroup handling
- Object matchObj = execRegExp(compiled, trail);
+ Object matchObj = compiled.exec(trail);
if (matchObj == null || trail == "" || (count == (maxMatch - 1) && maxMatch > 0)) {
out[count] = trail;
break;
@@ -673,7 +636,7 @@
trail = trail.substring(
getMatchIndex(matchObj) + getMatchLength(matchObj, 0), trail.length());
// Force the compiled pattern to reset internal state
- resetRegExpLastIndex(compiled);
+ compiled.lastIndex = 0;
// Only one zero length match per character to ensure termination
if (lastTrail == trail) {
out[count] = trail.substring(0, 1);
@@ -703,7 +666,7 @@
}
public boolean startsWith(String prefix, int toffset) {
- return toffset >= 0 && __substr(this, toffset, prefix.length()).equals(prefix);
+ return toffset >= 0 && asNativeString().substr(toffset, prefix.length()).equals(prefix);
}
@Override
@@ -712,11 +675,11 @@
}
public String substring(int beginIndex) {
- return __substr(this, beginIndex, this.length() - beginIndex);
+ return asNativeString().substr(beginIndex, this.length() - beginIndex);
}
public String substring(int beginIndex, int endIndex) {
- return __substr(this, beginIndex, endIndex - beginIndex);
+ return asNativeString().substr(beginIndex, endIndex - beginIndex);
}
public char[] toCharArray() {
@@ -735,19 +698,8 @@
* {@code toLowerCase(Locale.getDefault())} instead.
*/
public String toLowerCase() {
- return toLowerCase(this);
+ return asNativeString().toLowerCase();
}
-
- private static native String toLowerCase(String s) /*-{
- return s.toLowerCase();
- }-*/;
-
- /**
- * Transforms the String to lower-case based on the native locale of the browser.
- */
- private static native String toLocaleLowerCase(String s) /*-{
- return s.toLocaleLowerCase();
- }-*/;
/**
* If provided {@code locale} is {@link Locale#getDefault()}, uses javascript's
@@ -756,26 +708,19 @@
* predefined in GWT Locale emulation.
*/
public String toLowerCase(Locale locale) {
- return locale == Locale.getDefault() ? toLocaleLowerCase(this) : toLowerCase(this);
+ return locale == Locale.getDefault()
+ ? asNativeString().toLocaleLowerCase() : asNativeString().toLowerCase();
}
// See the notes in lowerCase pair.
public String toUpperCase() {
- return toLocaleUpperCase(this);
+ return asNativeString().toLocaleUpperCase();
}
- private static native String toUpperCase(String s) /*-{
- return s.toUpperCase();
- }-*/;
-
- // See the notes in lowerCase pair.
- private static native String toLocaleUpperCase(String s) /*-{
- return s.toLocaleUpperCase();
- }-*/;
-
// See the notes in lowerCase pair.
public String toUpperCase(Locale locale) {
- return locale == Locale.getDefault() ? toLocaleUpperCase(this) : toUpperCase(this);
+ return locale == Locale.getDefault()
+ ? asNativeString().toLocaleUpperCase() : asNativeString().toUpperCase();
}
@Override
@@ -800,6 +745,32 @@
return start > 0 || end < length ? substring(start, end) : this;
}
+ @JsType(isNative = true, name = "String", namespace = JsPackage.GLOBAL)
+ private static class NativeString {
+ public static native String fromCharCode(char x);
+ public int length;
+ public native char charCodeAt(int index);
+ public native int indexOf(String str);
+ public native int indexOf(String str, int startIndex);
+ public native int lastIndexOf(String str);
+ public native int lastIndexOf(String str, int start);
+ public native String replace(NativeRegExp regex, String replace);
+ public native String substr(int beginIndex, int len);
+ public native String toLocaleLowerCase();
+ public native String toLocaleUpperCase();
+ public native String toLowerCase();
+ public native String toUpperCase();
+ }
+
+ @JsType(isNative = true, name = "RegExp", namespace = JsPackage.GLOBAL)
+ static class NativeRegExp {
+ public int lastIndex;
+ public NativeRegExp(String regex) { }
+ public NativeRegExp(String regex, String mode) { }
+ public native Object exec(String value);
+ public native boolean test(String value);
+ }
+
// CHECKSTYLE_OFF: Utility Methods for unboxed String.
@JsMethod(name = "$create")
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 309fcbb..3d27af4 100644
--- a/user/super/com/google/gwt/emul/java/lang/Throwable.java
+++ b/user/super/com/google/gwt/emul/java/lang/Throwable.java
@@ -108,8 +108,7 @@
// Replace newlines with spaces so that we don't confuse the parser
// below which splits on newlines, and will otherwise try to parse
// the error message as part of the stack trace.
- // TODO: use string.asNativeString.replace instead when available.
- String message = detailMessage == null ? null : detailMessage.replace('\n', ' ');
+ String message = detailMessage == null ? null : detailMessage.nativeReplaceAll("\n", " ");
String errorMessage = toString(message);
setBackingJsObject(fixIE(createError(errorMessage)));
