anchor.diff:      // The current node [this] is not guaranteed to be at level 0, so we need
       // to account for the level offset of [this].
       final levelWithOffset = level + this.level;
  -    var currentNode = this;
  +    TreeNode<T> currentNode = this;
       while (currentNode.level < levelWithOffset) {
         // Walk down the tree until we find the node at [level].
         if (currentNode.children.isNotEmpty) {
  -        currentNode = traversalCondition(currentNode, levelWithOffset);
  +        currentNode = traversalCondition(currentNode as T, levelWithOffset);
         }
       }
  -    return currentNode;
  +    return currentNode as T?;
     }
   
     TreeNode<T> shallowCopy();
  
positive.code:   ///
    /// The runtime of this method is O(level * tree width). The worst case
    /// scenario is searching for a very deep level in a very wide tree.
    T _childNodeAtLevelWithCondition(
      int level,
      T traversalCondition(T currentNode, int levelWithOffset),
    ) {
  
negative.code:   /// Override to handle pressing on a Leaf node.
    void leaf() {}
  
    void addChild(T child, {int? index}) {
      index ??= children.length;
      assert(index <= children.length);
      children.insert(index, child);
      child.parent = this as T?;
      child.index = index;
      for (int i = index + 1; i < children.length; ++i) {
        children[i].index++;
  