Find tied containers' descendants regardless of insertion order

src/SIL.Machine/Annotations/AnnotationList.cs

@@ -227,12 +227,51 @@ public bool FindDepthFirst(TOffset offset, Direction dir, out Annotation<TOffset
             if (Find(offset, dir, out result))
                 return true;
 
-            if (!result.IsLeaf && result.Range.Contains(offset, dir))
-                return result.Children.FindDepthFirst(offset, dir, out result);
+            // Several containers can share the same range while only one of them owns the children that lead to the
+            // offset, so every one of them has to be tried, not just the one Find happened to return.
+            Annotation<TOffset> candidate = result;
+            Annotation<TOffset> miss = candidate;
+            foreach (Annotation<TOffset> tied in GetSameRange(candidate))
+            {
+                if (tied.IsLeaf || !tied.Range.Contains(offset, dir))
+                    continue;
+
+                if (tied.Children.FindDepthFirst(offset, dir, out Annotation<TOffset> inner))
+                {
+                    result = inner;
+                    return true;
+                }
+
+                // A miss reports the result of the candidate's own children, not of another tied container.
+                if (tied == candidate)
+                    miss = inner;
+            }
 
+            result = miss;
             return false;
         }
 
+        private IEnumerable<Annotation<TOffset>> GetSameRange(Annotation<TOffset> ann)
+        {
+            yield return ann;
+            if (ann == Begin || ann == End)
+                yield break;
+
+            for (
+                Annotation<TOffset> cur = ann.Prev;
+                cur != Begin && cur.Range.CompareTo(ann.Range) == 0;
+                cur = cur.Prev
+            )
+            {
+                yield return cur;
+            }
+
+            for (Annotation<TOffset> cur = ann.Next; cur != End && cur.Range.CompareTo(ann.Range) == 0; cur = cur.Next)
+            {
+                yield return cur;
+            }
+        }
+
         public IEnumerable<Annotation<TOffset>> GetNodes(TOffset start, TOffset end)
         {
             return GetNodes(Range<TOffset>.Create(start, end));

tests/SIL.Machine.Tests/Annotations/AnnotationTiedContainerTests.cs

@@ -0,0 +1,102 @@
+using System.Reflection;
+using NUnit.Framework;
+using SIL.Machine.DataStructures;
+using SIL.Machine.FeatureModel;
+
+namespace SIL.Machine.Annotations;
+
+[TestFixture]
+public class AnnotationTiedContainerTests
+{
+    private const int ContainerCount = 4;
+
+    private static Shape CreateShape(int seed, out ShapeNode[] nodes)
+    {
+        var annotations = new AnnotationList<ShapeNode>();
+        typeof(BidirList<Annotation<ShapeNode>>)
+            .GetField("_rand", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .SetValue(annotations, new Random(seed));
+        var shape = new Shape(begin => new ShapeNode(FeatureStruct.New().Value), annotations);
+        nodes = new ShapeNode[3];
+        for (int i = 0; i < nodes.Length; i++)
+            nodes[i] = shape.Add(FeatureStruct.New().Value);
+        return shape;
+    }
+
+    private static Annotation<ShapeNode> NewContainer(ShapeNode[] nodes)
+    {
+        return new Annotation<ShapeNode>(Range<ShapeNode>.Create(nodes[0], nodes[2]), FeatureStruct.New().Value);
+    }
+
+    // Only the tied container at ownerIndex owns the segments, so the one Find returns varies with insertion order.
+    [Test]
+    public void FindDepthFirst_TiedContainers_FindsSegmentInOwner(
+        [Values(0, 1, 2, 3, 4, 5)] int seed,
+        [Range(0, ContainerCount - 1)] int ownerIndex,
+        [Values] Direction dir
+    )
+    {
+        Shape shape = CreateShape(seed, out ShapeNode[] nodes);
+        for (int i = 0; i < ContainerCount; i++)
+        {
+            Annotation<ShapeNode> container = NewContainer(nodes);
+            if (i == ownerIndex)
+                container.Children.AddRange(nodes.Select(n => n.Annotation));
+            shape.Annotations.Add(container, false);
+        }
+
+        Assert.That(shape.Annotations.FindDepthFirst(nodes[1], dir, out Annotation<ShapeNode> result), Is.True);
+        Assert.That(result, Is.SameAs(nodes[1].Annotation));
+    }
+
+    // The owner is itself a container of tied containers, only one of which owns the segment annotations.
+    [Test]
+    public void FindDepthFirst_NestedTiedContainers_FindsSegmentInInnermostOwner(
+        [Values(0, 1, 2, 3, 4, 5)] int seed,
+        [Range(0, ContainerCount - 1)] int outerOwnerIndex,
+        [Range(0, ContainerCount - 1)] int innerOwnerIndex,
+        [Values] Direction dir
+    )
+    {
+        Shape shape = CreateShape(seed, out ShapeNode[] nodes);
+        for (int i = 0; i < ContainerCount; i++)
+        {
+            Annotation<ShapeNode> outer = NewContainer(nodes);
+            if (i == outerOwnerIndex)
+            {
+                for (int j = 0; j < ContainerCount; j++)
+                {
+                    Annotation<ShapeNode> inner = NewContainer(nodes);
+                    if (j == innerOwnerIndex)
+                        inner.Children.AddRange(nodes.Select(n => n.Annotation));
+                    outer.Children.Add(inner, false);
+                }
+            }
+            shape.Annotations.Add(outer, false);
+        }
+
+        Assert.That(shape.Annotations.FindDepthFirst(nodes[1], dir, out Annotation<ShapeNode> result), Is.True);
+        Assert.That(result, Is.SameAs(nodes[1].Annotation));
+    }
+
+    // Tied containers that own only the other segments must not hide, or stand in for, an annotation that is not
+    // inside any of them.
+    [Test]
+    public void FindDepthFirst_TiedContainersNotOwningTheOffset_ReturnsTheUnownedAnnotation(
+        [Values(0, 1, 2, 3, 4, 5)] int seed,
+        [Values] Direction dir
+    )
+    {
+        Shape shape = CreateShape(seed, out ShapeNode[] nodes);
+        for (int i = 0; i < ContainerCount; i++)
+        {
+            Annotation<ShapeNode> container = NewContainer(nodes);
+            if (i == 0)
+                container.Children.AddRange(new[] { nodes[0].Annotation, nodes[2].Annotation });
+            shape.Annotations.Add(container, false);
+        }
+
+        Assert.That(shape.Annotations.FindDepthFirst(nodes[1], dir, out Annotation<ShapeNode> result), Is.True);
+        Assert.That(result, Is.SameAs(nodes[1].Annotation));
+    }
+}