Revert of [regexp] Port RegExpConstructor

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 ExpandReplacement;
 var GlobalArray = global.Array;
 var GlobalObject = global.Object;
 var GlobalRegExp = global.RegExp;
+var GlobalRegExpPrototype;
 var InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
 var MaxSimple;
 var MinSimple;
 var matchSymbol = utils.ImportNow("match_symbol");
 var replaceSymbol = utils.ImportNow("replace_symbol");
 var searchSymbol = utils.ImportNow("search_symbol");
 var speciesSymbol = utils.ImportNow("species_symbol");
 var splitSymbol = utils.ImportNow("split_symbol");
 var SpeciesConstructor;
@@ skipping 46 matching lines @@
 
 function PatternFlags(pattern) {
   return (REGEXP_GLOBAL(pattern) ? 'g' : '') +
          (REGEXP_IGNORE_CASE(pattern) ? 'i' : '') +
          (REGEXP_MULTILINE(pattern) ? 'm' : '') +
          (REGEXP_UNICODE(pattern) ? 'u' : '') +
          (REGEXP_STICKY(pattern) ? 'y' : '');
 }
 
 
+// ES#sec-regexp-pattern-flags
+// RegExp ( pattern, flags )
+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 = PatternFlags(pattern);
+    pattern = REGEXP_SOURCE(pattern);
+
+  } else if (pattern_is_regexp) {
+    var input_pattern = pattern;
+    pattern = pattern.source;
+    if (IS_UNDEFINED(flags)) flags = input_pattern.flags;
+  }
+
+  var object = %_NewObject(GlobalRegExp, newtarget);
+  return RegExpInitialize(object, pattern, flags);
+}
+
+
 // ES#sec-regexp.prototype.compile RegExp.prototype.compile (pattern, flags)
 function RegExpCompileJS(pattern, flags) {
   if (!IS_REGEXP(this)) {
     throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.compile", this);
   }
 
   if (IS_REGEXP(pattern)) {
     if (!IS_UNDEFINED(flags)) throw %make_type_error(kRegExpFlags);
 
@@ skipping 240 matching lines @@
   }
   return regexp_val;
 }
 
 
 function RegExpToString() {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(
         kIncompatibleMethodReceiver, 'RegExp.prototype.toString', this);
   }
-  if (this === GlobalRegExp.prototype) {
+  if (this === GlobalRegExpPrototype) {
     %IncrementUseCounter(kRegExpPrototypeToString);
   }
   return '/' + TO_STRING(this.source) + '/' + TO_STRING(this.flags);
 }
 
 
 function AtSurrogatePair(subject, index) {
   if (index + 1 >= subject.length) return false;
   var first = %_StringCharCodeAt(subject, index);
   if (first < 0xD800 || first > 0xDBFF) return false;
@@ skipping 644 matching lines @@
   if (this.unicode) result += 'u';
   if (this.sticky) result += 'y';
   return result;
 }
 
 
 // ES6 21.2.5.4.
 function RegExpGetGlobal() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
+    if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
       return UNDEFINED;
     }
     throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.global");
   }
   return TO_BOOLEAN(REGEXP_GLOBAL(this));
 }
 %SetForceInlineFlag(RegExpGetGlobal);
 
 
 // ES6 21.2.5.5.
 function RegExpGetIgnoreCase() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
+    if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
       return UNDEFINED;
     }
     throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.ignoreCase");
   }
   return TO_BOOLEAN(REGEXP_IGNORE_CASE(this));
 }
 
 
 // ES6 21.2.5.7.
 function RegExpGetMultiline() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
+    if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeOldFlagGetter);
       return UNDEFINED;
     }
     throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.multiline");
   }
   return TO_BOOLEAN(REGEXP_MULTILINE(this));
 }
 
 
 // ES6 21.2.5.10.
 function RegExpGetSource() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
+    if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeSourceGetter);
       return "(?:)";
     }
     throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.source");
   }
   return REGEXP_SOURCE(this);
 }
 
 
 // ES6 21.2.5.12.
 function RegExpGetSticky() {
   if (!IS_REGEXP(this)) {
     // Compat fix: RegExp.prototype.sticky == undefined; UseCounter tracks it
     // TODO(littledan): Remove this workaround or standardize it
-    if (this === GlobalRegExp.prototype) {
+    if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeStickyGetter);
       return UNDEFINED;
     }
     throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.sticky");
   }
   return TO_BOOLEAN(REGEXP_STICKY(this));
 }
 %SetForceInlineFlag(RegExpGetSticky);
 
 
 // ES6 21.2.5.15.
 function RegExpGetUnicode() {
   if (!IS_REGEXP(this)) {
     // TODO(littledan): Remove this RegExp compat workaround
-    if (this === GlobalRegExp.prototype) {
+    if (this === GlobalRegExpPrototype) {
       %IncrementUseCounter(kRegExpPrototypeUnicodeGetter);
       return UNDEFINED;
     }
     throw %make_type_error(kRegExpNonRegExp, "RegExp.prototype.unicode");
   }
   return TO_BOOLEAN(REGEXP_UNICODE(this));
 }
 %SetForceInlineFlag(RegExpGetUnicode);
 
 
 function RegExpSpecies() {
   return this;
 }
 
 
 // -------------------------------------------------------------------
 
+%FunctionSetInstanceClassName(GlobalRegExp, 'RegExp');
+GlobalRegExpPrototype = new GlobalObject();
+%FunctionSetPrototype(GlobalRegExp, GlobalRegExpPrototype);
+%AddNamedProperty(
+    GlobalRegExp.prototype, 'constructor', GlobalRegExp, DONT_ENUM);
+%SetCode(GlobalRegExp, RegExpConstructor);
+
 utils.InstallGetter(GlobalRegExp, speciesSymbol, RegExpSpecies);
 
 utils.InstallFunctions(GlobalRegExp.prototype, DONT_ENUM, [
   "exec", RegExpSubclassExecJS,
   "test", RegExpSubclassTest,
   "toString", RegExpToString,
   "compile", RegExpCompileJS,
   matchSymbol, RegExpSubclassMatch,
   replaceSymbol, RegExpSubclassReplace,
   searchSymbol, RegExpSubclassSearch,
@@ skipping 84 matching lines @@
   to.InternalRegExpMatch = InternalRegExpMatch;
   to.InternalRegExpReplace = InternalRegExpReplace;
   to.IsRegExp = IsRegExp;
   to.RegExpExec = DoRegExpExec;
   to.RegExpInitialize = RegExpInitialize;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
 });
 
 })