Re-sync with internal repository

build/deps/github_hashes/facebook/fbthrift-rev.txt

@@ -0,0 +1 @@
+Subproject commit 02ab38972b961082010acdaab6c72628eb817303

build/deps/github_hashes/facebook/folly-rev.txt

@@ -0,0 +1 @@
+Subproject commit 25759e9e244f73f4f450b336c6905d069e406690

build/deps/github_hashes/facebook/mvfst-rev.txt

@@ -0,0 +1 @@
+Subproject commit 1724f61ccf96714f1a214841866998317a0d1d5f

build/deps/github_hashes/facebook/wangle-rev.txt

@@ -0,0 +1 @@
+Subproject commit b257d471a179bd2d448bf5ed41e0f7a73c7859ac

build/deps/github_hashes/facebookincubator/fizz-rev.txt

@@ -0,0 +1 @@
+Subproject commit 8b3f5162d1d58ae85f3d5d4ad0447dd669b92590

build/fbcode_builder/.gitignore

@@ -0,0 +1,5 @@
+# Facebook-internal CI builds don't have write permission outside of the
+# source tree, so we install all projects into this directory.
+/facebook_ci
+__pycache__/
+*.pyc

build/fbcode_builder/CMake/FBBuildOptions.cmake

@@ -0,0 +1,15 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+
+function (fb_activate_static_library_option)
+  option(USE_STATIC_DEPS_ON_UNIX
+    "If enabled, use static dependencies on unix systems. This is generally discouraged."
+    OFF
+  )
+  # Mark USE_STATIC_DEPS_ON_UNIX as an "advanced" option, since enabling it
+  # is generally discouraged.
+  mark_as_advanced(USE_STATIC_DEPS_ON_UNIX)
+
+  if(UNIX AND USE_STATIC_DEPS_ON_UNIX)
+    SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a" PARENT_SCOPE)
+  endif()
+endfunction()

build/fbcode_builder/CMake/FBCMakeParseArgs.cmake

@@ -0,0 +1,141 @@
+#
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Helper function for parsing arguments to a CMake function.
+#
+# This function is very similar to CMake's built-in cmake_parse_arguments()
+# function, with some improvements:
+# - This function correctly handles empty arguments.  (cmake_parse_arguments()
+#   ignores empty arguments.)
+# - If a multi-value argument is specified more than once, the subsequent
+#   arguments are appended to the original list rather than replacing it.  e.g.
+#   if "SOURCES" is a multi-value argument, and the argument list contains
+#   "SOURCES a b c SOURCES x y z" then the resulting value for SOURCES will be
+#   "a;b;c;x;y;z" rather than "x;y;z"
+# - This function errors out by default on unrecognized arguments.  You can
+#   pass in an extra "ALLOW_UNPARSED_ARGS" argument to make it behave like
+#   cmake_parse_arguments(), and return the unparsed arguments in a
+#   <prefix>_UNPARSED_ARGUMENTS variable instead.
+#
+# It does look like cmake_parse_arguments() handled empty arguments correctly
+# from CMake 3.0 through 3.3, but it seems like this was probably broken when
+# it was turned into a built-in function in CMake 3.4.  Here is discussion and
+# patches that fixed this behavior prior to CMake 3.0:
+# https://cmake.org/pipermail/cmake-developers/2013-November/020607.html
+#
+# The one downside to this function over the built-in cmake_parse_arguments()
+# is that I don't think we can achieve the PARSE_ARGV behavior in a non-builtin
+# function, so we can't properly handle arguments that contain ";".  CMake will
+# treat the ";" characters as list element separators, and treat it as multiple
+# separate arguments.
+#
+function(fb_cmake_parse_args PREFIX OPTIONS ONE_VALUE_ARGS MULTI_VALUE_ARGS ARGS)
+  foreach(option IN LISTS ARGN)
+    if ("${option}" STREQUAL "ALLOW_UNPARSED_ARGS")
+      set(ALLOW_UNPARSED_ARGS TRUE)
+    else()
+      message(
+        FATAL_ERROR
+        "unknown optional argument for fb_cmake_parse_args(): ${option}"
+      )
+    endif()
+  endforeach()
+
+  # Define all options as FALSE in the parent scope to start with
+  foreach(var_name IN LISTS OPTIONS)
+    set("${PREFIX}_${var_name}" "FALSE" PARENT_SCOPE)
+  endforeach()
+
+  # TODO: We aren't extremely strict about error checking for one-value
+  # arguments here.  e.g., we don't complain if a one-value argument is
+  # followed by another option/one-value/multi-value name rather than an
+  # argument.  We also don't complain if a one-value argument is the last
+  # argument and isn't followed by a value.
+
+  list(APPEND all_args ${ONE_VALUE_ARGS})
+  list(APPEND all_args ${MULTI_VALUE_ARGS})
+  set(current_variable)
+  set(unparsed_args)
+  foreach(arg IN LISTS ARGS)
+    list(FIND OPTIONS "${arg}" opt_index)
+    if("${opt_index}" EQUAL -1)
+      list(FIND all_args "${arg}" arg_index)
+      if("${arg_index}" EQUAL -1)
+        # This argument does not match an argument name,
+        # must be an argument value
+        if("${current_variable}" STREQUAL "")
+          list(APPEND unparsed_args "${arg}")
+        else()
+          # Ugh, CMake lists have a pretty fundamental flaw: they cannot
+          # distinguish between an empty list and a list with a single empty
+          # element.  We track our own SEEN_VALUES_arg setting to help
+          # distinguish this and behave properly here.
+          if ("${SEEN_${current_variable}}" AND "${${current_variable}}" STREQUAL "")
+            set("${current_variable}" ";${arg}")
+          else()
+            list(APPEND "${current_variable}" "${arg}")
+          endif()
+          set("SEEN_${current_variable}" TRUE)
+        endif()
+      else()
+        # We found a single- or multi-value argument name
+        set(current_variable "VALUES_${arg}")
+        set("SEEN_${arg}" TRUE)
+      endif()
+    else()
+      # We found an option variable
+      set("${PREFIX}_${arg}" "TRUE" PARENT_SCOPE)
+      set(current_variable)
+    endif()
+  endforeach()
+
+  foreach(arg_name IN LISTS ONE_VALUE_ARGS)
+    if(NOT "${SEEN_${arg_name}}")
+      unset("${PREFIX}_${arg_name}" PARENT_SCOPE)
+    elseif(NOT "${SEEN_VALUES_${arg_name}}")
+      # If the argument was seen but a value wasn't specified, error out.
+      # We require exactly one value to be specified.
+      message(
+        FATAL_ERROR "argument ${arg_name} was specified without a value"
+      )
+    else()
+      list(LENGTH "VALUES_${arg_name}" num_args)
+      if("${num_args}" EQUAL 0)
+        # We know an argument was specified and that we called list(APPEND).
+        # If CMake thinks the list is empty that means there is really a single
+        # empty element in the list.
+        set("${PREFIX}_${arg_name}" "" PARENT_SCOPE)
+      elseif("${num_args}" EQUAL 1)
+        list(GET "VALUES_${arg_name}" 0 arg_value)
+        set("${PREFIX}_${arg_name}" "${arg_value}" PARENT_SCOPE)
+      else()
+        message(
+          FATAL_ERROR "too many arguments specified for ${arg_name}: "
+          "${VALUES_${arg_name}}"
+        )
+      endif()
+    endif()
+  endforeach()
+
+  foreach(arg_name IN LISTS MULTI_VALUE_ARGS)
+    # If this argument name was never seen, then unset the parent scope
+    if (NOT "${SEEN_${arg_name}}")
+      unset("${PREFIX}_${arg_name}" PARENT_SCOPE)
+    else()
+      # TODO: Our caller still won't be able to distinguish between an empty
+      # list and a list with a single empty element.  We can tell which is
+      # which, but CMake lists don't make it easy to show this to our caller.
+      set("${PREFIX}_${arg_name}" "${VALUES_${arg_name}}" PARENT_SCOPE)
+    endif()
+  endforeach()
+
+  # By default we fatal out on unparsed arguments, but return them to the
+  # caller if ALLOW_UNPARSED_ARGS was specified.
+  if (DEFINED unparsed_args)
+    if ("${ALLOW_UNPARSED_ARGS}")
+      set("${PREFIX}_UNPARSED_ARGUMENTS" "${unparsed_args}" PARENT_SCOPE)
+    else()
+      message(FATAL_ERROR "unrecognized arguments: ${unparsed_args}")
+    endif()
+  endif()
+endfunction()

build/fbcode_builder/CMake/FBCompilerSettings.cmake

@@ -0,0 +1,13 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+
+# This file applies common compiler settings that are shared across
+# a number of Facebook opensource projects.
+# Please use caution and your best judgement before making changes
+# to these shared compiler settings in order to avoid accidentally
+# breaking a build in another project!
+
+if (WIN32)
+  include(FBCompilerSettingsMSVC)
+else()
+  include(FBCompilerSettingsUnix)
+endif()

build/fbcode_builder/CMake/FBCompilerSettingsMSVC.cmake

@@ -0,0 +1,11 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+
+# This file applies common compiler settings that are shared across
+# a number of Facebook opensource projects.
+# Please use caution and your best judgement before making changes
+# to these shared compiler settings in order to avoid accidentally
+# breaking a build in another project!
+
+add_compile_options(
+  /wd4250 # 'class1' : inherits 'class2::member' via dominance
+)

build/fbcode_builder/CMake/FBCompilerSettingsUnix.cmake

@@ -0,0 +1,9 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+
+# This file applies common compiler settings that are shared across
+# a number of Facebook opensource projects.
+# Please use caution and your best judgement before making changes
+# to these shared compiler settings in order to avoid accidentally
+# breaking a build in another project!
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -Wno-deprecated -Wno-deprecated-declarations")