schema diff UPDATE support for yang-version diff

Author: Per Andersson

modules/ietf-yang-schema-comparison@2025-10-20.yang

@@ -304,6 +304,10 @@ module ietf-yang-schema-comparison {
         description
           "YANG statement 'when'.";
       }
+      enum "yang-version" {
+        description
+          "YANG statement 'yang-version'.";
+      }
     }
     description
       "Type of the statement that a change affects.";
@@ -914,6 +918,11 @@ module ietf-yang-schema-comparison {
   grouping module-substmts {
     description
       "All non-data-definition substatements of a module.";
+    leaf yang-version {
+      type string;
+      description
+        "YANG version substatement value.";
+    }
     leaf prefix {
       if-feature parsed-schema;
       type string;

src/schema_diff.c

@@ -89,7 +89,6 @@ schema_diff_stmt2changed(enum ly_stmt stmt)
     case LY_STMT_SYNTAX_LEFT_BRACE:
     case LY_STMT_SYNTAX_RIGHT_BRACE:
     case LY_STMT_SYNTAX_SEMICOLON:
-    case LY_STMT_YANG_VERSION:
     case LY_STMT_YIN_ELEMENT:
         /* invalid */
         LOGINT(NULL);
@@ -194,6 +193,8 @@ schema_diff_stmt2changed(enum ly_stmt stmt)
         return LYS_CHANGED_VALUE;
     case LY_STMT_WHEN:
         return LYS_CHANGED_WHEN;
+    case LY_STMT_YANG_VERSION:
+        return LYS_CHANGED_YANG_VERSION;
     }
 
     return LYS_CHANGED_NONE;
@@ -587,6 +588,10 @@ schema_diff_module_identities_change(const struct lysc_ident *idents1, const str
 static LY_ERR
 schema_diff_module_change(const struct lys_module *mod1, const struct lys_module *mod2, struct lys_diff_s *diff)
 {
+    /* yang-version */
+    LY_CHECK_RET(schema_diff_yangversion_change(mod1->version, mod2->version, LYS_CHANGED_NONE, LYS_CHANGED_YANG_VERSION,
+            &diff->module_changes));
+
     /* organization */
     LY_CHECK_RET(schema_diff_text_bc(mod1->org, mod2->org, LYS_CHANGED_NONE, LYS_CHANGED_ORGANIZATION,
             &diff->module_changes));

src/schema_diff.h

@@ -92,7 +92,8 @@ enum lys_diff_changed_e {
     LYS_CHANGED_UNIQUE,
     LYS_CHANGED_UNITS,
     LYS_CHANGED_VALUE,
-    LYS_CHANGED_WHEN
+    LYS_CHANGED_WHEN,
+    LYS_CHANGED_YANG_VERSION
 };
 
 /**
@@ -440,6 +441,20 @@ LY_ERR schema_diff_ext_insts_change(const struct lysc_ext_instance *exts1, const
  */
 LY_ERR schema_diff_nodes_change_r(const struct lysc_node *node1, const struct lysc_node *node2, struct lys_diff_s *diff);
 
+/**
+ * @brief Check changes of a 'yang-version'.
+ *
+ * @param[in] yvsn1 First yang-version.
+ * @param[in] yvsn2 Second yang-version.
+ * @param[in] parent_changed Parent statement of the change.
+ * @param[in] changed Changed statement.
+ * @param[in,out] changes Changes to add to.
+ * @return LY_ERR value.
+ */
+LY_ERR schema_diff_yangversion_change(uint8_t yvsn1, uint8_t yvsn2,
+        enum lys_diff_changed_e parent_changed, enum lys_diff_changed_e changed,
+        struct lys_diff_changes_s *changes);
+
 /**
  * @brief Check changes of an 'if-feature' array.
  *

src/schema_diff_change_parsed.c

@@ -391,6 +391,20 @@ schema_diff_has_bc_pext(const struct ly_ctx *ctx, const struct lysp_ext_instance
     return 0;
 }
 
+LY_ERR
+schema_diff_yangversion_change(uint8_t yvsn1, uint8_t yvsn2,
+        enum lys_diff_changed_e parent_changed, enum lys_diff_changed_e changed,
+        struct lys_diff_changes_s *changes)
+{
+    if (yvsn1 != yvsn2) {
+        /* modified */
+        LY_CHECK_RET(schema_diff_add_change(LYS_CHANGE_MODIFIED, parent_changed,
+                     changed, 1, changes));
+    }
+
+    return LY_SUCCESS;
+}
+
 LY_ERR
 schema_diff_iffeatures_change(const struct lysp_qname *iffs1, uint16_t flags1, const struct lysp_qname *iffs2,
         enum lys_diff_changed_e parent_changed, struct lys_diff_changes_s *changes)

src/schema_diff_tree.c

@@ -144,6 +144,8 @@ schema_diff_changed2str(enum lys_diff_changed_e ch)
         return "unique";
     case LYS_CHANGED_WHEN:
         return "when";
+    case LYS_CHANGED_YANG_VERSION:
+        return "yang-version";
     }
 
     return NULL;
@@ -1555,6 +1557,53 @@ schema_diff_imports(const struct lys_module *mod, const struct lysc_node *schema
     return rc;
 }
 
+/**
+ * @brief Create cmp YANG data from direct text substatement of 'module'.
+ *
+ * @param[in] change Change to use.
+ * @param[in] mod1 Old module.
+ * @param[in] mod2 New module.
+ * @param[in] with_parsed Whether 'parsed-schema' feature is enabled.
+ * @param[in,out] diff_list Node to append to.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+schema_diff_module_version(const struct lys_diff_change_s *change, const struct lys_module *mod1,
+        const struct lys_module *mod2, struct lyd_node *diff_list)
+{
+    LY_ERR rc = LY_SUCCESS;
+    struct lyd_node *mod_cmp_list, *cont;
+    const char *node_name;
+
+    /* The only change handled. */
+    if (change->changed != LYS_CHANGED_YANG_VERSION) {
+        goto cleanup;
+    }
+
+    node_name = "yang-version";
+
+    /* module comparison */
+    LY_CHECK_GOTO(rc = lyd_new_list(diff_list, NULL, "module-comparison", 0, &mod_cmp_list), cleanup);
+
+    /* change info */
+    LY_CHECK_GOTO(rc = schema_diff_change_info(change, mod_cmp_list), cleanup);
+
+    if (mod1->version) {
+        LY_CHECK_GOTO(rc = lyd_new_inner(mod_cmp_list, NULL, "old", 0, &cont), cleanup);
+        LY_CHECK_GOTO(rc = lyd_new_term(cont, NULL, node_name,
+                    mod1->version == LYS_VERSION_1_1 ? "1.1" : "1", 0, NULL), cleanup);
+    }
+
+    if (mod2->version) {
+        LY_CHECK_GOTO(rc = lyd_new_inner(mod_cmp_list, NULL, "new", 0, &cont), cleanup);
+        LY_CHECK_GOTO(rc = lyd_new_term(cont, NULL, node_name,
+                    mod2->version == LYS_VERSION_1_1 ? "1.1" : "1", 0, NULL), cleanup);
+    }
+
+cleanup:
+    return rc;
+}
+
 /**
  * @brief Create cmp YANG data from direct text substatement of 'module'.
  *
@@ -1605,6 +1654,9 @@ schema_diff_module_text(const struct lys_diff_change_s *change, const struct lys
         text_old = mod1->ref;
         text_new = mod2->ref;
         break;
+    case LYS_CHANGED_YANG_VERSION:
+        /* not a textual field, ignore */
+        goto cleanup;
     default:
         LOGINT(mod1->ctx);
         rc = LY_EINT;
@@ -3024,6 +3076,12 @@ schema_diff_module(const struct lys_diff_s *diff, const struct lys_module *mod1,
     LY_ERR rc = LY_SUCCESS;
     uint32_t i;
 
+    /* yang-version */
+    for (i = 0; i < diff->module_changes.count; ++i) {
+        LY_CHECK_GOTO(rc = schema_diff_module_version(&diff->module_changes.changes[i], mod1, mod2, diff_list),
+                cleanup);
+    }
+
     /* text substmts */
     for (i = 0; i < diff->module_changes.count; ++i) {
         LY_CHECK_GOTO(rc = schema_diff_module_text(&diff->module_changes.changes[i], mod1, mod2, diff->with_parsed,

tests/utests/schema_comparison/nbc/x yang-version/yang-version@2000-01-01.yang

@@ -0,0 +1,7 @@
+module yang-version {
+    yang-version 1;
+    namespace "urn:test:yang-version";
+    prefix yvsn;
+
+    revision 2000-01-01;
+}

tests/utests/schema_comparison/nbc/x yang-version/yang-version@2000-01-02.yang

@@ -0,0 +1,7 @@
+module yang-version {
+    yang-version 1.1;
+    namespace "urn:test:yang-version";
+    prefix yvsn;
+
+    revision 2000-01-02;
+}

tests/utests/schema_comparison/nbc/x yang-version/yang-version_cmp.json

@@ -0,0 +1,34 @@
+{
+  "ietf-yang-schema-comparison:schema-comparison": {
+    "schema": [
+      {
+        "source": {
+          "module": "yang-version",
+          "revision": "2000-01-01"
+        },
+        "target": {
+          "module": "yang-version",
+          "revision": "2000-01-02"
+        },
+        "conformance": "non-backwards-compatible",
+        "module-comparison": [
+          {
+            "changed": [
+              {
+                "stmt": "yang-version",
+                "change": "modified",
+                "conformance": "non-backwards-compatible"
+              }
+            ],
+            "old": {
+              "yang-version": "1"
+            },
+            "new": {
+              "yang-version": "1.1"
+            }
+          }
+        ]
+      }
+    ]
+  }
+}

tests/utests/schema_comparison/test_schema_comparison.c

@@ -225,6 +225,7 @@ test_non_backwards_compatible(void **state)
     schema_comparison(st, "ext-inst");
     schema_comparison(st, "presence");
     schema_comparison(st, "union");
+    schema_comparison(st, "yang-version");
 }
 
 int