Tree::duplicate_no_rep(): improve naming, add debug logs

Author: biojppm

src/c4/yml/reference_resolver.cpp

@@ -240,6 +240,7 @@ void ReferenceResolver::resolve_()
                 _RYML_CB_ASSERT(m_tree->m_callbacks, m_tree->has_key_anchor(refdata.target) || m_tree->has_val_anchor(refdata.target));
                 if(m_tree->has_val_anchor(refdata.target) && m_tree->val_anchor(refdata.target) == m_tree->key_ref(refdata.node))
                 {
+                    _c4dbgpf("instance[{}:node{}] target.anchor==val.anchor=={}", i, refdata.node, m_tree->val_anchor(refdata.target));
                     _RYML_CB_CHECK(m_tree->m_callbacks, !m_tree->is_container(refdata.target));
                     _RYML_CB_CHECK(m_tree->m_callbacks, m_tree->has_val(refdata.target));
                     const type_bits existing_style_flags = VAL_STYLE & m_tree->_p(refdata.target)->m_type.type;
@@ -249,6 +250,7 @@ void ReferenceResolver::resolve_()
                 }
                 else
                 {
+                    _c4dbgpf("instance[{}:node{}] don't inherit container flags", i, refdata.node);
                     _RYML_CB_CHECK(m_tree->m_callbacks, m_tree->key_anchor(refdata.target) == m_tree->key_ref(refdata.node));
                     m_tree->_p(refdata.node)->m_key.scalar = m_tree->key(refdata.target);
                     // keys cannot be containers, so don't inherit container flags
@@ -262,6 +264,7 @@ void ReferenceResolver::resolve_()
                 _RYML_CB_ASSERT(m_tree->m_callbacks, refdata.type.is_val_ref());
                 if(m_tree->has_key_anchor(refdata.target) && m_tree->key_anchor(refdata.target) == m_tree->val_ref(refdata.node))
                 {
+                    _c4dbgpf("instance[{}:node{}] target.anchor==key.anchor=={}", i, refdata.node, m_tree->val_anchor(refdata.target));
                     _RYML_CB_CHECK(m_tree->m_callbacks, !m_tree->is_container(refdata.target));
                     _RYML_CB_CHECK(m_tree->m_callbacks, m_tree->has_val(refdata.target));
                     // keys cannot be containers, so don't inherit container flags
@@ -272,6 +275,7 @@ void ReferenceResolver::resolve_()
                 }
                 else
                 {
+                    _c4dbgpf("instance[{}:node{}] duplicate contents", i, refdata.node);
                     m_tree->duplicate_contents(refdata.target, refdata.node);
                 }
             }

src/c4/yml/tree.cpp

@@ -984,49 +984,59 @@ id_type Tree::duplicate_children_no_rep(Tree const *src, id_type node, id_type p
         _RYML_CB_CHECK(m_callbacks, this != src || (parent != i && !is_ancestor(parent, i)));
         if(is_seq(parent))
         {
-            prev = duplicate(i, parent, prev);
+            _c4dbgpf("duplicate_no_rep: {} is seq", parent);
+            prev = duplicate(src, i, parent, prev);
         }
         else
         {
+            _c4dbgpf("duplicate_no_rep: {} is map", parent);
             _RYML_CB_ASSERT(m_callbacks, is_map(parent));
             // does the parent already have a node with key equal to that of the current duplicate?
-            id_type rep = NONE, rep_pos = NONE;
-            for(id_type j = first_child(parent), jcount = 0; j != NONE; ++jcount, j = next_sibling(j))
+            id_type dstnode_dup = NONE, dstnode_dup_pos = NONE;
             {
-                if(key(j) == key(i))
+                csubstr srckey = src->key(i);
+                for(id_type j = first_child(parent), jcount = 0; j != NONE; ++jcount, j = next_sibling(j))
                 {
-                    rep = j;
-                    rep_pos = jcount;
-                    break;
+                    if(key(j) == srckey)
+                    {
+                        _c4dbgpf("duplicate_no_rep: found matching key '{}' src={}/{} dst={}/{}", srckey, node, i, parent, j);
+                        dstnode_dup = j;
+                        dstnode_dup_pos = jcount;
+                        break;
+                    }
                 }
             }
-            if(rep == NONE) // there is no repetition; just duplicate
+            _c4dbgpf("duplicate_no_rep: dstnode_dup={} dstnode_dup_pos={} after_pos={}", dstnode_dup, dstnode_dup_pos, after_pos);
+            if(dstnode_dup == NONE) // there is no repetition; just duplicate
             {
                 _c4dbgpf("duplicate_no_rep: no repetition, just duplicate i={} parent={} prev={}", i, parent, prev);
                 prev = duplicate(src, i, parent, prev);
             }
             else  // yes, there is a repetition
             {
-                if(after_pos != NONE && rep_pos < after_pos)
+                if(after_pos != NONE && dstnode_dup_pos < after_pos)
                 {
-                    // rep is located before the node which will be inserted,
+                    // the dst duplicate is located before the node which will be inserted,
                     // and will be overridden by the duplicate. So replace it.
-                    remove(rep);
+                    _c4dbgpf("duplicate_no_dstnode_dup: replace {}/{} with {}/{}", parent, dstnode_dup, node, i);
+                    remove(dstnode_dup);
                     prev = duplicate(src, i, parent, prev);
                 }
                 else if(prev == NONE)
                 {
-                    // first iteration with prev = after = NONE and repetition
-                    prev = rep;
+                    _c4dbgpf("duplicate_no_dstnode_dup: {}=prev <- {}", prev, dstnode_dup);
+                    // first iteration with prev = after = NONE and dstnode_dupetition
+                    prev = dstnode_dup;
                 }
-                else if(rep != prev)
+                else if(dstnode_dup != prev)
                 {
-                    // rep is located after the node which will be inserted
-                    // and overrides it. So move the rep into this node's place.
-                    move(rep, prev);
-                    prev = rep;
+                    // dstnode_dup is located after the node which will be inserted
+                    // and overrides it. So move the dstnode_dup into this node's place.
+                    _c4dbgpf("duplicate_no_dstnode_dup: move({}, {})", dstnode_dup, prev);
+                    move(dstnode_dup, prev);
+                    prev = dstnode_dup;
                 }
-            } // there's a repetition
+            } // there's a dstnode_dupetition
         }
     }
 

test/test_anchor.cpp

@@ -553,6 +553,26 @@ top5: &anchor5
     ASSERT_EQ(t["top62"]["key62"].has_key_anchor(), false);
 }
 
+TEST(simple_anchor, merge_seqs)
+{
+    const Tree src = parse_in_arena(R"([0, 1])");
+    {
+        Tree dst = parse_in_arena(R"([2, 3])");
+        dst.duplicate_children_no_rep(&src, 0, 0, NONE);
+        EXPECT_EQ(emitrs_yaml<std::string>(dst), "[0,1,2,3]");
+    }
+    {
+        Tree dst = parse_in_arena(R"([2, 3])");
+        dst.duplicate_children_no_rep(&src, 0, 0, 1);
+        EXPECT_EQ(emitrs_yaml<std::string>(dst), "[2,0,1,3]");
+    }
+    {
+        Tree dst = parse_in_arena(R"([2, 3])");
+        dst.duplicate_children_no_rep(&src, 0, 0, 2);
+        EXPECT_EQ(emitrs_yaml<std::string>(dst), "[2,3,0,1]");
+    }
+}
+
 TEST(simple_anchor, issue_400)
 {
     csubstr yaml = R"(