C++ Cleanup 4/N: Reorganize Log and YGNodePrint (facebook#1354)

Summary:
Pull Request resolved: facebook#1354

X-link: facebook/react-native#39197

## This diff

Moves these files to a `yoga/debug` subdirectory and does some mild renaming, namespace adjustment, and removes Yoga internal log function from list of library exports.

## This stack

The organization of the C++ internals of Yoga are in need of attention.
1. Some of the C++ internals are namespaced, but others not.
2. Some of the namespaces include `detail`, but are meant to be used outside of the translation unit (FB Clang Tidy rules warn on any usage of these)
2. Most of the files are in a flat hierarchy, except for event tracing in its own folder
3. Some files and functions begin with YG, others don’t
4. Some functions are uppercase, others are not
5. Almost all of the interesting logic is in Yoga.cpp, and the file is too large to reason about
6. There are multiple grab bag files where folks put random functions they need in (Utils, BitUtils, Yoga-Internal.h)
7. There is no clear indication from file structure or type naming what is private vs not
8. Handles like `YGNodeRef` and `YGConfigRef` can be used to access internals just by importing headers

This stack does some much needed spring cleaning:
1. All non-public headers and C++ implementation details are in separate folders from the root level `yoga`. This will give us room to split up logic and add more files without too large a flat hierarchy
3. All private C++ internals are under the `facebook::yoga` namespace. Details namespaces are only ever used within the same header, as they are intended
4. Utils files are split
5. Most C++ internals drop the YG prefix
6. Most C++ internal function names are all lower camel case
7. We start to split up Yoga.cpp
8. Every header beginning with YG or at the top-level directory is public and C only, with the exception of Yoga-Internal.h which has non-public functions for bindings
9. It is not possible to use private APIs without static casting handles to internal classes

This will give us more leeway to continue splitting monolithic files, and consistent guidelines for style in new files as well.

These changes should not be breaking to any project using only public Yoga headers. This includes every usage of Yoga in fbsource except for RN Fabric which is currently tied to internals. This refactor should make that boundary clearer.

Reviewed By: rshest

Differential Revision: D48763820

fbshipit-source-id: 18c6b2c6bea5f6a5fcfebb057dd1ab721167d6f5

yoga/Yoga.cpp

@@ -13,16 +13,15 @@
 
 #include <yoga/Yoga.h>
 
-#include "log.h"
+#include <yoga/debug/Log.h>
+#include <yoga/debug/NodeToString.h>
 #include <yoga/Utils.h>
 #include <yoga/node/Node.h>
-#include "YGNodePrint.h"
 #include <yoga/Yoga-internal.h>
 #include "event/event.h"
 
 using namespace facebook;
 using namespace facebook::yoga;
-using detail::Log;
 
 #ifdef ANDROID
 static int YGAndroidLog(
@@ -1005,8 +1004,8 @@ YOGA_EXPORT void YGNodePrint(
     const YGPrintOptions options) {
   const auto node = static_cast<yoga::Node*>(nodeRef);
   std::string str;
-  facebook::yoga::YGNodeToString(str, node, options, 0);
-  Log::log(node, YGLogLevelDebug, nullptr, str.c_str());
+  yoga::nodeToString(str, node, options, 0);
+  yoga::log(node, YGLogLevelDebug, nullptr, str.c_str());
 }
 #endif
 
@@ -3939,15 +3938,15 @@ bool YGLayoutNodeInternal(
                    : layoutMarkerData.cachedMeasures) += 1;
 
     if (gPrintChanges && gPrintSkips) {
-      Log::log(
+      yoga::log(
           node,
           YGLogLevelVerbose,
           nullptr,
           "%s%d.{[skipped] ",
           YGSpacer(depth),
           depth);
       node->print(layoutContext);
-      Log::log(
+      yoga::log(
           node,
           YGLogLevelVerbose,
           nullptr,
@@ -3962,7 +3961,7 @@ bool YGLayoutNodeInternal(
     }
   } else {
     if (gPrintChanges) {
-      Log::log(
+      yoga::log(
           node,
           YGLogLevelVerbose,
           nullptr,
@@ -3971,7 +3970,7 @@ bool YGLayoutNodeInternal(
           depth,
           needToVisitNode ? "*" : "");
       node->print(layoutContext);
-      Log::log(
+      yoga::log(
           node,
           YGLogLevelVerbose,
           nullptr,
@@ -4001,7 +4000,7 @@ bool YGLayoutNodeInternal(
         reason);
 
     if (gPrintChanges) {
-      Log::log(
+      yoga::log(
           node,
           YGLogLevelVerbose,
           nullptr,
@@ -4010,7 +4009,7 @@ bool YGLayoutNodeInternal(
           depth,
           needToVisitNode ? "*" : "");
       node->print(layoutContext);
-      Log::log(
+      yoga::log(
           node,
           YGLogLevelVerbose,
           nullptr,
@@ -4032,7 +4031,8 @@ bool YGLayoutNodeInternal(
       }
       if (layout->nextCachedMeasurementsIndex == YG_MAX_CACHED_RESULT_COUNT) {
         if (gPrintChanges) {
-          Log::log(node, YGLogLevelVerbose, nullptr, "Out of cache entries!\n");
+          yoga::log(
+              node, YGLogLevelVerbose, nullptr, "Out of cache entries!\n");
         }
         layout->nextCachedMeasurementsIndex = 0;
       }
@@ -4290,7 +4290,7 @@ YOGA_EXPORT void YGConfigSetLogger(const YGConfigRef config, YGLogger logger) {
 
 void YGAssert(const bool condition, const char* message) {
   if (!condition) {
-    Log::log(
+    yoga::log(
         static_cast<yoga::Node*>(nullptr),
         YGLogLevelFatal,
         nullptr,
@@ -4305,7 +4305,7 @@ void YGAssertWithNode(
     const bool condition,
     const char* message) {
   if (!condition) {
-    Log::log(
+    yoga::log(
         static_cast<yoga::Node*>(node),
         YGLogLevelFatal,
         nullptr,
@@ -4320,7 +4320,7 @@ void YGAssertWithConfig(
     const bool condition,
     const char* message) {
   if (!condition) {
-    Log::log(
+    yoga::log(
         static_cast<yoga::Config*>(config),
         YGLogLevelFatal,
         nullptr,

yoga/log.cpp → yoga/debug/Log.cpp

@@ -5,13 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <yoga/Yoga.h>
+#include <yoga/debug/Log.h>
 
-#include "log.h"
-#include <yoga/config/Config.h>
-#include <yoga/node/Node.h>
-
-namespace facebook::yoga::detail {
+namespace facebook::yoga {
 
 namespace {
 
@@ -29,7 +25,7 @@ void vlog(
 }
 } // namespace
 
-YOGA_EXPORT void Log::log(
+void log(
     yoga::Node* node,
     YGLogLevel level,
     void* context,
@@ -47,7 +43,7 @@ YOGA_EXPORT void Log::log(
   va_end(args);
 }
 
-void Log::log(
+void log(
     yoga::Config* config,
     YGLogLevel level,
     void* context,
@@ -59,4 +55,4 @@ void Log::log(
   va_end(args);
 }
 
-} // namespace facebook::yoga::detail
+} // namespace facebook::yoga

yoga/debug/Log.h

@@ -0,0 +1,30 @@
+/*
+ * 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
+
+#include <yoga/YGEnums.h>
+#include <yoga/node/Node.h>
+#include <yoga/config/Config.h>
+
+namespace facebook::yoga {
+
+void log(
+    yoga::Node* node,
+    YGLogLevel level,
+    void*,
+    const char* message,
+    ...) noexcept;
+
+void log(
+    yoga::Config* config,
+    YGLogLevel level,
+    void*,
+    const char* format,
+    ...) noexcept;
+
+} // namespace facebook::yoga

yoga/YGNodePrint.cpp → yoga/debug/NodeToString.cpp

@@ -11,14 +11,13 @@
 
 #include <yoga/YGEnums.h>
 
-#include "YGNodePrint.h"
+#include <yoga/debug/NodeToString.h>
 #include <yoga/Yoga-internal.h>
 #include <yoga/Utils.h>
 
 namespace facebook::yoga {
-typedef std::string string;
 
-static void indent(string& base, uint32_t level) {
+static void indent(std::string& base, uint32_t level) {
   for (uint32_t i = 0; i < level; ++i) {
     base.append("  ");
   }
@@ -29,7 +28,7 @@ static bool areFourValuesEqual(const Style::Edges& four) {
       YGValueEqual(four[0], four[3]);
 }
 
-static void appendFormattedString(string& str, const char* fmt, ...) {
+static void appendFormattedString(std::string& str, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   va_list argsCopy;
@@ -38,46 +37,46 @@ static void appendFormattedString(string& str, const char* fmt, ...) {
   va_end(args);
   vsnprintf(buf.data(), buf.size(), fmt, argsCopy);
   va_end(argsCopy);
-  string result = string(buf.begin(), buf.end() - 1);
+  std::string result = std::string(buf.begin(), buf.end() - 1);
   str.append(result);
 }
 
 static void appendFloatOptionalIfDefined(
-    string& base,
-    const string key,
+    std::string& base,
+    const std::string key,
     const YGFloatOptional num) {
   if (!num.isUndefined()) {
     appendFormattedString(base, "%s: %g; ", key.c_str(), num.unwrap());
   }
 }
 
 static void appendNumberIfNotUndefined(
-    string& base,
-    const string key,
+    std::string& base,
+    const std::string key,
     const YGValue number) {
   if (number.unit != YGUnitUndefined) {
     if (number.unit == YGUnitAuto) {
       base.append(key + ": auto; ");
     } else {
-      string unit = number.unit == YGUnitPoint ? "px" : "%%";
+      std::string unit = number.unit == YGUnitPoint ? "px" : "%%";
       appendFormattedString(
           base, "%s: %g%s; ", key.c_str(), number.value, unit.c_str());
     }
   }
 }
 
 static void appendNumberIfNotAuto(
-    string& base,
-    const string& key,
+    std::string& base,
+    const std::string& key,
     const YGValue number) {
   if (number.unit != YGUnitAuto) {
     appendNumberIfNotUndefined(base, key, number);
   }
 }
 
 static void appendNumberIfNotZero(
-    string& base,
-    const string& str,
+    std::string& base,
+    const std::string& str,
     const YGValue number) {
   if (number.unit == YGUnitAuto) {
     base.append(str + ": auto; ");
@@ -87,24 +86,24 @@ static void appendNumberIfNotZero(
 }
 
 static void appendEdges(
-    string& base,
-    const string& key,
+    std::string& base,
+    const std::string& key,
     const Style::Edges& edges) {
   if (areFourValuesEqual(edges)) {
     auto edgeValue = yoga::Node::computeEdgeValueForColumn(
         edges, YGEdgeLeft, CompactValue::ofZero());
     appendNumberIfNotZero(base, key, edgeValue);
   } else {
     for (int edge = YGEdgeLeft; edge != YGEdgeAll; ++edge) {
-      string str = key + "-" + YGEdgeToString(static_cast<YGEdge>(edge));
+      std::string str = key + "-" + YGEdgeToString(static_cast<YGEdge>(edge));
       appendNumberIfNotZero(base, str, edges[edge]);
     }
   }
 }
 
 static void appendEdgeIfNotUndefined(
-    string& base,
-    const string& str,
+    std::string& base,
+    const std::string& str,
     const Style::Edges& edges,
     const YGEdge edge) {
   // TODO: this doesn't take RTL / YGEdgeStart / YGEdgeEnd into account
@@ -116,7 +115,7 @@ static void appendEdgeIfNotUndefined(
   appendNumberIfNotUndefined(base, str, value);
 }
 
-void YGNodeToString(
+void nodeToString(
     std::string& str,
     yoga::Node* node,
     YGPrintOptions options,
@@ -232,7 +231,7 @@ void YGNodeToString(
   if (options & YGPrintOptionsChildren && childCount > 0) {
     for (uint32_t i = 0; i < childCount; i++) {
       appendFormattedString(str, "\n");
-      YGNodeToString(str, node->getChild(i), options, level + 1);
+      nodeToString(str, node->getChild(i), options, level + 1);
     }
     appendFormattedString(str, "\n");
     indent(str, level);

yoga/YGNodePrint.h → yoga/debug/NodeToString.h

@@ -16,7 +16,7 @@
 
 namespace facebook::yoga {
 
-void YGNodeToString(
+void nodeToString(
     std::string& str,
     yoga::Node* node,
     YGPrintOptions options,