#
#
# patch "cmd_merging.cc"
#  from [a78118d3b2bff1cc053657a7229b0d481ac88520]
#    to [62ecbbf6a981beb3b9612e34dd7c4804df43e9f1]
# 
# patch "roster_merge.cc"
#  from [094521bdae96a87be48551db617a7ebf385e6988]
#    to [3608b823761f8f700e73bf2013fbae536e9d0712]
# 
# patch "roster_merge.hh"
#  from [10ed203f9c28fe2ebdf0aca516407bceb4728ef8]
#    to [34fd64bd0dc1ef9bf7158f71aeb69230caa0462e]
# 
# patch "tests/show_conflicts/__driver__.lua"
#  from [9757234b8db8a3fbda5018ed6ae17dcf4201cf37]
#    to [0d2bdc5aca3d58387529b751f72acafb6c8c53a9]
#
============================================================
--- cmd_merging.cc	a78118d3b2bff1cc053657a7229b0d481ac88520
+++ cmd_merging.cc	62ecbbf6a981beb3b9612e34dd7c4804df43e9f1
@@ -812,6 +812,8 @@ CMD(show_conflicts, "show_conflicts", ""
     % result.duplicate_name_conflicts.size());
   P(F("There are %s directory_loop_conflicts.")
     % result.directory_loop_conflicts.size());
+  P(F("There are %s invalid_name_conflicts.")
+    % result.invalid_name_conflicts.size());
 }
 
 CMD(pluck, "pluck", "", CMD_REF(workspace), N_("[-r FROM] -r TO [PATH...]"),
============================================================
--- roster_merge.cc	094521bdae96a87be48551db617a7ebf385e6988
+++ roster_merge.cc	3608b823761f8f700e73bf2013fbae536e9d0712
@@ -92,7 +92,7 @@ template <> void
 }
 
 template <> void
-dump(illegal_name_conflict const & conflict, string & out)
+dump(invalid_name_conflict const & conflict, string & out)
 {
   ostringstream oss;
   oss << "node: " << conflict.nid << "\n"
@@ -130,7 +130,7 @@ roster_merge_result::has_non_content_con
     || !orphaned_node_conflicts.empty()
     || !duplicate_name_conflicts.empty()
     || !directory_loop_conflicts.empty()
-    || !illegal_name_conflicts.empty()
+    || !invalid_name_conflicts.empty()
     || missing_root_dir;
 }
 
@@ -205,11 +205,11 @@ debug_describe_conflicts(roster_merge_re
             % result.directory_loop_conflicts[i].parent_name.second)
       .str();
 
-  for (size_t i = 0; i < result.illegal_name_conflicts.size(); ++i)
+  for (size_t i = 0; i < result.invalid_name_conflicts.size(); ++i)
     out += (FL("illegal name conflict: node %d, wanted parent %d, name %s")
-            % result.illegal_name_conflicts[i].nid
-            % result.illegal_name_conflicts[i].parent_name.first
-            % result.illegal_name_conflicts[i].parent_name.second)
+            % result.invalid_name_conflicts[i].nid
+            % result.invalid_name_conflicts[i].parent_name.first
+            % result.invalid_name_conflicts[i].parent_name.second)
       .str();
 
   if (result.missing_root_dir)
@@ -530,9 +530,9 @@ roster_merge_result::warn_non_content_co
           % lca_parent_name % right_parent_name);
     }
 
-  for (size_t i = 0; i < illegal_name_conflicts.size(); ++i)
+  for (size_t i = 0; i < invalid_name_conflicts.size(); ++i)
     {
-      illegal_name_conflict const & conflict = illegal_name_conflicts[i];
+      invalid_name_conflict const & conflict = invalid_name_conflicts[i];
       MM(conflict);
 
       I(!roster.is_attached(conflict.nid));
@@ -659,7 +659,7 @@ roster_merge_result::clear()
   orphaned_node_conflicts.clear();
   duplicate_name_conflicts.clear();
   directory_loop_conflicts.clear();
-  illegal_name_conflicts.clear();
+  invalid_name_conflicts.clear();
   missing_root_dir = false;
   roster = roster_t();
 }
@@ -1153,7 +1153,7 @@ roster_merge(roster_t const & left_paren
 
       if (result_root->has_child(bookkeeping_root_component))
         {
-          illegal_name_conflict conflict;
+          invalid_name_conflict conflict;
           node_t n = result_root->get_child(bookkeeping_root_component);
           conflict.nid = n->self;
           conflict.parent_name.first = n->parent;
@@ -1161,7 +1161,7 @@ roster_merge(roster_t const & left_paren
           I(n->name == bookkeeping_root_component);
 
           result.roster.detach_node(n->self);
-          result.illegal_name_conflicts.push_back(conflict);
+          result.invalid_name_conflicts.push_back(conflict);
         }
     }
 }
@@ -2071,7 +2071,7 @@ struct simple_orphan_conflict : public s
 };
 
 // illegal node ("_MTN")
-struct simple_illegal_name_conflict : public structural_conflict_helper
+struct simple_invalid_name_conflict : public structural_conflict_helper
 {
   node_id new_root_nid, bad_dir_nid;
 
@@ -2095,12 +2095,12 @@ struct simple_illegal_name_conflict : pu
   virtual void check()
     {
       I(!result.is_clean());
-      illegal_name_conflict const & c = idx(result.illegal_name_conflicts, 0);
+      invalid_name_conflict const & c = idx(result.invalid_name_conflicts, 0);
       I(c.nid == bad_dir_nid);
       I(c.parent_name == make_pair(new_root_nid, bookkeeping_root_component));
       // this tests it was detached, implicitly
       result.roster.attach_node(bad_dir_nid, file_path_internal("dir_formerly_known_as__MTN"));
-      result.illegal_name_conflicts.pop_back();
+      result.invalid_name_conflicts.pop_back();
       I(result.is_clean());
       result.roster.check_sane();
     }
@@ -2149,7 +2149,7 @@ UNIT_TEST(roster_merge, simple_structura
     t.test();
   }
   {
-    simple_illegal_name_conflict t;
+    simple_invalid_name_conflict t;
     t.test();
   }
   {
@@ -2254,7 +2254,7 @@ struct multiple_name_plus_directory_loop
   }
 };
 
-struct multiple_name_plus_illegal_name : public multiple_name_plus_helper
+struct multiple_name_plus_invalid_name : public multiple_name_plus_helper
 {
   node_id new_root_nid;
 
@@ -2382,7 +2382,7 @@ UNIT_TEST(roster_merge, complex_structur
     t.test();
   }
   {
-    multiple_name_plus_illegal_name t;
+    multiple_name_plus_invalid_name t;
     t.test();
   }
   {
============================================================
--- roster_merge.hh	10ed203f9c28fe2ebdf0aca516407bceb4728ef8
+++ roster_merge.hh	34fd64bd0dc1ef9bf7158f71aeb69230caa0462e
@@ -105,7 +105,7 @@ struct directory_loop_conflict
 // this is a node that cleanly merged to some name, but that name was somehow
 // forbidden.  (Currently, the only forbidden name is "_MTN" in the root
 // directory.)
-struct illegal_name_conflict
+struct invalid_name_conflict
 {
   node_id nid;
   std::pair<node_id, path_component> parent_name;
@@ -117,7 +117,7 @@ template <> void dump(directory_loop_con
 template <> void dump(orphaned_node_conflict const & val, std::string & out);
 template <> void dump(duplicate_name_conflict const & val, std::string & out);
 template <> void dump(directory_loop_conflict const & val, std::string & out);
-template <> void dump(illegal_name_conflict const & val, std::string & out);
+template <> void dump(invalid_name_conflict const & val, std::string & out);
 
 struct roster_merge_result
 {
@@ -138,7 +138,7 @@ struct roster_merge_result
   std::vector<orphaned_node_conflict> orphaned_node_conflicts;
   std::vector<duplicate_name_conflict> duplicate_name_conflicts;
   std::vector<directory_loop_conflict> directory_loop_conflicts;
-  std::vector<illegal_name_conflict> illegal_name_conflicts;
+  std::vector<invalid_name_conflict> invalid_name_conflicts;
   bool missing_root_dir;
   // this roster is sane if is_clean() returns true
   roster_t roster;
============================================================
--- tests/show_conflicts/__driver__.lua	9757234b8db8a3fbda5018ed6ae17dcf4201cf37
+++ tests/show_conflicts/__driver__.lua	0d2bdc5aca3d58387529b751f72acafb6c8c53a9
@@ -26,3 +26,4 @@ check(qgrep("There are 0 directory_loop_
 check(qgrep("There are 0 orphaned_node_conflicts", "conflicts"))
 check(qgrep("There are 0 duplicate_name_conflicts", "conflicts"))
 check(qgrep("There are 0 directory_loop_conflicts", "conflicts"))
+check(qgrep("There are 0 invalid_name_conflicts", "conflicts"))