
  Syntax error!
  syntax_tests/data/parsing/infiniteLoops/equalAfterBinaryExpr.res:169:17

  167 ┆ if isLeaf(successor) {
  168 ┆   if rbt->root === Some(successor) {
  169 ┆     rbt->root = None
  170 ┆   }
  171 ┆ }

  Did you mean `==` here?

let rec _addLoop [arity:2]rbt currentNode =
  ((if (Some currentNode) === (rbt -> root)
    then currentNode.color <- Black
    else
      if (currentNode.parent -> castNotOption).color === Black
      then ()
      else
        if
          (((let uncle = uncleOf currentNode in
             ((!==) uncle None) && ((uncle -> castNotOption).color === Red)))
          [@res.braces ])
        then
          ((currentNode.parent -> castNotOption).color <- Black;
           ((uncleOf currentNode) -> castNotOption).color <- Black;
           ((grandParentOf currentNode) -> castNotOption).color <- Red;
           _addLoop rbt ((grandParentOf currentNode) -> castNotOption))
        else
          (let currentNode =
             if
               (not (isLeft currentNode)) &&
                 (isLeft (currentNode.parent -> castNotOption))
             then
               (rotateLeft rbt (currentNode.parent -> castNotOption);
                currentNode.left -> castNotOption)
             else
               if
                 (isLeft currentNode) &&
                   (not (isLeft (currentNode.parent -> castNotOption)))
               then
                 (rotateRight rbt (currentNode.parent -> castNotOption);
                  currentNode.right -> castNotOption)
               else currentNode in
           (currentNode.parent -> castNotOption).color <- Black;
           ((grandParentOf currentNode) -> castNotOption).color <- Red;
           if isLeft currentNode
           then
             rotateRight rbt ((grandParentOf currentNode) -> castNotOption)
           else rotateLeft rbt ((grandParentOf currentNode) -> castNotOption)))
  [@res.braces ])
let removeNode [arity:2]rbt node =
  ((if nodeToRemove.color === Black
    then
      (if successor.color === Red
       then
         (successor.color <- Black;
          if successor.parent === None then rbt -> (rootSet (Some successor)))
       else
         (let break = ref false in
          let successorRef = ref successor in
          while not break.contents do
            let successor = successorRef.contents in
            match successor.parent with
            | None ->
                (rbt -> (rootSet (Some successor)); break.contents <- true)
            | Some successorParent ->
                let sibling = siblingOf successor in
                (if
                   ((!==) sibling None) &&
                     ((sibling -> castNotOption).color === Red)
                 then
                   (successorParent.color <- Red;
                    (sibling -> castNotOption).color <- Black;
                    if isLeft successor
                    then rotateLeft rbt successorParent
                    else rotateRight rbt successorParent);
                 (let sibling = siblingOf successor in
                  let siblingNN = sibling -> castNotOption in
                  if
                    (successorParent.color === Black) &&
                      ((sibling === None) ||
                         (((siblingNN.color === Black) &&
                             ((siblingNN.left === None) ||
                                ((siblingNN.left -> castNotOption).color ===
                                   Black)))
                            &&
                            ((siblingNN.right === None) ||
                               ((siblingNN.right -> castNotOption).color ===
                                  Black))))
                  then
                    (if (!==) sibling None then siblingNN.color <- Red;
                     successorRef.contents <- successorParent)
                  else
                    if
                      (successorParent.color === Red) &&
                        ((sibling === None) ||
                           (((siblingNN.color === Black) &&
                               ((siblingNN.left === None) ||
                                  ((siblingNN.left -> castNotOption).color
                                     === Black)))
                              &&
                              ((siblingNN.right === None) ||
                                 ((siblingNN.right -> castNotOption).color
                                    === Black))))
                    then
                      (if (!==) sibling None then siblingNN.color <- Red;
                       successorParent.color <- Black;
                       break.contents <- true)
                    else
                      if
                        ((!==) sibling None) &&
                          ((sibling -> castNotOption).color === Black)
                      then
                        (let sibling = sibling -> castNotOption in
                         if
                           (((isLeft successor) &&
                               ((sibling.right === None) ||
                                  ((sibling.right -> castNotOption).color ===
                                     Black)))
                              && ((!==) sibling.left None))
                             &&
                             ((sibling.left -> castNotOption).color === Red)
                         then
                           (sibling.color <- Red;
                            (sibling.left -> castNotOption).color <- Black;
                            rotateRight rbt sibling)
                         else
                           if
                             (((not (isLeft successor)) &&
                                 ((sibling.left === None) ||
                                    ((sibling.left -> castNotOption).color
                                       === Black)))
                                && ((!==) sibling.right None))
                               &&
                               ((sibling.right -> castNotOption).color ===
                                  Red)
                           then
                             (sibling.color <- Red;
                              (sibling.right -> castNotOption).color <- Black;
                              rotateLeft rbt sibling);
                         break.contents <- true)
                      else
                        (let sibling = siblingOf successor in
                         let sibling = sibling -> castNotOption in
                         sibling.color <- (successorParent.color);
                         if isLeft successor
                         then
                           ((sibling.right -> castNotOption).color <- Black;
                            rotateRight rbt successorParent)
                         else
                           ((sibling.left -> castNotOption).color <- Black;
                            rotateLeft rbt successorParent))))
            done));
    if isLeaf successor
    then (if (rbt -> root) === (Some successor) then (rbt -> root) = None))
  [@res.braces ])