Remove the idea of explicit conditions from the compiler (#1100)

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

src/jsonschema/compile.cc

@@ -28,7 +28,7 @@ auto compile_subschema(
     } else {
       return {make<SchemaCompilerAssertionFail>(true, context, schema_context,
                                                 dynamic_context,
-                                                SchemaCompilerValueNone{}, {})};
+                                                SchemaCompilerValueNone{})};
     }
   }
 
@@ -154,8 +154,7 @@ auto compile(const JSON &schema, const SchemaWalker &walker,
           true, context, nested_schema_context, dynamic_context,
           SchemaCompilerValueUnsignedInteger{label},
           compile(context, nested_schema_context, relative_dynamic_context,
-                  empty_pointer, empty_pointer, entry.first.second),
-          {}));
+                  empty_pointer, empty_pointer, entry.first.second)));
     }
   }
 

src/jsonschema/compile_describe.cc

@@ -839,11 +839,11 @@ struct DescribeVisitor {
     return message.str();
   }
 
-  auto operator()(const SchemaCompilerAssertionSizeGreater &step) const
+  auto operator()(const SchemaCompilerAssertionStringSizeLess &step) const
       -> std::string {
-    if (this->keyword == "minLength") {
+    if (this->keyword == "maxLength") {
       std::ostringstream message;
-      const auto minimum{step_value(step) + 1};
+      const auto maximum{step_value(step) - 1};
 
       if (is_within_keyword(this->evaluate_path, "propertyNames")) {
         assert(this->instance_location.back().is_property());
@@ -854,8 +854,8 @@ struct DescribeVisitor {
         stringify(this->target, message);
       }
 
-      message << " was expected to consist of at least " << minimum
-              << (minimum == 1 ? " character" : " characters");
+      message << " was expected to consist of at most " << maximum
+              << (maximum == 1 ? " character" : " characters");
 
       if (this->valid) {
         message << " and";
@@ -878,45 +878,63 @@ struct DescribeVisitor {
       return message.str();
     }
 
-    if (this->keyword == "minItems") {
-      assert(this->target.is_array());
+    return unknown();
+  }
+
+  auto operator()(const SchemaCompilerAssertionStringSizeGreater &step) const
+      -> std::string {
+    if (this->keyword == "minLength") {
       std::ostringstream message;
       const auto minimum{step_value(step) + 1};
-      message << "The array value was expected to contain at least " << minimum;
-      assert(minimum > 0);
-      if (minimum == 1) {
-        message << " item";
+
+      if (is_within_keyword(this->evaluate_path, "propertyNames")) {
+        assert(this->instance_location.back().is_property());
+        message << "The object property name "
+                << escape_string(this->instance_location.back().to_property());
       } else {
-        message << " items";
+        message << "The string value ";
+        stringify(this->target, message);
       }
 
+      message << " was expected to consist of at least " << minimum
+              << (minimum == 1 ? " character" : " characters");
+
       if (this->valid) {
         message << " and";
       } else {
         message << " but";
       }
 
-      message << " it contained " << this->target.size();
-      if (this->target.size() == 1) {
-        message << " item";
+      message << " it consisted of ";
+
+      if (is_within_keyword(this->evaluate_path, "propertyNames")) {
+        message << this->instance_location.back().to_property().size();
+        message << (this->instance_location.back().to_property().size() == 1
+                        ? " character"
+                        : " characters");
       } else {
-        message << " items";
+        message << this->target.size();
+        message << (this->target.size() == 1 ? " character" : " characters");
       }
 
       return message.str();
     }
 
-    if (this->keyword == "minProperties") {
-      assert(this->target.is_object());
+    return unknown();
+  }
+
+  auto operator()(const SchemaCompilerAssertionArraySizeLess &step) const
+      -> std::string {
+    if (this->keyword == "maxItems") {
+      assert(this->target.is_array());
       std::ostringstream message;
-      const auto minimum{step_value(step) + 1};
-      message << "The object value was expected to contain at least "
-              << minimum;
-      assert(minimum > 0);
-      if (minimum == 1) {
-        message << " property";
+      const auto maximum{step_value(step) - 1};
+      message << "The array value was expected to contain at most " << maximum;
+      assert(maximum > 0);
+      if (maximum == 1) {
+        message << " item";
       } else {
-        message << " properties";
+        message << " items";
       }
 
       if (this->valid) {
@@ -927,18 +945,9 @@ struct DescribeVisitor {
 
       message << " it contained " << this->target.size();
       if (this->target.size() == 1) {
-        message << " property: ";
-        message << escape_string(this->target.as_object().cbegin()->first);
+        message << " item";
       } else {
-        message << " properties: ";
-        for (auto iterator = this->target.as_object().cbegin();
-             iterator != this->target.as_object().cend(); ++iterator) {
-          if (std::next(iterator) == this->target.as_object().cend()) {
-            message << "and " << escape_string(iterator->first);
-          } else {
-            message << escape_string(iterator->first) << ", ";
-          }
-        }
+        message << " items";
       }
 
       return message.str();
@@ -947,55 +956,51 @@ struct DescribeVisitor {
     return unknown();
   }
 
-  auto
-  operator()(const SchemaCompilerAssertionSizeLess &step) const -> std::string {
-    if (this->keyword == "maxLength") {
+  auto operator()(const SchemaCompilerAssertionArraySizeGreater &step) const
+      -> std::string {
+    if (this->keyword == "minItems") {
+      assert(this->target.is_array());
       std::ostringstream message;
-      const auto maximum{step_value(step) - 1};
-
-      if (is_within_keyword(this->evaluate_path, "propertyNames")) {
-        assert(this->instance_location.back().is_property());
-        message << "The object property name "
-                << escape_string(this->instance_location.back().to_property());
+      const auto minimum{step_value(step) + 1};
+      message << "The array value was expected to contain at least " << minimum;
+      assert(minimum > 0);
+      if (minimum == 1) {
+        message << " item";
       } else {
-        message << "The string value ";
-        stringify(this->target, message);
+        message << " items";
       }
 
-      message << " was expected to consist of at most " << maximum
-              << (maximum == 1 ? " character" : " characters");
-
       if (this->valid) {
         message << " and";
       } else {
         message << " but";
       }
 
-      message << " it consisted of ";
-
-      if (is_within_keyword(this->evaluate_path, "propertyNames")) {
-        message << this->instance_location.back().to_property().size();
-        message << (this->instance_location.back().to_property().size() == 1
-                        ? " character"
-                        : " characters");
+      message << " it contained " << this->target.size();
+      if (this->target.size() == 1) {
+        message << " item";
       } else {
-        message << this->target.size();
-        message << (this->target.size() == 1 ? " character" : " characters");
+        message << " items";
       }
 
       return message.str();
     }
 
-    if (this->keyword == "maxItems") {
-      assert(this->target.is_array());
+    return unknown();
+  }
+
+  auto operator()(const SchemaCompilerAssertionObjectSizeLess &step) const
+      -> std::string {
+    if (this->keyword == "maxProperties") {
+      assert(this->target.is_object());
       std::ostringstream message;
       const auto maximum{step_value(step) - 1};
-      message << "The array value was expected to contain at most " << maximum;
+      message << "The object value was expected to contain at most " << maximum;
       assert(maximum > 0);
       if (maximum == 1) {
-        message << " item";
+        message << " property";
       } else {
-        message << " items";
+        message << " properties";
       }
 
       if (this->valid) {
@@ -1006,21 +1011,36 @@ struct DescribeVisitor {
 
       message << " it contained " << this->target.size();
       if (this->target.size() == 1) {
-        message << " item";
+        message << " property: ";
+        message << escape_string(this->target.as_object().cbegin()->first);
       } else {
-        message << " items";
+        message << " properties: ";
+        for (auto iterator = this->target.as_object().cbegin();
+             iterator != this->target.as_object().cend(); ++iterator) {
+          if (std::next(iterator) == this->target.as_object().cend()) {
+            message << "and " << escape_string(iterator->first);
+          } else {
+            message << escape_string(iterator->first) << ", ";
+          }
+        }
       }
 
       return message.str();
     }
 
-    if (this->keyword == "maxProperties") {
+    return unknown();
+  }
+
+  auto operator()(const SchemaCompilerAssertionObjectSizeGreater &step) const
+      -> std::string {
+    if (this->keyword == "minProperties") {
       assert(this->target.is_object());
       std::ostringstream message;
-      const auto maximum{step_value(step) - 1};
-      message << "The object value was expected to contain at most " << maximum;
-      assert(maximum > 0);
-      if (maximum == 1) {
+      const auto minimum{step_value(step) + 1};
+      message << "The object value was expected to contain at least "
+              << minimum;
+      assert(minimum > 0);
+      if (minimum == 1) {
         message << " property";
       } else {
         message << " properties";

src/jsonschema/compile_evaluate.cc

@@ -347,16 +347,6 @@ auto evaluate_step(
     return true;                                                               \
   }
 
-#define EVALUATE_CONDITION_GUARD(title, step, instance)                        \
-  for (const auto &child : step.condition) {                                   \
-    if (!evaluate_step(child, instance, SchemaCompilerEvaluationMode::Fast,    \
-                       std::nullopt, context)) {                               \
-      context.pop(step);                                                       \
-      SOURCEMETA_TRACE_END(trace_id, title);                                   \
-      return true;                                                             \
-    }                                                                          \
-  }
-
   if (std::holds_alternative<SchemaCompilerAssertionFail>(step)) {
     SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionFail");
     const auto &assertion{std::get<SchemaCompilerAssertionFail>(step)};
@@ -483,30 +473,80 @@ auto evaluate_step(
     CALLBACK_PRE(assertion, context.instance_location());
     result = std::regex_search(target.to_string(), assertion.value.first);
     CALLBACK_POST("SchemaCompilerAssertionRegex", assertion);
-  } else if (std::holds_alternative<SchemaCompilerAssertionSizeGreater>(step)) {
-    SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionSizeGreater");
-    const auto &assertion{std::get<SchemaCompilerAssertionSizeGreater>(step)};
+  } else if (std::holds_alternative<SchemaCompilerAssertionStringSizeLess>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionStringSizeLess");
+    const auto &assertion{
+        std::get<SchemaCompilerAssertionStringSizeLess>(step)};
+    context.push(assertion);
+    const auto &target{context.resolve_target(instance)};
+    EVALUATE_IMPLICIT_PRECONDITION("SchemaCompilerAssertionStringSizeLess",
+                                   assertion, target.is_string());
+    CALLBACK_PRE(assertion, context.instance_location());
+    result = (target.size() < assertion.value);
+    CALLBACK_POST("SchemaCompilerAssertionStringSizeLess", assertion);
+  } else if (std::holds_alternative<SchemaCompilerAssertionStringSizeGreater>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id,
+                           "SchemaCompilerAssertionStringSizeGreater");
+    const auto &assertion{
+        std::get<SchemaCompilerAssertionStringSizeGreater>(step)};
+    context.push(assertion);
+    const auto &target{context.resolve_target(instance)};
+    EVALUATE_IMPLICIT_PRECONDITION("SchemaCompilerAssertionStringSizeGreater",
+                                   assertion, target.is_string());
+    CALLBACK_PRE(assertion, context.instance_location());
+    result = (target.size() > assertion.value);
+    CALLBACK_POST("SchemaCompilerAssertionStringSizeGreater", assertion);
+
+  } else if (std::holds_alternative<SchemaCompilerAssertionArraySizeLess>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionArraySizeLess");
+    const auto &assertion{std::get<SchemaCompilerAssertionArraySizeLess>(step)};
     context.push(assertion);
-    // TODO: Get rid of this
-    EVALUATE_CONDITION_GUARD("SchemaCompilerAssertionSizeGreater", assertion,
-                             instance);
+    const auto &target{context.resolve_target(instance)};
+    EVALUATE_IMPLICIT_PRECONDITION("SchemaCompilerAssertionArraySizeLess",
+                                   assertion, target.is_array());
     CALLBACK_PRE(assertion, context.instance_location());
+    result = (target.size() < assertion.value);
+    CALLBACK_POST("SchemaCompilerAssertionArraySizeLess", assertion);
+  } else if (std::holds_alternative<SchemaCompilerAssertionArraySizeGreater>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionArraySizeGreater");
+    const auto &assertion{
+        std::get<SchemaCompilerAssertionArraySizeGreater>(step)};
+    context.push(assertion);
     const auto &target{context.resolve_target(instance)};
-    result = (target.is_array() || target.is_object() || target.is_string()) &&
-             (target.size() > assertion.value);
-    CALLBACK_POST("SchemaCompilerAssertionSizeGreater", assertion);
-  } else if (std::holds_alternative<SchemaCompilerAssertionSizeLess>(step)) {
-    SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionSizeLess");
-    const auto &assertion{std::get<SchemaCompilerAssertionSizeLess>(step)};
+    EVALUATE_IMPLICIT_PRECONDITION("SchemaCompilerAssertionArraySizeGreater",
+                                   assertion, target.is_array());
+    CALLBACK_PRE(assertion, context.instance_location());
+    result = (target.size() > assertion.value);
+    CALLBACK_POST("SchemaCompilerAssertionArraySizeGreater", assertion);
+  } else if (std::holds_alternative<SchemaCompilerAssertionObjectSizeLess>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionObjectSizeLess");
+    const auto &assertion{
+        std::get<SchemaCompilerAssertionObjectSizeLess>(step)};
     context.push(assertion);
-    // TODO: Get rid of this
-    EVALUATE_CONDITION_GUARD("SchemaCompilerAssertionSizeLess", assertion,
-                             instance);
+    const auto &target{context.resolve_target(instance)};
+    EVALUATE_IMPLICIT_PRECONDITION("SchemaCompilerAssertionObjectSizeLess",
+                                   assertion, target.is_object());
     CALLBACK_PRE(assertion, context.instance_location());
+    result = (target.size() < assertion.value);
+    CALLBACK_POST("SchemaCompilerAssertionObjectSizeLess", assertion);
+  } else if (std::holds_alternative<SchemaCompilerAssertionObjectSizeGreater>(
+                 step)) {
+    SOURCEMETA_TRACE_START(trace_id,
+                           "SchemaCompilerAssertionObjectSizeGreater");
+    const auto &assertion{
+        std::get<SchemaCompilerAssertionObjectSizeGreater>(step)};
+    context.push(assertion);
     const auto &target{context.resolve_target(instance)};
-    result = (target.is_array() || target.is_object() || target.is_string()) &&
-             (target.size() < assertion.value);
-    CALLBACK_POST("SchemaCompilerAssertionSizeLess", assertion);
+    EVALUATE_IMPLICIT_PRECONDITION("SchemaCompilerAssertionObjectSizeGreater",
+                                   assertion, target.is_object());
+    CALLBACK_PRE(assertion, context.instance_location());
+    result = (target.size() > assertion.value);
+    CALLBACK_POST("SchemaCompilerAssertionObjectSizeGreater", assertion);
   } else if (std::holds_alternative<SchemaCompilerAssertionEqual>(step)) {
     SOURCEMETA_TRACE_START(trace_id, "SchemaCompilerAssertionEqual");
     const auto &assertion{std::get<SchemaCompilerAssertionEqual>(step)};
@@ -1358,7 +1398,6 @@ auto evaluate_step(
 #undef CALLBACK_POST
 #undef CALLBACK_ANNOTATION
 #undef EVALUATE_IMPLICIT_PRECONDITION
-#undef EVALUATE_CONDITION_GUARD
   // We should never get here
   assert(false);
   return result;