Unroll properties of 1 keyword even more aggressively (#1199)

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

src/jsonschema/compile_helpers.h

@@ -3,6 +3,7 @@
 
 #include <sourcemeta/jsontoolkit/jsonschema_compile.h>
 
+#include <cassert> // assert
 #include <utility> // std::declval, std::move
 
 namespace sourcemeta::jsontoolkit {
@@ -52,6 +53,25 @@ auto make(const bool report, const SchemaCompilerContext &context,
       std::move(children)};
 }
 
+template <typename Type, typename Step>
+auto unroll(const SchemaCompilerDynamicContext &dynamic_context,
+            const Step &step,
+            const Pointer &base_instance_location = empty_pointer) -> Type {
+  assert(std::holds_alternative<Type>(step));
+  return {dynamic_context.keyword.empty()
+              ? std::get<Type>(step).relative_schema_location
+              : dynamic_context.base_schema_location
+                    .concat({dynamic_context.keyword})
+                    .concat(std::get<Type>(step).relative_schema_location),
+          base_instance_location.concat(
+              std::get<Type>(step).relative_instance_location),
+          std::get<Type>(step).keyword_location,
+          std::get<Type>(step).schema_resource,
+          std::get<Type>(step).dynamic,
+          std::get<Type>(step).report,
+          std::get<Type>(step).value};
+}
+
 } // namespace sourcemeta::jsontoolkit
 
 #endif

src/jsonschema/default_compiler_draft4.h

@@ -428,24 +428,42 @@ auto compiler_draft4_applicator_properties_conditional_annotation(
 
       // Optimize `properties` where its subschemas just include a type check,
       // as that's a very common pattern
+
     } else if (substeps.size() == 1 &&
                std::holds_alternative<SchemaCompilerAssertionTypeStrict>(
                    substeps.front())) {
       const auto &type_step{
           std::get<SchemaCompilerAssertionTypeStrict>(substeps.front())};
       children.push_back(SchemaCompilerAssertionPropertyTypeStrict{
           type_step.relative_schema_location,
-          type_step.relative_instance_location, type_step.keyword_location,
-          type_step.schema_resource, type_step.dynamic, true, type_step.value});
+          dynamic_context.base_instance_location.concat(
+              type_step.relative_instance_location),
+          type_step.keyword_location, type_step.schema_resource,
+          type_step.dynamic, type_step.report, type_step.value});
     } else if (substeps.size() == 1 &&
                std::holds_alternative<SchemaCompilerAssertionType>(
                    substeps.front())) {
       const auto &type_step{
           std::get<SchemaCompilerAssertionType>(substeps.front())};
       children.push_back(SchemaCompilerAssertionPropertyType{
           type_step.relative_schema_location,
-          type_step.relative_instance_location, type_step.keyword_location,
-          type_step.schema_resource, type_step.dynamic, true, type_step.value});
+          dynamic_context.base_instance_location.concat(
+              type_step.relative_instance_location),
+          type_step.keyword_location, type_step.schema_resource,
+          type_step.dynamic, type_step.report, type_step.value});
+    } else if (substeps.size() == 1 &&
+               std::holds_alternative<
+                   SchemaCompilerAssertionPropertyTypeStrict>(
+                   substeps.front())) {
+      children.push_back(unroll<SchemaCompilerAssertionPropertyTypeStrict>(
+          relative_dynamic_context, substeps.front(),
+          dynamic_context.base_instance_location));
+    } else if (substeps.size() == 1 &&
+               std::holds_alternative<SchemaCompilerAssertionPropertyType>(
+                   substeps.front())) {
+      children.push_back(unroll<SchemaCompilerAssertionPropertyType>(
+          relative_dynamic_context, substeps.front(),
+          dynamic_context.base_instance_location));
 
     } else {
       children.push_back(make<SchemaCompilerLogicalWhenDefines>(
@@ -454,6 +472,14 @@ auto compiler_draft4_applicator_properties_conditional_annotation(
     }
   }
 
+  // Optimize away the wrapper when emitting a single instruction
+  if (children.size() == 1 &&
+      std::holds_alternative<SchemaCompilerAssertionPropertyTypeStrict>(
+          children.front())) {
+    return {unroll<SchemaCompilerAssertionPropertyTypeStrict>(
+        dynamic_context, children.front())};
+  }
+
   return {make<SchemaCompilerLogicalAnd>(
       true, context, schema_context, dynamic_context, SchemaCompilerValueNone{},
       std::move(children))};