Merge branch 'master' into edensan

BUCK

@@ -32,6 +32,20 @@ cxx_library(
     ],
 )
 
+cxx_library(
+    name = "yogafastmath",
+    srcs = glob(["yoga/*.cpp"]),
+    header_namespace = "",
+    exported_headers = subdir_glob([("", "yoga/*.h")]),
+    compiler_flags = COMPILER_FLAGS + ["-ffast-math"],
+    soname = "libyogafastmathcore.$(ext)",
+    tests = [":YogaTests"],
+    visibility = ["PUBLIC"],
+    deps = [
+        yoga_dep("lib/fb:ndklog"),
+    ],
+)
+
 cxx_test(
     name = "YogaTests",
     srcs = glob(["tests/*.cpp"]),

Yoga.podspec

@@ -1,9 +1,9 @@
 Pod::Spec.new do |spec|
   spec.name = 'Yoga'
-  spec.version = '1.8.0'
+  spec.version = '1.7.0'
   spec.license =  { :type => 'MIT', :file => "LICENSE" }
-  spec.homepage = 'https://yogalayout.com/'
-  spec.documentation_url = 'https://yogalayout.com/docs'
+  spec.homepage = 'https://facebook.github.io/yoga/'
+  spec.documentation_url = 'https://facebook.github.io/yoga/docs/api/c/'
 
   spec.summary = 'Yoga is a cross-platform layout engine which implements Flexbox.'
   spec.description = 'Yoga is a cross-platform layout engine enabling maximum collaboration within your team by implementing an API many designers are familiar with, and opening it up to developers across different platforms.'
@@ -11,9 +11,9 @@ Pod::Spec.new do |spec|
   spec.authors = 'Facebook'
   spec.source = {
     :git => 'https://github.com/facebook/yoga.git',
-    :tag => '1.8.0',
+    :tag => '1.7.0',
   }
-  spec.osx.deployment_target  = '10.13'
+
   spec.module_name = 'yoga'
   spec.requires_arc = false
   spec.compiler_flags = [
@@ -25,6 +25,4 @@ Pod::Spec.new do |spec|
       '-fPIC'
   ]
   spec.source_files = 'yoga/**/*.{c,h,cpp}'
-  spec.public_header_files = 'yoga/{Yoga,YGEnums,YGMacros}.h'
-
 end

android/src/main/java/com/facebook/yoga/android/YogaLayout.java

@@ -46,14 +46,14 @@ import java.util.Map;
  * <YogaLayout
  *     xmlns:android="http://schemas.android.com/apk/res/android"
  *     xmlns:yoga="http://schemas.android.com/apk/com.facebook.yoga.android"
- *     android:layout_width="match_owner"
- *     android:layout_height="match_owner"
+ *     android:layout_width="match_parent"
+ *     android:layout_height="match_parent"
  *     yoga:flex_direction="row"
  *     yoga:padding_all="10dp"
  *     >
  *     <TextView
- *         android:layout_width="match_owner"
- *         android:layout_height="match_owner"
+ *         android:layout_width="match_parent"
+ *         android:layout_height="match_parent"
  *         android:text="Hello, World!"
  *         yoga:flex="1"
  *         />
@@ -262,11 +262,11 @@ public class YogaLayout extends ViewGroup {
       return;
     }
 
-    final YogaNode owner = node.getOwner();
+    final YogaNode parent = node.getParent();
 
-    for (int i = 0; i < owner.getChildCount(); i++) {
-      if (owner.getChildAt(i).equals(node)) {
-        owner.removeChildAt(i);
+    for (int i = 0; i < parent.getChildCount(); i++) {
+      if (parent.getChildAt(i).equals(node)) {
+        parent.removeChildAt(i);
         break;
       }
     }
@@ -315,7 +315,7 @@ public class YogaLayout extends ViewGroup {
 
   @Override
   protected void onLayout(boolean changed, int l, int t, int r, int b) {
-    // Either we are a root of a tree, or this function is called by our owner's onLayout, in which
+    // Either we are a root of a tree, or this function is called by our parent's onLayout, in which
     // case our r-l and b-t are the size of our node.
     if (!(getParent() instanceof YogaLayout)) {
         createLayout(
@@ -699,7 +699,7 @@ public class YogaLayout extends ViewGroup {
     /**
      * Constructs a set of layout params, given width and height specs.  In this case, we can set
      * the {@code yoga:width} and {@code yoga:height} if we are given them explicitly.  If other
-     * options (such as {@code match_owner} or {@code wrap_content} are given, then the owner
+     * options (such as {@code match_parent} or {@code wrap_content} are given, then the parent
      * LayoutParams will store them, and we deal with them during layout. (see
      * {@link YogaLayout#createLayout})
      *
@@ -773,9 +773,9 @@ public class YogaLayout extends ViewGroup {
      * {@code View}'s measure function.
      *
      * @param node The yoga node to measure
-     * @param width The suggested width from the owner
+     * @param width The suggested width from the parent
      * @param widthMode The type of suggestion for the width
-     * @param height The suggested height from the owner
+     * @param height The suggested height from the parent
      * @param heightMode The type of suggestion for the height
      * @return A measurement output ({@code YogaMeasureOutput}) for the node
      */

csharp/Yoga/Yoga.vcxproj

@@ -227,31 +227,19 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClInclude Include="..\..\yoga\Utils.h" />
-    <ClInclude Include="..\..\yoga\YGConfig.h" />
-    <ClInclude Include="..\..\yoga\YGEnums.h" />
-    <ClInclude Include="..\..\yoga\YGFloatOptional.h" />
-    <ClInclude Include="..\..\yoga\YGLayout.h" />
-    <ClInclude Include="..\..\yoga\YGMacros.h" />
-    <ClInclude Include="..\..\yoga\YGNode.h" />
-    <ClInclude Include="..\..\yoga\YGNodePrint.h" />
-    <ClInclude Include="..\..\yoga\YGStyle.h" />
-    <ClInclude Include="..\..\yoga\Yoga-internal.h" />
     <ClInclude Include="..\..\yoga\Yoga.h" />
+    <ClInclude Include="..\..\yoga\YGEnums.h" />
+    <ClInclude Include="..\..\yoga\YGMacros.h" />
+    <ClInclude Include="..\..\yoga\YGNodeList.h" />
     <ClInclude Include="resource.h" />
+    <ClInclude Include="YGInterop.h" />
     <ClInclude Include="stdafx.h" />
     <ClInclude Include="targetver.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\yoga\Utils.cpp" />
-    <ClCompile Include="..\..\yoga\YGConfig.cpp" />
-    <ClCompile Include="..\..\yoga\YGEnums.cpp" />
-    <ClCompile Include="..\..\yoga\YGFloatOptional.cpp" />
-    <ClCompile Include="..\..\yoga\YGLayout.cpp" />
-    <ClCompile Include="..\..\yoga\YGNode.cpp" />
-    <ClCompile Include="..\..\yoga\YGNodePrint.cpp" />
-    <ClCompile Include="..\..\yoga\YGStyle.cpp" />
-    <ClCompile Include="..\..\yoga\Yoga.cpp" />
+    <ClCompile Include="..\..\yoga\Yoga.c" />
+    <ClCompile Include="..\..\yoga\YGEnums.c" />
+    <ClCompile Include="..\..\yoga\YGNodeList.c" />
     <ClCompile Include="YGInterop.cpp" />
     <ClCompile Include="dllmain.cpp">
       <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>

csharp/Yoga/Yoga.vcxproj.filters

@@ -21,40 +21,19 @@
     <ClInclude Include="targetver.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="resource.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\Utils.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\YGEnums.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\YGFloatOptional.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\YGLayout.h">
+    <ClInclude Include="..\..\yoga\Yoga.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="..\..\yoga\YGMacros.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\yoga\YGNode.h">
+    <ClInclude Include="..\..\yoga\YGNodeList.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\yoga\YGNodePrint.h">
+    <ClInclude Include="YGInterop.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\yoga\YGStyle.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\Yoga.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\Yoga-internal.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\..\yoga\YGConfig.h">
+    <ClInclude Include="resource.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
@@ -65,36 +44,15 @@
     <ClCompile Include="dllmain.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\yoga\Yoga.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGNodeList.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="YGInterop.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\yoga\Utils.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGEnums.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGFloatOptional.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGLayout.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGNode.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGNodePrint.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGStyle.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\Yoga.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGConfig.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Yoga.rc">

gradle.properties

@@ -2,7 +2,7 @@
 
 org.gradle.jvmargs=-Xmx1536M
 
-VERSION_NAME=1.8.0
+VERSION_NAME=1.7.1-SNAPSHOT
 POM_URL=https://github.com/facebook/yoga
 POM_SCM_URL=https://github.com/facebook/yoga.git
 POM_SCM_CONNECTION=scm:git:https://github.com/facebook/yoga.git

java/BUCK

@@ -28,6 +28,29 @@ cxx_library(
     ],
 )
 
+cxx_library(
+    name = "jniFastMath",
+    srcs = glob(["jni/*.cpp"]),
+    header_namespace = "",
+    compiler_flags = [
+        "-fno-omit-frame-pointer",
+        "-fexceptions",
+        "-fPIC",
+        "-Wall",
+        "-Werror",
+        "-O3",
+        "-std=c++11",
+    ],
+    platforms = ANDROID,
+    soname = "libyogafastmath.$(ext)",
+    visibility = ["PUBLIC"],
+    deps = [
+        FBJNI_TARGET,
+        JNI_TARGET,
+        yoga_dep(":yogafastmath"),
+    ],
+)
+
 java_library(
     name = "java",
     srcs = glob(["com/facebook/yoga/*.java"]),
@@ -40,6 +63,7 @@ java_library(
     visibility = ["PUBLIC"],
     deps = [
         ":jni",
+        ":jniFastMath",
         INFER_ANNOTATIONS_TARGET,
         JSR_305_TARGET,
         PROGRUARD_ANNOTATIONS_TARGET,

java/com/facebook/yoga/YogaConfig.java

@@ -16,12 +16,16 @@ public class YogaConfig {
   public static int SPACING_TYPE = 1;
 
   static {
+    if (YogaConstants.shouldUseFastMath) {
+      SoLoader.loadLibrary("yogafastmath");
+    } else {
       SoLoader.loadLibrary("yoga");
+    }
   }
 
   long mNativePointer;
   private YogaLogger mLogger;
-  private YogaNodeCloneFunction mYogaNodeCloneFunction;
+  private YogaNodeClonedFunction mNodeClonedFunction;
 
   private native long jni_YGConfigNew();
   public YogaConfig() {
@@ -70,19 +74,6 @@ public class YogaConfig {
     jni_YGConfigSetUseLegacyStretchBehaviour(mNativePointer, useLegacyStretchBehaviour);
   }
 
-  private native void jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
-      long nativePointer, boolean shouldDiffLayoutWithoutLegacyStretchBehaviour);
-  /**
-   * If this flag is set then yoga would diff the layout without legacy flag and would set a bool in
-   * YogaNode(mDoesLegacyStretchFlagAffectsLayout) with true if the layouts were different and false
-   * if not
-   */
-  public void setShouldDiffLayoutWithoutLegacyStretchBehaviour(
-      boolean shouldDiffLayoutWithoutLegacyStretchBehaviour) {
-    jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
-        mNativePointer, shouldDiffLayoutWithoutLegacyStretchBehaviour);
-  }
-
   private native void jni_YGConfigSetLogger(long nativePointer, Object logger);
   public void setLogger(YogaLogger logger) {
     mLogger = logger;
@@ -93,15 +84,16 @@ public class YogaConfig {
     return mLogger;
   }
 
-  private native void jni_YGConfigSetHasCloneNodeFunc(long nativePointer, boolean hasClonedFunc);
+  private native void jni_YGConfigSetHasNodeClonedFunc(long nativePointer, boolean hasClonedFunc);
 
-  public void setOnCloneNode(YogaNodeCloneFunction cloneYogaNodeFunction) {
-    mYogaNodeCloneFunction = cloneYogaNodeFunction;
-    jni_YGConfigSetHasCloneNodeFunc(mNativePointer, cloneYogaNodeFunction != null);
+  public void setOnNodeCloned(YogaNodeClonedFunction nodeClonedFunction) {
+    mNodeClonedFunction = nodeClonedFunction;
+    jni_YGConfigSetHasNodeClonedFunc(mNativePointer, nodeClonedFunction != null);
   }
 
   @DoNotStrip
-  private final YogaNode cloneNode(YogaNode oldNode, YogaNode parent, int childIndex) {
-    return mYogaNodeCloneFunction.cloneNode(oldNode, parent, childIndex);
+  public final void onNodeCloned(
+      YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex) {
+    mNodeClonedFunction.onNodeCloned(oldNode, newNode, parent, childIndex);
   }
 }

java/com/facebook/yoga/YogaConstants.java

@@ -18,6 +18,8 @@ public class YogaConstants {
    */
   public static final float UNDEFINED = (float) (10E20);
 
+  public static boolean shouldUseFastMath = false;
+
   public static boolean isUndefined(float value) {
     // Value of a float in the case of it being not defined is 10.1E20. Earlier it used to be NAN,
     // the benefit of which

java/com/facebook/yoga/YogaNode.java

@@ -17,7 +17,11 @@ import javax.annotation.Nullable;
 public class YogaNode implements Cloneable {
 
   static {
+    if (YogaConstants.shouldUseFastMath) {
+      SoLoader.loadLibrary("yogafastmath");
+    } else {
       SoLoader.loadLibrary("yoga");
+    }
   }
 
   /**
@@ -25,8 +29,8 @@ public class YogaNode implements Cloneable {
    */
   static native int jni_YGNodeGetInstanceCount();
 
-  private YogaNode mOwner;
-  @Nullable private List<YogaNode> mChildren;
+  private YogaNode mParent;
+  private List<YogaNode> mChildren;
   private YogaMeasureFunction mMeasureFunction;
   private YogaBaselineFunction mBaselineFunction;
   private long mNativePointer;
@@ -78,7 +82,6 @@ public class YogaNode implements Cloneable {
   private int mLayoutDirection = 0;
   @DoNotStrip
   private boolean mHasNewLayout = true;
-  @DoNotStrip private boolean mDoesLegacyStretchFlagAffectsLayout = false;
 
   private native long jni_YGNodeNew();
   public YogaNode() {
@@ -133,7 +136,6 @@ public class YogaNode implements Cloneable {
     mMeasureFunction = null;
     mBaselineFunction = null;
     mData = null;
-    mDoesLegacyStretchFlagAffectsLayout = false;
 
     jni_YGNodeReset(mNativePointer);
   }
@@ -143,15 +145,12 @@ public class YogaNode implements Cloneable {
   }
 
   public YogaNode getChildAt(int i) {
-    if (mChildren == null) {
-      throw new IllegalStateException("YogaNode does not have children");
-    }
     return mChildren.get(i);
   }
 
   private native void jni_YGNodeInsertChild(long nativePointer, long childPointer, int index);
   public void addChildAt(YogaNode child, int i) {
-    if (child.mOwner != null) {
+    if (child.mParent != null) {
       throw new IllegalStateException("Child already has a parent, it must be removed first.");
     }
 
@@ -159,84 +158,35 @@ public class YogaNode implements Cloneable {
       mChildren = new ArrayList<>(4);
     }
     mChildren.add(i, child);
-    child.mOwner = this;
+    child.mParent = this;
     jni_YGNodeInsertChild(mNativePointer, child.mNativePointer, i);
   }
 
-  private native void jni_YGNodeInsertSharedChild(long nativePointer, long childPointer, int index);
-
-  public void addSharedChildAt(YogaNode child, int i) {
-    if (mChildren == null) {
-      mChildren = new ArrayList<>(4);
-    }
-    mChildren.add(i, child);
-    child.mOwner = null;
-    jni_YGNodeInsertSharedChild(mNativePointer, child.mNativePointer, i);
-  }
-
   private native long jni_YGNodeClone(long nativePointer, Object newNode);
 
   @Override
-  public YogaNode clone() {
-    try {
-      YogaNode clonedYogaNode = (YogaNode) super.clone();
-      long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode);
-      clonedYogaNode.mNativePointer = clonedNativePointer;
-      clonedYogaNode.mOwner = null;
-      clonedYogaNode.mChildren =
-          mChildren != null ? (List<YogaNode>) ((ArrayList) mChildren).clone() : null;
-      return clonedYogaNode;
-    } catch (CloneNotSupportedException ex) {
-      // This class implements Cloneable, this should not happen
-      throw new RuntimeException(ex);
-    }
-  }
-
-  public YogaNode cloneWithNewChildren() {
-    try {
-      YogaNode clonedYogaNode = (YogaNode) super.clone();
-      long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode);
-      clonedYogaNode.mOwner = null;
-      clonedYogaNode.mNativePointer = clonedNativePointer;
-      clonedYogaNode.clearChildren();
-      return clonedYogaNode;
-    } catch (CloneNotSupportedException ex) {
-      // This class implements Cloneable, this should not happen
-      throw new RuntimeException(ex);
-    }
-  }
-
-  private native void jni_YGNodeClearChildren(long nativePointer);
-
-  private void clearChildren() {
-    mChildren = null;
-    jni_YGNodeClearChildren(mNativePointer);
+  public YogaNode clone() throws CloneNotSupportedException {
+    YogaNode clonedYogaNode = (YogaNode) super.clone();
+    long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode);
+    clonedYogaNode.mNativePointer = clonedNativePointer;
+    clonedYogaNode.mChildren =
+        mChildren != null ? (List<YogaNode>) ((ArrayList) mChildren).clone() : null;
+    return clonedYogaNode;
   }
 
   private native void jni_YGNodeRemoveChild(long nativePointer, long childPointer);
   public YogaNode removeChildAt(int i) {
-    if (mChildren == null) {
-      throw new IllegalStateException(
-          "Trying to remove a child of a YogaNode that does not have children");
-    }
+
     final YogaNode child = mChildren.remove(i);
-    child.mOwner = null;
+    child.mParent = null;
     jni_YGNodeRemoveChild(mNativePointer, child.mNativePointer);
     return child;
   }
 
-  /**
-   * @returns the {@link YogaNode} that owns this {@link YogaNode}.
-   * The owner is used to identify the YogaTree that a {@link YogaNode} belongs
-   * to.
-   * This method will return the parent of the {@link YogaNode} when the
-   * {@link YogaNode} only belongs to one YogaTree or null when the
-   * {@link YogaNode} is shared between two or more YogaTrees.
-   */
   @Nullable
   public
-  YogaNode getOwner() {
-    return mOwner;
+  YogaNode getParent() {
+    return mParent;
   }
 
   public int indexOf(YogaNode child) {
@@ -623,10 +573,6 @@ public class YogaNode implements Cloneable {
     return mHeight;
   }
 
-  public boolean getDoesLegacyStretchFlagAffectsLayout() {
-    return mDoesLegacyStretchFlagAffectsLayout;
-  }
-
   public float getLayoutMargin(YogaEdge edge) {
     switch (edge) {
       case LEFT:
@@ -745,22 +691,4 @@ public class YogaNode implements Cloneable {
   public void print() {
     jni_YGNodePrint(mNativePointer);
   }
-
-  /**
-   * This method replaces the child at childIndex position with the newNode received by parameter.
-   * This is different than calling removeChildAt and addChildAt because this method ONLY replaces
-   * the child in the mChildren datastructure. @DoNotStrip: called from JNI
-   *
-   * @return the nativePointer of the newNode {@linl YogaNode}
-   */
-  @DoNotStrip
-  private final long replaceChild(YogaNode newNode, int childIndex) {
-    if (mChildren == null) {
-      throw new IllegalStateException("Cannot replace child. YogaNode does not have children");
-    }
-    mChildren.remove(childIndex);
-    mChildren.add(childIndex, newNode);
-    newNode.mOwner = this;
-    return newNode.mNativePointer;
-  }
 }

java/com/facebook/yoga/YogaNodeClonedFunction.java

@@ -10,8 +10,8 @@ package com.facebook.yoga;
 import com.facebook.proguard.annotations.DoNotStrip;
 
 @DoNotStrip
-public interface YogaNodeCloneFunction {
+public interface YogaNodeClonedFunction {
 
   @DoNotStrip
-  YogaNode cloneNode(YogaNode oldNode, YogaNode parent, int childIndex);
+  void onNodeCloned(YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex);
 }

java/jni/YGJNI.cpp

@@ -67,9 +67,6 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) {
 
       static auto edgeSetFlagField = obj->getClass()->getField<jint>("mEdgeSetFlag");
       static auto hasNewLayoutField = obj->getClass()->getField<jboolean>("mHasNewLayout");
-      static auto doesLegacyStretchBehaviour =
-          obj->getClass()->getField<jboolean>(
-              "mDoesLegacyStretchFlagAffectsLayout");
 
       /* Those flags needs be in sync with YogaNode.java */
       const int MARGIN = 1;
@@ -82,19 +79,12 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) {
       obj->setFieldValue(heightField, YGNodeLayoutGetHeight(root));
       obj->setFieldValue(leftField, YGNodeLayoutGetLeft(root));
       obj->setFieldValue(topField, YGNodeLayoutGetTop(root));
-      obj->setFieldValue<jboolean>(
-          doesLegacyStretchBehaviour,
-          YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(root));
 
       if ((hasEdgeSetFlag & MARGIN) == MARGIN) {
-        obj->setFieldValue(
-            marginLeftField, YGNodeLayoutGetMargin(root, YGEdgeLeft));
-        obj->setFieldValue(
-            marginTopField, YGNodeLayoutGetMargin(root, YGEdgeTop));
-        obj->setFieldValue(
-            marginRightField, YGNodeLayoutGetMargin(root, YGEdgeRight));
-        obj->setFieldValue(
-            marginBottomField, YGNodeLayoutGetMargin(root, YGEdgeBottom));
+        obj->setFieldValue(marginLeftField, YGNodeLayoutGetMargin(root, YGEdgeLeft));
+        obj->setFieldValue(marginTopField, YGNodeLayoutGetMargin(root, YGEdgeTop));
+        obj->setFieldValue(marginRightField, YGNodeLayoutGetMargin(root, YGEdgeRight));
+        obj->setFieldValue(marginBottomField, YGNodeLayoutGetMargin(root, YGEdgeBottom));
       }
 
       if ((hasEdgeSetFlag & PADDING) == PADDING) {
@@ -142,49 +132,31 @@ static float YGJNIBaselineFunc(YGNodeRef node, float width, float height) {
   }
 }
 
-static inline YGNodeRef _jlong2YGNodeRef(jlong addr) {
-  return reinterpret_cast<YGNodeRef>(static_cast<intptr_t>(addr));
-}
-
-static inline YGConfigRef _jlong2YGConfigRef(jlong addr) {
-  return reinterpret_cast<YGConfigRef>(static_cast<intptr_t>(addr));
-}
-
-static YGNodeRef YGJNIOnNodeClonedFunc(
+static void YGJNIOnNodeClonedFunc(
     YGNodeRef oldNode,
-    YGNodeRef owner,
+    YGNodeRef newNode,
+    YGNodeRef parent,
     int childIndex) {
   auto config = oldNode->getConfig();
   if (!config) {
-    return nullptr;
+    return;
   }
-
   static auto onNodeClonedFunc = findClassStatic("com/facebook/yoga/YogaConfig")
-                                     ->getMethod<alias_ref<JYogaNode>(
+                                     ->getMethod<void(
                                          local_ref<JYogaNode>,
                                          local_ref<JYogaNode>,
-                                         jint)>("cloneNode");
+                                         local_ref<JYogaNode>,
+                                         jint)>("onNodeCloned");
 
   auto context = reinterpret_cast<YGConfigContext*>(YGConfigGetContext(config));
   auto javaConfig = context->config;
 
-  auto newNode = onNodeClonedFunc(
+  onNodeClonedFunc(
       javaConfig->get(),
       YGNodeJobject(oldNode)->lockLocal(),
-      YGNodeJobject(owner)->lockLocal(),
+      YGNodeJobject(newNode)->lockLocal(),
+      YGNodeJobject(parent)->lockLocal(),
       childIndex);
-
-  static auto replaceChild = findClassStatic("com/facebook/yoga/YogaNode")
-                                     ->getMethod<jlong(
-                                         local_ref<JYogaNode>,
-                                         jint)>("replaceChild");
-
-  jlong newNodeNativePointer = replaceChild(
-      YGNodeJobject(owner)->lockLocal(),
-      newNode,
-      childIndex);
-
-  return _jlong2YGNodeRef(newNodeNativePointer);
 }
 
 static YGSize YGJNIMeasureFunc(
@@ -252,6 +224,14 @@ static int YGJNILogFunc(const YGConfigRef config,
   return result;
 }
 
+static inline YGNodeRef _jlong2YGNodeRef(jlong addr) {
+  return reinterpret_cast<YGNodeRef>(static_cast<intptr_t>(addr));
+}
+
+static inline YGConfigRef _jlong2YGConfigRef(jlong addr) {
+  return reinterpret_cast<YGConfigRef>(static_cast<intptr_t>(addr));
+}
+
 jlong jni_YGNodeNew(alias_ref<jobject> thiz) {
   const YGNodeRef node = YGNodeNew();
   node->setContext(new weak_ref<jobject>(make_weak(thiz)));
@@ -284,11 +264,6 @@ void jni_YGNodeFree(alias_ref<jobject> thiz, jlong nativePointer) {
   YGNodeFree(node);
 }
 
-void jni_YGNodeClearChildren(alias_ref<jobject> thiz, jlong nativePointer) {
-  const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
-  node->clearChildren();
-}
-
 void jni_YGNodeReset(alias_ref<jobject> thiz, jlong nativePointer) {
   const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
   void* context = node->getContext();
@@ -308,15 +283,6 @@ void jni_YGNodeInsertChild(alias_ref<jobject>, jlong nativePointer, jlong childP
   YGNodeInsertChild(_jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer), index);
 }
 
-void jni_YGNodeInsertSharedChild(
-    alias_ref<jobject>,
-    jlong nativePointer,
-    jlong childPointer,
-    jint index) {
-  YGNodeInsertSharedChild(
-      _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer), index);
-}
-
 void jni_YGNodeRemoveChild(alias_ref<jobject>, jlong nativePointer, jlong childPointer) {
   YGNodeRemoveChild(_jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer));
 }
@@ -501,14 +467,6 @@ void jni_YGConfigSetExperimentalFeatureEnabled(alias_ref<jobject>,
                                         enabled);
 }
 
-void jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
-    alias_ref<jobject>,
-    jlong nativePointer,
-    jboolean enabled) {
-  const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
-  YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(config, enabled);
-}
-
 void jni_YGConfigSetUseWebDefaults(alias_ref<jobject>,
                                    jlong nativePointer,
                                    jboolean useWebDefaults) {
@@ -530,10 +488,10 @@ void jni_YGConfigSetUseLegacyStretchBehaviour(alias_ref<jobject>,
   YGConfigSetUseLegacyStretchBehaviour(config, useLegacyStretchBehaviour);
 }
 
-void jni_YGConfigSetHasCloneNodeFunc(
+void jni_YGConfigSetHasNodeClonedFunc(
     alias_ref<jobject> thiz,
     jlong nativePointer,
-    jboolean hasCloneNodeFunc) {
+    jboolean hasNodeClonedFunc) {
   const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
   auto context = reinterpret_cast<YGConfigContext*>(YGConfigGetContext(config));
   if (context && context->config) {
@@ -541,15 +499,15 @@ void jni_YGConfigSetHasCloneNodeFunc(
     context->config = nullptr;
   }
 
-  if (hasCloneNodeFunc) {
+  if (hasNodeClonedFunc) {
     if (!context) {
       context = new YGConfigContext();
       YGConfigSetContext(config, context);
     }
     context->config = new global_ref<jobject>(make_global(thiz));
-    YGConfigSetCloneNodeFunc(config, YGJNIOnNodeClonedFunc);
+    YGConfigSetNodeClonedFunc(config, YGJNIOnNodeClonedFunc);
   } else {
-    YGConfigSetCloneNodeFunc(config, nullptr);
+    YGConfigSetNodeClonedFunc(config, nullptr);
   }
 }
 
@@ -591,9 +549,7 @@ jint JNI_OnLoad(JavaVM *vm, void *) {
             YGMakeNativeMethod(jni_YGNodeNewWithConfig),
             YGMakeNativeMethod(jni_YGNodeFree),
             YGMakeNativeMethod(jni_YGNodeReset),
-            YGMakeNativeMethod(jni_YGNodeClearChildren),
             YGMakeNativeMethod(jni_YGNodeInsertChild),
-            YGMakeNativeMethod(jni_YGNodeInsertSharedChild),
             YGMakeNativeMethod(jni_YGNodeRemoveChild),
             YGMakeNativeMethod(jni_YGNodeCalculateLayout),
             YGMakeNativeMethod(jni_YGNodeMarkDirty),
@@ -668,19 +624,16 @@ jint JNI_OnLoad(JavaVM *vm, void *) {
             YGMakeNativeMethod(jni_YGNodePrint),
             YGMakeNativeMethod(jni_YGNodeClone),
         });
-    registerNatives(
-        "com/facebook/yoga/YogaConfig",
-        {
-            YGMakeNativeMethod(jni_YGConfigNew),
-            YGMakeNativeMethod(jni_YGConfigFree),
-            YGMakeNativeMethod(jni_YGConfigSetExperimentalFeatureEnabled),
-            YGMakeNativeMethod(jni_YGConfigSetUseWebDefaults),
-            YGMakeNativeMethod(jni_YGConfigSetPointScaleFactor),
-            YGMakeNativeMethod(jni_YGConfigSetUseLegacyStretchBehaviour),
-            YGMakeNativeMethod(jni_YGConfigSetLogger),
-            YGMakeNativeMethod(jni_YGConfigSetHasCloneNodeFunc),
-            YGMakeNativeMethod(
-                jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour),
-        });
+    registerNatives("com/facebook/yoga/YogaConfig",
+                    {
+                        YGMakeNativeMethod(jni_YGConfigNew),
+                        YGMakeNativeMethod(jni_YGConfigFree),
+                        YGMakeNativeMethod(jni_YGConfigSetExperimentalFeatureEnabled),
+                        YGMakeNativeMethod(jni_YGConfigSetUseWebDefaults),
+                        YGMakeNativeMethod(jni_YGConfigSetPointScaleFactor),
+                        YGMakeNativeMethod(jni_YGConfigSetUseLegacyStretchBehaviour),
+                        YGMakeNativeMethod(jni_YGConfigSetLogger),
+                        YGMakeNativeMethod(jni_YGConfigSetHasNodeClonedFunc),
+                    });
   });
 }

java/tests/com/facebook/yoga/YogaNodeTest.java

@@ -8,9 +8,7 @@
 package com.facebook.yoga;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -111,23 +109,21 @@ public class YogaNodeTest {
   }
 
   @Test
-  public void testMeasureFloatBigNumber() {
+  public void testMeasureFloatMax() {
     final YogaNode node = new YogaNode();
-    final float bigNumber = (float) 10E5;
-    node.setMeasureFunction(
-        new YogaMeasureFunction() {
-          public long measure(
-              YogaNode node,
-              float width,
-              YogaMeasureMode widthMode,
-              float height,
-              YogaMeasureMode heightMode) {
-            return YogaMeasureOutput.make(bigNumber, bigNumber);
-          }
-        });
+    node.setMeasureFunction(new YogaMeasureFunction() {
+        public long measure(
+            YogaNode node,
+            float width,
+            YogaMeasureMode widthMode,
+            float height,
+            YogaMeasureMode heightMode) {
+          return YogaMeasureOutput.make(Float.MAX_VALUE, Float.MAX_VALUE);
+        }
+    });
     node.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
-    assertEquals(bigNumber, node.getLayoutWidth(), 0.01f);
-    assertEquals(bigNumber, node.getLayoutHeight(), 0.01f);
+    assertEquals(Float.MAX_VALUE, node.getLayoutWidth(), 0.01f);
+    assertEquals(Float.MAX_VALUE, node.getLayoutHeight(), 0.01f);
   }
 
   @Test
@@ -252,58 +248,16 @@ public class YogaNodeTest {
     assertEquals(1, clonedChild.getChildCount());
   }
 
-  @Test
-  public void testCloneWithNewChildren() throws Exception {
-    YogaConfig config = new YogaConfig();
-    YogaNode root = new YogaNode(config);
-    YogaNode child = new YogaNode(config);
-    YogaNode grandChild = new YogaNode(config);
-    root.addChildAt(child, 0);
-    child.addChildAt(grandChild, 0);
-    child.setFlexDirection(YogaFlexDirection.ROW);
-
-    YogaNode clonedChild = child.cloneWithNewChildren();
-
-    assertNotSame(clonedChild, child);
-    assertEquals(YogaFlexDirection.ROW, clonedChild.getFlexDirection());
-    assertEquals(child.getFlexDirection(), clonedChild.getFlexDirection());
-    assertEquals(0, clonedChild.getChildCount());
-    assertEquals(1, child.getChildCount());
-  }
-
-  @Test
-  public void testAddSharedChildCloneWithNewChildren() throws Exception {
-    YogaConfig config = new YogaConfig();
-    YogaNode root = new YogaNode(config);
-    YogaNode child = new YogaNode(config);
-    YogaNode grandChild = new YogaNode(config);
-    root.addChildAt(child, 0);
-    child.addChildAt(grandChild, 0);
-    child.setFlexDirection(YogaFlexDirection.ROW);
-
-    YogaNode clonedChild = child.cloneWithNewChildren();
-
-    assertNotSame(clonedChild, child);
-    assertEquals(YogaFlexDirection.ROW, clonedChild.getFlexDirection());
-    assertEquals(child.getFlexDirection(), clonedChild.getFlexDirection());
-    assertEquals(0, clonedChild.getChildCount());
-    assertEquals(1, child.getChildCount());
-
-    clonedChild.addSharedChildAt(grandChild, 0);
-    assertEquals(1, clonedChild.getChildCount());
-    assertNull(grandChild.getOwner());
-  }
-
   @Test
   public void testCloneNodeListener() throws Exception {
     final AtomicBoolean onNodeClonedExecuted = new AtomicBoolean(false);
     YogaConfig config = new YogaConfig();
-    config.setOnCloneNode(
-        new YogaNodeCloneFunction() {
+    config.setOnNodeCloned(
+        new YogaNodeClonedFunction() {
           @Override
-          public YogaNode cloneNode(YogaNode oldNode, YogaNode owner, int childIndex) {
+          public void onNodeCloned(
+              YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex) {
             onNodeClonedExecuted.set(true);
-            return oldNode.clone();
           }
         });
     YogaNode root = new YogaNode(config);
@@ -311,7 +265,6 @@ public class YogaNodeTest {
     root.setHeight(100f);
     YogaNode child0 = new YogaNode(config);
     root.addChildAt(child0, 0);
-    child0.setWidth(50f);
     root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
 
     // Force a clone to happen.
@@ -320,24 +273,20 @@ public class YogaNodeTest {
     root2.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
 
     assertTrue(onNodeClonedExecuted.get());
-    assertEquals(1, root2.getChildCount());
-    YogaNode clonedNode = root2.getChildAt(0);
-    assertNotSame(child0, clonedNode);
-    assertEquals(child0.getWidth(), clonedNode.getWidth());
-    assertEquals(50f, clonedNode.getWidth().value, 0.01f);
   }
 
   @Test
   public void testOnNodeClonedLeak() throws Exception {
     YogaConfig config = new YogaConfig();
-    config.setOnCloneNode(
-        new YogaNodeCloneFunction() {
+    config.setOnNodeCloned(
+        new YogaNodeClonedFunction() {
           @Override
-          public YogaNode cloneNode(YogaNode oldNode, YogaNode owner, int childIndex) {
-            return oldNode.clone();
+          public void onNodeCloned(
+              YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex) {
+            // Do nothing
           }
         });
-    config.setOnCloneNode(null);
+    config.setOnNodeCloned(null);
     WeakReference<Object> ref = new WeakReference<Object>(config);
     // noinspection UnusedAssignment
     config = null;
@@ -353,27 +302,4 @@ public class YogaNodeTest {
     }
     fail("YogaConfig leaked");
   }
-
-  @Test
-  public void testFlagShouldDiffLayoutWithoutLegacyStretchBehaviour() throws Exception {
-    YogaConfig config = new YogaConfig();
-    config.setShouldDiffLayoutWithoutLegacyStretchBehaviour(true);
-    config.setUseLegacyStretchBehaviour(true);
-    YogaNode root = new YogaNode(config);
-    root.setWidth(500);
-    root.setHeight(500);
-    YogaNode root_child0 = new YogaNode(config);
-    root_child0.setAlignItems(YogaAlign.FLEX_START);
-    root.addChildAt(root_child0, 0);
-    YogaNode root_child0_child0 = new YogaNode(config);
-    root_child0_child0.setFlexGrow(1);
-    root_child0_child0.setFlexShrink(1);
-    root_child0.addChildAt(root_child0_child0, 0);
-    YogaNode root_child0_child0_child0 = new YogaNode(config);
-    root_child0_child0_child0.setFlexGrow(1);
-    root_child0_child0_child0.setFlexShrink(1);
-    root_child0_child0.addChildAt(root_child0_child0_child0, 0);
-    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
-    assertFalse(root.getDoesLegacyStretchFlagAffectsLayout());
-  }
 }

tests/YGRoundingFunctionTest.cpp

@@ -18,6 +18,14 @@ TEST(YogaTest, rounding_value) {
   ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(5.999999, 2.0, true, false));
   ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(5.999999, 2.0, false, true));
 
+  // Test with negative numbers
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.000001, 2.0, false, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.000001, 2.0, true, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.000001, 2.0, false, true));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.999999, 2.0, false, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.999999, 2.0, true, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.999999, 2.0, false, true));
+
   // Test that numbers with fraction are rounded correctly accounting for ceil/floor flags
   ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(6.01, 2.0, false, false));
   ASSERT_FLOAT_EQ(6.5, YGRoundValueToPixelGrid(6.01, 2.0, true, false));
@@ -25,4 +33,45 @@ TEST(YogaTest, rounding_value) {
   ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(5.99, 2.0, false, false));
   ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(5.99, 2.0, true, false));
   ASSERT_FLOAT_EQ(5.5, YGRoundValueToPixelGrid(5.99, 2.0, false, true));
+  ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(6.49, 1.0, false, false));
+  ASSERT_FLOAT_EQ(7.0, YGRoundValueToPixelGrid(6.50, 1.0, false, false));
+  ASSERT_FLOAT_EQ(7.0, YGRoundValueToPixelGrid(6.51, 1.0, false, false));
+  ASSERT_FLOAT_EQ(7.0, YGRoundValueToPixelGrid(6.50, 1.0, true, false));
+  ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(6.50, 1.0, false, true));
+
+  // Test with negative numbers
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.01, 2.0, false, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.01, 2.0, true, false));
+  ASSERT_FLOAT_EQ(-6.5, YGRoundValueToPixelGrid(-6.01, 2.0, false, true));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.99, 2.0, false, false));
+  ASSERT_FLOAT_EQ(-5.5, YGRoundValueToPixelGrid(-5.99, 2.0, true, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.99, 2.0, false, true));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.49, 1.0, false, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.50, 1.0, false, false));
+  ASSERT_FLOAT_EQ(-7.0, YGRoundValueToPixelGrid(-6.51, 1.0, false, false));
+  ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-6.50, 1.0, true, false));
+  ASSERT_FLOAT_EQ(-7.0, YGRoundValueToPixelGrid(-6.50, 1.0, false, true));
+
+  // Do a simple translation test to ensure that a distance between 2 values
+  // stays consistent during an animation, even after rounding them.
+  const int LAPS = 3;
+  const int LAP_CLOSEST = 0;
+  const int LAP_CEIL = 1;
+  const int LAP_FLOOR = 2;
+  for (int currentLap = LAP_CLOSEST; currentLap < LAPS; ++currentLap)
+  {
+    float left = -2.0f;
+    float right = 2.0f;
+    const float distance = right-left;
+    float totalDistance = 1.1f;
+    const float step = 0.01f;
+    while (totalDistance >= 0.0f) {
+      left += step;
+      right += step;
+      const float snappedLeft = YGRoundValueToPixelGrid(left, 1.0, currentLap==LAP_CEIL, currentLap==LAP_FLOOR);
+      const float snappedRight = YGRoundValueToPixelGrid(right, 1.0, currentLap==LAP_CEIL, currentLap==LAP_FLOOR);
+      ASSERT_FLOAT_EQ(distance, (snappedRight-snappedLeft));
+      totalDistance -= step;
+    }
+  }
 }

tests/YGStyleTest.cpp

@@ -57,26 +57,3 @@ TEST(YogaTest, copy_style_modified_same) {
   YGNodeFree(node0);
   YGNodeFree(node1);
 }
-
-TEST(YogaTest, initialise_flexShrink_flexGrow) {
-  const YGNodeRef node0 = YGNodeNew();
-  YGNodeStyleSetFlexShrink(node0, 1);
-  ASSERT_EQ(1, YGNodeStyleGetFlexShrink(node0));
-
-  YGNodeStyleSetFlexShrink(node0, YGUndefined);
-  YGNodeStyleSetFlexGrow(node0, 3);
-  ASSERT_EQ(
-      0,
-      YGNodeStyleGetFlexShrink(
-          node0)); // Default value is Zero, if flex shrink is not defined
-  ASSERT_EQ(3, YGNodeStyleGetFlexGrow(node0));
-
-  YGNodeStyleSetFlexGrow(node0, YGUndefined);
-  YGNodeStyleSetFlexShrink(node0, 3);
-  ASSERT_EQ(
-      0,
-      YGNodeStyleGetFlexGrow(
-          node0)); // Default value is Zero, if flex grow is not defined
-  ASSERT_EQ(3, YGNodeStyleGetFlexShrink(node0));
-  YGNodeFree(node0);
-}

tests/YGTraversalTest.cpp

@@ -1,34 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <gtest/gtest.h>
-#include <yoga/Yoga.h>
-
-TEST(YogaTest, pre_order_traversal) {
-  YGNodeRef const root = YGNodeNew();
-  YGNodeRef const root_child0 = YGNodeNew();
-  YGNodeRef const root_child1 = YGNodeNew();
-  YGNodeRef const root_child0_child0 = YGNodeNew();
-  
-  YGNodeSetChildren(root, {root_child0, root_child1});
-  YGNodeInsertChild(root_child0, root_child0_child0, 0);
-  
-  std::vector<YGNodeRef> visited;
-  YGTraversePreOrder(root, [&visited](YGNodeRef node) {
-    visited.push_back(node);
-  });
-  
-  const std::vector<YGNodeRef> expected = {
-    root,
-    root_child0,
-    root_child0_child0,
-    root_child1
-  };
-  ASSERT_EQ(visited, expected);
-
-  YGNodeFreeRecursive(root);
-}

tests/YGTreeMutationTest.cpp

@@ -1,111 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include <gtest/gtest.h>
-#include <yoga/Yoga.h>
-
-static std::vector<YGNodeRef> getChildren(YGNodeRef const node)
-{
-  const uint32_t count = YGNodeGetChildCount(node);
-  std::vector<YGNodeRef> children;
-  children.reserve(count);
-  for (uint32_t i = 0 ; i < count ; i++) {
-    children.push_back(YGNodeGetChild(node, i));
-  }
-  return children;
-}
-
-TEST(YogaTest, set_children_adds_children_to_parent) {
-  YGNodeRef const root = YGNodeNew();
-  YGNodeRef const root_child0 = YGNodeNew();
-  YGNodeRef const root_child1 = YGNodeNew();
-
-  YGNodeSetChildren(root, {root_child0, root_child1});
-
-  const std::vector<YGNodeRef> children = getChildren(root);
-  const std::vector<YGNodeRef> expectedChildren = {root_child0, root_child1};
-  ASSERT_EQ(children, expectedChildren);
-
-  const std::vector<YGNodeRef> owners = {YGNodeGetOwner(root_child0), YGNodeGetOwner(root_child1)};
-  const std::vector<YGNodeRef> expectedOwners = {root, root};
-  ASSERT_EQ(owners, expectedOwners);
-
-  YGNodeFreeRecursive(root);
-}
-
-TEST(YogaTest, set_children_to_empty_removes_old_children) {
-  YGNodeRef const root = YGNodeNew();
-  YGNodeRef const root_child0 = YGNodeNew();
-  YGNodeRef const root_child1 = YGNodeNew();
-
-  YGNodeSetChildren(root, {root_child0, root_child1});
-  YGNodeSetChildren(root, {});
-
-  const std::vector<YGNodeRef> children = getChildren(root);
-  const std::vector<YGNodeRef> expectedChildren = {};
-  ASSERT_EQ(children, expectedChildren);
-
-  const std::vector<YGNodeRef> owners = {YGNodeGetOwner(root_child0), YGNodeGetOwner(root_child1)};
-  const std::vector<YGNodeRef> expectedOwners = {nullptr, nullptr};
-  ASSERT_EQ(owners, expectedOwners);
-
-  YGNodeFreeRecursive(root);
-}
-
-TEST(YogaTest, set_children_replaces_non_common_children) {
-  YGNodeRef const root = YGNodeNew();
-  YGNodeRef const root_child0 = YGNodeNew();
-  YGNodeRef const root_child1 = YGNodeNew();
-
-  YGNodeSetChildren(root, {root_child0, root_child1});
-
-  YGNodeRef const root_child2 = YGNodeNew();
-  YGNodeRef const root_child3 = YGNodeNew();
-
-  YGNodeSetChildren(root, {root_child2, root_child3});
-
-  const std::vector<YGNodeRef> children = getChildren(root);
-  const std::vector<YGNodeRef> expectedChildren = {root_child2, root_child3};
-  ASSERT_EQ(children, expectedChildren);
-
-  const std::vector<YGNodeRef> owners = {YGNodeGetOwner(root_child0), YGNodeGetOwner(root_child1)};
-  const std::vector<YGNodeRef> expectedOwners = {nullptr, nullptr};
-  ASSERT_EQ(owners, expectedOwners);
-
-  YGNodeFreeRecursive(root);
-  YGNodeFree(root_child0);
-  YGNodeFree(root_child1);
-}
-
-TEST(YogaTest, set_children_keeps_and_reorders_common_children) {
-  YGNodeRef const root = YGNodeNew();
-  YGNodeRef const root_child0 = YGNodeNew();
-  YGNodeRef const root_child1 = YGNodeNew();
-  YGNodeRef const root_child2 = YGNodeNew();
-
-  YGNodeSetChildren(root, {root_child0, root_child1, root_child2});
-
-  YGNodeRef const root_child3 = YGNodeNew();
-
-  YGNodeSetChildren(root, {root_child2, root_child1, root_child3});
-
-  const std::vector<YGNodeRef> children = getChildren(root);
-  const std::vector<YGNodeRef> expectedChildren = {root_child2, root_child1, root_child3};
-  ASSERT_EQ(children, expectedChildren);
-
-  const std::vector<YGNodeRef> owners = {
-    YGNodeGetOwner(root_child0),
-    YGNodeGetOwner(root_child1),
-    YGNodeGetOwner(root_child2),
-    YGNodeGetOwner(root_child3)
-  };
-  const std::vector<YGNodeRef> expectedOwners = {nullptr, root, root, root};
-  ASSERT_EQ(owners, expectedOwners);
-
-  YGNodeFreeRecursive(root);
-  YGNodeFree(root_child0);
-}

website/contents/getting-started/standalone.md

@@ -18,45 +18,10 @@ dependencies {
 
 ### Javascript
 
-The JavaScript bindings for Yoga can be used from node.js and within the browser.
-When using Yoga from node.js the native library is used, in browesers a pure JS
-version is used (corss-compiled using [emscripten](http://kripken.github.io/emscripten-site/)).
-
 ```
 $> yarn add yoga-layout
 ```
 
-This is an example on how to use Yoga in JavaScript, for a full API reference,
-have a look at the [flow-type definitions](https://github.com/facebook/yoga/blob/master/javascript/sources/entry-common.js#L123).
-
-```js
-import yoga, {Node} from 'yoga-layout';
-
-const root = Node.create();
-root.setWidth(500);
-root.setHeight(300);
-root.setJustifyContent(yoga.JUSTIFY_CENTER);
-
-const node1 = Node.create();
-node1.setWidth(100);
-node1.setHeight(100);
-
-const node2 = Node.create();
-node2.setWidth(100);
-node2.setHeight(100);
-
-root.insertChild(node1, 0);
-root.insertChild(node2, 1);
-
-root.calculateLayout(500, 300, yoga.DIRECTION_LTR);
-console.log(root.getComputedLayout());
-// {left: 0, top: 0, width: 500, height: 300}
-console.log(node1.getComputedLayout());
-// {left: 150, top: 0, width: 100, height: 100}
-console.log(node2.getComputedLayout());
-// {left: 250, top: 0, width: 100, height: 100}
-```
-
 ### iOS
 
 ```

yoga/Utils.cpp

@@ -49,20 +49,3 @@ bool YGFloatsEqual(const float a, const float b) {
   }
   return YGFloatIsUndefined(a) && YGFloatIsUndefined(b);
 }
-
-float YGFloatSanitize(const float& val) {
-  return YGFloatIsUndefined(val) ? 0 : val;
-}
-
-float YGUnwrapFloatOptional(const YGFloatOptional& op) {
-  return op.isUndefined() ? YGUndefined : op.getValue();
-}
-
-YGFloatOptional YGFloatOptionalMax(
-    const YGFloatOptional& op1,
-    const YGFloatOptional& op2) {
-  if (!op1.isUndefined() && !op2.isUndefined()) {
-    return op1.getValue() > op2.getValue() ? op1 : op2;
-  }
-  return op1.isUndefined() ? op2 : op1;
-}

yoga/Utils.h

@@ -40,12 +40,12 @@ struct YGCollectFlexItemsRowValues {
   float sizeConsumedOnCurrentLine;
   float totalFlexGrowFactors;
   float totalFlexShrinkScaledFactors;
-  uint32_t endOfLineIndex;
+  float endOfLineIndex;
   std::vector<YGNodeRef> relativeChildren;
   float remainingFreeSpace;
   // The size of the mainDim for the row after considering size, padding, margin
   // and border of flex items. This is used to calculate maxLineDim after going
-  // through all the rows to decide on the main axis size of owner.
+  // through all the rows to decide on the main axis size of parent.
   float mainDim;
   // The size of the crossDim for the row after considering size, padding,
   // margin and border of flex items. Used for calculating containers crossSize.
@@ -65,10 +65,6 @@ bool YGFloatsEqual(const float a, const float b);
 // compiler flag.
 float YGFloatMax(const float a, const float b);
 
-YGFloatOptional YGFloatOptionalMax(
-    const YGFloatOptional& op1,
-    const YGFloatOptional& op2);
-
 // We need custom min function, since we want that, if one argument is
 // YGUndefined then the min funtion should return the other argument as the min
 // value. We wouldn't have needed a custom min function if YGUndefined was NAN
@@ -90,14 +86,6 @@ bool YGFloatArrayEqual(
   return areEqual;
 }
 
-// This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise
-float YGFloatSanitize(const float& val);
-
-// This function unwraps optional and returns YGUndefined if not defined or
-// op.value otherwise
-// TODO: Get rid off this function
-float YGUnwrapFloatOptional(const YGFloatOptional& op);
-
 YGFlexDirection YGFlexDirectionCross(
     const YGFlexDirection flexDirection,
     const YGDirection direction);
@@ -107,18 +95,17 @@ inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
       flexDirection == YGFlexDirectionRowReverse;
 }
 
-inline YGFloatOptional YGResolveValue(const YGValue value, const float ownerSize) {
+inline float YGResolveValue(const YGValue value, const float parentSize) {
   switch (value.unit) {
     case YGUnitUndefined:
     case YGUnitAuto:
-      return YGFloatOptional();
+      return YGUndefined;
     case YGUnitPoint:
-      return YGFloatOptional(value.value);
+      return value.value;
     case YGUnitPercent:
-      return YGFloatOptional(
-          static_cast<float>(value.value * ownerSize * 0.01));
+      return value.value * parentSize * 0.01;
   }
-  return YGFloatOptional();
+  return YGUndefined;
 }
 
 inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
@@ -140,9 +127,8 @@ inline YGFlexDirection YGResolveFlexDirection(
   return flexDirection;
 }
 
-static inline YGFloatOptional YGResolveValueMargin(
+static inline float YGResolveValueMargin(
     const YGValue value,
-    const float ownerSize) {
-  return value.unit == YGUnitAuto ? YGFloatOptional(0)
-                                  : YGResolveValue(value, ownerSize);
+    const float parentSize) {
+  return value.unit == YGUnitAuto ? 0 : YGResolveValue(value, parentSize);
 }

yoga/YGConfig.cpp

@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include "YGConfig.h"
-
-const std::array<bool, YGExperimentalFeatureCount>
-    kYGDefaultExperimentalFeatures = {{false}};
-
-YGConfig::YGConfig(YGLogger logger)
-    : experimentalFeatures(kYGDefaultExperimentalFeatures),
-      useWebDefaults(false),
-      useLegacyStretchBehaviour(false),
-      shouldDiffLayoutWithoutLegacyStretchBehaviour(false),
-      pointScaleFactor(1.0f), logger(logger), cloneNodeCallback(nullptr),
-      context(nullptr) {}

yoga/YGConfig.h

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * 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-internal.h"
-#include "Yoga.h"
-
-struct YGConfig {
-  std::array<bool, YGExperimentalFeatureCount> experimentalFeatures;
-  bool useWebDefaults;
-  bool useLegacyStretchBehaviour;
-  bool shouldDiffLayoutWithoutLegacyStretchBehaviour;
-  float pointScaleFactor;
-  YGLogger logger;
-  YGCloneNodeFunc cloneNodeCallback;
-  void* context;
-
-  YGConfig(YGLogger logger);
-};

yoga/YGFloatOptional.cpp

@@ -1,92 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#include "YGFloatOptional.h"
-#include <cstdlib>
-#include <iostream>
-#include "Yoga.h"
-
-YGFloatOptional::YGFloatOptional(const float& value) {
-  if (YGFloatIsUndefined(value)) {
-    isUndefined_ = true;
-    value_ = 0;
-  } else {
-    value_ = value;
-    isUndefined_ = false;
-  }
-}
-
-YGFloatOptional::YGFloatOptional() : value_(0), isUndefined_(true) {}
-
-const float& YGFloatOptional::getValue() const {
-  if (isUndefined_) {
-    // Abort, accessing a value of an undefined float optional
-    std::cerr << "Tried to get value of an undefined YGFloatOptional\n";
-    std::exit(EXIT_FAILURE);
-  }
-  return value_;
-}
-
-void YGFloatOptional::setValue(const float& val) {
-  value_ = val;
-  isUndefined_ = false;
-}
-
-const bool& YGFloatOptional::isUndefined() const {
-  return isUndefined_;
-}
-
-bool YGFloatOptional::operator==(const YGFloatOptional& op) const {
-  if (isUndefined_ == op.isUndefined()) {
-    return isUndefined_ ? true : value_ == op.getValue();
-  }
-  return false;
-}
-
-bool YGFloatOptional::operator!=(const YGFloatOptional& op) const {
-  return !(*this == op);
-}
-
-bool YGFloatOptional::operator==(const float& val) const {
-  if (YGFloatIsUndefined(val) == isUndefined_) {
-    return isUndefined_ ? true : val == value_;
-  }
-  return false;
-}
-
-bool YGFloatOptional::operator!=(const float& val) const {
-  return !(*this == val);
-}
-
-YGFloatOptional YGFloatOptional::operator+(const YGFloatOptional& op) {
-  if (!isUndefined_ && !op.isUndefined_) {
-    return YGFloatOptional(value_ + op.value_);
-  }
-  return YGFloatOptional();
-}
-
-bool YGFloatOptional::operator>(const YGFloatOptional& op) const {
-  if (isUndefined_ || op.isUndefined_) {
-    return false;
-  }
-  return value_ > op.value_;
-}
-
-bool YGFloatOptional::operator<(const YGFloatOptional& op) const {
-  if (isUndefined_ || op.isUndefined_) {
-    return false;
-  }
-  return value_ < op.value_;
-}
-
-bool YGFloatOptional::operator>=(const YGFloatOptional& op) const {
-  return *this == op ? true : *this > op;
-}
-
-bool YGFloatOptional::operator<=(const YGFloatOptional& op) const {
-  return *this == op ? true : *this < op;
-}

yoga/YGFloatOptional.h

@@ -1,39 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-struct YGFloatOptional {
- private:
-  float value_;
-  bool isUndefined_;
-
- public:
-  explicit YGFloatOptional(const float& value);
-  explicit YGFloatOptional();
-
-  // Program will terminate if the value of an undefined is accessed. Please
-  // make sure to check if the optional is defined before calling this function.
-  // To check if float optional is defined, use `isUndefined()`.
-  const float& getValue() const;
-
-  // Sets the value of float optional, and thus isUndefined is assigned false.
-  void setValue(const float& val);
-
-  const bool& isUndefined() const;
-
-  YGFloatOptional operator+(const YGFloatOptional& op);
-  bool operator>(const YGFloatOptional& op) const;
-  bool operator<(const YGFloatOptional& op) const;
-  bool operator>=(const YGFloatOptional& op) const;
-  bool operator<=(const YGFloatOptional& op) const;
-  bool operator==(const YGFloatOptional& op) const;
-  bool operator!=(const YGFloatOptional& op) const;
-
-  bool operator==(const float& val) const;
-  bool operator!=(const float& val) const;
-};

yoga/YGLayout.cpp

@@ -19,10 +19,10 @@ YGLayout::YGLayout()
       padding(),
       direction(YGDirectionInherit),
       computedFlexBasisGeneration(0),
-      computedFlexBasis(YGFloatOptional()),
+      computedFlexBasis(YGUndefined),
       hadOverflow(false),
       generationCount(0),
-      lastOwnerDirection((YGDirection)-1),
+      lastParentDirection((YGDirection)-1),
       nextCachedMeasurementsIndex(0),
       cachedMeasurements(),
       measuredDimensions(kYGDefaultDimensionValues),
@@ -37,15 +37,18 @@ bool YGLayout::operator==(YGLayout layout) const {
       YGFloatArrayEqual(border, layout.border) &&
       YGFloatArrayEqual(padding, layout.padding) &&
       direction == layout.direction && hadOverflow == layout.hadOverflow &&
-      lastOwnerDirection == layout.lastOwnerDirection &&
+      lastParentDirection == layout.lastParentDirection &&
       nextCachedMeasurementsIndex == layout.nextCachedMeasurementsIndex &&
-      cachedLayout == layout.cachedLayout &&
-      computedFlexBasis == layout.computedFlexBasis;
+      cachedLayout == layout.cachedLayout;
 
   for (uint32_t i = 0; i < YG_MAX_CACHED_RESULT_COUNT && isEqual; ++i) {
     isEqual = isEqual && cachedMeasurements[i] == layout.cachedMeasurements[i];
   }
 
+  if (!YGFloatIsUndefined(computedFlexBasis) ||
+      !YGFloatIsUndefined(layout.computedFlexBasis)) {
+    isEqual = isEqual && (computedFlexBasis == layout.computedFlexBasis);
+  }
   if (!YGFloatIsUndefined(measuredDimensions[0]) ||
       !YGFloatIsUndefined(layout.measuredDimensions[0])) {
     isEqual =

yoga/YGLayout.h

@@ -6,7 +6,6 @@
  */
 
 #pragma once
-#include "YGFloatOptional.h"
 #include "Yoga-internal.h"
 
 struct YGLayout {
@@ -18,13 +17,13 @@ struct YGLayout {
   YGDirection direction;
 
   uint32_t computedFlexBasisGeneration;
-  YGFloatOptional computedFlexBasis;
+  float computedFlexBasis;
   bool hadOverflow;
 
   // Instead of recomputing the entire layout every single time, we
   // cache some information to break early when nothing changed
   uint32_t generationCount;
-  YGDirection lastOwnerDirection;
+  YGDirection lastParentDirection;
 
   uint32_t nextCachedMeasurementsIndex;
   std::array<YGCachedMeasurement, YG_MAX_CACHED_RESULT_COUNT>

yoga/YGNode.cpp

@@ -49,8 +49,8 @@ uint32_t YGNode::getLineIndex() const {
   return lineIndex_;
 }
 
-YGNodeRef YGNode::getOwner() const {
-  return owner_;
+YGNodeRef YGNode::getParent() const {
+  return parent_;
 }
 
 YGVector YGNode::getChildren() const {
@@ -85,9 +85,9 @@ std::array<YGValue, 2> YGNode::getResolvedDimensions() const {
   return resolvedDimensions_;
 }
 
-YGFloatOptional YGNode::getLeadingPosition(
-    const YGFlexDirection& axis,
-    const float& axisSize) const {
+float YGNode::getLeadingPosition(
+    const YGFlexDirection axis,
+    const float axisSize) {
   if (YGFlexDirectionIsRow(axis)) {
     const YGValue* leadingPosition =
         YGComputedEdgeValue(style_.position, YGEdgeStart, &YGValueUndefined);
@@ -100,13 +100,13 @@ YGFloatOptional YGNode::getLeadingPosition(
       YGComputedEdgeValue(style_.position, leading[axis], &YGValueUndefined);
 
   return leadingPosition->unit == YGUnitUndefined
-      ? YGFloatOptional(0)
+      ? 0.0f
       : YGResolveValue(*leadingPosition, axisSize);
 }
 
-YGFloatOptional YGNode::getTrailingPosition(
-    const YGFlexDirection& axis,
-    const float& axisSize) const {
+float YGNode::getTrailingPosition(
+    const YGFlexDirection axis,
+    const float axisSize) {
   if (YGFlexDirectionIsRow(axis)) {
     const YGValue* trailingPosition =
         YGComputedEdgeValue(style_.position, YGEdgeEnd, &YGValueUndefined);
@@ -119,11 +119,11 @@ YGFloatOptional YGNode::getTrailingPosition(
       YGComputedEdgeValue(style_.position, trailing[axis], &YGValueUndefined);
 
   return trailingPosition->unit == YGUnitUndefined
-      ? YGFloatOptional(0)
+      ? 0.0f
       : YGResolveValue(*trailingPosition, axisSize);
 }
 
-bool YGNode::isLeadingPositionDefined(const YGFlexDirection& axis) const {
+bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) {
   return (YGFlexDirectionIsRow(axis) &&
           YGComputedEdgeValue(style_.position, YGEdgeStart, &YGValueUndefined)
                   ->unit != YGUnitUndefined) ||
@@ -131,7 +131,7 @@ bool YGNode::isLeadingPositionDefined(const YGFlexDirection& axis) const {
           ->unit != YGUnitUndefined;
 }
 
-bool YGNode::isTrailingPosDefined(const YGFlexDirection& axis) const {
+bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) {
   return (YGFlexDirectionIsRow(axis) &&
           YGComputedEdgeValue(style_.position, YGEdgeEnd, &YGValueUndefined)
                   ->unit != YGUnitUndefined) ||
@@ -139,9 +139,9 @@ bool YGNode::isTrailingPosDefined(const YGFlexDirection& axis) const {
           ->unit != YGUnitUndefined;
 }
 
-YGFloatOptional YGNode::getLeadingMargin(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
+float YGNode::getLeadingMargin(
+    const YGFlexDirection axis,
+    const float widthSize) {
   if (YGFlexDirectionIsRow(axis) &&
       style_.margin[YGEdgeStart].unit != YGUnitUndefined) {
     return YGResolveValueMargin(style_.margin[YGEdgeStart], widthSize);
@@ -152,9 +152,9 @@ YGFloatOptional YGNode::getLeadingMargin(
       widthSize);
 }
 
-YGFloatOptional YGNode::getTrailingMargin(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
+float YGNode::getTrailingMargin(
+    const YGFlexDirection axis,
+    const float widthSize) {
   if (YGFlexDirectionIsRow(axis) &&
       style_.margin[YGEdgeEnd].unit != YGUnitUndefined) {
     return YGResolveValueMargin(style_.margin[YGEdgeEnd], widthSize);
@@ -165,9 +165,9 @@ YGFloatOptional YGNode::getTrailingMargin(
       widthSize);
 }
 
-YGFloatOptional YGNode::getMarginForAxis(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
+float YGNode::getMarginForAxis(
+    const YGFlexDirection axis,
+    const float widthSize) {
   return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
 }
 
@@ -225,11 +225,11 @@ void YGNode::setDirtiedFunc(YGDirtiedFunc dirtiedFunc) {
   dirtied_ = dirtiedFunc;
 }
 
-void YGNode::setStyle(const YGStyle& style) {
+void YGNode::setStyle(YGStyle style) {
   style_ = style;
 }
 
-void YGNode::setLayout(const YGLayout& layout) {
+void YGNode::setLayout(YGLayout layout) {
   layout_ = layout;
 }
 
@@ -237,11 +237,11 @@ void YGNode::setLineIndex(uint32_t lineIndex) {
   lineIndex_ = lineIndex;
 }
 
-void YGNode::setOwner(YGNodeRef owner) {
-  owner_ = owner;
+void YGNode::setParent(YGNodeRef parent) {
+  parent_ = parent;
 }
 
-void YGNode::setChildren(const YGVector& children) {
+void YGNode::setChildren(YGVector children) {
   children_ = children;
 }
 
@@ -305,12 +305,11 @@ void YGNode::setLayoutPadding(float padding, int index) {
   layout_.padding[index] = padding;
 }
 
-void YGNode::setLayoutLastOwnerDirection(YGDirection direction) {
-  layout_.lastOwnerDirection = direction;
+void YGNode::setLayoutLastParentDirection(YGDirection direction) {
+  layout_.lastParentDirection = direction;
 }
 
-void YGNode::setLayoutComputedFlexBasis(
-    const YGFloatOptional& computedFlexBasis) {
+void YGNode::setLayoutComputedFlexBasis(float computedFlexBasis) {
   layout_.computedFlexBasis = computedFlexBasis;
 }
 
@@ -337,54 +336,41 @@ void YGNode::setLayoutDimension(float dimension, int index) {
 
 // If both left and right are defined, then use left. Otherwise return
 // +left or -right depending on which is defined.
-YGFloatOptional YGNode::relativePosition(
-    const YGFlexDirection& axis,
-    const float& axisSize) const {
-  if (isLeadingPositionDefined(axis)) {
-    return getLeadingPosition(axis, axisSize);
-  }
-
-  YGFloatOptional trailingPosition = getTrailingPosition(axis, axisSize);
-  if (!trailingPosition.isUndefined()) {
-    trailingPosition.setValue(-1 * trailingPosition.getValue());
-  }
-  return trailingPosition;
+float YGNode::relativePosition(
+    const YGFlexDirection axis,
+    const float axisSize) {
+  return isLeadingPositionDefined(axis) ? getLeadingPosition(axis, axisSize)
+                                        : -getTrailingPosition(axis, axisSize);
 }
 
 void YGNode::setPosition(
     const YGDirection direction,
     const float mainSize,
     const float crossSize,
-    const float ownerWidth) {
+    const float parentWidth) {
   /* Root nodes should be always layouted as LTR, so we don't return negative
    * values. */
   const YGDirection directionRespectingRoot =
-      owner_ != nullptr ? direction : YGDirectionLTR;
+      parent_ != nullptr ? direction : YGDirectionLTR;
   const YGFlexDirection mainAxis =
       YGResolveFlexDirection(style_.flexDirection, directionRespectingRoot);
   const YGFlexDirection crossAxis =
       YGFlexDirectionCross(mainAxis, directionRespectingRoot);
 
-  const YGFloatOptional relativePositionMain =
-      relativePosition(mainAxis, mainSize);
-  const YGFloatOptional relativePositionCross =
-      relativePosition(crossAxis, crossSize);
+  const float relativePositionMain = relativePosition(mainAxis, mainSize);
+  const float relativePositionCross = relativePosition(crossAxis, crossSize);
 
   setLayoutPosition(
-      YGUnwrapFloatOptional(
-          getLeadingMargin(mainAxis, ownerWidth) + relativePositionMain),
+      getLeadingMargin(mainAxis, parentWidth) + relativePositionMain,
       leading[mainAxis]);
   setLayoutPosition(
-      YGUnwrapFloatOptional(
-          getTrailingMargin(mainAxis, ownerWidth) + relativePositionMain),
+      getTrailingMargin(mainAxis, parentWidth) + relativePositionMain,
       trailing[mainAxis]);
   setLayoutPosition(
-      YGUnwrapFloatOptional(
-          getLeadingMargin(crossAxis, ownerWidth) + relativePositionCross),
+      getLeadingMargin(crossAxis, parentWidth) + relativePositionCross,
       leading[crossAxis]);
   setLayoutPosition(
-      YGUnwrapFloatOptional(
-          getTrailingMargin(crossAxis, ownerWidth) + relativePositionCross),
+      getTrailingMargin(crossAxis, parentWidth) + relativePositionCross,
       trailing[crossAxis]);
 }
 
@@ -399,7 +385,7 @@ YGNode::YGNode()
       style_(YGStyle()),
       layout_(YGLayout()),
       lineIndex_(0),
-      owner_(nullptr),
+      parent_(nullptr),
       children_(YGVector()),
       nextChild_(nullptr),
       config_(nullptr),
@@ -417,7 +403,7 @@ YGNode::YGNode(const YGNode& node)
       style_(node.style_),
       layout_(node.layout_),
       lineIndex_(node.lineIndex_),
-      owner_(node.owner_),
+      parent_(node.parent_),
       children_(node.children_),
       nextChild_(node.nextChild_),
       config_(node.config_),
@@ -437,10 +423,10 @@ YGNode::YGNode(
     YGBaselineFunc baseline,
     YGDirtiedFunc dirtied,
     YGStyle style,
-    const YGLayout& layout,
+    YGLayout layout,
     uint32_t lineIndex,
-    YGNodeRef owner,
-    const YGVector& children,
+    YGNodeRef parent,
+    YGVector children,
     YGNodeRef nextChild,
     YGConfigRef config,
     bool isDirty,
@@ -455,7 +441,7 @@ YGNode::YGNode(
       style_(style),
       layout_(layout),
       lineIndex_(lineIndex),
-      owner_(owner),
+      parent_(parent),
       children_(children),
       nextChild_(nextChild),
       config_(config),
@@ -481,7 +467,7 @@ YGNode& YGNode::operator=(const YGNode& node) {
   style_ = node.style_;
   layout_ = node.layout_;
   lineIndex_ = node.getLineIndex();
-  owner_ = node.getOwner();
+  parent_ = node.getParent();
   children_ = node.getChildren();
   nextChild_ = node.getNextChild();
   config_ = node.getConfig();
@@ -514,7 +500,7 @@ YGValue YGNode::resolveFlexBasisPtr() const {
   if (flexBasis.unit != YGUnitAuto && flexBasis.unit != YGUnitUndefined) {
     return flexBasis;
   }
-  if (!style_.flex.isUndefined() && style_.flex.getValue() > 0.0f) {
+  if (!YGFloatIsUndefined(style_.flex) && style_.flex > 0.0f) {
     return config_->useWebDefaults ? YGValueAuto : YGValueZero;
   }
   return YGValueAuto;
@@ -532,9 +518,9 @@ void YGNode::resolveDimension() {
   }
 }
 
-YGDirection YGNode::resolveDirection(const YGDirection ownerDirection) {
+YGDirection YGNode::resolveDirection(const YGDirection parentDirection) {
   if (style_.direction == YGDirectionInherit) {
-    return ownerDirection > YGDirectionInherit ? ownerDirection
+    return parentDirection > YGDirectionInherit ? parentDirection
                                                 : YGDirectionLTR;
   } else {
     return style_.direction;
@@ -564,35 +550,32 @@ void YGNode::cloneChildrenIfNeeded() {
   }
 
   const YGNodeRef firstChild = children_.front();
-  if (firstChild->getOwner() == this) {
-    // If the first child has this node as its owner, we assume that it is
+  if (firstChild->getParent() == this) {
+    // If the first child has this node as its parent, we assume that it is
     // already unique. We can do this because if we have it has a child, that
-    // means that its owner was at some point cloned which made that subtree
+    // means that its parent was at some point cloned which made that subtree
     // immutable. We also assume that all its sibling are cloned as well.
     return;
   }
 
-  const YGCloneNodeFunc cloneNodeCallback = config_->cloneNodeCallback;
+  const YGNodeClonedFunc cloneNodeCallback = config_->cloneNodeCallback;
   for (uint32_t i = 0; i < childCount; ++i) {
     const YGNodeRef oldChild = children_[i];
-    YGNodeRef newChild = nullptr;
-    if (cloneNodeCallback) {
-      newChild = cloneNodeCallback(oldChild, this, i);
-    }
-    if (newChild == nullptr) {
-      newChild = YGNodeClone(oldChild);
-    }
+    const YGNodeRef newChild = YGNodeClone(oldChild);
     replaceChild(newChild, i);
-    newChild->setOwner(this);
+    newChild->setParent(this);
+    if (cloneNodeCallback) {
+      cloneNodeCallback(oldChild, newChild, this, i);
+    }
   }
 }
 
 void YGNode::markDirtyAndPropogate() {
   if (!isDirty_) {
     setDirty(true);
-    setLayoutComputedFlexBasis(YGFloatOptional());
-    if (owner_) {
-      owner_->markDirtyAndPropogate();
+    setLayoutComputedFlexBasis(YGUndefined);
+    if (parent_) {
+      parent_->markDirtyAndPropogate();
     }
   }
 }
@@ -606,28 +589,28 @@ void YGNode::markDirtyAndPropogateDownwards() {
 
 float YGNode::resolveFlexGrow() {
   // Root nodes flexGrow should always be 0
-  if (owner_ == nullptr) {
+  if (parent_ == nullptr) {
     return 0.0;
   }
-  if (!style_.flexGrow.isUndefined()) {
-    return style_.flexGrow.getValue();
+  if (!YGFloatIsUndefined(style_.flexGrow)) {
+    return style_.flexGrow;
   }
-  if (!style_.flex.isUndefined() && style_.flex.getValue() > 0.0f) {
-    return style_.flex.getValue();
+  if (!YGFloatIsUndefined(style_.flex) && style_.flex > 0.0f) {
+    return style_.flex;
   }
   return kDefaultFlexGrow;
 }
 
 float YGNode::resolveFlexShrink() {
-  if (owner_ == nullptr) {
+  if (parent_ == nullptr) {
     return 0.0;
   }
-  if (!style_.flexShrink.isUndefined()) {
-    return style_.flexShrink.getValue();
+  if (!YGFloatIsUndefined(style_.flexShrink)) {
+    return style_.flexShrink;
   }
-  if (!config_->useWebDefaults && !style_.flex.isUndefined() &&
-      style_.flex.getValue() < 0.0f) {
-    return -style_.flex.getValue();
+  if (!config_->useWebDefaults && !YGFloatIsUndefined(style_.flex) &&
+      style_.flex < 0.0f) {
+    return -style_.flex;
   }
   return config_->useWebDefaults ? kWebDefaultFlexShrink : kDefaultFlexShrink;
 }
@@ -638,7 +621,7 @@ bool YGNode::isNodeFlexible() {
       (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
 }
 
-float YGNode::getLeadingBorder(const YGFlexDirection& axis) const {
+float YGNode::getLeadingBorder(const YGFlexDirection axis) {
   if (YGFlexDirectionIsRow(axis) &&
       style_.border[YGEdgeStart].unit != YGUnitUndefined &&
       !YGFloatIsUndefined(style_.border[YGEdgeStart].value) &&
@@ -651,7 +634,7 @@ float YGNode::getLeadingBorder(const YGFlexDirection& axis) const {
   return YGFloatMax(computedEdgeValue, 0.0f);
 }
 
-float YGNode::getTrailingBorder(const YGFlexDirection& flexDirection) const {
+float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) {
   if (YGFlexDirectionIsRow(flexDirection) &&
       style_.border[YGEdgeEnd].unit != YGUnitUndefined &&
       !YGFloatIsUndefined(style_.border[YGEdgeEnd].value) &&
@@ -665,52 +648,51 @@ float YGNode::getTrailingBorder(const YGFlexDirection& flexDirection) const {
   return YGFloatMax(computedEdgeValue, 0.0f);
 }
 
-YGFloatOptional YGNode::getLeadingPadding(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
-  const YGFloatOptional& paddingEdgeStart =
-      YGResolveValue(style_.padding[YGEdgeStart], widthSize);
+float YGNode::getLeadingPadding(
+    const YGFlexDirection axis,
+    const float widthSize) {
   if (YGFlexDirectionIsRow(axis) &&
       style_.padding[YGEdgeStart].unit != YGUnitUndefined &&
-      !paddingEdgeStart.isUndefined() && paddingEdgeStart.getValue() > 0.0f) {
-    return paddingEdgeStart;
+      !YGFloatIsUndefined(
+          YGResolveValue(style_.padding[YGEdgeStart], widthSize)) &&
+      YGResolveValue(style_.padding[YGEdgeStart], widthSize) > 0.0f) {
+    return YGResolveValue(style_.padding[YGEdgeStart], widthSize);
   }
 
-  YGFloatOptional resolvedValue = YGResolveValue(
+  float resolvedValue = YGResolveValue(
       *YGComputedEdgeValue(style_.padding, leading[axis], &YGValueZero),
       widthSize);
-  return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
+  return YGFloatMax(resolvedValue, 0.0f);
 }
 
-YGFloatOptional YGNode::getTrailingPadding(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
+float YGNode::getTrailingPadding(
+    const YGFlexDirection axis,
+    const float widthSize) {
   if (YGFlexDirectionIsRow(axis) &&
       style_.padding[YGEdgeEnd].unit != YGUnitUndefined &&
-      !YGResolveValue(style_.padding[YGEdgeEnd], widthSize).isUndefined() &&
-      YGResolveValue(style_.padding[YGEdgeEnd], widthSize).getValue() >= 0.0f) {
+      !YGFloatIsUndefined(
+          YGResolveValue(style_.padding[YGEdgeEnd], widthSize)) &&
+      YGResolveValue(style_.padding[YGEdgeEnd], widthSize) >= 0.0f) {
     return YGResolveValue(style_.padding[YGEdgeEnd], widthSize);
   }
 
-  YGFloatOptional resolvedValue = YGResolveValue(
+  float resolvedValue = YGResolveValue(
       *YGComputedEdgeValue(style_.padding, trailing[axis], &YGValueZero),
       widthSize);
 
-  return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
+  return YGFloatMax(resolvedValue, 0.0f);
 }
 
-YGFloatOptional YGNode::getLeadingPaddingAndBorder(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
-  return getLeadingPadding(axis, widthSize) +
-      YGFloatOptional(getLeadingBorder(axis));
+float YGNode::getLeadingPaddingAndBorder(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  return getLeadingPadding(axis, widthSize) + getLeadingBorder(axis);
 }
 
-YGFloatOptional YGNode::getTrailingPaddingAndBorder(
-    const YGFlexDirection& axis,
-    const float& widthSize) const {
-  return getTrailingPadding(axis, widthSize) +
-      YGFloatOptional(getTrailingBorder(axis));
+float YGNode::getTrailingPaddingAndBorder(
+    const YGFlexDirection axis,
+    const float widthSize) {
+  return getTrailingPadding(axis, widthSize) + getTrailingBorder(axis);
 }
 
 bool YGNode::didUseLegacyFlag() {

yoga/YGNode.h

@@ -7,7 +7,6 @@
 
 #pragma once
 #include <stdio.h>
-#include "YGConfig.h"
 #include "YGLayout.h"
 #include "YGStyle.h"
 #include "Yoga-internal.h"
@@ -24,16 +23,14 @@ struct YGNode {
   YGStyle style_;
   YGLayout layout_;
   uint32_t lineIndex_;
-  YGNodeRef owner_;
+  YGNodeRef parent_;
   YGVector children_;
   YGNodeRef nextChild_;
   YGConfigRef config_;
   bool isDirty_;
   std::array<YGValue, 2> resolvedDimensions_;
 
-  YGFloatOptional relativePosition(
-      const YGFlexDirection& axis,
-      const float& axisSize) const;
+  float relativePosition(const YGFlexDirection axis, const float axisSize);
 
  public:
   YGNode();
@@ -50,10 +47,10 @@ struct YGNode {
       YGBaselineFunc baseline,
       YGDirtiedFunc dirtied,
       YGStyle style,
-      const YGLayout& layout,
+      YGLayout layout,
       uint32_t lineIndex,
-      YGNodeRef owner,
-      const YGVector& children,
+      YGNodeRef parent,
+      YGVector children,
       YGNodeRef nextChild,
       YGConfigRef config,
       bool isDirty,
@@ -72,12 +69,7 @@ struct YGNode {
   // For Performance reasons passing as reference.
   YGLayout& getLayout();
   uint32_t getLineIndex() const;
-  // returns the YGNodeRef that owns this YGNode. An owner is used to identify
-  // the YogaTree that a YGNode belongs to.
-  // This method will return the parent of the YGNode when a YGNode only belongs
-  // to one YogaTree or nullptr when the YGNode is shared between two or more
-  // YogaTrees.
-  YGNodeRef getOwner() const;
+  YGNodeRef getParent() const;
   YGVector getChildren() const;
   uint32_t getChildrenCount() const;
   YGNodeRef getChild(uint32_t index) const;
@@ -88,36 +80,23 @@ struct YGNode {
   YGValue getResolvedDimension(int index);
 
   // Methods related to positions, margin, padding and border
-  YGFloatOptional getLeadingPosition(const YGFlexDirection& axis,
-      const float& axisSize) const;
-  bool isLeadingPositionDefined(const YGFlexDirection& axis) const;
-  bool isTrailingPosDefined(const YGFlexDirection& axis) const;
-  YGFloatOptional getTrailingPosition(
-      const YGFlexDirection& axis,
-      const float& axisSize) const;
-  YGFloatOptional getLeadingMargin(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
-  YGFloatOptional getTrailingMargin(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
-  float getLeadingBorder(const YGFlexDirection& flexDirection) const;
-  float getTrailingBorder(const YGFlexDirection& flexDirection) const;
-  YGFloatOptional getLeadingPadding(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
-  YGFloatOptional getTrailingPadding(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
-  YGFloatOptional getLeadingPaddingAndBorder(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
-  YGFloatOptional getTrailingPaddingAndBorder(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
-  YGFloatOptional getMarginForAxis(
-      const YGFlexDirection& axis,
-      const float& widthSize) const;
+  float getLeadingPosition(const YGFlexDirection axis, const float axisSize);
+  bool isLeadingPositionDefined(const YGFlexDirection axis);
+  bool isTrailingPosDefined(const YGFlexDirection axis);
+  float getTrailingPosition(const YGFlexDirection axis, const float axisSize);
+  float getLeadingMargin(const YGFlexDirection axis, const float widthSize);
+  float getTrailingMargin(const YGFlexDirection axis, const float widthSize);
+  float getLeadingBorder(const YGFlexDirection flexDirection);
+  float getTrailingBorder(const YGFlexDirection flexDirection);
+  float getLeadingPadding(const YGFlexDirection axis, const float widthSize);
+  float getTrailingPadding(const YGFlexDirection axis, const float widthSize);
+  float getLeadingPaddingAndBorder(
+      const YGFlexDirection axis,
+      const float widthSize);
+  float getTrailingPaddingAndBorder(
+      const YGFlexDirection axis,
+      const float widthSize);
+  float getMarginForAxis(const YGFlexDirection axis, const float widthSize);
   // Setters
 
   void setContext(void* context);
@@ -127,18 +106,18 @@ struct YGNode {
   void setMeasureFunc(YGMeasureFunc measureFunc);
   void setBaseLineFunc(YGBaselineFunc baseLineFunc);
   void setDirtiedFunc(YGDirtiedFunc dirtiedFunc);
-  void setStyle(const YGStyle& style);
+  void setStyle(YGStyle style);
   void setStyleFlexDirection(YGFlexDirection direction);
   void setStyleAlignContent(YGAlign alignContent);
-  void setLayout(const YGLayout& layout);
+  void setLayout(YGLayout layout);
   void setLineIndex(uint32_t lineIndex);
-  void setOwner(YGNodeRef owner);
-  void setChildren(const YGVector& children);
+  void setParent(YGNodeRef parent);
+  void setChildren(YGVector children);
   void setNextChild(YGNodeRef nextChild);
   void setConfig(YGConfigRef config);
   void setDirty(bool isDirty);
-  void setLayoutLastOwnerDirection(YGDirection direction);
-  void setLayoutComputedFlexBasis(const YGFloatOptional& computedFlexBasis);
+  void setLayoutLastParentDirection(YGDirection direction);
+  void setLayoutComputedFlexBasis(float computedFlexBasis);
   void setLayoutComputedFlexBasisGeneration(
       uint32_t computedFlexBasisGeneration);
   void setLayoutMeasuredDimension(float measuredDimension, int index);
@@ -153,7 +132,7 @@ struct YGNode {
       const YGDirection direction,
       const float mainSize,
       const float crossSize,
-      const float ownerWidth);
+      const float parentWidth);
   void setAndPropogateUseLegacyFlag(bool useLegacyFlag);
   void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout);
   void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag);
@@ -164,7 +143,7 @@ struct YGNode {
   YGValue marginTrailingValue(const YGFlexDirection axis) const;
   YGValue resolveFlexBasisPtr() const;
   void resolveDimension();
-  YGDirection resolveDirection(const YGDirection ownerDirection);
+  YGDirection resolveDirection(const YGDirection parentDirection);
   void clearChildren();
   /// Replaces the occurrences of oldChild with newChild
   void replaceChild(YGNodeRef oldChild, YGNodeRef newChild);

yoga/YGNodePrint.cpp

@@ -39,12 +39,10 @@ static void appendFormatedString(string* str, const char* fmt, ...) {
   str->append(result);
 }
 
-static void appendFloatOptionalIfDefined(
-    string* base,
-    const string key,
-    const YGFloatOptional num) {
-  if (!num.isUndefined()) {
-    appendFormatedString(base, "%s: %g; ", key.c_str(), num.getValue());
+static void
+appendFloatIfNotUndefined(string* base, const string key, const float num) {
+  if (!YGFloatIsUndefined(num)) {
+    appendFormatedString(base, "%s: %g; ", key.c_str(), num);
   }
 }
 
@@ -72,10 +70,7 @@ appendNumberIfNotAuto(string* base, const string& key, const YGValue number) {
 
 static void
 appendNumberIfNotZero(string* base, const string& str, const YGValue number) {
-
-  if (number.unit == YGUnitAuto) {
-    base->append(str + ": auto; ");
-  } else if (!YGFloatsEqual(number.value, 0)) {
+  if (!YGFloatsEqual(number.value, 0)) {
     appendNumberIfNotUndefined(base, str, number);
   }
 }
@@ -157,11 +152,10 @@ void YGNodeToString(
       appendFormatedString(
           str, "align-self: %s; ", YGAlignToString(node->getStyle().alignSelf));
     }
-    appendFloatOptionalIfDefined(str, "flex-grow", node->getStyle().flexGrow);
-    appendFloatOptionalIfDefined(
-        str, "flex-shrink", node->getStyle().flexShrink);
+    appendFloatIfNotUndefined(str, "flex-grow", node->getStyle().flexGrow);
+    appendFloatIfNotUndefined(str, "flex-shrink", node->getStyle().flexShrink);
     appendNumberIfNotAuto(str, "flex-basis", node->getStyle().flexBasis);
-    appendFloatOptionalIfDefined(str, "flex", node->getStyle().flex);
+    appendFloatIfNotUndefined(str, "flex", node->getStyle().flex);
 
     if (node->getStyle().flexWrap != YGNode().getStyle().flexWrap) {
       appendFormatedString(

yoga/YGStyle.cpp

@@ -7,9 +7,9 @@
 
 #include "YGStyle.h"
 
-const YGValue kYGValueUndefined = {0, YGUnitUndefined};
+const YGValue kYGValueUndefined = {YGUndefined, YGUnitUndefined};
 
-const YGValue kYGValueAuto = {0, YGUnitAuto};
+const YGValue kYGValueAuto = {YGUndefined, YGUnitAuto};
 
 const std::array<YGValue, YGEdgeCount> kYGDefaultEdgeValuesUnit = {
     {kYGValueUndefined,
@@ -39,9 +39,9 @@ YGStyle::YGStyle()
       flexWrap(YGWrapNoWrap),
       overflow(YGOverflowVisible),
       display(YGDisplayFlex),
-      flex(YGFloatOptional()),
-      flexGrow(YGFloatOptional()),
-      flexShrink(YGFloatOptional()),
+      flex(YGUndefined),
+      flexGrow(YGUndefined),
+      flexShrink(YGUndefined),
       flexBasis(kYGValueAuto),
       margin(kYGDefaultEdgeValuesUnit),
       position(kYGDefaultEdgeValuesUnit),
@@ -50,7 +50,7 @@ YGStyle::YGStyle()
       dimensions(kYGDefaultDimensionValuesAutoUnit),
       minDimensions(kYGDefaultDimensionValuesUnit),
       maxDimensions(kYGDefaultDimensionValuesUnit),
-      aspectRatio(YGFloatOptional()) {}
+      aspectRatio(YGUndefined) {}
 
 // Yoga specific properties, not compatible with flexbox specification
 bool YGStyle::operator==(const YGStyle& style) {
@@ -69,31 +69,25 @@ bool YGStyle::operator==(const YGStyle& style) {
       YGValueArrayEqual(minDimensions, style.minDimensions) &&
       YGValueArrayEqual(maxDimensions, style.maxDimensions);
 
-  areNonFloatValuesEqual =
-      areNonFloatValuesEqual && flex.isUndefined() == style.flex.isUndefined();
-  if (areNonFloatValuesEqual && !flex.isUndefined() &&
-      !style.flex.isUndefined()) {
+  if (!(YGFloatIsUndefined(flex) && YGFloatIsUndefined(style.flex))) {
+    areNonFloatValuesEqual = areNonFloatValuesEqual && flex == style.flex;
+  }
+
+  if (!(YGFloatIsUndefined(flexGrow) && YGFloatIsUndefined(style.flexGrow))) {
     areNonFloatValuesEqual =
-        areNonFloatValuesEqual && flex.getValue() == style.flex.getValue();
+        areNonFloatValuesEqual && flexGrow == style.flexGrow;
   }
 
-  areNonFloatValuesEqual = areNonFloatValuesEqual &&
-      flexGrow.isUndefined() == style.flexGrow.isUndefined();
-  if (areNonFloatValuesEqual && !flexGrow.isUndefined()) {
-    areNonFloatValuesEqual = areNonFloatValuesEqual &&
-        flexGrow.getValue() == style.flexGrow.getValue();
+  if (!(YGFloatIsUndefined(flexShrink) &&
+        YGFloatIsUndefined(style.flexShrink))) {
+    areNonFloatValuesEqual =
+        areNonFloatValuesEqual && flexShrink == style.flexShrink;
   }
 
-  areNonFloatValuesEqual = areNonFloatValuesEqual &&
-      flexShrink.isUndefined() == style.flexShrink.isUndefined();
-  if (areNonFloatValuesEqual && !style.flexShrink.isUndefined()) {
-    areNonFloatValuesEqual = areNonFloatValuesEqual &&
-        flexShrink.getValue() == style.flexShrink.getValue();
-  }
-
-  if (!(aspectRatio.isUndefined() && style.aspectRatio.isUndefined())) {
-    areNonFloatValuesEqual = areNonFloatValuesEqual &&
-        aspectRatio.getValue() == style.aspectRatio.getValue();
+  if (!(YGFloatIsUndefined(aspectRatio) &&
+        YGFloatIsUndefined(style.aspectRatio))) {
+    areNonFloatValuesEqual =
+        areNonFloatValuesEqual && aspectRatio == style.aspectRatio;
   }
 
   return areNonFloatValuesEqual;

yoga/YGStyle.h

@@ -6,7 +6,6 @@
  */
 
 #pragma once
-#include "YGFloatOptional.h"
 #include "Yoga-internal.h"
 #include "Yoga.h"
 
@@ -21,9 +20,9 @@ struct YGStyle {
   YGWrap flexWrap;
   YGOverflow overflow;
   YGDisplay display;
-  YGFloatOptional flex;
-  YGFloatOptional flexGrow;
-  YGFloatOptional flexShrink;
+  float flex;
+  float flexGrow;
+  float flexShrink;
   YGValue flexBasis;
   std::array<YGValue, YGEdgeCount> margin;
   std::array<YGValue, YGEdgeCount> position;
@@ -32,7 +31,7 @@ struct YGStyle {
   std::array<YGValue, 2> dimensions;
   std::array<YGValue, 2> minDimensions;
   std::array<YGValue, 2> maxDimensions;
-  YGFloatOptional aspectRatio;
+  float aspectRatio;
 
   YGStyle();
   // Yoga specific properties, not compatible with flexbox specification

yoga/Yoga-internal.h

@@ -87,6 +87,16 @@ struct YGCachedMeasurement {
 // layouts should not require more than 16 entries to fit within the cache.
 #define YG_MAX_CACHED_RESULT_COUNT 16
 
+struct YGConfig {
+  bool experimentalFeatures[YGExperimentalFeatureCount + 1];
+  bool useWebDefaults;
+  bool useLegacyStretchBehaviour;
+  bool shouldDiffLayoutWithoutLegacyStretchBehaviour;
+  float pointScaleFactor;
+  YGLogger logger;
+  YGNodeClonedFunc cloneNodeCallback;
+  void* context;
+};
 
 static const float kDefaultFlexGrow = 0.0f;
 static const float kDefaultFlexShrink = 0.0f;

yoga/Yoga.h

@@ -62,8 +62,10 @@ typedef int (*YGLogger)(const YGConfigRef config,
                         YGLogLevel level,
                         const char *format,
                         va_list args);
-typedef YGNodeRef (
-    *YGCloneNodeFunc)(YGNodeRef oldNode, YGNodeRef owner, int childIndex);
+typedef void (*YGNodeClonedFunc)(YGNodeRef oldNode,
+                                 YGNodeRef newNode,
+                                 YGNodeRef parent,
+                                 int childIndex);
 
 // YGNode
 WIN_EXPORT YGNodeRef YGNodeNew(void);
@@ -77,31 +79,16 @@ WIN_EXPORT int32_t YGNodeGetInstanceCount(void);
 WIN_EXPORT void YGNodeInsertChild(const YGNodeRef node,
                                   const YGNodeRef child,
                                   const uint32_t index);
-
-// This function inserts the child YGNodeRef as a children of the node received
-// by parameter and set the Owner of the child object to null. This function is
-// expected to be called when using Yoga in persistent mode in order to share a
-// YGNodeRef object as a child of two different Yoga trees. The child YGNodeRef
-// is expected to be referenced from its original owner and from a clone of its
-// original owner.
-WIN_EXPORT void YGNodeInsertSharedChild(
-    const YGNodeRef node,
-    const YGNodeRef child,
-    const uint32_t index);
 WIN_EXPORT void YGNodeRemoveChild(const YGNodeRef node, const YGNodeRef child);
 WIN_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef node);
 WIN_EXPORT YGNodeRef YGNodeGetChild(const YGNodeRef node, const uint32_t index);
-WIN_EXPORT YGNodeRef YGNodeGetOwner(const YGNodeRef node);
+WIN_EXPORT YGNodeRef YGNodeGetParent(const YGNodeRef node);
 WIN_EXPORT uint32_t YGNodeGetChildCount(const YGNodeRef node);
-WIN_EXPORT void YGNodeSetChildren(
-    YGNodeRef const owner,
-    const YGNodeRef children[],
-    const uint32_t count);
 
 WIN_EXPORT void YGNodeCalculateLayout(const YGNodeRef node,
                                       const float availableWidth,
                                       const float availableHeight,
-                                      const YGDirection ownerDirection);
+                                      const YGDirection parentDirection);
 
 // Mark a node as dirty. Only valid for nodes with a custom measure function
 // set.
@@ -203,6 +190,7 @@ YG_NODE_STYLE_PROPERTY(YGPositionType, PositionType, positionType);
 YG_NODE_STYLE_PROPERTY(YGWrap, FlexWrap, flexWrap);
 YG_NODE_STYLE_PROPERTY(YGOverflow, Overflow, overflow);
 YG_NODE_STYLE_PROPERTY(YGDisplay, Display, display);
+
 YG_NODE_STYLE_PROPERTY(float, Flex, flex);
 YG_NODE_STYLE_PROPERTY(float, FlexGrow, flexGrow);
 YG_NODE_STYLE_PROPERTY(float, FlexShrink, flexShrink);
@@ -244,7 +232,6 @@ YG_NODE_LAYOUT_PROPERTY(float, Width);
 YG_NODE_LAYOUT_PROPERTY(float, Height);
 YG_NODE_LAYOUT_PROPERTY(YGDirection, Direction);
 YG_NODE_LAYOUT_PROPERTY(bool, HadOverflow);
-bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(const YGNodeRef node);
 
 // Get the computed values for these nodes after performing layout. If they were set using
 // point values then the returned value will be the same as YGNodeStyleGetXXX. However if
@@ -262,12 +249,10 @@ WIN_EXPORT void YGAssertWithNode(const YGNodeRef node, const bool condition, con
 WIN_EXPORT void YGAssertWithConfig(const YGConfigRef config,
                                    const bool condition,
                                    const char *message);
+
 // Set this to number of pixels in 1 point to round calculation results
 // If you want to avoid rounding - set PointScaleFactor to 0
 WIN_EXPORT void YGConfigSetPointScaleFactor(const YGConfigRef config, const float pixelsInPoint);
-void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
-    const YGConfigRef config,
-    const bool shouldDiffLayout);
 
 // Yoga previously had an error where containers would take the maximum space possible instead of
 // the minimum
@@ -295,8 +280,8 @@ WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled(const YGConfigRef config,
 WIN_EXPORT void YGConfigSetUseWebDefaults(const YGConfigRef config, const bool enabled);
 WIN_EXPORT bool YGConfigGetUseWebDefaults(const YGConfigRef config);
 
-WIN_EXPORT void YGConfigSetCloneNodeFunc(const YGConfigRef config,
-                                          const YGCloneNodeFunc callback);
+WIN_EXPORT void YGConfigSetNodeClonedFunc(const YGConfigRef config,
+                                          const YGNodeClonedFunc callback);
 
 // Export only for C#
 WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
@@ -311,17 +296,3 @@ WIN_EXPORT float YGRoundValueToPixelGrid(
     const bool forceFloor);
 
 YG_EXTERN_C_END
-
-#ifdef __cplusplus
-
-#include <functional>
-#include <vector>
-
-// Calls f on each node in the tree including the given node argument.
-extern void YGTraversePreOrder(YGNodeRef const node, std::function<void(YGNodeRef node)>&& f);
-
-extern void YGNodeSetChildren(
-    YGNodeRef const owner,
-    const std::vector<YGNodeRef>& children);
-
-#endif

yoga_defs.bzl

@@ -32,7 +32,6 @@ BASE_COMPILER_FLAGS = [
   '-Wall',
   '-Werror',
   '-O3',
-  '-ffast-math',
 ]
 
 LIBRARY_COMPILER_FLAGS = BASE_COMPILER_FLAGS + [
@@ -113,3 +112,4 @@ def prebuilt_jar(*args, **kwargs):
 
 def is_apple_platform():
   return True
+