subversion-1.9.7HEADsubversion-1.9.7master

1 files changed, 1423 insertions, 1405 deletions

diff --git a/subversion/libsvn_wc/wc_db_update_move.c b/subversion/libsvn_wc/wc_db_update_move.c
index 7f4f853..46cbeae 100644
--- a/subversion/libsvn_wc/wc_db_update_move.c
+++ b/subversion/libsvn_wc/wc_db_update_move.c
@@ -46,7 +46,7 @@
  * layer. The destination may have additional higher op-depths
  * representing adds, deletes, moves within the move destination. [2]
  *
- * After the intial move an update has modified the NODES in the move
+ * After the initial move an update has modified the NODES in the move
  * source and may have introduced a tree-conflict since the source and
  * destination trees are no longer equivalent.  The source is a
  * different revision and may have text, property and tree changes
@@ -88,9 +88,9 @@
 #include "svn_sorts.h"
 
 #include "private/svn_skel.h"
+#include "private/svn_sorts_private.h"
 #include "private/svn_sqlite.h"
 #include "private/svn_wc_private.h"
-#include "private/svn_editor.h"
 
 #include "wc.h"
 #include "props.h"
@@ -100,6 +100,80 @@
 #include "workqueue.h"
 #include "token-map.h"
 
+/* Helper functions */
+/* Return the absolute path, in local path style, of LOCAL_RELPATH
+   in WCROOT.  */
+static const char *
+path_for_error_message(const svn_wc__db_wcroot_t *wcroot,
+                       const char *local_relpath,
+                       apr_pool_t *result_pool)
+{
+  const char *local_abspath
+    = svn_dirent_join(wcroot->abspath, local_relpath, result_pool);
+
+  return svn_dirent_local_style(local_abspath, result_pool);
+}
+
+/* Ensure that there is a working copy lock for LOCAL_RELPATH in WCROOT */
+static svn_error_t *
+verify_write_lock(svn_wc__db_wcroot_t *wcroot,
+                  const char *local_relpath,
+                  apr_pool_t *scratch_pool)
+{
+  svn_boolean_t locked;
+
+  SVN_ERR(svn_wc__db_wclock_owns_lock_internal(&locked, wcroot, local_relpath,
+                                               FALSE, scratch_pool));
+  if (!locked)
+    {
+      return svn_error_createf(SVN_ERR_WC_NOT_LOCKED, NULL,
+                               _("No write-lock in '%s'"),
+                               path_for_error_message(wcroot, local_relpath,
+                                                      scratch_pool));
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* In our merge conflicts we record the move_op_src path, which is essentially
+   the depth at which what was moved is marked deleted. The problem is that
+   this depth is not guaranteed to be stable, because somebody might just
+   remove another ancestor, or revert one.
+
+   To work around this problem we locate the layer below this path, and use
+   that to pinpoint whatever is moved.
+
+   For a path SRC_RELPATH that was deleted by an operation rooted at
+   DELETE_OP_DEPTH find the op-depth at which the node was originally added.
+   */
+static svn_error_t *
+find_src_op_depth(int *src_op_depth,
+                  svn_wc__db_wcroot_t *wcroot,
+                  const char *src_relpath,
+                  int delete_op_depth,
+                  apr_pool_t *scratch_pool)
+{
+  svn_sqlite__stmt_t *stmt;
+  svn_boolean_t have_row;
+
+  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+                                    STMT_SELECT_HIGHEST_WORKING_NODE));
+  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
+                            src_relpath, delete_op_depth));
+
+  SVN_ERR(svn_sqlite__step(&have_row, stmt));
+  if (have_row)
+    *src_op_depth = svn_sqlite__column_int(stmt, 0);
+  SVN_ERR(svn_sqlite__reset(stmt));
+  if (!have_row)
+    return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
+                              _("'%s' is not deleted"),
+                              path_for_error_message(wcroot, src_relpath,
+                                                    scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
 /*
  * Receiver code.
  *
@@ -113,20 +187,34 @@
  * be made at the move destination.
  */
 
-struct tc_editor_baton {
+typedef struct update_move_baton_t {
   svn_wc__db_t *db;
   svn_wc__db_wcroot_t *wcroot;
-  const char *move_root_dst_relpath;
 
-  /* The most recent conflict raised during this drive.  We rely on the
-     non-Ev2, depth-first, drive for this to make sense. */
-  const char *conflict_root_relpath;
+  int src_op_depth;
+  int dst_op_depth;
 
   svn_wc_operation_t operation;
   svn_wc_conflict_version_t *old_version;
   svn_wc_conflict_version_t *new_version;
-  apr_pool_t *result_pool;  /* For things that live as long as the baton. */
-};
+
+  svn_cancel_func_t cancel_func;
+  void *cancel_baton;
+} update_move_baton_t;
+
+/* Per node flags for tree conflict collection */
+typedef struct node_move_baton_t
+{
+  svn_boolean_t skip;
+  svn_boolean_t shadowed;
+  svn_boolean_t edited;
+
+  const char *src_relpath;
+  const char *dst_relpath;
+
+  update_move_baton_t *umb;
+  struct node_move_baton_t *pb;
+} node_move_baton_t;
 
 /*
  * Notifications are delayed until the entire update-move transaction
@@ -135,24 +223,52 @@ struct tc_editor_baton {
  * and spooling notifications out of that table after the transaction.
  */
 
-/* Add an entry to the notification list. */
+/* Add an entry to the notification list, and at the same time install
+   a conflict and/or work items. */
 static svn_error_t *
 update_move_list_add(svn_wc__db_wcroot_t *wcroot,
                      const char *local_relpath,
+                     svn_wc__db_t *db,
                      svn_wc_notify_action_t action,
                      svn_node_kind_t kind,
                      svn_wc_notify_state_t content_state,
-                     svn_wc_notify_state_t prop_state)
-
+                     svn_wc_notify_state_t prop_state,
+                     svn_skel_t *conflict,
+                     svn_skel_t *work_item,
+                     apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
 
+  if (conflict)
+    {
+      svn_boolean_t tree_conflict;
+
+      SVN_ERR(svn_wc__conflict_read_info(NULL, NULL, NULL, NULL,
+                                         &tree_conflict,
+                                         db, wcroot->abspath, conflict,
+                                         scratch_pool, scratch_pool));
+      if (tree_conflict)
+        {
+          action = svn_wc_notify_tree_conflict;
+          content_state = svn_wc_notify_state_inapplicable;
+          prop_state = svn_wc_notify_state_inapplicable;
+        }
+    }
+
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
                                     STMT_INSERT_UPDATE_MOVE_LIST));
-  SVN_ERR(svn_sqlite__bindf(stmt, "sdddd", local_relpath,
-                            action, kind, content_state, prop_state));
+  SVN_ERR(svn_sqlite__bindf(stmt, "sdtdd", local_relpath,
+                            action, kind_map_none, kind,
+                            content_state, prop_state));
   SVN_ERR(svn_sqlite__step_done(stmt));
 
+  if (conflict)
+    SVN_ERR(svn_wc__db_mark_conflict_internal(wcroot, local_relpath, conflict,
+                                              scratch_pool));
+
+  if (work_item)
+    SVN_ERR(svn_wc__db_wq_add_internal(wcroot, work_item, scratch_pool));
+
   return SVN_NO_ERROR;
 }
 
@@ -192,7 +308,7 @@ svn_wc__db_update_move_list_notify(svn_wc__db_wcroot_t *wcroot,
                                                         local_relpath,
                                                         iterpool),
                                         action, iterpool);
-          notify->kind = svn_sqlite__column_int(stmt, 2);
+          notify->kind = svn_sqlite__column_token(stmt, 2, kind_map_none);
           notify->content_state = svn_sqlite__column_int(stmt, 3);
           notify->prop_state = svn_sqlite__column_int(stmt, 4);
           notify->old_revision = old_revision;
@@ -212,23 +328,25 @@ svn_wc__db_update_move_list_notify(svn_wc__db_wcroot_t *wcroot,
   return SVN_NO_ERROR;
 }
 
-/* Mark a tree-conflict on LOCAL_RELPATH if such a tree-conflict does
-   not already exist. */
+/* Create a tree-conflict for recording on LOCAL_RELPATH if such
+   a tree-conflict does not already exist. */
 static svn_error_t *
-mark_tree_conflict(const char *local_relpath,
-                   svn_wc__db_wcroot_t *wcroot,
-                   svn_wc__db_t *db,
-                   const svn_wc_conflict_version_t *old_version,
-                   const svn_wc_conflict_version_t *new_version,
-                   const char *move_root_dst_relpath,
-                   svn_wc_operation_t operation,
-                   svn_node_kind_t old_kind,
-                   svn_node_kind_t new_kind,
-                   const char *old_repos_relpath,
-                   svn_wc_conflict_reason_t reason,
-                   svn_wc_conflict_action_t action,
-                   const char *move_src_op_root_relpath,
-                   apr_pool_t *scratch_pool)
+create_tree_conflict(svn_skel_t **conflict_p,
+                     svn_wc__db_wcroot_t *wcroot,
+                     const char *local_relpath,
+                     const char *dst_op_root_relpath,
+                     svn_wc__db_t *db,
+                     const svn_wc_conflict_version_t *old_version,
+                     const svn_wc_conflict_version_t *new_version,
+                     svn_wc_operation_t operation,
+                     svn_node_kind_t old_kind,
+                     svn_node_kind_t new_kind,
+                     const char *old_repos_relpath,
+                     svn_wc_conflict_reason_t reason,
+                     svn_wc_conflict_action_t action,
+                     const char *move_src_op_root_relpath,
+                     apr_pool_t *result_pool,
+                     apr_pool_t *scratch_pool)
 {
   svn_error_t *err;
   svn_skel_t *conflict;
@@ -250,14 +368,18 @@ mark_tree_conflict(const char *local_relpath,
     : NULL;
 
   if (!new_repos_relpath)
-    new_repos_relpath
-      = svn_relpath_join(new_version->path_in_repos,
-                         svn_relpath_skip_ancestor(move_root_dst_relpath,
-                                                   local_relpath),
-                         scratch_pool);
-
-  err = svn_wc__db_read_conflict_internal(&conflict, wcroot, local_relpath,
-                                          scratch_pool, scratch_pool);
+    {
+      const char *child_relpath = svn_relpath_skip_ancestor(
+                                            dst_op_root_relpath,
+                                            local_relpath);
+      SVN_ERR_ASSERT(child_relpath != NULL);
+      new_repos_relpath = svn_relpath_join(new_version->path_in_repos,
+                                           child_relpath, scratch_pool);
+    }
+
+  err = svn_wc__db_read_conflict_internal(&conflict, NULL, NULL,
+                                          wcroot, local_relpath,
+                                          result_pool, scratch_pool);
   if (err && err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
     return svn_error_trace(err);
   else if (err)
@@ -280,7 +402,7 @@ mark_tree_conflict(const char *local_relpath,
           && conflict_operation != svn_wc_operation_switch)
         return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
                                  _("'%s' already in conflict"),
-                                 svn_dirent_local_style(local_relpath,
+                                 path_for_error_message(wcroot, local_relpath,
                                                         scratch_pool));
 
       if (tree_conflicted)
@@ -302,17 +424,19 @@ mark_tree_conflict(const char *local_relpath,
                   && strcmp(move_src_op_root_relpath,
                             svn_dirent_skip_ancestor(wcroot->abspath,
                                                      existing_abspath))))
-            return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
+            return svn_error_createf(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
                                      _("'%s' already in conflict"),
-                                     svn_dirent_local_style(local_relpath,
+                                     path_for_error_message(wcroot,
+                                                            local_relpath,
                                                             scratch_pool));
 
           /* Already a suitable tree-conflict. */
+          *conflict_p = conflict;
           return SVN_NO_ERROR;
         }
     }
   else
-    conflict = svn_wc__conflict_skel_create(scratch_pool);
+    conflict = svn_wc__conflict_skel_create(result_pool);
 
   SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
                      conflict, db,
@@ -321,19 +445,13 @@ mark_tree_conflict(const char *local_relpath,
                      reason,
                      action,
                      move_src_op_root_abspath,
-                     scratch_pool,
+                     result_pool,
                      scratch_pool));
 
-  if (reason != svn_wc_conflict_reason_unversioned
-      && old_repos_relpath != NULL /* no local additions */)
-    {
-      conflict_old_version = svn_wc_conflict_version_create2(
+  conflict_old_version = svn_wc_conflict_version_create2(
                                old_version->repos_url, old_version->repos_uuid,
                                old_repos_relpath, old_version->peg_rev,
                                old_kind, scratch_pool);
-    }
-  else
-    conflict_old_version = NULL;
 
   conflict_new_version = svn_wc_conflict_version_create2(
                            new_version->repos_url, new_version->repos_uuid,
@@ -344,312 +462,368 @@ mark_tree_conflict(const char *local_relpath,
     {
       SVN_ERR(svn_wc__conflict_skel_set_op_update(
                 conflict, conflict_old_version, conflict_new_version,
-                scratch_pool, scratch_pool));
+                result_pool, scratch_pool));
     }
   else
     {
       assert(operation == svn_wc_operation_switch);
       SVN_ERR(svn_wc__conflict_skel_set_op_switch(
                   conflict, conflict_old_version, conflict_new_version,
-                  scratch_pool, scratch_pool));
+                  result_pool, scratch_pool));
     }
 
-  SVN_ERR(svn_wc__db_mark_conflict_internal(wcroot, local_relpath,
-                                            conflict, scratch_pool));
-
-  SVN_ERR(update_move_list_add(wcroot, local_relpath,
-                               svn_wc_notify_tree_conflict,
-                               new_kind,
-                               svn_wc_notify_state_inapplicable,
-                               svn_wc_notify_state_inapplicable));
+  *conflict_p = conflict;
   return SVN_NO_ERROR;
 }
 
-/* If LOCAL_RELPATH is a child of the most recently raised
-   tree-conflict or is shadowed then set *IS_CONFLICTED to TRUE and
-   raise a tree-conflict on the root of the obstruction if such a
-   tree-conflict does not already exist.  KIND is the kind of the
-   incoming LOCAL_RELPATH. This relies on the non-Ev2, depth-first,
-   drive. */
 static svn_error_t *
-check_tree_conflict(svn_boolean_t *is_conflicted,
-                    struct tc_editor_baton *b,
+create_node_tree_conflict(svn_skel_t **conflict_p,
+                          node_move_baton_t *nmb,
+                          const char *dst_local_relpath,
+                          svn_node_kind_t old_kind,
+                          svn_node_kind_t new_kind,
+                          svn_wc_conflict_reason_t reason,
+                          svn_wc_conflict_action_t action,
+                          const char *move_src_op_root_relpath,
+                          apr_pool_t *result_pool,
+                          apr_pool_t *scratch_pool)
+{
+  update_move_baton_t *umb = nmb->umb;
+  const char *dst_repos_relpath;
+  const char *dst_root_relpath = svn_relpath_prefix(nmb->dst_relpath,
+                                                    nmb->umb->dst_op_depth,
+                                                    scratch_pool);
+
+  dst_repos_relpath =
+            svn_relpath_join(nmb->umb->old_version->path_in_repos,
+                             svn_relpath_skip_ancestor(dst_root_relpath,
+                                                       nmb->dst_relpath),
+                             scratch_pool);
+
+
+
+  return svn_error_trace(
+            create_tree_conflict(conflict_p, umb->wcroot, dst_local_relpath,
+                                 svn_relpath_prefix(dst_local_relpath,
+                                                    umb->dst_op_depth,
+                                                    scratch_pool),
+                                 umb->db,
+                                 umb->old_version, umb->new_version,
+                                 umb->operation, old_kind, new_kind,
+                                 dst_repos_relpath,
+                                 reason, action, move_src_op_root_relpath,
+                                 result_pool, scratch_pool));
+}
+
+/* Checks if a specific local path is shadowed as seen from the move root.
+   Helper for update_moved_away_node() */
+static svn_error_t *
+check_node_shadowed(svn_boolean_t *shadowed,
+                    svn_wc__db_wcroot_t *wcroot,
                     const char *local_relpath,
-                    svn_node_kind_t old_kind,
-                    svn_node_kind_t new_kind,
-                    const char *old_repos_relpath,
-                    svn_wc_conflict_action_t action,
+                    int move_root_dst_op_depth,
                     apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
   svn_boolean_t have_row;
-  int dst_op_depth = relpath_depth(b->move_root_dst_relpath);
-  int op_depth;
-  const char *conflict_root_relpath = local_relpath;
-  const char *move_dst_relpath, *dummy1;
-  const char *dummy2, *move_src_op_root_relpath;
 
-  if (b->conflict_root_relpath)
-    {
-      if (svn_relpath_skip_ancestor(b->conflict_root_relpath, local_relpath))
-        {
-          *is_conflicted = TRUE;
-          return SVN_NO_ERROR;
-        }
-      b->conflict_root_relpath = NULL;
-    }
+  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+                                    STMT_SELECT_WORKING_NODE));
+  SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id, local_relpath));
 
-  SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                    STMT_SELECT_LOWEST_WORKING_NODE));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, local_relpath,
-                            dst_op_depth));
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
+
   if (have_row)
-    op_depth = svn_sqlite__column_int(stmt, 0);
+    {
+      int op_depth = svn_sqlite__column_int(stmt, 0);
+
+      *shadowed = (op_depth > move_root_dst_op_depth);
+    }
+  else
+    *shadowed = FALSE;
   SVN_ERR(svn_sqlite__reset(stmt));
 
-  if (!have_row)
+  return SVN_NO_ERROR;
+}
+
+/* Set a tree conflict for the shadowed node LOCAL_RELPATH, which is
+   the ROOT OF THE OBSTRUCTION if such a tree-conflict does not
+   already exist.  KIND is the kind of the incoming LOCAL_RELPATH. */
+static svn_error_t *
+mark_tc_on_op_root(node_move_baton_t *nmb,
+                   svn_node_kind_t old_kind,
+                   svn_node_kind_t new_kind,
+                   svn_wc_conflict_action_t action,
+                   apr_pool_t *scratch_pool)
+{
+  update_move_baton_t *b = nmb->umb;
+  const char *move_dst_relpath;
+  svn_skel_t *conflict;
+
+  SVN_ERR_ASSERT(nmb->shadowed && !nmb->pb->shadowed);
+
+  nmb->skip = TRUE;
+
+  if (old_kind == svn_node_none)
+    move_dst_relpath = NULL;
+  else
+    SVN_ERR(svn_wc__db_scan_moved_to_internal(NULL, &move_dst_relpath, NULL,
+                                              b->wcroot, nmb->dst_relpath,
+                                              b->dst_op_depth,
+                                              scratch_pool, scratch_pool));
+
+  SVN_ERR(create_node_tree_conflict(&conflict, nmb, nmb->dst_relpath,
+                                    old_kind, new_kind,
+                                    (move_dst_relpath
+                                     ? svn_wc_conflict_reason_moved_away
+                                     : svn_wc_conflict_reason_deleted),
+                                    action, move_dst_relpath
+                                              ? nmb->dst_relpath
+                                              : NULL,
+                                    scratch_pool, scratch_pool));
+
+  SVN_ERR(update_move_list_add(b->wcroot, nmb->dst_relpath, b->db,
+                               svn_wc_notify_tree_conflict,
+                               new_kind,
+                               svn_wc_notify_state_inapplicable,
+                               svn_wc_notify_state_inapplicable,
+                               conflict, NULL, scratch_pool));
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+mark_node_edited(node_move_baton_t *nmb,
+                 apr_pool_t *scratch_pool)
+{
+  if (nmb->edited)
+    return SVN_NO_ERROR;
+
+  if (nmb->pb)
     {
-      *is_conflicted = FALSE;
-      return SVN_NO_ERROR;
+      SVN_ERR(mark_node_edited(nmb->pb, scratch_pool));
+
+      if (nmb->pb->skip)
+        nmb->skip = TRUE;
     }
 
-  *is_conflicted = TRUE;
+  nmb->edited = TRUE;
 
-  while (relpath_depth(conflict_root_relpath) > op_depth)
+  if (nmb->skip)
+    return SVN_NO_ERROR;
+
+  if (nmb->shadowed && !(nmb->pb && nmb->pb->shadowed))
     {
-      conflict_root_relpath = svn_relpath_dirname(conflict_root_relpath,
-                                                  scratch_pool);
-      old_kind = new_kind = svn_node_dir;
-      if (old_repos_relpath)
-        old_repos_relpath = svn_relpath_dirname(old_repos_relpath,
-                                                scratch_pool);
-      action = svn_wc_conflict_action_edit;
+      svn_node_kind_t dst_kind, src_kind;
+
+      SVN_ERR(svn_wc__db_depth_get_info(NULL, &dst_kind, NULL,
+                                        NULL, NULL, NULL, NULL,
+                                        NULL, NULL, NULL, NULL, NULL, NULL,
+                                        nmb->umb->wcroot, nmb->dst_relpath,
+                                        nmb->umb->dst_op_depth,
+                                        scratch_pool, scratch_pool));
+
+      SVN_ERR(svn_wc__db_depth_get_info(NULL, &src_kind, NULL, NULL,
+                                        NULL, NULL, NULL,
+                                        NULL, NULL, NULL, NULL, NULL, NULL,
+                                        nmb->umb->wcroot, nmb->src_relpath,
+                                        nmb->umb->src_op_depth,
+                                        scratch_pool, scratch_pool));
+
+      SVN_ERR(mark_tc_on_op_root(nmb,
+                                 dst_kind, src_kind,
+                                 svn_wc_conflict_action_edit,
+                                 scratch_pool));
     }
 
-  SVN_ERR(svn_wc__db_op_depth_moved_to(&move_dst_relpath,
-                                       &dummy1,
-                                       &dummy2,
-                                       &move_src_op_root_relpath,
-                                       dst_op_depth,
-                                       b->wcroot, conflict_root_relpath,
-                                       scratch_pool, scratch_pool));
-
-  SVN_ERR(mark_tree_conflict(conflict_root_relpath,
-                             b->wcroot, b->db, b->old_version, b->new_version,
-                             b->move_root_dst_relpath, b->operation,
-                             old_kind, new_kind,
-                             old_repos_relpath,
-                             (move_dst_relpath
-                              ? svn_wc_conflict_reason_moved_away
-                              : svn_wc_conflict_reason_deleted),
-                             action, move_src_op_root_relpath,
-                             scratch_pool));
-  b->conflict_root_relpath = apr_pstrdup(b->result_pool, conflict_root_relpath);
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+mark_parent_edited(node_move_baton_t *nmb,
+                 apr_pool_t *scratch_pool)
+{
+  SVN_ERR_ASSERT(nmb && nmb->pb);
+
+  SVN_ERR(mark_node_edited(nmb->pb, scratch_pool));
+
+  if (nmb->pb->skip)
+    nmb->skip = TRUE;
 
   return SVN_NO_ERROR;
 }
 
 static svn_error_t *
-tc_editor_add_directory(void *baton,
+tc_editor_add_directory(node_move_baton_t *nmb,
                         const char *relpath,
-                        const apr_array_header_t *children,
+                        svn_node_kind_t old_kind,
                         apr_hash_t *props,
-                        svn_revnum_t replaces_rev,
                         apr_pool_t *scratch_pool)
 {
-  struct tc_editor_baton *b = baton;
-  int op_depth = relpath_depth(b->move_root_dst_relpath);
-  const char *move_dst_repos_relpath;
-  svn_node_kind_t move_dst_kind;
-  svn_boolean_t is_conflicted;
-  const char *abspath;
-  svn_node_kind_t old_kind;
-  svn_skel_t *work_item;
-  svn_wc_notify_action_t action = svn_wc_notify_update_add;
-  svn_error_t *err;
+  update_move_baton_t *b = nmb->umb;
+  const char *local_abspath;
+  svn_node_kind_t wc_kind;
+  svn_skel_t *work_item = NULL;
+  svn_skel_t *conflict = NULL;
+  svn_wc_conflict_reason_t reason = svn_wc_conflict_reason_unversioned;
+
+  SVN_ERR(mark_parent_edited(nmb, scratch_pool));
+  if (nmb->skip)
+    return SVN_NO_ERROR;
 
-  /* Update NODES, only the bits not covered by the later call to
-     replace_moved_layer. */
-  SVN_ERR(svn_wc__db_extend_parent_delete(b->wcroot, relpath, svn_node_dir,
-                                          op_depth, scratch_pool));
-
-  err = svn_wc__db_depth_get_info(NULL, &move_dst_kind, NULL,
-                                  &move_dst_repos_relpath, NULL, NULL, NULL,
-                                  NULL, NULL, NULL, NULL, NULL, NULL,
-                                  b->wcroot, relpath,
-                                  relpath_depth(b->move_root_dst_relpath),
-                                  scratch_pool, scratch_pool);
-  if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
+  if (nmb->shadowed)
     {
-      svn_error_clear(err);
-      old_kind = svn_node_none;
-      move_dst_repos_relpath = NULL;
+      svn_wc__db_status_t status;
+
+      SVN_ERR(svn_wc__db_read_info_internal(&status, &wc_kind, NULL, NULL,
+                                            NULL, NULL, NULL, NULL, NULL, NULL,
+                                            NULL, NULL, NULL, NULL, NULL, NULL,
+                                            NULL, NULL, NULL, NULL, NULL, NULL,
+                                            NULL, NULL, NULL,
+                                            b->wcroot, relpath,
+                                            scratch_pool, scratch_pool));
+
+      if (status == svn_wc__db_status_deleted)
+        reason = svn_wc_conflict_reason_deleted;
+      else if (status != svn_wc__db_status_added)
+        wc_kind = svn_node_none;
+      else if (old_kind == svn_node_none)
+        reason = svn_wc_conflict_reason_added;
+      else
+        reason = svn_wc_conflict_reason_replaced;
     }
   else
+    wc_kind = svn_node_none;
+
+  local_abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
+
+  if (wc_kind == svn_node_none)
     {
-      SVN_ERR(err);
-      old_kind = move_dst_kind;
+      /* Check for unversioned tree-conflict */
+      SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
     }
 
-  /* Check for NODES tree-conflict. */
-  SVN_ERR(check_tree_conflict(&is_conflicted, b, relpath,
-                              old_kind, svn_node_dir,
-                              move_dst_repos_relpath,
-                              svn_wc_conflict_action_add,
-                              scratch_pool));
-  if (is_conflicted)
-    return SVN_NO_ERROR;
+  if (!nmb->shadowed && wc_kind == old_kind)
+    wc_kind = svn_node_none; /* Node will be gone once we install */
 
-  /* Check for unversioned tree-conflict */
-  abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
-  SVN_ERR(svn_io_check_path(abspath, &old_kind, scratch_pool));
-
-  switch (old_kind)
+  if (wc_kind != svn_node_none
+      && (nmb->shadowed || wc_kind != old_kind)) /* replace */
     {
-    case svn_node_file:
-    default:
-      SVN_ERR(mark_tree_conflict(relpath, b->wcroot, b->db, b->old_version,
-                                 b->new_version, b->move_root_dst_relpath,
-                                 b->operation, old_kind, svn_node_dir,
-                                 move_dst_repos_relpath,
-                                 svn_wc_conflict_reason_unversioned,
-                                 svn_wc_conflict_action_add, NULL,
-                                 scratch_pool));
-      b->conflict_root_relpath = apr_pstrdup(b->result_pool, relpath);
-      action = svn_wc_notify_tree_conflict;
-      is_conflicted = TRUE;
-      break;
-
-    case svn_node_none:
-      SVN_ERR(svn_wc__wq_build_dir_install(&work_item, b->db, abspath,
+      SVN_ERR(create_node_tree_conflict(&conflict, nmb, relpath,
+                                        old_kind, svn_node_dir,
+                                        reason,
+                                        (old_kind == svn_node_none)
+                                          ? svn_wc_conflict_action_add
+                                          : svn_wc_conflict_action_replace,
+                                        NULL,
+                                        scratch_pool, scratch_pool));
+      nmb->skip = TRUE;
+    }
+  else
+    {
+      SVN_ERR(svn_wc__wq_build_dir_install(&work_item, b->db, local_abspath,
                                            scratch_pool, scratch_pool));
-
-      SVN_ERR(svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_item,
-                                scratch_pool));
-      /* Fall through */
-    case svn_node_dir:
-      break;
     }
 
-  if (!is_conflicted)
-    SVN_ERR(update_move_list_add(b->wcroot, relpath,
-                                 action,
-                                 svn_node_dir,
-                                 svn_wc_notify_state_inapplicable,
-                                 svn_wc_notify_state_inapplicable));
+  SVN_ERR(update_move_list_add(b->wcroot, relpath, b->db,
+                               (old_kind == svn_node_none)
+                                  ? svn_wc_notify_update_add
+                                  : svn_wc_notify_update_replace,
+                               svn_node_dir,
+                               svn_wc_notify_state_inapplicable,
+                               svn_wc_notify_state_inapplicable,
+                               conflict, work_item, scratch_pool));
   return SVN_NO_ERROR;
 }
 
 static svn_error_t *
-tc_editor_add_file(void *baton,
+tc_editor_add_file(node_move_baton_t *nmb,
                    const char *relpath,
+                   svn_node_kind_t old_kind,
                    const svn_checksum_t *checksum,
-                   svn_stream_t *contents,
                    apr_hash_t *props,
-                   svn_revnum_t replaces_rev,
                    apr_pool_t *scratch_pool)
 {
-  struct tc_editor_baton *b = baton;
-  int op_depth = relpath_depth(b->move_root_dst_relpath);
-  const char *move_dst_repos_relpath;
-  svn_node_kind_t move_dst_kind;
-  svn_node_kind_t old_kind;
-  svn_boolean_t is_conflicted;
-  const char *abspath;
-  svn_skel_t *work_item;
-  svn_error_t *err;
+  update_move_baton_t *b = nmb->umb;
+  svn_wc_conflict_reason_t reason = svn_wc_conflict_reason_unversioned;
+  svn_node_kind_t wc_kind;
+  const char *local_abspath;
+  svn_skel_t *work_item = NULL;
+  svn_skel_t *conflict = NULL;
+
+  SVN_ERR(mark_parent_edited(nmb, scratch_pool));
+  if (nmb->skip)
+    return SVN_NO_ERROR;
 
-  /* Update NODES, only the bits not covered by the later call to
-     replace_moved_layer. */
-  SVN_ERR(svn_wc__db_extend_parent_delete(b->wcroot, relpath, svn_node_file,
-                                          op_depth, scratch_pool));
-
-  err = svn_wc__db_depth_get_info(NULL, &move_dst_kind, NULL,
-                                  &move_dst_repos_relpath, NULL, NULL, NULL,
-                                  NULL, NULL, NULL, NULL, NULL, NULL,
-                                  b->wcroot, relpath,
-                                  relpath_depth(b->move_root_dst_relpath),
-                                  scratch_pool, scratch_pool);
-  if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
+  if (nmb->shadowed)
     {
-      svn_error_clear(err);
-      old_kind = svn_node_none;
-      move_dst_repos_relpath = NULL;
+      svn_wc__db_status_t status;
+
+      SVN_ERR(svn_wc__db_read_info_internal(&status, &wc_kind, NULL, NULL,
+                                            NULL, NULL, NULL, NULL, NULL, NULL,
+                                            NULL, NULL, NULL, NULL, NULL, NULL,
+                                            NULL, NULL, NULL, NULL, NULL, NULL,
+                                            NULL, NULL, NULL,
+                                            b->wcroot, relpath,
+                                            scratch_pool, scratch_pool));
+
+      if (status == svn_wc__db_status_deleted)
+        reason = svn_wc_conflict_reason_deleted;
+      else if (status != svn_wc__db_status_added)
+        wc_kind = svn_node_none;
+      else if (old_kind == svn_node_none)
+        reason = svn_wc_conflict_reason_added;
+      else
+        reason = svn_wc_conflict_reason_replaced;
     }
   else
-    {
-      SVN_ERR(err);
-      old_kind = move_dst_kind;
-    }
-
-  /* Check for NODES tree-conflict. */
-  SVN_ERR(check_tree_conflict(&is_conflicted, b, relpath,
-                              old_kind, svn_node_file, move_dst_repos_relpath,
-                              svn_wc_conflict_action_add,
-                              scratch_pool));
-  if (is_conflicted)
-    return SVN_NO_ERROR;
+    wc_kind = svn_node_none;
 
-  /* Check for unversioned tree-conflict */
-  abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
-  SVN_ERR(svn_io_check_path(abspath, &old_kind, scratch_pool));
+  local_abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
 
-  if (old_kind != svn_node_none)
+  if (wc_kind == svn_node_none)
     {
-      SVN_ERR(mark_tree_conflict(relpath, b->wcroot, b->db, b->old_version,
-                                 b->new_version, b->move_root_dst_relpath,
-                                 b->operation, old_kind, svn_node_file,
-                                 move_dst_repos_relpath,
-                                 svn_wc_conflict_reason_unversioned,
-                                 svn_wc_conflict_action_add, NULL,
-                                 scratch_pool));
-      b->conflict_root_relpath = apr_pstrdup(b->result_pool, relpath);
-      return SVN_NO_ERROR;
+      /* Check for unversioned tree-conflict */
+      SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
     }
 
-  /* Update working file. */
-  SVN_ERR(svn_wc__wq_build_file_install(&work_item, b->db,
-                                        svn_dirent_join(b->wcroot->abspath,
-                                                        relpath,
-                                                        scratch_pool),
+  if (wc_kind != svn_node_none
+      && (nmb->shadowed || wc_kind != old_kind)) /* replace */
+    {
+      SVN_ERR(create_node_tree_conflict(&conflict, nmb, relpath,
+                                        old_kind, svn_node_file,
+                                        reason,
+                                        (old_kind == svn_node_none)
+                                          ? svn_wc_conflict_action_add
+                                          : svn_wc_conflict_action_replace,
                                         NULL,
-                                        FALSE /* FIXME: use_commit_times? */,
-                                        TRUE  /* record_file_info */,
                                         scratch_pool, scratch_pool));
+      nmb->skip = TRUE;
+    }
+  else
+    {
+      /* Update working file. */
+      SVN_ERR(svn_wc__wq_build_file_install(&work_item, b->db,
+                                            svn_dirent_join(b->wcroot->abspath,
+                                                            relpath,
+                                                            scratch_pool),
+                                            NULL,
+                                            FALSE /*FIXME: use_commit_times?*/,
+                                            TRUE  /* record_file_info */,
+                                            scratch_pool, scratch_pool));
+    }
 
-  SVN_ERR(svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_item,
-                            scratch_pool));
-
-  SVN_ERR(update_move_list_add(b->wcroot, relpath,
-                               svn_wc_notify_update_add,
+  SVN_ERR(update_move_list_add(b->wcroot, relpath, b->db,
+                               (old_kind == svn_node_none)
+                                  ? svn_wc_notify_update_add
+                                  : svn_wc_notify_update_replace,
                                svn_node_file,
                                svn_wc_notify_state_inapplicable,
-                               svn_wc_notify_state_inapplicable));
+                               svn_wc_notify_state_inapplicable,
+                               conflict, work_item, scratch_pool));
   return SVN_NO_ERROR;
 }
 
-static svn_error_t *
-tc_editor_add_symlink(void *baton,
-                      const char *relpath,
-                      const char *target,
-                      apr_hash_t *props,
-                      svn_revnum_t replaces_rev,
-                      apr_pool_t *scratch_pool)
-{
-  return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
-}
-
-static svn_error_t *
-tc_editor_add_absent(void *baton,
-                     const char *relpath,
-                     svn_node_kind_t kind,
-                     svn_revnum_t replaces_rev,
-                     apr_pool_t *scratch_pool)
-{
-  return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
-}
-
 /* All the info we need about one version of a working node. */
 typedef struct working_node_version_t
 {
@@ -669,6 +843,7 @@ create_conflict_markers(svn_skel_t **work_items,
                         const working_node_version_t *old_version,
                         const working_node_version_t *new_version,
                         svn_node_kind_t kind,
+                        svn_boolean_t set_operation,
                         apr_pool_t *result_pool,
                         apr_pool_t *scratch_pool)
 {
@@ -689,19 +864,22 @@ create_conflict_markers(svn_skel_t **work_items,
     = svn_relpath_join(conflicted_version->path_in_repos, part, scratch_pool);
   original_version->path_in_repos = repos_relpath;
 
-  if (operation == svn_wc_operation_update)
+  if (set_operation)
     {
-      SVN_ERR(svn_wc__conflict_skel_set_op_update(
-                conflict_skel, original_version,
-                conflicted_version,
-                scratch_pool, scratch_pool));
-    }
-  else
-    {
-      SVN_ERR(svn_wc__conflict_skel_set_op_switch(
-                conflict_skel, original_version,
-                conflicted_version,
-                scratch_pool, scratch_pool));
+      if (operation == svn_wc_operation_update)
+        {
+          SVN_ERR(svn_wc__conflict_skel_set_op_update(
+                    conflict_skel, original_version,
+                    conflicted_version,
+                    scratch_pool, scratch_pool));
+        }
+      else
+        {
+          SVN_ERR(svn_wc__conflict_skel_set_op_switch(
+                    conflict_skel, original_version,
+                    conflicted_version,
+                    scratch_pool, scratch_pool));
+        }
     }
 
   /* According to this func's doc string, it is "Currently only used for
@@ -720,8 +898,8 @@ update_working_props(svn_wc_notify_state_t *prop_state,
                      svn_skel_t **conflict_skel,
                      apr_array_header_t **propchanges,
                      apr_hash_t **actual_props,
-                     svn_wc__db_t *db,
-                     const char *local_abspath,
+                     update_move_baton_t *b,
+                     const char *local_relpath,
                      const struct working_node_version_t *old_version,
                      const struct working_node_version_t *new_version,
                      apr_pool_t *result_pool,
@@ -736,139 +914,123 @@ update_working_props(svn_wc_notify_state_t *prop_state,
    * merge-left version, and the current props of the
    * moved-here working file as the merge-right version.
    */
-  SVN_ERR(svn_wc__db_read_props(actual_props,
-                                db, local_abspath,
-                                result_pool, scratch_pool));
+  SVN_ERR(svn_wc__db_read_props_internal(actual_props,
+                                         b->wcroot, local_relpath,
+                                         result_pool, scratch_pool));
   SVN_ERR(svn_prop_diffs(propchanges, new_version->props, old_version->props,
                          result_pool));
   SVN_ERR(svn_wc__merge_props(conflict_skel, prop_state,
                               &new_actual_props,
-                              db, local_abspath,
+                              b->db, svn_dirent_join(b->wcroot->abspath,
+                                                     local_relpath,
+                                                     scratch_pool),
                               old_version->props, old_version->props,
                               *actual_props, *propchanges,
                               result_pool, scratch_pool));
 
-  /* Setting properties in ACTUAL_NODE with svn_wc__db_op_set_props
-     relies on NODES row having been updated first which we don't do
-     at present. So this extra property diff has the same effect.
+  /* Setting properties in ACTUAL_NODE with svn_wc__db_op_set_props_internal
+     relies on NODES row being updated via a different route .
 
-     ### Perhaps we should update NODES first (but after
-     ### svn_wc__db_read_props above)?  */
+     This extra property diff makes sure we clear the actual row when
+     the final result is unchanged properties. */
   SVN_ERR(svn_prop_diffs(&new_propchanges, new_actual_props, new_version->props,
                          scratch_pool));
   if (!new_propchanges->nelts)
     new_actual_props = NULL;
 
-  /* Install the new actual props. Don't set the conflict_skel yet, because
-     we might need to add a text conflict to it as well. */
-  SVN_ERR(svn_wc__db_op_set_props(db, local_abspath,
-                                  new_actual_props,
-                                  svn_wc__has_magic_property(*propchanges),
-                                  NULL/*conflict_skel*/, NULL/*work_items*/,
-                                  scratch_pool));
+  /* Install the new actual props. */
+  SVN_ERR(svn_wc__db_op_set_props_internal(b->wcroot, local_relpath,
+                                           new_actual_props,
+                                           svn_wc__has_magic_property(
+                                                    *propchanges),
+                                           scratch_pool));
 
   return SVN_NO_ERROR;
 }
 
 static svn_error_t *
-tc_editor_alter_directory(void *baton,
+tc_editor_alter_directory(node_move_baton_t *nmb,
                           const char *dst_relpath,
-                          svn_revnum_t expected_move_dst_revision,
-                          const apr_array_header_t *children,
+                          apr_hash_t *old_props,
                           apr_hash_t *new_props,
                           apr_pool_t *scratch_pool)
 {
-  struct tc_editor_baton *b = baton;
-  const char *move_dst_repos_relpath;
-  svn_revnum_t move_dst_revision;
-  svn_node_kind_t move_dst_kind;
+  update_move_baton_t *b = nmb->umb;
   working_node_version_t old_version, new_version;
-  svn_wc__db_status_t status;
-  svn_boolean_t is_conflicted;
-
-  SVN_ERR_ASSERT(expected_move_dst_revision == b->old_version->peg_rev);
-
-  SVN_ERR(svn_wc__db_depth_get_info(&status, &move_dst_kind, &move_dst_revision,
-                                    &move_dst_repos_relpath, NULL, NULL, NULL,
-                                    NULL, NULL, &old_version.checksum, NULL,
-                                    NULL, &old_version.props,
-                                    b->wcroot, dst_relpath,
-                                    relpath_depth(b->move_root_dst_relpath),
-                                    scratch_pool, scratch_pool));
+  svn_skel_t *work_items = NULL;
+  svn_skel_t *conflict_skel = NULL;
+  const char *local_abspath = svn_dirent_join(b->wcroot->abspath, dst_relpath,
+                                              scratch_pool);
+  svn_wc_notify_state_t prop_state;
+  apr_hash_t *actual_props;
+  apr_array_header_t *propchanges;
+  svn_node_kind_t wc_kind;
+  svn_boolean_t obstructed = FALSE;
 
-  /* If the node would be recorded as svn_wc__db_status_base_deleted it
-     wouldn't have a repos_relpath */
-  /* ### Can svn_wc__db_depth_get_info() do this for us without this hint? */
-  if (status == svn_wc__db_status_deleted && move_dst_repos_relpath)
-    status = svn_wc__db_status_not_present;
-
-  /* There might be not-present nodes of a different revision as the same
-     depth as a copy. This is commonly caused by copying/moving mixed revision
-     directories */
-  SVN_ERR_ASSERT(move_dst_revision == expected_move_dst_revision
-                 || status == svn_wc__db_status_not_present);
-  SVN_ERR_ASSERT(move_dst_kind == svn_node_dir);
-
-  SVN_ERR(check_tree_conflict(&is_conflicted, b, dst_relpath,
-                              move_dst_kind,
-                              svn_node_dir,
-                              move_dst_repos_relpath,
-                              svn_wc_conflict_action_edit,
-                              scratch_pool));
-  if (is_conflicted)
+  SVN_ERR(mark_node_edited(nmb, scratch_pool));
+  if (nmb->skip)
     return SVN_NO_ERROR;
 
+  SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
+  if (wc_kind != svn_node_none && wc_kind != svn_node_dir)
+    {
+      SVN_ERR(create_node_tree_conflict(&conflict_skel, nmb, dst_relpath,
+                                        svn_node_dir, svn_node_dir,
+                                        svn_wc_conflict_reason_obstructed,
+                                        svn_wc_conflict_action_edit,
+                                        NULL,
+                                        scratch_pool, scratch_pool));
+      obstructed = TRUE;
+    }
+
   old_version.location_and_kind = b->old_version;
   new_version.location_and_kind = b->new_version;
 
+  old_version.checksum = NULL; /* not a file */
+  old_version.props = old_props;
   new_version.checksum = NULL; /* not a file */
-  new_version.props = new_props ? new_props : old_version.props;
+  new_version.props = new_props;
 
-  if (new_props)
+  SVN_ERR(update_working_props(&prop_state, &conflict_skel,
+                                &propchanges, &actual_props,
+                                b, dst_relpath,
+                                &old_version, &new_version,
+                                scratch_pool, scratch_pool));
+
+  if (prop_state == svn_wc_notify_state_conflicted)
     {
-      const char *dst_abspath = svn_dirent_join(b->wcroot->abspath,
-                                                dst_relpath,
-                                                scratch_pool);
-      svn_wc_notify_state_t prop_state;
-      svn_skel_t *conflict_skel = NULL;
-      apr_hash_t *actual_props;
-      apr_array_header_t *propchanges;
-
-      SVN_ERR(update_working_props(&prop_state, &conflict_skel,
-                                   &propchanges, &actual_props,
-                                   b->db, dst_abspath,
-                                   &old_version, &new_version,
-                                   scratch_pool, scratch_pool));
-
-      if (conflict_skel)
-        {
-          svn_skel_t *work_items;
-
-          SVN_ERR(create_conflict_markers(&work_items, dst_abspath,
-                                          b->db, move_dst_repos_relpath,
-                                          conflict_skel, b->operation,
-                                          &old_version, &new_version,
-                                          svn_node_dir,
-                                          scratch_pool, scratch_pool));
-          SVN_ERR(svn_wc__db_mark_conflict_internal(b->wcroot, dst_relpath,
-                                                    conflict_skel,
-                                                    scratch_pool));
-          SVN_ERR(svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_items,
-                                    scratch_pool));
-        }
+      const char *move_dst_repos_relpath;
 
-    SVN_ERR(update_move_list_add(b->wcroot, dst_relpath,
-                                 svn_wc_notify_update_update,
-                                 svn_node_dir,
-                                 svn_wc_notify_state_inapplicable,
-                                 prop_state));
+      SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
+                                        &move_dst_repos_relpath, NULL, NULL,
+                                        NULL, NULL, NULL, NULL, NULL, NULL,
+                                        NULL,
+                                        b->wcroot, dst_relpath,
+                                        b->dst_op_depth,
+                                        scratch_pool, scratch_pool));
+
+      SVN_ERR(create_conflict_markers(&work_items, local_abspath,
+                                      b->db, move_dst_repos_relpath,
+                                      conflict_skel, b->operation,
+                                      &old_version, &new_version,
+                                      svn_node_dir, !obstructed,
+                                      scratch_pool, scratch_pool));
     }
 
+  SVN_ERR(update_move_list_add(b->wcroot, dst_relpath, b->db,
+                               svn_wc_notify_update_update,
+                               svn_node_dir,
+                               svn_wc_notify_state_inapplicable,
+                               prop_state,
+                               conflict_skel, work_items, scratch_pool));
+
   return SVN_NO_ERROR;
 }
 
-
-/* Merge the difference between OLD_VERSION and NEW_VERSION into
+/* Edit the file found at the move destination, which is initially at
+ * the old state.  Merge the changes into the "working"/"actual" file.
+ *
+ * Merge the difference between OLD_VERSION and NEW_VERSION into
  * the working file at LOCAL_RELPATH.
  *
  * The term 'old' refers to the pre-update state, which is the state of
@@ -883,17 +1045,18 @@ tc_editor_alter_directory(void *baton,
  * Set *WORK_ITEMS to any required work items, allocated in RESULT_POOL.
  * Use SCRATCH_POOL for temporary allocations. */
 static svn_error_t *
-update_working_file(const char *local_relpath,
-                    const char *repos_relpath,
-                    svn_wc_operation_t operation,
-                    const working_node_version_t *old_version,
-                    const working_node_version_t *new_version,
-                    svn_wc__db_wcroot_t *wcroot,
-                    svn_wc__db_t *db,
-                    apr_pool_t *scratch_pool)
+tc_editor_alter_file(node_move_baton_t *nmb,
+                     const char *dst_relpath,
+                     const svn_checksum_t *old_checksum,
+                     const svn_checksum_t *new_checksum,
+                     apr_hash_t *old_props,
+                     apr_hash_t *new_props,
+                     apr_pool_t *scratch_pool)
 {
-  const char *local_abspath = svn_dirent_join(wcroot->abspath,
-                                              local_relpath,
+  update_move_baton_t *b = nmb->umb;
+  working_node_version_t old_version, new_version;
+  const char *local_abspath = svn_dirent_join(b->wcroot->abspath,
+                                              dst_relpath,
                                               scratch_pool);
   const char *old_pristine_abspath;
   const char *new_pristine_abspath;
@@ -903,23 +1066,51 @@ update_working_file(const char *local_relpath,
   enum svn_wc_merge_outcome_t merge_outcome;
   svn_wc_notify_state_t prop_state, content_state;
   svn_skel_t *work_item, *work_items = NULL;
+  svn_node_kind_t wc_kind;
+  svn_boolean_t obstructed = FALSE;
 
+  SVN_ERR(mark_node_edited(nmb, scratch_pool));
+  if (nmb->skip)
+    return SVN_NO_ERROR;
+
+  SVN_ERR(svn_io_check_path(local_abspath, &wc_kind, scratch_pool));
+  if (wc_kind != svn_node_none && wc_kind != svn_node_file)
+    {
+      SVN_ERR(create_node_tree_conflict(&conflict_skel, nmb, dst_relpath,
+                                        svn_node_file, svn_node_file,
+                                        svn_wc_conflict_reason_obstructed,
+                                        svn_wc_conflict_action_edit,
+                                        NULL,
+                                        scratch_pool, scratch_pool));
+      obstructed = TRUE;
+    }
+
+  old_version.location_and_kind = b->old_version;
+  new_version.location_and_kind = b->new_version;
+
+  old_version.checksum = old_checksum;
+  old_version.props = old_props;
+  new_version.checksum = new_checksum;
+  new_version.props = new_props;
+
+  /* ### TODO: Only do this when there is no higher WORKING layer */
   SVN_ERR(update_working_props(&prop_state, &conflict_skel, &propchanges,
-                               &actual_props, db, local_abspath,
-                               old_version, new_version,
+                               &actual_props, b, dst_relpath,
+                               &old_version, &new_version,
                                scratch_pool, scratch_pool));
 
-  if (!svn_checksum_match(new_version->checksum, old_version->checksum))
+  if (!obstructed
+      && !svn_checksum_match(new_version.checksum, old_version.checksum))
     {
       svn_boolean_t is_locally_modified;
 
       SVN_ERR(svn_wc__internal_file_modified_p(&is_locally_modified,
-                                               db, local_abspath,
+                                               b->db, local_abspath,
                                                FALSE /* exact_comparison */,
                                                scratch_pool));
       if (!is_locally_modified)
         {
-          SVN_ERR(svn_wc__wq_build_file_install(&work_item, db,
+          SVN_ERR(svn_wc__wq_build_file_install(&work_item, b->db,
                                                 local_abspath,
                                                 NULL,
                                                 FALSE /* FIXME: use_commit_times? */,
@@ -939,15 +1130,15 @@ update_working_file(const char *local_relpath,
            * moved-here working file as the merge-right version.
            */
           SVN_ERR(svn_wc__db_pristine_get_path(&old_pristine_abspath,
-                                               db, wcroot->abspath,
-                                               old_version->checksum,
+                                               b->db, b->wcroot->abspath,
+                                               old_version.checksum,
                                                scratch_pool, scratch_pool));
           SVN_ERR(svn_wc__db_pristine_get_path(&new_pristine_abspath,
-                                               db, wcroot->abspath,
-                                               new_version->checksum,
+                                               b->db, b->wcroot->abspath,
+                                               new_version.checksum,
                                                scratch_pool, scratch_pool));
           SVN_ERR(svn_wc__internal_merge(&work_item, &conflict_skel,
-                                         &merge_outcome, db,
+                                         &merge_outcome, b->db,
                                          old_pristine_abspath,
                                          new_pristine_abspath,
                                          local_abspath,
@@ -958,7 +1149,7 @@ update_working_file(const char *local_relpath,
                                          NULL, /* diff3-cmd */
                                          NULL, /* merge options */
                                          propchanges,
-                                         NULL, NULL, /* cancel_func + baton */
+                                         b->cancel_func, b->cancel_baton,
                                          scratch_pool, scratch_pool));
 
           work_items = svn_wc__wq_merge(work_items, work_item, scratch_pool);
@@ -976,207 +1167,113 @@ update_working_file(const char *local_relpath,
    * too. */
   if (conflict_skel)
     {
-      SVN_ERR(create_conflict_markers(&work_item, local_abspath, db,
-                                      repos_relpath, conflict_skel,
-                                      operation, old_version, new_version,
-                                      svn_node_file,
-                                      scratch_pool, scratch_pool));
+      const char *move_dst_repos_relpath;
 
-      SVN_ERR(svn_wc__db_mark_conflict_internal(wcroot, local_relpath,
-                                                conflict_skel,
-                                                scratch_pool));
+      SVN_ERR(svn_wc__db_depth_get_info(NULL, NULL, NULL,
+                                        &move_dst_repos_relpath, NULL, NULL,
+                                        NULL, NULL, NULL, NULL, NULL, NULL,
+                                        NULL,
+                                        b->wcroot, dst_relpath,
+                                        b->dst_op_depth,
+                                        scratch_pool, scratch_pool));
+
+      SVN_ERR(create_conflict_markers(&work_item, local_abspath, b->db,
+                                      move_dst_repos_relpath, conflict_skel,
+                                      b->operation, &old_version, &new_version,
+                                      svn_node_file, !obstructed,
+                                      scratch_pool, scratch_pool));
 
       work_items = svn_wc__wq_merge(work_items, work_item, scratch_pool);
     }
 
-  SVN_ERR(svn_wc__db_wq_add(db, wcroot->abspath, work_items, scratch_pool));
-
-  SVN_ERR(update_move_list_add(wcroot, local_relpath,
+  SVN_ERR(update_move_list_add(b->wcroot, dst_relpath, b->db,
                                svn_wc_notify_update_update,
                                svn_node_file,
                                content_state,
-                               prop_state));
+                               prop_state,
+                               conflict_skel, work_items, scratch_pool));
 
   return SVN_NO_ERROR;
 }
 
-
-/* Edit the file found at the move destination, which is initially at
- * the old state.  Merge the changes into the "working"/"actual" file.
- */
 static svn_error_t *
-tc_editor_alter_file(void *baton,
-                     const char *dst_relpath,
-                     svn_revnum_t expected_move_dst_revision,
-                     apr_hash_t *new_props,
-                     const svn_checksum_t *new_checksum,
-                     svn_stream_t *new_contents,
-                     apr_pool_t *scratch_pool)
-{
-  struct tc_editor_baton *b = baton;
-  const char *move_dst_repos_relpath;
-  svn_revnum_t move_dst_revision;
-  svn_node_kind_t move_dst_kind;
-  working_node_version_t old_version, new_version;
-  svn_boolean_t is_conflicted;
-  svn_wc__db_status_t status;
-
-  SVN_ERR(svn_wc__db_depth_get_info(&status, &move_dst_kind, &move_dst_revision,
-                                    &move_dst_repos_relpath, NULL, NULL, NULL,
-                                    NULL, NULL, &old_version.checksum, NULL,
-                                    NULL, &old_version.props,
-                                    b->wcroot, dst_relpath,
-                                    relpath_depth(b->move_root_dst_relpath),
-                                    scratch_pool, scratch_pool));
-
-  /* If the node would be recorded as svn_wc__db_status_base_deleted it
-     wouldn't have a repos_relpath */
-  /* ### Can svn_wc__db_depth_get_info() do this for us without this hint? */
-  if (status == svn_wc__db_status_deleted && move_dst_repos_relpath)
-    status = svn_wc__db_status_not_present;
-
-  SVN_ERR_ASSERT(move_dst_revision == expected_move_dst_revision
-                 || status == svn_wc__db_status_not_present);
-  SVN_ERR_ASSERT(move_dst_kind == svn_node_file);
-
-  SVN_ERR(check_tree_conflict(&is_conflicted, b, dst_relpath,
-                              move_dst_kind,
-                              svn_node_file,
-                              move_dst_repos_relpath,
-                              svn_wc_conflict_action_edit,
-                              scratch_pool));
-  if (is_conflicted)
-    return SVN_NO_ERROR;
-
-  old_version.location_and_kind = b->old_version;
-  new_version.location_and_kind = b->new_version;
-
-  /* If new checksum is null that means no change; similarly props. */
-  new_version.checksum = new_checksum ? new_checksum : old_version.checksum;
-  new_version.props = new_props ? new_props : old_version.props;
-
-  /* Update file and prop contents if the update has changed them. */
-  if (!svn_checksum_match(new_checksum, old_version.checksum) || new_props)
-    {
-      SVN_ERR(update_working_file(dst_relpath, move_dst_repos_relpath,
-                                  b->operation, &old_version, &new_version,
-                                  b->wcroot, b->db,
-                                  scratch_pool));
-    }
-
-  return SVN_NO_ERROR;
-}
-
-static svn_error_t *
-tc_editor_alter_symlink(void *baton,
-                        const char *relpath,
-                        svn_revnum_t revision,
-                        apr_hash_t *props,
-                        const char *target,
-                        apr_pool_t *scratch_pool)
-{
-  return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
-}
-
-static svn_error_t *
-tc_editor_delete(void *baton,
+tc_editor_delete(node_move_baton_t *nmb,
                  const char *relpath,
-                 svn_revnum_t revision,
+                 svn_node_kind_t old_kind,
+                 svn_node_kind_t new_kind,
                  apr_pool_t *scratch_pool)
 {
-  struct tc_editor_baton *b = baton;
+  update_move_baton_t *b = nmb->umb;
   svn_sqlite__stmt_t *stmt;
-  int op_depth = relpath_depth(b->move_root_dst_relpath);
-  const char *move_dst_repos_relpath;
-  svn_node_kind_t move_dst_kind;
-  svn_boolean_t is_conflicted;
-  svn_boolean_t must_delete_working_nodes = FALSE;
-  const char *local_abspath = svn_dirent_join(b->wcroot->abspath, relpath,
-                                              scratch_pool);
-  const char *parent_relpath = svn_relpath_dirname(relpath, scratch_pool);
-  int op_depth_below;
-  svn_boolean_t have_row;
+  const char *local_abspath;
+  svn_boolean_t is_modified, is_all_deletes;
+  svn_skel_t *work_items = NULL;
+  svn_skel_t *conflict = NULL;
 
-  SVN_ERR(svn_wc__db_depth_get_info(NULL, &move_dst_kind, NULL,
-                                    &move_dst_repos_relpath, NULL, NULL, NULL,
-                                    NULL, NULL, NULL, NULL, NULL, NULL,
-                                    b->wcroot, relpath,
-                                    relpath_depth(b->move_root_dst_relpath),
-                                    scratch_pool, scratch_pool));
+  SVN_ERR(mark_parent_edited(nmb, scratch_pool));
+  if (nmb->skip)
+    return SVN_NO_ERROR;
 
   /* Check before retracting delete to catch delete-delete
      conflicts. This catches conflicts on the node itself; deleted
      children are caught as local modifications below.*/
-  SVN_ERR(check_tree_conflict(&is_conflicted, b, relpath,
-                              move_dst_kind,
-                              svn_node_unknown,
-                              move_dst_repos_relpath,
-                              svn_wc_conflict_action_delete,
-                              scratch_pool));
+  if (nmb->shadowed)
+    {
+      SVN_ERR(mark_tc_on_op_root(nmb,
+                                 old_kind, new_kind,
+                                 svn_wc_conflict_action_delete,
+                                 scratch_pool));
+      return SVN_NO_ERROR;
+    }
 
-  if (!is_conflicted)
+  local_abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
+  SVN_ERR(svn_wc__node_has_local_mods(&is_modified, &is_all_deletes,
+                                      nmb->umb->db, local_abspath, FALSE,
+                                      NULL, NULL, scratch_pool));
+  if (is_modified)
     {
-      svn_boolean_t is_modified, is_all_deletes;
+      svn_wc_conflict_reason_t reason;
 
-      SVN_ERR(svn_wc__node_has_local_mods(&is_modified, &is_all_deletes, b->db,
-                                          local_abspath,
-                                          NULL, NULL, scratch_pool));
-      if (is_modified)
-        {
-          svn_wc_conflict_reason_t reason;
+      /* No conflict means no NODES rows at the relpath op-depth
+         so it's easy to convert the modified tree into a copy.
 
-          if (!is_all_deletes)
-            {
-              /* No conflict means no NODES rows at the relpath op-depth
-                 so it's easy to convert the modified tree into a copy. */
-              SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                              STMT_UPDATE_OP_DEPTH_RECURSIVE));
-              SVN_ERR(svn_sqlite__bindf(stmt, "isdd", b->wcroot->wc_id, relpath,
-                                        op_depth, relpath_depth(relpath)));
-              SVN_ERR(svn_sqlite__step_done(stmt));
-
-              reason = svn_wc_conflict_reason_edited;
-            }
-          else
-            {
+         Note the following assumptions for relpath:
+            * it is not shadowed
+            * it is not the/an op-root. (or we can't make us a copy)
+       */
 
-              SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                          STMT_DELETE_WORKING_OP_DEPTH_ABOVE));
-              SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, relpath,
-                                        op_depth));
-              SVN_ERR(svn_sqlite__step_done(stmt));
+      SVN_ERR(svn_wc__db_op_make_copy_internal(b->wcroot, relpath, FALSE,
+                                               NULL, NULL, scratch_pool));
 
-              reason = svn_wc_conflict_reason_deleted;
-              must_delete_working_nodes = TRUE;
-            }
-          is_conflicted = TRUE;
-          SVN_ERR(mark_tree_conflict(relpath, b->wcroot, b->db, b->old_version,
-                                     b->new_version, b->move_root_dst_relpath,
-                                     b->operation,
-                                     move_dst_kind,
-                                     svn_node_none,
-                                     move_dst_repos_relpath, reason,
-                                     svn_wc_conflict_action_delete, NULL,
-                                     scratch_pool));
-          b->conflict_root_relpath = apr_pstrdup(b->result_pool, relpath);
-        }
-    }
+      reason = svn_wc_conflict_reason_edited;
 
-  if (!is_conflicted || must_delete_working_nodes)
+      SVN_ERR(create_node_tree_conflict(&conflict, nmb, relpath,
+                                        old_kind, new_kind, reason,
+                                        (new_kind == svn_node_none)
+                                          ? svn_wc_conflict_action_delete
+                                          : svn_wc_conflict_action_replace,
+                                        NULL,
+                                        scratch_pool, scratch_pool));
+      nmb->skip = TRUE;
+    }
+  else
     {
       apr_pool_t *iterpool = svn_pool_create(scratch_pool);
-      svn_skel_t *work_item;
-      svn_node_kind_t del_kind;
       const char *del_abspath;
+      svn_boolean_t have_row;
 
+      /* Get all descendants of the node in reverse order (so children are
+         handled before their parents, but not strictly depth first) */
       SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                        STMT_SELECT_CHILDREN_OP_DEPTH));
+                                        STMT_SELECT_DESCENDANTS_OP_DEPTH_RV));
       SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, relpath,
-                                op_depth));
+                                b->dst_op_depth));
       SVN_ERR(svn_sqlite__step(&have_row, stmt));
       while (have_row)
         {
           svn_error_t *err;
+          svn_skel_t *work_item;
+          svn_node_kind_t del_kind;
 
           svn_pool_clear(iterpool);
 
@@ -1194,8 +1291,7 @@ tc_editor_delete(void *baton,
                                                b->wcroot->abspath, del_abspath,
                                                iterpool, iterpool);
           if (!err)
-            err = svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_item,
-                                    iterpool);
+            err = svn_wc__db_wq_add_internal(b->wcroot, work_item, iterpool);
           if (err)
             return svn_error_compose_create(err, svn_sqlite__reset(stmt));
 
@@ -1203,139 +1299,34 @@ tc_editor_delete(void *baton,
         }
       SVN_ERR(svn_sqlite__reset(stmt));
 
-      SVN_ERR(svn_wc__db_depth_get_info(NULL, &del_kind, NULL, NULL, NULL,
-                                        NULL, NULL, NULL, NULL, NULL, NULL,
-                                        NULL, NULL,
-                                        b->wcroot, relpath, op_depth,
-                                        iterpool, iterpool));
-      if (del_kind == svn_node_dir)
-        SVN_ERR(svn_wc__wq_build_dir_remove(&work_item, b->db,
+      if (old_kind == svn_node_dir)
+        SVN_ERR(svn_wc__wq_build_dir_remove(&work_items, b->db,
                                             b->wcroot->abspath, local_abspath,
                                             FALSE /* recursive */,
-                                            iterpool, iterpool));
+                                            scratch_pool, iterpool));
       else
-        SVN_ERR(svn_wc__wq_build_file_remove(&work_item, b->db,
+        SVN_ERR(svn_wc__wq_build_file_remove(&work_items, b->db,
                                              b->wcroot->abspath, local_abspath,
-                                             iterpool, iterpool));
-      SVN_ERR(svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_item,
-                                iterpool));
-
-      if (!is_conflicted)
-        SVN_ERR(update_move_list_add(b->wcroot, relpath,
-                                     svn_wc_notify_update_delete,
-                                     del_kind,
-                                     svn_wc_notify_state_inapplicable,
-                                     svn_wc_notify_state_inapplicable));
-      svn_pool_destroy(iterpool);
-    }
+                                             scratch_pool, iterpool));
 
-  /* Deleting the ROWS is valid so long as we update the parent before
-     committing the transaction.  The removed rows could have been
-     replacing a lower layer in which case we need to add base-deleted
-     rows. */
-  SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                    STMT_SELECT_HIGHEST_WORKING_NODE));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, parent_relpath,
-                            op_depth));
-  SVN_ERR(svn_sqlite__step(&have_row, stmt));
-  if (have_row)
-    op_depth_below = svn_sqlite__column_int(stmt, 0);
-  SVN_ERR(svn_sqlite__reset(stmt));
-  if (have_row)
-    {
-      /* Remove non-shadowing nodes. */
-      SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                        STMT_DELETE_NO_LOWER_LAYER));
-      SVN_ERR(svn_sqlite__bindf(stmt, "isdd", b->wcroot->wc_id, relpath,
-                                op_depth, op_depth_below));
-      SVN_ERR(svn_sqlite__step_done(stmt));
-
-      /* Convert remaining shadowing nodes to presence='base-deleted'. */
-      SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                        STMT_REPLACE_WITH_BASE_DELETED));
-      SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, relpath,
-                                op_depth));
-      SVN_ERR(svn_sqlite__step_done(stmt));
-    }
-  else
-    {
-      SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
-                                        STMT_DELETE_WORKING_OP_DEPTH));
-      SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, relpath,
-                                op_depth));
-      SVN_ERR(svn_sqlite__step_done(stmt));
+      svn_pool_destroy(iterpool);
     }
 
-  /* Retract any base-delete. */
-  SVN_ERR(svn_wc__db_retract_parent_delete(b->wcroot, relpath, op_depth,
-                                           scratch_pool));
-
-  return SVN_NO_ERROR;
-}
-
-static svn_error_t *
-tc_editor_copy(void *baton,
-               const char *src_relpath,
-               svn_revnum_t src_revision,
-               const char *dst_relpath,
-               svn_revnum_t replaces_rev,
-               apr_pool_t *scratch_pool)
-{
-  return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
-}
-
-static svn_error_t *
-tc_editor_move(void *baton,
-               const char *src_relpath,
-               svn_revnum_t src_revision,
-               const char *dst_relpath,
-               svn_revnum_t replaces_rev,
-               apr_pool_t *scratch_pool)
-{
-  return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
-}
-
-static svn_error_t *
-tc_editor_rotate(void *baton,
-                 const apr_array_header_t *relpaths,
-                 const apr_array_header_t *revisions,
-                 apr_pool_t *scratch_pool)
-{
-  return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
-}
-
-static svn_error_t *
-tc_editor_complete(void *baton,
-                   apr_pool_t *scratch_pool)
-{
-  return SVN_NO_ERROR;
-}
+  /* Only notify if add_file/add_dir is not going to notify */
+  if (conflict || (new_kind == svn_node_none))
+    SVN_ERR(update_move_list_add(b->wcroot, relpath, b->db,
+                                 svn_wc_notify_update_delete,
+                                 new_kind,
+                                 svn_wc_notify_state_inapplicable,
+                                 svn_wc_notify_state_inapplicable,
+                                 conflict, work_items, scratch_pool));
+  else if (work_items)
+    SVN_ERR(svn_wc__db_wq_add_internal(b->wcroot, work_items,
+                                       scratch_pool));
 
-static svn_error_t *
-tc_editor_abort(void *baton,
-                apr_pool_t *scratch_pool)
-{
   return SVN_NO_ERROR;
 }
 
-/* The editor callback table implementing the receiver. */
-static const svn_editor_cb_many_t editor_ops = {
-  tc_editor_add_directory,
-  tc_editor_add_file,
-  tc_editor_add_symlink,
-  tc_editor_add_absent,
-  tc_editor_alter_directory,
-  tc_editor_alter_file,
-  tc_editor_alter_symlink,
-  tc_editor_delete,
-  tc_editor_copy,
-  tc_editor_move,
-  tc_editor_rotate,
-  tc_editor_complete,
-  tc_editor_abort
-};
-
-
 /*
  * Driver code.
  *
@@ -1352,73 +1343,11 @@ static const svn_editor_cb_many_t editor_ops = {
  * single-revision.
  */
 
-/* Set *OPERATION, *LOCAL_CHANGE, *INCOMING_CHANGE, *OLD_VERSION, *NEW_VERSION
- * to reflect the tree conflict on the victim SRC_ABSPATH in DB.
- *
- * If SRC_ABSPATH is not a tree-conflict victim, return an error.
- */
-static svn_error_t *
-get_tc_info(svn_wc_operation_t *operation,
-            svn_wc_conflict_reason_t *local_change,
-            svn_wc_conflict_action_t *incoming_change,
-            const char **move_src_op_root_abspath,
-            svn_wc_conflict_version_t **old_version,
-            svn_wc_conflict_version_t **new_version,
-            svn_wc__db_t *db,
-            const char *src_abspath,
-            apr_pool_t *result_pool,
-            apr_pool_t *scratch_pool)
-{
-  const apr_array_header_t *locations;
-  svn_boolean_t tree_conflicted;
-  svn_skel_t *conflict_skel;
-
-  /* Check for tree conflict on src. */
-  SVN_ERR(svn_wc__db_read_conflict(&conflict_skel, db,
-                                   src_abspath,
-                                   scratch_pool, scratch_pool));
-  if (!conflict_skel)
-    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
-                             _("'%s' is not in conflict"),
-                             svn_dirent_local_style(src_abspath,
-                                                    scratch_pool));
-
-  SVN_ERR(svn_wc__conflict_read_info(operation, &locations,
-                                     NULL, NULL, &tree_conflicted,
-                                     db, src_abspath,
-                                     conflict_skel, result_pool,
-                                     scratch_pool));
-  if ((*operation != svn_wc_operation_update
-       && *operation != svn_wc_operation_switch)
-      || !tree_conflicted)
-    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
-                             _("'%s' is not a tree-conflict victim"),
-                             svn_dirent_local_style(src_abspath,
-                                                    scratch_pool));
-  if (locations)
-    {
-      SVN_ERR_ASSERT(locations->nelts >= 2);
-      *old_version = APR_ARRAY_IDX(locations, 0,
-                                     svn_wc_conflict_version_t *);
-      *new_version = APR_ARRAY_IDX(locations, 1,
-                                   svn_wc_conflict_version_t *);
-    }
-
-  SVN_ERR(svn_wc__conflict_read_tree_conflict(local_change,
-                                              incoming_change,
-                                              move_src_op_root_abspath,
-                                              db, src_abspath,
-                                              conflict_skel, scratch_pool,
-                                              scratch_pool));
-
-  return SVN_NO_ERROR;
-}
-
 /* Return *PROPS, *CHECKSUM, *CHILDREN and *KIND for LOCAL_RELPATH at
    OP_DEPTH provided the row exists.  Return *KIND of svn_node_none if
-   the row does not exist. *CHILDREN is a sorted array of basenames of
-   type 'const char *', rather than a hash, to allow the driver to
-   process children in a defined order. */
+   the row does not exist, or only describes a delete of a lower op-depth.
+   *CHILDREN is a sorted array of basenames of type 'const char *', rather
+   than a hash, to allow the driver to process children in a defined order. */
 static svn_error_t *
 get_info(apr_hash_t **props,
          const svn_checksum_t **checksum,
@@ -1430,64 +1359,68 @@ get_info(apr_hash_t **props,
          apr_pool_t *result_pool,
          apr_pool_t *scratch_pool)
 {
-  apr_hash_t *hash_children;
-  apr_array_header_t *sorted_children;
+  svn_wc__db_status_t status;
+  const char *repos_relpath;
+  svn_node_kind_t db_kind;
   svn_error_t *err;
-  int i;
 
-  err = svn_wc__db_depth_get_info(NULL, kind, NULL, NULL, NULL, NULL, NULL,
-                                  NULL, NULL, checksum, NULL, NULL, props,
+  err = svn_wc__db_depth_get_info(&status, &db_kind, NULL, &repos_relpath, NULL,
+                                  NULL, NULL, NULL, NULL, checksum, NULL,
+                                  NULL, props,
                                   wcroot, local_relpath, op_depth,
                                   result_pool, scratch_pool);
-  if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
+
+  /* If there is no node at this depth, or only a node that describes a delete
+     of a lower layer we report this node as not existing. */
+  if ((err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
+      || (!err && status != svn_wc__db_status_added
+               && status != svn_wc__db_status_normal))
     {
       svn_error_clear(err);
-      *kind = svn_node_none;
+
+      if (kind)
+        *kind = svn_node_none;
+      if (checksum)
+        *checksum = NULL;
+      if (props)
+        *props = NULL;
+      if (children)
+        *children = apr_array_make(result_pool, 0, sizeof(const char *));
+
+      return SVN_NO_ERROR;
     }
   else
     SVN_ERR(err);
 
+  if (kind)
+    *kind = db_kind;
 
-  SVN_ERR(svn_wc__db_get_children_op_depth(&hash_children, wcroot,
-                                           local_relpath, op_depth,
-                                           scratch_pool, scratch_pool));
-
-  sorted_children = svn_sort__hash(hash_children,
-                                   svn_sort_compare_items_lexically,
-                                   scratch_pool);
-
-  *children = apr_array_make(result_pool, sorted_children->nelts,
-                             sizeof(const char *));
-  for (i = 0; i < sorted_children->nelts; ++i)
-    APR_ARRAY_PUSH(*children, const char *)
-      = apr_pstrdup(result_pool, APR_ARRAY_IDX(sorted_children, i,
-                                               svn_sort__item_t).key);
-
-  return SVN_NO_ERROR;
-}
-
-/* Return TRUE if SRC_CHILDREN and DST_CHILDREN represent the same
-   children, FALSE otherwise.  SRC_CHILDREN and DST_CHILDREN are
-   sorted arrays of basenames of type 'const char *'. */
-static svn_boolean_t
-children_match(apr_array_header_t *src_children,
-               apr_array_header_t *dst_children) { int i;
+  if (children && db_kind == svn_node_dir)
+    {
+      svn_sqlite__stmt_t *stmt;
+      svn_boolean_t have_row;
 
-  if (src_children->nelts != dst_children->nelts)
-    return FALSE;
+      *children = apr_array_make(result_pool, 16, sizeof(const char *));
+      SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+                                        STMT_SELECT_OP_DEPTH_CHILDREN_EXISTS));
+      SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, local_relpath,
+                                op_depth));
+      SVN_ERR(svn_sqlite__step(&have_row, stmt));
+      while (have_row)
+        {
+          const char *child_relpath = svn_sqlite__column_text(stmt, 0, NULL);
 
-  for(i = 0; i < src_children->nelts; ++i)
-    {
-      const char *src_child =
-        APR_ARRAY_IDX(src_children, i, const char *);
-      const char *dst_child =
-        APR_ARRAY_IDX(dst_children, i, const char *);
+          APR_ARRAY_PUSH(*children, const char *)
+              = svn_relpath_basename(child_relpath, result_pool);
 
-      if (strcmp(src_child, dst_child))
-        return FALSE;
+          SVN_ERR(svn_sqlite__step(&have_row, stmt));
+        }
+      SVN_ERR(svn_sqlite__reset(stmt));
     }
+  else if (children)
+    *children = apr_array_make(result_pool, 0, sizeof(const char *));
 
-  return TRUE;
+  return SVN_NO_ERROR;
 }
 
 /* Return TRUE if SRC_PROPS and DST_PROPS contain the same properties,
@@ -1516,97 +1449,77 @@ props_match(svn_boolean_t *match,
 /* ### Drive TC_EDITOR so as to ...
  */
 static svn_error_t *
-update_moved_away_node(svn_editor_t *tc_editor,
+update_moved_away_node(node_move_baton_t *nmb,
+                       svn_wc__db_wcroot_t *wcroot,
                        const char *src_relpath,
                        const char *dst_relpath,
-                       int src_op_depth,
-                       const char *move_root_dst_relpath,
-                       svn_revnum_t move_root_dst_revision,
-                       svn_wc__db_t *db,
-                       svn_wc__db_wcroot_t *wcroot,
                        apr_pool_t *scratch_pool)
 {
+  update_move_baton_t *b = nmb->umb;
   svn_node_kind_t src_kind, dst_kind;
   const svn_checksum_t *src_checksum, *dst_checksum;
   apr_hash_t *src_props, *dst_props;
   apr_array_header_t *src_children, *dst_children;
-  int dst_op_depth = relpath_depth(move_root_dst_relpath);
+
+  if (b->cancel_func)
+    SVN_ERR(b->cancel_func(b->cancel_baton));
 
   SVN_ERR(get_info(&src_props, &src_checksum, &src_children, &src_kind,
-                   src_relpath, src_op_depth,
+                   src_relpath, b->src_op_depth,
                    wcroot, scratch_pool, scratch_pool));
 
   SVN_ERR(get_info(&dst_props, &dst_checksum, &dst_children, &dst_kind,
-                   dst_relpath, dst_op_depth,
+                   dst_relpath, b->dst_op_depth,
                    wcroot, scratch_pool, scratch_pool));
 
   if (src_kind == svn_node_none
       || (dst_kind != svn_node_none && src_kind != dst_kind))
     {
-      SVN_ERR(svn_editor_delete(tc_editor, dst_relpath,
-                                move_root_dst_revision));
+      SVN_ERR(tc_editor_delete(nmb, dst_relpath, dst_kind, src_kind,
+                               scratch_pool));
     }
 
+  if (nmb->skip)
+    return SVN_NO_ERROR;
+
   if (src_kind != svn_node_none && src_kind != dst_kind)
     {
       if (src_kind == svn_node_file || src_kind == svn_node_symlink)
         {
-          svn_stream_t *contents;
-
-          SVN_ERR(svn_wc__db_pristine_read(&contents, NULL, db,
-                                           wcroot->abspath, src_checksum,
-                                           scratch_pool, scratch_pool));
-          SVN_ERR(svn_editor_add_file(tc_editor, dst_relpath,
-                                      src_checksum, contents, src_props,
-                                      move_root_dst_revision));
+          SVN_ERR(tc_editor_add_file(nmb, dst_relpath, dst_kind,
+                                     src_checksum, src_props, scratch_pool));
         }
       else if (src_kind == svn_node_dir)
         {
-          SVN_ERR(svn_editor_add_directory(tc_editor, dst_relpath,
-                                           src_children, src_props,
-                                           move_root_dst_revision));
+          SVN_ERR(tc_editor_add_directory(nmb, dst_relpath, dst_kind,
+                                          src_props, scratch_pool));
         }
     }
   else if (src_kind != svn_node_none)
     {
-      svn_boolean_t match;
-      apr_hash_t *props;
-
-      SVN_ERR(props_match(&match, src_props, dst_props, scratch_pool));
-      props = match ? NULL: src_props;
+      svn_boolean_t props_equal;
 
+      SVN_ERR(props_match(&props_equal, src_props, dst_props, scratch_pool));
 
       if (src_kind == svn_node_file || src_kind == svn_node_symlink)
         {
-          svn_stream_t *contents;
-
-          if (svn_checksum_match(src_checksum, dst_checksum))
-            src_checksum = NULL;
-
-          if (src_checksum)
-            SVN_ERR(svn_wc__db_pristine_read(&contents, NULL, db,
-                                             wcroot->abspath, src_checksum,
-                                             scratch_pool, scratch_pool));
-          else
-            contents = NULL;
-
-          if (props || src_checksum)
-            SVN_ERR(svn_editor_alter_file(tc_editor, dst_relpath,
-                                          move_root_dst_revision,
-                                          props, src_checksum, contents));
+          if (!props_equal || !svn_checksum_match(src_checksum, dst_checksum))
+            SVN_ERR(tc_editor_alter_file(nmb, dst_relpath,
+                                         dst_checksum, src_checksum,
+                                         dst_props, src_props, scratch_pool));
         }
       else if (src_kind == svn_node_dir)
         {
-          apr_array_header_t *children
-            = children_match(src_children, dst_children) ? NULL : src_children;
-
-          if (props || children)
-            SVN_ERR(svn_editor_alter_directory(tc_editor, dst_relpath,
-                                               move_root_dst_revision,
-                                               children, props));
+          if (!props_equal)
+            SVN_ERR(tc_editor_alter_directory(nmb, dst_relpath,
+                                              dst_props, src_props,
+                                              scratch_pool));
         }
     }
 
+  if (nmb->skip)
+    return SVN_NO_ERROR;
+
   if (src_kind == svn_node_dir)
     {
       apr_pool_t *iterpool = svn_pool_create(scratch_pool);
@@ -1615,8 +1528,12 @@ update_moved_away_node(svn_editor_t *tc_editor,
       while (i < src_children->nelts || j < dst_children->nelts)
         {
           const char *child_name;
-          const char *src_child_relpath, *dst_child_relpath;
           svn_boolean_t src_only = FALSE, dst_only = FALSE;
+          node_move_baton_t cnmb = { 0 };
+
+          cnmb.pb = nmb;
+          cnmb.umb = nmb->umb;
+          cnmb.shadowed = nmb->shadowed;
 
           svn_pool_clear(iterpool);
           if (i >= src_children->nelts)
@@ -1645,130 +1562,28 @@ update_moved_away_node(svn_editor_t *tc_editor,
               child_name = dst_only ? dst_name : src_name;
             }
 
-          src_child_relpath = svn_relpath_join(src_relpath, child_name,
-                                               iterpool);
-          dst_child_relpath = svn_relpath_join(dst_relpath, child_name,
-                                               iterpool);
+          cnmb.src_relpath = svn_relpath_join(src_relpath, child_name,
+                                              iterpool);
+          cnmb.dst_relpath = svn_relpath_join(dst_relpath, child_name,
+                                              iterpool);
 
-          SVN_ERR(update_moved_away_node(tc_editor, src_child_relpath,
-                                         dst_child_relpath, src_op_depth,
-                                         move_root_dst_relpath,
-                                         move_root_dst_revision,
-                                         db, wcroot, scratch_pool));
+          if (!cnmb.shadowed)
+            SVN_ERR(check_node_shadowed(&cnmb.shadowed, wcroot,
+                                        cnmb.dst_relpath, b->dst_op_depth,
+                                        iterpool));
+
+          SVN_ERR(update_moved_away_node(&cnmb, wcroot, cnmb.src_relpath,
+                                         cnmb.dst_relpath, iterpool));
 
           if (!dst_only)
             ++i;
           if (!src_only)
             ++j;
-        }
-    }
-
-  return SVN_NO_ERROR;
-}
-
-/* Update the single op-depth layer in the move destination subtree
-   rooted at DST_RELPATH to make it match the move source subtree
-   rooted at SRC_RELPATH. */
-static svn_error_t *
-replace_moved_layer(const char *src_relpath,
-                    const char *dst_relpath,
-                    int src_op_depth,
-                    svn_wc__db_wcroot_t *wcroot,
-                    apr_pool_t *scratch_pool)
-{
-  svn_sqlite__stmt_t *stmt;
-  svn_boolean_t have_row;
-  int dst_op_depth = relpath_depth(dst_relpath);
 
-  /* Replace entire subtree at one op-depth. */
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_LOCAL_RELPATH_OP_DEPTH));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
-                            src_relpath, src_op_depth));
-  SVN_ERR(svn_sqlite__step(&have_row, stmt));
-  while (have_row)
-    {
-      svn_error_t *err;
-      svn_sqlite__stmt_t *stmt2;
-      const char *src_cp_relpath = svn_sqlite__column_text(stmt, 0, NULL);
-      const char *dst_cp_relpath
-        = svn_relpath_join(dst_relpath,
-                           svn_relpath_skip_ancestor(src_relpath,
-                                                     src_cp_relpath),
-                           scratch_pool);
-
-      err = svn_sqlite__get_statement(&stmt2, wcroot->sdb,
-                                      STMT_COPY_NODE_MOVE);
-      if (!err)
-        err = svn_sqlite__bindf(stmt2, "isdsds", wcroot->wc_id,
-                                src_cp_relpath, src_op_depth,
-                                dst_cp_relpath, dst_op_depth,
-                                svn_relpath_dirname(dst_cp_relpath,
-                                                    scratch_pool));
-      if (!err)
-        err = svn_sqlite__step_done(stmt2);
-      if (err)
-        return svn_error_compose_create(err, svn_sqlite__reset(stmt));
-
-      SVN_ERR(svn_sqlite__step(&have_row, stmt));
+          if (nmb->skip) /* Does parent now want a skip? */
+            break;
+        }
     }
-  SVN_ERR(svn_sqlite__reset(stmt));
-
-  return SVN_NO_ERROR;
-}
-
-/* Transfer changes from the move source to the move destination.
- *
- * Drive the editor TC_EDITOR with the difference between DST_RELPATH
- * (at its own op-depth) and SRC_RELPATH (at op-depth zero).
- *
- * Then update the single op-depth layer in the move destination subtree
- * rooted at DST_RELPATH to make it match the move source subtree
- * rooted at SRC_RELPATH.
- *
- * ### And the other params?
- */
-static svn_error_t *
-drive_tree_conflict_editor(svn_editor_t *tc_editor,
-                           const char *src_relpath,
-                           const char *dst_relpath,
-                           int src_op_depth,
-                           svn_wc_operation_t operation,
-                           svn_wc_conflict_reason_t local_change,
-                           svn_wc_conflict_action_t incoming_change,
-                           svn_wc_conflict_version_t *old_version,
-                           svn_wc_conflict_version_t *new_version,
-                           svn_wc__db_t *db,
-                           svn_wc__db_wcroot_t *wcroot,
-                           svn_cancel_func_t cancel_func,
-                           void *cancel_baton,
-                           apr_pool_t *scratch_pool)
-{
-  /*
-   * Refuse to auto-resolve unsupported tree conflicts.
-   */
-  /* ### Only handle conflicts created by update/switch operations for now. */
-  if (operation != svn_wc_operation_update &&
-      operation != svn_wc_operation_switch)
-    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
-                            _("Cannot auto-resolve tree-conflict on '%s'"),
-                            svn_dirent_local_style(
-                              svn_dirent_join(wcroot->abspath,
-                                              src_relpath, scratch_pool),
-                              scratch_pool));
-
-  /* We walk the move source (i.e. the post-update tree), comparing each node
-   * with the equivalent node at the move destination and applying the update
-   * to nodes at the move destination. */
-  SVN_ERR(update_moved_away_node(tc_editor, src_relpath, dst_relpath,
-                                 src_op_depth,
-                                 dst_relpath, old_version->peg_rev,
-                                 db, wcroot, scratch_pool));
-
-  SVN_ERR(replace_moved_layer(src_relpath, dst_relpath, src_op_depth,
-                              wcroot, scratch_pool));
-
-  SVN_ERR(svn_editor_complete(tc_editor));
 
   return SVN_NO_ERROR;
 }
@@ -1788,14 +1603,13 @@ suitable_for_move(svn_wc__db_wcroot_t *wcroot,
                                     STMT_SELECT_BASE_NODE));
   SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id, local_relpath));
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
-  if (have_row)
-    {
-      revision = svn_sqlite__column_revnum(stmt, 4);
-      repos_relpath = svn_sqlite__column_text(stmt, 1, scratch_pool);
-    }
-  SVN_ERR(svn_sqlite__reset(stmt));
   if (!have_row)
-    return SVN_NO_ERROR; /* Return an error? */
+    return svn_error_trace(svn_sqlite__reset(stmt));
+
+  revision = svn_sqlite__column_revnum(stmt, 4);
+  repos_relpath = svn_sqlite__column_text(stmt, 1, scratch_pool);
+
+  SVN_ERR(svn_sqlite__reset(stmt));
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
                                     STMT_SELECT_REPOS_PATH_REVISION));
@@ -1816,22 +1630,17 @@ suitable_for_move(svn_wc__db_wcroot_t *wcroot,
                                  svn_sqlite__reset(stmt),
                                  _("Cannot apply update because move source "
                                    "%s' is a mixed-revision working copy"),
-                                 svn_dirent_local_style(svn_dirent_join(
-                                                          wcroot->abspath,
-                                                          local_relpath,
-                                                          scratch_pool),
-                                 scratch_pool));
+                                 path_for_error_message(wcroot, local_relpath,
+                                                        scratch_pool));
 
       if (strcmp(relpath, svn_sqlite__column_text(stmt, 1, NULL)))
         return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
                                  svn_sqlite__reset(stmt),
                                  _("Cannot apply update because move source "
                                    "'%s' is a switched subtree"),
-                                 svn_dirent_local_style(svn_dirent_join(
-                                                          wcroot->abspath,
-                                                          local_relpath,
-                                                          scratch_pool),
-                                 scratch_pool));
+                                 path_for_error_message(wcroot,
+                                                        local_relpath,
+                                                        scratch_pool));
 
       SVN_ERR(svn_sqlite__step(&have_row, stmt));
     }
@@ -1845,96 +1654,113 @@ suitable_for_move(svn_wc__db_wcroot_t *wcroot,
 /* The body of svn_wc__db_update_moved_away_conflict_victim(), which see.
  */
 static svn_error_t *
-update_moved_away_conflict_victim(svn_wc__db_t *db,
+update_moved_away_conflict_victim(svn_revnum_t *old_rev,
+                                  svn_revnum_t *new_rev,
+                                  svn_wc__db_t *db,
                                   svn_wc__db_wcroot_t *wcroot,
-                                  const char *victim_relpath,
+                                  const char *local_relpath,
+                                  const char *delete_relpath,
                                   svn_wc_operation_t operation,
-                                  svn_wc_conflict_reason_t local_change,
-                                  svn_wc_conflict_action_t incoming_change,
-                                  const char *move_src_op_root_relpath,
-                                  svn_wc_conflict_version_t *old_version,
-                                  svn_wc_conflict_version_t *new_version,
+                                  svn_wc_conflict_action_t action,
+                                  svn_wc_conflict_reason_t reason,
                                   svn_cancel_func_t cancel_func,
                                   void *cancel_baton,
                                   apr_pool_t *scratch_pool)
 {
-  svn_editor_t *tc_editor;
-  struct tc_editor_baton *tc_editor_baton;
-  svn_sqlite__stmt_t *stmt;
-  svn_boolean_t have_row;
-  const char *dummy1, *dummy2, *dummy3;
-  int src_op_depth;
-  const char *move_root_dst_abspath;
+  update_move_baton_t umb = { NULL };
+  const char *src_relpath, *dst_relpath;
+  svn_wc_conflict_version_t old_version;
+  svn_wc_conflict_version_t new_version;
+  apr_int64_t repos_id;
+  node_move_baton_t nmb = { 0 };
 
-  /* ### assumes wc write lock already held */
+  SVN_ERR_ASSERT(svn_relpath_skip_ancestor(delete_relpath, local_relpath));
 
   /* Construct editor baton. */
-  tc_editor_baton = apr_pcalloc(scratch_pool, sizeof(*tc_editor_baton));
-  SVN_ERR(svn_wc__db_op_depth_moved_to(
-            &dummy1, &tc_editor_baton->move_root_dst_relpath, &dummy2, &dummy3,
-            relpath_depth(move_src_op_root_relpath) - 1,
-            wcroot, victim_relpath, scratch_pool, scratch_pool));
-  if (tc_editor_baton->move_root_dst_relpath == NULL)
+
+  SVN_ERR(find_src_op_depth(&umb.src_op_depth, wcroot,
+                            local_relpath, relpath_depth(delete_relpath),
+                            scratch_pool));
+
+  SVN_ERR(svn_wc__db_scan_moved_to_internal(&src_relpath, &dst_relpath, NULL,
+                                            wcroot, local_relpath,
+                                            umb.src_op_depth,
+                                            scratch_pool, scratch_pool));
+
+  if (dst_relpath == NULL)
     return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
                              _("The node '%s' has not been moved away"),
-                             svn_dirent_local_style(
-                               svn_dirent_join(wcroot->abspath, victim_relpath,
-                                               scratch_pool),
-                               scratch_pool));
+                             path_for_error_message(wcroot, local_relpath,
+                                                    scratch_pool));
 
-  move_root_dst_abspath
-    = svn_dirent_join(wcroot->abspath, tc_editor_baton->move_root_dst_relpath,
-                      scratch_pool);
-  SVN_ERR(svn_wc__write_check(db, move_root_dst_abspath, scratch_pool));
+  umb.dst_op_depth = relpath_depth(dst_relpath);
 
-  tc_editor_baton->operation = operation;
-  tc_editor_baton->old_version= old_version;
-  tc_editor_baton->new_version= new_version;
-  tc_editor_baton->db = db;
-  tc_editor_baton->wcroot = wcroot;
-  tc_editor_baton->result_pool = scratch_pool;
+  SVN_ERR(verify_write_lock(wcroot, src_relpath, scratch_pool));
+  SVN_ERR(verify_write_lock(wcroot, dst_relpath, scratch_pool));
 
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_HIGHEST_WORKING_NODE));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
-                            move_src_op_root_relpath,
-                            relpath_depth(move_src_op_root_relpath)));
-  SVN_ERR(svn_sqlite__step(&have_row, stmt));
-  if (have_row)
-    src_op_depth = svn_sqlite__column_int(stmt, 0);
-  SVN_ERR(svn_sqlite__reset(stmt));
-  if (!have_row)
-    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
-                             _("'%s' is not deleted"),
-                             svn_dirent_local_style(
-                               svn_dirent_join(wcroot->abspath, victim_relpath,
-                                               scratch_pool),
-                               scratch_pool));
 
-  if (src_op_depth == 0)
-    SVN_ERR(suitable_for_move(wcroot, victim_relpath, scratch_pool));
+  SVN_ERR(svn_wc__db_depth_get_info(NULL, &new_version.node_kind,
+                                    &new_version.peg_rev,
+                                    &new_version.path_in_repos, &repos_id,
+                                    NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                    NULL,
+                                    wcroot, src_relpath, umb.src_op_depth,
+                                    scratch_pool, scratch_pool));
+
+  SVN_ERR(svn_wc__db_fetch_repos_info(&new_version.repos_url,
+                                      &new_version.repos_uuid,
+                                      wcroot, repos_id,
+                                      scratch_pool));
+
+  SVN_ERR(svn_wc__db_depth_get_info(NULL, &old_version.node_kind,
+                                    &old_version.peg_rev,
+                                    &old_version.path_in_repos, &repos_id,
+                                    NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                                    NULL,
+                                    wcroot, dst_relpath, umb.dst_op_depth,
+                                    scratch_pool, scratch_pool));
+
+  SVN_ERR(svn_wc__db_fetch_repos_info(&old_version.repos_url,
+                                      &old_version.repos_uuid,
+                                      wcroot, repos_id,
+                                      scratch_pool));
+  *old_rev = old_version.peg_rev;
+  *new_rev = new_version.peg_rev;
+
+  umb.operation = operation;
+  umb.old_version= &old_version;
+  umb.new_version= &new_version;
+  umb.db = db;
+  umb.wcroot = wcroot;
+  umb.cancel_func = cancel_func;
+  umb.cancel_baton = cancel_baton;
+
+  if (umb.src_op_depth == 0)
+    SVN_ERR(suitable_for_move(wcroot, src_relpath, scratch_pool));
 
   /* Create a new, and empty, list for notification information. */
   SVN_ERR(svn_sqlite__exec_statements(wcroot->sdb,
                                       STMT_CREATE_UPDATE_MOVE_LIST));
-  /* Create the editor... */
-  SVN_ERR(svn_editor_create(&tc_editor, tc_editor_baton,
-                            cancel_func, cancel_baton,
-                            scratch_pool, scratch_pool));
-  SVN_ERR(svn_editor_setcb_many(tc_editor, &editor_ops, scratch_pool));
-
-  /* ... and drive it. */
-  SVN_ERR(drive_tree_conflict_editor(tc_editor,
-                                     victim_relpath,
-                                     tc_editor_baton->move_root_dst_relpath,
-                                     src_op_depth,
-                                     operation,
-                                     local_change, incoming_change,
-                                     tc_editor_baton->old_version,
-                                     tc_editor_baton->new_version,
-                                     db, wcroot,
-                                     cancel_func, cancel_baton,
-                                     scratch_pool));
+
+  /* Drive the editor... */
+
+  nmb.umb = &umb;
+  nmb.src_relpath = src_relpath;
+  nmb.dst_relpath = dst_relpath;
+  /* nmb.shadowed = FALSE; */
+  /* nmb.edited = FALSE; */
+  /* nmb.skip_children = FALSE; */
+
+  /* We walk the move source (i.e. the post-update tree), comparing each node
+    * with the equivalent node at the move destination and applying the update
+    * to nodes at the move destination. */
+  SVN_ERR(update_moved_away_node(&nmb, wcroot, src_relpath, dst_relpath,
+                                 scratch_pool));
+
+  SVN_ERR(svn_wc__db_op_copy_layer_internal(wcroot, src_relpath,
+                                            umb.src_op_depth,
+                                            dst_relpath, NULL, NULL,
+                                            scratch_pool));
 
   return SVN_NO_ERROR;
 }
@@ -1942,58 +1768,43 @@ update_moved_away_conflict_victim(svn_wc__db_t *db,
 
 svn_error_t *
 svn_wc__db_update_moved_away_conflict_victim(svn_wc__db_t *db,
-                                             const char *victim_abspath,
-                                             svn_wc_notify_func2_t notify_func,
-                                             void *notify_baton,
+                                             const char *local_abspath,
+                                             const char *delete_op_abspath,
+                                             svn_wc_operation_t operation,
+                                             svn_wc_conflict_action_t action,
+                                             svn_wc_conflict_reason_t reason,
                                              svn_cancel_func_t cancel_func,
                                              void *cancel_baton,
+                                             svn_wc_notify_func2_t notify_func,
+                                             void *notify_baton,
                                              apr_pool_t *scratch_pool)
 {
   svn_wc__db_wcroot_t *wcroot;
+  svn_revnum_t old_rev, new_rev;
   const char *local_relpath;
-  svn_wc_operation_t operation;
-  svn_wc_conflict_reason_t local_change;
-  svn_wc_conflict_action_t incoming_change;
-  svn_wc_conflict_version_t *old_version;
-  svn_wc_conflict_version_t *new_version;
-  const char *move_src_op_root_abspath, *move_src_op_root_relpath;
+  const char *delete_relpath;
 
   /* ### Check for mixed-rev src or dst? */
 
-  SVN_ERR(get_tc_info(&operation, &local_change, &incoming_change,
-                      &move_src_op_root_abspath,
-                      &old_version, &new_version,
-                      db, victim_abspath,
-                      scratch_pool, scratch_pool));
-
-  SVN_ERR(svn_wc__write_check(db, move_src_op_root_abspath, scratch_pool));
-
   SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath,
-                                                db, victim_abspath,
+                                                db, local_abspath,
                                                 scratch_pool, scratch_pool));
   VERIFY_USABLE_WCROOT(wcroot);
 
-  move_src_op_root_relpath
-    = svn_dirent_skip_ancestor(wcroot->abspath, move_src_op_root_abspath);
+  delete_relpath
+    = svn_dirent_skip_ancestor(wcroot->abspath, delete_op_abspath);
 
   SVN_WC__DB_WITH_TXN(
     update_moved_away_conflict_victim(
-      db, wcroot, local_relpath,
-      operation, local_change, incoming_change,
-      move_src_op_root_relpath,
-      old_version, new_version,
+      &old_rev, &new_rev,
+      db, wcroot, local_relpath, delete_relpath,
+      operation, action, reason,
       cancel_func, cancel_baton,
       scratch_pool),
     wcroot);
 
   /* Send all queued up notifications. */
-  SVN_ERR(svn_wc__db_update_move_list_notify(wcroot,
-                                             (old_version
-                                              ? old_version->peg_rev
-                                              : SVN_INVALID_REVNUM),
-                                             (new_version
-                                              ? new_version->peg_rev
-                                              : SVN_INVALID_REVNUM),
+  SVN_ERR(svn_wc__db_update_move_list_notify(wcroot, old_rev, new_rev,
                                              notify_func, notify_baton,
                                              scratch_pool));
   if (notify_func)
@@ -2008,7 +1819,7 @@ svn_wc__db_update_moved_away_conflict_victim(svn_wc__db_t *db,
       notify->kind = svn_node_none;
       notify->content_state = svn_wc_notify_state_inapplicable;
       notify->prop_state = svn_wc_notify_state_inapplicable;
-      notify->revision = new_version->peg_rev;
+      notify->revision = new_rev;
       notify_func(notify_baton, notify, scratch_pool);
     }
 
@@ -2017,11 +1828,12 @@ svn_wc__db_update_moved_away_conflict_victim(svn_wc__db_t *db,
 }
 
 /* Set *CAN_BUMP to TRUE if DEPTH is sufficient to cover the entire
-   BASE tree at LOCAL_RELPATH, to FALSE otherwise. */
+   tree  LOCAL_RELPATH at OP_DEPTH, to FALSE otherwise. */
 static svn_error_t *
 depth_sufficient_to_bump(svn_boolean_t *can_bump,
-                         const char *local_relpath,
                          svn_wc__db_wcroot_t *wcroot,
+                         const char *local_relpath,
+                         int op_depth,
                          svn_depth_t depth,
                          apr_pool_t *scratch_pool)
 {
@@ -2038,21 +1850,21 @@ depth_sufficient_to_bump(svn_boolean_t *can_bump,
       SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
                                         STMT_SELECT_OP_DEPTH_CHILDREN));
       SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
-                                local_relpath, 0));
+                                local_relpath, op_depth));
       break;
 
     case svn_depth_files:
       SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
                                         STMT_SELECT_HAS_NON_FILE_CHILDREN));
-      SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id,
-                                local_relpath));
+      SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
+                                local_relpath, op_depth));
       break;
 
     case svn_depth_immediates:
       SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
                                         STMT_SELECT_HAS_GRANDCHILDREN));
-      SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id,
-                                local_relpath));
+      SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
+                                local_relpath, op_depth));
       break;
     default:
       SVN_ERR_MALFUNCTION();
@@ -2068,6 +1880,7 @@ depth_sufficient_to_bump(svn_boolean_t *can_bump,
 static svn_error_t *
 bump_mark_tree_conflict(svn_wc__db_wcroot_t *wcroot,
                         const char *move_src_root_relpath,
+                        int src_op_depth,
                         const char *move_src_op_root_relpath,
                         const char *move_dst_op_root_relpath,
                         svn_wc__db_t *db,
@@ -2084,18 +1897,29 @@ bump_mark_tree_conflict(svn_wc__db_wcroot_t *wcroot,
   svn_node_kind_t new_kind;
   svn_wc_conflict_version_t *old_version;
   svn_wc_conflict_version_t *new_version;
+  svn_skel_t *conflict;
+
+  /* Verify precondition: We are allowed to set a tree conflict here. */
+  SVN_ERR(verify_write_lock(wcroot, move_src_root_relpath, scratch_pool));
 
   /* Read new (post-update) information from the new move source BASE node. */
-  SVN_ERR(svn_wc__db_base_get_info_internal(NULL, &new_kind, &new_rev,
-                                            &new_repos_relpath, &repos_id,
-                                            NULL, NULL, NULL, NULL, NULL,
-                                            NULL, NULL, NULL, NULL, NULL,
-                                            wcroot, move_src_op_root_relpath,
-                                            scratch_pool, scratch_pool));
+  SVN_ERR(svn_wc__db_depth_get_info(NULL, &new_kind, &new_rev,
+                                    &new_repos_relpath, &repos_id,
+                                    NULL, NULL, NULL, NULL, NULL,
+                                    NULL, NULL, NULL,
+                                    wcroot, move_src_op_root_relpath,
+                                    src_op_depth, scratch_pool, scratch_pool));
   SVN_ERR(svn_wc__db_fetch_repos_info(&repos_root_url, &repos_uuid,
-                                      wcroot->sdb, repos_id, scratch_pool));
+                                      wcroot, repos_id, scratch_pool));
+
+  /* Read old (pre-update) information from the move destination node.
 
-  /* Read old (pre-update) information from the move destination node. */
+     This potentially touches nodes that aren't locked by us, but that is not
+     a problem because we have a SQLite write lock here, and all sqlite
+     operations that affect move stability use a sqlite lock as well.
+     (And affecting the move itself requires a write lock on the node that
+      we do own the lock for: the move source)
+  */
   SVN_ERR(svn_wc__db_depth_get_info(NULL, &old_kind, &old_rev,
                                     &old_repos_relpath, NULL, NULL, NULL,
                                     NULL, NULL, NULL, NULL, NULL, NULL,
@@ -2103,6 +1927,21 @@ bump_mark_tree_conflict(svn_wc__db_wcroot_t *wcroot,
                                     relpath_depth(move_dst_op_root_relpath),
                                     scratch_pool, scratch_pool));
 
+  if (strcmp(move_src_root_relpath, move_src_op_root_relpath))
+    {
+      /* We have information for the op-root, but need it for the node that
+         we are putting the tree conflict on. Luckily we know that we have
+         a clean BASE */
+
+      const char *rpath = svn_relpath_skip_ancestor(move_src_op_root_relpath,
+                                                    move_src_root_relpath);
+
+      old_repos_relpath = svn_relpath_join(old_repos_relpath, rpath,
+                                           scratch_pool);
+      new_repos_relpath = svn_relpath_join(new_repos_relpath, rpath,
+                                           scratch_pool);
+    }
+
   old_version = svn_wc_conflict_version_create2(
                   repos_root_url, repos_uuid, old_repos_relpath, old_rev,
                   old_kind, scratch_pool);
@@ -2110,38 +1949,202 @@ bump_mark_tree_conflict(svn_wc__db_wcroot_t *wcroot,
                   repos_root_url, repos_uuid, new_repos_relpath, new_rev,
                   new_kind, scratch_pool);
 
-  SVN_ERR(mark_tree_conflict(move_src_root_relpath,
-                             wcroot, db, old_version, new_version,
-                             move_dst_op_root_relpath,
-                             svn_wc_operation_update,
-                             old_kind, new_kind,
-                             old_repos_relpath,
-                             svn_wc_conflict_reason_moved_away,
-                             svn_wc_conflict_action_edit,
-                             move_src_op_root_relpath,
-                             scratch_pool));
+  SVN_ERR(create_tree_conflict(&conflict, wcroot, move_src_root_relpath,
+                               move_dst_op_root_relpath,
+                               db, old_version, new_version,
+                               svn_wc_operation_update,
+                               old_kind, new_kind,
+                               old_repos_relpath,
+                               svn_wc_conflict_reason_moved_away,
+                               svn_wc_conflict_action_edit,
+                               move_src_op_root_relpath,
+                               scratch_pool, scratch_pool));
+
+  SVN_ERR(update_move_list_add(wcroot, move_src_root_relpath, db,
+                               svn_wc_notify_tree_conflict,
+                               new_kind,
+                               svn_wc_notify_state_inapplicable,
+                               svn_wc_notify_state_inapplicable,
+                               conflict, NULL, scratch_pool));
 
   return SVN_NO_ERROR;
 }
 
-/* Bump LOCAL_RELPATH, and all the children of LOCAL_RELPATH, that are
-   moved-to at op-depth greater than OP_DEPTH.  SRC_DONE is a hash
-   with keys that are 'const char *' relpaths that have already been
-   bumped.  Any bumped paths are added to SRC_DONE. */
+/* Checks if SRC_RELPATH is within BUMP_DEPTH from BUMP_ROOT. Sets
+ * *SKIP to TRUE if the node should be skipped, otherwise to FALSE.
+ * Sets *SRC_DEPTH to the remaining depth at SRC_RELPATH.
+ */
+static svn_error_t *
+check_bump_layer(svn_boolean_t *skip,
+                 svn_depth_t *src_depth,
+                 const char *bump_root,
+                 svn_depth_t bump_depth,
+                 const char *src_relpath,
+                 svn_node_kind_t src_kind,
+                 apr_pool_t *scratch_pool)
+{
+  const char *relpath;
+
+  *skip = FALSE;
+  *src_depth = bump_depth;
+
+  relpath = svn_relpath_skip_ancestor(bump_root, src_relpath);
+
+  if (!relpath)
+    *skip = TRUE;
+
+  if (bump_depth == svn_depth_infinity)
+    return SVN_NO_ERROR;
+
+  if (relpath && *relpath == '\0')
+    return SVN_NO_ERROR;
+
+  switch (bump_depth)
+    {
+      case svn_depth_empty:
+        *skip = TRUE;
+        break;
+
+      case svn_depth_files:
+        if (src_kind != svn_node_file)
+          {
+            *skip = TRUE;
+            break;
+          }
+        /* Fallthrough */
+      case svn_depth_immediates:
+        if (!relpath || relpath_depth(relpath) > 1)
+          *skip = TRUE;
+
+        *src_depth = svn_depth_empty;
+        break;
+      default:
+        SVN_ERR_MALFUNCTION();
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* The guts of bump_moved_away: Determines if a move can be bumped to match
+ * the move origin and if so performs this bump.
+ */
+static svn_error_t *
+bump_moved_layer(svn_boolean_t *recurse,
+                 svn_wc__db_wcroot_t *wcroot,
+                 const char *local_relpath,
+                 int op_depth,
+                 const char *src_relpath,
+                 int src_del_depth,
+                 svn_depth_t src_depth,
+                 const char *dst_relpath,
+                 svn_wc__db_t *db,
+                 apr_pool_t *scratch_pool)
+{
+  svn_sqlite__stmt_t *stmt;
+  svn_boolean_t have_row;
+  svn_skel_t *conflict;
+  svn_boolean_t can_bump;
+  const char *src_root_relpath;
+
+  SVN_ERR(verify_write_lock(wcroot, local_relpath, scratch_pool));
+
+  *recurse = FALSE;
+
+  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+                                    STMT_HAS_LAYER_BETWEEN));
+
+  SVN_ERR(svn_sqlite__bindf(stmt, "isdd", wcroot->wc_id, local_relpath,
+                            op_depth, src_del_depth));
+
+  SVN_ERR(svn_sqlite__step(&have_row, stmt));
+  SVN_ERR(svn_sqlite__reset(stmt));
+
+  if (have_row)
+    return SVN_NO_ERROR;
+
+  if (op_depth == 0)
+    SVN_ERR(depth_sufficient_to_bump(&can_bump, wcroot, src_relpath,
+                                     op_depth, src_depth, scratch_pool));
+  else
+    /* Having chosen to bump an entire BASE tree move we
+       always have sufficient depth to bump subtree moves. */
+    can_bump = TRUE;
+
+  /* Are we allowed to bump */
+  if (can_bump)
+    {
+      svn_boolean_t locked;
+
+      SVN_ERR(svn_wc__db_wclock_owns_lock_internal(&locked, wcroot,
+                                                   dst_relpath,
+                                                   FALSE, scratch_pool));
+
+      if (!locked)
+        can_bump = FALSE;
+    }
+
+  src_root_relpath = svn_relpath_prefix(src_relpath, src_del_depth,
+                                        scratch_pool);
+
+  if (!can_bump)
+    {
+      SVN_ERR(bump_mark_tree_conflict(wcroot, src_relpath, op_depth,
+                                      src_root_relpath, dst_relpath,
+                                      db, scratch_pool));
+
+      return SVN_NO_ERROR;
+    }
+
+  SVN_ERR(svn_wc__db_read_conflict_internal(&conflict, NULL, NULL,
+                                            wcroot, src_root_relpath,
+                                            scratch_pool, scratch_pool));
+
+  /* ### TODO: check this is the right sort of tree-conflict? */
+  if (!conflict)
+    {
+      /* ### TODO: verify moved_here? */
+
+      SVN_ERR(verify_write_lock(wcroot, src_relpath, scratch_pool));
+
+      SVN_ERR(svn_wc__db_op_copy_layer_internal(wcroot,
+                                                src_relpath, op_depth,
+                                                dst_relpath, NULL, NULL,
+                                                scratch_pool));
+
+      *recurse = TRUE;
+    }
+
+  return SVN_NO_ERROR;
+}
+
+/* Internal storage for bump_moved_away() */
+struct bump_pair_t
+{
+  const char *src_relpath;
+  const char *dst_relpath;
+  int src_del_op_depth;
+  svn_node_kind_t src_kind;
+};
+
+/* Bump moves of LOCAL_RELPATH and all its descendants that were
+   originally below LOCAL_RELPATH at op-depth OP_DEPTH.
+ */
 static svn_error_t *
 bump_moved_away(svn_wc__db_wcroot_t *wcroot,
                 const char *local_relpath,
                 int op_depth,
-                apr_hash_t *src_done,
                 svn_depth_t depth,
                 svn_wc__db_t *db,
-                apr_pool_t *result_pool,
                 apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
   svn_boolean_t have_row;
   apr_pool_t *iterpool;
+  int i;
+  apr_array_header_t *pairs = apr_array_make(scratch_pool, 32,
+                                             sizeof(struct bump_pair_t*));
 
+  /* Build an array, as we can't execute the same Sqlite query recursively */
   iterpool = svn_pool_create(scratch_pool);
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
@@ -2151,126 +2154,48 @@ bump_moved_away(svn_wc__db_wcroot_t *wcroot,
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
   while(have_row)
     {
-      svn_sqlite__stmt_t *stmt2;
-      const char *src_relpath, *dst_relpath;
-      int src_op_depth = svn_sqlite__column_int(stmt, 2);
-      svn_error_t *err;
-      svn_skel_t *conflict;
-      svn_depth_t src_depth = depth;
-
-      svn_pool_clear(iterpool);
+      struct bump_pair_t *bp = apr_pcalloc(scratch_pool, sizeof(*bp));
 
-      src_relpath = svn_sqlite__column_text(stmt, 0, iterpool);
-      dst_relpath = svn_sqlite__column_text(stmt, 1, iterpool);
+      bp->src_relpath = svn_sqlite__column_text(stmt, 0, scratch_pool);
+      bp->dst_relpath = svn_sqlite__column_text(stmt, 1, scratch_pool);
+      bp->src_del_op_depth = svn_sqlite__column_int(stmt, 2);
+      bp->src_kind = svn_sqlite__column_token(stmt, 3, kind_map);
 
-      if (depth != svn_depth_infinity)
-        {
-          svn_boolean_t skip_this_src = FALSE;
-          svn_node_kind_t src_kind;
+      APR_ARRAY_PUSH(pairs, struct bump_pair_t *) = bp;
 
-          if (strcmp(src_relpath, local_relpath))
-            {
-              switch (depth)
-                {
-                case svn_depth_empty:
-                  skip_this_src = TRUE;
-                  break;
-                case svn_depth_files:
-                  src_kind = svn_sqlite__column_token(stmt, 3, kind_map);
-                  if (src_kind != svn_node_file)
-                    {
-                      skip_this_src = TRUE;
-                      break;
-                    }
-                  /* Fallthrough */
-                case svn_depth_immediates:
-                  if (strcmp(svn_relpath_dirname(src_relpath, scratch_pool),
-                             local_relpath))
-                    skip_this_src = TRUE;
-                  src_depth = svn_depth_empty;
-                  break;
-                default:
-                  SVN_ERR_MALFUNCTION();
-                }
-            }
+      SVN_ERR(svn_sqlite__step(&have_row, stmt));
+    }
 
-          if (skip_this_src)
-            {
-              SVN_ERR(svn_sqlite__step(&have_row, stmt));
-              continue;
-            }
-        }
+  SVN_ERR(svn_sqlite__reset(stmt));
 
-      err = svn_sqlite__get_statement(&stmt2, wcroot->sdb,
-                                      STMT_HAS_LAYER_BETWEEN);
-      if (!err)
-       err = svn_sqlite__bindf(stmt2, "isdd", wcroot->wc_id, local_relpath,
-                               op_depth, src_op_depth);
-      if (!err)
-        err = svn_sqlite__step(&have_row, stmt2);
-      if (!err)
-        err = svn_sqlite__reset(stmt2);
-      if (!err && !have_row)
-        {
-          svn_boolean_t can_bump;
-          const char *src_root_relpath = src_relpath;
+  for (i = 0; i < pairs->nelts; i++)
+    {
+      struct bump_pair_t *bp = APR_ARRAY_IDX(pairs, i, struct bump_pair_t *);
+      svn_boolean_t skip;
+      svn_depth_t src_wc_depth;
 
-          if (op_depth == 0)
-            err = depth_sufficient_to_bump(&can_bump, src_relpath, wcroot,
-                                           src_depth, scratch_pool);
-          else
-            /* Having chosen to bump an entire BASE tree move we
-               always have sufficient depth to bump subtree moves. */
-            can_bump = TRUE;
+      svn_pool_clear(iterpool);
 
-          if (!err)
-            {
-              if (!can_bump)
-                {
-                  err = bump_mark_tree_conflict(wcroot, src_relpath,
-                                                src_root_relpath, dst_relpath,
-                                                db, scratch_pool);
-                  if (err)
-                    return svn_error_compose_create(err,
-                                                    svn_sqlite__reset(stmt));
-                  SVN_ERR(svn_sqlite__step(&have_row, stmt));
-                  continue;
-                }
 
-              while (relpath_depth(src_root_relpath) > src_op_depth)
-                src_root_relpath = svn_relpath_dirname(src_root_relpath,
-                                                       iterpool);
+      SVN_ERR(check_bump_layer(&skip, &src_wc_depth, local_relpath, depth,
+                               bp->src_relpath, bp->src_kind, iterpool));
 
-              if (!svn_hash_gets(src_done, src_relpath))
-                {
-                  svn_hash_sets(src_done,
-                                apr_pstrdup(result_pool, src_relpath), "");
-                  err = svn_wc__db_read_conflict_internal(&conflict, wcroot,
-                                                          src_root_relpath,
-                                                          iterpool, iterpool);
-                  /* ### TODO: check this is the right sort of tree-conflict? */
-                  if (!err && !conflict)
-                    {
-                      /* ### TODO: verify moved_here? */
-                      err = replace_moved_layer(src_relpath, dst_relpath,
-                                                op_depth, wcroot, iterpool);
-
-                      if (!err)
-                        err = bump_moved_away(wcroot, dst_relpath,
-                                              relpath_depth(dst_relpath),
-                                              src_done, depth, db,
-                                              result_pool, iterpool);
-                    }
-                }
-            }
+      if (!skip)
+        {
+          svn_boolean_t recurse;
+
+          SVN_ERR(bump_moved_layer(&recurse, wcroot,
+                                   local_relpath, op_depth,
+                                   bp->src_relpath, bp->src_del_op_depth,
+                                   src_wc_depth, bp->dst_relpath,
+                                   db, iterpool));
+
+          if (recurse)
+            SVN_ERR(bump_moved_away(wcroot, bp->dst_relpath,
+                                    relpath_depth(bp->dst_relpath),
+                                    depth, db, iterpool));
         }
-
-      if (err)
-        return svn_error_compose_create(err, svn_sqlite__reset(stmt));
-
-      SVN_ERR(svn_sqlite__step(&have_row, stmt));
     }
-  SVN_ERR(svn_sqlite__reset(stmt));
 
   svn_pool_destroy(iterpool);
 
@@ -2284,84 +2209,216 @@ svn_wc__db_bump_moved_away(svn_wc__db_wcroot_t *wcroot,
                            svn_wc__db_t *db,
                            apr_pool_t *scratch_pool)
 {
-  apr_hash_t *src_done;
-
   SVN_ERR(svn_sqlite__exec_statements(wcroot->sdb,
                                       STMT_CREATE_UPDATE_MOVE_LIST));
 
   if (local_relpath[0] != '\0')
     {
-      const char *dummy1, *move_dst_op_root_relpath;
-      const char *move_src_root_relpath, *move_src_op_root_relpath;
+      const char *move_dst_op_root_relpath;
+      const char *move_src_root_relpath, *delete_relpath;
+      svn_error_t *err;
 
       /* Is the root of the update moved away? (Impossible for the wcroot) */
-      SVN_ERR(svn_wc__db_op_depth_moved_to(&dummy1, &move_dst_op_root_relpath,
-                                           &move_src_root_relpath,
-                                           &move_src_op_root_relpath, 0,
-                                           wcroot, local_relpath,
-                                           scratch_pool, scratch_pool));
 
-      if (move_src_root_relpath)
+      err = svn_wc__db_scan_moved_to_internal(&move_src_root_relpath,
+                                              &move_dst_op_root_relpath,
+                                              &delete_relpath,
+                                              wcroot, local_relpath,
+                                              0 /* BASE */,
+                                              scratch_pool, scratch_pool);
+
+      if (err)
+        {
+          if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
+            return svn_error_trace(err);
+
+          svn_error_clear(err);
+        }
+      else if (move_src_root_relpath)
         {
           if (strcmp(move_src_root_relpath, local_relpath))
             {
-              SVN_ERR(bump_mark_tree_conflict(wcroot, move_src_root_relpath,
-                                              move_src_op_root_relpath,
-                                              move_dst_op_root_relpath,
-                                              db, scratch_pool));
+              /* An ancestor of the path that was updated is moved away.
+
+                 If we have a lock on that ancestor, we can mark a tree
+                 conflict on it, if we don't we ignore this case. A future
+                 update of the ancestor will handle this. */
+              svn_boolean_t locked;
+
+              SVN_ERR(svn_wc__db_wclock_owns_lock_internal(
+                                &locked, wcroot,
+                                move_src_root_relpath,
+                                FALSE, scratch_pool));
+
+              if (locked)
+                {
+                  SVN_ERR(bump_mark_tree_conflict(wcroot,
+                                                  move_src_root_relpath, 0,
+                                                  delete_relpath,
+                                                  move_dst_op_root_relpath,
+                                                  db, scratch_pool));
+                }
               return SVN_NO_ERROR;
             }
         }
     }
 
-  src_done = apr_hash_make(scratch_pool);
-  SVN_ERR(bump_moved_away(wcroot, local_relpath, 0, src_done, depth, db,
-                          scratch_pool, scratch_pool));
+  SVN_ERR(bump_moved_away(wcroot, local_relpath, 0, depth, db, scratch_pool));
 
   return SVN_NO_ERROR;
 }
 
+/* Set *OPERATION, *LOCAL_CHANGE, *INCOMING_CHANGE, *OLD_VERSION, *NEW_VERSION
+ * to reflect the tree conflict on the victim SRC_ABSPATH in DB.
+ *
+ * If SRC_ABSPATH is not a tree-conflict victim, return an error.
+ */
 static svn_error_t *
-resolve_delete_raise_moved_away(svn_wc__db_wcroot_t *wcroot,
-                                const char *local_relpath,
-                                svn_wc__db_t *db,
-                                svn_wc_operation_t operation,
-                                svn_wc_conflict_action_t action,
-                                svn_wc_conflict_version_t *old_version,
-                                svn_wc_conflict_version_t *new_version,
-                                apr_pool_t *scratch_pool)
+fetch_conflict_details(int *src_op_depth,
+                       svn_wc_operation_t *operation,
+                       svn_wc_conflict_action_t *action,
+                       svn_wc_conflict_version_t **left_version,
+                       svn_wc_conflict_version_t **right_version,
+                       svn_wc__db_wcroot_t *wcroot,
+                       svn_wc__db_t *db,
+                       const char *local_relpath,
+                       const svn_skel_t *conflict_skel,
+                       apr_pool_t *result_pool,
+                       apr_pool_t *scratch_pool)
+{
+  const apr_array_header_t *locations;
+  svn_boolean_t text_conflicted;
+  svn_boolean_t prop_conflicted;
+  svn_boolean_t tree_conflicted;
+  const char *move_src_op_root_abspath;
+  svn_wc_conflict_reason_t reason;
+  const char *local_abspath = svn_dirent_join(wcroot->abspath, local_relpath,
+                                              scratch_pool);
+
+  if (!conflict_skel)
+    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
+                             _("'%s' is not in conflict"),
+                             path_for_error_message(wcroot, local_relpath,
+                                                    scratch_pool));
+
+  SVN_ERR(svn_wc__conflict_read_info(operation, &locations,
+                                     &text_conflicted, &prop_conflicted,
+                                     &tree_conflicted,
+                                     db, local_abspath,
+                                     conflict_skel, result_pool,
+                                     scratch_pool));
+
+  if (text_conflicted || prop_conflicted || !tree_conflicted)
+    return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
+                             _("'%s' is not a valid tree-conflict victim"),
+                             path_for_error_message(wcroot, local_relpath,
+                                                    scratch_pool));
+
+  SVN_ERR(svn_wc__conflict_read_tree_conflict(&reason,
+                                              action,
+                                              &move_src_op_root_abspath,
+                                              db, local_abspath,
+                                              conflict_skel, result_pool,
+                                              scratch_pool));
+
+  if (reason == svn_wc_conflict_reason_moved_away)
+    return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
+                             _("'%s' is already a moved away tree-conflict"),
+                             path_for_error_message(wcroot, local_relpath,
+                                                    scratch_pool));
+
+  if (left_version)
+    {
+      if (locations && locations->nelts > 0)
+        *left_version = APR_ARRAY_IDX(locations, 0,
+                                     svn_wc_conflict_version_t *);
+      else
+        *left_version = NULL;
+    }
+
+  if (right_version)
+    {
+      if (locations && locations->nelts > 1)
+        *right_version = APR_ARRAY_IDX(locations, 1,
+                                     svn_wc_conflict_version_t *);
+      else
+        *right_version = NULL;
+    }
+
+  {
+    int del_depth = relpath_depth(local_relpath);
+
+    if (move_src_op_root_abspath)
+      del_depth = relpath_depth(
+                      svn_dirent_skip_ancestor(wcroot->abspath,
+                                               move_src_op_root_abspath));
+
+    SVN_ERR(find_src_op_depth(src_op_depth, wcroot, local_relpath, del_depth,
+                              scratch_pool));
+  }
+
+  return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_wc__db_op_raise_moved_away_internal(
+                        svn_wc__db_wcroot_t *wcroot,
+                        const char *local_relpath,
+                        int src_op_depth,
+                        svn_wc__db_t *db,
+                        svn_wc_operation_t operation,
+                        svn_wc_conflict_action_t action,
+                        const svn_wc_conflict_version_t *old_version,
+                        const svn_wc_conflict_version_t *new_version,
+                        apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
   svn_boolean_t have_row;
-  int op_depth = relpath_depth(local_relpath);
   apr_pool_t *iterpool = svn_pool_create(scratch_pool);
 
   SVN_ERR(svn_sqlite__exec_statements(wcroot->sdb,
                                       STMT_CREATE_UPDATE_MOVE_LIST));
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_OP_DEPTH_MOVED_PAIR));
+                                    STMT_SELECT_MOVED_DESCENDANTS_SRC));
   SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, local_relpath,
-                            op_depth));
+                            src_op_depth));
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
   while(have_row)
     {
-      const char *moved_relpath = svn_sqlite__column_text(stmt, 0, NULL);
-      const char *move_root_dst_relpath = svn_sqlite__column_text(stmt, 1,
-                                                                  NULL);
-      const char *moved_dst_repos_relpath = svn_sqlite__column_text(stmt, 2,
-                                                                    NULL);
+      svn_error_t *err;
+      int delete_op_depth = svn_sqlite__column_int(stmt, 0);
+      const char *src_relpath = svn_sqlite__column_text(stmt, 1, NULL);
+      svn_node_kind_t src_kind = svn_sqlite__column_token(stmt, 2, kind_map);
+      const char *src_repos_relpath = svn_sqlite__column_text(stmt, 3, NULL);
+      const char *dst_relpath = svn_sqlite__column_text(stmt, 4, NULL);
+      svn_skel_t *conflict;
       svn_pool_clear(iterpool);
 
-      SVN_ERR(mark_tree_conflict(moved_relpath,
-                                 wcroot, db, old_version, new_version,
-                                 move_root_dst_relpath, operation,
-                                 svn_node_dir /* ### ? */,
-                                 svn_node_dir /* ### ? */,
-                                 moved_dst_repos_relpath,
+      SVN_ERR_ASSERT(src_repos_relpath != NULL);
+
+      err = create_tree_conflict(&conflict, wcroot, src_relpath, dst_relpath,
+                                 db, old_version, new_version, operation,
+                                 src_kind /* ### old kind */,
+                                 src_kind /* ### new kind */,
+                                 src_repos_relpath,
                                  svn_wc_conflict_reason_moved_away,
-                                 action, local_relpath,
-                                 iterpool));
+                                 action,
+                                 svn_relpath_prefix(src_relpath,
+                                                    delete_op_depth,
+                                                    iterpool),
+                                 iterpool, iterpool);
+
+      if (!err)
+        err = update_move_list_add(wcroot, src_relpath, db,
+                                   svn_wc_notify_tree_conflict,
+                                   src_kind,
+                                   svn_wc_notify_state_inapplicable,
+                                   svn_wc_notify_state_inapplicable,
+                                   conflict, NULL, scratch_pool);
+
+      if (err)
+        return svn_error_compose_create(err, svn_sqlite__reset(stmt));
 
       SVN_ERR(svn_sqlite__step(&have_row, stmt));
     }
@@ -2373,41 +2430,52 @@ resolve_delete_raise_moved_away(svn_wc__db_wcroot_t *wcroot,
 }
 
 svn_error_t *
-svn_wc__db_resolve_delete_raise_moved_away(svn_wc__db_t *db,
-                                           const char *local_abspath,
-                                           svn_wc_notify_func2_t notify_func,
-                                           void *notify_baton,
-                                           apr_pool_t *scratch_pool)
+svn_wc__db_op_raise_moved_away(svn_wc__db_t *db,
+                               const char *local_abspath,
+                               svn_wc_notify_func2_t notify_func,
+                               void *notify_baton,
+                               apr_pool_t *scratch_pool)
 {
   svn_wc__db_wcroot_t *wcroot;
   const char *local_relpath;
   svn_wc_operation_t operation;
-  svn_wc_conflict_reason_t reason;
   svn_wc_conflict_action_t action;
-  svn_wc_conflict_version_t *old_version, *new_version;
+  svn_wc_conflict_version_t *left_version, *right_version;
+  int move_src_op_depth;
+  svn_skel_t *conflict;
 
   SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath,
                                                 db, local_abspath,
                                                 scratch_pool, scratch_pool));
   VERIFY_USABLE_WCROOT(wcroot);
 
-  SVN_ERR(get_tc_info(&operation, &reason, &action, NULL,
-                      &old_version, &new_version,
-                      db, local_abspath, scratch_pool, scratch_pool));
-
-  SVN_WC__DB_WITH_TXN(
-    resolve_delete_raise_moved_away(wcroot, local_relpath,
-                                    db, operation, action,
-                                    old_version, new_version,
-                                    scratch_pool),
+  SVN_WC__DB_WITH_TXN4(
+    svn_wc__db_read_conflict_internal(&conflict, NULL, NULL,
+                                      wcroot, local_relpath,
+                                      scratch_pool, scratch_pool),
+    fetch_conflict_details(&move_src_op_depth,
+                           &operation, &action,
+                           &left_version, &right_version,
+                           wcroot, db, local_relpath, conflict,
+                           scratch_pool, scratch_pool),
+    svn_wc__db_op_mark_resolved_internal(wcroot, local_relpath, db,
+                                         FALSE, FALSE, TRUE,
+                                         NULL, scratch_pool),
+    svn_wc__db_op_raise_moved_away_internal(wcroot, local_relpath,
+                                            move_src_op_depth,
+                                            db, operation, action,
+                                            left_version, right_version,
+                                            scratch_pool),
     wcroot);
 
+  /* These version numbers are valid for update/switch notifications 
+     only! */
   SVN_ERR(svn_wc__db_update_move_list_notify(wcroot,
-                                             (old_version
-                                              ? old_version->peg_rev
+                                             (left_version
+                                              ? left_version->peg_rev
                                               : SVN_INVALID_REVNUM),
-                                             (new_version
-                                              ? new_version->peg_rev
+                                             (right_version
+                                              ? right_version->peg_rev
                                               : SVN_INVALID_REVNUM),
                                              notify_func, notify_baton,
                                              scratch_pool));
@@ -2416,159 +2484,109 @@ svn_wc__db_resolve_delete_raise_moved_away(svn_wc__db_t *db,
 }
 
 static svn_error_t *
-break_move(svn_wc__db_wcroot_t *wcroot,
-           const char *src_relpath,
-           int src_op_depth,
-           const char *dst_relpath,
-           int dst_op_depth,
-           apr_pool_t *scratch_pool)
-{
-  svn_sqlite__stmt_t *stmt;
-
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_CLEAR_MOVED_TO_RELPATH));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, src_relpath,
-                            src_op_depth));
-  SVN_ERR(svn_sqlite__step_done(stmt));
-
-  /* This statement clears moved_here. */
-  SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_UPDATE_OP_DEPTH_RECURSIVE));
-  SVN_ERR(svn_sqlite__bindf(stmt, "isdd", wcroot->wc_id,
-                            dst_relpath, dst_op_depth, dst_op_depth));
-  SVN_ERR(svn_sqlite__step_done(stmt));
-
-  return SVN_NO_ERROR;
-}
-
-svn_error_t *
-svn_wc__db_resolve_break_moved_away_internal(svn_wc__db_wcroot_t *wcroot,
-                                             const char *local_relpath,
-                                             int op_depth,
-                                             apr_pool_t *scratch_pool)
-{
-  const char *dummy1, *move_dst_op_root_relpath;
-  const char *dummy2, *move_src_op_root_relpath;
-
-  /* We want to include the passed op-depth, but the function does a > check */
-  SVN_ERR(svn_wc__db_op_depth_moved_to(&dummy1, &move_dst_op_root_relpath,
-                                       &dummy2,
-                                       &move_src_op_root_relpath,
-                                       op_depth - 1,
-                                       wcroot, local_relpath,
-                                       scratch_pool, scratch_pool));
-
-  SVN_ERR_ASSERT(move_src_op_root_relpath != NULL
-                 && move_dst_op_root_relpath != NULL);
-
-  SVN_ERR(break_move(wcroot, local_relpath,
-                     relpath_depth(move_src_op_root_relpath),
-                     move_dst_op_root_relpath,
-                     relpath_depth(move_dst_op_root_relpath),
-                     scratch_pool));
-
-  return SVN_NO_ERROR;
-}
-
-static svn_error_t *
-break_moved_away_children_internal(svn_wc__db_wcroot_t *wcroot,
-                                   const char *local_relpath,
-                                   apr_pool_t *scratch_pool)
+break_moved_away(svn_wc__db_wcroot_t *wcroot,
+                 svn_wc__db_t *db,
+                 const char *local_relpath,
+                 int parent_src_op_depth,
+                 apr_pool_t *scratch_pool)
 {
   svn_sqlite__stmt_t *stmt;
   svn_boolean_t have_row;
   apr_pool_t *iterpool;
+  svn_error_t *err = NULL;
 
   SVN_ERR(svn_sqlite__exec_statements(wcroot->sdb,
                                       STMT_CREATE_UPDATE_MOVE_LIST));
 
   SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
-                                    STMT_SELECT_MOVED_PAIR2));
-  SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id, local_relpath));
+                                    STMT_SELECT_MOVED_DESCENDANTS_SRC));
+  SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id, local_relpath,
+                            parent_src_op_depth));
   SVN_ERR(svn_sqlite__step(&have_row, stmt));
 
   iterpool = svn_pool_create(scratch_pool);
   while (have_row)
     {
-      const char *src_relpath = svn_sqlite__column_text(stmt, 0, iterpool);
-      const char *dst_relpath = svn_sqlite__column_text(stmt, 1, iterpool);
-      int src_op_depth = svn_sqlite__column_int(stmt, 2);
+      int src_op_depth = svn_sqlite__column_int(stmt, 0);
+      const char *src_relpath = svn_sqlite__column_text(stmt, 1, NULL);
+      svn_node_kind_t src_kind = svn_sqlite__column_token(stmt, 2, kind_map);
+      const char *dst_relpath = svn_sqlite__column_text(stmt, 4, NULL);
 
       svn_pool_clear(iterpool);
 
-      SVN_ERR(break_move(wcroot, src_relpath, src_op_depth, dst_relpath,
-                         relpath_depth(dst_relpath), iterpool));
-      SVN_ERR(update_move_list_add(wcroot, src_relpath,
-                                   svn_wc_notify_move_broken,
-                                   svn_node_unknown,
-                                   svn_wc_notify_state_inapplicable,
-                                   svn_wc_notify_state_inapplicable));
-      SVN_ERR(svn_sqlite__step(&have_row, stmt));
-    }
-  svn_pool_destroy(iterpool);
+      err = verify_write_lock(wcroot, src_relpath, iterpool);
 
-  SVN_ERR(svn_sqlite__reset(stmt));
+      if (!err)
+        err = verify_write_lock(wcroot, dst_relpath, iterpool);
 
-  return SVN_NO_ERROR;
-}
+      if (err)
+        break;
 
-svn_error_t *
-svn_wc__db_resolve_break_moved_away(svn_wc__db_t *db,
-                                    const char *local_abspath,
-                                    svn_wc_notify_func2_t notify_func,
-                                    void *notify_baton,
-                                    apr_pool_t *scratch_pool)
-{
-  svn_wc__db_wcroot_t *wcroot;
-  const char *local_relpath;
+      err = svn_error_trace(
+              svn_wc__db_op_break_move_internal(wcroot,
+                                                src_relpath, src_op_depth,
+                                                dst_relpath, NULL, iterpool));
 
-  SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath,
-                                                db, local_abspath,
-                                                scratch_pool, scratch_pool));
-  VERIFY_USABLE_WCROOT(wcroot);
+      if (err)
+        break;
 
-  SVN_WC__DB_WITH_TXN(
-    svn_wc__db_resolve_break_moved_away_internal(wcroot, local_relpath,
-                                                 relpath_depth(local_relpath),
-                                                 scratch_pool),
-    wcroot);
+      err = svn_error_trace(
+              update_move_list_add(wcroot, src_relpath, db,
+                                   svn_wc_notify_move_broken,
+                                   src_kind,
+                                   svn_wc_notify_state_inapplicable,
+                                   svn_wc_notify_state_inapplicable,
+                                   NULL, NULL, scratch_pool));
 
-  if (notify_func)
-    {
-      svn_wc_notify_t *notify;
+      if (err)
+        break;
 
-      notify = svn_wc_create_notify(svn_dirent_join(wcroot->abspath,
-                                                    local_relpath,
-                                                    scratch_pool),
-                                    svn_wc_notify_move_broken,
-                                    scratch_pool);
-      notify->kind = svn_node_unknown;
-      notify->content_state = svn_wc_notify_state_inapplicable;
-      notify->prop_state = svn_wc_notify_state_inapplicable;
-      notify->revision = SVN_INVALID_REVNUM;
-      notify_func(notify_baton, notify, scratch_pool);
+      SVN_ERR(svn_sqlite__step(&have_row, stmt));
     }
+  svn_pool_destroy(iterpool);
 
-  return SVN_NO_ERROR;
+  return svn_error_compose_create(err, svn_sqlite__reset(stmt));
 }
 
 svn_error_t *
-svn_wc__db_resolve_break_moved_away_children(svn_wc__db_t *db,
-                                             const char *local_abspath,
-                                             svn_wc_notify_func2_t notify_func,
-                                             void *notify_baton,
-                                             apr_pool_t *scratch_pool)
+svn_wc__db_op_break_moved_away(svn_wc__db_t *db,
+                               const char *local_abspath,
+                               const char *del_op_root_abspath,
+                               svn_boolean_t mark_tc_resolved,
+                               svn_wc_notify_func2_t notify_func,
+                               void *notify_baton,
+                               apr_pool_t *scratch_pool)
 {
   svn_wc__db_wcroot_t *wcroot;
   const char *local_relpath;
+  const char *del_relpath;
+  int src_op_depth;
 
   SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath,
                                                 db, local_abspath,
                                                 scratch_pool, scratch_pool));
   VERIFY_USABLE_WCROOT(wcroot);
 
-  SVN_WC__DB_WITH_TXN(
-    break_moved_away_children_internal(wcroot, local_relpath, scratch_pool),
+  if (del_op_root_abspath)
+    del_relpath = svn_dirent_skip_ancestor(wcroot->abspath,
+                                           del_op_root_abspath);
+  else
+    del_relpath = NULL;
+
+
+  SVN_WC__DB_WITH_TXN4(
+    find_src_op_depth(&src_op_depth, wcroot, local_relpath,
+                      del_relpath ? relpath_depth(del_relpath)
+                                 : relpath_depth(local_relpath),
+                      scratch_pool),
+    break_moved_away(wcroot, db, local_relpath, src_op_depth,
+                     scratch_pool),
+    mark_tc_resolved
+        ? svn_wc__db_op_mark_resolved_internal(wcroot, local_relpath, db,
+                                               FALSE, FALSE, TRUE,
+                                               NULL, scratch_pool)
+        : SVN_NO_ERROR,
+    SVN_NO_ERROR,
     wcroot);
 
   SVN_ERR(svn_wc__db_update_move_list_notify(wcroot,