[WTF] Import std::optional reference implementation as WTF::Optional

author utatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Sun, 27 Nov 2016 06:08:16 +0000 (06:08 +0000)

committer utatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Sun, 27 Nov 2016 06:08:16 +0000 (06:08 +0000)
author utatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 27 Nov 2016 06:08:16 +0000 (06:08 +0000)
committer utatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 27 Nov 2016 06:08:16 +0000 (06:08 +0000)
diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog

index 92bb5b9..ad24699 100644 (file)
--- a/Source/JavaScriptCore/ChangeLog
+++ b/Source/JavaScriptCore/ChangeLog
@@ -1,3 +1,247 @@
+2016-11-26  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        [WTF] Import std::optional reference implementation as WTF::Optional
+        https://bugs.webkit.org/show_bug.cgi?id=164199
+
+        Reviewed by Saam Barati and Sam Weinig.
+
+        Previous WTF::Optional::operator= is not compatible to std::optional::operator=.
+        std::optional::emplace has the same semantics to the previous one.
+        So we change the code to use it.
+
+        * Scripts/builtins/builtins_templates.py:
+        * Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Combined.js-result:
+        * Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Separate.js-result:
+        * Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Combined.js-result:
+        * Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Separate.js-result:
+        * Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Combined.js-result:
+        * Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Separate.js-result:
+        * Scripts/tests/builtins/expected/JavaScriptCore-InternalClashingNames-Combined.js-result:
+        * Scripts/tests/builtins/expected/WebCore-AnotherGuardedInternalBuiltin-Separate.js-result:
+        * Scripts/tests/builtins/expected/WebCore-ArbitraryConditionalGuard-Separate.js-result:
+        * Scripts/tests/builtins/expected/WebCore-GuardedBuiltin-Separate.js-result:
+        * Scripts/tests/builtins/expected/WebCore-GuardedInternalBuiltin-Separate.js-result:
+        * Scripts/tests/builtins/expected/WebCore-UnguardedBuiltin-Separate.js-result:
+        * Scripts/tests/builtins/expected/WebCore-xmlCasingTest-Separate.js-result:
+        * assembler/MacroAssemblerARM64.h:
+        (JSC::MacroAssemblerARM64::commuteCompareToZeroIntoTest):
+        * assembler/MacroAssemblerX86Common.h:
+        (JSC::MacroAssemblerX86Common::commuteCompareToZeroIntoTest):
+        * b3/B3CheckSpecial.cpp:
+        (JSC::B3::CheckSpecial::forEachArg):
+        (JSC::B3::CheckSpecial::shouldTryAliasingDef):
+        * b3/B3CheckSpecial.h:
+        * b3/B3LowerToAir.cpp:
+        (JSC::B3::Air::LowerToAir::scaleForShl):
+        (JSC::B3::Air::LowerToAir::effectiveAddr):
+        (JSC::B3::Air::LowerToAir::tryAppendLea):
+        * b3/B3Opcode.cpp:
+        (JSC::B3::invertedCompare):
+        * b3/B3Opcode.h:
+        * b3/B3PatchpointSpecial.cpp:
+        (JSC::B3::PatchpointSpecial::forEachArg):
+        * b3/B3StackmapSpecial.cpp:
+        (JSC::B3::StackmapSpecial::forEachArgImpl):
+        * b3/B3StackmapSpecial.h:
+        * b3/B3Value.cpp:
+        (JSC::B3::Value::invertedCompare):
+        * b3/air/AirArg.h:
+        (JSC::B3::Air::Arg::isValidScale):
+        (JSC::B3::Air::Arg::isValidAddrForm):
+        (JSC::B3::Air::Arg::isValidIndexForm):
+        (JSC::B3::Air::Arg::isValidForm):
+        * b3/air/AirCustom.h:
+        (JSC::B3::Air::PatchCustom::shouldTryAliasingDef):
+        * b3/air/AirFixObviousSpills.cpp:
+        * b3/air/AirInst.h:
+        * b3/air/AirInstInlines.h:
+        (JSC::B3::Air::Inst::shouldTryAliasingDef):
+        * b3/air/AirIteratedRegisterCoalescing.cpp:
+        * b3/air/AirSpecial.cpp:
+        (JSC::B3::Air::Special::shouldTryAliasingDef):
+        * b3/air/AirSpecial.h:
+        * bytecode/BytecodeGeneratorification.cpp:
+        (JSC::BytecodeGeneratorification::storageForGeneratorLocal):
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::findPC):
+        (JSC::CodeBlock::bytecodeOffsetFromCallSiteIndex):
+        * bytecode/CodeBlock.h:
+        * bytecode/UnlinkedFunctionExecutable.cpp:
+        (JSC::UnlinkedFunctionExecutable::link):
+        * bytecode/UnlinkedFunctionExecutable.h:
+        * bytecompiler/BytecodeGenerator.h:
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::PropertyListNode::emitPutConstantProperty):
+        (JSC::ObjectPatternNode::bindValue):
+        * debugger/Debugger.cpp:
+        (JSC::Debugger::resolveBreakpoint):
+        * debugger/DebuggerCallFrame.cpp:
+        (JSC::DebuggerCallFrame::currentPosition):
+        * debugger/DebuggerParseData.cpp:
+        (JSC::DebuggerPausePositions::breakpointLocationForLineColumn):
+        * debugger/DebuggerParseData.h:
+        * debugger/ScriptProfilingScope.h:
+        * dfg/DFGAbstractInterpreterInlines.h:
+        (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
+        (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeDoubleUnaryOpEffects):
+        * dfg/DFGJITCode.cpp:
+        (JSC::DFG::JITCode::findPC):
+        * dfg/DFGJITCode.h:
+        * dfg/DFGOperations.cpp:
+        (JSC::DFG::operationPutByValInternal):
+        * dfg/DFGSlowPathGenerator.h:
+        (JSC::DFG::SlowPathGenerator::generate):
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::runSlowPathGenerators):
+        (JSC::DFG::SpeculativeJIT::emitUntypedBitOp):
+        (JSC::DFG::SpeculativeJIT::emitUntypedRightShiftBitOp):
+        (JSC::DFG::SpeculativeJIT::compileMathIC):
+        (JSC::DFG::SpeculativeJIT::compileArithDiv):
+        (JSC::DFG::SpeculativeJIT::compileCallDOMGetter):
+        * dfg/DFGSpeculativeJIT.h:
+        * dfg/DFGSpeculativeJIT32_64.cpp:
+        (JSC::DFG::SpeculativeJIT::compile):
+        * dfg/DFGSpeculativeJIT64.cpp:
+        (JSC::DFG::SpeculativeJIT::compileLogicalNot):
+        (JSC::DFG::SpeculativeJIT::emitBranch):
+        (JSC::DFG::SpeculativeJIT::compile):
+        * dfg/DFGStrengthReductionPhase.cpp:
+        (JSC::DFG::StrengthReductionPhase::handleNode):
+        * ftl/FTLJITCode.cpp:
+        (JSC::FTL::JITCode::findPC):
+        * ftl/FTLJITCode.h:
+        * heap/Heap.cpp:
+        (JSC::Heap::collectAsync):
+        (JSC::Heap::collectSync):
+        (JSC::Heap::collectInThread):
+        (JSC::Heap::requestCollection):
+        (JSC::Heap::willStartCollection):
+        (JSC::Heap::didFinishCollection):
+        (JSC::Heap::shouldDoFullCollection):
+        * heap/Heap.h:
+        (JSC::Heap::collectionScope):
+        * heap/HeapSnapshot.cpp:
+        (JSC::HeapSnapshot::nodeForCell):
+        (JSC::HeapSnapshot::nodeForObjectIdentifier):
+        * heap/HeapSnapshot.h:
+        * inspector/InspectorBackendDispatcher.cpp:
+        (Inspector::BackendDispatcher::dispatch):
+        (Inspector::BackendDispatcher::sendPendingErrors):
+        (Inspector::BackendDispatcher::reportProtocolError):
+        * inspector/InspectorBackendDispatcher.h:
+        * inspector/agents/InspectorHeapAgent.cpp:
+        (Inspector::InspectorHeapAgent::nodeForHeapObjectIdentifier):
+        (Inspector::InspectorHeapAgent::getPreview):
+        (Inspector::InspectorHeapAgent::getRemoteObject):
+        * inspector/agents/InspectorHeapAgent.h:
+        * inspector/remote/RemoteConnectionToTarget.h:
+        * inspector/remote/RemoteConnectionToTarget.mm:
+        (Inspector::RemoteConnectionToTarget::targetIdentifier):
+        (Inspector::RemoteConnectionToTarget::setup):
+        * inspector/remote/RemoteInspector.h:
+        * inspector/remote/RemoteInspector.mm:
+        (Inspector::RemoteInspector::updateClientCapabilities):
+        * inspector/scripts/codegen/generate_cpp_protocol_types_header.py:
+        (_generate_declarations_for_enum_conversion_methods):
+        (_generate_declarations_for_enum_conversion_methods.return_type_with_export_macro):
+        * inspector/scripts/codegen/generate_cpp_protocol_types_implementation.py:
+        (CppProtocolTypesImplementationGenerator._generate_enum_conversion_methods_for_domain.generate_conversion_method_body):
+        * inspector/scripts/tests/expected/commands-with-async-attribute.json-result:
+        * inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result:
+        * inspector/scripts/tests/expected/enum-values.json-result:
+        * inspector/scripts/tests/expected/shadowed-optional-type-setters.json-result:
+        * inspector/scripts/tests/expected/type-declaration-array-type.json-result:
+        * inspector/scripts/tests/expected/type-declaration-enum-type.json-result:
+        * inspector/scripts/tests/expected/type-requiring-runtime-casts.json-result:
+        * jit/JITCode.h:
+        (JSC::JITCode::findPC):
+        * jit/JITDivGenerator.cpp:
+        (JSC::JITDivGenerator::generateFastPath):
+        * jit/JITOperations.cpp:
+        * jit/PCToCodeOriginMap.cpp:
+        (JSC::PCToCodeOriginMap::findPC):
+        * jit/PCToCodeOriginMap.h:
+        * jsc.cpp:
+        (WTF::RuntimeArray::getOwnPropertySlot):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        * parser/ModuleAnalyzer.cpp:
+        (JSC::ModuleAnalyzer::exportVariable):
+        * runtime/ConcurrentJSLock.h:
+        (JSC::ConcurrentJSLocker::ConcurrentJSLocker):
+        * runtime/DefinePropertyAttributes.h:
+        (JSC::DefinePropertyAttributes::writable):
+        (JSC::DefinePropertyAttributes::configurable):
+        (JSC::DefinePropertyAttributes::enumerable):
+        * runtime/GenericArgumentsInlines.h:
+        (JSC::GenericArguments<Type>::getOwnPropertySlot):
+        (JSC::GenericArguments<Type>::put):
+        (JSC::GenericArguments<Type>::deleteProperty):
+        (JSC::GenericArguments<Type>::defineOwnProperty):
+        * runtime/HasOwnPropertyCache.h:
+        (JSC::HasOwnPropertyCache::get):
+        * runtime/HashMapImpl.h:
+        (JSC::concurrentJSMapHash):
+        * runtime/Identifier.h:
+        (JSC::parseIndex):
+        * runtime/JSArray.cpp:
+        (JSC::JSArray::defineOwnProperty):
+        * runtime/JSCJSValue.cpp:
+        (JSC::JSValue::toNumberFromPrimitive):
+        (JSC::JSValue::putToPrimitive):
+        * runtime/JSCJSValue.h:
+        * runtime/JSGenericTypedArrayView.h:
+        (JSC::JSGenericTypedArrayView::toAdaptorNativeFromValueWithoutCoercion):
+        * runtime/JSGenericTypedArrayViewConstructorInlines.h:
+        (JSC::constructGenericTypedArrayViewWithArguments):
+        (JSC::constructGenericTypedArrayView):
+        * runtime/JSGenericTypedArrayViewInlines.h:
+        (JSC::JSGenericTypedArrayView<Adaptor>::getOwnPropertySlot):
+        (JSC::JSGenericTypedArrayView<Adaptor>::put):
+        * runtime/JSModuleRecord.cpp:
+        * runtime/JSModuleRecord.h:
+        * runtime/JSObject.cpp:
+        (JSC::JSObject::putDirectAccessor):
+        (JSC::JSObject::deleteProperty):
+        (JSC::JSObject::putDirectMayBeIndex):
+        (JSC::JSObject::defineOwnProperty):
+        * runtime/JSObject.h:
+        (JSC::JSObject::getOwnPropertySlot):
+        (JSC::JSObject::getPropertySlot):
+        (JSC::JSObject::putOwnDataPropertyMayBeIndex):
+        * runtime/JSObjectInlines.h:
+        (JSC::JSObject::putInline):
+        * runtime/JSString.cpp:
+        (JSC::JSString::getStringPropertyDescriptor):
+        * runtime/JSString.h:
+        (JSC::JSString::getStringPropertySlot):
+        * runtime/LiteralParser.cpp:
+        (JSC::LiteralParser<CharType>::parse):
+        * runtime/MathCommon.h:
+        (JSC::safeReciprocalForDivByConst):
+        * runtime/ObjectPrototype.cpp:
+        (JSC::objectProtoFuncHasOwnProperty):
+        * runtime/PropertyDescriptor.h:
+        (JSC::toPropertyDescriptor):
+        * runtime/PropertyName.h:
+        (JSC::parseIndex):
+        * runtime/SamplingProfiler.cpp:
+        (JSC::SamplingProfiler::processUnverifiedStackTraces):
+        * runtime/StringObject.cpp:
+        (JSC::StringObject::put):
+        (JSC::isStringOwnProperty):
+        (JSC::StringObject::deleteProperty):
+        * runtime/ToNativeFromValue.h:
+        (JSC::toNativeFromValueWithoutCoercion):
+        * runtime/TypedArrayAdaptors.h:
+        (JSC::IntegralTypedArrayAdaptor::toNativeFromInt32WithoutCoercion):
+        (JSC::IntegralTypedArrayAdaptor::toNativeFromUint32WithoutCoercion):
+        (JSC::IntegralTypedArrayAdaptor::toNativeFromDoubleWithoutCoercion):
+        (JSC::FloatTypedArrayAdaptor::toNativeFromInt32WithoutCoercion):
+        (JSC::FloatTypedArrayAdaptor::toNativeFromDoubleWithoutCoercion):
+        (JSC::Uint8ClampedAdaptor::toNativeFromInt32WithoutCoercion):
+        (JSC::Uint8ClampedAdaptor::toNativeFromDoubleWithoutCoercion):
+
  2016-11-26  Sam Weinig  <sam@webkit.org>
  
          Convert IntersectionObserver over to using RuntimeEnabledFeatures so it can be properly excluded from script
diff --git a/Source/JavaScriptCore/Scripts/builtins/builtins_templates.py b/Source/JavaScriptCore/Scripts/builtins/builtins_templates.py

index 8728ad7..5e3ee82 100644 (file)
--- a/Source/JavaScriptCore/Scripts/builtins/builtins_templates.py
+++ b/Source/JavaScriptCore/Scripts/builtins/builtins_templates.py
@@ -85,7 +85,7 @@ ${macroPrefix}_FOREACH_${objectMacro}_BUILTIN_CODE(DECLARE_BUILTIN_GENERATOR)
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \\
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \\
  {\\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  ${macroPrefix}_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
@@ -96,7 +96,7 @@ ${macroPrefix}_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \\
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \\
  {\\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  ${macroPrefix}_FOREACH_${objectMacro}_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
@@ -108,7 +108,7 @@ ${macroPrefix}_FOREACH_${objectMacro}_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \\
  {\\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \\
-    return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \\
+    return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \\
  }
  ${macroPrefix}_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
@@ -120,7 +120,7 @@ ${macroPrefix}_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \\
  {\\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \\
-    return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \\
+    return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \\
  }
  ${macroPrefix}_FOREACH_${objectMacro}_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Combined.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Combined.js-result

index faf4499..9bb21d6 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Combined.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Combined.js-result
@@ -152,7 +152,7 @@ const char* s_builtinPromiseFulfillPromiseCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Separate.js-result

index 611aeef..87fdaee 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Separate.js-result
@@ -151,7 +151,7 @@ const char* s_builtinPromiseFulfillPromiseCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTIN.PROMISE_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Combined.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Combined.js-result

index 687688a..6bf696f 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Combined.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Combined.js-result
@@ -176,7 +176,7 @@ const char* s_builtinPrototypeForEachCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Separate.js-result

index 9dadc56..d0c8f26 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Separate.js-result
@@ -175,7 +175,7 @@ const char* s_builtinPrototypeForEachCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTIN.PROTOTYPE_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Combined.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Combined.js-result

index 67bed64..023a829 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Combined.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Combined.js-result
@@ -189,7 +189,7 @@ const char* s_builtinConstructorFromCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Separate.js-result

index 0962013..8000b69 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Separate.js-result
@@ -188,7 +188,7 @@ const char* s_builtinConstructorFromCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTINCONSTRUCTOR_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-InternalClashingNames-Combined.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-InternalClashingNames-Combined.js-result

index bf8a46c..8cbb539 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-InternalClashingNames-Combined.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-InternalClashingNames-Combined.js-result
@@ -139,7 +139,7 @@ const char* s_internalClashingNamesIsReadableStreamLockedCode =
  #define DEFINE_BUILTIN_GENERATOR(codeName, functionName, argumentCount) \
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
-    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), Nullopt, s_##codeName##Intrinsic); }
+    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), std::nullopt, s_##codeName##Intrinsic); }
  JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
  
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-AnotherGuardedInternalBuiltin-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-AnotherGuardedInternalBuiltin-Separate.js-result

index 8f84511..ad530b2 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-AnotherGuardedInternalBuiltin-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-AnotherGuardedInternalBuiltin-Separate.js-result
@@ -214,7 +214,7 @@ const char* s_anotherGuardedInternalBuiltinLetsFetchCode =
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
-    return clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  WEBCORE_FOREACH_ANOTHERGUARDEDINTERNALBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-ArbitraryConditionalGuard-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-ArbitraryConditionalGuard-Separate.js-result

index 29ce218..f91b6d9 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-ArbitraryConditionalGuard-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-ArbitraryConditionalGuard-Separate.js-result
@@ -184,7 +184,7 @@ const char* s_arbitraryConditionalGuardIsReadableStreamLockedCode =
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
-    return clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  WEBCORE_FOREACH_ARBITRARYCONDITIONALGUARD_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedBuiltin-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedBuiltin-Separate.js-result

index 7c20028..e971755 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedBuiltin-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedBuiltin-Separate.js-result
@@ -184,7 +184,7 @@ const char* s_guardedBuiltinIsReadableStreamLockedCode =
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
-    return clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  WEBCORE_FOREACH_GUARDEDBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedInternalBuiltin-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedInternalBuiltin-Separate.js-result

index 22e7a74..039ccc1 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedInternalBuiltin-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedInternalBuiltin-Separate.js-result
@@ -216,7 +216,7 @@ const char* s_guardedInternalBuiltinIsReadableStreamLockedCode =
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
-    return clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  WEBCORE_FOREACH_GUARDEDINTERNALBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-UnguardedBuiltin-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-UnguardedBuiltin-Separate.js-result

index ac10a11..f1dcace 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-UnguardedBuiltin-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-UnguardedBuiltin-Separate.js-result
@@ -178,7 +178,7 @@ const char* s_unguardedBuiltinIsReadableStreamLockedCode =
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
-    return clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  WEBCORE_FOREACH_UNGUARDEDBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-xmlCasingTest-Separate.js-result b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-xmlCasingTest-Separate.js-result

index d5be62f..d21626d 100644 (file)
--- a/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-xmlCasingTest-Separate.js-result
+++ b/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-xmlCasingTest-Separate.js-result
@@ -267,7 +267,7 @@ const char* s_xmlCasingTestUrlCasingTestCode =
  JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
  {\
      JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
-    return clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Source(), Nullopt, s_##codeName##Intrinsic); \
+    return clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
  }
  WEBCORE_FOREACH_XMLCASINGTEST_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
  #undef DEFINE_BUILTIN_GENERATOR
diff --git a/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h b/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

index 6546107..e38057b 100644 (file)
--- a/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h
+++ b/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h
@@ -3292,7 +3292,7 @@ public:
          return static_cast<RelationalCondition>(ARM64Assembler::invert(static_cast<ARM64Assembler::Condition>(cond)));
      }
  
-    static Optional<ResultCondition> commuteCompareToZeroIntoTest(RelationalCondition cond)
+    static std::optional<ResultCondition> commuteCompareToZeroIntoTest(RelationalCondition cond)
      {
          switch (cond) {
          case Equal:
@@ -3305,7 +3305,7 @@ public:
              return PositiveOrZero;
              break;
          default:
-            return Nullopt;
+            return std::nullopt;
          }
      }
  
diff --git a/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h b/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

index caf792a..daa23c3 100644 (file)
--- a/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h
+++ b/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h
@@ -2656,7 +2656,7 @@ public:
          }
      }
  
-    static Optional<ResultCondition> commuteCompareToZeroIntoTest(RelationalCondition cond)
+    static std::optional<ResultCondition> commuteCompareToZeroIntoTest(RelationalCondition cond)
      {
          switch (cond) {
          case Equal:
@@ -2669,7 +2669,7 @@ public:
              return PositiveOrZero;
              break;
          default:
-            return Nullopt;
+            return std::nullopt;
          }
      }
  
diff --git a/Source/JavaScriptCore/b3/B3CheckSpecial.cpp b/Source/JavaScriptCore/b3/B3CheckSpecial.cpp

index 8661bbd..6f7826c 100644 (file)
--- a/Source/JavaScriptCore/b3/B3CheckSpecial.cpp
+++ b/Source/JavaScriptCore/b3/B3CheckSpecial.cpp
@@ -115,7 +115,7 @@ void CheckSpecial::forEachArg(Inst& inst, const ScopedLambda<Inst::EachArgCallba
              callback(inst.args[1 + index], role, type, width);
          });
  
-    Optional<unsigned> firstRecoverableIndex;
+    std::optional<unsigned> firstRecoverableIndex;
      if (m_checkKind.opcode == BranchAdd32 || m_checkKind.opcode == BranchAdd64)
          firstRecoverableIndex = 1;
      forEachArgImpl(numB3Args(inst), m_numCheckArgs + 1, inst, m_stackmapRole, firstRecoverableIndex, callback);
@@ -135,11 +135,11 @@ bool CheckSpecial::admitsStack(Inst& inst, unsigned argIndex)
      return admitsStackImpl(numB3Args(inst), m_numCheckArgs + 1, inst, argIndex);
  }
  
-Optional<unsigned> CheckSpecial::shouldTryAliasingDef(Inst& inst)
+std::optional<unsigned> CheckSpecial::shouldTryAliasingDef(Inst& inst)
  {
-    if (Optional<unsigned> branchDef = hiddenBranch(inst).shouldTryAliasingDef())
+    if (std::optional<unsigned> branchDef = hiddenBranch(inst).shouldTryAliasingDef())
          return *branchDef + 1;
-    return Nullopt;
+    return std::nullopt;
  }
  
  CCallHelpers::Jump CheckSpecial::generate(Inst& inst, CCallHelpers& jit, GenerationContext& context)
diff --git a/Source/JavaScriptCore/b3/B3CheckSpecial.h b/Source/JavaScriptCore/b3/B3CheckSpecial.h

index aec1897..aa7f2fe 100644 (file)
--- a/Source/JavaScriptCore/b3/B3CheckSpecial.h
+++ b/Source/JavaScriptCore/b3/B3CheckSpecial.h
@@ -123,7 +123,7 @@ protected:
      void forEachArg(Air::Inst&, const ScopedLambda<Air::Inst::EachArgCallback>&) override;
      bool isValid(Air::Inst&) override;
      bool admitsStack(Air::Inst&, unsigned argIndex) override;
-    Optional<unsigned> shouldTryAliasingDef(Air::Inst&) override;
+    std::optional<unsigned> shouldTryAliasingDef(Air::Inst&) override;
  
      // NOTE: the generate method will generate the hidden branch and then register a LatePath that
      // generates the stackmap. Super crazy dude!
diff --git a/Source/JavaScriptCore/b3/B3LowerToAir.cpp b/Source/JavaScriptCore/b3/B3LowerToAir.cpp

index 9759226..490bae4 100644 (file)
--- a/Source/JavaScriptCore/b3/B3LowerToAir.cpp
+++ b/Source/JavaScriptCore/b3/B3LowerToAir.cpp
@@ -427,12 +427,12 @@ private:
          return true;
      }
      
-    Optional<unsigned> scaleForShl(Value* shl, int32_t offset, Optional<Arg::Width> width = Nullopt)
+    std::optional<unsigned> scaleForShl(Value* shl, int32_t offset, std::optional<Arg::Width> width = std::nullopt)
      {
          if (shl->opcode() != Shl)
-            return Nullopt;
+            return std::nullopt;
          if (!shl->child(1)->hasInt32())
-            return Nullopt;
+            return std::nullopt;
          unsigned logScale = shl->child(1)->asInt32();
          if (shl->type() == Int32)
              logScale &= 31;
@@ -442,10 +442,10 @@ private:
          // to signed since that's what all of our APIs want.
          int64_t bigScale = static_cast<uint64_t>(1) << static_cast<uint64_t>(logScale);
          if (!isRepresentableAs<int32_t>(bigScale))
-            return Nullopt;
+            return std::nullopt;
          unsigned scale = static_cast<int32_t>(bigScale);
          if (!Arg::isValidIndexForm(scale, offset, width))
-            return Nullopt;
+            return std::nullopt;
          return scale;
      }
  
@@ -470,7 +470,7 @@ private:
              Value* right = address->child(1);
  
              auto tryIndex = [&] (Value* index, Value* base) -> Arg {
-                Optional<unsigned> scale = scaleForShl(index, offset, width);
+                std::optional<unsigned> scale = scaleForShl(index, offset, width);
                  if (!scale)
                      return Arg();
                  if (m_locked.contains(index->child(0)) || m_locked.contains(base))
@@ -1934,7 +1934,7 @@ private:
          }
          
          auto tryShl = [&] (Value* shl, Value* other) -> bool {
-            Optional<unsigned> scale = scaleForShl(shl, offset);
+            std::optional<unsigned> scale = scaleForShl(shl, offset);
              if (!scale)
                  return false;
              if (!canBeInternal(shl))
diff --git a/Source/JavaScriptCore/b3/B3Opcode.cpp b/Source/JavaScriptCore/b3/B3Opcode.cpp

index 3c7fede..a0aa5a9 100644 (file)
--- a/Source/JavaScriptCore/b3/B3Opcode.cpp
+++ b/Source/JavaScriptCore/b3/B3Opcode.cpp
@@ -32,7 +32,7 @@
  
  namespace JSC { namespace B3 {
  
-Optional<Opcode> invertedCompare(Opcode opcode, Type type)
+std::optional<Opcode> invertedCompare(Opcode opcode, Type type)
  {
      switch (opcode) {
      case Equal:
@@ -42,19 +42,19 @@ Optional<Opcode> invertedCompare(Opcode opcode, Type type)
      case LessThan:
          if (isInt(type))
              return GreaterEqual;
-        return Nullopt;
+        return std::nullopt;
      case GreaterThan:
          if (isInt(type))
              return LessEqual;
-        return Nullopt;
+        return std::nullopt;
      case LessEqual:
          if (isInt(type))
              return GreaterThan;
-        return Nullopt;
+        return std::nullopt;
      case GreaterEqual:
          if (isInt(type))
              return LessThan;
-        return Nullopt;
+        return std::nullopt;
      case Above:
          return BelowEqual;
      case Below:
@@ -64,7 +64,7 @@ Optional<Opcode> invertedCompare(Opcode opcode, Type type)
      case BelowEqual:
          return Above;
      default:
-        return Nullopt;
+        return std::nullopt;
      }
  }
  
diff --git a/Source/JavaScriptCore/b3/B3Opcode.h b/Source/JavaScriptCore/b3/B3Opcode.h

index c68aabb..956dba9 100644 (file)
--- a/Source/JavaScriptCore/b3/B3Opcode.h
+++ b/Source/JavaScriptCore/b3/B3Opcode.h
@@ -265,7 +265,7 @@ inline bool isCheckMath(Opcode opcode)
      }
  }
  
-Optional<Opcode> invertedCompare(Opcode, Type);
+std::optional<Opcode> invertedCompare(Opcode, Type);
  
  inline Opcode constPtrOpcode()
  {
diff --git a/Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp b/Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp

index 71adac9..c5fc588 100644 (file)
--- a/Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp
+++ b/Source/JavaScriptCore/b3/B3PatchpointSpecial.cpp
@@ -59,7 +59,7 @@ void PatchpointSpecial::forEachArg(Inst& inst, const ScopedLambda<Inst::EachArgC
          callback(inst.args[argIndex++], role, inst.origin->airType(), inst.origin->airWidth());
      }
  
-    forEachArgImpl(0, argIndex, inst, SameAsRep, Nullopt, callback);
+    forEachArgImpl(0, argIndex, inst, SameAsRep, std::nullopt, callback);
      argIndex += inst.origin->numChildren();
  
      for (unsigned i = patchpoint->numGPScratchRegisters; i--;)
diff --git a/Source/JavaScriptCore/b3/B3StackmapSpecial.cpp b/Source/JavaScriptCore/b3/B3StackmapSpecial.cpp

index 8cf81d0..b5aa6c3 100644 (file)
--- a/Source/JavaScriptCore/b3/B3StackmapSpecial.cpp
+++ b/Source/JavaScriptCore/b3/B3StackmapSpecial.cpp
@@ -73,7 +73,7 @@ RegisterSet StackmapSpecial::extraEarlyClobberedRegs(Inst& inst)
  
  void StackmapSpecial::forEachArgImpl(
      unsigned numIgnoredB3Args, unsigned numIgnoredAirArgs,
-    Inst& inst, RoleMode roleMode, Optional<unsigned> firstRecoverableIndex,
+    Inst& inst, RoleMode roleMode, std::optional<unsigned> firstRecoverableIndex,
      const ScopedLambda<Inst::EachArgCallback>& callback)
  {
      StackmapValue* value = inst.origin->as<StackmapValue>();
diff --git a/Source/JavaScriptCore/b3/B3StackmapSpecial.h b/Source/JavaScriptCore/b3/B3StackmapSpecial.h

index bd6a3b5..97a0813 100644 (file)
--- a/Source/JavaScriptCore/b3/B3StackmapSpecial.h
+++ b/Source/JavaScriptCore/b3/B3StackmapSpecial.h
@@ -59,7 +59,7 @@ protected:
      // subclasses that implement that.
      void forEachArgImpl(
          unsigned numIgnoredB3Args, unsigned numIgnoredAirArgs,
-        Air::Inst&, RoleMode, Optional<unsigned> firstRecoverableIndex,
+        Air::Inst&, RoleMode, std::optional<unsigned> firstRecoverableIndex,
          const ScopedLambda<Air::Inst::EachArgCallback>&);
      
      bool isValidImpl(
diff --git a/Source/JavaScriptCore/b3/B3Value.cpp b/Source/JavaScriptCore/b3/B3Value.cpp

index 64410ac..b4fc433 100644 (file)
--- a/Source/JavaScriptCore/b3/B3Value.cpp
+++ b/Source/JavaScriptCore/b3/B3Value.cpp
@@ -457,7 +457,7 @@ Value* Value::invertedCompare(Procedure& proc) const
  {
      if (!numChildren())
          return nullptr;
-    if (Optional<Opcode> invertedOpcode = B3::invertedCompare(opcode(), child(0)->type())) {
+    if (std::optional<Opcode> invertedOpcode = B3::invertedCompare(opcode(), child(0)->type())) {
          ASSERT(!kind().hasExtraBits());
          return proc.add<Value>(*invertedOpcode, type(), origin(), children());
      }
diff --git a/Source/JavaScriptCore/b3/air/AirArg.h b/Source/JavaScriptCore/b3/air/AirArg.h

index 2e9e57d..13db1ce 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirArg.h
+++ b/Source/JavaScriptCore/b3/air/AirArg.h
@@ -545,7 +545,7 @@ public:
      }
  
      // If you don't pass a Width, this optimistically assumes that you're using the right width.
-    static bool isValidScale(unsigned scale, Optional<Width> width = Nullopt)
+    static bool isValidScale(unsigned scale, std::optional<Width> width = std::nullopt)
      {
          switch (scale) {
          case 1:
@@ -1085,7 +1085,7 @@ public:
          return false;
      }
  
-    static bool isValidAddrForm(int32_t offset, Optional<Width> width = Nullopt)
+    static bool isValidAddrForm(int32_t offset, std::optional<Width> width = std::nullopt)
      {
          if (isX86())
              return true;
@@ -1110,7 +1110,7 @@ public:
          return false;
      }
  
-    static bool isValidIndexForm(unsigned scale, int32_t offset, Optional<Width> width = Nullopt)
+    static bool isValidIndexForm(unsigned scale, int32_t offset, std::optional<Width> width = std::nullopt)
      {
          if (!isValidScale(scale, width))
              return false;
@@ -1124,7 +1124,7 @@ public:
      // If you don't pass a width then this optimistically assumes that you're using the right width. But
      // the width is relevant to validity, so passing a null width is only useful for assertions. Don't
      // pass null widths when cascading through Args in the instruction selector!
-    bool isValidForm(Optional<Width> width = Nullopt) const
+    bool isValidForm(std::optional<Width> width = std::nullopt) const
      {
          switch (kind()) {
          case Invalid:
diff --git a/Source/JavaScriptCore/b3/air/AirCustom.h b/Source/JavaScriptCore/b3/air/AirCustom.h

index b0d55cd..644b7a1 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirCustom.h
+++ b/Source/JavaScriptCore/b3/air/AirCustom.h
@@ -82,7 +82,7 @@ struct PatchCustom {
          return inst.args[0].special()->admitsStack(inst, argIndex);
      }
  
-    static Optional<unsigned> shouldTryAliasingDef(Inst& inst)
+    static std::optional<unsigned> shouldTryAliasingDef(Inst& inst)
      {
          return inst.args[0].special()->shouldTryAliasingDef(inst);
      }
diff --git a/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp b/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp

index ec89ac5..d000d6c 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp
+++ b/Source/JavaScriptCore/b3/air/AirFixObviousSpills.cpp
@@ -129,12 +129,12 @@ private:
                  else if (isSpillSlot(inst.args[1]))
                      m_state.addAlias(SlotConst(inst.args[1].stackSlot(), inst.args[0].value()));
              } else if (isSpillSlot(inst.args[0]) && inst.args[1].isReg()) {
-                if (Optional<int64_t> constant = m_state.constantFor(inst.args[0]))
+                if (std::optional<int64_t> constant = m_state.constantFor(inst.args[0]))
                      m_state.addAlias(RegConst(inst.args[1].reg(), *constant));
                  m_state.addAlias(
                      RegSlot(inst.args[1].reg(), inst.args[0].stackSlot(), RegSlot::AllBits));
              } else if (inst.args[0].isReg() && isSpillSlot(inst.args[1])) {
-                if (Optional<int64_t> constant = m_state.constantFor(inst.args[0]))
+                if (std::optional<int64_t> constant = m_state.constantFor(inst.args[0]))
                      m_state.addAlias(SlotConst(inst.args[1].stackSlot(), *constant));
                  m_state.addAlias(
                      RegSlot(inst.args[0].reg(), inst.args[1].stackSlot(), RegSlot::AllBits));
@@ -148,12 +148,12 @@ private:
                  else if (isSpillSlot(inst.args[1]))
                      m_state.addAlias(SlotConst(inst.args[1].stackSlot(), static_cast<uint32_t>(inst.args[0].value())));
              } else if (isSpillSlot(inst.args[0]) && inst.args[1].isReg()) {
-                if (Optional<int64_t> constant = m_state.constantFor(inst.args[0]))
+                if (std::optional<int64_t> constant = m_state.constantFor(inst.args[0]))
                      m_state.addAlias(RegConst(inst.args[1].reg(), static_cast<uint32_t>(*constant)));
                  m_state.addAlias(
                      RegSlot(inst.args[1].reg(), inst.args[0].stackSlot(), RegSlot::ZExt32));
              } else if (inst.args[0].isReg() && isSpillSlot(inst.args[1])) {
-                if (Optional<int64_t> constant = m_state.constantFor(inst.args[0]))
+                if (std::optional<int64_t> constant = m_state.constantFor(inst.args[0]))
                      m_state.addAlias(SlotConst(inst.args[1].stackSlot(), static_cast<int32_t>(*constant)));
                  m_state.addAlias(
                      RegSlot(inst.args[0].reg(), inst.args[1].stackSlot(), RegSlot::Match32));
@@ -454,19 +454,19 @@ private:
              return nullptr;
          }
  
-        Optional<int64_t> constantFor(const Arg& arg)
+        std::optional<int64_t> constantFor(const Arg& arg)
          {
              if (arg.isReg()) {
                  if (const RegConst* alias = getRegConst(arg.reg()))
                      return alias->constant;
-                return Nullopt;
+                return std::nullopt;
              }
              if (arg.isStack()) {
                  if (const SlotConst* alias = getSlotConst(arg.stackSlot()))
                      return alias->constant;
-                return Nullopt;
+                return std::nullopt;
              }
-            return Nullopt;
+            return std::nullopt;
          }
  
          void clobber(const Arg& arg)
diff --git a/Source/JavaScriptCore/b3/air/AirInst.h b/Source/JavaScriptCore/b3/air/AirInst.h

index 30f24d8..f38c21d 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirInst.h
+++ b/Source/JavaScriptCore/b3/air/AirInst.h
@@ -190,7 +190,7 @@ public:
      // For example,
      //     Add Tmp1, Tmp2, Tmp3
      // returns 2 if 0 and 1 benefit from aliasing to Tmp3.
-    Optional<unsigned> shouldTryAliasingDef();
+    std::optional<unsigned> shouldTryAliasingDef();
      
      // This computes a hash for comparing this to JSAir's Inst.
      unsigned jsHash() const;
diff --git a/Source/JavaScriptCore/b3/air/AirInstInlines.h b/Source/JavaScriptCore/b3/air/AirInstInlines.h

index 1aaa06c..b753921 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirInstInlines.h
+++ b/Source/JavaScriptCore/b3/air/AirInstInlines.h
@@ -111,10 +111,10 @@ inline bool Inst::admitsStack(Arg& arg)
      return admitsStack(&arg - &args[0]);
  }
  
-inline Optional<unsigned> Inst::shouldTryAliasingDef()
+inline std::optional<unsigned> Inst::shouldTryAliasingDef()
  {
      if (!isX86())
-        return Nullopt;
+        return std::nullopt;
  
      switch (kind.opcode) {
      case Add32:
@@ -140,7 +140,7 @@ inline Optional<unsigned> Inst::shouldTryAliasingDef()
      case MulFloat:
  #if CPU(X86) || CPU(X86_64)
          if (MacroAssembler::supportsAVX())
-            return Nullopt;
+            return std::nullopt;
  #endif
          if (args.size() == 3)
              return 2;
@@ -171,7 +171,7 @@ inline Optional<unsigned> Inst::shouldTryAliasingDef()
      default:
          break;
      }
-    return Nullopt;
+    return std::nullopt;
  }
  
  inline bool isShiftValid(const Inst& inst)
diff --git a/Source/JavaScriptCore/b3/air/AirIteratedRegisterCoalescing.cpp b/Source/JavaScriptCore/b3/air/AirIteratedRegisterCoalescing.cpp

index 94d6291..bd1a5c7 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirIteratedRegisterCoalescing.cpp
+++ b/Source/JavaScriptCore/b3/air/AirIteratedRegisterCoalescing.cpp
@@ -1007,7 +1007,7 @@ private:
          m_worklistMoves.startAddingLowPriorityMoves();
          for (BasicBlock* block : m_code) {
              for (Inst& inst : *block) {
-                if (Optional<unsigned> defArgIndex = inst.shouldTryAliasingDef()) {
+                if (std::optional<unsigned> defArgIndex = inst.shouldTryAliasingDef()) {
                      Arg op1 = inst.args[*defArgIndex - 2];
                      Arg op2 = inst.args[*defArgIndex - 1];
                      Arg dest = inst.args[*defArgIndex];
diff --git a/Source/JavaScriptCore/b3/air/AirSpecial.cpp b/Source/JavaScriptCore/b3/air/AirSpecial.cpp

index 0a722e8..e825767 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirSpecial.cpp
+++ b/Source/JavaScriptCore/b3/air/AirSpecial.cpp
@@ -50,9 +50,9 @@ CString Special::name() const
      return out.toCString();
  }
  
-Optional<unsigned> Special::shouldTryAliasingDef(Inst&)
+std::optional<unsigned> Special::shouldTryAliasingDef(Inst&)
  {
-    return Nullopt;
+    return std::nullopt;
  }
  
  bool Special::isTerminal(Inst&)
diff --git a/Source/JavaScriptCore/b3/air/AirSpecial.h b/Source/JavaScriptCore/b3/air/AirSpecial.h

index 6c10cb5..480cbfc 100644 (file)
--- a/Source/JavaScriptCore/b3/air/AirSpecial.h
+++ b/Source/JavaScriptCore/b3/air/AirSpecial.h
@@ -55,7 +55,7 @@ public:
      virtual void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) = 0;
      virtual bool isValid(Inst&) = 0;
      virtual bool admitsStack(Inst&, unsigned argIndex) = 0;
-    virtual Optional<unsigned> shouldTryAliasingDef(Inst&);
+    virtual std::optional<unsigned> shouldTryAliasingDef(Inst&);
  
      // This gets called on for each Inst that uses this Special. Note that there is no way to
      // guarantee that a Special gets used from just one Inst, because Air might taildup late. So,
diff --git a/Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp b/Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp

index 95903e2..f7e1e9a 100644 (file)
--- a/Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp
+++ b/Source/JavaScriptCore/bytecode/BytecodeGeneratorification.cpp
@@ -117,7 +117,7 @@ private:
  
          if (m_storages.size() <= index)
              m_storages.resize(index + 1);
-        if (Optional<Storage> storage = m_storages[index])
+        if (std::optional<Storage> storage = m_storages[index])
              return *storage;
  
          UnlinkedCodeBlock* codeBlock = m_graph.codeBlock();
@@ -138,7 +138,7 @@ private:
  
      unsigned m_enterPoint { 0 };
      BytecodeGraph<UnlinkedCodeBlock> m_graph;
-    Vector<Optional<Storage>> m_storages;
+    Vector<std::optional<Storage>> m_storages;
      Yields m_yields;
      Strong<SymbolTable> m_generatorFrameSymbolTable;
      int m_generatorFrameSymbolTableIndex;
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp

index 249d113..a12bc0a 100644 (file)
--- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp
+++ b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
@@ -4512,29 +4512,29 @@ void CodeBlock::setPCToCodeOriginMap(std::unique_ptr<PCToCodeOriginMap>&& map)
      m_pcToCodeOriginMap = WTFMove(map);
  }
  
-Optional<CodeOrigin> CodeBlock::findPC(void* pc)
+std::optional<CodeOrigin> CodeBlock::findPC(void* pc)
  {
      if (m_pcToCodeOriginMap) {
-        if (Optional<CodeOrigin> codeOrigin = m_pcToCodeOriginMap->findPC(pc))
+        if (std::optional<CodeOrigin> codeOrigin = m_pcToCodeOriginMap->findPC(pc))
              return codeOrigin;
      }
  
      for (Bag<StructureStubInfo>::iterator iter = m_stubInfos.begin(); !!iter; ++iter) {
          StructureStubInfo* stub = *iter;
          if (stub->containsPC(pc))
-            return Optional<CodeOrigin>(stub->codeOrigin);
+            return std::optional<CodeOrigin>(stub->codeOrigin);
      }
  
-    if (Optional<CodeOrigin> codeOrigin = m_jitCode->findPC(this, pc))
+    if (std::optional<CodeOrigin> codeOrigin = m_jitCode->findPC(this, pc))
          return codeOrigin;
  
-    return Nullopt;
+    return std::nullopt;
  }
  #endif // ENABLE(JIT)
  
-Optional<unsigned> CodeBlock::bytecodeOffsetFromCallSiteIndex(CallSiteIndex callSiteIndex)
+std::optional<unsigned> CodeBlock::bytecodeOffsetFromCallSiteIndex(CallSiteIndex callSiteIndex)
  {
-    Optional<unsigned> bytecodeOffset;
+    std::optional<unsigned> bytecodeOffset;
      JITCode::JITType jitType = this->jitType();
      if (jitType == JITCode::InterpreterThunk || jitType == JITCode::BaselineJIT) {
  #if USE(JSVALUE64)
diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.h b/Source/JavaScriptCore/bytecode/CodeBlock.h

index 6bb91db..aafea19 100644 (file)
--- a/Source/JavaScriptCore/bytecode/CodeBlock.h
+++ b/Source/JavaScriptCore/bytecode/CodeBlock.h
@@ -233,7 +233,7 @@ public:
      void expressionRangeForBytecodeOffset(unsigned bytecodeOffset, int& divot,
          int& startOffset, int& endOffset, unsigned& line, unsigned& column) const;
  
-    Optional<unsigned> bytecodeOffsetFromCallSiteIndex(CallSiteIndex);
+    std::optional<unsigned> bytecodeOffsetFromCallSiteIndex(CallSiteIndex);
  
      void getStubInfoMap(const ConcurrentJSLocker&, StubInfoMap& result);
      void getStubInfoMap(StubInfoMap& result);
@@ -889,7 +889,7 @@ public:
  
  #if ENABLE(JIT)
      void setPCToCodeOriginMap(std::unique_ptr<PCToCodeOriginMap>&&);
-    Optional<CodeOrigin> findPC(void* pc);
+    std::optional<CodeOrigin> findPC(void* pc);
  #endif
  
  protected:
diff --git a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp

index e3af61f..952e98b 100644 (file)
--- a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
+++ b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
@@ -131,7 +131,7 @@ void UnlinkedFunctionExecutable::visitChildren(JSCell* cell, SlotVisitor& visito
      visitor.append(&thisObject->m_unlinkedCodeBlockForConstruct);
  }
  
-FunctionExecutable* UnlinkedFunctionExecutable::link(VM& vm, const SourceCode& ownerSource, Optional<int> overrideLineNumber, Intrinsic intrinsic)
+FunctionExecutable* UnlinkedFunctionExecutable::link(VM& vm, const SourceCode& ownerSource, std::optional<int> overrideLineNumber, Intrinsic intrinsic)
  {
      SourceCode source = m_sourceOverride ? SourceCode(m_sourceOverride) : ownerSource;
      unsigned firstLine = source.firstLine() + m_firstLineOffset;
diff --git a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h

index 6f558cf..bf3c528 100644 (file)
--- a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
+++ b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
@@ -106,7 +106,7 @@ public:
          const Identifier&, ExecState&, const SourceCode&, JSObject*& exception, 
          int overrideLineNumber);
  
-    JS_EXPORT_PRIVATE FunctionExecutable* link(VM&, const SourceCode&, Optional<int> overrideLineNumber = Nullopt, Intrinsic = NoIntrinsic);
+    JS_EXPORT_PRIVATE FunctionExecutable* link(VM&, const SourceCode&, std::optional<int> overrideLineNumber = std::nullopt, Intrinsic = NoIntrinsic);
  
      void clearCode()
      {
diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

index 046d2a7..bf1320f 100644 (file)
--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
@@ -910,7 +910,7 @@ namespace JSC {
          };
          typedef HashMap<RefPtr<UniquedStringImpl>, TDZNecessityLevel, IdentifierRepHash> TDZMap;
          Vector<TDZMap> m_TDZStack;
-        Optional<size_t> m_varScopeSymbolTableIndex;
+        std::optional<size_t> m_varScopeSymbolTableIndex;
          void pushTDZVariables(const VariableEnvironment&, TDZCheckOptimization, TDZRequirement);
  
          ScopeNode* const m_scopeNode;
diff --git a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

index edb65d7..68aeb5a 100644 (file)
--- a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
+++ b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
@@ -620,7 +620,7 @@ void PropertyListNode::emitPutConstantProperty(BytecodeGenerator& generator, Reg
          return;
      }
      if (const auto* identifier = node.name()) {
-        Optional<uint32_t> optionalIndex = parseIndex(*identifier);
+        std::optional<uint32_t> optionalIndex = parseIndex(*identifier);
          if (!optionalIndex) {
              generator.emitDirectPutById(newObj, *identifier, value.get(), node.putType());
              return;
@@ -3967,7 +3967,7 @@ void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs)
          RefPtr<RegisterID> temp = generator.newTemporary();
          if (!target.propertyExpression) {
              // Should not emit get_by_id for indexed ones.
-            Optional<uint32_t> optionalIndex = parseIndex(target.propertyName);
+            std::optional<uint32_t> optionalIndex = parseIndex(target.propertyName);
              if (!optionalIndex)
                  generator.emitGetById(temp.get(), rhs, target.propertyName);
              else {
diff --git a/Source/JavaScriptCore/debugger/Debugger.cpp b/Source/JavaScriptCore/debugger/Debugger.cpp

index 98acd32..de23e13 100644 (file)
--- a/Source/JavaScriptCore/debugger/Debugger.cpp
+++ b/Source/JavaScriptCore/debugger/Debugger.cpp
@@ -360,7 +360,7 @@ void Debugger::resolveBreakpoint(Breakpoint& breakpoint, SourceProvider* sourceP
      unsigned column = breakpoint.column ? breakpoint.column : Breakpoint::unspecifiedColumn;
  
      DebuggerParseData& parseData = debuggerParseData(breakpoint.sourceID, sourceProvider);
-    Optional<JSTextPosition> resolvedPosition = parseData.pausePositions.breakpointLocationForLineColumn((int)line, (int)column);
+    std::optional<JSTextPosition> resolvedPosition = parseData.pausePositions.breakpointLocationForLineColumn((int)line, (int)column);
      if (!resolvedPosition)
          return;
  
diff --git a/Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp b/Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp

index 16ac1ad..7f82127 100644 (file)
--- a/Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp
+++ b/Source/JavaScriptCore/debugger/DebuggerCallFrame.cpp
@@ -290,7 +290,7 @@ TextPosition DebuggerCallFrame::currentPosition()
  
      if (isTailDeleted()) {
          CodeBlock* codeBlock = m_shadowChickenFrame.codeBlock;
-        if (Optional<unsigned> bytecodeOffset = codeBlock->bytecodeOffsetFromCallSiteIndex(m_shadowChickenFrame.callSiteIndex)) {
+        if (std::optional<unsigned> bytecodeOffset = codeBlock->bytecodeOffsetFromCallSiteIndex(m_shadowChickenFrame.callSiteIndex)) {
              return TextPosition(OrdinalNumber::fromOneBasedInt(codeBlock->lineNumberForBytecodeOffset(*bytecodeOffset)),
                  OrdinalNumber::fromOneBasedInt(codeBlock->columnNumberForBytecodeOffset(*bytecodeOffset)));
          }
diff --git a/Source/JavaScriptCore/debugger/DebuggerParseData.cpp b/Source/JavaScriptCore/debugger/DebuggerParseData.cpp

index e71aac6..3b058ba 100644 (file)
--- a/Source/JavaScriptCore/debugger/DebuggerParseData.cpp
+++ b/Source/JavaScriptCore/debugger/DebuggerParseData.cpp
@@ -30,7 +30,7 @@
  
  namespace JSC {
  
-Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn(int line, int column)
+std::optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn(int line, int column)
  {
      unsigned start = 0;
      unsigned end = m_positions.size();
@@ -54,7 +54,7 @@ Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn
              // We are guarenteed to have a Leave for an Entry so we don't need to bounds check.
              while (true) {
                  if (pausePosition.type != DebuggerPausePositionType::Enter)
-                    return Optional<JSTextPosition>(pausePosition.position);
+                    return std::optional<JSTextPosition>(pausePosition.position);
                  pausePosition = m_positions[middle++];
              }
          }
@@ -67,7 +67,7 @@ Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn
  
      // Past the end, no possible pause locations.
      if (start >= m_positions.size())
-        return Nullopt;
+        return std::nullopt;
  
      // If the next location is a function Entry we will need to decide if we should go into
      // the function or go past the function. We decide to go into the function if the
@@ -87,7 +87,7 @@ Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn
      // Valid pause location. Use it.
      DebuggerPausePosition& firstSlidePosition = m_positions[start];
      if (firstSlidePosition.type != DebuggerPausePositionType::Enter)
-        return Optional<JSTextPosition>(firstSlidePosition.position);
+        return std::optional<JSTextPosition>(firstSlidePosition.position);
  
      // Determine if we should enter this function or skip past it.
      // If entryStackSize is > 0 we are skipping functions.
@@ -113,11 +113,11 @@ Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn
          }
  
          // Found pause position.
-        return Optional<JSTextPosition>(slidePosition.position);
+        return std::optional<JSTextPosition>(slidePosition.position);
      }
  
      // No pause positions found.
-    return Nullopt;
+    return std::nullopt;
  }
  
  void DebuggerPausePositions::sort()
diff --git a/Source/JavaScriptCore/debugger/DebuggerParseData.h b/Source/JavaScriptCore/debugger/DebuggerParseData.h

index 0622515..ecc78d0 100644 (file)
--- a/Source/JavaScriptCore/debugger/DebuggerParseData.h
+++ b/Source/JavaScriptCore/debugger/DebuggerParseData.h
@@ -60,7 +60,7 @@ public:
          m_positions.append({ DebuggerPausePositionType::Leave, position });
      }
  
-    Optional<JSTextPosition> breakpointLocationForLineColumn(int line, int column);
+    std::optional<JSTextPosition> breakpointLocationForLineColumn(int line, int column);
  
      void sort();
  
diff --git a/Source/JavaScriptCore/debugger/ScriptProfilingScope.h b/Source/JavaScriptCore/debugger/ScriptProfilingScope.h

index 99624db..e40337f 100644 (file)
--- a/Source/JavaScriptCore/debugger/ScriptProfilingScope.h
+++ b/Source/JavaScriptCore/debugger/ScriptProfilingScope.h
@@ -83,7 +83,7 @@ private:
      }
  
      JSGlobalObject* m_globalObject { nullptr };
-    Optional<double> m_startTime;
+    std::optional<double> m_startTime;
      ProfilingReason m_reason;
  };
  
diff --git a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h

index 5df4da3..d4be12a 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
+++ b/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
@@ -435,7 +435,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
          
      case DoubleRep: {
          JSValue child = forNode(node->child1()).value();
-        if (Optional<double> number = child.toNumberFromPrimitive()) {
+        if (std::optional<double> number = child.toNumberFromPrimitive()) {
              setConstant(node, jsDoubleNumber(*number));
              break;
          }
@@ -549,7 +549,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
  
      case ArithClz32: {
          JSValue operand = forNode(node->child1()).value();
-        if (Optional<double> number = operand.toNumberFromPrimitive()) {
+        if (std::optional<double> number = operand.toNumberFromPrimitive()) {
              uint32_t value = toUInt32(*number);
              setConstant(node, jsNumber(clz32(value)));
              break;
@@ -855,7 +855,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
          JSValue child = forNode(node->child1()).value();
          switch (node->child1().useKind()) {
          case Int32Use:
-            if (Optional<double> number = child.toNumberFromPrimitive()) {
+            if (std::optional<double> number = child.toNumberFromPrimitive()) {
                  JSValue result = jsNumber(fabs(*number));
                  if (result.isInt32()) {
                      setConstant(node, result);
@@ -865,7 +865,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
              forNode(node).setType(SpecInt32Only);
              break;
          case DoubleRepUse:
-            if (Optional<double> number = child.toNumberFromPrimitive()) {
+            if (std::optional<double> number = child.toNumberFromPrimitive()) {
                  setConstant(node, jsDoubleNumber(fabs(*number)));
                  break;
              }
@@ -907,7 +907,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
      case ArithCeil:
      case ArithTrunc: {
          JSValue operand = forNode(node->child1()).value();
-        if (Optional<double> number = operand.toNumberFromPrimitive()) {
+        if (std::optional<double> number = operand.toNumberFromPrimitive()) {
              double roundedValue = 0;
              if (node->op() == ArithRound)
                  roundedValue = jsRound(*number);
@@ -995,7 +995,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
  
      case MapHash: {
          if (JSValue key = forNode(node->child1()).value()) {
-            if (Optional<uint32_t> hash = concurrentJSMapHash(key)) {
+            if (std::optional<uint32_t> hash = concurrentJSMapHash(key)) {
                  // Although C++ code uses uint32_t for the hash, the closest type in DFG IR is Int32
                  // and that's what MapHash returns. So, we have to cast to int32_t to avoid large
                  // unsigned values becoming doubles. This casting between signed and unsigned
@@ -3165,7 +3165,7 @@ template<typename AbstractStateType>
  void AbstractInterpreter<AbstractStateType>::executeDoubleUnaryOpEffects(Node* node, double(*equivalentFunction)(double))
  {
      JSValue child = forNode(node->child1()).value();
-    if (Optional<double> number = child.toNumberFromPrimitive()) {
+    if (std::optional<double> number = child.toNumberFromPrimitive()) {
          setConstant(node, jsDoubleNumber(equivalentFunction(*number)));
          return;
      }
diff --git a/Source/JavaScriptCore/dfg/DFGJITCode.cpp b/Source/JavaScriptCore/dfg/DFGJITCode.cpp

index e9ac3e5..7fb9f71 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGJITCode.cpp
+++ b/Source/JavaScriptCore/dfg/DFGJITCode.cpp
@@ -215,16 +215,16 @@ void JITCode::validateReferences(const TrackedReferences& trackedReferences)
      minifiedDFG.validateReferences(trackedReferences);
  }
  
-Optional<CodeOrigin> JITCode::findPC(CodeBlock*, void* pc)
+std::optional<CodeOrigin> JITCode::findPC(CodeBlock*, void* pc)
  {
      for (OSRExit& exit : osrExit) {
          if (ExecutableMemoryHandle* handle = exit.m_code.executableMemory()) {
              if (handle->start() <= pc && pc < handle->end())
-                return Optional<CodeOrigin>(exit.m_codeOriginForExitProfile);
+                return std::optional<CodeOrigin>(exit.m_codeOriginForExitProfile);
          }
      }
  
-    return Nullopt;
+    return std::nullopt;
  }
  
  } } // namespace JSC::DFG
diff --git a/Source/JavaScriptCore/dfg/DFGJITCode.h b/Source/JavaScriptCore/dfg/DFGJITCode.h

index e1f1d7c..aee8742 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGJITCode.h
+++ b/Source/JavaScriptCore/dfg/DFGJITCode.h
@@ -124,7 +124,7 @@ public:
  
      static ptrdiff_t commonDataOffset() { return OBJECT_OFFSETOF(JITCode, common); }
  
-    Optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;
+    std::optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;
      
  private:
      friend class JITCompiler; // Allow JITCompiler to call setCodeRef().
diff --git a/Source/JavaScriptCore/dfg/DFGOperations.cpp b/Source/JavaScriptCore/dfg/DFGOperations.cpp

index 529869e..1026a84 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGOperations.cpp
+++ b/Source/JavaScriptCore/dfg/DFGOperations.cpp
@@ -132,7 +132,7 @@ ALWAYS_INLINE static void JIT_OPERATION operationPutByValInternal(ExecState* exe
      PutPropertySlot slot(baseValue, strict);
      if (direct) {
          RELEASE_ASSERT(baseValue.isObject());
-        if (Optional<uint32_t> index = parseIndex(propertyName)) {
+        if (std::optional<uint32_t> index = parseIndex(propertyName)) {
              scope.release();
              asObject(baseValue)->putDirectIndex(exec, index.value(), value, 0, strict ? PutDirectIndexShouldThrow : PutDirectIndexShouldNotThrow);
              return;
@@ -1174,7 +1174,7 @@ char* JIT_OPERATION operationNewInt8ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSInt8Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSInt8Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewInt16ArrayWithSize(
@@ -1188,7 +1188,7 @@ char* JIT_OPERATION operationNewInt16ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSInt16Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSInt16Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewInt32ArrayWithSize(
@@ -1202,7 +1202,7 @@ char* JIT_OPERATION operationNewInt32ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSInt32Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSInt32Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewUint8ArrayWithSize(
@@ -1216,7 +1216,7 @@ char* JIT_OPERATION operationNewUint8ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint8Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint8Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewUint8ClampedArrayWithSize(
@@ -1230,7 +1230,7 @@ char* JIT_OPERATION operationNewUint8ClampedArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint8ClampedArray>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint8ClampedArray>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewUint16ArrayWithSize(
@@ -1244,7 +1244,7 @@ char* JIT_OPERATION operationNewUint16ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint16Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint16Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewUint32ArrayWithSize(
@@ -1258,7 +1258,7 @@ char* JIT_OPERATION operationNewUint32ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint32Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSUint32Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewFloat32ArrayWithSize(
@@ -1272,7 +1272,7 @@ char* JIT_OPERATION operationNewFloat32ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSFloat32Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSFloat32Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  char* JIT_OPERATION operationNewFloat64ArrayWithSize(
@@ -1286,7 +1286,7 @@ char* JIT_OPERATION operationNewFloat64ArrayWithOneArgument(
  {
      VM& vm = exec->vm();
      NativeCallFrameTracer tracer(&vm, exec);
-    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSFloat64Array>(exec, structure, encodedValue, 0, Nullopt));
+    return reinterpret_cast<char*>(constructGenericTypedArrayViewWithArguments<JSFloat64Array>(exec, structure, encodedValue, 0, std::nullopt));
  }
  
  JSCell* JIT_OPERATION operationCreateActivationDirect(ExecState* exec, Structure* structure, JSScope* scope, SymbolTable* table, EncodedJSValue initialValueEncoded)
diff --git a/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h b/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h

index 6081c57..67aba80 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h
+++ b/Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h
@@ -51,7 +51,7 @@ public:
          jit->m_outOfLineStreamIndex = m_streamIndex;
          jit->m_origin = m_origin;
          generateInternal(jit);
-        jit->m_outOfLineStreamIndex = Nullopt;
+        jit->m_outOfLineStreamIndex = std::nullopt;
          if (!ASSERT_DISABLED)
              jit->m_jit.abortWithReason(DFGSlowPathGeneratorFellThrough);
      }
diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

index 6ce045b..2b1efa1 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
@@ -399,7 +399,7 @@ void SpeculativeJIT::runSlowPathGenerators(PCToCodeOriginMapBuilder& pcToCodeOri
          m_outOfLineStreamIndex = slowPathLambda.streamIndex;
          pcToCodeOriginMapBuilder.appendItem(m_jit.labelIgnoringWatchpoints(), currentNode->origin.semantic);
          slowPathLambda.generator();
-        m_outOfLineStreamIndex = Nullopt;
+        m_outOfLineStreamIndex = std::nullopt;
      }
  }
  
@@ -3188,8 +3188,8 @@ void SpeculativeJIT::emitUntypedBitOp(Node* node)
          return;
      }
  
-    Optional<JSValueOperand> left;
-    Optional<JSValueOperand> right;
+    std::optional<JSValueOperand> left;
+    std::optional<JSValueOperand> right;
  
      JSValueRegs leftRegs;
      JSValueRegs rightRegs;
@@ -3219,11 +3219,11 @@ void SpeculativeJIT::emitUntypedBitOp(Node* node)
      RELEASE_ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
  
      if (!leftOperand.isConst()) {
-        left = JSValueOperand(this, leftChild);
+        left.emplace(this, leftChild);
          leftRegs = left->jsValueRegs();
      }
      if (!rightOperand.isConst()) {
-        right = JSValueOperand(this, rightChild);
+        right.emplace(this, rightChild);
          rightRegs = right->jsValueRegs();
      }
  
@@ -3335,8 +3335,8 @@ void SpeculativeJIT::emitUntypedRightShiftBitOp(Node* node)
          return;
      }
  
-    Optional<JSValueOperand> left;
-    Optional<JSValueOperand> right;
+    std::optional<JSValueOperand> left;
+    std::optional<JSValueOperand> right;
  
      JSValueRegs leftRegs;
      JSValueRegs rightRegs;
@@ -3372,11 +3372,11 @@ void SpeculativeJIT::emitUntypedRightShiftBitOp(Node* node)
      RELEASE_ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
  
      if (!leftOperand.isConst()) {
-        left = JSValueOperand(this, leftChild);
+        left.emplace(this, leftChild);
          leftRegs = left->jsValueRegs();
      }
      if (!rightOperand.isConst()) {
-        right = JSValueOperand(this, rightChild);
+        right.emplace(this, rightChild);
          rightRegs = right->jsValueRegs();
      }
  
@@ -3497,8 +3497,8 @@ void SpeculativeJIT::compileMathIC(Node* node, JITBinaryMathIC<Generator>* mathI
      Edge& leftChild = node->child1();
      Edge& rightChild = node->child2();
  
-    Optional<JSValueOperand> left;
-    Optional<JSValueOperand> right;
+    std::optional<JSValueOperand> left;
+    std::optional<JSValueOperand> right;
  
      JSValueRegs leftRegs;
      JSValueRegs rightRegs;
@@ -3511,16 +3511,16 @@ void SpeculativeJIT::compileMathIC(Node* node, JITBinaryMathIC<Generator>* mathI
      GPRReg scratchGPR = InvalidGPRReg;
      FPRReg scratchFPR = InvalidFPRReg;
  
-    Optional<FPRTemporary> fprScratch;
+    std::optional<FPRTemporary> fprScratch;
      if (needsScratchFPRReg) {
-        fprScratch = FPRTemporary(this);
+        fprScratch.emplace(this);
          scratchFPR = fprScratch->fpr();
      }
  
  #if USE(JSVALUE64)
-    Optional<GPRTemporary> gprScratch;
+    std::optional<GPRTemporary> gprScratch;
      if (needsScratchGPRReg) {
-        gprScratch = GPRTemporary(this);
+        gprScratch.emplace(this);
          scratchGPR = gprScratch->gpr();
      }
      GPRTemporary result(this);
@@ -3547,11 +3547,11 @@ void SpeculativeJIT::compileMathIC(Node* node, JITBinaryMathIC<Generator>* mathI
      ASSERT(!(Generator::isLeftOperandValidConstant(leftOperand) && Generator::isRightOperandValidConstant(rightOperand)));
  
      if (!Generator::isLeftOperandValidConstant(leftOperand)) {
-        left = JSValueOperand(this, leftChild);
+        left.emplace(this, leftChild);
          leftRegs = left->jsValueRegs();
      }
      if (!Generator::isRightOperandValidConstant(rightOperand)) {
-        right = JSValueOperand(this, rightChild);
+        right.emplace(this, rightChild);
          rightRegs = right->jsValueRegs();
      }
  
@@ -3616,10 +3616,10 @@ void SpeculativeJIT::compileMathIC(Node* node, JITBinaryMathIC<Generator>* mathI
          });
      } else {
          if (Generator::isLeftOperandValidConstant(leftOperand)) {
-            left = JSValueOperand(this, leftChild);
+            left.emplace(this, leftChild);
              leftRegs = left->jsValueRegs();
          } else if (Generator::isRightOperandValidConstant(rightOperand)) {
-            right = JSValueOperand(this, rightChild);
+            right.emplace(this, rightChild);
              rightRegs = right->jsValueRegs();
          }
  
@@ -4258,9 +4258,9 @@ template <typename Generator, typename RepatchingFunction, typename NonRepatchin
  void SpeculativeJIT::compileMathIC(Node* node, JITUnaryMathIC<Generator>* mathIC, bool needsScratchGPRReg, RepatchingFunction repatchingFunction, NonRepatchingFunction nonRepatchingFunction)
  {
      GPRReg scratchGPR = InvalidGPRReg;
-    Optional<GPRTemporary> gprScratch;
+    std::optional<GPRTemporary> gprScratch;
      if (needsScratchGPRReg) {
-        gprScratch = GPRTemporary(this);
+        gprScratch.emplace(this);
          scratchGPR = gprScratch->gpr();
      }
      JSValueOperand childOperand(this, node->child1());
@@ -4687,8 +4687,8 @@ void SpeculativeJIT::compileArithDiv(Node* node)
              return;
          }
  
-        Optional<JSValueOperand> left;
-        Optional<JSValueOperand> right;
+        std::optional<JSValueOperand> left;
+        std::optional<JSValueOperand> right;
  
          JSValueRegs leftRegs;
          JSValueRegs rightRegs;
@@ -4735,11 +4735,11 @@ void SpeculativeJIT::compileArithDiv(Node* node)
          RELEASE_ASSERT(!leftOperand.isConst() || !rightOperand.isConst());
  
          if (!leftOperand.isConst()) {
-            left = JSValueOperand(this, leftChild);
+            left.emplace(this, leftChild);
              leftRegs = left->jsValueRegs();
          }
          if (!rightOperand.isConst()) {
-            right = JSValueOperand(this, rightChild);
+            right.emplace(this, rightChild);
              rightRegs = right->jsValueRegs();
          }
  
@@ -7612,10 +7612,10 @@ void SpeculativeJIT::compileCallDOMGetter(Node* node)
      SpeculateCellOperand base(this, baseEdge);
      regs.append(DOMJIT::Value(base.gpr(), m_state.forNode(baseEdge).value()));
  
-    Optional<SpeculateCellOperand> globalObject;
+    std::optional<SpeculateCellOperand> globalObject;
      if (patchpoint->requireGlobalObject) {
          Edge& globalObjectEdge = node->child2();
-        globalObject = SpeculateCellOperand(this, globalObjectEdge);
+        globalObject.emplace(this, globalObjectEdge);
          regs.append(DOMJIT::Value(globalObject->gpr(), m_state.forNode(globalObjectEdge).value()));
      }
  
diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h

index c8c9ef3..519df65 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
@@ -2928,7 +2928,7 @@ public:
      };
      Vector<SlowPathLambda> m_slowPathLambdas;
      Vector<SilentRegisterSavePlan> m_plans;
-    Optional<unsigned> m_outOfLineStreamIndex;
+    std::optional<unsigned> m_outOfLineStreamIndex;
  };
  
  
diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

index 657442f..8d1bc0b 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
@@ -5050,15 +5050,15 @@ void SpeculativeJIT::compile(Node* node)
          GPRTemporary structureID(this);
          GPRTemporary result(this);
  
-        Optional<SpeculateCellOperand> keyAsCell;
-        Optional<JSValueOperand> keyAsValue;
+        std::optional<SpeculateCellOperand> keyAsCell;
+        std::optional<JSValueOperand> keyAsValue;
          JSValueRegs keyRegs;
          if (node->child2().useKind() == UntypedUse) {
-            keyAsValue = JSValueOperand(this, node->child2());
+            keyAsValue.emplace(this, node->child2());
              keyRegs = keyAsValue->jsValueRegs();
          } else {
              ASSERT(node->child2().useKind() == StringUse || node->child2().useKind() == SymbolUse);
-            keyAsCell = SpeculateCellOperand(this, node->child2());
+            keyAsCell.emplace(this, node->child2());
              keyRegs = JSValueRegs::payloadOnly(keyAsCell->gpr());
          }
  
diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

index 5804688..e538fbb 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
@@ -1949,10 +1949,10 @@ void SpeculativeJIT::compileLogicalNot(Node* node)
  
          bool shouldCheckMasqueradesAsUndefined = !masqueradesAsUndefinedWatchpointIsStillValid();
          JSGlobalObject* globalObject = m_jit.graph().globalObjectFor(node->origin.semantic);
-        Optional<GPRTemporary> scratch;
+        std::optional<GPRTemporary> scratch;
          GPRReg scratchGPR = InvalidGPRReg;
          if (shouldCheckMasqueradesAsUndefined) {
-            scratch = GPRTemporary(this);
+            scratch.emplace(this);
              scratchGPR = scratch->gpr();
          }
          bool negateResult = true;
@@ -2103,12 +2103,12 @@ void SpeculativeJIT::emitBranch(Node* node)
              GPRTemporary result(this);
              FPRTemporary fprValue(this);
              FPRTemporary fprTemp(this);
-            Optional<GPRTemporary> scratch;
+            std::optional<GPRTemporary> scratch;
  
              GPRReg scratchGPR = InvalidGPRReg;
              bool shouldCheckMasqueradesAsUndefined = !masqueradesAsUndefinedWatchpointIsStillValid();
              if (shouldCheckMasqueradesAsUndefined) {
-                scratch = GPRTemporary(this);
+                scratch.emplace(this);
                  scratchGPR = scratch->gpr();
              }
  
@@ -4769,11 +4769,11 @@ void SpeculativeJIT::compile(Node* node)
          case StringUse: {
              SpeculateCellOperand input(this, node->child1());
              GPRTemporary result(this);
-            Optional<GPRTemporary> temp;
+            std::optional<GPRTemporary> temp;
  
              GPRReg tempGPR = InvalidGPRReg;
              if (node->child1().useKind() == CellUse) {
-                temp = GPRTemporary(this);
+                temp.emplace(this);
                  tempGPR = temp->gpr();
              }
  
@@ -5207,15 +5207,15 @@ void SpeculativeJIT::compile(Node* node)
          GPRTemporary structureID(this);
          GPRTemporary result(this);
  
-        Optional<SpeculateCellOperand> keyAsCell;
-        Optional<JSValueOperand> keyAsValue;
+        std::optional<SpeculateCellOperand> keyAsCell;
+        std::optional<JSValueOperand> keyAsValue;
          GPRReg keyGPR;
          if (node->child2().useKind() == UntypedUse) {
-            keyAsValue = JSValueOperand(this, node->child2());
+            keyAsValue.emplace(this, node->child2());
              keyGPR = keyAsValue->gpr();
          } else {
              ASSERT(node->child2().useKind() == StringUse || node->child2().useKind() == SymbolUse);
-            keyAsCell = SpeculateCellOperand(this, node->child2());
+            keyAsCell.emplace(this, node->child2());
              keyGPR = keyAsCell->gpr();
          }
  
diff --git a/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp b/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp

index 10406fa..66c5008 100644 (file)
--- a/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp
+++ b/Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp
@@ -204,7 +204,7 @@ private:
              if (m_node->isBinaryUseKind(DoubleRepUse)
                  && m_node->child2()->isNumberConstant()) {
  
-                if (Optional<double> reciprocal = safeReciprocalForDivByConst(m_node->child2()->asNumber())) {
+                if (std::optional<double> reciprocal = safeReciprocalForDivByConst(m_node->child2()->asNumber())) {
                      Node* reciprocalNode = m_insertionSet.insertConstant(m_nodeIndex, m_node->origin, jsDoubleNumber(*reciprocal), DoubleConstant);
                      m_node->setOp(ArithMul);
                      m_node->child2() = Edge(reciprocalNode, DoubleRepUse);
diff --git a/Source/JavaScriptCore/ftl/FTLJITCode.cpp b/Source/JavaScriptCore/ftl/FTLJITCode.cpp

index 3ac41d9..1cdb509 100644 (file)
--- a/Source/JavaScriptCore/ftl/FTLJITCode.cpp
+++ b/Source/JavaScriptCore/ftl/FTLJITCode.cpp
@@ -146,23 +146,23 @@ RegisterSet JITCode::liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBloc
      return RegisterSet();
  }
  
-Optional<CodeOrigin> JITCode::findPC(CodeBlock* codeBlock, void* pc)
+std::optional<CodeOrigin> JITCode::findPC(CodeBlock* codeBlock, void* pc)
  {
      for (OSRExit& exit : osrExit) {
          if (ExecutableMemoryHandle* handle = exit.m_code.executableMemory()) {
              if (handle->start() <= pc && pc < handle->end())
-                return Optional<CodeOrigin>(exit.m_codeOriginForExitProfile);
+                return std::optional<CodeOrigin>(exit.m_codeOriginForExitProfile);
          }
      }
  
      for (std::unique_ptr<LazySlowPath>& lazySlowPath : lazySlowPaths) {
          if (ExecutableMemoryHandle* handle = lazySlowPath->stub().executableMemory()) {
              if (handle->start() <= pc && pc < handle->end())
-                return Optional<CodeOrigin>(codeBlock->codeOrigin(lazySlowPath->callSiteIndex()));
+                return std::optional<CodeOrigin>(codeBlock->codeOrigin(lazySlowPath->callSiteIndex()));
          }
      }
  
-    return Nullopt;
+    return std::nullopt;
  }
  
  } } // namespace JSC::FTL
diff --git a/Source/JavaScriptCore/ftl/FTLJITCode.h b/Source/JavaScriptCore/ftl/FTLJITCode.h

index 986a90a..2c2809e 100644 (file)
--- a/Source/JavaScriptCore/ftl/FTLJITCode.h
+++ b/Source/JavaScriptCore/ftl/FTLJITCode.h
@@ -60,7 +60,7 @@ public:
  
      RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) override;
  
-    Optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;
+    std::optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;
  
      CodeRef b3Code() const { return m_b3Code; }
      
diff --git a/Source/JavaScriptCore/heap/Heap.cpp b/Source/JavaScriptCore/heap/Heap.cpp

index 124d36f..8454dbe 100644 (file)
--- a/Source/JavaScriptCore/heap/Heap.cpp
+++ b/Source/JavaScriptCore/heap/Heap.cpp
@@ -190,7 +190,7 @@ SimpleStats& timingStats(const char* name, CollectionScope scope)
  
  class TimingScope {
  public:
-    TimingScope(Optional<CollectionScope> scope, const char* name)
+    TimingScope(std::optional<CollectionScope> scope, const char* name)
          : m_scope(scope)
          , m_name(name)
      {
@@ -203,7 +203,7 @@ public:
      {
      }
      
-    void setScope(Optional<CollectionScope> scope)
+    void setScope(std::optional<CollectionScope> scope)
      {
          m_scope = scope;
      }
@@ -224,7 +224,7 @@ public:
          }
      }
  private:
-    Optional<CollectionScope> m_scope;
+    std::optional<CollectionScope> m_scope;
      double m_before;
      const char* m_name;
  };
@@ -1084,7 +1084,7 @@ void Heap::collectAllGarbage()
      sweepAllLogicallyEmptyWeakBlocks();
  }
  
-void Heap::collectAsync(Optional<CollectionScope> scope)
+void Heap::collectAsync(std::optional<CollectionScope> scope)
  {
      if (!m_isSafeToCollect)
          return;
@@ -1092,7 +1092,7 @@ void Heap::collectAsync(Optional<CollectionScope> scope)
      bool alreadyRequested = false;
      {
          LockHolder locker(*m_threadLock);
-        for (Optional<CollectionScope> request : m_requests) {
+        for (std::optional<CollectionScope> request : m_requests) {
              if (scope) {
                  if (scope == CollectionScope::Eden) {
                      alreadyRequested = true;
@@ -1118,7 +1118,7 @@ void Heap::collectAsync(Optional<CollectionScope> scope)
      requestCollection(scope);
  }
  
-void Heap::collectSync(Optional<CollectionScope> scope)
+void Heap::collectSync(std::optional<CollectionScope> scope)
  {
      if (!m_isSafeToCollect)
          return;
@@ -1138,7 +1138,7 @@ void Heap::collectInThread()
  {
      m_currentGCStartTime = MonotonicTime::now();
      
-    Optional<CollectionScope> scope;
+    std::optional<CollectionScope> scope;
      {
          LockHolder locker(*m_threadLock);
          RELEASE_ASSERT(!m_requests.isEmpty());
@@ -1164,7 +1164,7 @@ void Heap::collectInThread()
      
      ASSERT(m_isSafeToCollect);
      if (m_collectionScope) {
-        dataLog("Collection scope already set during GC: ", m_collectionScope, "\n");
+        dataLog("Collection scope already set during GC: ", *m_collectionScope, "\n");
          RELEASE_ASSERT_NOT_REACHED();
      }
      
@@ -1542,7 +1542,7 @@ void Heap::finalize()
          cache->clear();
  }
  
-Heap::Ticket Heap::requestCollection(Optional<CollectionScope> scope)
+Heap::Ticket Heap::requestCollection(std::optional<CollectionScope> scope)
  {
      stopIfNecessary();
      
@@ -1582,7 +1582,7 @@ void Heap::suspendCompilerThreads()
  #endif
  }
  
-void Heap::willStartCollection(Optional<CollectionScope> scope)
+void Heap::willStartCollection(std::optional<CollectionScope> scope)
  {
      if (Options::logGC())
          dataLog("=> ");
@@ -1789,7 +1789,7 @@ void Heap::didFinishCollection(double gcStartTime)
  
      RELEASE_ASSERT(m_collectionScope);
      m_lastCollectionScope = m_collectionScope;
-    m_collectionScope = Nullopt;
+    m_collectionScope = std::nullopt;
  
      for (auto* observer : m_observers)
          observer->didGarbageCollect(scope);
@@ -1915,7 +1915,7 @@ void Heap::flushWriteBarrierBuffer(JSCell* cell)
      m_writeBarrierBuffer.add(cell);
  }
  
-bool Heap::shouldDoFullCollection(Optional<CollectionScope> scope) const
+bool Heap::shouldDoFullCollection(std::optional<CollectionScope> scope) const
  {
      if (!Options::useGenerationalGC())
          return true;
diff --git a/Source/JavaScriptCore/heap/Heap.h b/Source/JavaScriptCore/heap/Heap.h

index 411f92a..7726ade 100644 (file)
--- a/Source/JavaScriptCore/heap/Heap.h
+++ b/Source/JavaScriptCore/heap/Heap.h
@@ -146,7 +146,7 @@ public:
      void removeObserver(HeapObserver* observer) { m_observers.removeFirst(observer); }
  
      MutatorState mutatorState() const { return m_mutatorState; }
-    Optional<CollectionScope> collectionScope() const { return m_collectionScope; }
+    std::optional<CollectionScope> collectionScope() const { return m_collectionScope; }
      bool hasHeapAccess() const;
      bool mutatorIsStopped() const;
      bool collectorBelievesThatTheWorldIsStopped() const;
@@ -186,18 +186,18 @@ public:
      bool shouldCollect();
      
      // Queue up a collection. Returns immediately. This will not queue a collection if a collection
-    // of equal or greater strength exists. Full collections are stronger than Nullopt collections
-    // and Nullopt collections are stronger than Eden collections. Nullopt means that the GC can
+    // of equal or greater strength exists. Full collections are stronger than std::nullopt collections
+    // and std::nullopt collections are stronger than Eden collections. std::nullopt means that the GC can
      // choose Eden or Full. This implies that if you request a GC while that GC is ongoing, nothing
      // will happen.
-    JS_EXPORT_PRIVATE void collectAsync(Optional<CollectionScope> = Nullopt);
+    JS_EXPORT_PRIVATE void collectAsync(std::optional<CollectionScope> = std::nullopt);
      
      // Queue up a collection and wait for it to complete. This won't return until you get your own
      // complete collection. For example, if there was an ongoing asynchronous collection at the time
      // you called this, then this would wait for that one to complete and then trigger your
      // collection and then return. In weird cases, there could be multiple GC requests in the backlog
      // and this will wait for that backlog before running its GC and returning.
-    JS_EXPORT_PRIVATE void collectSync(Optional<CollectionScope> = Nullopt);
+    JS_EXPORT_PRIVATE void collectSync(std::optional<CollectionScope> = std::nullopt);
      
      bool collectIfNecessaryOrDefer(GCDeferralContext* = nullptr); // Returns true if it did collect.
      void collectAccordingToDeferGCProbability();
@@ -425,11 +425,11 @@ private:
      void notifyThreadStopping(const LockHolder&);
      
      typedef uint64_t Ticket;
-    Ticket requestCollection(Optional<CollectionScope>);
+    Ticket requestCollection(std::optional<CollectionScope>);
      void waitForCollection(Ticket);
      
      void suspendCompilerThreads();
-    void willStartCollection(Optional<CollectionScope>);
+    void willStartCollection(std::optional<CollectionScope>);
      void flushWriteBarrierBuffer();
      void prepareForMarking();
      
@@ -469,7 +469,7 @@ private:
      void sweepAllLogicallyEmptyWeakBlocks();
      bool sweepNextLogicallyEmptyWeakBlock();
  
-    bool shouldDoFullCollection(Optional<CollectionScope> requestedCollectionScope) const;
+    bool shouldDoFullCollection(std::optional<CollectionScope> requestedCollectionScope) const;
  
      void incrementDeferralDepth();
      void decrementDeferralDepth();
@@ -497,8 +497,8 @@ private:
      size_t m_totalBytesVisited;
      size_t m_totalBytesVisitedThisCycle;
      
-    Optional<CollectionScope> m_collectionScope;
-    Optional<CollectionScope> m_lastCollectionScope;
+    std::optional<CollectionScope> m_collectionScope;
+    std::optional<CollectionScope> m_lastCollectionScope;
      MutatorState m_mutatorState { MutatorState::Running };
      StructureIDTable m_structureIDTable;
      MarkedSpace m_objectSpace;
@@ -599,7 +599,7 @@ private:
      bool m_collectorBelievesThatTheWorldIsStopped { false };
      MonotonicTime m_stopTime;
      
-    Deque<Optional<CollectionScope>> m_requests;
+    Deque<std::optional<CollectionScope>> m_requests;
      Ticket m_lastServedTicket { 0 };
      Ticket m_lastGrantedTicket { 0 };
      bool m_threadShouldStop { false };
diff --git a/Source/JavaScriptCore/heap/HeapSnapshot.cpp b/Source/JavaScriptCore/heap/HeapSnapshot.cpp

index fa33dc9..34db12c 100644 (file)
--- a/Source/JavaScriptCore/heap/HeapSnapshot.cpp
+++ b/Source/JavaScriptCore/heap/HeapSnapshot.cpp
@@ -130,7 +130,7 @@ void HeapSnapshot::finalize()
  #endif
  }
  
-Optional<HeapSnapshotNode> HeapSnapshot::nodeForCell(JSCell* cell)
+std::optional<HeapSnapshotNode> HeapSnapshot::nodeForCell(JSCell* cell)
  {
      ASSERT(m_finalized);
  
@@ -142,7 +142,7 @@ Optional<HeapSnapshotNode> HeapSnapshot::nodeForCell(JSCell* cell)
              unsigned middle = start + ((end - start) / 2);
              HeapSnapshotNode& node = m_nodes[middle];
              if (cell == node.cell)
-                return Optional<HeapSnapshotNode>(node);
+                return std::optional<HeapSnapshotNode>(node);
              if (cell < node.cell)
                  end = middle;
              else
@@ -153,32 +153,32 @@ Optional<HeapSnapshotNode> HeapSnapshot::nodeForCell(JSCell* cell)
      if (m_previous)
          return m_previous->nodeForCell(cell);
  
-    return Nullopt;
+    return std::nullopt;
  }
  
-Optional<HeapSnapshotNode> HeapSnapshot::nodeForObjectIdentifier(unsigned objectIdentifier)
+std::optional<HeapSnapshotNode> HeapSnapshot::nodeForObjectIdentifier(unsigned objectIdentifier)
  {
      if (isEmpty()) {
          if (m_previous)
              return m_previous->nodeForObjectIdentifier(objectIdentifier);
-        return Nullopt;
+        return std::nullopt;
      }
  
      if (objectIdentifier > m_lastObjectIdentifier)
-        return Nullopt;
+        return std::nullopt;
  
      if (objectIdentifier < m_firstObjectIdentifier) {
          if (m_previous)
              return m_previous->nodeForObjectIdentifier(objectIdentifier);
-        return Nullopt;
+        return std::nullopt;
      }
  
      for (auto& node : m_nodes) {
          if (node.identifier == objectIdentifier)
-            return Optional<HeapSnapshotNode>(node);
+            return std::optional<HeapSnapshotNode>(node);
      }
  
-    return Nullopt;
+    return std::nullopt;
  }
  
  } // namespace JSC
diff --git a/Source/JavaScriptCore/heap/HeapSnapshot.h b/Source/JavaScriptCore/heap/HeapSnapshot.h

index 60d8284..fdd3de3 100644 (file)
--- a/Source/JavaScriptCore/heap/HeapSnapshot.h
+++ b/Source/JavaScriptCore/heap/HeapSnapshot.h
@@ -45,8 +45,8 @@ public:
      void finalize();
  
      bool isEmpty() const { return m_nodes.isEmpty(); }
-    Optional<HeapSnapshotNode> nodeForCell(JSCell*);
-    Optional<HeapSnapshotNode> nodeForObjectIdentifier(unsigned objectIdentifier);
+    std::optional<HeapSnapshotNode> nodeForCell(JSCell*);
+    std::optional<HeapSnapshotNode> nodeForObjectIdentifier(unsigned objectIdentifier);
  
  private:
      friend class HeapSnapshotBuilder;
diff --git a/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.cpp b/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.cpp

index e295f40..2388c28 100644 (file)
--- a/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.cpp
+++ b/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.cpp
@@ -114,7 +114,7 @@ void BackendDispatcher::dispatch(const String& message)
      {
          // In case this is a re-entrant call from a nested run loop, we don't want to lose
          // the outer request's id just because the inner request is bogus.
-        SetForScope<Optional<long>> scopedRequestId(m_currentRequestId, Nullopt);
+        SetForScope<std::optional<long>> scopedRequestId(m_currentRequestId, std::nullopt);
  
          RefPtr<InspectorValue> parsedMessage;
          if (!InspectorValue::parseJSON(message, parsedMessage)) {
@@ -145,7 +145,7 @@ void BackendDispatcher::dispatch(const String& message)
  
      {
          // We could be called re-entrantly from a nested run loop, so restore the previous id.
-        SetForScope<Optional<long>> scopedRequestId(m_currentRequestId, requestId);
+        SetForScope<std::optional<long>> scopedRequestId(m_currentRequestId, requestId);
  
          RefPtr<InspectorValue> methodValue;
          if (!messageObject->getValue(ASCIILiteral("method"), methodValue)) {
@@ -246,7 +246,7 @@ void BackendDispatcher::sendPendingErrors()
      m_frontendRouter->sendResponse(message->toJSONString());
  
      m_protocolErrors.clear();
-    m_currentRequestId = Nullopt;
+    m_currentRequestId = std::nullopt;
  }
      
  void BackendDispatcher::reportProtocolError(CommonErrorCode errorCode, const String& errorMessage)
@@ -254,7 +254,7 @@ void BackendDispatcher::reportProtocolError(CommonErrorCode errorCode, const Str
      reportProtocolError(m_currentRequestId, errorCode, errorMessage);
  }
  
-void BackendDispatcher::reportProtocolError(Optional<long> relatedRequestId, CommonErrorCode errorCode, const String& errorMessage)
+void BackendDispatcher::reportProtocolError(std::optional<long> relatedRequestId, CommonErrorCode errorCode, const String& errorMessage)
  {
      ASSERT_ARG(errorCode, errorCode >= 0);
  
diff --git a/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.h b/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.h

index 3176b2d..927642c 100644 (file)
--- a/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.h
+++ b/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.h
@@ -87,7 +87,7 @@ public:
      void sendPendingErrors();
  
      void reportProtocolError(CommonErrorCode, const String& errorMessage);
-    void reportProtocolError(Optional<long> relatedRequestId, CommonErrorCode, const String& errorMessage);
+    void reportProtocolError(std::optional<long> relatedRequestId, CommonErrorCode, const String& errorMessage);
  
      template<typename T>
      WTF_HIDDEN_DECLARATION
@@ -114,7 +114,7 @@ private:
  
      // For synchronously handled requests, avoid plumbing requestId through every
      // call that could potentially fail with a protocol error.
-    Optional<long> m_currentRequestId { Nullopt };
+    std::optional<long> m_currentRequestId { std::nullopt };
  };
  
  } // namespace Inspector
diff --git a/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.cpp b/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.cpp

index 404169f..7e6eb50 100644 (file)
--- a/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.cpp
+++ b/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.cpp
@@ -213,24 +213,24 @@ void InspectorHeapAgent::stopTracking(ErrorString& errorString)
      m_frontendDispatcher->trackingComplete(timestamp, snapshotData);
  }
  
-Optional<HeapSnapshotNode> InspectorHeapAgent::nodeForHeapObjectIdentifier(ErrorString& errorString, unsigned heapObjectIdentifier)
+std::optional<HeapSnapshotNode> InspectorHeapAgent::nodeForHeapObjectIdentifier(ErrorString& errorString, unsigned heapObjectIdentifier)
  {
      HeapProfiler* heapProfiler = m_environment.vm().heapProfiler();
      if (!heapProfiler) {
          errorString = ASCIILiteral("No heap snapshot");
-        return Nullopt;
+        return std::nullopt;
      }
  
      HeapSnapshot* snapshot = heapProfiler->mostRecentSnapshot();
      if (!snapshot) {
          errorString = ASCIILiteral("No heap snapshot");
-        return Nullopt;
+        return std::nullopt;
      }
  
-    const Optional<HeapSnapshotNode> optionalNode = snapshot->nodeForObjectIdentifier(heapObjectIdentifier);
+    const std::optional<HeapSnapshotNode> optionalNode = snapshot->nodeForObjectIdentifier(heapObjectIdentifier);
      if (!optionalNode) {
          errorString = ASCIILiteral("No object for identifier, it may have been collected");
-        return Nullopt;
+        return std::nullopt;
      }
  
      return optionalNode;
@@ -244,7 +244,7 @@ void InspectorHeapAgent::getPreview(ErrorString& errorString, int heapObjectId,
      DeferGC deferGC(vm.heap);
  
      unsigned heapObjectIdentifier = static_cast<unsigned>(heapObjectId);
-    const Optional<HeapSnapshotNode> optionalNode = nodeForHeapObjectIdentifier(errorString, heapObjectIdentifier);
+    const std::optional<HeapSnapshotNode> optionalNode = nodeForHeapObjectIdentifier(errorString, heapObjectIdentifier);
      if (!optionalNode)
          return;
  
@@ -293,7 +293,7 @@ void InspectorHeapAgent::getRemoteObject(ErrorString& errorString, int heapObjec
      DeferGC deferGC(vm.heap);
  
      unsigned heapObjectIdentifier = static_cast<unsigned>(heapObjectId);
-    const Optional<HeapSnapshotNode> optionalNode = nodeForHeapObjectIdentifier(errorString, heapObjectIdentifier);
+    const std::optional<HeapSnapshotNode> optionalNode = nodeForHeapObjectIdentifier(errorString, heapObjectIdentifier);
      if (!optionalNode)
          return;
  
diff --git a/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.h b/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.h

index ba7382b..4757608 100644 (file)
--- a/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.h
+++ b/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.h
@@ -66,7 +66,7 @@ protected:
      void clearHeapSnapshots();
  
  private:
-    Optional<JSC::HeapSnapshotNode> nodeForHeapObjectIdentifier(ErrorString&, unsigned heapObjectIdentifier);
+    std::optional<JSC::HeapSnapshotNode> nodeForHeapObjectIdentifier(ErrorString&, unsigned heapObjectIdentifier);
  
      InjectedScriptManager& m_injectedScriptManager;
      std::unique_ptr<HeapFrontendDispatcher> m_frontendDispatcher;
diff --git a/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.h b/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.h

index 931705d..dba0601 100644 (file)
--- a/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.h
+++ b/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.h
@@ -53,7 +53,7 @@ public:
      void close();
      void targetClosed();
  
-    Optional<unsigned> targetIdentifier() const;
+    std::optional<unsigned> targetIdentifier() const;
      NSString *connectionIdentifier() const;
      NSString *destination() const;
  
diff --git a/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.mm b/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.mm

index 12f954c..d60da48 100644 (file)
--- a/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.mm
+++ b/Source/JavaScriptCore/inspector/remote/RemoteConnectionToTarget.mm
@@ -119,9 +119,9 @@ RemoteConnectionToTarget::~RemoteConnectionToTarget()
      teardownRunLoop();
  }
  
-Optional<unsigned> RemoteConnectionToTarget::targetIdentifier() const
+std::optional<unsigned> RemoteConnectionToTarget::targetIdentifier() const
  {
-    return m_target ? Optional<unsigned>(m_target->targetIdentifier()) : Nullopt;
+    return m_target ? std::optional<unsigned>(m_target->targetIdentifier()) : std::nullopt;
  }
  
  NSString *RemoteConnectionToTarget::connectionIdentifier() const
@@ -163,7 +163,7 @@ bool RemoteConnectionToTarget::setup(bool isAutomaticInspection, bool automatica
          {
              std::lock_guard<Lock> lock(m_targetMutex);
              if (!m_target || !m_target->remoteControlAllowed()) {
-                RemoteInspector::singleton().setupFailed(targetIdentifier().valueOr(0));
+                RemoteInspector::singleton().setupFailed(targetIdentifier().value_or(0));
                  m_target = nullptr;
              } else if (is<RemoteInspectionTarget>(m_target)) {
                  auto castedTarget = downcast<RemoteInspectionTarget>(m_target);
diff --git a/Source/JavaScriptCore/inspector/remote/RemoteInspector.h b/Source/JavaScriptCore/inspector/remote/RemoteInspector.h

index 4ea7f39..93fd1a7 100644 (file)
--- a/Source/JavaScriptCore/inspector/remote/RemoteInspector.h
+++ b/Source/JavaScriptCore/inspector/remote/RemoteInspector.h
@@ -137,7 +137,7 @@ private:
      RefPtr<RemoteInspectorXPCConnection> m_relayConnection;
  
      RemoteInspector::Client* m_client { nullptr };
-    Optional<RemoteInspector::Client::Capabilities> m_clientCapabilities;
+    std::optional<RemoteInspector::Client::Capabilities> m_clientCapabilities;
  
      dispatch_queue_t m_xpcQueue;
      unsigned m_nextAvailableTargetIdentifier { 1 };
diff --git a/Source/JavaScriptCore/inspector/remote/RemoteInspector.mm b/Source/JavaScriptCore/inspector/remote/RemoteInspector.mm

index cb0bacd..21cb232 100644 (file)
--- a/Source/JavaScriptCore/inspector/remote/RemoteInspector.mm
+++ b/Source/JavaScriptCore/inspector/remote/RemoteInspector.mm
@@ -256,7 +256,7 @@ void RemoteInspector::updateClientCapabilities()
      std::lock_guard<Lock> lock(m_mutex);
  
      if (!m_client)
-        m_clientCapabilities = Nullopt;
+        m_clientCapabilities = std::nullopt;
      else {
          RemoteInspector::Client::Capabilities updatedCapabilities = {
              m_client->remoteAutomationAllowed() // remoteAutomationAllowed
diff --git a/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_header.py b/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_header.py

index d43d5a1..0704b3e 100755 (executable)
--- a/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_header.py
+++ b/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_header.py
@@ -370,11 +370,11 @@ class CppProtocolTypesHeaderGenerator(CppGenerator):
              'namespace %s {' % self.helpers_namespace(),
              '',
              'template<typename ProtocolEnumType>',
-            'Optional<ProtocolEnumType> parseEnumValueFromString(const String&);',
+            'std::optional<ProtocolEnumType> parseEnumValueFromString(const String&);',
          ]))
  
          def return_type_with_export_macro(cpp_protocol_type):
-            enum_return_type = 'Optional<%s>' % cpp_protocol_type
+            enum_return_type = 'std::optional<%s>' % cpp_protocol_type
              result_terms = [enum_return_type]
              export_macro = self.model().framework.setting('export_macro', None)
              if export_macro is not None:
diff --git a/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_implementation.py b/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_implementation.py

index 57b842b..7bbb903 100755 (executable)
--- a/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_implementation.py
+++ b/Source/JavaScriptCore/inspector/scripts/codegen/generate_cpp_protocol_types_implementation.py
@@ -97,7 +97,7 @@ class CppProtocolTypesImplementationGenerator(CppGenerator):
              body_lines = []
              body_lines.extend([
                  'template<>',
-                'Optional<%s> parseEnumValueFromString<%s>(const String& protocolString)' % (cpp_protocol_type, cpp_protocol_type),
+                'std::optional<%s> parseEnumValueFromString<%s>(const String& protocolString)' % (cpp_protocol_type, cpp_protocol_type),
                  '{',
                  '    static const size_t constantValues[] = {',
              ])
@@ -112,7 +112,7 @@ class CppProtocolTypesImplementationGenerator(CppGenerator):
                  '        if (protocolString == enum_constant_values[constantValues[i]])',
                  '            return (%s)constantValues[i];' % cpp_protocol_type,
                  '',
-                '    return Nullopt;',
+                '    return std::nullopt;',
                  '}',
                  '',
              ])
diff --git a/Source/JavaScriptCore/inspector/scripts/tests/expected/commands-with-async-attribute.json-result b/Source/JavaScriptCore/inspector/scripts/tests/expected/commands-with-async-attribute.json-result

index df3103d..442d5cb 100644 (file)
--- a/Source/JavaScriptCore/inspector/scripts/tests/expected/commands-with-async-attribute.json-result
+++ b/Source/JavaScriptCore/inspector/scripts/tests/expected/commands-with-async-attribute.json-result
@@ -723,11 +723,11 @@ public:
  namespace TestHelpers {
  
  template<typename ProtocolEnumType>
-Optional<ProtocolEnumType> parseEnumValueFromString(const String&);
+std::optional<ProtocolEnumType> parseEnumValueFromString(const String&);
  
  // Enums in the 'Database' Domain
  template<>
-Optional<Inspector::Protocol::Database::PrimaryColors> parseEnumValueFromString<Inspector::Protocol::Database::PrimaryColors>(const String&);
+std::optional<Inspector::Protocol::Database::PrimaryColors> parseEnumValueFromString<Inspector::Protocol::Database::PrimaryColors>(const String&);<
author	utatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Sun, 27 Nov 2016 06:08:16 +0000 (06:08 +0000)
committer	utatane.tea@gmail.com <utatane.tea@gmail.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Sun, 27 Nov 2016 06:08:16 +0000 (06:08 +0000)