first commit

node_modules/react-native/ReactCommon/react/debug/CMakeLists.txt

@@ -0,0 +1,26 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+file(GLOB react_debug_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_debug OBJECT ${react_debug_SRC})
+
+target_include_directories(react_debug PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_debug folly_runtime)
+
+if(ANDROID)
+  target_link_libraries(react_debug log)
+endif()
+
+target_compile_reactnative_options(react_debug PRIVATE)
+target_compile_options(react_debug PRIVATE -Wpedantic)
+if(NOT ${CMAKE_BUILD_TYPE} MATCHES Debug AND NOT REACT_NATIVE_DEBUG_OPTIMIZED)
+        target_compile_options(react_debug PUBLIC -DNDEBUG)
+endif()

node_modules/react-native/ReactCommon/react/debug/React-debug.podspec

@@ -0,0 +1,34 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-debug"
+  s.version                = version
+  s.summary                = "-"  # TODO
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("**/*.{cpp,h}", "**/*.h")
+  s.header_dir             = "react/debug"
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "DEFINES_MODULE" => "YES" }
+
+  resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_debug")
+end

node_modules/react-native/ReactCommon/react/debug/flags.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+//
+// Preprocessor flags which control whether code meant for debugging the
+// internals of React Native is included in the build. E.g. debug assertions.
+//
+// This flag is normally derived from NDEBUG, but may be set explicitly by
+// defining `REACT_NATIVE_DEBUG` or `REACT_NATIVE_PRODUCTION`.
+#if !(defined(REACT_NATIVE_DEBUG) || defined(REACT_NATIVE_PRODUCTION))
+#ifdef NDEBUG
+#define REACT_NATIVE_PRODUCTION
+#else
+#define REACT_NATIVE_DEBUG
+#endif
+#endif

node_modules/react-native/ReactCommon/react/debug/react_native_assert.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+
+// Provide a prototype to silence missing prototype warning in release
+// mode.
+extern "C" void react_native_assert_fail(
+    const char* func,
+    const char* file,
+    int line,
+    const char* expr);
+
+extern "C" void react_native_assert_fail(
+    const char* func,
+    const char* file,
+    int line,
+    const char* expr) {
+  // Print as an error so it shows up in logcat before crash...
+  __android_log_print(
+      ANDROID_LOG_ERROR,
+      "ReactNative",
+      "%s:%d: function %s: assertion failed (%s)",
+      file,
+      line,
+      func,
+      expr);
+  // ...and trigger an abort so it crashes and shows up in uploaded logs.
+  __android_log_assert(
+      nullptr,
+      "ReactNative",
+      "%s:%d: function %s: assertion failed (%s)",
+      file,
+      line,
+      func,
+      expr);
+}
+
+#endif // __ANDROID__

node_modules/react-native/ReactCommon/react/debug/react_native_assert.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// No header guards since it is legitimately possible to include this file more
+// than once with and without REACT_NATIVE_DEBUG.
+
+// react_native_assert allows us to opt-in to specific asserts on Android and
+// test before moving on. When all issues have been found, maybe we can use
+// `UNDEBUG` flag to disable NDEBUG in debug builds on Android.
+
+// Asserting is appropriate for conditions that:
+//   1. May or may not be recoverable, and
+//   2. imply there is a bug in React Native when violated.
+// For recoverable conditions that can be violated by user mistake (e.g. JS
+// code passes an unexpected prop value), consider react_native_expect instead.
+
+#pragma once
+
+#include "flags.h"
+
+#undef react_native_assert
+
+#ifndef REACT_NATIVE_DEBUG
+
+#define react_native_assert(e) ((void)0)
+
+#else // REACT_NATIVE_DEBUG
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+void react_native_assert_fail(const char *func, const char *file, int line, const char *expr);
+#ifdef __cplusplus
+}
+#endif // __cpusplus
+
+#define react_native_assert(e) ((e) ? (void)0 : react_native_assert_fail(__func__, __FILE__, __LINE__, #e))
+
+#else // __ANDROID__
+
+#include <glog/logging.h>
+#include <cassert>
+
+// For all platforms, but iOS+Xcode especially: flush logs because some might be
+// lost on iOS if an assert is hit right after this. If you are trying to debug
+// something actively and have added lots of LOG statements to track down an
+// issue, there is race between flushing the final logs and stopping execution
+// when the assert hits. Thus, if we know an assert will fail, we force flushing
+// to happen right before the assert.
+#define react_native_assert(cond)                           \
+  if (!(cond)) {                                            \
+    LOG(ERROR) << "react_native_assert failure: " << #cond; \
+    google::FlushLogFiles(google::GLOG_INFO);               \
+    assert(cond);                                           \
+  }
+
+#endif // platforms besides __ANDROID__
+
+#endif // REACT_NATIVE_DEBUG

node_modules/react-native/ReactCommon/react/debug/react_native_expect.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// No header guards since it is legitimately possible to include this file more
+// than once with and without REACT_NATIVE_DEBUG.
+
+// react_native_expect is a non-fatal counterpart of react_native_assert.
+// In debug builds, when an expectation fails, we log and move on.
+// In release builds, react_native_expect is a noop.
+
+// react_native_expect is appropriate for recoverable conditions that can be
+// violated by user mistake (e.g. JS code passes an unexpected prop value).
+// To enforce invariants that are internal to React Native, consider
+// react_native_assert (or a stronger mechanism).
+// Calling react_native_expect does NOT, by itself, guarantee that the user
+// will see a helpful diagnostic (beyond a low level log). That concern is the
+// caller's responsibility.
+
+#pragma once
+
+#include "flags.h"
+
+#undef react_native_expect
+
+#ifndef REACT_NATIVE_DEBUG
+
+#define react_native_expect(e) ((void)0)
+
+#else // REACT_NATIVE_DEBUG
+
+#include <glog/logging.h>
+#include <cassert>
+
+#define react_native_expect(cond)                           \
+  if (!(cond)) {                                            \
+    LOG(ERROR) << "react_native_expect failure: " << #cond; \
+  }
+
+#endif // REACT_NATIVE_DEBUG