schemagen: drop support for additionalProperties: true

Following review feedback, the generator no longer supports permissive
objects. Changes:

- Reject `additionalProperties: true` at generation time.
- Treat an absent `additionalProperties` as `false`, so every object is
  strict by default and unknown keys are rejected during parsing.
- Remove the now-dead permissive-object infrastructure: `Kind::Skip`,
  `Cat::Skip`, `kSkip`, the per-frame `unknown` key set, and `isStrict()`.
- Update the README feature/rejection tables accordingly.
- Remove the permissive "loose" object from example.schema.json and the
  associated tests from test_gen.cpp.
- Add Python unit tests verifying the new `additionalProperties` behavior.

All tests pass (`ctest --output-on-failure`).

contrib/schemagen/CMakeLists.txt

@@ -46,49 +46,6 @@ target_link_libraries(schemagen_big PRIVATE ${PROJECT_NAME})
 target_compile_options(schemagen_big PRIVATE -Wno-switch-enum)
 add_dependencies(schemagen_big schemagen_big_h)
 
-set(NULLABLE_OBJECT_SCHEMA
-    ${CMAKE_CURRENT_SOURCE_DIR}/nullable_object.schema.json)
-set(NULLABLE_STRING_SCHEMA
-    ${CMAKE_CURRENT_SOURCE_DIR}/nullable_string.schema.json)
-set(NULLABLE_ARRAY_SCHEMA
-    ${CMAKE_CURRENT_SOURCE_DIR}/nullable_array.schema.json)
-set(NULLABLE_OBJECT_H ${CMAKE_CURRENT_BINARY_DIR}/nullable_object.h)
-set(NULLABLE_STRING_H ${CMAKE_CURRENT_BINARY_DIR}/nullable_string.h)
-set(NULLABLE_ARRAY_H ${CMAKE_CURRENT_BINARY_DIR}/nullable_array.h)
-
-add_custom_command(
-  OUTPUT ${NULLABLE_OBJECT_H}
-  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${NULLABLE_OBJECT_SCHEMA} -o
-          ${NULLABLE_OBJECT_H} --namespace nullable_object
-  DEPENDS ${SCHEMAGEN_SCRIPT} ${NULLABLE_OBJECT_SCHEMA}
-  COMMENT "Generating nullable_object.h")
-
-add_custom_command(
-  OUTPUT ${NULLABLE_STRING_H}
-  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${NULLABLE_STRING_SCHEMA} -o
-          ${NULLABLE_STRING_H} --namespace nullable_string
-  DEPENDS ${SCHEMAGEN_SCRIPT} ${NULLABLE_STRING_SCHEMA}
-  COMMENT "Generating nullable_string.h")
-
-add_custom_command(
-  OUTPUT ${NULLABLE_ARRAY_H}
-  COMMAND ${Python3_EXECUTABLE} ${SCHEMAGEN_SCRIPT} ${NULLABLE_ARRAY_SCHEMA} -o
-          ${NULLABLE_ARRAY_H} --namespace nullable_array
-  DEPENDS ${SCHEMAGEN_SCRIPT} ${NULLABLE_ARRAY_SCHEMA}
-  COMMENT "Generating nullable_array.h")
-
-add_custom_target(
-  schemagen_nullable_h DEPENDS ${NULLABLE_OBJECT_H} ${NULLABLE_STRING_H}
-                               ${NULLABLE_ARRAY_H})
-
-add_executable(schemagen_nullable_root
-               ${CMAKE_CURRENT_SOURCE_DIR}/test_nullable_root.cpp)
-target_include_directories(schemagen_nullable_root
-                           PRIVATE include ${CMAKE_CURRENT_BINARY_DIR})
-target_link_libraries(schemagen_nullable_root PRIVATE ${PROJECT_NAME})
-target_compile_options(schemagen_nullable_root PRIVATE -Wno-switch-enum)
-add_dependencies(schemagen_nullable_root schemagen_nullable_h)
-
 add_test(
   NAME schemagen_example
   COMMAND schemagen_example
@@ -98,8 +55,3 @@ add_test(
   NAME schemagen_big
   COMMAND schemagen_big
   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-add_test(
-  NAME schemagen_nullable_root
-  COMMAND schemagen_nullable_root
-  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

contrib/schemagen/nullable_array.schema.json

@@ -1,9 +0,0 @@
-{
-  "type": [
-    "array",
-    "null"
-  ],
-  "items": {
-    "type": "integer"
-  }
-}

contrib/schemagen/nullable_object.schema.json

@@ -1,15 +0,0 @@
-{
-  "type": [
-    "object",
-    "null"
-  ],
-  "additionalProperties": false,
-  "required": [
-    "x"
-  ],
-  "properties": {
-    "x": {
-      "type": "string"
-    }
-  }
-}

contrib/schemagen/nullable_string.schema.json

@@ -1,6 +0,0 @@
-{
-  "type": [
-    "string",
-    "null"
-  ]
-}

contrib/schemagen/test_nullable_root.cpp

@@ -1,158 +0,0 @@
-// Regression test for issue #13: nullable root types.
-#include <cassert>
-#include <cstdio>
-#include <string>
-
-#include "nullable_array.h"
-#include "nullable_object.h"
-#include "nullable_string.h"
-
-static int failures = 0;
-#define CHECK(cond)                                                            \
-  do {                                                                         \
-    if (!(cond)) {                                                             \
-      printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond);                   \
-      ++failures;                                                              \
-    }                                                                          \
-  } while (0)
-
-static WeaselJsonStatus parseStrided(nullable_object::RootBuilder &b,
-                                     std::string in) {
-  for (size_t i = 0; i < in.size(); ++i) {
-    char c = in[i];
-    WeaselJsonStatus s = b.feed(&c, 1);
-    if (s != WeaselJson_AGAIN)
-      return s;
-  }
-  return b.finish();
-}
-
-static WeaselJsonStatus parseStrided(nullable_string::RootBuilder &b,
-                                     std::string in) {
-  for (size_t i = 0; i < in.size(); ++i) {
-    char c = in[i];
-    WeaselJsonStatus s = b.feed(&c, 1);
-    if (s != WeaselJson_AGAIN)
-      return s;
-  }
-  return b.finish();
-}
-
-static WeaselJsonStatus parseStrided(nullable_array::RootBuilder &b,
-                                     std::string in) {
-  for (size_t i = 0; i < in.size(); ++i) {
-    char c = in[i];
-    WeaselJsonStatus s = b.feed(&c, 1);
-    if (s != WeaselJson_AGAIN)
-      return s;
-  }
-  return b.finish();
-}
-
-static void expectReject(nullable_object::RootBuilder &b, std::string in,
-                         const char *what) {
-  WeaselJsonStatus s = parseStrided(b, in);
-  if (s == WeaselJson_REJECT) {
-    printf("ok   reject: %s\n", what);
-  } else {
-    printf("FAIL expected reject (%s) got status %d for: %s\n", what, s,
-           in.c_str());
-    ++failures;
-  }
-}
-
-int main() {
-  // ---- nullable root object: valid document ----
-  {
-    nullable_object::RootBuilder b;
-    WeaselJsonStatus s = parseStrided(b, R"({"x":"hello"})");
-    CHECK(s == WeaselJson_OK);
-    if (s == WeaselJson_OK) {
-      nullable_object::Root r = b.take();
-      CHECK(r.has_value());
-      CHECK(r->x == "hello");
-      printf("ok   nullable root object accepts object\n");
-    }
-  }
-
-  // ---- nullable root object: null document ----
-  {
-    nullable_object::RootBuilder b;
-    WeaselJsonStatus s = parseStrided(b, "null");
-    CHECK(s == WeaselJson_OK);
-    if (s == WeaselJson_OK) {
-      nullable_object::Root r = b.take();
-      CHECK(!r.has_value());
-      printf("ok   nullable root object accepts null\n");
-    }
-  }
-
-  // ---- nullable root object: schema checks still run ----
-  {
-    nullable_object::RootBuilder b;
-    expectReject(b, R"({"x":"hello","extra":1})",
-                 "unknown key in strict nullable root object");
-  }
-  {
-    nullable_object::RootBuilder b;
-    expectReject(b, R"({})", "missing required field in nullable root object");
-  }
-
-  // ---- nullable root string: valid value ----
-  {
-    nullable_string::RootBuilder b;
-    WeaselJsonStatus s = parseStrided(b, R"("hello")");
-    CHECK(s == WeaselJson_OK);
-    if (s == WeaselJson_OK) {
-      nullable_string::Root r = b.take();
-      CHECK(r.has_value());
-      CHECK(*r == "hello");
-      printf("ok   nullable root string accepts string\n");
-    }
-  }
-
-  // ---- nullable root string: null value ----
-  {
-    nullable_string::RootBuilder b;
-    WeaselJsonStatus s = parseStrided(b, "null");
-    CHECK(s == WeaselJson_OK);
-    if (s == WeaselJson_OK) {
-      nullable_string::Root r = b.take();
-      CHECK(!r.has_value());
-      printf("ok   nullable root string accepts null\n");
-    }
-  }
-
-  // ---- nullable root array: valid value ----
-  {
-    nullable_array::RootBuilder b;
-    WeaselJsonStatus s = parseStrided(b, "[1,2,3]");
-    CHECK(s == WeaselJson_OK);
-    if (s == WeaselJson_OK) {
-      nullable_array::Root r = b.take();
-      CHECK(r.has_value());
-      CHECK(r->size() == 3);
-      CHECK((*r)[0] == 1 && (*r)[1] == 2 && (*r)[2] == 3);
-      printf("ok   nullable root array accepts array\n");
-    }
-  }
-
-  // ---- nullable root array: null value ----
-  {
-    nullable_array::RootBuilder b;
-    WeaselJsonStatus s = parseStrided(b, "null");
-    CHECK(s == WeaselJson_OK);
-    if (s == WeaselJson_OK) {
-      nullable_array::Root r = b.take();
-      CHECK(!r.has_value());
-      printf("ok   nullable root array accepts null\n");
-    }
-  }
-
-  if (failures == 0) {
-    printf("\nALL TESTS PASSED\n");
-    return 0;
-  }
-  printf("\n%d FAILURE(S)\n", failures);
-  return 1;
-}

contrib/schemagen/test_schemagen.py

@@ -3,8 +3,6 @@
 
 import json
 import os
-import re
-import shutil
 import subprocess
 import sys
 import tempfile
@@ -89,112 +87,6 @@ class SchemagenKeywordTest(unittest.TestCase):
             self.assertNotIn(f"std::optional<std::string> {kw};", stdout)
 
 
-class SchemagenCollisionTest(unittest.TestCase):
-    """Regression tests for issue #21: generated Root alias / Kind enum collisions."""
-
-    def setUp(self):
-        self.repo_root = os.path.dirname(
-            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        )
-        self.include_dir = os.path.join(self.repo_root, "include")
-        self.compiler = shutil.which("c++")
-
-    def generate_and_compile(self, schema):
-        """Run schemagen on schema and syntax-check the resulting header."""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            schema_path = os.path.join(tmpdir, "schema.json")
-            with open(schema_path, "w") as fp:
-                json.dump(schema, fp)
-            header_path = os.path.join(tmpdir, "gen.h")
-            cmd = [
-                sys.executable,
-                SCRIPT,
-                schema_path,
-                "-o",
-                header_path,
-                "--namespace",
-                "test_schema",
-            ]
-            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
-            self.assertEqual(result.returncode, 0, msg=result.stderr)
-
-            if self.compiler:
-                cpp_path = os.path.join(tmpdir, "test.cpp")
-                with open(cpp_path, "w") as fp:
-                    fp.write(
-                        '#include "gen.h"\n'
-                        "int main() {\n"
-                        "  test_schema::RootBuilder b;\n"
-                        "  test_schema::Root r = b.take();\n"
-                        "  (void)r;\n"
-                        "}\n"
-                    )
-                comp = subprocess.run(
-                    [
-                        self.compiler,
-                        "-std=c++20",
-                        "-fsyntax-only",
-                        "-I",
-                        self.include_dir,
-                        "-I",
-                        tmpdir,
-                        cpp_path,
-                    ],
-                    capture_output=True,
-                    text=True,
-                    check=False,
-                )
-                self.assertEqual(comp.returncode, 0, msg=comp.stderr)
-
-            with open(header_path) as fp:
-                return fp.read()
-
-    def test_root_alias_does_not_collide_with_user_type(self):
-        schema = {
-            "type": "array",
-            "items": {"$ref": "#/$defs/Root"},
-            "$defs": {"Root": {"enum": ["a", "b"]}},
-        }
-        out = self.generate_and_compile(schema)
-        self.assertIn("enum class Root1 : int { a, b };", out)
-        self.assertIn("using Root = std::vector<Root1>;", out)
-        self.assertNotIn("using Root = std::vector<Root>;", out)
-
-    def test_kind_enum_does_not_duplicate_arr0(self):
-        schema = {
-            "type": "object",
-            "properties": {
-                "arr": {"type": "array", "items": {"type": "string"}},
-                "obj": {"$ref": "#/$defs/Arr0"},
-            },
-            "$defs": {"Arr0": {"type": "object", "properties": {}}},
-        }
-        out = self.generate_and_compile(schema)
-        self.assertIn("struct Arr0", out)
-        m = re.search(r"enum class Kind : uint8_t \{([^}]+)\}", out)
-        self.assertIsNotNone(m)
-        enumerators = [e.strip() for e in m.group(1).split(",")]
-        self.assertIn("Arr0", enumerators)
-        self.assertIn("Arr1", enumerators)
-        self.assertEqual(len(enumerators), len(set(enumerators)))
-
-    def test_skip_user_type_is_allowed(self):
-        schema = {
-            "type": "array",
-            "items": {"$ref": "#/$defs/Skip"},
-            "$defs": {"Skip": {"type": "object", "properties": {}}},
-        }
-        out = self.generate_and_compile(schema)
-        self.assertIn("struct Skip", out)
-        self.assertNotIn("struct Skip1", out)
-        m = re.search(r"enum class Kind : uint8_t \{([^}]+)\}", out)
-        self.assertIsNotNone(m)
-        enumerators = [e.strip() for e in m.group(1).split(",")]
-        self.assertIn("Skip", enumerators)
-        self.assertIn("Arr0", enumerators)
-        self.assertEqual(len(enumerators), len(set(enumerators)))
-
-
 class SchemagenAdditionalPropertiesTest(unittest.TestCase):
     def run_schemagen(self, schema, args=None):
         """Run schemagen on a schema dict. Returns (returncode, stdout, stderr)."""

contrib/schemagen/weaseljson_schemagen.py

@@ -215,26 +215,12 @@ class Builder:
         base = camel(hint)
         name = base
         i = 1
-        while self._name_taken(name):
+        while name in self._used_names:
-            candidate = f"{base}{i}"
-            # A numeric suffix can itself land on a reserved generated name
-            # (e.g. hint "Arr0" -> "Arr01").  Use an underscore separator so
-            # we never loop through the reserved block.
-            if self._is_reserved(candidate):
-                candidate = f"{base}_{i}"
-            name = candidate
             i += 1
+            name = f"{base}{i}"
         self._used_names.add(name)
         return name
 
-    def _name_taken(self, name):
-        return name in self._used_names or self._is_reserved(name)
-
-    @staticmethod
-    def _is_reserved(name):
-        """Names generated internally that must not collide with user types."""
-        return name in ("Root", "RootScalar")
-
     def ref_name(self, ref):
         if not ref.startswith("#/"):
             raise GenError(f"only local $ref supported, got: {ref}")
@@ -449,7 +435,6 @@ class Emitter:
         self.kind_order = []  # all Kind enumerators in declaration order
         self.root_ty = None
         self.root_nullable = False
-        self._arr_counter = 0
 
     # -- type strings -------------------------------------------------------
     def base_cpp(self, ty):
@@ -480,19 +465,11 @@ class Emitter:
     def arr_kind(self, tarr):
         sig = self.base_cpp(tarr)
         if sig not in self.arr_kinds:
-            name = self._fresh_arr_kind_name()
+            name = f"Arr{len(self.arr_kinds)}"
             self.arr_kinds[sig] = name
             self.arr_types.append((name, tarr))
-            self.b._used_names.add(name)
         return self.arr_kinds[sig]
 
-    def _fresh_arr_kind_name(self):
-        while True:
-            name = f"Arr{self._arr_counter}"
-            self._arr_counter += 1
-            if not self.b._name_taken(name):
-                return name
-
     def cat(self, ty):
         if isinstance(ty, TScalar):
             return {"str": "Str", "int": "Int", "dbl": "Dbl", "bool": "Bool"}[ty.kind]
@@ -516,18 +493,6 @@ class Emitter:
         self.root_ty, self.root_nullable = Builder._unpack(
             self.b.build_type(self.b.root_schema, "Root")
         )
-
-        # A nullable root object would otherwise produce
-        #   using Root = std::optional<Root>;
-        # which conflicts with the struct named Root.  Rename the inner struct.
-        if isinstance(self.root_ty, TObj) and self.root_nullable:
-            old_name = self.root_ty.name
-            new_name = self.b.unique_name("RootInner")
-            obj = self.b.objects.pop(old_name)
-            obj.name = new_name
-            self.b.objects[new_name] = obj
-            self.root_ty = TObj(new_name)
-
         break_cycles(self.b.objects)
 
         # register all array kinds (walk every field + root)
@@ -617,7 +582,9 @@ namespace {ns} {{"""
     def _kind_enum(self):
         kinds = list(self.b.objects.keys())
         kinds += [n for n, _ in self.arr_types]
-        root_is_container = isinstance(self.root_ty, (TObj, TArr))
+        root_is_container = (
+            isinstance(self.root_ty, (TObj, TArr)) and not self.root_nullable
+        )
         if not root_is_container:
             kinds.append("RootScalar")
         self.kind_order = kinds
@@ -625,9 +592,9 @@ namespace {ns} {{"""
 
     def _root_info(self):
         """Return (root_cat, root_container_kind_or_None)."""
-        if isinstance(self.root_ty, TObj):
+        if isinstance(self.root_ty, TObj) and not self.root_nullable:
             return ("Obj", f"Kind::{self.root_ty.name}")
-        if isinstance(self.root_ty, TArr):
+        if isinstance(self.root_ty, TArr) and not self.root_nullable:
             return ("Arr", f"Kind::{self.arr_kind(self.root_ty)}")
         return (self.cat(self.root_ty), None)
 
@@ -697,11 +664,6 @@ namespace {ns} {{"""
             lines.append("    }")
         root_cat, root_kind = self._root_info()
         if root_kind is None:
-            if self.root_nullable:
-                lines.append(
-                    "    case Kind::RootScalar: { if (!result_) result_.emplace(); return &*result_; }"
-                )
-            else:
             lines.append("    case Kind::RootScalar: return &result_;")
         lines.append("    default: return nullptr;")
         lines.append("    }")
@@ -833,12 +795,7 @@ namespace {ns} {{"""
         lines = ["    if (error_) return;"]
         if root_kind is not None and root_cat == event_cat:
             lines.append("    if (stack_.empty()) {")
-            if self.root_nullable:
+            lines.append(f"      stack_.push_back(Frame{{{root_kind}, &result_}});")
-                lines.append("      result_.emplace();")
-                dest = "&*result_"
-            else:
-                dest = "&result_"
-            lines.append(f"      stack_.push_back(Frame{{{root_kind}, {dest}}});")
             if event_cat == "Obj":
                 lines.append("      {")
                 lines.append(f"        int n = fieldCount({root_kind});")
@@ -864,9 +821,6 @@ namespace {ns} {{"""
         root_cat, root_kind = self._root_info()
         begin_obj = self._begin_container("Obj", root_kind)
         begin_arr = self._begin_container("Arr", root_kind)
-        null_at_root = (
-            "done_ = true; return;" if self.root_nullable else "reject(); return;"
-        )
 
         return f"""
 class RootBuilder {{
@@ -1073,9 +1027,6 @@ private:
 
   void cbNull() {{
     if (error_) return;
-    if (stack_.empty()) {{
-      {null_at_root}
-    }}
     Frame &f = stack_.back();
     SlotInfo si = slotInfoG(f);
     if (!si.nullable) {{ reject(); return; }}