Prototype a new LoopItemsIntegerBounded instruction

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

Author: jviotti

src/compiler/default_compiler_draft4.h

@@ -1474,6 +1474,71 @@ auto compiler_draft4_applicator_items_array(
   }
 }
 
+auto is_number_type_check(const Instruction &instruction) -> bool {
+  if (instruction.type == InstructionIndex::AssertionTypeStrictAny) {
+    const auto &value{std::get<ValueTypes>(instruction.value)};
+    return value.test(
+               std::to_underlying(sourcemeta::core::JSON::Type::Integer)) &&
+           value.test(std::to_underlying(sourcemeta::core::JSON::Type::Real));
+  }
+
+  if (instruction.type == InstructionIndex::AssertionTypeStrict) {
+    const auto &value{std::get<ValueType>(instruction.value)};
+    return value == sourcemeta::core::JSON::Type::Integer ||
+           value == sourcemeta::core::JSON::Type::Real;
+  }
+
+  if (instruction.type == InstructionIndex::AssertionType) {
+    const auto &value{std::get<ValueType>(instruction.value)};
+    return value == sourcemeta::core::JSON::Type::Integer ||
+           value == sourcemeta::core::JSON::Type::Real;
+  }
+
+  return false;
+}
+
+auto is_integer_bounded_pattern(const Instructions &children) -> bool {
+  if (children.size() != 3) {
+    return false;
+  }
+
+  bool has_type{false};
+  bool has_min{false};
+  bool has_max{false};
+  for (const auto &child : children) {
+    if (is_number_type_check(child)) {
+      has_type = true;
+    } else if (child.type == InstructionIndex::AssertionGreaterEqual) {
+      if (!std::get<ValueJSON>(child.value).is_integer()) {
+        return false;
+      }
+      has_min = true;
+    } else if (child.type == InstructionIndex::AssertionLessEqual) {
+      if (!std::get<ValueJSON>(child.value).is_integer()) {
+        return false;
+      }
+      has_max = true;
+    }
+  }
+
+  return has_type && has_min && has_max;
+}
+
+auto extract_integer_bounds(const Instructions &children)
+    -> ValueIntegerBounds {
+  std::int64_t minimum{0};
+  std::int64_t maximum{0};
+  for (const auto &child : children) {
+    if (child.type == InstructionIndex::AssertionGreaterEqual) {
+      minimum = std::get<ValueJSON>(child.value).to_integer();
+    } else if (child.type == InstructionIndex::AssertionLessEqual) {
+      maximum = std::get<ValueJSON>(child.value).to_integer();
+    }
+  }
+
+  return {minimum, maximum};
+}
+
 auto compiler_draft4_applicator_items_with_options(
     const Context &context, const SchemaContext &schema_context,
     const DynamicContext &dynamic_context, const bool annotate,
@@ -1539,6 +1604,13 @@ auto compiler_draft4_applicator_items_with_options(
       return {};
     }
 
+    if (context.mode == Mode::FastValidation && children.size() == 3 &&
+        is_integer_bounded_pattern(children)) {
+      return {make(sourcemeta::blaze::InstructionIndex::LoopItemsIntegerBounded,
+                   context, schema_context, dynamic_context,
+                   extract_integer_bounds(children))};
+    }
+
     if (context.mode == Mode::FastValidation && children.size() == 1) {
       if (children.front().type == InstructionIndex::AssertionTypeStrict) {
         return {make(sourcemeta::blaze::InstructionIndex::LoopItemsTypeStrict,
@@ -1614,6 +1686,15 @@ auto compiler_draft4_applicator_additionalitems_from_cursor(
   Instructions children;
 
   if (!subchildren.empty()) {
+    if (context.mode == Mode::FastValidation && cursor == 0 && !annotate &&
+        !track_evaluation && is_integer_bounded_pattern(subchildren)) {
+      children.push_back(
+          make(sourcemeta::blaze::InstructionIndex::LoopItemsIntegerBounded,
+               context, schema_context, dynamic_context,
+               extract_integer_bounds(subchildren)));
+      return children;
+    }
+
     children.push_back(make(sourcemeta::blaze::InstructionIndex::LoopItemsFrom,
                             context, schema_context, dynamic_context,
                             ValueUnsignedInteger{cursor},

src/compiler/default_compiler_draft6.h

@@ -107,7 +107,9 @@ auto compiler_draft6_validation_type(const Context &context,
                    LoopItemsPropertiesExactlyTypeStrictHash ||
            current.back().type ==
                sourcemeta::blaze::InstructionIndex::
-                   LoopItemsPropertiesExactlyTypeStrictHash3) &&
+                   LoopItemsPropertiesExactlyTypeStrictHash3 ||
+           current.back().type ==
+               sourcemeta::blaze::InstructionIndex::LoopItemsIntegerBounded) &&
           current.back().relative_instance_location ==
               to_pointer(dynamic_context.base_instance_location)) {
         return {};

src/evaluator/evaluator_describe.cc

@@ -775,6 +775,12 @@ auto describe(const bool valid, const Instruction &step,
     return message.str();
   }
 
+  if (step.type ==
+      sourcemeta::blaze::InstructionIndex::LoopItemsIntegerBounded) {
+    return "Every item in the array was expected to be a number within the "
+           "given range";
+  }
+
   if (step.type == sourcemeta::blaze::InstructionIndex::LoopPropertiesType) {
     std::ostringstream message;
     message << "The object properties were expected to be of type "

src/evaluator/evaluator_json.cc

@@ -40,6 +40,13 @@ auto value_from_json(const sourcemeta::core::JSON &wrapper)
     case 19: return sourcemeta::core::from_json<ValueTypedProperties>(value);
     case 20: return sourcemeta::core::from_json<ValueStringHashes>(value);
     case 21: return sourcemeta::core::from_json<ValueTypedHashes>(value);
+    case 22:
+      if (value.is_array() && value.array_size() == 2 &&
+          value.at(0).is_integer() && value.at(1).is_integer()) {
+        return ValueIntegerBounds{value.at(0).to_integer(),
+                                  value.at(1).to_integer()};
+      }
+      return std::nullopt;
     // clang-format on
     default:
       std::unreachable();

src/evaluator/include/sourcemeta/blaze/evaluator_dispatch.h

@@ -2207,6 +2207,35 @@ INSTRUCTION_HANDLER(LoopItemsPropertiesExactlyTypeStrictHash3) {
   EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
 }
 
+INSTRUCTION_HANDLER(LoopItemsIntegerBounded) {
+  EVALUATE_BEGIN_NON_STRING(LoopItemsIntegerBounded, target.is_array());
+  const auto value{assume_value_copy<ValueIntegerBounds>(instruction.value)};
+  result = true;
+  for (const auto &element : target.as_array()) {
+    if (!element.is_number()) [[unlikely]] {
+      result = false;
+      break;
+    }
+
+    if (element.is_integer()) {
+      const auto integer{element.to_integer()};
+      if (integer < value.first || integer > value.second) [[unlikely]] {
+        result = false;
+        break;
+      }
+    } else {
+      const auto real{element.as_real()};
+      if (real < static_cast<double>(value.first) ||
+          real > static_cast<double>(value.second)) [[unlikely]] {
+        result = false;
+        break;
+      }
+    }
+  }
+
+  EVALUATE_END(LoopItemsIntegerBounded);
+}
+
 INSTRUCTION_HANDLER(LoopContains) {
   EVALUATE_BEGIN_NON_STRING(LoopContains, target.is_array());
   assert(!instruction.children.empty());
@@ -2277,7 +2306,7 @@ using DispatchHandler = bool (*)(
 template <bool Track, bool Dynamic, bool HasCallback>
 // Must have same order as InstructionIndex
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
-static constexpr DispatchHandler<Track, Dynamic, HasCallback> handlers[95] = {
+static constexpr DispatchHandler<Track, Dynamic, HasCallback> handlers[93] = {
     AssertionFail,
     AssertionDefines,
     AssertionDefinesStrict,
@@ -2362,6 +2391,7 @@ static constexpr DispatchHandler<Track, Dynamic, HasCallback> handlers[95] = {
     LoopItemsTypeStrictAny,
     LoopItemsPropertiesExactlyTypeStrictHash,
     LoopItemsPropertiesExactlyTypeStrictHash3,
+    LoopItemsIntegerBounded,
     LoopContains,
     ControlGroup,
     ControlGroupWhenDefines,

src/evaluator/include/sourcemeta/blaze/evaluator_instruction.h

@@ -104,6 +104,7 @@ enum class InstructionIndex : std::uint8_t {
   LoopItemsTypeStrictAny,
   LoopItemsPropertiesExactlyTypeStrictHash,
   LoopItemsPropertiesExactlyTypeStrictHash3,
+  LoopItemsIntegerBounded,
   LoopContains,
   ControlGroup,
   ControlGroupWhenDefines,
@@ -201,6 +202,7 @@ constexpr std::string_view InstructionNames[] = {
     "LoopItemsTypeStrictAny",
     "LoopItemsPropertiesExactlyTypeStrictHash",
     "LoopItemsPropertiesExactlyTypeStrictHash3",
+    "LoopItemsIntegerBounded",
     "LoopContains",
     "ControlGroup",
     "ControlGroupWhenDefines",

src/evaluator/include/sourcemeta/blaze/evaluator_value.h

@@ -155,14 +155,19 @@ using ValueStringHashes =
 /// Represents a compiler step types property hashes value
 using ValueTypedHashes = std::pair<ValueType, ValueStringHashes>;
 
+/// @ingroup evaluator
+/// Represents integer bounds with minimum and maximum
+using ValueIntegerBounds = std::pair<std::int64_t, std::int64_t>;
+
 /// @ingroup evaluator
 using Value =
     std::variant<ValueNone, ValueJSON, ValueSet, ValueString, ValueProperty,
                  ValueStrings, ValueStringSet, ValueTypes, ValueType,
                  ValueRegex, ValueUnsignedInteger, ValueRange, ValueBoolean,
                  ValueNamedIndexes, ValueStringType, ValueStringMap,
                  ValuePropertyFilter, ValueIndexPair, ValuePointer,
-                 ValueTypedProperties, ValueStringHashes, ValueTypedHashes>;
+                 ValueTypedProperties, ValueStringHashes, ValueTypedHashes,
+                 ValueIntegerBounds>;
 
 } // namespace sourcemeta::blaze