Make reserved identifiers a strict warning, not an error (240317, r=shaver).

js/src/jsparse.c

@@ -3669,7 +3669,6 @@ PrimaryExpr(JSContext *cx, JSTokenStream *ts, JSTreeContext *tc)
 {
     JSTokenType tt;
     JSParseNode *pn, *pn2, *pn3;
-    char *badWord;
 #if JS_HAS_GETTER_SETTER
     JSAtom *atom;
     JSRuntime *rt;
@@ -4032,15 +4031,6 @@ PrimaryExpr(JSContext *cx, JSTokenStream *ts, JSTreeContext *tc)
       case TOK_EXPORT:
       case TOK_IMPORT:
 #endif
-      case TOK_RESERVED:
-        badWord = js_DeflateString(cx, CURRENT_TOKEN(ts).ptr,
-                                   (size_t) CURRENT_TOKEN(ts).pos.end.index
-                                          - CURRENT_TOKEN(ts).pos.begin.index);
-        js_ReportCompileErrorNumber(cx, ts, JSREPORT_TS | JSREPORT_ERROR,
-                                    JSMSG_RESERVED_ID, badWord);
-        JS_free(cx, badWord);
-        return NULL;
-
       case TOK_ERROR:
         /* The scanner or one of its subroutines reported the error. */
         return NULL;

js/src/jsscan.c

@@ -75,6 +75,8 @@
 #define RESERVE_JAVA_KEYWORDS
 #define RESERVE_ECMA_KEYWORDS
 
+#define MAX_KEYWORD_LENGTH      12
+
 static struct keyword {
     const char  *name;
     JSTokenType tokentype;      /* JSTokenType */
@@ -176,10 +178,13 @@ JSBool
 js_InitScanner(JSContext *cx)
 {
     struct keyword *kw;
+    size_t length;
     JSAtom *atom;
 
     for (kw = keywords; kw->name; kw++) {
-        atom = js_Atomize(cx, kw->name, strlen(kw->name), ATOM_PINNED);
+        length = strlen(kw->name);
+        JS_ASSERT(length <= MAX_KEYWORD_LENGTH);
+        atom = js_Atomize(cx, kw->name, length, ATOM_PINNED);
         if (!atom)
             return JS_FALSE;
         ATOM_SET_KEYWORD(atom, kw);
@@ -1267,8 +1272,20 @@ retry:
         if (!hadUnicodeEscape && ATOM_KEYWORD(atom)) {
             struct keyword *kw = ATOM_KEYWORD(atom);
 
-            if (JS_VERSION_IS_ECMA(cx) ||
+            if (kw->tokentype == TOK_RESERVED) {
-                kw->version <= (cx->version & JSVERSION_MASK)) {
+                char buf[MAX_KEYWORD_LENGTH + 1];
+
+                js_DeflateStringToBuffer(buf, TOKENBUF_BASE(),
+                                              TOKENBUF_LENGTH());
+                if (!js_ReportCompileErrorNumber(cx, ts,
+                                                 JSREPORT_TS |
+                                                 JSREPORT_WARNING |
+                                                 JSREPORT_STRICT,
+                                                 JSMSG_RESERVED_ID, buf)) {
+                    goto error;
+                }
+            } else if (JS_VERSION_IS_ECMA(cx) ||
+                       kw->version <= (cx->version & JSVERSION_MASK)) {
                 tt = kw->tokentype;
                 tp->t_op = (JSOp) kw->op;
                 goto out;

js/src/jsstr.c

@@ -551,12 +551,13 @@ str_enumerate(JSContext *cx, JSObject *obj)
 }
 
 static JSBool
-str_resolve(JSContext *cx, JSObject *obj, jsval id)
+str_resolve(JSContext *cx, JSObject *obj, jsval id, uintN flags,
+            JSObject **objp)
 {
     JSString *str, *str1;
     jsint slot;
 
-    if (!JSVAL_IS_INT(id))
+    if (!JSVAL_IS_INT(id) || (flags & JSRESOLVE_ASSIGNING))
         return JS_TRUE;
 
     str = js_ValueToString(cx, OBJECT_TO_JSVAL(obj));
@@ -572,15 +573,16 @@ str_resolve(JSContext *cx, JSObject *obj, jsval id)
                                  STRING_ELEMENT_ATTRS, NULL)) {
             return JS_FALSE;
         }
+        *objp = obj;
     }
     return JS_TRUE;
 }
 
 JSClass js_StringClass = {
     js_String_str,
-    JSCLASS_HAS_PRIVATE,
+    JSCLASS_HAS_PRIVATE | JSCLASS_NEW_RESOLVE,
-    JS_PropertyStub,  JS_PropertyStub,  str_getProperty,  JS_PropertyStub,
+    JS_PropertyStub,   JS_PropertyStub,   str_getProperty,   JS_PropertyStub,
-    str_enumerate,    str_resolve,      JS_ConvertStub,   JS_FinalizeStub,
+    str_enumerate, (JSResolveOp)str_resolve, JS_ConvertStub, JS_FinalizeStub,
     JSCLASS_NO_OPTIONAL_MEMBERS
 };
 
@@ -2470,6 +2472,9 @@ js_NewDependentString(JSContext *cx, JSString *base, size_t start,
     if (length == 0)
         return cx->runtime->emptyString;
 
+    if (start == 0 && length == JSSTRING_LENGTH(base))
+        return base;
+
     if (start > JSSTRDEP_START_MASK ||
         (start != 0 && length > JSSTRDEP_LENGTH_MASK)) {
         return js_NewStringCopyN(cx, JSSTRING_CHARS(base) + start, length,
@@ -2815,10 +2820,22 @@ js_InflateString(JSContext *cx, const char *bytes, size_t length)
         return NULL;
 
     INFLATE_STRING_BODY
-
     return chars;
 }
 
+#define DEFLATE_STRING_BODY                                                   \
+    for (i = 0; i < length; i++)                                              \
+        bytes[i] = (char) chars[i];                                           \
+    bytes[i] = 0;
+
+void
+js_DeflateStringToBuffer(char *bytes, const jschar *chars, size_t length)
+{
+    size_t i;
+
+    DEFLATE_STRING_BODY
+}
+
 /*
  * May be called with null cx by js_GetStringBytes, see below.
  */
@@ -2832,9 +2849,8 @@ js_DeflateString(JSContext *cx, const jschar *chars, size_t length)
     bytes = (char *) (cx ? JS_malloc(cx, size) : malloc(size));
     if (!bytes)
         return NULL;
-    for (i = 0; i < length; i++)
+
-        bytes[i] = (char) chars[i];
+    DEFLATE_STRING_BODY
-    bytes[i] = 0;
     return bytes;
 }
 
@@ -2906,7 +2922,7 @@ js_GetStringBytes(JSString *str)
                       *bytes == (char) JSSTRING_CHARS(str)[0]);
         } else {
             bytes = js_DeflateString(NULL, JSSTRING_CHARS(str),
-                                     JSSTRING_LENGTH(str));
+                                           JSSTRING_LENGTH(str));
             if (bytes) {
                 if (JS_HashTableRawAdd(cache, hep, hash, str, bytes)) {
 #ifdef DEBUG

js/src/jsstr.h

@@ -439,6 +439,13 @@ js_DeflateString(JSContext *cx, const jschar *chars, size_t length);
 extern void
 js_InflateStringToBuffer(jschar *chars, const char *bytes, size_t length);
 
+/*
+ * Deflate JS chars to bytes into a buffer.
+ * 'bytes' must be large enough for 'length'+1 chars.
+ */
+extern void
+js_DeflateStringToBuffer(char *bytes, const jschar *chars, size_t length);
+
 /*
  * Associate bytes with str in the deflated string cache, returning true on
  * successful association, false on out of memory.