Introduce a BuiltinsConstructStub that sets up new.target and does a [[call]] per ES6 9.3.2

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_tolength;
 var GlobalObject = global.Object;
 var GlobalRegExp = global.RegExp;
 var InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
 var MakeTypeError;
 var splitSymbol = utils.ImportNow("split_symbol");
+var matchSymbol = utils.ImportNow("match_symbol");;
 
 utils.ImportFromExperimental(function(from) {
   FLAG_harmony_tolength = from.FLAG_harmony_tolength;
 });
 
 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
 // array of the last successful regexp match (an array of start/end index
 // pairs for the match and all the captured substrings), the invariant is
 // that there are at least two capture indeces.  The array also contains
 // the subject string for the last successful match.
 var RegExpLastMatchInfo = new InternalPackedArray(
  2,                 // REGEXP_NUMBER_OF_CAPTURES
  "",                // Last subject.
  UNDEFINED,         // Last input - settable with RegExpSetInput.
  0,                 // REGEXP_FIRST_CAPTURE + 0
  0                  // REGEXP_FIRST_CAPTURE + 1
 );
 
 // -------------------------------------------------------------------
 
-// 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.
+function IsRegExp(o) {
+  if (!IS_OBJECT(o)) return false;
+  var is_regexp = o[matchSymbol];
+  if (!IS_UNDEFINED(is_regexp)) return TO_BOOLEAN(is_regexp);
+  return IS_REGEXP(o);
+}
+
+
+// ES6 section 21.2.3.2.2
+function RegExpInitialize(object, pattern, flags) {
+  pattern = IS_UNDEFINED(pattern) ? '' : TO_STRING(pattern);
+  flags = IS_UNDEFINED(flags) ? '' : TO_STRING(flags);
+  %RegExpInitializeAndCompile(object, pattern, flags);
+  return object;
+}
+
+
+function RegExpConstructor(pattern, flags) {
+  var newtarget = new.target;
+  var pattern_is_regexp = IsRegExp(pattern);
+
+  if (IS_UNDEFINED(newtarget)) {
+    newtarget = GlobalRegExp;
+
+    // ES6 section 21.2.3.1 step 3.b
+    if (pattern_is_regexp && IS_UNDEFINED(flags) &&
+        pattern.constructor === newtarget) {
+      return pattern;
+    }
+  }
+
+  if (IS_REGEXP(pattern)) {
+    if (IS_UNDEFINED(flags)) {
+      flags = (REGEXP_GLOBAL(pattern) ? 'g' : '')

[Igor Sheludko, 2015/11/19 09:30:53]

We do this kind of thing in three places already, what about wrapping this code
to a helper function?

+          + (REGEXP_IGNORE_CASE(pattern) ? 'i' : '')
+          + (REGEXP_MULTILINE(pattern) ? 'm' : '')
+          + (REGEXP_UNICODE(pattern) ? 'u' : '')
+          + (REGEXP_STICKY(pattern) ? 'y' : '');
+    }
+    pattern = REGEXP_SOURCE(pattern);
+
+  } else if (pattern_is_regexp) {
+    var input_pattern = pattern;
+    pattern = pattern.source;

[Igor Sheludko, 2015/11/19 09:30:53]

Shouldn't this be a REGEXP_SOURCE(pattern) instead?

BTW, let's be uniform and put this line after next line and avoid introducing
var input_patter.

[Toon Verwaest, 2015/11/19 09:39:53]

We actually have to do Get(..."source") and "flags" according to the spec, both
of which are observable.

+    if (IS_UNDEFINED(flags)) flags = input_pattern.flags;
+  }
+
+  var object = %NewObject(GlobalRegExp, newtarget);
+  return RegExpInitialize(object, pattern, flags);
+}
+
+
+function RegExpCompileJS(pattern, flags) {
+  if (!IS_REGEXP(this)) {
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        "RegExp.prototype.compile", this);
+  }
+
   if (IS_REGEXP(pattern)) {
     if (!IS_UNDEFINED(flags)) throw MakeTypeError(kRegExpFlags);
+
     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);
+  return RegExpInitialize(this, pattern, flags);
 }
 
 
-function RegExpConstructor(pattern, flags) {
-  if (%_IsConstructCall()) {
-    DoConstructRegExp(this, pattern, flags);
-  } else {
-    // RegExp : Called as function; see ECMA-262, section 15.10.3.1.
-    if (IS_REGEXP(pattern) && IS_UNDEFINED(flags)) {
-      return pattern;
-    }
-    return new GlobalRegExp(pattern, flags);
-  }
-}
-
-// Deprecated RegExp.prototype.compile method.  We behave like the constructor
-// were called again.  In SpiderMonkey, this method returns the regexp object.
-// In JSC, it returns undefined.  For compatibility with JSC, we match their
-// behavior.
-function RegExpCompileJS(pattern, flags) {
-  // Both JSC and SpiderMonkey treat a missing pattern argument as the
-  // empty subject string, and an actual undefined value passed as the
-  // pattern as the string 'undefined'.  Note that JSC is inconsistent
-  // here, treating undefined values differently in
-  // RegExp.prototype.compile and in the constructor, where they are
-  // the empty string.  For compatibility with JSC, we match their
-  // behavior.
-  if (this == GlobalRegExp.prototype) {
-    // We don't allow recompiling RegExp.prototype.
-    throw MakeTypeError(kIncompatibleMethodReceiver,
-                        'RegExp.prototype.compile', this);
-  }
-  if (IS_UNDEFINED(pattern) && %_ArgumentsLength() != 0) {
-    DoConstructRegExp(this, 'undefined', flags);
-  } else {
-    DoConstructRegExp(this, pattern, flags);
-  }
-}
-
-
 function DoRegExpExec(regexp, string, index) {
   var result = %_RegExpExec(regexp, string, index, RegExpLastMatchInfo);
   return result;
 }
 
 
 // This is kind of performance sensitive, so we want to avoid unnecessary
 // type checks on inputs. But we also don't want to inline it several times
 // manually, so we use a macro :-)
 macro RETURN_NEW_RESULT_FROM_MATCH_INFO(MATCHINFO, STRING)
@@ skipping 403 matching lines @@
 // Exports
 
 utils.Export(function(to) {
   to.RegExpExec = DoRegExpExec;
   to.RegExpExecNoTests = RegExpExecNoTests;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
 });
 
 })