react-native-tvos 0.72.6-0 → 0.73.0-0

package/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp

@@ -5,25 +5,26 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "jni.h"
 #include "YGJNIVanilla.h"
-#include <yoga/YGNode.h>
 #include <cstring>
-#include "YGJNI.h"
-#include "common.h"
-#include "YGJTypesVanilla.h"
-#include <yoga/log.h>
 #include <iostream>
 #include <memory>
+#include "LayoutContext.h"
+#include "YGJNI.h"
+#include "YGJTypesVanilla.h"
 #include "YogaJniException.h"
+#include "common.h"
+#include "jni.h"
+
+#include <yoga/Yoga-internal.h>
+#include <yoga/bits/BitCast.h>
 
+using namespace facebook;
+using namespace facebook::yoga;
 using namespace facebook::yoga::vanillajni;
-using facebook::yoga::detail::Log;
 
-static inline ScopedLocalRef<jobject> YGNodeJobject(
-    YGNodeRef node,
-    void* layoutContext) {
-  return reinterpret_cast<PtrJNodeMapVanilla*>(layoutContext)->ref(node);
+static inline ScopedLocalRef<jobject> YGNodeJobject(YGNodeConstRef node) {
+  return LayoutContext::getNodeMap()->ref(node);
 }
 
 static inline YGNodeRef _jlong2YGNodeRef(jlong addr) {
@@ -34,11 +35,12 @@ static inline YGConfigRef _jlong2YGConfigRef(jlong addr) {
   return reinterpret_cast<YGConfigRef>(static_cast<intptr_t>(addr));
 }
 
-static jlong jni_YGConfigNewJNI(JNIEnv* env, jobject obj) {
+static jlong jni_YGConfigNewJNI(JNIEnv* /*env*/, jobject /*obj*/) {
   return reinterpret_cast<jlong>(YGConfigNew());
 }
 
-static void jni_YGConfigFreeJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
+static void
+jni_YGConfigFreeJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
   // unique_ptr will destruct the underlying global_ref, if present.
   auto context = std::unique_ptr<ScopedGlobalRef<jobject>>{
@@ -47,8 +49,8 @@ static void jni_YGConfigFreeJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
 }
 
 static void jni_YGConfigSetExperimentalFeatureEnabledJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint feature,
     jboolean enabled) {
@@ -58,8 +60,8 @@ static void jni_YGConfigSetExperimentalFeatureEnabledJNI(
 }
 
 static void jni_YGConfigSetUseWebDefaultsJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jboolean useWebDefaults) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
@@ -67,8 +69,8 @@ static void jni_YGConfigSetUseWebDefaultsJNI(
 }
 
 static void jni_YGConfigSetPrintTreeFlagJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jboolean enable) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
@@ -76,60 +78,56 @@ static void jni_YGConfigSetPrintTreeFlagJNI(
 }
 
 static void jni_YGConfigSetPointScaleFactorJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jfloat pixelsInPoint) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
   YGConfigSetPointScaleFactor(config, pixelsInPoint);
 }
 
-static void YGPrint(YGNodeRef node, void* layoutContext) {
-  if (auto obj = YGNodeJobject(node, layoutContext)) {
-    // TODO cout << obj.get()->toString() << endl;
-  } else {
-    Log::log(
-        node,
-        YGLogLevelError,
-        nullptr,
-        "Java YGNode was GCed during layout calculation\n");
-  }
+static void jni_YGConfigSetErrataJNI(
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
+    jlong nativePointer,
+    jint errata) {
+  const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
+  YGConfigSetErrata(config, static_cast<YGErrata>(errata));
 }
 
-static void jni_YGConfigSetUseLegacyStretchBehaviourJNI(
-    JNIEnv* env,
-    jobject obj,
-    jlong nativePointer,
-    jboolean useLegacyStretchBehaviour) {
+static jint jni_YGConfigGetErrataJNI(
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
+    jlong nativePointer) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
-  YGConfigSetUseLegacyStretchBehaviour(config, useLegacyStretchBehaviour);
+  return static_cast<jint>(YGConfigGetErrata(config));
 }
 
-static jlong jni_YGNodeNewJNI(JNIEnv* env, jobject obj) {
+static jlong jni_YGNodeNewJNI(JNIEnv* /*env*/, jobject /*obj*/) {
   const YGNodeRef node = YGNodeNew();
-  node->setContext(YGNodeContext{}.asVoidPtr);
-  node->setPrintFunc(YGPrint);
+  YGNodeSetContext(node, YGNodeContext{}.asVoidPtr);
   return reinterpret_cast<jlong>(node);
 }
 
 static jlong jni_YGNodeNewWithConfigJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong configPointer) {
   const YGNodeRef node = YGNodeNewWithConfig(_jlong2YGConfigRef(configPointer));
-  node->setContext(YGNodeContext{}.asVoidPtr);
+  YGNodeSetContext(node, YGNodeContext{}.asVoidPtr);
   return reinterpret_cast<jlong>(node);
 }
 
 static int YGJNILogFunc(
-    const YGConfigRef config,
-    const YGNodeRef node,
+    const YGConfigConstRef config,
+    const YGNodeConstRef /*node*/,
     YGLogLevel level,
-    void* layoutContext,
     const char* format,
     va_list args) {
-  int result = vsnprintf(NULL, 0, format, args);
-  std::vector<char> buffer(1 + result);
+  va_list argsCopy;
+  va_copy(argsCopy, args);
+  int result = vsnprintf(nullptr, 0, format, argsCopy);
+  std::vector<char> buffer(1 + static_cast<size_t>(result));
   vsnprintf(buffer.data(), buffer.size(), format, args);
 
   auto jloggerPtr =
@@ -167,7 +165,7 @@ static int YGJNILogFunc(
 
 static void jni_YGConfigSetLoggerJNI(
     JNIEnv* env,
-    jobject obj,
+    jobject /*obj*/,
     jlong nativePointer,
     jobject logger) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
@@ -181,7 +179,7 @@ static void jni_YGConfigSetLoggerJNI(
     }
 
     *context = newGlobalRef(env, logger);
-    config->setLogger(YGJNILogFunc);
+    YGConfigSetLogger(config, YGJNILogFunc);
   } else {
     if (context != nullptr) {
       delete context;
@@ -191,44 +189,50 @@ static void jni_YGConfigSetLoggerJNI(
   }
 }
 
-static void jni_YGNodeFreeJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
+static void
+jni_YGNodeDeallocateJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
   if (nativePointer == 0) {
     return;
   }
   const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
-  YGNodeFree(node);
+  YGNodeDeallocate(node);
 }
 
-static void jni_YGNodeResetJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
+static void
+jni_YGNodeResetJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
   const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
-  void* context = node->getContext();
+  void* context = YGNodeGetContext(node);
   YGNodeReset(node);
-  node->setContext(context);
+  YGNodeSetContext(node, context);
 }
 
 static void jni_YGNodeInsertChildJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jlong childPointer,
     jint index) {
   YGNodeInsertChild(
-      _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer), index);
+      _jlong2YGNodeRef(nativePointer),
+      _jlong2YGNodeRef(childPointer),
+      static_cast<uint32_t>(index));
 }
 
 static void jni_YGNodeSwapChildJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jlong childPointer,
     jint index) {
   YGNodeSwapChild(
-      _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer), index);
+      _jlong2YGNodeRef(nativePointer),
+      _jlong2YGNodeRef(childPointer),
+      static_cast<uint32_t>(index));
 }
 
 static void jni_YGNodeSetIsReferenceBaselineJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jboolean isReferenceBaseline) {
   YGNodeSetIsReferenceBaseline(
@@ -236,44 +240,36 @@ static void jni_YGNodeSetIsReferenceBaselineJNI(
 }
 
 static jboolean jni_YGNodeIsReferenceBaselineJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer) {
   return YGNodeIsReferenceBaseline(_jlong2YGNodeRef(nativePointer));
 }
 
-static void jni_YGNodeClearChildrenJNI(
-    JNIEnv* env,
-    jobject obj,
+static void jni_YGNodeRemoveAllChildrenJNI(
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer) {
   const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
-  node->clearChildren();
+  YGNodeRemoveAllChildren(node);
 }
 
 static void jni_YGNodeRemoveChildJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jlong childPointer) {
   YGNodeRemoveChild(
       _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer));
 }
 
-static void YGTransferLayoutOutputsRecursive(
-    JNIEnv* env,
-    jobject thiz,
-    YGNodeRef root,
-    void* layoutContext) {
-  if (!root->getHasNewLayout()) {
+static void
+YGTransferLayoutOutputsRecursive(JNIEnv* env, jobject thiz, YGNodeRef root) {
+  if (!YGNodeGetHasNewLayout(root)) {
     return;
   }
-  auto obj = YGNodeJobject(root, layoutContext);
+  auto obj = YGNodeJobject(root);
   if (!obj) {
-    Log::log(
-        root,
-        YGLogLevelError,
-        nullptr,
-        "Java YGNode was GCed during layout calculation\n");
     return;
   }
 
@@ -289,13 +285,13 @@ static void YGTransferLayoutOutputsRecursive(
   const int arrSize = 6 + (marginFieldSet ? 4 : 0) + (paddingFieldSet ? 4 : 0) +
       (borderFieldSet ? 4 : 0);
   float arr[18];
-  arr[LAYOUT_EDGE_SET_FLAG_INDEX] = fieldFlags;
+  arr[LAYOUT_EDGE_SET_FLAG_INDEX] = static_cast<float>(fieldFlags);
   arr[LAYOUT_WIDTH_INDEX] = YGNodeLayoutGetWidth(root);
   arr[LAYOUT_HEIGHT_INDEX] = YGNodeLayoutGetHeight(root);
   arr[LAYOUT_LEFT_INDEX] = YGNodeLayoutGetLeft(root);
   arr[LAYOUT_TOP_INDEX] = YGNodeLayoutGetTop(root);
   arr[LAYOUT_DIRECTION_INDEX] =
-      static_cast<jint>(YGNodeLayoutGetDirection(root));
+      static_cast<float>(YGNodeLayoutGetDirection(root));
   if (marginFieldSet) {
     arr[LAYOUT_MARGIN_START_INDEX] = YGNodeLayoutGetMargin(root, YGEdgeLeft);
     arr[LAYOUT_MARGIN_START_INDEX + 1] = YGNodeLayoutGetMargin(root, YGEdgeTop);
@@ -322,23 +318,25 @@ static void YGTransferLayoutOutputsRecursive(
     arr[borderStartIndex + 3] = YGNodeLayoutGetBorder(root, YGEdgeBottom);
   }
 
-  // Don't change this field name without changing the name of the field in
-  // Database.java
-  auto objectClass = facebook::yoga::vanillajni::make_local_ref(
-      env, env->GetObjectClass(obj.get()));
-  static const jfieldID arrField = facebook::yoga::vanillajni::getFieldId(
-      env, objectClass.get(), "arr", "[F");
+  // Create scope to make sure to release any local refs created here
+  {
+    // Don't change this field name without changing the name of the field in
+    // Database.java
+    auto objectClass = facebook::yoga::vanillajni::make_local_ref(
+        env, env->GetObjectClass(obj.get()));
+    static const jfieldID arrField = facebook::yoga::vanillajni::getFieldId(
+        env, objectClass.get(), "arr", "[F");
 
-  ScopedLocalRef<jfloatArray> arrFinal =
-      make_local_ref(env, env->NewFloatArray(arrSize));
-  env->SetFloatArrayRegion(arrFinal.get(), 0, arrSize, arr);
-  env->SetObjectField(obj.get(), arrField, arrFinal.get());
+    ScopedLocalRef<jfloatArray> arrFinal =
+        make_local_ref(env, env->NewFloatArray(arrSize));
+    env->SetFloatArrayRegion(arrFinal.get(), 0, arrSize, arr);
+    env->SetObjectField(obj.get(), arrField, arrFinal.get());
+  }
 
-  root->setHasNewLayout(false);
+  YGNodeSetHasNewLayout(root, false);
 
-  for (uint32_t i = 0; i < YGNodeGetChildCount(root); i++) {
-    YGTransferLayoutOutputsRecursive(
-        env, thiz, YGNodeGetChild(root, i), layoutContext);
+  for (size_t i = 0; i < YGNodeGetChildCount(root); i++) {
+    YGTransferLayoutOutputsRecursive(env, thiz, YGNodeGetChild(root, i));
   }
 }
 
@@ -350,23 +348,23 @@ static void jni_YGNodeCalculateLayoutJNI(
     jfloat height,
     jlongArray nativePointers,
     jobjectArray javaNodes) {
-
   try {
-    void* layoutContext = nullptr;
+    PtrJNodeMapVanilla* layoutContext = nullptr;
     auto map = PtrJNodeMapVanilla{};
     if (nativePointers) {
       map = PtrJNodeMapVanilla{nativePointers, javaNodes};
       layoutContext = &map;
     }
 
+    LayoutContext::Provider contextProvider(layoutContext);
+
     const YGNodeRef root = _jlong2YGNodeRef(nativePointer);
-    YGNodeCalculateLayoutWithContext(
+    YGNodeCalculateLayout(
         root,
         static_cast<float>(width),
         static_cast<float>(height),
-        YGNodeStyleGetDirection(_jlong2YGNodeRef(nativePointer)),
-        layoutContext);
-    YGTransferLayoutOutputsRecursive(env, obj, root, layoutContext);
+        YGNodeStyleGetDirection(_jlong2YGNodeRef(nativePointer)));
+    YGTransferLayoutOutputsRecursive(env, obj, root);
   } catch (const YogaJniException& jniException) {
     ScopedLocalRef<jthrowable> throwable = jniException.getThrowable();
     if (throwable.get()) {
@@ -382,103 +380,99 @@ static void jni_YGNodeCalculateLayoutJNI(
   }
 }
 
-static void jni_YGNodeMarkDirtyJNI(
-    JNIEnv* env,
-    jobject obj,
-    jlong nativePointer) {
+static void
+jni_YGNodeMarkDirtyJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
   YGNodeMarkDirty(_jlong2YGNodeRef(nativePointer));
 }
 
-static void jni_YGNodeMarkDirtyAndPropogateToDescendantsJNI(
-    JNIEnv* env,
-    jobject obj,
+static void jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI(
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer) {
-  YGNodeMarkDirtyAndPropogateToDescendants(_jlong2YGNodeRef(nativePointer));
+  YGNodeMarkDirtyAndPropagateToDescendants(_jlong2YGNodeRef(nativePointer));
 }
 
-static jboolean jni_YGNodeIsDirtyJNI(
-    JNIEnv* env,
-    jobject obj,
-    jlong nativePointer) {
-  return (jboolean) _jlong2YGNodeRef(nativePointer)->isDirty();
+static jboolean
+jni_YGNodeIsDirtyJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
+  return (jboolean)YGNodeIsDirty(_jlong2YGNodeRef(nativePointer));
 }
 
 static void jni_YGNodeCopyStyleJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong dstNativePointer,
     jlong srcNativePointer) {
   YGNodeCopyStyle(
       _jlong2YGNodeRef(dstNativePointer), _jlong2YGNodeRef(srcNativePointer));
 }
 
-#define YG_NODE_JNI_STYLE_PROP(javatype, type, name)                         \
-  static javatype jni_YGNodeStyleGet##name##JNI(                             \
-      JNIEnv* env, jobject obj, jlong nativePointer) {                       \
-    return (javatype) YGNodeStyleGet##name(_jlong2YGNodeRef(nativePointer)); \
+#define YG_NODE_JNI_STYLE_PROP(javatype, type, name)                           \
+  static javatype jni_YGNodeStyleGet##name##JNI(                               \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {                 \
+    return (javatype)YGNodeStyleGet##name(_jlong2YGNodeRef(nativePointer));    \
+  }                                                                            \
+                                                                               \
+  static void jni_YGNodeStyleSet##name##JNI(                                   \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, javatype value) { \
+    YGNodeStyleSet##name(                                                      \
+        _jlong2YGNodeRef(nativePointer), static_cast<type>(value));            \
+  }
+
+#define YG_NODE_JNI_STYLE_UNIT_PROP(name)                                    \
+  static jlong jni_YGNodeStyleGet##name##JNI(                                \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {               \
+    return YogaValue::asJavaLong(                                            \
+        YGNodeStyleGet##name(_jlong2YGNodeRef(nativePointer)));              \
   }                                                                          \
                                                                              \
   static void jni_YGNodeStyleSet##name##JNI(                                 \
-      JNIEnv* env, jobject obj, jlong nativePointer, javatype value) {       \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, jfloat value) { \
     YGNodeStyleSet##name(                                                    \
-        _jlong2YGNodeRef(nativePointer), static_cast<type>(value));          \
-  }
-
-#define YG_NODE_JNI_STYLE_UNIT_PROP(name)                            \
-  static jlong jni_YGNodeStyleGet##name##JNI(                        \
-      JNIEnv* env, jobject obj, jlong nativePointer) {               \
-    return YogaValue::asJavaLong(                                    \
-        YGNodeStyleGet##name(_jlong2YGNodeRef(nativePointer)));      \
-  }                                                                  \
-                                                                     \
-  static void jni_YGNodeStyleSet##name##JNI(                         \
-      JNIEnv* env, jobject obj, jlong nativePointer, jfloat value) { \
-    YGNodeStyleSet##name(                                            \
-        _jlong2YGNodeRef(nativePointer), static_cast<float>(value)); \
-  }                                                                  \
-                                                                     \
-  static void jni_YGNodeStyleSet##name##PercentJNI(                  \
-      JNIEnv* env, jobject obj, jlong nativePointer, jfloat value) { \
-    YGNodeStyleSet##name##Percent(                                   \
-        _jlong2YGNodeRef(nativePointer), static_cast<float>(value)); \
+        _jlong2YGNodeRef(nativePointer), static_cast<float>(value));         \
+  }                                                                          \
+                                                                             \
+  static void jni_YGNodeStyleSet##name##PercentJNI(                          \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, jfloat value) { \
+    YGNodeStyleSet##name##Percent(                                           \
+        _jlong2YGNodeRef(nativePointer), static_cast<float>(value));         \
   }
 
 #define YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(name)                   \
   YG_NODE_JNI_STYLE_UNIT_PROP(name)                              \
   static void jni_YGNodeStyleSet##name##AutoJNI(                 \
-      JNIEnv* env, jobject obj, jlong nativePointer) {           \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {   \
     YGNodeStyleSet##name##Auto(_jlong2YGNodeRef(nativePointer)); \
   }
 
-#define YG_NODE_JNI_STYLE_EDGE_UNIT_PROP(name)                        \
-  static jlong jni_YGNodeStyleGet##name##JNI(                         \
-      JNIEnv* env, jobject obj, jlong nativePointer, jint edge) {     \
-    return YogaValue::asJavaLong(YGNodeStyleGet##name(                \
-        _jlong2YGNodeRef(nativePointer), static_cast<YGEdge>(edge))); \
-  }                                                                   \
-                                                                      \
-  static void jni_YGNodeStyleSet##name##JNI(                          \
-      JNIEnv* env,                                                    \
-      jobject obj,                                                    \
-      jlong nativePointer,                                            \
-      jint edge,                                                      \
-      jfloat value) {                                                 \
-    YGNodeStyleSet##name(                                             \
-        _jlong2YGNodeRef(nativePointer),                              \
-        static_cast<YGEdge>(edge),                                    \
-        static_cast<float>(value));                                   \
-  }                                                                   \
-                                                                      \
-  static void jni_YGNodeStyleSet##name##PercentJNI(                   \
-      JNIEnv* env,                                                    \
-      jobject obj,                                                    \
-      jlong nativePointer,                                            \
-      jint edge,                                                      \
-      jfloat value) {                                                 \
-    YGNodeStyleSet##name##Percent(                                    \
-        _jlong2YGNodeRef(nativePointer),                              \
-        static_cast<YGEdge>(edge),                                    \
-        static_cast<float>(value));                                   \
+#define YG_NODE_JNI_STYLE_EDGE_UNIT_PROP(name)                            \
+  static jlong jni_YGNodeStyleGet##name##JNI(                             \
+      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, jint edge) { \
+    return YogaValue::asJavaLong(YGNodeStyleGet##name(                    \
+        _jlong2YGNodeRef(nativePointer), static_cast<YGEdge>(edge)));     \
+  }                                                                       \
+                                                                          \
+  static void jni_YGNodeStyleSet##name##JNI(                              \
+      JNIEnv* /*env*/,                                                    \
+      jobject /*obj*/,                                                    \
+      jlong nativePointer,                                                \
+      jint edge,                                                          \
+      jfloat value) {                                                     \
+    YGNodeStyleSet##name(                                                 \
+        _jlong2YGNodeRef(nativePointer),                                  \
+        static_cast<YGEdge>(edge),                                        \
+        static_cast<float>(value));                                       \
+  }                                                                       \
+                                                                          \
+  static void jni_YGNodeStyleSet##name##PercentJNI(                       \
+      JNIEnv* /*env*/,                                                    \
+      jobject /*obj*/,                                                    \
+      jlong nativePointer,                                                \
+      jint edge,                                                          \
+      jfloat value) {                                                     \
+    YGNodeStyleSet##name##Percent(                                        \
+        _jlong2YGNodeRef(nativePointer),                                  \
+        static_cast<YGEdge>(edge),                                        \
+        static_cast<float>(value));                                       \
   }
 
 YG_NODE_JNI_STYLE_PROP(jint, YGDirection, Direction);
@@ -506,8 +500,8 @@ YG_NODE_JNI_STYLE_UNIT_PROP(MaxHeight);
 YG_NODE_JNI_STYLE_EDGE_UNIT_PROP(Position);
 
 static jlong jni_YGNodeStyleGetMarginJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge) {
   YGNodeRef yogaNodeRef = _jlong2YGNodeRef(nativePointer);
@@ -519,8 +513,8 @@ static jlong jni_YGNodeStyleGetMarginJNI(
 }
 
 static void jni_YGNodeStyleSetMarginJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge,
     jfloat margin) {
@@ -531,8 +525,8 @@ static void jni_YGNodeStyleSetMarginJNI(
 }
 
 static void jni_YGNodeStyleSetMarginPercentJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge,
     jfloat percent) {
@@ -543,8 +537,8 @@ static void jni_YGNodeStyleSetMarginPercentJNI(
 }
 
 static void jni_YGNodeStyleSetMarginAutoJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge) {
   YGNodeRef yogaNodeRef = _jlong2YGNodeRef(nativePointer);
@@ -553,8 +547,8 @@ static void jni_YGNodeStyleSetMarginAutoJNI(
 }
 
 static jlong jni_YGNodeStyleGetPaddingJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge) {
   YGNodeRef yogaNodeRef = _jlong2YGNodeRef(nativePointer);
@@ -566,8 +560,8 @@ static jlong jni_YGNodeStyleGetPaddingJNI(
 }
 
 static void jni_YGNodeStyleSetPaddingJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge,
     jfloat padding) {
@@ -578,8 +572,8 @@ static void jni_YGNodeStyleSetPaddingJNI(
 }
 
 static void jni_YGNodeStyleSetPaddingPercentJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge,
     jfloat percent) {
@@ -590,20 +584,20 @@ static void jni_YGNodeStyleSetPaddingPercentJNI(
 }
 
 static jfloat jni_YGNodeStyleGetBorderJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge) {
   YGNodeRef yogaNodeRef = _jlong2YGNodeRef(nativePointer);
   if (!YGNodeEdges{yogaNodeRef}.has(YGNodeEdges::BORDER)) {
-    return (jfloat) YGUndefined;
+    return (jfloat)YGUndefined;
   }
-  return (jfloat) YGNodeStyleGetBorder(yogaNodeRef, static_cast<YGEdge>(edge));
+  return (jfloat)YGNodeStyleGetBorder(yogaNodeRef, static_cast<YGEdge>(edge));
 }
 
 static void jni_YGNodeStyleSetBorderJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint edge,
     jfloat border) {
@@ -613,7 +607,7 @@ static void jni_YGNodeStyleSetBorderJNI(
       yogaNodeRef, static_cast<YGEdge>(edge), static_cast<float>(border));
 }
 
-static void YGTransferLayoutDirection(YGNodeRef node, jobject javaNode) {
+static void YGTransferLayoutDirection(YGNodeConstRef node, jobject javaNode) {
   // Don't change this field name without changing the name of the field in
   // Database.java
   JNIEnv* env = getCurrentEnv();
@@ -629,13 +623,12 @@ static void YGTransferLayoutDirection(YGNodeRef node, jobject javaNode) {
 }
 
 static YGSize YGJNIMeasureFunc(
-    YGNodeRef node,
+    YGNodeConstRef node,
     float width,
     YGMeasureMode widthMode,
     float height,
-    YGMeasureMode heightMode,
-    void* layoutContext) {
-  if (auto obj = YGNodeJobject(node, layoutContext)) {
+    YGMeasureMode heightMode) {
+  if (auto obj = YGNodeJobject(node)) {
     YGTransferLayoutDirection(node, obj.get());
     JNIEnv* env = getCurrentEnv();
     auto objectClass = facebook::yoga::vanillajni::make_local_ref(
@@ -649,19 +642,14 @@ static YGSize YGJNIMeasureFunc(
         sizeof(measureResult) == 8,
         "Expected measureResult to be 8 bytes, or two 32 bit ints");
 
-    int32_t wBits = 0xFFFFFFFF & (measureResult >> 32);
-    int32_t hBits = 0xFFFFFFFF & measureResult;
+    uint32_t wBits = 0xFFFFFFFF & (measureResult >> 32);
+    uint32_t hBits = 0xFFFFFFFF & measureResult;
 
-    const float* measuredWidth = reinterpret_cast<float*>(&wBits);
-    const float* measuredHeight = reinterpret_cast<float*>(&hBits);
+    const float measuredWidth = yoga::bit_cast<float>(wBits);
+    const float measuredHeight = yoga::bit_cast<float>(hBits);
 
-    return YGSize{*measuredWidth, *measuredHeight};
+    return YGSize{measuredWidth, measuredHeight};
   } else {
-    Log::log(
-        node,
-        YGLogLevelError,
-        nullptr,
-        "Java YGNode was GCed during layout calculation\n");
     return YGSize{
         widthMode == YGMeasureModeUndefined ? 0 : width,
         heightMode == YGMeasureModeUndefined ? 0 : height,
@@ -670,20 +658,17 @@ static YGSize YGJNIMeasureFunc(
 }
 
 static void jni_YGNodeSetHasMeasureFuncJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jboolean hasMeasureFunc) {
-  _jlong2YGNodeRef(nativePointer)
-      ->setMeasureFunc(hasMeasureFunc ? YGJNIMeasureFunc : nullptr);
+  YGNodeSetMeasureFunc(
+      _jlong2YGNodeRef(nativePointer),
+      hasMeasureFunc ? YGJNIMeasureFunc : nullptr);
 }
 
-static float YGJNIBaselineFunc(
-    YGNodeRef node,
-    float width,
-    float height,
-    void* layoutContext) {
-  if (auto obj = YGNodeJobject(node, layoutContext)) {
+static float YGJNIBaselineFunc(YGNodeConstRef node, float width, float height) {
+  if (auto obj = YGNodeJobject(node)) {
     JNIEnv* env = getCurrentEnv();
     auto objectClass = facebook::yoga::vanillajni::make_local_ref(
         env, env->GetObjectClass(obj.get()));
@@ -697,43 +682,48 @@ static float YGJNIBaselineFunc(
 }
 
 static void jni_YGNodeSetHasBaselineFuncJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jboolean hasBaselineFunc) {
-  _jlong2YGNodeRef(nativePointer)
-      ->setBaselineFunc(hasBaselineFunc ? YGJNIBaselineFunc : nullptr);
+  YGNodeSetBaselineFunc(
+      _jlong2YGNodeRef(nativePointer),
+      hasBaselineFunc ? YGJNIBaselineFunc : nullptr);
 }
 
-static void jni_YGNodePrintJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
+static void
+jni_YGNodePrintJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
 #ifdef DEBUG
   const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
   YGNodePrint(
       node,
-      (YGPrintOptions) (YGPrintOptionsStyle | YGPrintOptionsLayout | YGPrintOptionsChildren));
+      (YGPrintOptions)(YGPrintOptionsStyle | YGPrintOptionsLayout | YGPrintOptionsChildren));
+#else
+  (void)nativePointer;
 #endif
 }
 
-static jlong jni_YGNodeCloneJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
+static jlong
+jni_YGNodeCloneJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
   auto node = _jlong2YGNodeRef(nativePointer);
   const YGNodeRef clonedYogaNode = YGNodeClone(node);
-  clonedYogaNode->setContext(node->getContext());
+  YGNodeSetContext(clonedYogaNode, YGNodeGetContext(node));
 
   return reinterpret_cast<jlong>(clonedYogaNode);
 }
 
 static jfloat jni_YGNodeStyleGetGapJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint gutter) {
-  return (jfloat) YGNodeStyleGetGap(
+  return (jfloat)YGNodeStyleGetGap(
       _jlong2YGNodeRef(nativePointer), static_cast<YGGutter>(gutter));
 }
 
 static void jni_YGNodeStyleSetGapJNI(
-    JNIEnv* env,
-    jobject obj,
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
     jlong nativePointer,
     jint gutter,
     jfloat gapLength) {
@@ -747,243 +737,242 @@ static void jni_YGNodeStyleSetGapJNI(
 YG_NODE_JNI_STYLE_PROP(jfloat, float, AspectRatio);
 
 static JNINativeMethod methods[] = {
-    {"jni_YGConfigNewJNI", "()J", (void*) jni_YGConfigNewJNI},
-    {"jni_YGConfigFreeJNI", "(J)V", (void*) jni_YGConfigFreeJNI},
+    {"jni_YGConfigNewJNI", "()J", (void*)jni_YGConfigNewJNI},
+    {"jni_YGConfigFreeJNI", "(J)V", (void*)jni_YGConfigFreeJNI},
     {"jni_YGConfigSetExperimentalFeatureEnabledJNI",
      "(JIZ)V",
-     (void*) jni_YGConfigSetExperimentalFeatureEnabledJNI},
+     (void*)jni_YGConfigSetExperimentalFeatureEnabledJNI},
     {"jni_YGConfigSetUseWebDefaultsJNI",
      "(JZ)V",
-     (void*) jni_YGConfigSetUseWebDefaultsJNI},
+     (void*)jni_YGConfigSetUseWebDefaultsJNI},
     {"jni_YGConfigSetPrintTreeFlagJNI",
      "(JZ)V",
-     (void*) jni_YGConfigSetPrintTreeFlagJNI},
+     (void*)jni_YGConfigSetPrintTreeFlagJNI},
     {"jni_YGConfigSetPointScaleFactorJNI",
      "(JF)V",
-     (void*) jni_YGConfigSetPointScaleFactorJNI},
-    {"jni_YGConfigSetUseLegacyStretchBehaviourJNI",
-     "(JZ)V",
-     (void*) jni_YGConfigSetUseLegacyStretchBehaviourJNI},
+     (void*)jni_YGConfigSetPointScaleFactorJNI},
+    {"jni_YGConfigSetErrataJNI", "(JI)V", (void*)jni_YGConfigSetErrataJNI},
+    {"jni_YGConfigGetErrataJNI", "(J)I", (void*)jni_YGConfigGetErrataJNI},
     {"jni_YGConfigSetLoggerJNI",
      "(JLcom/facebook/yoga/YogaLogger;)V",
-     (void*) jni_YGConfigSetLoggerJNI},
-    {"jni_YGNodeNewJNI", "()J", (void*) jni_YGNodeNewJNI},
-    {"jni_YGNodeNewWithConfigJNI", "(J)J", (void*) jni_YGNodeNewWithConfigJNI},
-    {"jni_YGNodeFreeJNI", "(J)V", (void*) jni_YGNodeFreeJNI},
-    {"jni_YGNodeResetJNI", "(J)V", (void*) jni_YGNodeResetJNI},
-    {"jni_YGNodeInsertChildJNI", "(JJI)V", (void*) jni_YGNodeInsertChildJNI},
-    {"jni_YGNodeSwapChildJNI", "(JJI)V", (void*) jni_YGNodeSwapChildJNI},
+     (void*)jni_YGConfigSetLoggerJNI},
+    {"jni_YGNodeNewJNI", "()J", (void*)jni_YGNodeNewJNI},
+    {"jni_YGNodeNewWithConfigJNI", "(J)J", (void*)jni_YGNodeNewWithConfigJNI},
+    {"jni_YGNodeDeallocateJNI", "(J)V", (void*)jni_YGNodeDeallocateJNI},
+    {"jni_YGNodeResetJNI", "(J)V", (void*)jni_YGNodeResetJNI},
+    {"jni_YGNodeInsertChildJNI", "(JJI)V", (void*)jni_YGNodeInsertChildJNI},
+    {"jni_YGNodeSwapChildJNI", "(JJI)V", (void*)jni_YGNodeSwapChildJNI},
     {"jni_YGNodeSetIsReferenceBaselineJNI",
      "(JZ)V",
-     (void*) jni_YGNodeSetIsReferenceBaselineJNI},
+     (void*)jni_YGNodeSetIsReferenceBaselineJNI},
     {"jni_YGNodeIsReferenceBaselineJNI",
      "(J)Z",
-     (void*) jni_YGNodeIsReferenceBaselineJNI},
-    {"jni_YGNodeClearChildrenJNI", "(J)V", (void*) jni_YGNodeClearChildrenJNI},
-    {"jni_YGNodeRemoveChildJNI", "(JJ)V", (void*) jni_YGNodeRemoveChildJNI},
+     (void*)jni_YGNodeIsReferenceBaselineJNI},
+    {"jni_YGNodeRemoveAllChildrenJNI",
+     "(J)V",
+     (void*)jni_YGNodeRemoveAllChildrenJNI},
+    {"jni_YGNodeRemoveChildJNI", "(JJ)V", (void*)jni_YGNodeRemoveChildJNI},
     {"jni_YGNodeCalculateLayoutJNI",
      "(JFF[J[Lcom/facebook/yoga/YogaNodeJNIBase;)V",
-     (void*) jni_YGNodeCalculateLayoutJNI},
-    {"jni_YGNodeMarkDirtyJNI", "(J)V", (void*) jni_YGNodeMarkDirtyJNI},
-    {"jni_YGNodeMarkDirtyAndPropogateToDescendantsJNI",
+     (void*)jni_YGNodeCalculateLayoutJNI},
+    {"jni_YGNodeMarkDirtyJNI", "(J)V", (void*)jni_YGNodeMarkDirtyJNI},
+    {"jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI",
      "(J)V",
-     (void*) jni_YGNodeMarkDirtyAndPropogateToDescendantsJNI},
-    {"jni_YGNodeIsDirtyJNI", "(J)Z", (void*) jni_YGNodeIsDirtyJNI},
-    {"jni_YGNodeCopyStyleJNI", "(JJ)V", (void*) jni_YGNodeCopyStyleJNI},
+     (void*)jni_YGNodeMarkDirtyAndPropagateToDescendantsJNI},
+    {"jni_YGNodeIsDirtyJNI", "(J)Z", (void*)jni_YGNodeIsDirtyJNI},
+    {"jni_YGNodeCopyStyleJNI", "(JJ)V", (void*)jni_YGNodeCopyStyleJNI},
     {"jni_YGNodeStyleGetDirectionJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetDirectionJNI},
+     (void*)jni_YGNodeStyleGetDirectionJNI},
     {"jni_YGNodeStyleSetDirectionJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetDirectionJNI},
+     (void*)jni_YGNodeStyleSetDirectionJNI},
     {"jni_YGNodeStyleGetFlexDirectionJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetFlexDirectionJNI},
+     (void*)jni_YGNodeStyleGetFlexDirectionJNI},
     {"jni_YGNodeStyleSetFlexDirectionJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetFlexDirectionJNI},
+     (void*)jni_YGNodeStyleSetFlexDirectionJNI},
     {"jni_YGNodeStyleGetJustifyContentJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetJustifyContentJNI},
+     (void*)jni_YGNodeStyleGetJustifyContentJNI},
     {"jni_YGNodeStyleSetJustifyContentJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetJustifyContentJNI},
+     (void*)jni_YGNodeStyleSetJustifyContentJNI},
     {"jni_YGNodeStyleGetAlignItemsJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetAlignItemsJNI},
+     (void*)jni_YGNodeStyleGetAlignItemsJNI},
     {"jni_YGNodeStyleSetAlignItemsJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetAlignItemsJNI},
+     (void*)jni_YGNodeStyleSetAlignItemsJNI},
     {"jni_YGNodeStyleGetAlignSelfJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetAlignSelfJNI},
+     (void*)jni_YGNodeStyleGetAlignSelfJNI},
     {"jni_YGNodeStyleSetAlignSelfJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetAlignSelfJNI},
+     (void*)jni_YGNodeStyleSetAlignSelfJNI},
     {"jni_YGNodeStyleGetAlignContentJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetAlignContentJNI},
+     (void*)jni_YGNodeStyleGetAlignContentJNI},
     {"jni_YGNodeStyleSetAlignContentJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetAlignContentJNI},
+     (void*)jni_YGNodeStyleSetAlignContentJNI},
     {"jni_YGNodeStyleGetPositionTypeJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetPositionTypeJNI},
+     (void*)jni_YGNodeStyleGetPositionTypeJNI},
     {"jni_YGNodeStyleSetPositionTypeJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetPositionTypeJNI},
+     (void*)jni_YGNodeStyleSetPositionTypeJNI},
     {"jni_YGNodeStyleGetFlexWrapJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetFlexWrapJNI},
+     (void*)jni_YGNodeStyleGetFlexWrapJNI},
     {"jni_YGNodeStyleSetFlexWrapJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetFlexWrapJNI},
+     (void*)jni_YGNodeStyleSetFlexWrapJNI},
     {"jni_YGNodeStyleGetOverflowJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetOverflowJNI},
+     (void*)jni_YGNodeStyleGetOverflowJNI},
     {"jni_YGNodeStyleSetOverflowJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetOverflowJNI},
+     (void*)jni_YGNodeStyleSetOverflowJNI},
     {"jni_YGNodeStyleGetDisplayJNI",
      "(J)I",
-     (void*) jni_YGNodeStyleGetDisplayJNI},
+     (void*)jni_YGNodeStyleGetDisplayJNI},
     {"jni_YGNodeStyleSetDisplayJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetDisplayJNI},
-    {"jni_YGNodeStyleGetFlexJNI", "(J)F", (void*) jni_YGNodeStyleGetFlexJNI},
-    {"jni_YGNodeStyleSetFlexJNI", "(JF)V", (void*) jni_YGNodeStyleSetFlexJNI},
+     (void*)jni_YGNodeStyleSetDisplayJNI},
+    {"jni_YGNodeStyleGetFlexJNI", "(J)F", (void*)jni_YGNodeStyleGetFlexJNI},
+    {"jni_YGNodeStyleSetFlexJNI", "(JF)V", (void*)jni_YGNodeStyleSetFlexJNI},
     {"jni_YGNodeStyleGetFlexGrowJNI",
      "(J)F",
-     (void*) jni_YGNodeStyleGetFlexGrowJNI},
+     (void*)jni_YGNodeStyleGetFlexGrowJNI},
     {"jni_YGNodeStyleSetFlexGrowJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetFlexGrowJNI},
+     (void*)jni_YGNodeStyleSetFlexGrowJNI},
     {"jni_YGNodeStyleGetFlexShrinkJNI",
      "(J)F",
-     (void*) jni_YGNodeStyleGetFlexShrinkJNI},
+     (void*)jni_YGNodeStyleGetFlexShrinkJNI},
     {"jni_YGNodeStyleSetFlexShrinkJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetFlexShrinkJNI},
+     (void*)jni_YGNodeStyleSetFlexShrinkJNI},
     {"jni_YGNodeStyleGetFlexBasisJNI",
      "(J)J",
-     (void*) jni_YGNodeStyleGetFlexBasisJNI},
+     (void*)jni_YGNodeStyleGetFlexBasisJNI},
     {"jni_YGNodeStyleSetFlexBasisJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetFlexBasisJNI},
+     (void*)jni_YGNodeStyleSetFlexBasisJNI},
     {"jni_YGNodeStyleSetFlexBasisPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetFlexBasisPercentJNI},
+     (void*)jni_YGNodeStyleSetFlexBasisPercentJNI},
     {"jni_YGNodeStyleSetFlexBasisAutoJNI",
      "(J)V",
-     (void*) jni_YGNodeStyleSetFlexBasisAutoJNI},
+     (void*)jni_YGNodeStyleSetFlexBasisAutoJNI},
     {"jni_YGNodeStyleGetMarginJNI",
      "(JI)J",
-     (void*) jni_YGNodeStyleGetMarginJNI},
+     (void*)jni_YGNodeStyleGetMarginJNI},
     {"jni_YGNodeStyleSetMarginJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetMarginJNI},
+     (void*)jni_YGNodeStyleSetMarginJNI},
     {"jni_YGNodeStyleSetMarginPercentJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetMarginPercentJNI},
+     (void*)jni_YGNodeStyleSetMarginPercentJNI},
     {"jni_YGNodeStyleSetMarginAutoJNI",
      "(JI)V",
-     (void*) jni_YGNodeStyleSetMarginAutoJNI},
+     (void*)jni_YGNodeStyleSetMarginAutoJNI},
     {"jni_YGNodeStyleGetPaddingJNI",
      "(JI)J",
-     (void*) jni_YGNodeStyleGetPaddingJNI},
+     (void*)jni_YGNodeStyleGetPaddingJNI},
     {"jni_YGNodeStyleSetPaddingJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetPaddingJNI},
+     (void*)jni_YGNodeStyleSetPaddingJNI},
     {"jni_YGNodeStyleSetPaddingPercentJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetPaddingPercentJNI},
+     (void*)jni_YGNodeStyleSetPaddingPercentJNI},
     {"jni_YGNodeStyleGetBorderJNI",
      "(JI)F",
-     (void*) jni_YGNodeStyleGetBorderJNI},
+     (void*)jni_YGNodeStyleGetBorderJNI},
     {"jni_YGNodeStyleSetBorderJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetBorderJNI},
+     (void*)jni_YGNodeStyleSetBorderJNI},
     {"jni_YGNodeStyleGetPositionJNI",
      "(JI)J",
-     (void*) jni_YGNodeStyleGetPositionJNI},
+     (void*)jni_YGNodeStyleGetPositionJNI},
     {"jni_YGNodeStyleSetPositionJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetPositionJNI},
+     (void*)jni_YGNodeStyleSetPositionJNI},
     {"jni_YGNodeStyleSetPositionPercentJNI",
      "(JIF)V",
-     (void*) jni_YGNodeStyleSetPositionPercentJNI},
-    {"jni_YGNodeStyleGetWidthJNI", "(J)J", (void*) jni_YGNodeStyleGetWidthJNI},
-    {"jni_YGNodeStyleSetWidthJNI", "(JF)V", (void*) jni_YGNodeStyleSetWidthJNI},
+     (void*)jni_YGNodeStyleSetPositionPercentJNI},
+    {"jni_YGNodeStyleGetWidthJNI", "(J)J", (void*)jni_YGNodeStyleGetWidthJNI},
+    {"jni_YGNodeStyleSetWidthJNI", "(JF)V", (void*)jni_YGNodeStyleSetWidthJNI},
     {"jni_YGNodeStyleSetWidthPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetWidthPercentJNI},
+     (void*)jni_YGNodeStyleSetWidthPercentJNI},
     {"jni_YGNodeStyleSetWidthAutoJNI",
      "(J)V",
-     (void*) jni_YGNodeStyleSetWidthAutoJNI},
-    {"jni_YGNodeStyleGetHeightJNI",
-     "(J)J",
-     (void*) jni_YGNodeStyleGetHeightJNI},
+     (void*)jni_YGNodeStyleSetWidthAutoJNI},
+    {"jni_YGNodeStyleGetHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetHeightJNI},
     {"jni_YGNodeStyleSetHeightJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetHeightJNI},
+     (void*)jni_YGNodeStyleSetHeightJNI},
     {"jni_YGNodeStyleSetHeightPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetHeightPercentJNI},
+     (void*)jni_YGNodeStyleSetHeightPercentJNI},
     {"jni_YGNodeStyleSetHeightAutoJNI",
      "(J)V",
-     (void*) jni_YGNodeStyleSetHeightAutoJNI},
+     (void*)jni_YGNodeStyleSetHeightAutoJNI},
     {"jni_YGNodeStyleGetMinWidthJNI",
      "(J)J",
-     (void*) jni_YGNodeStyleGetMinWidthJNI},
+     (void*)jni_YGNodeStyleGetMinWidthJNI},
     {"jni_YGNodeStyleSetMinWidthJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMinWidthJNI},
+     (void*)jni_YGNodeStyleSetMinWidthJNI},
     {"jni_YGNodeStyleSetMinWidthPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMinWidthPercentJNI},
+     (void*)jni_YGNodeStyleSetMinWidthPercentJNI},
     {"jni_YGNodeStyleGetMinHeightJNI",
      "(J)J",
-     (void*) jni_YGNodeStyleGetMinHeightJNI},
+     (void*)jni_YGNodeStyleGetMinHeightJNI},
     {"jni_YGNodeStyleSetMinHeightJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMinHeightJNI},
+     (void*)jni_YGNodeStyleSetMinHeightJNI},
     {"jni_YGNodeStyleSetMinHeightPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMinHeightPercentJNI},
+     (void*)jni_YGNodeStyleSetMinHeightPercentJNI},
     {"jni_YGNodeStyleGetMaxWidthJNI",
      "(J)J",
-     (void*) jni_YGNodeStyleGetMaxWidthJNI},
+     (void*)jni_YGNodeStyleGetMaxWidthJNI},
     {"jni_YGNodeStyleSetMaxWidthJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMaxWidthJNI},
+     (void*)jni_YGNodeStyleSetMaxWidthJNI},
     {"jni_YGNodeStyleSetMaxWidthPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMaxWidthPercentJNI},
+     (void*)jni_YGNodeStyleSetMaxWidthPercentJNI},
     {"jni_YGNodeStyleGetMaxHeightJNI",
      "(J)J",
-     (void*) jni_YGNodeStyleGetMaxHeightJNI},
+     (void*)jni_YGNodeStyleGetMaxHeightJNI},
     {"jni_YGNodeStyleSetMaxHeightJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMaxHeightJNI},
+     (void*)jni_YGNodeStyleSetMaxHeightJNI},
     {"jni_YGNodeStyleSetMaxHeightPercentJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetMaxHeightPercentJNI},
+     (void*)jni_YGNodeStyleSetMaxHeightPercentJNI},
     {"jni_YGNodeStyleGetAspectRatioJNI",
      "(J)F",
-     (void*) jni_YGNodeStyleGetAspectRatioJNI},
+     (void*)jni_YGNodeStyleGetAspectRatioJNI},
     {"jni_YGNodeStyleSetAspectRatioJNI",
      "(JF)V",
-     (void*) jni_YGNodeStyleSetAspectRatioJNI},
+     (void*)jni_YGNodeStyleSetAspectRatioJNI},
     {"jni_YGNodeSetHasMeasureFuncJNI",
      "(JZ)V",
-     (void*) jni_YGNodeSetHasMeasureFuncJNI},
-    {"jni_YGNodeStyleGetGapJNI", "(JI)F", (void*) jni_YGNodeStyleGetGapJNI},
-    {"jni_YGNodeStyleSetGapJNI", "(JIF)V", (void*) jni_YGNodeStyleSetGapJNI},
+     (void*)jni_YGNodeSetHasMeasureFuncJNI},
+    {"jni_YGNodeStyleGetGapJNI", "(JI)F", (void*)jni_YGNodeStyleGetGapJNI},
+    {"jni_YGNodeStyleSetGapJNI", "(JIF)V", (void*)jni_YGNodeStyleSetGapJNI},
     {"jni_YGNodeSetHasBaselineFuncJNI",
      "(JZ)V",
-     (void*) jni_YGNodeSetHasBaselineFuncJNI},
-    {"jni_YGNodePrintJNI", "(J)V", (void*) jni_YGNodePrintJNI},
-    {"jni_YGNodeCloneJNI", "(J)J", (void*) jni_YGNodeCloneJNI},
+     (void*)jni_YGNodeSetHasBaselineFuncJNI},
+    {"jni_YGNodePrintJNI", "(J)V", (void*)jni_YGNodePrintJNI},
+    {"jni_YGNodeCloneJNI", "(J)J", (void*)jni_YGNodeCloneJNI},
 };
 
 void YGJNIVanilla::registerNatives(JNIEnv* env) {