Lint reanimated with clang-tidy

Author: wisniewskij

packages/react-native-reanimated/Common/cpp/reanimated/CSS/utils/DelayedItemsManager.cpp

@@ -18,7 +18,7 @@ bool DelayedItemComparator<TValue>::operator()(const DelayedItem<TValue> &lhs, c
 }
 
 template <typename TValue>
-void DelayedItemsManager<TValue>::add(const double timestamp, const TValue value) {
+void DelayedItemsManager<TValue>::add(const double timestamp, const TValue &value) {
   auto result = itemsSet_.emplace(timestamp, value);
   if (result.second) {
     itemsMap_[result.first->value] = result.first;
@@ -38,7 +38,7 @@ typename DelayedItemsManager<TValue>::Item DelayedItemsManager<TValue>::pop() {
 }
 
 template <typename TValue>
-bool DelayedItemsManager<TValue>::remove(const TValue value) {
+bool DelayedItemsManager<TValue>::remove(const TValue &value) {
   auto it = itemsMap_.find(value);
 
   if (it == itemsMap_.end()) {

packages/react-native-reanimated/Common/cpp/reanimated/CSS/utils/DelayedItemsManager.h

@@ -34,9 +34,9 @@ class DelayedItemsManager {
   ItemMap itemsMap_;
 
  public:
-  void add(double timestamp, TValue value);
+  void add(double timestamp, const TValue &value);
   Item pop();
-  bool remove(TValue value);
+  bool remove(const TValue &value);
   const Item &top() const;
   bool empty() const;
   size_t size() const;

packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.cpp

@@ -32,7 +32,7 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
   ShadowViewMutationList filteredMutations;
   auto rootChildCount = static_cast<int>(lightNodes_[surfaceId]->children.size());
   const std::vector<std::shared_ptr<MutationNode>> roots;
-  const bool isInTransition = transitionState_;
+  const bool isInTransition = static_cast<bool>(transitionState_);
 
   if (isInTransition) {
     updateLightTree(propsParserContext, mutations, filteredMutations);
@@ -50,7 +50,7 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
     auto beforeTopScreen = topScreen[surfaceId];
     if (beforeTopScreen) {
       ReanimatedSystraceSection s("find before elements");
-      findSharedElementsOnScreen(beforeTopScreen, BEFORE, propsParserContext);
+      findSharedElementsOnScreen(beforeTopScreen, BeforeOrAfter::BEFORE, propsParserContext);
     }
 
     updateLightTree(propsParserContext, mutations, filteredMutations);
@@ -59,7 +59,7 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
     topScreen[surfaceId] = afterTopScreen;
     if (afterTopScreen) {
       ReanimatedSystraceSection s("find after elements");
-      findSharedElementsOnScreen(afterTopScreen, AFTER, propsParserContext);
+      findSharedElementsOnScreen(afterTopScreen, BeforeOrAfter::AFTER, propsParserContext);
 #ifdef __APPLE__
       forceScreenSnapshot_(afterTopScreen->current.tag);
 #endif
@@ -71,9 +71,9 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
       // To keep things simple, we put mutations related to source views before all muatations
       // and mutations to hide target views after all mutations.
       std::vector<ShadowViewMutation> mergedMutations;
-      hideTransitioningViews(BEFORE, mergedMutations, propsParserContext);
+      hideTransitioningViews(BeforeOrAfter::BEFORE, mergedMutations, propsParserContext);
       mergedMutations.insert(mergedMutations.end(), filteredMutations.begin(), filteredMutations.end());
-      hideTransitioningViews(AFTER, mergedMutations, propsParserContext);
+      hideTransitioningViews(BeforeOrAfter::AFTER, mergedMutations, propsParserContext);
       std::swap(filteredMutations, mergedMutations);
     }
 

packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h

@@ -44,7 +44,7 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
   mutable Tag transitionTag_;
   mutable double transitionProgress_;
   mutable bool transitionUpdated_;
-  mutable TransitionState transitionState_ = NONE;
+  mutable TransitionState transitionState_ = TransitionState::NONE;
   mutable SurfaceId transitioningSurfaceId_ = -1;
   mutable std::unordered_map<SurfaceId, std::shared_ptr<LightNode>> topScreen;
   mutable int containerTag_ = 10000002;

packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.cpp

@@ -124,7 +124,7 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Legacy::endLayoutAnimation(int ta
 
   auto node = nodeForTag_[tag];
   auto mutationNode = std::static_pointer_cast<MutationNode>(node);
-  mutationNode->state = DEAD;
+  mutationNode->state = ExitingState_Legacy::DEAD;
   auto &[deadNodes] = surfaceContext_[surfaceId];
   deadNodes.insert(mutationNode);
 
@@ -172,7 +172,7 @@ void LayoutAnimationsProxy_Legacy::parseRemoveMutations(
         }
       }
       if (!deletedViews.contains(mutation.oldChildShadowView.tag)) {
-        mutationNode->state = MOVED;
+        mutationNode->state = ExitingState_Legacy::MOVED;
         movedViews.insert_or_assign(mutation.oldChildShadowView.tag, -1);
       }
       nodeForTag_[tag] = mutationNode;
@@ -245,11 +245,11 @@ void LayoutAnimationsProxy_Legacy::handleRemovals(
     if (!startAnimationsRecursively(node, true, shouldAnimate, false, filteredMutations)) {
       filteredMutations.push_back(node->mutation);
       node->unflattenedParent->removeChildFromUnflattenedTree(node); //???
-      if (node->state != MOVED) {
+      if (node->state != ExitingState_Legacy::MOVED) {
         maybeCancelAnimation(node->tag);
         filteredMutations.push_back(ShadowViewMutation::DeleteMutation(node->mutation.oldChildShadowView));
         nodeForTag_.erase(node->tag);
-        node->state = DELETED;
+        node->state = ExitingState_Legacy::DELETED;
 #ifdef LAYOUT_ANIMATIONS_LOGS
         LOG(INFO) << "delete " << node->tag << std::endl;
 #endif
@@ -258,7 +258,7 @@ void LayoutAnimationsProxy_Legacy::handleRemovals(
   }
 
   for (const auto &node : deadNodes) {
-    if (node->state != DELETED) {
+    if (node->state != ExitingState_Legacy::DELETED) {
       endAnimationsRecursively(node, filteredMutations);
       maybeDropAncestors(node->unflattenedParent, node, filteredMutations);
     }
@@ -429,12 +429,12 @@ void LayoutAnimationsProxy_Legacy::endAnimationsRecursively(
     const std::shared_ptr<MutationNode> &node,
     ShadowViewMutationList &mutations) const {
   maybeCancelAnimation(node->tag);
-  node->state = DELETED;
+  node->state = ExitingState_Legacy::DELETED;
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
   for (auto it = node->unflattenedChildren.rbegin(); it != node->unflattenedChildren.rend(); it++) {
     auto &subNode = *it;
-    if (subNode->state != DELETED) {
+    if (subNode->state != ExitingState_Legacy::DELETED) {
       endAnimationsRecursively(subNode, mutations);
     }
   }
@@ -457,11 +457,11 @@ void LayoutAnimationsProxy_Legacy::maybeDropAncestors(
 
   auto node = std::static_pointer_cast<MutationNode>(parent);
 
-  if (node->children.size() == 0 && node->state != ANIMATING) {
+  if (node->children.size() == 0 && node->state != ExitingState_Legacy::ANIMATING) {
     nodeForTag_.erase(node->tag);
     cleanupMutations.push_back(node->mutation);
     maybeCancelAnimation(node->tag);
-    node->state = DELETED;
+    node->state = ExitingState_Legacy::DELETED;
 #ifdef LAYOUT_ANIMATIONS_LOGS
     LOG(INFO) << "delete " << node->tag << std::endl;
 #endif
@@ -492,7 +492,7 @@ bool LayoutAnimationsProxy_Legacy::startAnimationsRecursively(
   bool hasAnimatedChildren = false;
 
   shouldRemoveSubviewsWithoutAnimations =
-      shouldRemoveSubviewsWithoutAnimations && (!hasExitAnimation || node->state == MOVED);
+      shouldRemoveSubviewsWithoutAnimations && (!hasExitAnimation || node->state == ExitingState_Legacy::MOVED);
   std::vector<std::shared_ptr<MutationNode>> toBeRemoved;
 
   // iterate from the end, so that children
@@ -503,8 +503,8 @@ bool LayoutAnimationsProxy_Legacy::startAnimationsRecursively(
     LOG(INFO) << "child " << subNode->tag << " "
               << " " << shouldAnimate << " " << shouldRemoveSubviewsWithoutAnimations << std::endl;
 #endif
-    if (subNode->state != UNDEFINED && subNode->state != MOVED) {
-      if (shouldAnimate && subNode->state != DEAD) {
+    if (subNode->state != ExitingState_Legacy::UNDEFINED && subNode->state != ExitingState_Legacy::MOVED) {
+      if (shouldAnimate && subNode->state != ExitingState_Legacy::DEAD) {
         hasAnimatedChildren = true;
       } else {
         endAnimationsRecursively(subNode, mutations);
@@ -516,29 +516,29 @@ bool LayoutAnimationsProxy_Legacy::startAnimationsRecursively(
       LOG(INFO) << "child " << subNode->tag << " start animations returned true " << std::endl;
 #endif
       hasAnimatedChildren = true;
-    } else if (subNode->state == MOVED) {
+    } else if (subNode->state == ExitingState_Legacy::MOVED) {
       mutations.push_back(subNode->mutation);
       toBeRemoved.push_back(subNode);
     } else if (shouldRemoveSubviewsWithoutAnimations) {
       maybeCancelAnimation(subNode->tag);
       mutations.push_back(subNode->mutation);
       toBeRemoved.push_back(subNode);
-      subNode->state = DELETED;
+      subNode->state = ExitingState_Legacy::DELETED;
       nodeForTag_.erase(subNode->tag);
 #ifdef LAYOUT_ANIMATIONS_LOGS
       LOG(INFO) << "delete " << subNode->tag << std::endl;
 #endif
       mutations.push_back(ShadowViewMutation::DeleteMutation(subNode->mutation.oldChildShadowView));
     } else {
-      subNode->state = WAITING;
+      subNode->state = ExitingState_Legacy::WAITING;
     }
   }
 
   for (auto &subNode : toBeRemoved) {
     node->removeChildFromUnflattenedTree(subNode);
   }
 
-  if (node->state == MOVED) {
+  if (node->state == ExitingState_Legacy::MOVED) {
     auto replacement = std::make_shared<Node>(*node);
     for (const auto &subNode : node->children) {
       subNode->parent = replacement;
@@ -553,7 +553,7 @@ bool LayoutAnimationsProxy_Legacy::startAnimationsRecursively(
   bool wantAnimateExit = hasExitAnimation || hasAnimatedChildren;
 
   if (hasExitAnimation) {
-    node->state = ANIMATING;
+    node->state = ExitingState_Legacy::ANIMATING;
     startExitingAnimation(node->tag, node->mutation);
   } else {
     layoutAnimationsManager_->clearLayoutAnimationConfig(node->tag);

packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h

@@ -24,7 +24,7 @@ class ReanimatedModuleProxy;
 
 using namespace facebook;
 
-typedef enum ExitingState_Legacy : std::uint8_t {
+typedef enum class ExitingState_Legacy : std::uint8_t {
   UNDEFINED = 1,
   WAITING = 2,
   ANIMATING = 4,
@@ -60,7 +60,7 @@ struct Node {
  */
 struct MutationNode : public Node {
   ShadowViewMutation mutation;
-  ExitingState_Legacy state = UNDEFINED;
+  ExitingState_Legacy state = ExitingState_Legacy::UNDEFINED;
   explicit MutationNode(ShadowViewMutation &mutation) : Node(mutation.oldChildShadowView.tag), mutation(mutation) {}
   MutationNode(ShadowViewMutation &mutation, Node &&node) : Node(std::move(node)), mutation(mutation) {}
   bool isMutationNode() override;

packages/react-native-reanimated/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.h

@@ -13,7 +13,7 @@
 
 namespace reanimated {
 
-enum BeforeOrAfter : std::uint8_t { BEFORE = 0, AFTER = 1 };
+enum class BeforeOrAfter : std::uint8_t { BEFORE = 0, AFTER = 1 };
 
 struct Rect {
   double width, height;
@@ -66,15 +66,15 @@ typedef enum class ExitingState : std::uint8_t {
 
 struct MutationNode;
 
-enum TransitionState : std::uint8_t {
+enum class TransitionState : std::uint8_t {
   NONE = 0,
   START = 1,
   ACTIVE = 2,
   END = 3,
   CANCELLED = 4,
 };
 
-enum Intent : std::uint8_t {
+enum class Intent : std::uint8_t {
   NO_INTENT = 0,
   TO_MOVE = 1,
   TO_DELETE = 2,