ibex 0.2.0 → 0.3.0

data/lib/ibex/table_artifact/validator/metadata.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Ibex
+  module TableArtifact
+    class MetadataValidator
+      include ValidationSupport
+
+      # @rbs (Hash[String, ValidationSupport::json_value] payload, symbols: Array[Hash[String, ValidationSupport::json_value]],
+      #   productions: Array[Hash[String, ValidationSupport::json_value]]) -> void
+      def initialize(payload, symbols:, productions:)
+        @payload = payload
+        @symbols = symbols
+        @productions = productions
+        @terminal_ids = ids_for_kind(symbols, "terminal")
+        @nonterminal_ids = ids_for_kind(symbols, "nonterminal")
+      end
+
+      # @rbs () -> void
+      def validate!
+        validate_semantic_actions(@payload.fetch("semantic_actions"))
+        validate_recovery(@payload.fetch("recovery"))
+        validate_cst(@payload.fetch("cst"))
+      end
+
+      private
+
+      # @rbs (Array[Hash[String, ValidationSupport::json_value]] symbols, String kind) -> Set[Integer]
+      def ids_for_kind(symbols, kind)
+        symbols.filter_map do |symbol|
+          next unless symbol.fetch("kind") == kind
+
+          symbol.fetch("id") #: Integer
+        end.to_set
+      end
+
+      # @rbs (ValidationSupport::json_value data) -> void
+      def validate_semantic_actions(data)
+        path = "$.payload.semantic_actions"
+        data = record(data, path, %w[binding verified slots])
+        enum(data.fetch("binding"), "#{path}.binding", ["opaque-wrapper-production-id-v1"])
+        invalid("#{path}.verified", "must be false") unless boolean(data.fetch("verified"), "#{path}.verified") == false
+        slots = integer_ids(data.fetch("slots"), "#{path}.slots")
+        expected = @productions.filter_map { |production| production.fetch("action_slot") }
+        invalid("#{path}.slots", "must match production action slots") unless slots == expected
+      end
+
+      # @rbs (ValidationSupport::json_value data) -> void
+      def validate_recovery(data)
+        path = "$.payload.recovery"
+        data = record(data, path, %w[sync_token_ids on_error_reduce_symbol_ids])
+        sync_ids = integer_ids(data.fetch("sync_token_ids"), "#{path}.sync_token_ids", sorted: false)
+        sync_ids.each do |id|
+          invalid("#{path}.sync_token_ids", "must reference terminals") unless @terminal_ids.include?(id)
+        end
+        groups = array(data.fetch("on_error_reduce_symbol_ids"), "#{path}.on_error_reduce_symbol_ids")
+        groups.each_with_index do |group, index|
+          ids = integer_ids(group, "#{path}.on_error_reduce_symbol_ids[#{index}]", sorted: false)
+          invalid("#{path}.on_error_reduce_symbol_ids[#{index}]", "must not be empty") if ids.empty?
+          ids.each do |id|
+            invalid("#{path}.on_error_reduce_symbol_ids[#{index}]", "must reference nonterminals") unless
+              @nonterminal_ids.include?(id)
+          end
+        end
+      end
+
+      # @rbs (ValidationSupport::json_value data) -> void
+      def validate_cst(data)
+        return if data.nil?
+
+        path = "$.payload.cst"
+        data = record(data, path, %w[version trivia_policy kinds slots])
+        invalid("#{path}.version", "must be 1") unless integer(data.fetch("version"), "#{path}.version") == 1
+        enum(data.fetch("trivia_policy"), "#{path}.trivia_policy", %w[leading balanced drop])
+        kind_count = validate_cst_kinds(data.fetch("kinds"), "#{path}.kinds")
+        validate_cst_slots(data.fetch("slots"), "#{path}.slots", kind_count)
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path) -> Integer
+      def validate_cst_kinds(data, path)
+        keys = %w[names terminal_range nonterminal_range named named_nonterminals trivia synthetic]
+        data = record(data, path, keys)
+        names = array(data.fetch("names"), "#{path}.names") #: Array[String]
+        names.each_with_index { |name, index| string(name, "#{path}.names[#{index}]") }
+        validate_range(data.fetch("terminal_range"), "#{path}.terminal_range", names.length)
+        validate_range(data.fetch("nonterminal_range"), "#{path}.nonterminal_range", names.length)
+        %w[named trivia synthetic].each { |key| validate_named_kinds(data.fetch(key), "#{path}.#{key}", names) }
+        validate_named_nonterminals(data.fetch("named_nonterminals"), "#{path}.named_nonterminals", names.length)
+        names.length
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path, Integer limit) -> void
+      def validate_range(data, path, limit)
+        values = array(data, path)
+        invalid(path, "must contain two bounds") unless values.length == 2
+        start = integer(values.fetch(0), "#{path}[0]", minimum: 0)
+        finish = integer(values.fetch(1), "#{path}[1]", minimum: 0)
+        invalid(path, "must be an ordered half-open range") unless finish.between?(start, limit)
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path, Array[String] names) -> void
+      def validate_named_kinds(data, path, names)
+        entries = array(data, path)
+        ids = entries.map.with_index do |entry, index|
+          entry_path = "#{path}[#{index}]"
+          entry = record(entry, entry_path, %w[name id])
+          name = string(entry.fetch("name"), "#{entry_path}.name")
+          id = integer(entry.fetch("id"), "#{entry_path}.id", minimum: 0)
+          invalid(entry_path, "does not match the kind name table") unless names[id] == name
+          id
+        end
+        sorted_unique!(ids, path)
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path, Integer kind_count) -> void
+      def validate_named_nonterminals(data, path, kind_count)
+        pairs = array(data, path).map.with_index do |entry, index|
+          entry_path = "#{path}[#{index}]"
+          entry = record(entry, entry_path, %w[kind_id symbol_id])
+          kind_id = integer(entry.fetch("kind_id"), "#{entry_path}.kind_id", minimum: 0)
+          invalid("#{entry_path}.kind_id", "references a missing kind") unless kind_id < kind_count
+          symbol_id = integer(entry.fetch("symbol_id"), "#{entry_path}.symbol_id", minimum: 0)
+          invalid("#{entry_path}.symbol_id", "must reference a nonterminal") unless @nonterminal_ids.include?(symbol_id)
+          [kind_id, symbol_id]
+        end
+        return if pairs == pairs.sort && pairs.map(&:first).uniq.length == pairs.length
+
+        invalid(path,
+                "must be sorted with unique kind ids")
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path, Integer kind_count) -> void
+      def validate_cst_slots(data, path, kind_count)
+        production_ids = array(data, path).map.with_index do |slot, index|
+          slot_path = "#{path}[#{index}]"
+          slot = record(slot, slot_path, %w[production_id node_kind_id node_name fields])
+          production_id = integer(slot.fetch("production_id"), "#{slot_path}.production_id", minimum: 0)
+          unless production_id < @productions.length
+            invalid("#{slot_path}.production_id",
+                    "references a missing production")
+          end
+          node_kind = integer(slot.fetch("node_kind_id"), "#{slot_path}.node_kind_id", minimum: 0)
+          invalid("#{slot_path}.node_kind_id", "references a missing kind") unless node_kind < kind_count
+          string(slot.fetch("node_name"), "#{slot_path}.node_name")
+          validate_fields(slot.fetch("fields"), "#{slot_path}.fields", @productions.fetch(production_id))
+          production_id
+        end
+        sorted_unique!(production_ids, path)
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path,
+      #   Hash[String, ValidationSupport::json_value] production) -> void
+      def validate_fields(data, path, production)
+        names = array(data, path).map.with_index do |field, index|
+          field_path = "#{path}[#{index}]"
+          field = record(field, field_path, %w[name index extraction])
+          name = string(field.fetch("name"), "#{field_path}.name")
+          field_index = integer(field.fetch("index"), "#{field_path}.index", minimum: 0)
+          rhs_length = production.fetch("rhs_length") #: Integer
+          invalid("#{field_path}.index", "exceeds production rhs") unless field_index < rhs_length
+          extraction = field.fetch("extraction")
+          enum(extraction, "#{field_path}.extraction", %w[repetition separated_list]) unless extraction.nil?
+          name
+        end
+        invalid(path, "must have unique field names") unless names.uniq.length == names.length
+      end
+
+      # @rbs (ValidationSupport::json_value data, String path, ?sorted: bool) -> Array[Integer]
+      def integer_ids(data, path, sorted: true)
+        ids = array(data, path).map.with_index { |id, index| integer(id, "#{path}[#{index}]", minimum: 0) }
+        if sorted
+          sorted_unique!(ids, path)
+        else
+          invalid(path, "must contain unique ids") unless ids.uniq.length == ids.length
+        end
+        ids
+      end
+    end
+  end
+end

data/lib/ibex/table_artifact/validator/support.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ibex
+  module TableArtifact
+    module ValidationSupport
+      # @rbs!
+      #   type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
+      DIGEST = /\Asha256:[0-9a-f]{64}\z/ #: Regexp
+
+      private
+
+      # @rbs (json_value value, String path, Array[String] keys) -> Hash[String, json_value]
+      def record(value, path, keys)
+        invalid(path, "must be an object") unless value.is_a?(Hash)
+        invalid(path, "must use string keys") unless value.keys.all?(String)
+
+        missing = keys - value.keys
+        extra = value.keys - keys
+        invalid(path, "is missing #{missing.join(', ')}") unless missing.empty?
+        invalid(path, "contains unknown fields #{extra.join(', ')}") unless extra.empty?
+        value #: Hash[String, json_value]
+      end
+
+      # @rbs (json_value value, String path) -> Array[json_value]
+      def array(value, path)
+        invalid(path, "must be an array") unless value.is_a?(Array)
+        value #: Array[json_value]
+      end
+
+      # @rbs (json_value value, String path, ?allow_empty: bool) -> String
+      def string(value, path, allow_empty: false)
+        invalid(path, "must be a string") unless value.is_a?(String)
+        invalid(path, "must not be empty") if !allow_empty && value.empty?
+        value #: String
+      end
+
+      # @rbs (json_value value, String path, ?minimum: Integer?) -> Integer
+      def integer(value, path, minimum: nil)
+        invalid(path, "must be an integer") unless value.is_a?(Integer)
+        invalid(path, "must be at least #{minimum}") if minimum && value < minimum
+        value #: Integer
+      end
+
+      # @rbs (json_value value, String path) -> bool
+      def boolean(value, path)
+        invalid(path, "must be true or false") unless [true, false].include?(value)
+        value #: bool
+      end
+
+      # @rbs [T] (T value, String path, Array[T] values) -> T
+      def enum(value, path, values)
+        invalid(path, "must be one of #{values.join(', ')}") unless values.include?(value)
+        value
+      end
+
+      # @rbs (json_value value, String path) -> String
+      def digest(value, path)
+        invalid(path, "must be a sha256 digest") unless value.is_a?(String) && DIGEST.match?(value)
+        value
+      end
+
+      # @rbs (json_value value, String path) -> String?
+      def nullable_string(value, path)
+        string(value, path, allow_empty: true) unless value.nil?
+        value #: String?
+      end
+
+      # @rbs (json_value value, String path, ?minimum: Integer?) -> Integer?
+      def nullable_integer(value, path, minimum: nil)
+        integer(value, path, minimum: minimum) unless value.nil?
+        value #: Integer?
+      end
+
+      # @rbs (Array[json_value] values, String path) -> void
+      def sorted_unique!(values, path)
+        invalid(path, "must be sorted and unique") unless values == values.sort.uniq
+      end
+
+      # @rbs (String path, String message) -> bot
+      def invalid(path, message)
+        raise ValidationError, "#{path} #{message}"
+      end
+    end
+  end
+end

data/lib/ibex/table_artifact/validator/tables.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Ibex
+  module TableArtifact
+    class TableValidator
+      include ValidationSupport
+
+      # @rbs!
+      #   private def integer_array: (ValidationSupport::json_value value, String path,
+      #     allow_nil: false, minimum: Integer?) -> Array[Integer]
+      #                            | (ValidationSupport::json_value value, String path,
+      #     allow_nil: true, minimum: Integer?) -> Array[Integer?]
+
+      # @rbs (Hash[String, ValidationSupport::json_value] data, state_count: Integer, production_count: Integer,
+      #   terminal_ids: Set[Integer], nonterminal_ids: Set[Integer], representation: String) -> void
+      def initialize(data, state_count:, production_count:, terminal_ids:, nonterminal_ids:, representation:)
+        @data = data
+        @state_count = state_count
+        @production_count = production_count
+        @terminal_ids = terminal_ids
+        @nonterminal_ids = nonterminal_ids
+        @representation = representation
+      end
+
+      # @rbs () -> void
+      def validate!
+        record(@data, "$.payload.tables", %w[actions gotos default_actions])
+        validate_actions(@data.fetch("actions"))
+        validate_gotos(@data.fetch("gotos"))
+        validate_defaults(@data.fetch("default_actions"))
+      end
+
+      private
+
+      # @rbs (ValidationSupport::json_value table) -> void
+      def validate_actions(table)
+        invalid("$.payload.tables.actions", "must be an object") unless table.is_a?(Hash)
+        table_data = table #: Hash[String, ValidationSupport::json_value]
+        encoding = table_data["encoding"]
+        expected = @representation == "compact" ? "signed-row-displacement-v1" : "signed-sparse-rows-v1"
+        invalid("$.payload.tables.actions.encoding", "does not match table representation") unless encoding == expected
+        case encoding
+        when "signed-sparse-rows-v1" then validate_sparse_actions(table_data)
+        when "signed-row-displacement-v1" then validate_compact_actions(table_data)
+        else invalid("$.payload.tables.actions.encoding", "is unsupported")
+        end
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table) -> void
+      def validate_sparse_actions(table)
+        record(table, "$.payload.tables.actions", %w[encoding rows])
+        rows = array(table.fetch("rows"), "$.payload.tables.actions.rows")
+        invalid("$.payload.tables.actions.rows", "must contain one row per state") unless rows.length == @state_count
+        rows.each_with_index do |row, state|
+          token_ids = array(row, "$.payload.tables.actions.rows[#{state}]").map.with_index do |cell, index|
+            path = "$.payload.tables.actions.rows[#{state}][#{index}]"
+            cell = record(cell, path, %w[token_id code])
+            token_id = integer(cell.fetch("token_id"), "#{path}.token_id", minimum: 0)
+            invalid("#{path}.token_id", "must reference a terminal") unless @terminal_ids.include?(token_id)
+            validate_token_action(cell.fetch("code"), token_id, "#{path}.code")
+            token_id
+          end
+          sorted_unique!(token_ids, "$.payload.tables.actions.rows[#{state}]")
+        end
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table) -> void
+      def validate_compact_actions(table)
+        keys = %w[encoding row_count column_count offsets codes checks]
+        record(table, "$.payload.tables.actions", keys)
+        enum(table.fetch("encoding"), "$.payload.tables.actions.encoding", ["signed-row-displacement-v1"])
+        validate_row_count(table, "$.payload.tables.actions")
+        column_count = nullable_integer(table.fetch("column_count"), "$.payload.tables.actions.column_count",
+                                        minimum: 1)
+        rows = validate_displacement(table, value_key: "codes", path: "$.payload.tables.actions") do |column, code,
+                                                                                                         cell_path|
+          invalid(cell_path, "column must reference a terminal") unless @terminal_ids.include?(column)
+          invalid(cell_path, "column exceeds column_count") if column_count && column >= column_count
+          validate_token_action(code, column, "#{cell_path}.code")
+        end
+        validate_canonical_displacement(
+          table, rows, value_key: "codes", width_key: "column_count", width: column_count, dense: false,
+                       path: "$.payload.tables.actions"
+        )
+      end
+
+      # @rbs (ValidationSupport::json_value table) -> void
+      def validate_gotos(table)
+        invalid("$.payload.tables.gotos", "must be an object") unless table.is_a?(Hash)
+        table_data = table #: Hash[String, ValidationSupport::json_value]
+        encoding = table_data["encoding"]
+        expected = @representation == "compact" ? "row-displacement-v1" : "sparse-rows-v1"
+        invalid("$.payload.tables.gotos.encoding", "does not match table representation") unless encoding == expected
+        case encoding
+        when "sparse-rows-v1" then validate_sparse_gotos(table_data)
+        when "row-displacement-v1" then validate_compact_gotos(table_data)
+        else invalid("$.payload.tables.gotos.encoding", "is unsupported")
+        end
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table) -> void
+      def validate_sparse_gotos(table)
+        record(table, "$.payload.tables.gotos", %w[encoding rows])
+        rows = array(table.fetch("rows"), "$.payload.tables.gotos.rows")
+        invalid("$.payload.tables.gotos.rows", "must contain one row per state") unless rows.length == @state_count
+        rows.each_with_index do |row, state|
+          symbol_ids = array(row, "$.payload.tables.gotos.rows[#{state}]").map.with_index do |cell, index|
+            path = "$.payload.tables.gotos.rows[#{state}][#{index}]"
+            cell = record(cell, path, %w[symbol_id state])
+            symbol_id = integer(cell.fetch("symbol_id"), "#{path}.symbol_id", minimum: 0)
+            invalid("#{path}.symbol_id", "must reference a nonterminal") unless @nonterminal_ids.include?(symbol_id)
+            validate_state(cell.fetch("state"), "#{path}.state")
+            symbol_id
+          end
+          sorted_unique!(symbol_ids, "$.payload.tables.gotos.rows[#{state}]")
+        end
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table) -> void
+      def validate_compact_gotos(table)
+        keys = %w[encoding row_count dense_width offsets values checks]
+        record(table, "$.payload.tables.gotos", keys)
+        enum(table.fetch("encoding"), "$.payload.tables.gotos.encoding", ["row-displacement-v1"])
+        validate_row_count(table, "$.payload.tables.gotos")
+        dense_width = nullable_integer(table.fetch("dense_width"), "$.payload.tables.gotos.dense_width", minimum: 1)
+        rows = validate_displacement(table, value_key: "values", path: "$.payload.tables.gotos") do |column, state,
+                                                                                                         cell_path|
+          invalid(cell_path, "column must reference a nonterminal") unless @nonterminal_ids.include?(column)
+          invalid(cell_path, "column exceeds dense_width") if dense_width && column >= dense_width
+          validate_state(state, "#{cell_path}.state")
+        end
+        validate_canonical_displacement(
+          table, rows, value_key: "values", width_key: "dense_width", width: dense_width, dense: true,
+                       path: "$.payload.tables.gotos"
+        )
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table, String path) -> void
+      def validate_row_count(table, path)
+        count = integer(table.fetch("row_count"), "#{path}.row_count", minimum: 1)
+        invalid("#{path}.row_count", "must equal state_count") unless count == @state_count
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table, value_key: String, path: String)
+      #   { (Integer, ValidationSupport::json_value, String) -> void } -> Array[Hash[Integer, ValidationSupport::json_value]]
+      def validate_displacement(table, value_key:, path:)
+        offsets = integer_array(table.fetch("offsets"), "#{path}.offsets", allow_nil: false, minimum: 0)
+        invalid("#{path}.offsets", "must contain one offset per state") unless offsets.length == @state_count
+        minimum = value_key == "codes" ? nil : 0
+        values = integer_array(table.fetch(value_key), "#{path}.#{value_key}", allow_nil: true, minimum: minimum)
+        checks = integer_array(table.fetch("checks"), "#{path}.checks", allow_nil: true, minimum: 0)
+        invalid(path, "#{value_key} and checks must have equal length") unless values.length == checks.length
+
+        rows = Array.new(@state_count) { {} } #: Array[Hash[Integer, ValidationSupport::json_value]]
+        checks.each_index do |index|
+          row = checks[index]
+          value = values[index]
+          invalid("#{path}[#{index}]", "value and check occupancy must match") unless row.nil? == value.nil?
+          next unless row
+
+          invalid("#{path}.checks[#{index}]", "references a missing state") unless row.between?(0, @state_count - 1)
+          column = index - offsets.fetch(row)
+          invalid("#{path}[#{index}]", "has a negative column") if column.negative?
+          yield(column, value, "#{path}[#{index}]")
+          rows.fetch(row)[column] = value
+        end
+        rows
+      end
+
+      # @rbs (Hash[String, ValidationSupport::json_value] table,
+      #   Array[Hash[Integer, ValidationSupport::json_value]] rows, value_key: String,
+      #   width_key: String, width: Integer?, dense: bool, path: String) -> void
+      def validate_canonical_displacement(table, rows, value_key:, width_key:, width:, dense:, path:)
+        canonical = Tables::Compact.build(rows, dense: dense)
+        expected = [canonical.offsets, canonical.values, canonical.checks]
+        actual = [table.fetch("offsets"), table.fetch(value_key), table.fetch("checks")]
+        invalid(path, "must use the canonical minimal row-displacement layout") unless actual == expected
+
+        expected_width = if width_key == "column_count"
+                           rows.flat_map(&:keys).max.to_i + 1
+                         else
+                           canonical.dense_width
+                         end
+        expected_width = nil if expected_width && (@state_count * expected_width) > Tables::Compact::DENSE_CELL_LIMIT
+        invalid("#{path}.#{width_key}", "does not match the canonical table width") unless width == expected_width
+      end
+
+      # @rbs skip
+      def integer_array(value, path, allow_nil:, minimum:)
+        array(value, path).map.with_index do |item, index|
+          next if allow_nil && item.nil?
+
+          integer(item, "#{path}[#{index}]", minimum: minimum)
+        end
+      end
+
+      # @rbs (ValidationSupport::json_value defaults) -> void
+      def validate_defaults(defaults)
+        values = array(defaults, "$.payload.tables.default_actions")
+        unless values.length == @state_count
+          invalid("$.payload.tables.default_actions",
+                  "must contain one entry per state")
+        end
+        values.each_with_index do |code, state|
+          next if code.nil?
+
+          path = "$.payload.tables.default_actions[#{state}]"
+          code = integer(code, path)
+          invalid(path, "must be an error or reduction") if code >= 0
+        end
+      end
+
+      # @rbs (ValidationSupport::json_value code, Integer token_id, String path) -> void
+      def validate_token_action(code, token_id, path)
+        code = integer(code, path)
+        invalid(path, "accept is only valid for $eof") if code.zero? && !token_id.zero?
+        invalid(path, "$eof cannot be shifted") if token_id.zero? && code.positive?
+        validate_action_code(code, path)
+      end
+
+      # @rbs (ValidationSupport::json_value code, String path) -> void
+      def validate_action_code(code, path)
+        code = integer(code, path)
+        return if [0, -1].include?(code)
+        return validate_state(code - 1, path) if code.positive?
+
+        production = -2 - code
+        invalid(path, "references a missing production") unless production.between?(0, @production_count - 1)
+      end
+
+      # @rbs (ValidationSupport::json_value state, String path) -> void
+      def validate_state(state, path)
+        state = integer(state, path, minimum: 0)
+        invalid(path, "references a missing state") unless state.between?(0, @state_count - 1)
+      end
+    end
+  end
+end