Add a new LogicalWhenNoAdjacentAnnotations compiler step (#1077)

Signed-off-by: Juan Cruz Viotti <[email protected]>

src/jsonschema/compile_describe.cc

@@ -178,7 +178,7 @@ struct DescribeVisitor {
       return message.str();
     }
 
-    if (this->keyword == "then" || this->keyword == "else") {
+    if (this->keyword == "then") {
       assert(!step.children.empty());
       std::ostringstream message;
       message << "Because of the conditional outcome, the "
@@ -1566,6 +1566,26 @@ struct DescribeVisitor {
     return unknown();
   }
 
+  auto operator()(const SchemaCompilerLogicalWhenNoAdjacentAnnotations &step)
+      const -> std::string {
+    if (this->keyword == "else") {
+      assert(!step.children.empty());
+      std::ostringstream message;
+      message << "Because of the conditional outcome, the "
+              << to_string(this->target.type())
+              << " value was expected to validate against the ";
+      if (step.children.size() > 1) {
+        message << step.children.size() << " given subschemas";
+      } else {
+        message << "given subschema";
+      }
+
+      return message.str();
+    }
+
+    return unknown();
+  }
+
   // These steps are never described, at least not right now
 
   auto
@@ -1584,10 +1604,6 @@ struct DescribeVisitor {
   operator()(const SchemaCompilerAssertionAnnotation &) const -> std::string {
     return unknown();
   }
-  auto operator()(const SchemaCompilerAssertionNoAdjacentAnnotation &) const
-      -> std::string {
-    return unknown();
-  }
   auto
   operator()(const SchemaCompilerLoopPropertiesRegex &) const -> std::string {
     return unknown();

src/jsonschema/compile_evaluate.cc

@@ -630,21 +630,6 @@ auto evaluate_step(
         context.resolve_target<std::set<JSON>>(assertion.target, instance)};
     result = target.contains(value);
     CALLBACK_POST("SchemaCompilerAssertionAnnotation", assertion);
-  } else if (std::holds_alternative<
-                 SchemaCompilerAssertionNoAdjacentAnnotation>(step)) {
-    SOURCEMETA_TRACE_START(trace_id,
-                           "SchemaCompilerAssertionNoAdjacentAnnotation");
-    const auto &assertion{
-        std::get<SchemaCompilerAssertionNoAdjacentAnnotation>(step)};
-    context.push(assertion);
-    EVALUATE_CONDITION_GUARD("SchemaCompilerAssertionNoAdjacentAnnotation",
-                             assertion, instance);
-    CALLBACK_PRE(assertion, context.instance_location());
-    const auto &value{context.resolve_value(assertion.value, instance)};
-    const auto &target{
-        context.resolve_target<std::set<JSON>>(assertion.target, instance)};
-    result = !target.contains(value);
-    CALLBACK_POST("SchemaCompilerAssertionNoAdjacentAnnotation", assertion);
   } else if (std::holds_alternative<SchemaCompilerAssertionNoAnnotation>(
                  step)) {
     SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionNoAnnotation");
@@ -760,6 +745,37 @@ auto evaluate_step(
     }
 
     CALLBACK_POST("SchemaCompilerLogicalWhenDefines", logical);
+  } else if (std::holds_alternative<
+                 SchemaCompilerLogicalWhenNoAdjacentAnnotations>(step)) {
+    SOURCEMETA_TRACE_START(trace_id,
+                           "SchemaCompilerLogicalWhenNoAdjacentAnnotations");
+    const auto &logical{
+        std::get<SchemaCompilerLogicalWhenNoAdjacentAnnotations>(step)};
+    context.push(logical);
+    EVALUATE_CONDITION_GUARD("SchemaCompilerLogicalWhenNoAdjacentAnnotations",
+                             logical, instance);
+    const auto &value{context.resolve_value(logical.value, instance)};
+
+    // TODO: How can we avoid this expensive pointer manipulation?
+    auto expected_evaluate_path{context.evaluate_path()};
+    expected_evaluate_path.pop_back();
+    expected_evaluate_path.push_back({value});
+    const auto &current_annotations{context.annotations(
+        context.instance_location(), expected_evaluate_path)};
+    EVALUATE_IMPLICIT_PRECONDITION(
+        "SchemaCompilerLogicalWhenNoAdjacentAnnotations", logical,
+        current_annotations.empty());
+
+    CALLBACK_PRE(logical, context.instance_location());
+    result = true;
+    for (const auto &child : logical.children) {
+      if (!evaluate_step(child, instance, mode, callback, context)) {
+        result = false;
+        break;
+      }
+    }
+
+    CALLBACK_POST("SchemaCompilerLogicalWhenNoAdjacentAnnotations", logical);
   } else if (std::holds_alternative<SchemaCompilerLogicalXor>(step)) {
     SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerLogicalXor");
     const auto &logical{std::get<SchemaCompilerLogicalXor>(step)};
@@ -1071,6 +1087,7 @@ auto evaluate_step(
     for (const auto &entry : target.as_object()) {
       bool apply_children{true};
       for (const auto &annotations : current_annotations) {
+        // TODO: Can we avoid this JSON conversion?
         if (annotations.get().contains(JSON{entry.first})) {
           apply_children = false;
           break;

src/jsonschema/compile_json.cc

@@ -253,8 +253,6 @@ struct StepVisitor {
   HANDLE_STEP("assertion", "equals-any", SchemaCompilerAssertionEqualsAny)
   HANDLE_STEP("assertion", "size-equal", SchemaCompilerAssertionSizeEqual)
   HANDLE_STEP("assertion", "annotation", SchemaCompilerAssertionAnnotation)
-  HANDLE_STEP("assertion", "no-adjacent-annotation",
-              SchemaCompilerAssertionNoAdjacentAnnotation)
   HANDLE_STEP("assertion", "no-annotation", SchemaCompilerAssertionNoAnnotation)
   HANDLE_STEP("annotation", "emit", SchemaCompilerAnnotationEmit)
   HANDLE_STEP("annotation", "to-parent", SchemaCompilerAnnotationToParent)
@@ -267,6 +265,8 @@ struct StepVisitor {
   HANDLE_STEP("logical", "not", SchemaCompilerLogicalNot)
   HANDLE_STEP("logical", "when-type", SchemaCompilerLogicalWhenType)
   HANDLE_STEP("logical", "when-defines", SchemaCompilerLogicalWhenDefines)
+  HANDLE_STEP("logical", "when-no-adjacent-annotations",
+              SchemaCompilerLogicalWhenNoAdjacentAnnotations)
   HANDLE_STEP("loop", "properties-match", SchemaCompilerLoopPropertiesMatch)
   HANDLE_STEP("loop", "properties", SchemaCompilerLoopProperties)
   HANDLE_STEP("loop", "properties-regex", SchemaCompilerLoopPropertiesRegex)

src/jsonschema/default_compiler_draft7.h

@@ -60,16 +60,11 @@ auto compiler_draft7_applicator_else(
     return {};
   }
 
-  SchemaCompilerTemplate children{compile(context, schema_context,
-                                          relative_dynamic_context,
-                                          empty_pointer, empty_pointer)};
-  SchemaCompilerTemplate condition{
-      make<SchemaCompilerAssertionNoAdjacentAnnotation>(
-          false, context, schema_context, relative_dynamic_context, JSON{true},
-          {}, SchemaCompilerTargetType::AdjacentAnnotations, Pointer{"if"})};
-  return {make<SchemaCompilerLogicalAnd>(
-      true, context, schema_context, dynamic_context, SchemaCompilerValueNone{},
-      std::move(children), std::move(condition))};
+  return {make<SchemaCompilerLogicalWhenNoAdjacentAnnotations>(
+      true, context, schema_context, dynamic_context, "if",
+      compile(context, schema_context, relative_dynamic_context, empty_pointer,
+              empty_pointer),
+      SchemaCompilerTemplate{})};
 }
 
 } // namespace internal

src/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_compile.h

@@ -223,11 +223,6 @@ struct SchemaCompilerAssertionSizeEqual;
 /// annotation was produced
 struct SchemaCompilerAssertionAnnotation;
 
-/// @ingroup jsonschema
-/// Represents a compiler assertion step that checks a certain
-/// annotation was not produced at an adjacent location
-struct SchemaCompilerAssertionNoAdjacentAnnotation;
-
 /// @ingroup jsonschema
 /// Represents a compiler assertion step that checks a certain
 /// annotation was not produced independently of the schema location
@@ -277,6 +272,11 @@ struct SchemaCompilerLogicalWhenType;
 /// when the instance is an object and defines a given property
 struct SchemaCompilerLogicalWhenDefines;
 
+/// @ingroup jsonschema
+/// Represents a compiler logical step that represents a conjunction
+/// when the instance did not receive any certain adjacent annotation
+struct SchemaCompilerLogicalWhenNoAdjacentAnnotations;
+
 /// @ingroup jsonschema
 /// Represents a compiler step that matches steps to object properties
 struct SchemaCompilerLoopPropertiesMatch;
@@ -345,13 +345,13 @@ using SchemaCompilerTemplate = std::vector<std::variant<
     SchemaCompilerAssertionGreater, SchemaCompilerAssertionLess,
     SchemaCompilerAssertionUnique, SchemaCompilerAssertionDivisible,
     SchemaCompilerAssertionStringType, SchemaCompilerAssertionSizeEqual,
-    SchemaCompilerAssertionAnnotation,
-    SchemaCompilerAssertionNoAdjacentAnnotation,
-    SchemaCompilerAssertionNoAnnotation, SchemaCompilerAnnotationEmit,
-    SchemaCompilerAnnotationToParent, SchemaCompilerAnnotationBasenameToParent,
-    SchemaCompilerLogicalOr, SchemaCompilerLogicalAnd, SchemaCompilerLogicalXor,
+    SchemaCompilerAssertionAnnotation, SchemaCompilerAssertionNoAnnotation,
+    SchemaCompilerAnnotationEmit, SchemaCompilerAnnotationToParent,
+    SchemaCompilerAnnotationBasenameToParent, SchemaCompilerLogicalOr,
+    SchemaCompilerLogicalAnd, SchemaCompilerLogicalXor,
     SchemaCompilerLogicalTry, SchemaCompilerLogicalNot,
     SchemaCompilerLogicalWhenType, SchemaCompilerLogicalWhenDefines,
+    SchemaCompilerLogicalWhenNoAdjacentAnnotations,
     SchemaCompilerLoopPropertiesMatch, SchemaCompilerLoopProperties,
     SchemaCompilerLoopPropertiesRegex,
     SchemaCompilerLoopPropertiesNoAdjacentAnnotation, SchemaCompilerLoopKeys,
@@ -450,6 +450,8 @@ DEFINE_STEP_APPLICATOR(Logical, Try, SchemaCompilerValueNone)
 DEFINE_STEP_APPLICATOR(Logical, Not, SchemaCompilerValueNone)
 DEFINE_STEP_APPLICATOR(Logical, WhenType, SchemaCompilerValueType)
 DEFINE_STEP_APPLICATOR(Logical, WhenDefines, SchemaCompilerValueString)
+DEFINE_STEP_APPLICATOR(Logical, WhenNoAdjacentAnnotations,
+                       SchemaCompilerValueString)
 DEFINE_STEP_APPLICATOR(Loop, PropertiesMatch, SchemaCompilerValueNamedIndexes)
 DEFINE_STEP_APPLICATOR(Loop, Properties, SchemaCompilerValueNone)
 DEFINE_STEP_APPLICATOR(Loop, PropertiesRegex, SchemaCompilerValueRegex)

test/jsonschema/jsonschema_compile_draft7_test.cc

@@ -256,15 +256,17 @@ TEST(JSONSchema_compile_draft7, else_3) {
 
   EVALUATE_TRACE_PRE(0, LogicalTry, "/if", "#/if", "");
   EVALUATE_TRACE_PRE(1, AssertionEqual, "/if/const", "#/if/const", "");
-  EVALUATE_TRACE_PRE(2, LogicalAnd, "/else", "#/else", "");
+  EVALUATE_TRACE_PRE(2, LogicalWhenNoAdjacentAnnotations, "/else", "#/else",
+                     "");
   EVALUATE_TRACE_PRE(3, AssertionDivisible, "/else/multipleOf",
                      "#/else/multipleOf", "");
 
   EVALUATE_TRACE_POST_FAILURE(0, AssertionEqual, "/if/const", "#/if/const", "");
   EVALUATE_TRACE_POST_SUCCESS(1, LogicalTry, "/if", "#/if", "");
   EVALUATE_TRACE_POST_SUCCESS(2, AssertionDivisible, "/else/multipleOf",
                               "#/else/multipleOf", "");
-  EVALUATE_TRACE_POST_SUCCESS(3, LogicalAnd, "/else", "#/else", "");
+  EVALUATE_TRACE_POST_SUCCESS(3, LogicalWhenNoAdjacentAnnotations, "/else",
+                              "#/else", "");
 
   EVALUATE_TRACE_POST_DESCRIBE(
       instance, 0,
@@ -300,15 +302,17 @@ TEST(JSONSchema_compile_draft7, else_4) {
 
   EVALUATE_TRACE_PRE(0, LogicalTry, "/if", "#/if", "");
   EVALUATE_TRACE_PRE(1, AssertionEqual, "/if/const", "#/if/const", "");
-  EVALUATE_TRACE_PRE(2, LogicalAnd, "/else", "#/else", "");
+  EVALUATE_TRACE_PRE(2, LogicalWhenNoAdjacentAnnotations, "/else", "#/else",
+                     "");
   EVALUATE_TRACE_PRE(3, AssertionDivisible, "/else/multipleOf",
                      "#/else/multipleOf", "");
 
   EVALUATE_TRACE_POST_FAILURE(0, AssertionEqual, "/if/const", "#/if/const", "");
   EVALUATE_TRACE_POST_SUCCESS(1, LogicalTry, "/if", "#/if", "");
   EVALUATE_TRACE_POST_FAILURE(2, AssertionDivisible, "/else/multipleOf",
                               "#/else/multipleOf", "");
-  EVALUATE_TRACE_POST_FAILURE(3, LogicalAnd, "/else", "#/else", "");
+  EVALUATE_TRACE_POST_FAILURE(3, LogicalWhenNoAdjacentAnnotations, "/else",
+                              "#/else", "");
 
   EVALUATE_TRACE_POST_DESCRIBE(
       instance, 0,