<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[207517] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/207517">207517</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2016-10-18 19:43:44 -0700 (Tue, 18 Oct 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Replace std::experimental::variant with WTF::Variant (or similar)
https://bugs.webkit.org/show_bug.cgi?id=163626
Patch by Sam Weinig <sam@webkit.org> on 2016-10-18
Reviewed by Chris Dumez.
Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
into the WTF namespace.
Source/JavaScriptCore:
* domjit/DOMJITReg.h:
(JSC::DOMJIT::Reg::gpr):
(JSC::DOMJIT::Reg::fpr):
(JSC::DOMJIT::Reg::jsValueRegs):
Source/WebCore:
* Modules/fetch/FetchBody.h:
(WebCore::FetchBody::isBlob):
(WebCore::FetchBody::isFormData):
(WebCore::FetchBody::isArrayBuffer):
(WebCore::FetchBody::isArrayBufferView):
(WebCore::FetchBody::isURLSearchParams):
(WebCore::FetchBody::isText):
(WebCore::FetchBody::blobBody):
(WebCore::FetchBody::formDataBody):
(WebCore::FetchBody::arrayBufferBody):
(WebCore::FetchBody::arrayBufferViewBody):
(WebCore::FetchBody::textBody):
(WebCore::FetchBody::urlSearchParamsBody):
* bindings/generic/IDLTypes.h:
* dom/ExceptionOr.h:
(WebCore::ExceptionOr<ReturnType>::hasException):
(WebCore::ExceptionOr<ReturnType>::releaseException):
(WebCore::ExceptionOr<ReturnType>::releaseReturnValue):
* dom/MessageEvent.cpp:
(WebCore::MessageEvent::source):
* dom/MessageEvent.h:
* dom/Node.cpp:
(WebCore::nodeSetPreTransformedFromNodeOrStringVector):
(WebCore::Node::convertNodesOrStringsIntoNode):
* dom/Node.h:
* html/HTMLOptionsCollection.h:
* html/HTMLSelectElement.cpp:
(WebCore::HTMLSelectElement::add):
* html/HTMLSelectElement.h:
* html/track/TrackEvent.cpp:
(WebCore::TrackEvent::TrackEvent):
* html/track/TrackEvent.h:
Source/WebKit/mac:
* DOM/DOMHTMLSelectElement.mm:
(-[DOMHTMLSelectElement add:before:]):
Source/WTF:
* wtf/Forward.h:
* wtf/Variant.h:
Tools:
* TestWebKitAPI/Tests/WTF/Variant.cpp:
(TestWebKitAPI::TEST):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoredomjitDOMJITRegh">trunk/Source/JavaScriptCore/domjit/DOMJITReg.h</a></li>
<li><a href="#trunkSourceWTFChangeLog">trunk/Source/WTF/ChangeLog</a></li>
<li><a href="#trunkSourceWTFwtfForwardh">trunk/Source/WTF/wtf/Forward.h</a></li>
<li><a href="#trunkSourceWTFwtfVarianth">trunk/Source/WTF/wtf/Variant.h</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreModulesfetchFetchBodyh">trunk/Source/WebCore/Modules/fetch/FetchBody.h</a></li>
<li><a href="#trunkSourceWebCorebindingsgenericIDLTypesh">trunk/Source/WebCore/bindings/generic/IDLTypes.h</a></li>
<li><a href="#trunkSourceWebCoredomExceptionOrh">trunk/Source/WebCore/dom/ExceptionOr.h</a></li>
<li><a href="#trunkSourceWebCoredomMessageEventcpp">trunk/Source/WebCore/dom/MessageEvent.cpp</a></li>
<li><a href="#trunkSourceWebCoredomMessageEventh">trunk/Source/WebCore/dom/MessageEvent.h</a></li>
<li><a href="#trunkSourceWebCoredomNodecpp">trunk/Source/WebCore/dom/Node.cpp</a></li>
<li><a href="#trunkSourceWebCoredomNodeh">trunk/Source/WebCore/dom/Node.h</a></li>
<li><a href="#trunkSourceWebCorehtmlHTMLOptionsCollectionh">trunk/Source/WebCore/html/HTMLOptionsCollection.h</a></li>
<li><a href="#trunkSourceWebCorehtmlHTMLSelectElementcpp">trunk/Source/WebCore/html/HTMLSelectElement.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlHTMLSelectElementh">trunk/Source/WebCore/html/HTMLSelectElement.h</a></li>
<li><a href="#trunkSourceWebCorehtmltrackTrackEventcpp">trunk/Source/WebCore/html/track/TrackEvent.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmltrackTrackEventh">trunk/Source/WebCore/html/track/TrackEvent.h</a></li>
<li><a href="#trunkSourceWebKitmacChangeLog">trunk/Source/WebKit/mac/ChangeLog</a></li>
<li><a href="#trunkSourceWebKitmacDOMDOMHTMLSelectElementmm">trunk/Source/WebKit/mac/DOM/DOMHTMLSelectElement.mm</a></li>
<li><a href="#trunkToolsChangeLog">trunk/Tools/ChangeLog</a></li>
<li><a href="#trunkToolsTestWebKitAPITestsWTFVariantcpp">trunk/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -1,3 +1,18 @@
</span><ins>+2016-10-18 Sam Weinig <sam@webkit.org>
+
+ Replace std::experimental::variant with WTF::Variant (or similar)
+ https://bugs.webkit.org/show_bug.cgi?id=163626
+
+ Reviewed by Chris Dumez.
+
+ Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
+ into the WTF namespace.
+
+ * domjit/DOMJITReg.h:
+ (JSC::DOMJIT::Reg::gpr):
+ (JSC::DOMJIT::Reg::fpr):
+ (JSC::DOMJIT::Reg::jsValueRegs):
+
</ins><span class="cx"> 2016-10-18 Keith Miller <keith_miller@apple.com>
</span><span class="cx">
</span><span class="cx"> GetByVal to GetById conversion in the DFG is incorrect for getters with control flow
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredomjitDOMJITRegh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/domjit/DOMJITReg.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/domjit/DOMJITReg.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/JavaScriptCore/domjit/DOMJITReg.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -71,21 +71,21 @@
</span><span class="cx"> GPRReg gpr() const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isGPR());
</span><del>- return std::experimental::get<GPRReg>(m_variant);
</del><ins>+ return WTF::get<GPRReg>(m_variant);
</ins><span class="cx"> }
</span><span class="cx"> FPRReg fpr() const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isFPR());
</span><del>- return std::experimental::get<FPRReg>(m_variant);
</del><ins>+ return WTF::get<FPRReg>(m_variant);
</ins><span class="cx"> }
</span><span class="cx"> JSValueRegs jsValueRegs() const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isJSValueRegs());
</span><del>- return std::experimental::get<JSValueRegs>(m_variant);
</del><ins>+ return WTF::get<JSValueRegs>(m_variant);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- std::experimental::variant<GPRReg, FPRReg, JSValueRegs> m_variant;
</del><ins>+ Variant<GPRReg, FPRReg, JSValueRegs> m_variant;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } }
</span></span></pre></div>
<a id="trunkSourceWTFChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/ChangeLog (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/ChangeLog 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WTF/ChangeLog 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -1,3 +1,16 @@
</span><ins>+2016-10-18 Sam Weinig <sam@webkit.org>
+
+ Replace std::experimental::variant with WTF::Variant (or similar)
+ https://bugs.webkit.org/show_bug.cgi?id=163626
+
+ Reviewed by Chris Dumez.
+
+ Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
+ into the WTF namespace.
+
+ * wtf/Forward.h:
+ * wtf/Variant.h:
+
</ins><span class="cx"> 2016-10-18 Filip Pizlo <fpizlo@apple.com>
</span><span class="cx">
</span><span class="cx"> WTF should make it easier to create threads that die automatically after inactivity
</span></span></pre></div>
<a id="trunkSourceWTFwtfForwardh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/wtf/Forward.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/wtf/Forward.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WTF/wtf/Forward.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -34,6 +34,7 @@
</span><span class="cx"> template<typename T> class RefPtr;
</span><span class="cx"> template<typename T> class StringBuffer;
</span><span class="cx">
</span><ins>+template<typename... T> class Variant;
</ins><span class="cx"> template<typename T, size_t inlineCapacity, typename OverflowHandler, size_t minCapacity> class Vector;
</span><span class="cx">
</span><span class="cx"> class AtomicString;
</span><span class="lines">@@ -51,18 +52,6 @@
</span><span class="cx">
</span><span class="cx"> }
</span><span class="cx">
</span><del>-namespace std {
-namespace experimental {
-
-template<typename... T> class variant;
-
-}
-
-template<typename... Types>
-using variant = std::experimental::variant<Types...>;
-
-}
-
</del><span class="cx"> using WTF::AtomicString;
</span><span class="cx"> using WTF::AtomicStringImpl;
</span><span class="cx"> using WTF::BinarySemaphore;
</span><span class="lines">@@ -84,4 +73,5 @@
</span><span class="cx"> using WTF::StringImpl;
</span><span class="cx"> using WTF::StringView;
</span><span class="cx"> using WTF::TextPosition;
</span><ins>+using WTF::Variant;
</ins><span class="cx"> using WTF::Vector;
</span></span></pre></div>
<a id="trunkSourceWTFwtfVarianth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WTF/wtf/Variant.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WTF/wtf/Variant.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WTF/wtf/Variant.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -59,8 +59,7 @@
</span><span class="cx">
</span><span class="cx"> #if !COMPILER(CLANG) || WTF_CPP_STD_VER >= 14
</span><span class="cx">
</span><del>-namespace std {
-namespace experimental {
</del><ins>+namespace WTF {
</ins><span class="cx">
</span><span class="cx"> #if COMPILER_SUPPORTS(EXCEPTIONS)
</span><span class="cx"> #define __THROW_EXCEPTION(__exception) throw __exception;
</span><span class="lines">@@ -165,7 +164,7 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-class variant;
</del><ins>+class Variant;
</ins><span class="cx">
</span><span class="cx"> template<typename>
</span><span class="cx"> struct variant_size;
</span><span class="lines">@@ -180,7 +179,7 @@
</span><span class="cx"> struct variant_size<const volatile _Type> : variant_size<_Type> {};
</span><span class="cx">
</span><span class="cx"> template <typename... _Types>
</span><del>-struct variant_size<variant<_Types...>>
</del><ins>+struct variant_size<Variant<_Types...>>
</ins><span class="cx"> : std::integral_constant<size_t, sizeof...(_Types)> {};
</span><span class="cx">
</span><span class="cx"> template<size_t _Index,typename _Type>
</span><span class="lines">@@ -205,7 +204,7 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<size_t _Index,typename ... _Types>
</span><del>-struct variant_alternative<_Index,variant<_Types...>>{
</del><ins>+struct variant_alternative<_Index,Variant<_Types...>>{
</ins><span class="cx"> using type=typename __indexed_type<_Index,_Types...>::__type;
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -212,43 +211,43 @@
</span><span class="cx"> constexpr size_t variant_npos=-1;
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr _Type& get(variant<_Types...>&);
</del><ins>+constexpr _Type& get(Variant<_Types...>&);
</ins><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr _Type const& get(variant<_Types...> const&);
</del><ins>+constexpr _Type const& get(Variant<_Types...> const&);
</ins><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr _Type&& get(variant<_Types...>&&);
</del><ins>+constexpr _Type&& get(Variant<_Types...>&&);
</ins><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr const _Type&& get(variant<_Types...> const&&);
</del><ins>+constexpr const _Type&& get(Variant<_Types...> const&&);
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr typename __indexed_type<_Index,_Types...>::__type& get(variant<_Types...>&);
</del><ins>+constexpr typename __indexed_type<_Index,_Types...>::__type& get(Variant<_Types...>&);
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr typename __indexed_type<_Index,_Types...>::__type&& get(variant<_Types...>&&);
</del><ins>+constexpr typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...>&&);
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><span class="cx"> constexpr typename __indexed_type<_Index,_Types...>::__type const& get(
</span><del>- variant<_Types...> const&);
</del><ins>+ Variant<_Types...> const&);
</ins><span class="cx">
</span><span class="cx"> template <ptrdiff_t _Index, typename... _Types>
</span><span class="cx"> constexpr const typename __indexed_type<_Index, _Types...>::__type &&
</span><del>-get(variant<_Types...> const &&);
</del><ins>+get(Variant<_Types...> const &&);
</ins><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr std::add_pointer_t<_Type> get_if(variant<_Types...>&);
</del><ins>+constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>&);
</ins><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr std::add_pointer_t<_Type const> get_if(variant<_Types...> const&);
</del><ins>+constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const&);
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(variant<_Types...>&);
</del><ins>+constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(Variant<_Types...>&);
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><span class="cx"> constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
</span><del>- variant<_Types...> const&);
</del><ins>+ Variant<_Types...> const&);
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><span class="cx"> struct __variant_accessor;
</span><span class="lines">@@ -379,7 +378,7 @@
</span><span class="cx"> struct __any_backup_storage_required;
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-struct __any_backup_storage_required<variant<_Types...> >{
</del><ins>+struct __any_backup_storage_required<Variant<_Types...> >{
</ins><span class="cx"> static const bool __value=
</span><span class="cx"> __any_backup_storage_required_impl<0,sizeof...(_Types),_Types...>::__value;
</span><span class="cx"> };
</span><span class="lines">@@ -704,7 +703,7 @@
</span><span class="cx"> struct __variant_indices;
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-struct __variant_indices<variant<_Types...>>{
</del><ins>+struct __variant_indices<Variant<_Types...>>{
</ins><span class="cx"> typedef typename __type_indices<_Types...>::__type __type;
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -1436,17 +1435,17 @@
</span><span class="cx"> {};
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-class variant:
</del><ins>+class Variant:
</ins><span class="cx"> private __variant_base<
</span><del>- variant<_Types...>,__all_trivially_destructible<_Types...>::__value>
</del><ins>+ Variant<_Types...>,__all_trivially_destructible<_Types...>::__value>
</ins><span class="cx"> {
</span><del>- typedef __variant_base<variant<_Types...>,__all_trivially_destructible<_Types...>::__value> __base_type;
</del><ins>+ typedef __variant_base<Variant<_Types...>,__all_trivially_destructible<_Types...>::__value> __base_type;
</ins><span class="cx"> friend __base_type;
</span><del>- friend struct __copy_construct_op_table<variant>;
- friend struct __copy_assign_op_table<variant>;
- friend struct __move_construct_op_table<variant>;
- friend struct __move_assign_op_table<variant>;
- friend struct __destroy_op_table<variant>;
</del><ins>+ friend struct __copy_construct_op_table<Variant>;
+ friend struct __copy_assign_op_table<Variant>;
+ friend struct __move_construct_op_table<Variant>;
+ friend struct __move_assign_op_table<Variant>;
+ friend struct __destroy_op_table<Variant>;
</ins><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types2>
</span><span class="cx"> friend struct __variant_accessor;
</span><span class="lines">@@ -1467,24 +1466,24 @@
</span><span class="cx"> void __destroy_self(){
</span><span class="cx"> if(valueless_by_exception())
</span><span class="cx"> return;
</span><del>- __destroy_op_table<variant>::__apply[index()](this);
</del><ins>+ __destroy_op_table<Variant>::__apply[index()](this);
</ins><span class="cx"> __index=-1;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- ptrdiff_t __move_construct(variant& __other){
</del><ins>+ ptrdiff_t __move_construct(Variant& __other){
</ins><span class="cx"> ptrdiff_t const __other_index=__other.index();
</span><span class="cx"> if(__other_index==-1)
</span><span class="cx"> return -1;
</span><del>- __move_construct_op_table<variant>::__apply[__other_index](this,__other);
</del><ins>+ __move_construct_op_table<Variant>::__apply[__other_index](this,__other);
</ins><span class="cx"> __other.__destroy_self();
</span><span class="cx"> return __other_index;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- ptrdiff_t __copy_construct(variant const& __other){
</del><ins>+ ptrdiff_t __copy_construct(Variant const& __other){
</ins><span class="cx"> ptrdiff_t const __other_index=__other.index();
</span><span class="cx"> if(__other_index==-1)
</span><span class="cx"> return -1;
</span><del>- __copy_construct_op_table<variant>::__apply[__other_index](this,__other);
</del><ins>+ __copy_construct_op_table<Variant>::__apply[__other_index](this,__other);
</ins><span class="cx"> return __other_index;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1531,35 +1530,35 @@
</span><span class="cx"> struct __private_type{};
</span><span class="cx">
</span><span class="cx"> public:
</span><del>- constexpr variant()
</del><ins>+ constexpr Variant()
</ins><span class="cx"> __NOEXCEPT_(noexcept(typename __indexed_type<0,_Types...>::__type())):
</span><span class="cx"> __storage(in_place<0>),
</span><span class="cx"> __index(0)
</span><span class="cx"> {}
</span><span class="cx">
</span><del>- constexpr variant(typename std::conditional<__all_move_constructible<_Types...>::value,variant,__private_type>::type&& __other)
</del><ins>+ constexpr Variant(typename std::conditional<__all_move_constructible<_Types...>::value,Variant,__private_type>::type&& __other)
</ins><span class="cx"> __NOEXCEPT_(__noexcept_variant_move_construct<_Types...>::value):
</span><span class="cx"> __index(__move_construct(__other))
</span><span class="cx"> {}
</span><span class="cx">
</span><del>- constexpr variant(typename std::conditional<!__all_move_constructible<_Types...>::value,variant,__private_type>::type&& __other)=delete;
</del><ins>+ constexpr Variant(typename std::conditional<!__all_move_constructible<_Types...>::value,Variant,__private_type>::type&& __other)=delete;
</ins><span class="cx">
</span><del>- constexpr variant(typename std::conditional<__all_copy_constructible<_Types...>::value,variant,__private_type>::type& __other)
</del><ins>+ constexpr Variant(typename std::conditional<__all_copy_constructible<_Types...>::value,Variant,__private_type>::type& __other)
</ins><span class="cx"> __NOEXCEPT_(__noexcept_variant_non_const_copy_construct<_Types...>::value):
</span><span class="cx"> __index(__copy_construct(__other))
</span><span class="cx"> {}
</span><span class="cx">
</span><del>- constexpr variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,variant,__private_type>::type& __other)=delete;
</del><ins>+ constexpr Variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,Variant,__private_type>::type& __other)=delete;
</ins><span class="cx">
</span><del>- constexpr variant(typename std::conditional<__all_copy_constructible<_Types...>::value,variant,__private_type>::type const& __other)
</del><ins>+ constexpr Variant(typename std::conditional<__all_copy_constructible<_Types...>::value,Variant,__private_type>::type const& __other)
</ins><span class="cx"> __NOEXCEPT_(__noexcept_variant_const_copy_construct<_Types...>::value):
</span><span class="cx"> __index(__copy_construct(__other))
</span><span class="cx"> {}
</span><span class="cx">
</span><del>- constexpr variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,variant,__private_type>::type const& __other)=delete;
</del><ins>+ constexpr Variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,Variant,__private_type>::type const& __other)=delete;
</ins><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Args>
</span><del>- explicit constexpr variant(in_place_type_t<_Type>,_Args&& ... __args):
</del><ins>+ explicit constexpr Variant(in_place_type_t<_Type>,_Args&& ... __args):
</ins><span class="cx"> __storage(
</span><span class="cx"> in_place<__type_index<_Type,_Types...>::__value>,
</span><span class="cx"> std::forward<_Args>(__args)...),
</span><span class="lines">@@ -1569,7 +1568,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<size_t _Index,typename ... _Args>
</span><del>- explicit constexpr variant(in_place_index_t<_Index>,_Args&& ... __args):
</del><ins>+ explicit constexpr Variant(in_place_index_t<_Index>,_Args&& ... __args):
</ins><span class="cx"> __storage(in_place<_Index>,std::forward<_Args>(__args)...),
</span><span class="cx"> __index(_Index)
</span><span class="cx"> {
</span><span class="lines">@@ -1577,7 +1576,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type>
</span><del>- constexpr variant(_Type&& __x):
</del><ins>+ constexpr Variant(_Type&& __x):
</ins><span class="cx"> __storage(
</span><span class="cx"> in_place<
</span><span class="cx"> __type_index_to_construct<_Type,_Types...>::__value>,
</span><span class="lines">@@ -1590,7 +1589,7 @@
</span><span class="cx"> typename std::enable_if<
</span><span class="cx"> (__constructible_matches<std::initializer_list<_Type>,_Types...>::__type::__length>0)
</span><span class="cx"> >::type>
</span><del>- constexpr variant(std::initializer_list<_Type> __x):
</del><ins>+ constexpr Variant(std::initializer_list<_Type> __x):
</ins><span class="cx"> __storage(
</span><span class="cx"> in_place<
</span><span class="cx"> __type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value>,
</span><span class="lines">@@ -1599,7 +1598,7 @@
</span><span class="cx"> {}
</span><span class="cx">
</span><span class="cx"> template<typename _Type>
</span><del>- variant& operator=(_Type&& __x){
</del><ins>+ Variant& operator=(_Type&& __x){
</ins><span class="cx"> constexpr size_t _Index=
</span><span class="cx"> __type_index_to_construct<_Type,_Types...>::__value;
</span><span class="cx"> if(_Index==__index){
</span><span class="lines">@@ -1611,76 +1610,76 @@
</span><span class="cx"> return *this;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- variant &operator=(
</del><ins>+ Variant &operator=(
</ins><span class="cx"> typename std::conditional<
</span><span class="cx"> !(__all_copy_constructible<_Types...>::value &&
</span><span class="cx"> __all_move_constructible<_Types...>::value &&
</span><span class="cx"> __all_copy_assignable<_Types...>::value),
</span><del>- variant, __private_type>::type const &__other) = delete;
</del><ins>+ Variant, __private_type>::type const &__other) = delete;
</ins><span class="cx">
</span><del>- variant &operator=(
</del><ins>+ Variant &operator=(
</ins><span class="cx"> typename std::conditional<
</span><span class="cx"> __all_copy_constructible<_Types...>::value &&
</span><span class="cx"> __all_move_constructible<_Types...>::value &&
</span><span class="cx"> __all_copy_assignable<_Types...>::value,
</span><del>- variant, __private_type>::type const &__other) {
</del><ins>+ Variant, __private_type>::type const &__other) {
</ins><span class="cx"> if (__other.valueless_by_exception()) {
</span><span class="cx"> __destroy_self();
</span><span class="cx"> }
</span><span class="cx"> else if(__other.index()==index()){
</span><del>- __copy_assign_op_table<variant>::__apply[index()](this,__other);
</del><ins>+ __copy_assign_op_table<Variant>::__apply[index()](this,__other);
</ins><span class="cx"> }
</span><span class="cx"> else{
</span><del>- __replace_construct_helper::__op_table<variant>::__copy_assign[
</del><ins>+ __replace_construct_helper::__op_table<Variant>::__copy_assign[
</ins><span class="cx"> __other.index()](this,__other);
</span><span class="cx"> }
</span><span class="cx"> return *this;
</span><span class="cx"> }
</span><del>- variant &operator=(
</del><ins>+ Variant &operator=(
</ins><span class="cx"> typename std::conditional<
</span><span class="cx"> !(__all_copy_constructible<_Types...>::value &&
</span><span class="cx"> __all_move_constructible<_Types...>::value &&
</span><span class="cx"> __all_copy_assignable<_Types...>::value),
</span><del>- variant, __private_type>::type &__other) = delete;
</del><ins>+ Variant, __private_type>::type &__other) = delete;
</ins><span class="cx">
</span><del>- variant &operator=(
</del><ins>+ Variant &operator=(
</ins><span class="cx"> typename std::conditional<
</span><span class="cx"> __all_copy_constructible<_Types...>::value &&
</span><span class="cx"> __all_move_constructible<_Types...>::value &&
</span><span class="cx"> __all_copy_assignable<_Types...>::value,
</span><del>- variant, __private_type>::type &__other) {
</del><ins>+ Variant, __private_type>::type &__other) {
</ins><span class="cx"> if(__other.valueless_by_exception()){
</span><span class="cx"> __destroy_self();
</span><span class="cx"> }
</span><span class="cx"> else if(__other.index()==index()){
</span><del>- __copy_assign_op_table<variant>::__apply[index()](this,__other);
</del><ins>+ __copy_assign_op_table<Variant>::__apply[index()](this,__other);
</ins><span class="cx"> }
</span><span class="cx"> else{
</span><del>- __replace_construct_helper::__op_table<variant>::__copy_assign[
</del><ins>+ __replace_construct_helper::__op_table<Variant>::__copy_assign[
</ins><span class="cx"> __other.index()](this,__other);
</span><span class="cx"> }
</span><span class="cx"> return *this;
</span><span class="cx"> }
</span><del>- variant &operator=(
</del><ins>+ Variant &operator=(
</ins><span class="cx"> typename std::conditional<
</span><span class="cx"> !(__all_move_constructible<_Types...>::value &&
</span><span class="cx"> __all_move_assignable<_Types...>::value),
</span><del>- variant, __private_type>::type &&__other) = delete;
</del><ins>+ Variant, __private_type>::type &&__other) = delete;
</ins><span class="cx">
</span><del>- variant &operator=(
</del><ins>+ Variant &operator=(
</ins><span class="cx"> typename std::conditional<__all_move_constructible<_Types...>::value &&
</span><span class="cx"> __all_move_assignable<_Types...>::value,
</span><del>- variant, __private_type>::type &&
</del><ins>+ Variant, __private_type>::type &&
</ins><span class="cx"> __other) __NOEXCEPT_(__noexcept_variant_move_assign<_Types...>::value) {
</span><span class="cx"> if (__other.valueless_by_exception()) {
</span><span class="cx"> __destroy_self();
</span><span class="cx"> }
</span><span class="cx"> else if(__other.index()==index()){
</span><del>- __move_assign_op_table<variant>::__apply[index()](this,__other);
</del><ins>+ __move_assign_op_table<Variant>::__apply[index()](this,__other);
</ins><span class="cx"> __other.__destroy_self();
</span><span class="cx"> }
</span><span class="cx"> else{
</span><del>- __replace_construct_helper::__op_table<variant>::__move_assign[
</del><ins>+ __replace_construct_helper::__op_table<Variant>::__move_assign[
</ins><span class="cx"> __other.index()](this,__other);
</span><span class="cx"> }
</span><span class="cx"> return *this;
</span><span class="lines">@@ -1708,14 +1707,14 @@
</span><span class="cx"> typename std::conditional<
</span><span class="cx"> __all_swappable<_Types...>::value &&
</span><span class="cx"> __all_move_constructible<_Types...>::value,
</span><del>- variant, __private_type>::type
</del><ins>+ Variant, __private_type>::type
</ins><span class="cx"> &__other) __NOEXCEPT_(__noexcept_variant_swap<_Types...>::value) {
</span><span class="cx"> if (__other.index() == index()) {
</span><span class="cx"> if(!valueless_by_exception())
</span><del>- __swap_op_table<variant>::__apply[index()](*this,__other);
</del><ins>+ __swap_op_table<Variant>::__apply[index()](*this,__other);
</ins><span class="cx"> }
</span><span class="cx"> else{
</span><del>- variant __temp(std::move(__other));
</del><ins>+ Variant __temp(std::move(__other));
</ins><span class="cx"> __other.__index=__other.__move_construct(*this);
</span><span class="cx"> __index=__move_construct(__temp);
</span><span class="cx"> }
</span><span class="lines">@@ -1723,9 +1722,9 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<>
</span><del>-class variant<>{
</del><ins>+class Variant<>{
</ins><span class="cx"> public:
</span><del>- variant()=delete;
</del><ins>+ Variant()=delete;
</ins><span class="cx">
</span><span class="cx"> constexpr bool valueless_by_exception() const __NOEXCEPT{
</span><span class="cx"> return true;
</span><span class="lines">@@ -1734,7 +1733,7 @@
</span><span class="cx"> return -1;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void swap(variant&){}
</del><ins>+ void swap(Variant&){}
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template <typename... _Types>
</span><span class="lines">@@ -1741,7 +1740,7 @@
</span><span class="cx"> typename std::enable_if<__all_swappable<_Types...>::value &&
</span><span class="cx"> __all_move_constructible<_Types...>::value,
</span><span class="cx"> void>::type
</span><del>-swap(variant<_Types...> &__lhs, variant<_Types...> &__rhs) __NOEXCEPT_(
</del><ins>+swap(Variant<_Types...> &__lhs, Variant<_Types...> &__rhs) __NOEXCEPT_(
</ins><span class="cx"> __noexcept_variant_swap<_Types...>::value) {
</span><span class="cx"> __lhs.swap(__rhs);
</span><span class="cx"> }
</span><span class="lines">@@ -1749,85 +1748,85 @@
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><span class="cx"> struct __variant_accessor{
</span><span class="cx"> typedef typename __indexed_type<_Index,_Types...>::__type __type;
</span><del>- static constexpr __type& get(variant<_Types...>& __v){
</del><ins>+ static constexpr __type& get(Variant<_Types...>& __v){
</ins><span class="cx"> return __v.__storage.__get(in_place<_Index>);
</span><span class="cx"> }
</span><del>- static constexpr __type const& get(variant<_Types...> const& __v){
</del><ins>+ static constexpr __type const& get(Variant<_Types...> const& __v){
</ins><span class="cx"> return __v.__storage.__get(in_place<_Index>);
</span><span class="cx"> }
</span><del>- static constexpr __type&& get(variant<_Types...>&& __v){
</del><ins>+ static constexpr __type&& get(Variant<_Types...>&& __v){
</ins><span class="cx"> return __v.__storage.__get_rref(in_place<_Index>);
</span><span class="cx"> }
</span><del>- static constexpr const __type&& get(variant<_Types...> const&& __v){
</del><ins>+ static constexpr const __type&& get(Variant<_Types...> const&& __v){
</ins><span class="cx"> return __v.__storage.__get_rref(in_place<_Index>);
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr _Type& get(variant<_Types...>& __v){
</del><ins>+constexpr _Type& get(Variant<_Types...>& __v){
</ins><span class="cx"> return get<__type_index<_Type,_Types...>::__value>(__v);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr _Type&& get(variant<_Types...>&& __v){
</del><ins>+constexpr _Type&& get(Variant<_Types...>&& __v){
</ins><span class="cx"> return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr _Type const& get(variant<_Types...> const& __v){
</del><ins>+constexpr _Type const& get(Variant<_Types...> const& __v){
</ins><span class="cx"> return get<__type_index<_Type,_Types...>::__value>(__v);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr const _Type&& get(variant<_Types...> const&& __v){
</del><ins>+constexpr const _Type&& get(Variant<_Types...> const&& __v){
</ins><span class="cx"> return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr typename __indexed_type<_Index,_Types...>::__type const& get(variant<_Types...> const& __v){
</del><ins>+constexpr typename __indexed_type<_Index,_Types...>::__type const& get(Variant<_Types...> const& __v){
</ins><span class="cx"> return *(
</span><span class="cx"> (_Index!=__v.index())
</span><del>- ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type const&>("Bad variant index in get")
</del><ins>+ ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type const&>("Bad Variant index in get")
</ins><span class="cx"> : &__variant_accessor<_Index,_Types...>::get(__v)
</span><span class="cx"> );
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr typename __indexed_type<_Index,_Types...>::__type& get(variant<_Types...>& __v){
</del><ins>+constexpr typename __indexed_type<_Index,_Types...>::__type& get(Variant<_Types...>& __v){
</ins><span class="cx"> return *(
</span><span class="cx"> (_Index!=__v.index())
</span><del>- ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type&>("Bad variant index in get")
</del><ins>+ ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type&>("Bad Variant index in get")
</ins><span class="cx"> : &__variant_accessor<_Index,_Types...>::get(__v)
</span><span class="cx"> );
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr typename __indexed_type<_Index,_Types...>::__type&& get(variant<_Types...>&& __v){
</del><ins>+constexpr typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...>&& __v){
</ins><span class="cx"> return __variant_accessor<_Index,_Types...>::get(
</span><del>- (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad variant index in get") : 0), std::move(__v))
</del><ins>+ (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad Variant index in get") : 0), std::move(__v))
</ins><span class="cx"> );
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr const typename __indexed_type<_Index,_Types...>::__type&& get(variant<_Types...> const&& __v){
</del><ins>+constexpr const typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...> const&& __v){
</ins><span class="cx"> return __variant_accessor<_Index,_Types...>::get(
</span><del>- (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad variant index in get") : 0), std::move(__v))
</del><ins>+ (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad Variant index in get") : 0), std::move(__v))
</ins><span class="cx"> );
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr std::add_pointer_t<_Type> get_if(variant<_Types...>& __v){
</del><ins>+constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>& __v){
</ins><span class="cx"> return (__type_index<_Type,_Types...>::__value!=__v.index())?nullptr:&get<_Type>(__v);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr std::add_pointer_t<_Type const> get_if(variant<_Types...> const& __v){
</del><ins>+constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const& __v){
</ins><span class="cx"> return (__type_index<_Type,_Types...>::__value!=__v.index())?nullptr:&get<_Type>(__v);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><del>-constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(variant<_Types...>& __v){
</del><ins>+constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(Variant<_Types...>& __v){
</ins><span class="cx"> return ((_Index!=__v.index())?nullptr:
</span><span class="cx"> &__variant_accessor<_Index,_Types...>::get(__v));
</span><span class="cx"> }
</span><span class="lines">@@ -1834,13 +1833,13 @@
</span><span class="cx">
</span><span class="cx"> template<ptrdiff_t _Index,typename ... _Types>
</span><span class="cx"> constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
</span><del>- variant<_Types...> const& __v){
</del><ins>+ Variant<_Types...> const& __v){
</ins><span class="cx"> return ((_Index!=__v.index())?nullptr:
</span><span class="cx"> &__variant_accessor<_Index,_Types...>::get(__v));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename _Type,typename ... _Types>
</span><del>-constexpr bool holds_alternative(variant<_Types...> const& __v) __NOEXCEPT{
</del><ins>+constexpr bool holds_alternative(Variant<_Types...> const& __v) __NOEXCEPT{
</ins><span class="cx"> return __v.index()==__type_index<_Type,_Types...>::__value;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1859,7 +1858,7 @@
</span><span class="cx">
</span><span class="cx"> template<typename _Visitor,typename ... _Types>
</span><span class="cx"> struct __visitor_table{
</span><del>- typedef variant<_Types...> __variant_type;
</del><ins>+ typedef Variant<_Types...> __variant_type;
</ins><span class="cx"> typedef typename __visitor_return_type<_Visitor,_Types...>::__type __return_type;
</span><span class="cx"> typedef __return_type (*__func_type)(_Visitor&,__variant_type&);
</span><span class="cx">
</span><span class="lines">@@ -1878,9 +1877,9 @@
</span><span class="cx">
</span><span class="cx"> template<typename _Visitor,typename ... _Types>
</span><span class="cx"> constexpr typename __visitor_return_type<_Visitor,_Types...>::__type
</span><del>-visit(_Visitor&& __visitor,variant<_Types...>& __v){
</del><ins>+visit(_Visitor&& __visitor,Variant<_Types...>& __v){
</ins><span class="cx"> return (__v.valueless_by_exception())
</span><del>- ? __throw_bad_variant_access<typename __visitor_return_type<_Visitor,_Types...>::__type>("Visiting of empty variant")
</del><ins>+ ? __throw_bad_variant_access<typename __visitor_return_type<_Visitor,_Types...>::__type>("Visiting of empty Variant")
</ins><span class="cx"> : __visitor_table<_Visitor,_Types...>::__trampoline[__v.index()](__visitor,__v);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1944,7 +1943,7 @@
</span><span class="cx"> template<typename _Visitor,typename ... _Variants>
</span><span class="cx"> static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
</span><span class="cx"> __visit(_Visitor&,_Variants&& ...){
</span><del>- return __throw_bad_variant_access<typename __multi_visitor_return_type<_Visitor,_Variants...>::__type>("Visiting of empty variant");
</del><ins>+ return __throw_bad_variant_access<typename __multi_visitor_return_type<_Visitor,_Variants...>::__type>("Visiting of empty Variant");
</ins><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -1952,7 +1951,7 @@
</span><span class="cx"> struct __variant_type_count;
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-struct __variant_type_count<variant<_Types...>>{
</del><ins>+struct __variant_type_count<Variant<_Types...>>{
</ins><span class="cx"> static constexpr size_t __value=sizeof...(_Types);
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -1989,50 +1988,50 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-constexpr bool operator==(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
</del><ins>+constexpr bool operator==(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
</ins><span class="cx"> return (__lhs.index()==__rhs.index()) &&
</span><span class="cx"> ((__lhs.index()==-1) ||
</span><del>- __equality_op_table<variant<_Types...>>::__equality_compare[__lhs.index()](
</del><ins>+ __equality_op_table<Variant<_Types...>>::__equality_compare[__lhs.index()](
</ins><span class="cx"> __lhs,__rhs));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-constexpr bool operator!=(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
</del><ins>+constexpr bool operator!=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
</ins><span class="cx"> return !(__lhs==__rhs);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-constexpr bool operator<(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
</del><ins>+constexpr bool operator<(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
</ins><span class="cx"> return (__lhs.index()<__rhs.index()) ||
</span><span class="cx"> ((__lhs.index()==__rhs.index()) &&
</span><span class="cx"> ((__lhs.index()!=-1) &&
</span><del>- __less_than_op_table<variant<_Types...>>::
</del><ins>+ __less_than_op_table<Variant<_Types...>>::
</ins><span class="cx"> __less_than_compare[__lhs.index()](__lhs,__rhs)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-constexpr bool operator>(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
</del><ins>+constexpr bool operator>(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
</ins><span class="cx"> return __rhs<__lhs;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-constexpr bool operator>=(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
</del><ins>+constexpr bool operator>=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
</ins><span class="cx"> return !(__lhs<__rhs);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-constexpr bool operator<=(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
</del><ins>+constexpr bool operator<=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
</ins><span class="cx"> return !(__lhs>__rhs);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-struct monostate{};
</del><ins>+struct Monostate{};
</ins><span class="cx">
</span><del>-constexpr inline bool operator==(monostate const&,monostate const&){ return true;}
-constexpr inline bool operator!=(monostate const&,monostate const&){ return false;}
-constexpr inline bool operator>=(monostate const&,monostate const&){ return true;}
-constexpr inline bool operator<=(monostate const&,monostate const&){ return true;}
-constexpr inline bool operator>(monostate const&,monostate const&){ return false;}
-constexpr inline bool operator<(monostate const&,monostate const&){ return false;}
</del><ins>+constexpr inline bool operator==(Monostate const&,Monostate const&){ return true;}
+constexpr inline bool operator!=(Monostate const&,Monostate const&){ return false;}
+constexpr inline bool operator>=(Monostate const&,Monostate const&){ return true;}
+constexpr inline bool operator<=(Monostate const&,Monostate const&){ return true;}
+constexpr inline bool operator>(Monostate const&,Monostate const&){ return false;}
+constexpr inline bool operator<(Monostate const&,Monostate const&){ return false;}
</ins><span class="cx">
</span><span class="cx"> struct __hash_visitor{
</span><span class="cx"> template<typename _Type>
</span><span class="lines">@@ -2041,25 +2040,29 @@
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><del>-} // namespace experimental
</del><ins>+} // namespace WTF
</ins><span class="cx">
</span><ins>+namespace std {
+
</ins><span class="cx"> template<>
</span><del>-struct hash<experimental::monostate>{
- size_t operator()(experimental::monostate) __NOEXCEPT{
</del><ins>+struct hash<WTF::Monostate>{
+ size_t operator()(WTF::Monostate) __NOEXCEPT{
</ins><span class="cx"> return 42;
</span><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<typename ... _Types>
</span><del>-struct hash<experimental::variant<_Types...>>{
- size_t operator()(experimental::variant<_Types...> const &v) __NOEXCEPT {
- return std::hash<ptrdiff_t>()(v.index()) ^
- experimental::visit(experimental::__hash_visitor(), v);
</del><ins>+struct hash<WTF::Variant<_Types...>>{
+ size_t operator()(WTF::Variant<_Types...> const &v) __NOEXCEPT {
+ return std::hash<ptrdiff_t>()(v.index()) ^ WTF::visit(WTF::__hash_visitor(), v);
</ins><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace std
</span><span class="cx">
</span><ins>+using WTF::Monostate;
+using WTF::Variant;
+
</ins><span class="cx"> #endif // !COMPILER(CLANG) || WTF_CPP_STD_VER >= 14
</span><span class="cx">
</span><span class="cx"> #if COMPILER(MSVC)
</span></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/ChangeLog 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -1,3 +1,46 @@
</span><ins>+2016-10-18 Sam Weinig <sam@webkit.org>
+
+ Replace std::experimental::variant with WTF::Variant (or similar)
+ https://bugs.webkit.org/show_bug.cgi?id=163626
+
+ Reviewed by Chris Dumez.
+
+ Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
+ into the WTF namespace.
+
+ * Modules/fetch/FetchBody.h:
+ (WebCore::FetchBody::isBlob):
+ (WebCore::FetchBody::isFormData):
+ (WebCore::FetchBody::isArrayBuffer):
+ (WebCore::FetchBody::isArrayBufferView):
+ (WebCore::FetchBody::isURLSearchParams):
+ (WebCore::FetchBody::isText):
+ (WebCore::FetchBody::blobBody):
+ (WebCore::FetchBody::formDataBody):
+ (WebCore::FetchBody::arrayBufferBody):
+ (WebCore::FetchBody::arrayBufferViewBody):
+ (WebCore::FetchBody::textBody):
+ (WebCore::FetchBody::urlSearchParamsBody):
+ * bindings/generic/IDLTypes.h:
+ * dom/ExceptionOr.h:
+ (WebCore::ExceptionOr<ReturnType>::hasException):
+ (WebCore::ExceptionOr<ReturnType>::releaseException):
+ (WebCore::ExceptionOr<ReturnType>::releaseReturnValue):
+ * dom/MessageEvent.cpp:
+ (WebCore::MessageEvent::source):
+ * dom/MessageEvent.h:
+ * dom/Node.cpp:
+ (WebCore::nodeSetPreTransformedFromNodeOrStringVector):
+ (WebCore::Node::convertNodesOrStringsIntoNode):
+ * dom/Node.h:
+ * html/HTMLOptionsCollection.h:
+ * html/HTMLSelectElement.cpp:
+ (WebCore::HTMLSelectElement::add):
+ * html/HTMLSelectElement.h:
+ * html/track/TrackEvent.cpp:
+ (WebCore::TrackEvent::TrackEvent):
+ * html/track/TrackEvent.h:
+
</ins><span class="cx"> 2016-10-18 Chris Dumez <cdumez@apple.com>
</span><span class="cx">
</span><span class="cx"> Unreviewed, rebaseline bindings tests after Sam's r207505.
</span></span></pre></div>
<a id="trunkSourceWebCoreModulesfetchFetchBodyh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/Modules/fetch/FetchBody.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/Modules/fetch/FetchBody.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/Modules/fetch/FetchBody.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -65,12 +65,12 @@
</span><span class="cx"> void consumeAsStream(FetchBodyOwner&, FetchResponseSource&);
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- bool isBlob() const { return std::experimental::holds_alternative<Ref<const Blob>>(m_data); }
- bool isFormData() const { return std::experimental::holds_alternative<Ref<FormData>>(m_data); }
- bool isArrayBuffer() const { return std::experimental::holds_alternative<Ref<const ArrayBuffer>>(m_data); }
- bool isArrayBufferView() const { return std::experimental::holds_alternative<Ref<const ArrayBufferView>>(m_data); }
- bool isURLSearchParams() const { return std::experimental::holds_alternative<Ref<const URLSearchParams>>(m_data); }
- bool isText() const { return std::experimental::holds_alternative<String>(m_data); }
</del><ins>+ bool isBlob() const { return WTF::holds_alternative<Ref<const Blob>>(m_data); }
+ bool isFormData() const { return WTF::holds_alternative<Ref<FormData>>(m_data); }
+ bool isArrayBuffer() const { return WTF::holds_alternative<Ref<const ArrayBuffer>>(m_data); }
+ bool isArrayBufferView() const { return WTF::holds_alternative<Ref<const ArrayBufferView>>(m_data); }
+ bool isURLSearchParams() const { return WTF::holds_alternative<Ref<const URLSearchParams>>(m_data); }
+ bool isText() const { return WTF::holds_alternative<String>(m_data); }
</ins><span class="cx">
</span><span class="cx"> static Optional<FetchBody> extract(ScriptExecutionContext&, JSC::ExecState&, JSC::JSValue, String&);
</span><span class="cx"> static FetchBody loadingBody() { return { }; }
</span><span class="lines">@@ -104,16 +104,16 @@
</span><span class="cx"> void consumeText(Ref<DeferredPromise>&&, const String&);
</span><span class="cx"> void consumeBlob(FetchBodyOwner&, Ref<DeferredPromise>&&);
</span><span class="cx">
</span><del>- const Blob& blobBody() const { return std::experimental::get<Ref<const Blob>>(m_data).get(); }
- FormData& formDataBody() { return std::experimental::get<Ref<FormData>>(m_data).get(); }
- const FormData& formDataBody() const { return std::experimental::get<Ref<FormData>>(m_data).get(); }
- const ArrayBuffer& arrayBufferBody() const { return std::experimental::get<Ref<const ArrayBuffer>>(m_data).get(); }
- const ArrayBufferView& arrayBufferViewBody() const { return std::experimental::get<Ref<const ArrayBufferView>>(m_data).get(); }
- String& textBody() { return std::experimental::get<String>(m_data); }
- const String& textBody() const { return std::experimental::get<String>(m_data); }
- const URLSearchParams& urlSearchParamsBody() const { return std::experimental::get<Ref<const URLSearchParams>>(m_data).get(); }
</del><ins>+ const Blob& blobBody() const { return WTF::get<Ref<const Blob>>(m_data).get(); }
+ FormData& formDataBody() { return WTF::get<Ref<FormData>>(m_data).get(); }
+ const FormData& formDataBody() const { return WTF::get<Ref<FormData>>(m_data).get(); }
+ const ArrayBuffer& arrayBufferBody() const { return WTF::get<Ref<const ArrayBuffer>>(m_data).get(); }
+ const ArrayBufferView& arrayBufferViewBody() const { return WTF::get<Ref<const ArrayBufferView>>(m_data).get(); }
+ String& textBody() { return WTF::get<String>(m_data); }
+ const String& textBody() const { return WTF::get<String>(m_data); }
+ const URLSearchParams& urlSearchParamsBody() const { return WTF::get<Ref<const URLSearchParams>>(m_data).get(); }
</ins><span class="cx">
</span><del>- std::experimental::variant<std::nullptr_t, Ref<const Blob>, Ref<FormData>, Ref<const ArrayBuffer>, Ref<const ArrayBufferView>, Ref<const URLSearchParams>, String> m_data { nullptr };
</del><ins>+ Variant<std::nullptr_t, Ref<const Blob>, Ref<FormData>, Ref<const ArrayBuffer>, Ref<const ArrayBufferView>, Ref<const URLSearchParams>, String> m_data { nullptr };
</ins><span class="cx">
</span><span class="cx"> FetchBodyConsumer m_consumer { FetchBodyConsumer::Type::None };
</span><span class="cx"> RefPtr<DeferredPromise> m_consumePromise;
</span></span></pre></div>
<a id="trunkSourceWebCorebindingsgenericIDLTypesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/bindings/generic/IDLTypes.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/bindings/generic/IDLTypes.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/bindings/generic/IDLTypes.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -115,7 +115,7 @@
</span><span class="cx"> struct IDLDOMException : IDLUnsupportedType { };
</span><span class="cx">
</span><span class="cx"> template<typename... Ts>
</span><del>-struct IDLUnion : IDLType<std::experimental::variant<typename Ts::ImplementationType...>> {
</del><ins>+struct IDLUnion : IDLType<Variant<typename Ts::ImplementationType...>> {
</ins><span class="cx"> using TypeList = brigand::list<Ts...>;
</span><span class="cx"> };
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCoredomExceptionOrh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/ExceptionOr.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/ExceptionOr.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/dom/ExceptionOr.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -43,7 +43,7 @@
</span><span class="cx"> ReturnType&& releaseReturnValue();
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- std::experimental::variant<Exception, ReturnType> m_value;
</del><ins>+ Variant<Exception, ReturnType> m_value;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> template<> class ExceptionOr<void> {
</span><span class="lines">@@ -75,17 +75,17 @@
</span><span class="cx">
</span><span class="cx"> template<typename ReturnType> inline bool ExceptionOr<ReturnType>::hasException() const
</span><span class="cx"> {
</span><del>- return std::experimental::holds_alternative<Exception>(m_value);
</del><ins>+ return WTF::holds_alternative<Exception>(m_value);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ReturnType> inline Exception&& ExceptionOr<ReturnType>::releaseException()
</span><span class="cx"> {
</span><del>- return std::experimental::get<Exception>(WTFMove(m_value));
</del><ins>+ return WTF::get<Exception>(WTFMove(m_value));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template<typename ReturnType> inline ReturnType&& ExceptionOr<ReturnType>::releaseReturnValue()
</span><span class="cx"> {
</span><del>- return std::experimental::get<ReturnType>(WTFMove(m_value));
</del><ins>+ return WTF::get<ReturnType>(WTFMove(m_value));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline ExceptionOr<void>::ExceptionOr(Exception&& exception)
</span></span></pre></div>
<a id="trunkSourceWebCoredomMessageEventcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/MessageEvent.cpp (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/MessageEvent.cpp 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/dom/MessageEvent.cpp 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -177,7 +177,7 @@
</span><span class="cx"> [](const RefPtr<MessagePort>& messagePort) -> EventTarget* { return const_cast<EventTarget*>(static_cast<const EventTarget*>(messagePort.get())); }
</span><span class="cx"> );
</span><span class="cx">
</span><del>- return std::experimental::visit(visitor, m_source.value());
</del><ins>+ return WTF::visit(visitor, m_source.value());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<SerializedScriptValue> MessageEvent::trySerializeData(ExecState* exec)
</span></span></pre></div>
<a id="trunkSourceWebCoredomMessageEventh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/MessageEvent.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/MessageEvent.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/dom/MessageEvent.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -38,7 +38,7 @@
</span><span class="cx">
</span><span class="cx"> class Blob;
</span><span class="cx">
</span><del>-using MessageEventSource = std::experimental::variant<RefPtr<DOMWindow>, RefPtr<MessagePort>>;
</del><ins>+using MessageEventSource = Variant<RefPtr<DOMWindow>, RefPtr<MessagePort>>;
</ins><span class="cx">
</span><span class="cx"> class MessageEvent final : public Event {
</span><span class="cx"> public:
</span></span></pre></div>
<a id="trunkSourceWebCoredomNodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Node.cpp (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Node.cpp 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/dom/Node.cpp 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -445,7 +445,7 @@
</span><span class="cx"> );
</span><span class="cx">
</span><span class="cx"> for (const auto& variant : vector)
</span><del>- std::experimental::visit(visitor, variant);
</del><ins>+ WTF::visit(visitor, variant);
</ins><span class="cx">
</span><span class="cx"> return nodeSet;
</span><span class="cx"> }
</span><span class="lines">@@ -482,7 +482,7 @@
</span><span class="cx"> );
</span><span class="cx">
</span><span class="cx"> for (auto& variant : nodeOrStringVector)
</span><del>- std::experimental::visit(visitor, variant);
</del><ins>+ WTF::visit(visitor, variant);
</ins><span class="cx">
</span><span class="cx"> if (nodes.size() == 1)
</span><span class="cx"> return WTFMove(nodes.first());
</span></span></pre></div>
<a id="trunkSourceWebCoredomNodeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Node.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Node.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/dom/Node.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -62,7 +62,7 @@
</span><span class="cx"> class TouchEvent;
</span><span class="cx"> class UIRequestEvent;
</span><span class="cx">
</span><del>-using NodeOrString = std::experimental::variant<RefPtr<Node>, String>;
</del><ins>+using NodeOrString = Variant<RefPtr<Node>, String>;
</ins><span class="cx">
</span><span class="cx"> class NodeRareDataBase {
</span><span class="cx"> public:
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlHTMLOptionsCollectionh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/HTMLOptionsCollection.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/HTMLOptionsCollection.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/html/HTMLOptionsCollection.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -41,8 +41,8 @@
</span><span class="cx"> HTMLOptionElement* item(unsigned offset) const final;
</span><span class="cx"> HTMLOptionElement* namedItem(const AtomicString& name) const final;
</span><span class="cx">
</span><del>- using OptionOrOptGroupElement = std::experimental::variant<RefPtr<HTMLOptionElement>, RefPtr<HTMLOptGroupElement>>;
- using HTMLElementOrInt = std::experimental::variant<RefPtr<HTMLElement>, int>;
</del><ins>+ using OptionOrOptGroupElement = Variant<RefPtr<HTMLOptionElement>, RefPtr<HTMLOptGroupElement>>;
+ using HTMLElementOrInt = Variant<RefPtr<HTMLElement>, int>;
</ins><span class="cx"> WEBCORE_EXPORT ExceptionOr<void> add(const OptionOrOptGroupElement&, Optional<HTMLElementOrInt> before);
</span><span class="cx"> WEBCORE_EXPORT void remove(int index);
</span><span class="cx"> void remove(HTMLOptionElement&);
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlHTMLSelectElementcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/HTMLSelectElement.cpp (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/HTMLSelectElement.cpp 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/html/HTMLSelectElement.cpp 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -230,9 +230,9 @@
</span><span class="cx"> [this](int index) -> HTMLElement* { return item(index); }
</span><span class="cx"> );
</span><span class="cx">
</span><del>- beforeElement = std::experimental::visit(visitor, before.value());
</del><ins>+ beforeElement = WTF::visit(visitor, before.value());
</ins><span class="cx"> }
</span><del>- HTMLElement& toInsert = std::experimental::visit([](const auto& htmlElement) -> HTMLElement& {
</del><ins>+ HTMLElement& toInsert = WTF::visit([](const auto& htmlElement) -> HTMLElement& {
</ins><span class="cx"> return *htmlElement;
</span><span class="cx"> }, element);
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlHTMLSelectElementh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/HTMLSelectElement.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/HTMLSelectElement.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/html/HTMLSelectElement.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -51,8 +51,8 @@
</span><span class="cx">
</span><span class="cx"> bool usesMenuList() const;
</span><span class="cx">
</span><del>- using OptionOrOptGroupElement = std::experimental::variant<RefPtr<HTMLOptionElement>, RefPtr<HTMLOptGroupElement>>;
- using HTMLElementOrInt = std::experimental::variant<RefPtr<HTMLElement>, int>;
</del><ins>+ using OptionOrOptGroupElement = Variant<RefPtr<HTMLOptionElement>, RefPtr<HTMLOptGroupElement>>;
+ using HTMLElementOrInt = Variant<RefPtr<HTMLElement>, int>;
</ins><span class="cx"> WEBCORE_EXPORT ExceptionOr<void> add(const OptionOrOptGroupElement&, Optional<HTMLElementOrInt> before);
</span><span class="cx">
</span><span class="cx"> using Node::remove;
</span></span></pre></div>
<a id="trunkSourceWebCorehtmltrackTrackEventcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/track/TrackEvent.cpp (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/track/TrackEvent.cpp 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/html/track/TrackEvent.cpp 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -43,7 +43,7 @@
</span><span class="cx"> : Event(type, initializer, isTrusted)
</span><span class="cx"> {
</span><span class="cx"> if (initializer.track) {
</span><del>- m_track = std::experimental::visit([](const auto& trackbase) -> TrackBase* {
</del><ins>+ m_track = WTF::visit([](const auto& trackbase) -> TrackBase* {
</ins><span class="cx"> return trackbase.get();
</span><span class="cx"> }, *initializer.track);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorehtmltrackTrackEventh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/track/TrackEvent.h (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/track/TrackEvent.h 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebCore/html/track/TrackEvent.h 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -44,7 +44,7 @@
</span><span class="cx"> return adoptRef(*new TrackEvent(type, canBubble, cancelable, WTFMove(track)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- using TrackEventTrack = std::experimental::variant<RefPtr<VideoTrack>, RefPtr<AudioTrack>, RefPtr<TextTrack>>;
</del><ins>+ using TrackEventTrack = Variant<RefPtr<VideoTrack>, RefPtr<AudioTrack>, RefPtr<TextTrack>>;
</ins><span class="cx">
</span><span class="cx"> struct Init : public EventInit {
</span><span class="cx"> Optional<TrackEventTrack> track;
</span></span></pre></div>
<a id="trunkSourceWebKitmacChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/mac/ChangeLog (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/mac/ChangeLog 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebKit/mac/ChangeLog 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -1,3 +1,16 @@
</span><ins>+2016-10-18 Sam Weinig <sam@webkit.org>
+
+ Replace std::experimental::variant with WTF::Variant (or similar)
+ https://bugs.webkit.org/show_bug.cgi?id=163626
+
+ Reviewed by Chris Dumez.
+
+ Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
+ into the WTF namespace.
+
+ * DOM/DOMHTMLSelectElement.mm:
+ (-[DOMHTMLSelectElement add:before:]):
+
</ins><span class="cx"> 2016-10-18 Simon Fraser <simon.fraser@apple.com>
</span><span class="cx">
</span><span class="cx"> Add a MiniBrowser menu item to apply page scale in WK1 and WK2
</span></span></pre></div>
<a id="trunkSourceWebKitmacDOMDOMHTMLSelectElementmm"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/mac/DOM/DOMHTMLSelectElement.mm (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/mac/DOM/DOMHTMLSelectElement.mm 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Source/WebKit/mac/DOM/DOMHTMLSelectElement.mm 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -185,7 +185,7 @@
</span><span class="cx"> raiseTypeErrorException();
</span><span class="cx">
</span><span class="cx"> auto& coreElement = *core(element);
</span><del>- std::experimental::variant<RefPtr<WebCore::HTMLOptionElement>, RefPtr<WebCore::HTMLOptGroupElement>> variantElement;
</del><ins>+ Variant<RefPtr<WebCore::HTMLOptionElement>, RefPtr<WebCore::HTMLOptGroupElement>> variantElement;
</ins><span class="cx"> if (is<WebCore::HTMLOptionElement>(coreElement))
</span><span class="cx"> variantElement = &downcast<WebCore::HTMLOptionElement>(coreElement);
</span><span class="cx"> else if (is<WebCore::HTMLOptGroupElement>(coreElement))
</span></span></pre></div>
<a id="trunkToolsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Tools/ChangeLog (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/ChangeLog 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Tools/ChangeLog 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -1,3 +1,16 @@
</span><ins>+2016-10-18 Sam Weinig <sam@webkit.org>
+
+ Replace std::experimental::variant with WTF::Variant (or similar)
+ https://bugs.webkit.org/show_bug.cgi?id=163626
+
+ Reviewed by Chris Dumez.
+
+ Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
+ into the WTF namespace.
+
+ * TestWebKitAPI/Tests/WTF/Variant.cpp:
+ (TestWebKitAPI::TEST):
+
</ins><span class="cx"> 2016-10-18 Simon Fraser <simon.fraser@apple.com>
</span><span class="cx">
</span><span class="cx"> Add a MiniBrowser menu item to apply page scale in WK1 and WK2
</span></span></pre></div>
<a id="trunkToolsTestWebKitAPITestsWTFVariantcpp"></a>
<div class="modfile"><h4>Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp (207516 => 207517)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp 2016-10-19 02:33:49 UTC (rev 207516)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp 2016-10-19 02:43:44 UTC (rev 207517)
</span><span class="lines">@@ -37,9 +37,9 @@
</span><span class="cx">
</span><span class="cx"> TEST(WTF_Variant, Initial)
</span><span class="cx"> {
</span><del>- std::experimental::variant<int, double> v1;
</del><ins>+ Variant<int, double> v1;
</ins><span class="cx"> EXPECT_TRUE(v1.index() == 0);
</span><del>- EXPECT_TRUE(std::experimental::get<int>(v1) == 0);
</del><ins>+ EXPECT_TRUE(WTF::get<int>(v1) == 0);
</ins><span class="cx">
</span><span class="cx"> struct T {
</span><span class="cx"> T() : value(15) { }
</span><span class="lines">@@ -46,28 +46,28 @@
</span><span class="cx"> int value;
</span><span class="cx"> };
</span><span class="cx">
</span><del>- std::experimental::variant<T, int> v2;
</del><ins>+ Variant<T, int> v2;
</ins><span class="cx"> EXPECT_TRUE(v2.index() == 0);
</span><del>- EXPECT_TRUE(std::experimental::get<T>(v2).value == 15);
</del><ins>+ EXPECT_TRUE(WTF::get<T>(v2).value == 15);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> TEST(WTF_Variant, Basic)
</span><span class="cx"> {
</span><del>- std::experimental::variant<int, double> variant = 1;
</del><ins>+ Variant<int, double> variant = 1;
</ins><span class="cx"> EXPECT_TRUE(variant.index() == 0);
</span><del>- EXPECT_TRUE(std::experimental::get<int>(variant) == 1);
- EXPECT_TRUE(*std::experimental::get_if<int>(variant) == 1);
- EXPECT_TRUE(std::experimental::get_if<double>(variant) == nullptr);
- EXPECT_TRUE(std::experimental::holds_alternative<int>(variant));
- EXPECT_FALSE(std::experimental::holds_alternative<double>(variant));
</del><ins>+ EXPECT_TRUE(WTF::get<int>(variant) == 1);
+ EXPECT_TRUE(*WTF::get_if<int>(variant) == 1);
+ EXPECT_TRUE(WTF::get_if<double>(variant) == nullptr);
+ EXPECT_TRUE(WTF::holds_alternative<int>(variant));
+ EXPECT_FALSE(WTF::holds_alternative<double>(variant));
</ins><span class="cx">
</span><span class="cx"> variant = 1.0;
</span><span class="cx"> EXPECT_TRUE(variant.index() == 1);
</span><del>- EXPECT_TRUE(std::experimental::get<double>(variant) == 1);
- EXPECT_TRUE(*std::experimental::get_if<double>(variant) == 1.0);
- EXPECT_TRUE(std::experimental::get_if<int>(variant) == nullptr);
- EXPECT_TRUE(std::experimental::holds_alternative<double>(variant));
- EXPECT_FALSE(std::experimental::holds_alternative<int>(variant));
</del><ins>+ EXPECT_TRUE(WTF::get<double>(variant) == 1);
+ EXPECT_TRUE(*WTF::get_if<double>(variant) == 1.0);
+ EXPECT_TRUE(WTF::get_if<int>(variant) == nullptr);
+ EXPECT_TRUE(WTF::holds_alternative<double>(variant));
+ EXPECT_FALSE(WTF::holds_alternative<int>(variant));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> TEST(WTF_Variant, BasicVisitor)
</span><span class="lines">@@ -94,18 +94,18 @@
</span><span class="cx">
</span><span class="cx"> Type type = Type::None;
</span><span class="cx">
</span><del>- std::experimental::variant<int, float, String> variant = 8;
- std::experimental::visit(Visitor(type), variant);
</del><ins>+ Variant<int, float, String> variant = 8;
+ WTF::visit(Visitor(type), variant);
</ins><span class="cx"> EXPECT_TRUE(Type::Int == type);
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> variant = 1.0f;
</span><del>- std::experimental::visit(Visitor(type), variant);
</del><ins>+ WTF::visit(Visitor(type), variant);
</ins><span class="cx"> EXPECT_TRUE(Type::Float == type);
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> variant = "hello";
</span><del>- std::experimental::visit(Visitor(type), variant);
</del><ins>+ WTF::visit(Visitor(type), variant);
</ins><span class="cx"> EXPECT_TRUE(Type::String == type);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -126,18 +126,18 @@
</span><span class="cx"> [&](String) { type = Type::String; }
</span><span class="cx"> );
</span><span class="cx">
</span><del>- std::experimental::variant<int, float, String> variant = 8;
- std::experimental::visit(visitor, variant);
</del><ins>+ Variant<int, float, String> variant = 8;
+ WTF::visit(visitor, variant);
</ins><span class="cx"> EXPECT_TRUE(Type::Int == type);
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> variant = 1.0f;
</span><del>- std::experimental::visit(visitor, variant);
</del><ins>+ WTF::visit(visitor, variant);
</ins><span class="cx"> EXPECT_TRUE(Type::Float == type);
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> variant = "hello";
</span><del>- std::experimental::visit(visitor, variant);
</del><ins>+ WTF::visit(visitor, variant);
</ins><span class="cx"> EXPECT_TRUE(Type::String == type);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -147,7 +147,7 @@
</span><span class="cx">
</span><span class="cx"> {
</span><span class="cx"> auto uniquePtr = std::make_unique<ConstructorDestructorCounter>();
</span><del>- std::experimental::variant<std::unique_ptr<ConstructorDestructorCounter>, int> v = WTFMove(uniquePtr);
</del><ins>+ Variant<std::unique_ptr<ConstructorDestructorCounter>, int> v = WTFMove(uniquePtr);
</ins><span class="cx">
</span><span class="cx"> EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount);
</span><span class="cx"> EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount);
</span><span class="lines">@@ -162,7 +162,7 @@
</span><span class="cx"> {
</span><span class="cx"> RefLogger a("a");
</span><span class="cx"> RefPtr<RefLogger> ref(&a);
</span><del>- std::experimental::variant<RefPtr<RefLogger>, int> v = ref;
</del><ins>+ Variant<RefPtr<RefLogger>, int> v = ref;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ASSERT_STREQ("ref(a) ref(a) deref(a) deref(a) ", takeLogStr().c_str());
</span><span class="lines">@@ -170,7 +170,7 @@
</span><span class="cx"> {
</span><span class="cx"> RefLogger a("a");
</span><span class="cx"> RefPtr<RefLogger> ref(&a);
</span><del>- std::experimental::variant<RefPtr<RefLogger>, int> v = WTFMove(ref);
</del><ins>+ Variant<RefPtr<RefLogger>, int> v = WTFMove(ref);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());
</span><span class="lines">@@ -181,7 +181,7 @@
</span><span class="cx"> {
</span><span class="cx"> RefLogger a("a");
</span><span class="cx"> Ref<RefLogger> ref(a);
</span><del>- std::experimental::variant<Ref<RefLogger>, int> v = WTFMove(ref);
</del><ins>+ Variant<Ref<RefLogger>, int> v = WTFMove(ref);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());
</span></span></pre>
</div>
</div>
</body>
</html>