fix benchmark ci warnings

Author: intergalacticspacehighway

yoga/algorithm/grid/GridLayout.cpp

@@ -254,7 +254,7 @@ void calculateGridLayoutInternal(Node* node,
     for (auto& item : itemAreas) {
       auto [containingBlockWidth, containingBlockHeight] = trackSizing.getContainingBlockSizeForItem(item);
       float gridAreaLeft = 0.0f;
-      for (size_t i = 0; i < item.columnStart && i < columnTracks.size(); i++) {
+      for (size_t i = 0; i < static_cast<size_t>(item.columnStart) && i < columnTracks.size(); i++) {
         gridAreaLeft += columnTracks[i].baseSize;
         if (i < columnTracks.size() - 1) {
           // Add both explicit gap and content-distribution spacing
@@ -263,7 +263,7 @@ void calculateGridLayoutInternal(Node* node,
       }
 
       float gridAreaTop = 0.0f;
-      for (size_t i = 0; i < item.rowStart && i < rowTracks.size(); i++) {
+      for (size_t i = 0; i < static_cast<size_t>(item.rowStart) && i < rowTracks.size(); i++) {
         gridAreaTop += rowTracks[i].baseSize;
         if (i < rowTracks.size() - 1) {
           // Add both explicit gap and content-distribution spacing
@@ -451,13 +451,13 @@ GridTracks createGridTracks(yoga::Node* node, const AutoPlacement& autoPlacement
     columnTracks.push_back(autoColumnTrack);
   }
 
-  for (auto i = 0; i < gridExplicitColumns.size(); i++) {
+  for (size_t i = 0; i < gridExplicitColumns.size(); i++) {
     columnTracks.push_back(gridExplicitColumns[i]);
   }
 
   // The first track after the last explicitly-sized track receives the first specified size
   // i.e. the pattern repeats forwards
-  for (auto i = 0; i < autoPlacement.maxColumnEnd - gridExplicitColumns.size(); i++) {
+  for (size_t i = 0; i < static_cast<size_t>(autoPlacement.maxColumnEnd) - gridExplicitColumns.size(); i++) {
     auto autoColumnTrack = autoColumnTracks[i % autoColumnTracksSize];
     columnTracks.push_back(autoColumnTrack);
   }
@@ -469,10 +469,10 @@ GridTracks createGridTracks(yoga::Node* node, const AutoPlacement& autoPlacement
     auto autoRowTrack = autoRowTracks[autoRowTracksSize - currentRowTrackIndex - 1];
     rowTracks.push_back(autoRowTrack);
   }
-  for (auto i = 0; i < gridExplicitRows.size(); i++) {
+  for (size_t i = 0; i < gridExplicitRows.size(); i++) {
     rowTracks.push_back(gridExplicitRows[i]);
   }
-  for (auto i = 0; i < autoPlacement.maxRowEnd - gridExplicitRows.size(); i++) {
+  for (size_t i = 0; i < static_cast<size_t>(autoPlacement.maxRowEnd) - gridExplicitRows.size(); i++) {
     auto autoRowTrack = autoRowTracks[i % autoRowTracksSize];
     rowTracks.push_back(autoRowTrack);
   }

yoga/algorithm/grid/TrackSizing.h

@@ -1276,19 +1276,19 @@ struct TrackSizing {
     auto rowGap = node->style().computeGapForDimension(Dimension::Height, containerInnerHeight);
 
     // Calculate width: sum of spanned column tracks + gaps
-    for (int i = item.columnStart; i < item.columnEnd && i < (int)columnTracks.size(); i++) {
+    for (size_t i = item.columnStart; i < static_cast<size_t>(item.columnEnd) && i < columnTracks.size(); i++) {
       containingBlockWidth += columnTracks[i].baseSize;
       // Add column gap if not the last spanned track
-      if (i < item.columnEnd - 1) {
+      if (i < static_cast<size_t>(item.columnEnd - 1)) {
         containingBlockWidth += columnGap;
       }
     }
 
     // Calculate height: sum of spanned row tracks + gaps
-    for (int i = item.rowStart; i < item.rowEnd && i < (int)rowTracks.size(); i++) {
+    for (size_t i = item.rowStart; i < static_cast<size_t>(item.rowEnd) && i < rowTracks.size(); i++) {
       containingBlockHeight += rowTracks[i].baseSize;
       // Add row gap if not the last spanned track
-      if (i < item.rowEnd - 1) {
+      if (i < static_cast<size_t>(item.rowEnd - 1)) {
         containingBlockHeight += rowGap;
       }
     }
@@ -1306,10 +1306,10 @@ struct TrackSizing {
     auto rowGap = node->style().computeGapForDimension(Dimension::Height, containerInnerHeight);
     auto columnGap = node->style().computeGapForDimension(Dimension::Width, containerInnerWidth);
 
-    for (size_t i = item.rowStart; i < item.rowEnd && i < rowTracks.size(); i++) {
+    for (size_t i = item.rowStart; i < static_cast<size_t>(item.rowEnd) && i < rowTracks.size(); i++) {
       if (isFixedSizingFunction(rowTracks[i].maxSizingFunction, containerInnerHeight)) {
         containingBlockHeight += rowTracks[i].maxSizingFunction.resolve(containerInnerHeight).unwrap();
-        if (i < item.rowEnd - 1) {
+        if (i < static_cast<size_t>(item.rowEnd - 1)) {
           containingBlockHeight += rowGap;
         }
       } else {
@@ -1321,10 +1321,10 @@ struct TrackSizing {
     // In trackSizing columnTracks
     // If calculating the layout of a grid item in this step depends on the available space in the block axis, assume the available space that it would have if any row with a definite max track sizing function had that size and all other rows were infinite.
     if (dimension == Dimension::Width) {
-      for (size_t i = item.columnStart; i < item.columnEnd && i < columnTracks.size(); i++) {
+      for (size_t i = item.columnStart; i < static_cast<size_t>(item.columnEnd) && i < columnTracks.size(); i++) {
         if (isFixedSizingFunction(columnTracks[i].maxSizingFunction, containerInnerWidth)) {
           containingBlockWidth += columnTracks[i].maxSizingFunction.resolve(containerInnerWidth).unwrap();
-          if (i < item.columnEnd - 1) {
+          if (i < static_cast<size_t>(item.columnEnd - 1)) {
             containingBlockWidth += columnGap;
           }
         } else {
@@ -1336,9 +1336,9 @@ struct TrackSizing {
     // In trackSizing rowTracks
     // To find the inline-axis available space for any items whose block-axis size contributions require it, use the grid column sizes calculated in the previous step. If the grid container’s inline size is definite, also apply justify-content to account for the effective column gap sizes.
     else if (dimension == Dimension::Height) {
-      for (size_t i = item.columnStart; i < item.columnEnd && i < columnTracks.size(); i++) {
+      for (size_t i = item.columnStart; i < static_cast<size_t>(item.columnEnd) && i < columnTracks.size(); i++) {
         containingBlockWidth += columnTracks[i].baseSize;
-        if (i < item.columnEnd - 1) {
+        if (i < static_cast<size_t>(item.columnEnd - 1)) {
           containingBlockWidth += columnGap;
         }
       }