Keep Instruction additional data out of band in the Template (#657)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

src/compiler/compile.cc

@@ -64,7 +64,7 @@ auto compile_subschema(const sourcemeta::blaze::Context &context,
       // Just a sanity check to ensure every keyword location is indeed valid
       assert(context.frame.locations().contains(
           {sourcemeta::core::SchemaReferenceType::Static,
-           step.keyword_location}));
+           context.extra[step.extra_index].keyword_location}));
       steps.push_back(std::move(step));
     }
   }
@@ -297,6 +297,7 @@ auto compile(const sourcemeta::core::JSON &schema,
   auto unevaluated{
       sourcemeta::blaze::unevaluated(schema, frame, walker, resolver)};
 
+  std::vector<InstructionExtra> instruction_extra;
   const Context context{.root = schema,
                         .frame = frame,
                         .resources = std::move(resources),
@@ -307,7 +308,8 @@ auto compile(const sourcemeta::core::JSON &schema,
                         .uses_dynamic_scopes = uses_dynamic_scopes,
                         .unevaluated = std::move(unevaluated),
                         .tweaks = effective_tweaks,
-                        .targets = std::move(targets_map)};
+                        .targets = std::move(targets_map),
+                        .extra = instruction_extra};
 
   ///////////////////////////////////////////////////////////////////
   // (5) Build labels map for dynamic anchors
@@ -399,7 +401,8 @@ auto compile(const sourcemeta::core::JSON &schema,
   ///////////////////////////////////////////////////////////////////
 
   if (mode == Mode::FastValidation) {
-    postprocess(compiled_targets, effective_tweaks, uses_dynamic_scopes);
+    postprocess(compiled_targets, instruction_extra, effective_tweaks,
+                uses_dynamic_scopes);
   }
 
   ///////////////////////////////////////////////////////////////////
@@ -417,7 +420,8 @@ auto compile(const sourcemeta::core::JSON &schema,
   return {.dynamic = uses_dynamic_scopes,
           .track = track,
           .targets = std::move(compiled_targets),
-          .labels = std::move(labels_map)};
+          .labels = std::move(labels_map),
+          .extra = std::move(instruction_extra)};
 }
 
 auto compile(const sourcemeta::core::JSON &schema,

src/compiler/compile_helpers.h

@@ -78,16 +78,19 @@ inline auto make_with_resource(const InstructionIndex type,
           ? to_pointer(dynamic_context.base_schema_location)
           : to_pointer(dynamic_context.base_schema_location)
                 .concat({dynamic_context.keyword})};
+  const auto extra_index{context.extra.size()};
+  context.extra.push_back(
+      {.relative_schema_location = schema_location,
+       .keyword_location =
+           to_uri(schema_context.relative_pointer, schema_context.base)
+               .recompose(),
+       .schema_resource = schema_resource_id(context.resources, resource)});
   return {.type = type,
           .relative_instance_location =
               to_pointer(dynamic_context.base_instance_location),
           .value = value,
           .children = {},
-          .relative_schema_location = schema_location,
-          .keyword_location =
-              to_uri(schema_context.relative_pointer, schema_context.base)
-                  .recompose(),
-          .schema_resource = schema_resource_id(context.resources, resource)};
+          .extra_index = extra_index};
 }
 
 // Instantiate a value-oriented step
@@ -109,42 +112,47 @@ inline auto make(const InstructionIndex type, const Context &context,
           ? to_pointer(dynamic_context.base_schema_location)
           : to_pointer(dynamic_context.base_schema_location)
                 .concat({dynamic_context.keyword})};
+  const auto extra_index{context.extra.size()};
+  context.extra.push_back(
+      {.relative_schema_location = schema_location,
+       .keyword_location =
+           to_uri(schema_context.relative_pointer, schema_context.base)
+               .recompose(),
+       .schema_resource = schema_resource_id(context.resources,
+                                             schema_context.base.recompose())});
   return {.type = type,
           .relative_instance_location =
               to_pointer(dynamic_context.base_instance_location),
           .value = std::move(value),
           .children = std::move(children),
-          .relative_schema_location = schema_location,
-          .keyword_location =
-              to_uri(schema_context.relative_pointer, schema_context.base)
-                  .recompose(),
-          .schema_resource = schema_resource_id(
-              context.resources, schema_context.base.recompose())};
+          .extra_index = extra_index};
 }
 
-inline auto unroll(const Instruction &step,
+inline auto unroll(const Context &context, const Instruction &step,
                    const sourcemeta::core::WeakPointer &base_instance_location =
                        sourcemeta::core::empty_weak_pointer) -> Instruction {
+  auto source_extra{context.extra[step.extra_index]};
+  const auto extra_index{context.extra.size()};
+  context.extra.push_back(std::move(source_extra));
   return {.type = step.type,
           .relative_instance_location =
               to_pointer(base_instance_location)
                   .concat(step.relative_instance_location),
           .value = step.value,
           .children = {},
-          .relative_schema_location = step.relative_schema_location,
-          .keyword_location = step.keyword_location,
-          .schema_resource = step.schema_resource};
+          .extra_index = extra_index};
 }
 
-inline auto rephrase(const InstructionIndex type, const Instruction &step)
-    -> Instruction {
+inline auto rephrase(const Context &context, const InstructionIndex type,
+                     const Instruction &step) -> Instruction {
+  auto source_extra{context.extra[step.extra_index]};
+  const auto extra_index{context.extra.size()};
+  context.extra.push_back(std::move(source_extra));
   return {.type = type,
           .relative_instance_location = step.relative_instance_location,
           .value = step.value,
           .children = {},
-          .relative_schema_location = step.relative_schema_location,
-          .keyword_location = step.keyword_location,
-          .schema_resource = step.schema_resource};
+          .extra_index = extra_index};
 }
 
 inline auto

src/compiler/compile_json.cc

@@ -6,6 +6,7 @@
 
 namespace {
 auto to_json(const sourcemeta::blaze::Instruction &instruction,
+             const std::vector<sourcemeta::blaze::InstructionExtra> &extra,
              std::vector<sourcemeta::core::JSON::String> &resources)
     -> sourcemeta::core::JSON {
   // Note that we purposely avoid objects to help consumers avoid potentially
@@ -16,29 +17,29 @@ auto to_json(const sourcemeta::blaze::Instruction &instruction,
   // is not meant to be human-readable anyway
   result.push_back(sourcemeta::core::to_json(instruction.type));
 
-  result.push_back(
-      sourcemeta::core::to_json(instruction.relative_schema_location));
+  const auto &meta{extra[instruction.extra_index]};
+  result.push_back(sourcemeta::core::to_json(meta.relative_schema_location));
   result.push_back(
       sourcemeta::core::to_json(instruction.relative_instance_location));
 
-  const auto match{instruction.keyword_location.find('#')};
-  if (instruction.schema_resource > 0 && match != std::string::npos) {
-    if (resources.size() < instruction.schema_resource) {
-      resources.resize(instruction.schema_resource);
+  const auto match{meta.keyword_location.find('#')};
+  if (meta.schema_resource > 0 && match != std::string::npos) {
+    if (resources.size() < meta.schema_resource) {
+      resources.resize(meta.schema_resource);
     }
 
-    if (resources[instruction.schema_resource - 1].empty()) {
-      resources[instruction.schema_resource - 1] =
-          instruction.keyword_location.substr(0, match);
+    if (resources[meta.schema_resource - 1].empty()) {
+      resources[meta.schema_resource - 1] =
+          meta.keyword_location.substr(0, match);
     }
 
     result.push_back(
-        sourcemeta::core::JSON{instruction.keyword_location.substr(match)});
+        sourcemeta::core::JSON{meta.keyword_location.substr(match)});
   } else {
-    result.push_back(sourcemeta::core::to_json(instruction.keyword_location));
+    result.push_back(sourcemeta::core::to_json(meta.keyword_location));
   }
 
-  result.push_back(sourcemeta::core::to_json(instruction.schema_resource));
+  result.push_back(sourcemeta::core::to_json(meta.schema_resource));
 
   // Note that we purposely avoid objects to help consumers avoid potentially
   // expensive hash-map or flat-map lookups when parsing back
@@ -59,8 +60,8 @@ auto to_json(const sourcemeta::blaze::Instruction &instruction,
   if (!instruction.children.empty()) {
     auto children_json{sourcemeta::core::JSON::make_array()};
     result.push_back(sourcemeta::core::to_json(
-        instruction.children, [&resources](const auto &subinstruction) {
-          return to_json(subinstruction, resources);
+        instruction.children, [&extra, &resources](const auto &subinstruction) {
+          return to_json(subinstruction, extra, resources);
         }));
   }
 
@@ -81,8 +82,8 @@ auto to_json(const Template &schema_template) -> sourcemeta::core::JSON {
   auto targets{sourcemeta::core::JSON::make_array()};
   for (const auto &target : schema_template.targets) {
     targets.push_back(sourcemeta::core::to_json(
-        target, [&resources](const auto &instruction) {
-          return ::to_json(instruction, resources);
+        target, [&schema_template, &resources](const auto &instruction) {
+          return ::to_json(instruction, schema_template.extra, resources);
         }));
   }
 

src/compiler/default_compiler_draft4.h

@@ -27,9 +27,10 @@ static auto parse_regex(const std::string &pattern,
 }
 
 static auto
-relative_schema_location_size(const sourcemeta::blaze::Instruction &step)
+relative_schema_location_size(const sourcemeta::blaze::Context &context,
+                              const sourcemeta::blaze::Instruction &step)
     -> std::size_t {
-  return step.relative_schema_location.size();
+  return context.extra[step.extra_index].relative_schema_location.size();
 }
 
 static auto
@@ -103,7 +104,8 @@ compile_properties(const sourcemeta::blaze::Context &context,
   // we prefer to evaluate smaller subschemas first, in the hope of failing
   // earlier without spending a lot of time on other subschemas
   if (context.tweaks.properties_reorder) {
-    std::ranges::sort(properties, [](const auto &left, const auto &right) {
+    std::ranges::sort(properties, [&context](const auto &left,
+                                             const auto &right) {
       const auto left_size{recursive_template_size(left.second)};
       const auto right_size{recursive_template_size(right.second)};
       if (left_size == right_size) {
@@ -118,8 +120,9 @@ compile_properties(const sourcemeta::blaze::Context &context,
           // If both options have a direct enumeration, we choose
           // the one with the shorter relative schema location
           return relative_schema_location_size(
-                     left.second.at(left_direct_enumeration.value())) <
+                     context, left.second.at(left_direct_enumeration.value())) <
                  relative_schema_location_size(
+                     context,
                      right.second.at(right_direct_enumeration.value()));
         } else if (left_direct_enumeration.has_value()) {
           return true;
@@ -994,39 +997,45 @@ auto compiler_draft4_applicator_properties_with_options(
     if (context.mode == Mode::FastValidation && track_evaluation &&
         substeps.size() == 1 &&
         substeps.front().type == InstructionIndex::AssertionTypeStrict) {
-      children.push_back(rephrase(sourcemeta::blaze::InstructionIndex::
+      children.push_back(rephrase(context,
+                                  sourcemeta::blaze::InstructionIndex::
                                       AssertionPropertyTypeStrictEvaluate,
                                   substeps.front()));
     } else if (context.mode == Mode::FastValidation && track_evaluation &&
                substeps.size() == 1 &&
                substeps.front().type == InstructionIndex::AssertionType) {
       children.push_back(rephrase(
+          context,
           sourcemeta::blaze::InstructionIndex::AssertionPropertyTypeEvaluate,
           substeps.front()));
     } else if (context.mode == Mode::FastValidation && track_evaluation &&
                substeps.size() == 1 &&
                substeps.front().type ==
                    InstructionIndex::AssertionTypeStrictAny) {
-      children.push_back(rephrase(sourcemeta::blaze::InstructionIndex::
+      children.push_back(rephrase(context,
+                                  sourcemeta::blaze::InstructionIndex::
                                       AssertionPropertyTypeStrictAnyEvaluate,
                                   substeps.front()));
 
       // NOLINTBEGIN(bugprone-branch-clone)
     } else if (context.mode == Mode::FastValidation && substeps.size() == 1 &&
                substeps.front().type ==
                    InstructionIndex::AssertionPropertyTypeStrict) {
-      children.push_back(unroll(
-          substeps.front(), effective_dynamic_context.base_instance_location));
+      children.push_back(
+          unroll(context, substeps.front(),
+                 effective_dynamic_context.base_instance_location));
     } else if (context.mode == Mode::FastValidation && substeps.size() == 1 &&
                substeps.front().type ==
                    InstructionIndex::AssertionPropertyType) {
-      children.push_back(unroll(
-          substeps.front(), effective_dynamic_context.base_instance_location));
+      children.push_back(
+          unroll(context, substeps.front(),
+                 effective_dynamic_context.base_instance_location));
     } else if (context.mode == Mode::FastValidation && substeps.size() == 1 &&
                substeps.front().type ==
                    InstructionIndex::AssertionPropertyTypeStrictAny) {
-      children.push_back(unroll(
-          substeps.front(), effective_dynamic_context.base_instance_location));
+      children.push_back(
+          unroll(context, substeps.front(),
+                 effective_dynamic_context.base_instance_location));
       // NOLINTEND(bugprone-branch-clone)
 
     } else {
@@ -1608,26 +1617,22 @@ auto compiler_draft4_applicator_items_with_options(
                           context, schema_context, dynamic_context, ValueNone{},
                           std::move(children))};
         if (std::get<ValueTypedHashes>(value_copy).second.first.size() == 3) {
-          return {Instruction{
-              .type = sourcemeta::blaze::InstructionIndex::
-                  LoopItemsPropertiesExactlyTypeStrictHash3,
-              .relative_instance_location = current.relative_instance_location,
-              .value = std::move(value_copy),
-              .children = {},
-              .relative_schema_location = current.relative_schema_location,
-              .keyword_location = current.keyword_location,
-              .schema_resource = current.schema_resource}};
+          return {Instruction{.type = sourcemeta::blaze::InstructionIndex::
+                                  LoopItemsPropertiesExactlyTypeStrictHash3,
+                              .relative_instance_location =
+                                  current.relative_instance_location,
+                              .value = std::move(value_copy),
+                              .children = {},
+                              .extra_index = current.extra_index}};
         }
 
-        return {Instruction{
-            .type = sourcemeta::blaze::InstructionIndex::
-                LoopItemsPropertiesExactlyTypeStrictHash,
-            .relative_instance_location = current.relative_instance_location,
-            .value = std::move(value_copy),
-            .children = {},
-            .relative_schema_location = current.relative_schema_location,
-            .keyword_location = current.keyword_location,
-            .schema_resource = current.schema_resource}};
+        return {Instruction{.type = sourcemeta::blaze::InstructionIndex::
+                                LoopItemsPropertiesExactlyTypeStrictHash,
+                            .relative_instance_location =
+                                current.relative_instance_location,
+                            .value = std::move(value_copy),
+                            .children = {},
+                            .extra_index = current.extra_index}};
       }
     }
 

src/compiler/include/sourcemeta/blaze/compiler.h

@@ -127,6 +127,8 @@ struct Context {
       std::tuple<sourcemeta::core::SchemaReferenceType, std::string_view, bool>,
       std::pair<std::size_t, const sourcemeta::core::WeakPointer *>>
       targets;
+  /// Accumulator for instruction extra data during compilation
+  std::vector<InstructionExtra> &extra;
   // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
 };