react-native-windows 0.0.0-canary.581 → 0.0.0-canary.583

package/Directory.Build.props

@@ -16,8 +16,8 @@
     -->
     <EnableSourceLink Condition="'$(EnableSourceLink)' == ''">false</EnableSourceLink>
     <!-- When bumping the Folly version, be sure to bump the git hash of that version's commit and build Folly.vcxproj (to update its cgmanifest.json) too. -->
-    <FollyVersion>2021.07.22.00</FollyVersion>
-    <FollyCommitHash>4baba28200d7446c870e96f3cdbeb492f54625d0</FollyCommitHash>
+    <FollyVersion>2022.11.07.00</FollyVersion>
+    <FollyCommitHash>2aa28128d1f7a04b41521367f0b615f782814089</FollyCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
     <FmtVersion>8.0.0</FmtVersion>
     <FmtCommitHash>9e8b86fd2d9806672cc73133d21780dd182bfd24</FmtCommitHash>

package/Folly/Folly.vcxproj

@@ -51,10 +51,10 @@
     <ClCompile Include="$(FollyDir)\folly\portability\Unistd.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="$(FollyDir)\folly\system\AtFork.cpp" />
     <ClCompile Include="$(FollyDir)\folly\system\ThreadId.cpp" />
     <ClCompile Include="$(FollyDir)\folly\lang\SafeAssert.cpp" />
     <ClCompile Include="$(FollyDir)\folly\lang\ToAscii.cpp" />
-    <ClCompile Include="$(FollyDir)\folly\lang\Assume.cpp" />
     <ClCompile Include="$(FollyDir)\folly\json_pointer.cpp" />
     <ClCompile Include="$(FollyDir)\folly\Format.cpp" />
     <ClCompile Include="$(FollyDir)\folly\String.cpp" />

package/Folly/Folly.vcxproj.filters

@@ -39,9 +39,6 @@
     <ClCompile Include="$(FollyDir)\folly\lang\ToAscii.cpp">
       <Filter>Source Files\lang</Filter>
     </ClCompile>
-    <ClCompile Include="$(FollyDir)\folly\lang\Assume.cpp">
-      <Filter>Source Files\lang</Filter>
-    </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\Conv.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>

package/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
 #include <folly/Conv.h>
 #include <folly/Format.h>
 #include <folly/Likely.h>
+#include <folly/Portability.h>
 #include <folly/detail/Iterators.h>
 #include <folly/lang/Exception.h>
 
@@ -87,38 +88,41 @@ struct hash<::folly::dynamic> {
 } // namespace std
 
 //////////////////////////////////////////////////////////////////////
-
+/* clang-format off */
 // This is a higher-order preprocessor macro to aid going from runtime
 // types to the compile time type system.
-#define FB_DYNAMIC_APPLY(type, apply) \
-  do {                                \
-    switch ((type)) {                 \
-      case NULLT:                     \
-        apply(std::nullptr_t);        \
-        break;                        \
-      case ARRAY:                     \
-        apply(Array);                 \
-        break;                        \
-      case BOOL:                      \
-        apply(bool);                  \
-        break;                        \
-      case DOUBLE:                    \
-        apply(double);                \
-        break;                        \
-      case INT64:                     \
-        apply(int64_t);               \
-        break;                        \
-      case OBJECT:                    \
-        apply(ObjectImpl);            \
-        break;                        \
-      case STRING:                    \
-        apply(std::string);           \
-        break;                        \
-      default:                        \
-        abort();                      \
-    }                                 \
-  } while (0)
 
+#define FB_DYNAMIC_APPLY(type, apply)                                             \
+  do {                                                                            \
+    FOLLY_PUSH_WARNING FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")    \
+    switch ((type)) {                                                             \
+      case NULLT:                                                                 \
+        apply(std::nullptr_t);                                                    \
+        break;                                                                    \
+      case ARRAY:                                                                 \
+        apply(Array);                                                             \
+        break;                                                                    \
+      case BOOL:                                                                  \
+        apply(bool);                                                              \
+        break;                                                                    \
+      case DOUBLE:                                                                \
+        apply(double);                                                            \
+        break;                                                                    \
+      case INT64:                                                                 \
+        apply(int64_t);                                                           \
+        break;                                                                    \
+      case OBJECT:                                                                \
+        apply(ObjectImpl);                                                        \
+        break;                                                                    \
+      case STRING:                                                                \
+        apply(std::string);                                                       \
+        break;                                                                    \
+      default:                                                                    \
+        abort();                                                                  \
+    }                                                                             \
+    FOLLY_POP_WARNING                                                             \
+  } while (0)
+/* clang-format on */
 //////////////////////////////////////////////////////////////////////
 
 namespace folly {
@@ -235,6 +239,7 @@ struct dynamic::item_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::iterator,
       std::pair<dynamic const, dynamic>,
       std::forward_iterator_tag>;
+  item_iterator() = default;
   /* implicit */ item_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
 
   using object_type = dynamic::ObjectImpl;
@@ -250,6 +255,7 @@ struct dynamic::value_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::iterator,
       dynamic,
       std::forward_iterator_tag>;
+  value_iterator() = default;
   /* implicit */ value_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
 
   using object_type = dynamic::ObjectImpl;
@@ -268,6 +274,7 @@ struct dynamic::const_item_iterator
       dynamic::ObjectImpl::const_iterator,
       std::pair<dynamic const, dynamic> const,
       std::forward_iterator_tag>;
+  const_item_iterator() = default;
   /* implicit */ const_item_iterator(dynamic::ObjectImpl::const_iterator b)
       : Super(b) {}
   /* implicit */ const_item_iterator(const_item_iterator const& i)
@@ -287,6 +294,7 @@ struct dynamic::const_key_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::const_iterator,
       dynamic const,
       std::forward_iterator_tag>;
+  const_key_iterator() = default;
   /* implicit */ const_key_iterator(dynamic::ObjectImpl::const_iterator b)
       : Super(b) {}
 
@@ -305,6 +313,7 @@ struct dynamic::const_value_iterator : detail::IteratorAdaptor<
       dynamic::ObjectImpl::const_iterator,
       dynamic const,
       std::forward_iterator_tag>;
+  const_value_iterator() = default;
   /* implicit */ const_value_iterator(dynamic::ObjectImpl::const_iterator b)
       : Super(b) {}
   /* implicit */ const_value_iterator(value_iterator i) : Super(i.base()) {}
@@ -348,14 +357,6 @@ inline dynamic::dynamic(ObjectMaker&& maker) : type_(OBJECT) {
       ObjectImpl(std::move(*maker.val_.getAddress<ObjectImpl>()));
 }
 
-inline dynamic::dynamic(dynamic const& o) : type_(NULLT) {
-  *this = o;
-}
-
-inline dynamic::dynamic(dynamic&& o) noexcept : type_(NULLT) {
-  *this = std::move(o);
-}
-
 inline dynamic::~dynamic() noexcept {
   destroy();
 }
@@ -558,7 +559,7 @@ struct dynamic::CompareOp<dynamic::ObjectImpl> {
 template <>
 struct dynamic::CompareOp<std::nullptr_t> {
   static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
-    return true;
+    return false;
   }
 };
 
@@ -834,6 +835,20 @@ inline dynamic::IfNotIterator<K, void> dynamic::insert(K&& key, V&& val) {
   obj[std::forward<K>(key)] = std::forward<V>(val);
 }
 
+template <class... Args>
+inline std::pair<dynamic::item_iterator, bool> dynamic::emplace(
+    Args&&... args) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(std::forward<Args>(args)...);
+}
+
+template <class K, class... Args>
+inline std::pair<dynamic::item_iterator, bool> dynamic::try_emplace(
+    K&& key, Args&&... args) {
+  auto& obj = get<ObjectImpl>();
+  return obj.try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
+}
+
 template <class T>
 inline dynamic::iterator dynamic::insert(const_iterator pos, T&& value) {
   auto& arr = get<Array>();
@@ -993,6 +1008,8 @@ FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::ObjectImpl, dynamic::OBJECT)
 
 template <class T>
 T dynamic::asImpl() const {
+  FOLLY_PUSH_WARNING
+  FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")
   switch (type()) {
     case INT64:
       return to<T>(*get_nothrow<int64_t>());
@@ -1008,10 +1025,10 @@ T dynamic::asImpl() const {
     default:
       throw_exception<TypeError>("int/double/bool/string", type());
   }
+  FOLLY_POP_WARNING
 }
 
 // Return a T* to our type, or null if we're not that type.
-// clang-format off
 template <class T>
 T* dynamic::get_nothrow() & noexcept {
   if (type_ != TypeInfo<T>::type) {
@@ -1019,7 +1036,6 @@ T* dynamic::get_nothrow() & noexcept {
   }
   return getAddress<T>();
 }
-// clang-format on
 
 template <class T>
 T const* dynamic::get_nothrow() const& noexcept {
@@ -1216,7 +1232,7 @@ const_dynamic_view::descend_unchecked_(Key const& key) const noexcept {
     if /* constexpr */ (!std::is_integral<Key>::value) {
       return nullptr;
     }
-    if (key < 0 || key >= parray->size()) {
+    if (key < 0 || folly::to_unsigned(key) >= parray->size()) {
       return nullptr;
     }
     return &(*parray)[size_t(key)];
@@ -1327,7 +1343,7 @@ inline std::string dynamic_view::move_string_or(Stringish&& val) {
 
 //////////////////////////////////////////////////////////////////////
 
-// Secialization of FormatValue so dynamic objects can be formatted
+// Specialization of FormatValue so dynamic objects can be formatted
 template <>
 class FormatValue<dynamic> {
  public:

package/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <utility>
+
+#include <folly/CppAttributes.h>
+#include <folly/Portability.h>
+#include <folly/Preprocessor.h>
+#include <folly/lang/CArray.h>
+
+#define FOLLY_DETAIL_SAFE_CHECK_IMPL(d, p, u, expr, ...)                  \
+  do {                                                                    \
+    if ((!d || ::folly::kIsDebug || ::folly::kIsSanitize) &&              \
+        !static_cast<bool>(expr)) {                                       \
+      static constexpr auto __folly_detail_safe_assert_fun = __func__;    \
+      static constexpr ::folly::detail::safe_assert_arg                   \
+          __folly_detail_safe_assert_arg{                                 \
+              u ? nullptr : #expr,                                        \
+              __FILE__,                                                   \
+              FOLLY_PP_CONSTINIT_LINE_UNSIGNED,                           \
+              __folly_detail_safe_assert_fun,                             \
+              ::folly::detail::safe_assert_msg_types<                     \
+                  decltype(::folly::detail::safe_assert_msg_types_seq_of( \
+                      __VA_ARGS__))>::value.data};                        \
+      constexpr ::folly::detail::safe_assert_terminate_w<p>               \
+          __folly_detail_safe_assert_terminate_w{                         \
+              __folly_detail_safe_assert_arg};                            \
+      __folly_detail_safe_assert_terminate_w(__VA_ARGS__);                \
+    }                                                                     \
+  } while (false)
+
+//  FOLLY_SAFE_CHECK
+//
+//  If expr evaluates to false after explicit conversion to bool, prints context
+//  information to stderr and aborts. Context information includes the remaining
+//  variadic arguments.
+//
+//  When the remaining variadic arguments are printed to stderr, there are two
+//  supported types after implicit conversions: char const* and uint64_t. This
+//  facility is intentionally not extensible to custom types.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_CHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_DCHECK
+//
+//  Equivalent to FOLLY_SAFE_CHECK when in debug or instrumented builds, where
+//  debug builds are signalled by NDEBUG being undefined and instrumented builds
+//  include sanitizer builds.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_PCHECK
+//
+//  Equivalent to FOLLY_SAFE_CHECK but includes errno in the contextual
+//  information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_PCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 1, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_DPCHECK
+//
+//  Equivalent to FOLLY_SAFE_DCHECK but includes errno in the contextual
+//  information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DPCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 1, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_FATAL
+//
+//  Equivalent to FOLLY_SAFE_CHECK(false, ...) but excludes any failing
+//  expression from the contextual information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_FATAL(...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 1, false, __VA_ARGS__)
+
+//  FOLLY_SAFE_DFATAL
+//
+//  Equivalent to FOLLY_SAFE_DCHECK(false, ...) but excludes any failing
+//  expression from the contextual information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DFATAL(...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 1, false, __VA_ARGS__)
+
+namespace folly {
+namespace detail {
+
+enum class safe_assert_msg_type : char { term, cstr, ui64 };
+
+template <safe_assert_msg_type... A>
+struct safe_assert_msg_type_s {};
+
+struct safe_assert_msg_types_one_fn {
+  template <safe_assert_msg_type A>
+  using c = std::integral_constant<safe_assert_msg_type, A>;
+  // only used in unevaluated contexts:
+  c<safe_assert_msg_type::cstr> operator()(char const*) const;
+  c<safe_assert_msg_type::ui64> operator()(uint64_t) const;
+};
+FOLLY_INLINE_VARIABLE constexpr safe_assert_msg_types_one_fn
+    safe_assert_msg_types_one{}; // a function object to prevent extensions
+
+template <typename... A>
+safe_assert_msg_type_s<decltype(safe_assert_msg_types_one((A)A{}))::value...>
+safe_assert_msg_types_seq_of(A...); // only used in unevaluated contexts
+
+template <typename>
+struct safe_assert_msg_types;
+template <safe_assert_msg_type... A>
+struct safe_assert_msg_types<safe_assert_msg_type_s<A...>> {
+  using value_type = c_array<safe_assert_msg_type, sizeof...(A) + 1>;
+  static constexpr value_type value = {{A..., safe_assert_msg_type::term}};
+};
+template <safe_assert_msg_type... A>
+constexpr
+    typename safe_assert_msg_types<safe_assert_msg_type_s<A...>>::value_type
+        safe_assert_msg_types<safe_assert_msg_type_s<A...>>::value;
+
+struct safe_assert_arg {
+  char const* expr;
+  char const* file;
+  unsigned int line;
+  char const* function;
+  safe_assert_msg_type const* msg_types;
+};
+
+struct safe_assert_msg_cast_one_fn {
+  FOLLY_ERASE auto operator()(char const* const a) const { return a; }
+  FOLLY_ERASE auto operator()(uint64_t const a) const { return a; }
+};
+FOLLY_INLINE_VARIABLE constexpr safe_assert_msg_cast_one_fn
+    safe_assert_msg_cast_one{}; // a function object to prevent extensions
+
+template <bool P>
+[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate(
+    safe_assert_arg const* arg, ...) noexcept; // the true backing function
+
+// [Win - Fixes Error C2908 explicit specialization; 'void folly::detail::safe_assert_terminate<false>(const folly::detail::safe_assert_arg *,...) noexcept' has already been instantiated 
+template <>
+[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate<0>(
+    safe_assert_arg const* arg, ...) noexcept;
+
+template <>
+[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate<1>(
+    safe_assert_arg const* arg, ...) noexcept;
+// Win]
+
+template <bool P>
+struct safe_assert_terminate_w {
+  safe_assert_arg const& arg;
+
+  FOLLY_ERASE constexpr safe_assert_terminate_w(
+      safe_assert_arg const& arg_) noexcept
+      : arg{arg_} {}
+
+  template <typename... A>
+  [[noreturn]] FOLLY_ERASE void operator()(A... a) const noexcept {
+    safe_assert_terminate<P>(&arg, safe_assert_msg_cast_one(a)...);
+  }
+};
+
+} // namespace detail
+} // namespace folly

package/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.cpp

@@ -189,7 +189,8 @@ FOLLY_ALWAYS_INLINE size_t to_ascii_size_clzll(uint64_t v) {
   }
 
   //  blog2r is approx 1 / log<2>(Base), used in log change-of-base just below
-  constexpr auto const blog2r = 8. / constexpr_log2(constexpr_pow(Base, 8));
+  constexpr auto const blog2m = constexpr_log2(constexpr_pow(Base, 8));
+  constexpr auto const blog2r = 8. / double(blog2m);
 
   //  vlogb is approx log<Base>(v) = log<2>(v) / log<2>(Base)
   auto const vlogb = vlog2 * size_t(blog2r * 256) / 256;
@@ -244,18 +245,19 @@ template <uint64_t Base, typename Alphabet>
 FOLLY_ALWAYS_INLINE void to_ascii_with_table(
     char* out, size_t size, uint64_t v) {
   using table = to_ascii_table<Base, Alphabet>;
-  auto pos = size - 2;
-  while (FOLLY_UNLIKELY(v >= Base * Base)) {
+  auto pos = size;
+  while (FOLLY_UNLIKELY(pos > 2)) {
+    pos -= 2;
     //  keep /, % together so a peephole optimization computes them together
     auto const q = v / (Base * Base);
     auto const r = v % (Base * Base);
     auto const val = table::data.data[size_t(r)];
     std::memcpy(out + pos, &val, 2);
-    pos -= 2;
     v = q;
   }
+
   auto const val = table::data.data[size_t(v)];
-  if (FOLLY_UNLIKELY(size % 2 == 0)) {
+  if (FOLLY_UNLIKELY(pos == 2)) {
     std::memcpy(out, &val, 2);
   } else {
     *out = val >> (kIsLittleEndian ? 8 : 0);

package/Folly/cgmanifest.json

@@ -6,7 +6,7 @@
                 "Type": "git",
                 "Git": {
                   "RepositoryUrl": "https://github.com/facebook/folly",
-                  "CommitHash": "4baba28200d7446c870e96f3cdbeb492f54625d0"
+                  "CommitHash": "2aa28128d1f7a04b41521367f0b615f782814089"
                 }
             },
             "DevelopmentDependency": false