test262: test262/test/built-ins/Array/S15.4.3_A2.2.js
[WebKit-https.git] / Source / JavaScriptCore / runtime / RegExpConstructor.cpp
index 1547813..fcc6026 100644 (file)
@@ -1,6 +1,6 @@
 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
- *  Copyright (C) 2003, 2007, 2008 Apple Inc. All Rights Reserved.
+ *  Copyright (C) 2003, 2007-2008, 2016 Apple Inc. All Rights Reserved.
  *  Copyright (C) 2009 Torch Mobile, Inc.
  *
  *  This library is free software; you can redistribute it and/or
 #include "config.h"
 #include "RegExpConstructor.h"
 
-#include "ArrayPrototype.h"
 #include "Error.h"
-#include "ExceptionHelpers.h"
-#include "JSArray.h"
-#include "JSFunction.h"
-#include "JSString.h"
-#include "Lookup.h"
-#include "ObjectPrototype.h"
-#include "RegExpMatchesArray.h"
-#include "RegExpObject.h"
+#include "GetterSetter.h"
+#include "JSCInlines.h"
 #include "RegExpPrototype.h"
-#include "RegExp.h"
-#include "RegExpCache.h"
-#include "UStringConcatenate.h"
-#include <wtf/PassOwnPtr.h>
+#include "StructureInlines.h"
 
 namespace JSC {
 
-static JSValue regExpConstructorInput(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorMultiline(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorLastMatch(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorLastParen(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorLeftContext(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorRightContext(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar1(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar2(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar3(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar4(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar5(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar6(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar7(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar8(ExecState*, JSValue, const Identifier&);
-static JSValue regExpConstructorDollar9(ExecState*, JSValue, const Identifier&);
-
-static void setRegExpConstructorInput(ExecState*, JSObject*, JSValue);
-static void setRegExpConstructorMultiline(ExecState*, JSObject*, JSValue);
+static EncodedJSValue regExpConstructorInput(ExecState*, EncodedJSValue, PropertyName);
+static EncodedJSValue regExpConstructorMultiline(ExecState*, EncodedJSValue, PropertyName);
+static EncodedJSValue regExpConstructorLastMatch(ExecState*, EncodedJSValue, PropertyName);
+static EncodedJSValue regExpConstructorLastParen(ExecState*, EncodedJSValue, PropertyName);
+static EncodedJSValue regExpConstructorLeftContext(ExecState*, EncodedJSValue, PropertyName);
+static EncodedJSValue regExpConstructorRightContext(ExecState*, EncodedJSValue, PropertyName);
+template<int N>
+static EncodedJSValue regExpConstructorDollar(ExecState*, EncodedJSValue, PropertyName);
+
+static bool setRegExpConstructorInput(ExecState*, EncodedJSValue, EncodedJSValue);
+static bool setRegExpConstructorMultiline(ExecState*, EncodedJSValue, EncodedJSValue);
 
 } // namespace JSC
 
@@ -65,9 +48,7 @@ static void setRegExpConstructorMultiline(ExecState*, JSObject*, JSValue);
 
 namespace JSC {
 
-ASSERT_CLASS_FITS_IN_CELL(RegExpConstructor);
-
-const ClassInfo RegExpConstructor::s_info = { "Function", &InternalFunction::s_info, 0, ExecState::regExpConstructorTable };
+const ClassInfo RegExpConstructor::s_info = { "Function", &InternalFunction::s_info, &regExpConstructorTable, CREATE_METHOD_TABLE(RegExpConstructor) };
 
 /* Source for RegExpConstructor.lut.h
 @begin regExpConstructorTable
@@ -83,291 +64,268 @@ const ClassInfo RegExpConstructor::s_info = { "Function", &InternalFunction::s_i
     $`              regExpConstructorLeftContext    DontDelete|ReadOnly|DontEnum
     rightContext    regExpConstructorRightContext   DontDelete|ReadOnly
     $'              regExpConstructorRightContext   DontDelete|ReadOnly|DontEnum
-    $1              regExpConstructorDollar1        DontDelete|ReadOnly
-    $2              regExpConstructorDollar2        DontDelete|ReadOnly
-    $3              regExpConstructorDollar3        DontDelete|ReadOnly
-    $4              regExpConstructorDollar4        DontDelete|ReadOnly
-    $5              regExpConstructorDollar5        DontDelete|ReadOnly
-    $6              regExpConstructorDollar6        DontDelete|ReadOnly
-    $7              regExpConstructorDollar7        DontDelete|ReadOnly
-    $8              regExpConstructorDollar8        DontDelete|ReadOnly
-    $9              regExpConstructorDollar9        DontDelete|ReadOnly
+    $1              regExpConstructorDollar<1>      DontDelete|ReadOnly
+    $2              regExpConstructorDollar<2>      DontDelete|ReadOnly
+    $3              regExpConstructorDollar<3>      DontDelete|ReadOnly
+    $4              regExpConstructorDollar<4>      DontDelete|ReadOnly
+    $5              regExpConstructorDollar<5>      DontDelete|ReadOnly
+    $6              regExpConstructorDollar<6>      DontDelete|ReadOnly
+    $7              regExpConstructorDollar<7>      DontDelete|ReadOnly
+    $8              regExpConstructorDollar<8>      DontDelete|ReadOnly
+    $9              regExpConstructorDollar<9>      DontDelete|ReadOnly
 @end
 */
 
-RegExpConstructor::RegExpConstructor(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, RegExpPrototype* regExpPrototype)
-    : InternalFunction(&exec->globalData(), globalObject, structure, Identifier(exec, "RegExp"))
-    , d(adoptPtr(new RegExpConstructorPrivate))
+RegExpConstructor::RegExpConstructor(VM& vm, Structure* structure, RegExpPrototype* regExpPrototype)
+    : InternalFunction(vm, structure)
+    , m_cachedResult(vm, this, regExpPrototype->emptyRegExp())
+    , m_multiline(false)
 {
-    ASSERT(inherits(&s_info));
-
-    // ECMA 15.10.5.1 RegExp.prototype
-    putDirectWithoutTransition(exec->globalData(), exec->propertyNames().prototype, regExpPrototype, DontEnum | DontDelete | ReadOnly);
-
-    // no. of arguments for constructor
-    putDirectWithoutTransition(exec->globalData(), exec->propertyNames().length, jsNumber(2), ReadOnly | DontDelete | DontEnum);
 }
 
-RegExpMatchesArray::RegExpMatchesArray(ExecState* exec, RegExpConstructorPrivate* data)
-    : JSArray(exec->globalData(), exec->lexicalGlobalObject()->regExpMatchesArrayStructure(), data->lastNumSubPatterns + 1, CreateInitialized)
+void RegExpConstructor::finishCreation(VM& vm, RegExpPrototype* regExpPrototype, GetterSetter* speciesSymbol)
 {
-    RegExpConstructorPrivate* d = new RegExpConstructorPrivate;
-    d->input = data->lastInput;
-    d->lastInput = data->lastInput;
-    d->lastNumSubPatterns = data->lastNumSubPatterns;
-    unsigned offsetVectorSize = (data->lastNumSubPatterns + 1) * 2; // only copying the result part of the vector
-    d->lastOvector().resize(offsetVectorSize);
-    memcpy(d->lastOvector().data(), data->lastOvector().data(), offsetVectorSize * sizeof(int));
-    // d->multiline is not needed, and remains uninitialized
-
-    setSubclassData(d);
-}
+    Base::finishCreation(vm, ASCIILiteral("RegExp"));
+    ASSERT(inherits(vm, info()));
 
-RegExpMatchesArray::~RegExpMatchesArray()
-{
-    delete static_cast<RegExpConstructorPrivate*>(subclassData());
+    putDirectWithoutTransition(vm, vm.propertyNames->prototype, regExpPrototype, DontEnum | DontDelete | ReadOnly);
+    putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(2), ReadOnly | DontEnum);
+
+    putDirectNonIndexAccessor(vm, vm.propertyNames->speciesSymbol, speciesSymbol, Accessor | ReadOnly | DontEnum);
 }
 
-void RegExpMatchesArray::fillArrayInstance(ExecState* exec)
+void RegExpConstructor::destroy(JSCell* cell)
 {
-    RegExpConstructorPrivate* d = static_cast<RegExpConstructorPrivate*>(subclassData());
-    ASSERT(d);
-
-    unsigned lastNumSubpatterns = d->lastNumSubPatterns;
-
-    for (unsigned i = 0; i <= lastNumSubpatterns; ++i) {
-        int start = d->lastOvector()[2 * i];
-        if (start >= 0)
-            JSArray::put(exec, i, jsSubstring(exec, d->lastInput, start, d->lastOvector()[2 * i + 1] - start));
-        else
-            JSArray::put(exec, i, jsUndefined());
-    }
-
-    PutPropertySlot slot;
-    JSArray::put(exec, exec->propertyNames().index, jsNumber(d->lastOvector()[0]), slot);
-    JSArray::put(exec, exec->propertyNames().input, jsString(exec, d->input), slot);
-
-    delete d;
-    setSubclassData(0);
+    static_cast<RegExpConstructor*>(cell)->RegExpConstructor::~RegExpConstructor();
 }
 
-JSObject* RegExpConstructor::arrayOfMatches(ExecState* exec) const
+void RegExpConstructor::visitChildren(JSCell* cell, SlotVisitor& visitor)
 {
-    return new (exec) RegExpMatchesArray(exec, d.get());
+    RegExpConstructor* thisObject = jsCast<RegExpConstructor*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    thisObject->m_cachedResult.visitChildren(visitor);
 }
 
-JSValue RegExpConstructor::getBackref(ExecState* exec, unsigned i) const
+JSValue RegExpConstructor::getBackref(ExecState* exec, unsigned i)
 {
-    if (!d->lastOvector().isEmpty() && i <= d->lastNumSubPatterns) {
-        int start = d->lastOvector()[2 * i];
-        if (start >= 0)
-            return jsSubstring(exec, d->lastInput, start, d->lastOvector()[2 * i + 1] - start);
+    JSArray* array = m_cachedResult.lastResult(exec, this);
+
+    if (i < array->length()) {
+        JSValue result = JSValue(array).get(exec, i);
+        ASSERT(result.isString() || result.isUndefined());
+        if (!result.isUndefined())
+            return result;
     }
     return jsEmptyString(exec);
 }
 
-JSValue RegExpConstructor::getLastParen(ExecState* exec) const
+JSValue RegExpConstructor::getLastParen(ExecState* exec)
 {
-    unsigned i = d->lastNumSubPatterns;
-    if (i > 0) {
-        ASSERT(!d->lastOvector().isEmpty());
-        int start = d->lastOvector()[2 * i];
-        if (start >= 0)
-            return jsSubstring(exec, d->lastInput, start, d->lastOvector()[2 * i + 1] - start);
+    JSArray* array = m_cachedResult.lastResult(exec, this);
+    unsigned length = array->length();
+    if (length > 1) {
+        JSValue result = JSValue(array).get(exec, length - 1);
+        ASSERT(result.isString() || result.isUndefined());
+        if (!result.isUndefined())
+            return result;
     }
     return jsEmptyString(exec);
 }
 
-JSValue RegExpConstructor::getLeftContext(ExecState* exec) const
+JSValue RegExpConstructor::getLeftContext(ExecState* exec)
 {
-    if (!d->lastOvector().isEmpty())
-        return jsSubstring(exec, d->lastInput, 0, d->lastOvector()[0]);
-    return jsEmptyString(exec);
+    return m_cachedResult.leftContext(exec, this);
 }
 
-JSValue RegExpConstructor::getRightContext(ExecState* exec) const
+JSValue RegExpConstructor::getRightContext(ExecState* exec)
 {
-    if (!d->lastOvector().isEmpty())
-        return jsSubstring(exec, d->lastInput, d->lastOvector()[1], d->lastInput.length() - d->lastOvector()[1]);
-    return jsEmptyString(exec);
-}
-    
-bool RegExpConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
-{
-    return getStaticValueSlot<RegExpConstructor, InternalFunction>(exec, ExecState::regExpConstructorTable(exec), this, propertyName, slot);
+    return m_cachedResult.rightContext(exec, this);
 }
 
-bool RegExpConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
+template<int N>
+EncodedJSValue regExpConstructorDollar(ExecState* exec, EncodedJSValue thisValue, PropertyName)
 {
-    return getStaticValueDescriptor<RegExpConstructor, InternalFunction>(exec, ExecState::regExpConstructorTable(exec), this, propertyName, descriptor);
+    return JSValue::encode(asRegExpConstructor(JSValue::decode(thisValue))->getBackref(exec, N));
 }
 
-JSValue regExpConstructorDollar1(ExecState* exec, JSValue slotBase, const Identifier&)
+EncodedJSValue regExpConstructorInput(ExecState*, EncodedJSValue thisValue, PropertyName)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 1);
+    return JSValue::encode(asRegExpConstructor(JSValue::decode(thisValue))->input());
 }
 
-JSValue regExpConstructorDollar2(ExecState* exec, JSValue slotBase, const Identifier&)
+EncodedJSValue regExpConstructorMultiline(ExecState*, EncodedJSValue thisValue, PropertyName)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 2);
+    return JSValue::encode(jsBoolean(asRegExpConstructor(JSValue::decode(thisValue))->multiline()));
 }
 
-JSValue regExpConstructorDollar3(ExecState* exec, JSValue slotBase, const Identifier&)
+EncodedJSValue regExpConstructorLastMatch(ExecState* exec, EncodedJSValue thisValue, PropertyName)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 3);
+    return JSValue::encode(asRegExpConstructor(JSValue::decode(thisValue))->getBackref(exec, 0));
 }
 
-JSValue regExpConstructorDollar4(ExecState* exec, JSValue slotBase, const Identifier&)
+EncodedJSValue regExpConstructorLastParen(ExecState* exec, EncodedJSValue thisValue, PropertyName)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 4);
+    return JSValue::encode(asRegExpConstructor(JSValue::decode(thisValue))->getLastParen(exec));
 }
 
-JSValue regExpConstructorDollar5(ExecState* exec, JSValue slotBase, const Identifier&)
+EncodedJSValue regExpConstructorLeftContext(ExecState* exec, EncodedJSValue thisValue, PropertyName)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 5);
+    return JSValue::encode(asRegExpConstructor(JSValue::decode(thisValue))->getLeftContext(exec));
 }
 
-JSValue regExpConstructorDollar6(ExecState* exec, JSValue slotBase, const Identifier&)
+EncodedJSValue regExpConstructorRightContext(ExecState* exec, EncodedJSValue thisValue, PropertyName)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 6);
+    return JSValue::encode(asRegExpConstructor(JSValue::decode(thisValue))->getRightContext(exec));
 }
 
-JSValue regExpConstructorDollar7(ExecState* exec, JSValue slotBase, const Identifier&)
+bool setRegExpConstructorInput(ExecState* exec, EncodedJSValue thisValue, EncodedJSValue value)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 7);
+    if (auto constructor = jsDynamicCast<RegExpConstructor*>(exec->vm(), JSValue::decode(thisValue))) {
+        constructor->setInput(exec, JSValue::decode(value).toString(exec));
+        return true;
+    }
+    return false;
 }
 
-JSValue regExpConstructorDollar8(ExecState* exec, JSValue slotBase, const Identifier&)
+bool setRegExpConstructorMultiline(ExecState* exec, EncodedJSValue thisValue, EncodedJSValue value)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 8);
+    if (auto constructor = jsDynamicCast<RegExpConstructor*>(exec->vm(), JSValue::decode(thisValue))) {
+        constructor->setMultiline(JSValue::decode(value).toBoolean(exec));
+        return true;
+    }
+    return false;
 }
 
-JSValue regExpConstructorDollar9(ExecState* exec, JSValue slotBase, const Identifier&)
+inline Structure* getRegExpStructure(ExecState* exec, JSGlobalObject* globalObject, JSValue newTarget)
 {
-    return asRegExpConstructor(slotBase)->getBackref(exec, 9);
+    Structure* structure = globalObject->regExpStructure();
+    if (newTarget != jsUndefined())
+        structure = InternalFunction::createSubclassStructure(exec, newTarget, structure);
+    return structure;
 }
 
-JSValue regExpConstructorInput(ExecState* exec, JSValue slotBase, const Identifier&)
+inline RegExpFlags toFlags(ExecState* exec, JSValue flags)
 {
-    return jsString(exec, asRegExpConstructor(slotBase)->input());
-}
+    VM& vm = exec->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-JSValue regExpConstructorMultiline(ExecState*, JSValue slotBase, const Identifier&)
-{
-    return jsBoolean(asRegExpConstructor(slotBase)->multiline());
-}
+    if (flags.isUndefined())
+        return NoFlags;
+    JSString* flagsString = flags.toStringOrNull(exec);
+    ASSERT(!!scope.exception() == !flagsString);
+    if (UNLIKELY(!flagsString))
+        return InvalidFlags;
 
-JSValue regExpConstructorLastMatch(ExecState* exec, JSValue slotBase, const Identifier&)
-{
-    return asRegExpConstructor(slotBase)->getBackref(exec, 0);
+    RegExpFlags result = regExpFlags(flagsString->value(exec));
+    RETURN_IF_EXCEPTION(scope, InvalidFlags);
+    if (result == InvalidFlags)
+        throwSyntaxError(exec, scope, ASCIILiteral("Invalid flags supplied to RegExp constructor."));
+    return result;
 }
 
-JSValue regExpConstructorLastParen(ExecState* exec, JSValue slotBase, const Identifier&)
+static JSObject* regExpCreate(ExecState* exec, JSGlobalObject* globalObject, JSValue newTarget, JSValue patternArg, JSValue flagsArg)
 {
-    return asRegExpConstructor(slotBase)->getLastParen(exec);
-}
+    VM& vm = exec->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-JSValue regExpConstructorLeftContext(ExecState* exec, JSValue slotBase, const Identifier&)
-{
-    return asRegExpConstructor(slotBase)->getLeftContext(exec);
-}
+    String pattern = patternArg.isUndefined() ? emptyString() : patternArg.toWTFString(exec);
+    RETURN_IF_EXCEPTION(scope, nullptr);
 
-JSValue regExpConstructorRightContext(ExecState* exec, JSValue slotBase, const Identifier&)
-{
-    return asRegExpConstructor(slotBase)->getRightContext(exec);
-}
+    RegExpFlags flags = toFlags(exec, flagsArg);
+    ASSERT(!!scope.exception() == (flags == InvalidFlags));
+    if (UNLIKELY(flags == InvalidFlags))
+        return nullptr;
 
-void RegExpConstructor::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
-{
-    lookupPut<RegExpConstructor, InternalFunction>(exec, propertyName, value, ExecState::regExpConstructorTable(exec), this, slot);
-}
+    RegExp* regExp = RegExp::create(vm, pattern, flags);
+    if (!regExp->isValid())
+        return throwException(exec, scope, createSyntaxError(exec, regExp->errorMessage()));
 
-void setRegExpConstructorInput(ExecState* exec, JSObject* baseObject, JSValue value)
-{
-    asRegExpConstructor(baseObject)->setInput(value.toString(exec));
+    Structure* structure = getRegExpStructure(exec, globalObject, newTarget);
+    RETURN_IF_EXCEPTION(scope, nullptr);
+    return RegExpObject::create(vm, structure, regExp);
 }
 
-void setRegExpConstructorMultiline(ExecState* exec, JSObject* baseObject, JSValue value)
+JSObject* constructRegExp(ExecState* exec, JSGlobalObject* globalObject, const ArgList& args,  JSObject* callee, JSValue newTarget)
 {
-    asRegExpConstructor(baseObject)->setMultiline(value.toBoolean(exec));
-}
+    VM& vm = exec->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSValue patternArg = args.at(0);
+    JSValue flagsArg = args.at(1);
 
-// ECMA 15.10.4
-JSObject* constructRegExp(ExecState* exec, JSGlobalObject* globalObject, const ArgList& args)
-{
-    JSValue arg0 = args.at(0);
-    JSValue arg1 = args.at(1);
+    bool isPatternRegExp = patternArg.inherits(vm, RegExpObject::info());
+    bool constructAsRegexp = isRegExp(vm, exec, patternArg);
+    RETURN_IF_EXCEPTION(scope, nullptr);
 
-    if (arg0.inherits(&RegExpObject::s_info)) {
-        if (!arg1.isUndefined())
-            return throwError(exec, createTypeError(exec, "Cannot supply flags when constructing one RegExp from another."));
-        return asObject(arg0);
+    if (newTarget.isUndefined() && constructAsRegexp && flagsArg.isUndefined()) {
+        JSValue constructor = patternArg.get(exec, vm.propertyNames->constructor);
+        RETURN_IF_EXCEPTION(scope, nullptr);
+        if (callee == constructor) {
+            // We know that patternArg is a object otherwise constructAsRegexp would be false.
+            return patternArg.getObject();
+        }
     }
 
-    UString pattern = arg0.isUndefined() ? UString("") : arg0.toString(exec);
-    if (exec->hadException())
-        return 0;
-
-    RegExpFlags flags = NoFlags;
-    if (!arg1.isUndefined()) {
-        flags = regExpFlags(arg1.toString(exec));
-        if (exec->hadException())
-            return 0;
-        if (flags == InvalidFlags)
-            return throwError(exec, createSyntaxError(exec, "Invalid flags supplied to RegExp constructor."));
+    if (isPatternRegExp) {
+        RegExp* regExp = jsCast<RegExpObject*>(patternArg)->regExp();
+        Structure* structure = getRegExpStructure(exec, globalObject, newTarget);
+        RETURN_IF_EXCEPTION(scope, nullptr);
+
+        if (!flagsArg.isUndefined()) {
+            RegExpFlags flags = toFlags(exec, flagsArg);
+            ASSERT(!!scope.exception() == (flags == InvalidFlags));
+            if (flags == InvalidFlags)
+                return nullptr;
+            regExp = RegExp::create(vm, regExp->pattern(), flags);
+        }
+
+        return RegExpObject::create(vm, structure, regExp);
     }
 
-    RegExp* regExp = RegExp::create(&exec->globalData(), pattern, flags);
-    if (!regExp->isValid())
-        return throwError(exec, createSyntaxError(exec, regExp->errorMessage()));
-    return new (exec) RegExpObject(exec->lexicalGlobalObject(), globalObject->regExpStructure(), regExp);
+    if (constructAsRegexp) {
+        JSValue pattern = patternArg.get(exec, vm.propertyNames->source);
+        RETURN_IF_EXCEPTION(scope, nullptr);
+        if (flagsArg.isUndefined()) {
+            flagsArg = patternArg.get(exec, vm.propertyNames->flags);
+            RETURN_IF_EXCEPTION(scope, nullptr);
+        }
+        patternArg = pattern;
+    }
+
+    scope.release();
+    return regExpCreate(exec, globalObject, newTarget, patternArg, flagsArg);
+}
+
+EncodedJSValue JSC_HOST_CALL esSpecRegExpCreate(ExecState* exec)
+{
+    JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+    JSValue patternArg = exec->argument(0);
+    JSValue flagsArg = exec->argument(1);
+    return JSValue::encode(regExpCreate(exec, globalObject, jsUndefined(), patternArg, flagsArg));
 }
 
 static EncodedJSValue JSC_HOST_CALL constructWithRegExpConstructor(ExecState* exec)
 {
     ArgList args(exec);
-    return JSValue::encode(constructRegExp(exec, asInternalFunction(exec->callee())->globalObject(), args));
+    return JSValue::encode(constructRegExp(exec, asInternalFunction(exec->jsCallee())->globalObject(), args, exec->jsCallee(), exec->newTarget()));
 }
 
-ConstructType RegExpConstructor::getConstructData(ConstructData& constructData)
+ConstructType RegExpConstructor::getConstructData(JSCell*, ConstructData& constructData)
 {
     constructData.native.function = constructWithRegExpConstructor;
-    return ConstructTypeHost;
+    return ConstructType::Host;
 }
 
-// ECMA 15.10.3
 static EncodedJSValue JSC_HOST_CALL callRegExpConstructor(ExecState* exec)
 {
     ArgList args(exec);
-    return JSValue::encode(constructRegExp(exec, asInternalFunction(exec->callee())->globalObject(), args));
+    return JSValue::encode(constructRegExp(exec, asInternalFunction(exec->jsCallee())->globalObject(), args, exec->jsCallee()));
 }
 
-CallType RegExpConstructor::getCallData(CallData& callData)
+CallType RegExpConstructor::getCallData(JSCell*, CallData& callData)
 {
     callData.native.function = callRegExpConstructor;
-    return CallTypeHost;
-}
-
-void RegExpConstructor::setInput(const UString& input)
-{
-    d->input = input;
-}
-
-const UString& RegExpConstructor::input() const
-{
-    // Can detect a distinct initial state that is invisible to JavaScript, by checking for null
-    // state (since jsString turns null strings to empty strings).
-    return d->input;
-}
-
-void RegExpConstructor::setMultiline(bool multiline)
-{
-    d->multiline = multiline;
-}
-
-bool RegExpConstructor::multiline() const
-{
-    return d->multiline;
+    return CallType::Host;
 }
 
 } // namespace JSC