Implement flag and source getters on RegExp.prototype.

src/js/regexp.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
-var FLAG_harmony_regexps;
 var FLAG_harmony_tolength;
-var FLAG_harmony_unicode_regexps;
 var GlobalObject = global.Object;
 var GlobalRegExp = global.RegExp;
 var InternalPackedArray = utils.InternalPackedArray;
 var MakeTypeError;
+var regExpFlagsSymbol = utils.ImportNow("regexp_flags_symbol");
+var regExpSourceSymbol = utils.ImportNow("regexp_source_symbol");
 
 utils.ImportFromExperimental(function(from) {
-  FLAG_harmony_regexps = from.FLAG_harmony_regexps;
   FLAG_harmony_tolength = from.FLAG_harmony_tolength;
-  FLAG_harmony_unicode_regexps = from.FLAG_harmony_unicode_regexps;
 });
 
 utils.Import(function(from) {
   MakeTypeError = from.MakeTypeError;
 });
 
 // -------------------------------------------------------------------
 
 // Property of the builtins object for recording the result of the last
 // regexp match.  The property RegExpLastMatchInfo includes the matchIndices
@@ skipping 10 matching lines @@
 );
 
 // -------------------------------------------------------------------
 
 // A recursive descent parser for Patterns according to the grammar of
 // ECMA-262 15.10.1, with deviations noted below.
 function DoConstructRegExp(object, pattern, flags) {
   // RegExp : Called as constructor; see ECMA-262, section 15.10.4.
   if (IS_REGEXP(pattern)) {
     if (!IS_UNDEFINED(flags)) throw MakeTypeError(kRegExpFlags);
-    flags = (pattern.global ? 'g' : '')
-        + (pattern.ignoreCase ? 'i' : '')
-        + (pattern.multiline ? 'm' : '');
-    if (FLAG_harmony_unicode_regexps)
-        flags += (pattern.unicode ? 'u' : '');
-    if (FLAG_harmony_regexps)
-        flags += (pattern.sticky ? 'y' : '');
-    pattern = pattern.source;
+    flags = (REGEXP_GLOBAL(pattern) ? 'g' : '')
+        + (REGEXP_IGNORE_CASE(pattern) ? 'i' : '')
+        + (REGEXP_MULTILINE(pattern) ? 'm' : '')
+        + (REGEXP_UNICODE(pattern) ? 'u' : '')
+        + (REGEXP_STICKY(pattern) ? 'y' : '');
+    pattern = REGEXP_SOURCE(pattern);
   }
 
   pattern = IS_UNDEFINED(pattern) ? '' : TO_STRING(pattern);
   flags = IS_UNDEFINED(flags) ? '' : TO_STRING(flags);
 
   %RegExpInitializeAndCompile(object, pattern, flags);
 }
 
 
 function RegExpConstructor(pattern, flags) {
@@ skipping 63 matching lines @@
   }
   return result;
 endmacro
 
 
 function RegExpExecNoTests(regexp, string, start) {
   // Must be called with RegExp, string and positive integer as arguments.
   var matchInfo = %_RegExpExec(regexp, string, start, RegExpLastMatchInfo);
   if (matchInfo !== null) {
     // ES6 21.2.5.2.2 step 18.
-    if (FLAG_harmony_regexps && regexp.sticky) {
-      regexp.lastIndex = matchInfo[CAPTURE1];
-    }
+    if (REGEXP_STICKY(regexp)) regexp.lastIndex = matchInfo[CAPTURE1];
     RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, string);
   }
   regexp.lastIndex = 0;
   return null;
 }
 
 
 function RegExpExecJS(string) {
   if (!IS_REGEXP(this)) {
     throw MakeTypeError(kIncompatibleMethodReceiver,
                         'RegExp.prototype.exec', this);
   }
 
   string = TO_STRING(string);
   var lastIndex = this.lastIndex;
 
   // Conversion is required by the ES2015 specification (RegExpBuiltinExec
   // algorithm, step 4) even if the value is discarded for non-global RegExps.
   var i = TO_LENGTH_OR_INTEGER(lastIndex);
 
-  var updateLastIndex = this.global || (FLAG_harmony_regexps && this.sticky);
+  var updateLastIndex = REGEXP_GLOBAL(this) || REGEXP_STICKY(this);
   if (updateLastIndex) {
     if (i < 0 || i > string.length) {
       this.lastIndex = 0;
       return null;
     }
   } else {
     i = 0;
   }
 
   // matchIndices is either null or the RegExpLastMatchInfo array.
@@ skipping 26 matching lines @@
                         'RegExp.prototype.test', this);
   }
   string = TO_STRING(string);
 
   var lastIndex = this.lastIndex;
 
   // Conversion is required by the ES2015 specification (RegExpBuiltinExec
   // algorithm, step 4) even if the value is discarded for non-global RegExps.
   var i = TO_LENGTH_OR_INTEGER(lastIndex);
 
-  if (this.global || (FLAG_harmony_regexps && this.sticky)) {
+  if (REGEXP_GLOBAL(this) || REGEXP_STICKY(this)) {
     if (i < 0 || i > string.length) {
       this.lastIndex = 0;
       return false;
     }
     // matchIndices is either null or the RegExpLastMatchInfo array.
     var matchIndices = %_RegExpExec(this, string, i, RegExpLastMatchInfo);
     if (IS_NULL(matchIndices)) {
       this.lastIndex = 0;
       return false;
     }
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
     return true;
   } else {
     // Non-global, non-sticky regexp.
     // Remove irrelevant preceeding '.*' in a test regexp.  The expression
     // checks whether this.source starts with '.*' and that the third char is
     // not a '?'.  But see https://code.google.com/p/v8/issues/detail?id=3560
     var regexp = this;
-    if (regexp.source.length >= 3 &&
-        %_StringCharCodeAt(regexp.source, 0) == 46 &&  // '.'
-        %_StringCharCodeAt(regexp.source, 1) == 42 &&  // '*'
-        %_StringCharCodeAt(regexp.source, 2) != 63) {  // '?'
+    var source = REGEXP_SOURCE(regexp);
+    if (regexp.length >= 3 &&
+        %_StringCharCodeAt(regexp, 0) == 46 &&  // '.'
+        %_StringCharCodeAt(regexp, 1) == 42 &&  // '*'
+        %_StringCharCodeAt(regexp, 2) != 63) {  // '?'
       regexp = TrimRegExp(regexp);
     }
     // matchIndices is either null or the RegExpLastMatchInfo array.
     var matchIndices = %_RegExpExec(regexp, string, 0, RegExpLastMatchInfo);
     if (IS_NULL(matchIndices)) {
       this.lastIndex = 0;
       return false;
     }
     return true;
   }
 }
 
 function TrimRegExp(regexp) {
   if (!%_ObjectEquals(regexp_key, regexp)) {
     regexp_key = regexp;
     regexp_val =
-      new GlobalRegExp(%_SubString(regexp.source, 2, regexp.source.length),
-                       (regexp.ignoreCase ? regexp.multiline ? "im" : "i"
-                                          : regexp.multiline ? "m" : ""));
+      new GlobalRegExp(
+          %_SubString(REGEXP_SOURCE(regexp), 2, REGEXP_SOURCE(regexp).length),
+          (REGEXP_IGNORE_CASE(regexp) ? REGEXP_MULTILINE(regexp) ? "im" : "i"
+                                      : REGEXP_MULTILINE(regexp) ? "m" : ""));
   }
   return regexp_val;
 }
 
 
 function RegExpToString() {
   if (!IS_REGEXP(this)) {
     throw MakeTypeError(kIncompatibleMethodReceiver,
                         'RegExp.prototype.toString', this);
   }
-  var result = '/' + this.source + '/';
-  if (this.global) result += 'g';
-  if (this.ignoreCase) result += 'i';
-  if (this.multiline) result += 'm';
-  if (FLAG_harmony_unicode_regexps && this.unicode) result += 'u';
-  if (FLAG_harmony_regexps && this.sticky) result += 'y';
+  var result = '/' + REGEXP_SOURCE(this) + '/';
+  if (REGEXP_GLOBAL(this)) result += 'g';
+  if (REGEXP_IGNORE_CASE(this)) result += 'i';
+  if (REGEXP_MULTILINE(this)) result += 'm';
+  if (REGEXP_UNICODE(this)) result += 'u';
+  if (REGEXP_STICKY(this)) result += 'y';
   return result;
 }
 
 
 // Getters for the static properties lastMatch, lastParen, leftContext, and
 // rightContext of the RegExp constructor.  The properties are computed based
 // on the captures array of the last successful match and the subject string
 // of the last successful match.
 function RegExpGetLastMatch() {
   var regExpSubject = LAST_SUBJECT(RegExpLastMatchInfo);
@@ skipping 44 matching lines @@
   return function foo() {
     var index = n * 2;
     if (index >= NUMBER_OF_CAPTURES(RegExpLastMatchInfo)) return '';
     var matchStart = RegExpLastMatchInfo[CAPTURE(index)];
     var matchEnd = RegExpLastMatchInfo[CAPTURE(index + 1)];
     if (matchStart == -1 || matchEnd == -1) return '';
     return %_SubString(LAST_SUBJECT(RegExpLastMatchInfo), matchStart, matchEnd);
   };
 }
 
+
+// ES6 21.2.5.4.
+function RegExpGetGlobal() {
+  if (!IS_REGEXP(this)) {
+    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.global");
+  }
+  return !!REGEXP_GLOBAL(this);
+}
+%FunctionSetName(RegExpGetGlobal, "RegExp.prototype.global");
+%SetNativeFlag(RegExpGetGlobal);
+
+
+// ES6 21.2.5.5.
+function RegExpGetIgnoreCase() {
+  if (!IS_REGEXP(this)) {
+    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.ignoreCase");
+  }
+  return !!REGEXP_IGNORE_CASE(this);
+}
+%FunctionSetName(RegExpGetIgnoreCase, "RegExp.prototype.ignoreCase");
+%SetNativeFlag(RegExpGetIgnoreCase);
+
+
+// ES6 21.2.5.7.
+function RegExpGetMultiline() {
+  if (!IS_REGEXP(this)) {
+    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.multiline");
+  }
+  return !!REGEXP_MULTILINE(this);
+}
+%FunctionSetName(RegExpGetMultiline, "RegExp.prototype.multiline");
+%SetNativeFlag(RegExpGetMultiline);
+
+
+// ES6 21.2.5.10.
+function RegExpGetSource() {
+  if (!IS_REGEXP(this)) {
+    throw MakeTypeError(kRegExpNonRegExp, "RegExp.prototype.source");
+  }
+  return REGEXP_SOURCE(this);
+}
+%FunctionSetName(RegExpGetSource, "RegExp.prototype.source");
+%SetNativeFlag(RegExpGetSource);
+
 // -------------------------------------------------------------------
 
 %FunctionSetInstanceClassName(GlobalRegExp, 'RegExp');
 %FunctionSetPrototype(GlobalRegExp, new GlobalObject());
 %AddNamedProperty(
     GlobalRegExp.prototype, 'constructor', GlobalRegExp, DONT_ENUM);
 %SetCode(GlobalRegExp, RegExpConstructor);
 
 utils.InstallFunctions(GlobalRegExp.prototype, DONT_ENUM, [
   "exec", RegExpExecJS,
   "test", RegExpTest,
   "toString", RegExpToString,
   "compile", RegExpCompileJS
 ]);
 
+%DefineGetterPropertyUnchecked(GlobalRegExp.prototype, "global",
+                               RegExpGetGlobal, DONT_ENUM);
+%DefineGetterPropertyUnchecked(GlobalRegExp.prototype, "ignoreCase",
+                               RegExpGetIgnoreCase, DONT_ENUM);
+%DefineGetterPropertyUnchecked(GlobalRegExp.prototype, "multiline",
+                               RegExpGetMultiline, DONT_ENUM);
+%DefineGetterPropertyUnchecked(GlobalRegExp.prototype, "source",
+                               RegExpGetSource, DONT_ENUM);
+
 // The length of compile is 1 in SpiderMonkey.
 %FunctionSetLength(GlobalRegExp.prototype.compile, 1);
 
 // The properties `input` and `$_` are aliases for each other.  When this
 // value is set the value it is set to is coerced to a string.
 // Getter and setter for the input.
 var RegExpGetInput = function() {
   var regExpInput = LAST_INPUT(RegExpLastMatchInfo);
   return IS_UNDEFINED(regExpInput) ? "" : regExpInput;
 };
@@ skipping 60 matching lines @@
 // Exports
 
 utils.Export(function(to) {
   to.RegExpExec = DoRegExpExec;
   to.RegExpExecNoTests = RegExpExecNoTests;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
 });
 
 })