validation OPTIMIZE drop diff nodes created and deleted in one run

When a when condition turns out false, the default nodes created speculatively
before it was resolved are auto-deleted again. Recording that deletion went
through lyd_diff_merge_all(), which duplicated the deleted subtree and
reconciled it node by node, only for the entries to end up as "none" and be
dropped as redundant.

Recognise the case directly: if the diff already holds a create for the node,
and nothing in that subtree was set explicitly, the create and the delete
cancel out, so remove the subtree together with any ancestor left without a
change.

Author: fredrik-persson

src/diff.c

@@ -2732,6 +2732,69 @@ lyd_diff_is_redundant(struct lyd_node *diff)
     return 0;
 }
 
+/**
+ * @brief Check whether a diff subtree was created by validation only, so that deleting the
+ * corresponding data nodes cancels it out.
+ *
+ * @param[in] diff_node Diff subtree to check.
+ * @return Whether it can be dropped.
+ */
+static ly_bool
+lyd_diff_val_subtree_created(const struct lyd_node *diff_node)
+{
+    const struct lyd_node *elem;
+    struct lyd_meta *meta;
+    struct lyd_attr *attr;
+
+    LYD_TREE_DFS_BEGIN(diff_node, elem) {
+        if (!elem->schema) {
+            /* cannot reason about opaque nodes */
+            return 0;
+        }
+
+        lyd_diff_find_meta(elem, "operation", &meta, &attr);
+        if (attr) {
+            return 0;
+        }
+        if (meta && (lyd_diff_str2op(lyd_get_meta_value(meta)) != LYD_DIFF_OP_CREATE)) {
+            return 0;
+        }
+
+        /* a non-default term was set explicitly, deleting it is a real change */
+        if ((elem->schema->nodetype & LYD_NODE_TERM) && !(elem->flags & LYD_DEFAULT)) {
+            return 0;
+        }
+
+        LYD_TREE_DFS_END(diff_node, elem);
+    }
+
+    return 1;
+}
+
+LY_ERR
+lyd_diff_val_del_created(struct lyd_node *diff_node, struct lyd_node **diff)
+{
+    struct lyd_node *parent;
+    enum lyd_diff_op op;
+
+    LY_CHECK_RET(lyd_diff_get_op(diff_node, &op, NULL));
+    if ((op != LYD_DIFF_OP_CREATE) || !lyd_diff_val_subtree_created(diff_node)) {
+        return LY_ENOT;
+    }
+
+    /* drop it, then any ancestor left without a change */
+    do {
+        parent = lyd_parent(diff_node);
+        if (diff_node == *diff) {
+            *diff = (*diff)->next;
+        }
+        lyd_free_tree(diff_node);
+        diff_node = parent;
+    } while (diff_node && lyd_diff_is_redundant(diff_node));
+
+    return LY_SUCCESS;
+}
+
 /**
  * @brief Merge all diff metadata found on a source diff node.
  *

src/diff.h

@@ -87,4 +87,14 @@ LIBYANG_API_DECL LY_ERR lyd_diff_add(const struct lyd_node *node, enum lyd_diff_
 LY_ERR lyd_diff_add_explicit_op(const struct lyd_node *node, enum lyd_diff_op op, const char *key,
         const char *value, const char *position, struct lyd_node **diff);
 
+/**
+ * @brief Drop a diff subtree that validation created, when its data nodes are being deleted again.
+ *
+ * @param[in] diff_node Diff node of the data node being deleted.
+ * @param[in,out] diff Diff @p diff_node belongs to.
+ * @return LY_SUCCESS if the subtree was dropped.
+ * @return LY_ENOT if it has to be merged instead.
+ */
+LY_ERR lyd_diff_val_del_created(struct lyd_node *diff_node, struct lyd_node **diff);
+
 #endif /* LY_DIFF_H_ */

src/validation.c

@@ -248,6 +248,16 @@ lyd_val_diff_add(const struct lyd_node *node, enum lyd_diff_op op, struct lyd_no
         goto cleanup;
     }
 
+    /* a create followed by a delete cancels out; merging would reconcile the whole subtree to
+     * "none" only to drop it as redundant */
+    if (op == LYD_DIFF_OP_DELETE) {
+        ret = lyd_diff_val_del_created(match, diff);
+        if (ret != LY_ENOT) {
+            goto cleanup;
+        }
+        ret = LY_SUCCESS;
+    }
+
     /* create new diff tree */
     LY_CHECK_GOTO(ret = lyd_diff_add(node, op, NULL, NULL, key, value, position, NULL, NULL, &new_diff, NULL), cleanup);