ibex 0.1.0 → 0.2.0

data/schema/runtime-event-v1.schema.json

@@ -0,0 +1,308 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/ibex/main/schema/runtime-event-v1.schema.json",
+  "title": "Ibex runtime event v1",
+  "type": "object",
+  "required": [
+    "ibex_runtime_event",
+    "schema_version",
+    "sequence",
+    "event",
+    "data"
+  ],
+  "properties": {
+    "ibex_runtime_event": { "const": "runtime-event" },
+    "schema_version": { "const": 1 },
+    "sequence": { "type": "integer", "minimum": 1 },
+    "event": {
+      "enum": [
+        "start",
+        "shift",
+        "reduce",
+        "error",
+        "recover",
+        "discard",
+        "accept",
+        "reject",
+        "cst_built",
+        "cst_fallback",
+        "cst_reuse"
+      ]
+    },
+    "data": { "type": "object", "maxProperties": 16 }
+  },
+  "additionalProperties": false,
+  "oneOf": [
+    {
+      "properties": {
+        "event": { "const": "start" },
+        "data": { "$ref": "#/$defs/start" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "shift" },
+        "data": { "$ref": "#/$defs/shift" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "reduce" },
+        "data": { "$ref": "#/$defs/reduce" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "error" },
+        "data": { "$ref": "#/$defs/error" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "recover" },
+        "data": { "$ref": "#/$defs/recover" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "discard" },
+        "data": { "$ref": "#/$defs/discard" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "accept" },
+        "data": { "$ref": "#/$defs/accept" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "reject" },
+        "data": { "$ref": "#/$defs/reject" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "cst_built" },
+        "data": { "$ref": "#/$defs/cst_built" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "cst_fallback" },
+        "data": { "$ref": "#/$defs/cst_fallback" }
+      }
+    },
+    {
+      "properties": {
+        "event": { "const": "cst_reuse" },
+        "data": { "$ref": "#/$defs/cst_reuse" }
+      }
+    }
+  ],
+  "$defs": {
+    "summary": {
+      "oneOf": [
+        { "type": "null" },
+        { "type": "boolean" },
+        { "type": "number" },
+        { "type": "string", "maxLength": 256 },
+        {
+          "type": "array",
+          "maxItems": 17,
+          "items": { "$ref": "#/$defs/summary" }
+        },
+        {
+          "type": "object",
+          "maxProperties": 17,
+          "additionalProperties": { "$ref": "#/$defs/summary" }
+        }
+      ]
+    },
+    "location": {
+      "oneOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "properties": {
+            "file": { "$ref": "#/$defs/summary" },
+            "line": { "$ref": "#/$defs/summary" },
+            "column": { "$ref": "#/$defs/summary" },
+            "end_line": { "$ref": "#/$defs/summary" },
+            "end_column": { "$ref": "#/$defs/summary" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["unavailable"],
+          "properties": {
+            "unavailable": { "type": "string" }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "token_fields": {
+      "type": "object",
+      "required": ["state", "token_id", "token", "value", "location"],
+      "properties": {
+        "state": { "type": "integer" },
+        "token_id": { "type": ["integer", "null"] },
+        "token": { "$ref": "#/$defs/summary" },
+        "value": { "$ref": "#/$defs/summary" },
+        "location": { "$ref": "#/$defs/location" }
+      }
+    },
+    "start": {
+      "type": "object",
+      "required": [
+        "driver",
+        "initial_state",
+        "table_format_version",
+        "grammar_digest",
+        "state_count",
+        "production_count"
+      ],
+      "properties": {
+        "driver": { "enum": ["pull", "push"] },
+        "initial_state": { "type": "integer" },
+        "table_format_version": { "type": "integer" },
+        "grammar_digest": { "type": ["string", "null"] },
+        "state_count": { "type": ["integer", "null"] },
+        "production_count": { "type": ["integer", "null"] }
+      },
+      "additionalProperties": false
+    },
+    "shift": {
+      "allOf": [
+        { "$ref": "#/$defs/token_fields" },
+        {
+          "required": ["from_state"],
+          "properties": {
+            "from_state": { "type": "integer" }
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "reduce": {
+      "type": "object",
+      "required": [
+        "production_id",
+        "lhs",
+        "rhs_length",
+        "pre_state",
+        "post_state",
+        "goto_state",
+        "result",
+        "location"
+      ],
+      "properties": {
+        "production_id": { "type": "integer" },
+        "lhs": { "type": "integer" },
+        "rhs_length": { "type": "integer", "minimum": 0 },
+        "pre_state": { "type": "integer" },
+        "post_state": { "type": "integer" },
+        "goto_state": { "type": "integer" },
+        "result": { "$ref": "#/$defs/summary" },
+        "location": { "$ref": "#/$defs/location" }
+      },
+      "additionalProperties": false
+    },
+    "error": {
+      "allOf": [
+        { "$ref": "#/$defs/token_fields" },
+        {
+          "required": ["reason"],
+          "properties": {
+            "reason": { "enum": ["syntax", "semantic"] }
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "recover": {
+      "allOf": [
+        { "$ref": "#/$defs/token_fields" },
+        {
+          "required": ["from_state", "reason"],
+          "properties": {
+            "from_state": { "type": "integer" },
+            "reason": { "enum": ["syntax", "semantic"] }
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "discard": {
+      "allOf": [
+        { "$ref": "#/$defs/token_fields" },
+        {
+          "required": ["reason"],
+          "properties": {
+            "reason": { "const": "recovery" }
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "accept": {
+      "type": "object",
+      "required": ["state", "result", "reason"],
+      "properties": {
+        "state": { "type": "integer" },
+        "result": { "$ref": "#/$defs/summary" },
+        "reason": { "enum": ["table", "semantic"] }
+      },
+      "additionalProperties": false
+    },
+    "reject": {
+      "allOf": [
+        { "$ref": "#/$defs/token_fields" },
+        {
+          "required": ["reason"],
+          "properties": {
+            "reason": {
+              "enum": ["eof_during_recovery", "no_recovery_state"]
+            }
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "cst_built": {
+      "type": "object",
+      "required": ["descendant_count", "full_width", "contains_error"],
+      "properties": {
+        "descendant_count": { "type": "integer", "minimum": 1 },
+        "full_width": { "type": "integer", "minimum": 0 },
+        "contains_error": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "cst_fallback": {
+      "type": "object",
+      "required": ["reason", "limit", "observed"],
+      "properties": {
+        "reason": {
+          "enum": ["memo_budget", "decomposition_budget", "memo_mismatch", "lexical_error"]
+        },
+        "limit": { "type": "integer", "minimum": 0 },
+        "observed": { "type": "integer", "minimum": 0 }
+      },
+      "additionalProperties": false
+    },
+    "cst_reuse": {
+      "type": "object",
+      "required": ["stage", "reused_tokens", "token_count", "reused_ratio"],
+      "properties": {
+        "stage": { "enum": ["lexical", "subtree"] },
+        "reused_tokens": { "type": "integer", "minimum": 0 },
+        "token_count": { "type": "integer", "minimum": 0 },
+        "reused_ratio": { "type": "number", "minimum": 0, "maximum": 1 }
+      },
+      "additionalProperties": false
+    }
+  }
+}

data/schema/table-simulation-v1.schema.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/ibex/main/schema/table-simulation-v1.schema.json",
+  "title": "Ibex table simulation v1",
+  "type": "object",
+  "required": [
+    "ibex_table_simulation",
+    "schema_version",
+    "grammar_digest",
+    "algorithm",
+    "tokens",
+    "status",
+    "steps"
+  ],
+  "properties": {
+    "ibex_table_simulation": { "const": "table-simulation" },
+    "schema_version": { "const": 1 },
+    "grammar_digest": {
+      "type": "string",
+      "pattern": "^sha256:[0-9a-f]{64}$"
+    },
+    "algorithm": { "enum": ["slr", "lalr1", "ielr1", "lr1"] },
+    "tokens": {
+      "type": "array",
+      "items": { "type": "string" },
+      "maxItems": 100000
+    },
+    "status": { "enum": ["accepted", "error"] },
+    "steps": {
+      "type": "array",
+      "maxItems": 100000,
+      "items": { "$ref": "#/$defs/step" }
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "step": {
+      "type": "object",
+      "required": [
+        "sequence",
+        "state",
+        "token_id",
+        "token",
+        "action",
+        "action_source",
+        "production_id",
+        "lhs",
+        "rhs_length",
+        "target_state",
+        "stack_depth_before",
+        "stack_depth_after"
+      ],
+      "properties": {
+        "sequence": { "type": "integer", "minimum": 1 },
+        "state": { "type": "integer", "minimum": 0 },
+        "token_id": { "type": "integer", "minimum": 0 },
+        "token": { "type": "string" },
+        "action": { "enum": ["shift", "reduce", "accept", "error"] },
+        "action_source": { "enum": ["explicit", "default", "implicit"] },
+        "production_id": { "type": ["integer", "null"], "minimum": 0 },
+        "lhs": { "type": ["string", "null"] },
+        "rhs_length": { "type": ["integer", "null"], "minimum": 0 },
+        "target_state": { "type": ["integer", "null"], "minimum": 0 },
+        "stack_depth_before": { "type": "integer", "minimum": 1 },
+        "stack_depth_after": { "type": "integer", "minimum": 1 }
+      },
+      "additionalProperties": false
+    }
+  }
+}

data/sig/ibex/artifact_set.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/artifact_set.rb with RBS::Inline
+
+module Ibex
+  # One fully rendered file in a parser generation.
+  class Artifact
+    attr_reader kind: Symbol
+
+    attr_reader path: String
+
+    attr_reader content: String
+
+    attr_reader mode: Integer?
+
+    # @rbs (kind: Symbol, path: String, content: String, ?mode: Integer?) -> void
+    def initialize: (kind: Symbol, path: String, content: String, ?mode: Integer?) -> void
+  end
+
+  # A generation's rendered outputs before any target is changed.
+  class ArtifactSet
+    include Enumerable[Artifact]
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs (kind: Symbol, path: String, content: String, ?mode: Integer?) -> Artifact
+    def add: (kind: Symbol, path: String, content: String, ?mode: Integer?) -> Artifact
+
+    def each: () -> Enumerator[Artifact, ArtifactSet]
+            | () { (Artifact) -> void } -> ArtifactSet
+
+    # @rbs () -> Array[Artifact]
+    def to_a: () -> Array[Artifact]
+
+    # @rbs () -> bool
+    def empty?: () -> bool
+  end
+end

data/sig/ibex/cli/ambiguity.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/ibex/cli/ambiguity.rb with RBS::Inline
+
+module Ibex
+  # Bounded grammar ambiguity checking for CI and human inspection.
+  module CLIAmbiguity
+    private def print_help: (OptionParser) -> Integer
+
+    private def input_path: (Array[String]) -> String
+
+    private def positive_counterexample_limit: (Integer, String) -> Integer
+
+    private def normalize_grammar_path: (String) -> IR::Grammar
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_check_command: (Array[String] arguments) -> Integer
+
+    # @rbs () -> OptionParser
+    def ambiguity_option_parser: () -> OptionParser
+  end
+end

data/sig/ibex/cli/counterexample_options.rbs

@@ -3,6 +3,8 @@
 module Ibex
   # Counterexample report limits and their command-line validation.
   module CLICounterexampleOptions
+    @options: cli_options
+
     DEFAULTS: Hash[Symbol, Integer]
 
     private

data/sig/ibex/cli/coverage.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/cli/coverage.rb with RBS::Inline
+
+module Ibex
+  # CLI collection, merge, and threshold checks for runtime coverage.
+  module CLICoverage
+    private def same_file_target?: (String left, String right) -> bool
+
+    type coverage_output_options = { paths: Array[String], ?output: String }
+
+    type coverage_check_options = { paths: Array[String], min_states: Float, min_productions: Float }
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_collect: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_merge: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_check: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments, String command, String operands) -> coverage_output_options
+    def coverage_output_options: (Array[String] arguments, String command, String operands) -> coverage_output_options
+
+    # @rbs (Array[String] arguments) -> coverage_check_options
+    def coverage_check_options: (Array[String] arguments) -> coverage_check_options
+
+    # @rbs (Float value, String name) -> Float
+    def coverage_threshold: (Float value, String name) -> Float
+
+    # @rbs (Integer covered, Integer total) -> Float
+    def coverage_percentage: (Integer covered, Integer total) -> Float
+
+    # @rbs (Array[String] arguments, String command) -> String
+    def single_coverage_path: (Array[String] arguments, String command) -> String
+
+    # @rbs (Array[String] inputs, String? output) -> void
+    def reject_coverage_output_collision: (Array[String] inputs, String? output) -> void
+
+    # @rbs (Coverage::Report report, String? output) -> void
+    def write_coverage_report: (Coverage::Report report, String? output) -> void
+
+    # @rbs (String path, String source) -> void
+    def atomic_write_coverage: (String path, String source) -> void
+
+    # @rbs (String path) -> Integer
+    def coverage_file_mode: (String path) -> Integer
+  end
+end

data/sig/ibex/cli/debug.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/ibex/cli/debug.rb with RBS::Inline
+
+module Ibex
+  # Safe parser-table simulation subcommand.
+  module CLIDebug
+    type debug_options = { paths: Array[String], format: String, max_steps: Integer, max_stack: Integer }
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_debug_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> debug_options
+    def debug_options: (Array[String] arguments) -> debug_options
+
+    # @rbs (Integer value, String name) -> Integer
+    def positive_debug_budget: (Integer value, String name) -> Integer
+
+    # @rbs (TableSimulation::Simulator simulator, String format) -> TableSimulation::Result
+    def simulate_debug_input: (TableSimulation::Simulator simulator, String format) -> TableSimulation::Result
+
+    # @rbs (TableSimulation::Result result, String format, steps_written: bool) -> void
+    def write_debug_result: (TableSimulation::Result result, String format, steps_written: bool) -> void
+
+    # @rbs (Array[TableSimulation::Step] steps) -> void
+    def write_debug_steps: (Array[TableSimulation::Step] steps) -> void
+  end
+end

data/sig/ibex/cli/diagnostics.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/ibex/cli/diagnostics.rb with RBS::Inline
+
+module Ibex
+  # Batch frontend diagnostics subcommand.
+  module CLIDiagnostics
+    DIAGNOSTICS_SCHEMA_VERSION: Integer
+
+    DEFAULT_MAX_DIAGNOSTICS: Integer
+
+    type diagnostic_settings = { format: String, max_diagnostics: Integer, mode: Symbol, ?help: bool }
+
+    private def input_path: (Array[String]) -> String
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_diagnose_command: (Array[String] arguments) -> Integer
+
+    # Cross-file recovery is deliberately bounded to the first resolver error.
+    # @rbs (Frontend::ParseResult result, String path, Symbol mode) -> Frontend::ParseResult
+    def resolve_diagnostic_result: (Frontend::ParseResult result, String path, Symbol mode) -> Frontend::ParseResult
+
+    # @rbs (Ibex::Error error, String fallback_file) -> Frontend::Diagnostic
+    def resolution_diagnostic: (Ibex::Error error, String fallback_file) -> Frontend::Diagnostic
+
+    # @rbs (diagnostic_settings settings) -> OptionParser
+    def diagnostics_option_parser: (diagnostic_settings settings) -> OptionParser
+
+    # @rbs (String value) -> Integer
+    def positive_diagnostic_limit: (String value) -> Integer
+
+    # @rbs (Frontend::ParseResult result, format: String) -> void
+    def write_diagnostics: (Frontend::ParseResult result, format: String) -> void
+
+    # @rbs (Frontend::ParseResult result) -> Hash[String, untyped]
+    def diagnostics_document: (Frontend::ParseResult result) -> Hash[String, untyped]
+  end
+end

data/sig/ibex/cli/documentation.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/cli/documentation.rb with RBS::Inline
+
+module Ibex
+  # Generates standalone grammar documentation from the canonical include closure.
+  module CLIDocumentation
+    type documentation_settings = { format: String, mode: Symbol, ?output: String, ?help: bool }
+
+    private def input_path: (Array[String]) -> String
+
+    private def same_file_target?: (String left, String right) -> bool
+
+    private def atomic_write_ir: (String path, String source) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_documentation_command: (Array[String] arguments) -> Integer
+
+    # @rbs (String output, Array[String] grammar_files) -> void
+    def reject_documentation_output_collision: (String output, Array[String] grammar_files) -> void
+
+    # @rbs (documentation_settings settings) -> OptionParser
+    def documentation_option_parser: (documentation_settings settings) -> OptionParser
+  end
+end

data/sig/ibex/cli/error_messages.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/ibex/cli/error_messages.rb with RBS::Inline
+
+module Ibex
+  # CLI subcommand and generation-file handling for example-keyed errors.
+  module CLIErrorMessages
+    private def print_help: (OptionParser) -> Integer
+
+    private def input_path: (Array[String]) -> String
+
+    private def warning_categories: (String) -> Array[Symbol]
+
+    private def report_status: (String) -> void
+
+    private def handle_grammar_warnings: (IR::Grammar, String) -> void
+
+    private def build_automaton: (IR::Grammar, String) -> IR::Automaton
+
+    private def prepare_loaded_automaton: (IR::Automaton, String) -> void
+
+    private def default_output_path: (String, String) -> String
+
+    private def same_file_target?: (String, String) -> bool
+
+    private def normalize_grammar_path: (String) -> IR::Grammar
+
+    private def record_generation_input: (String, String) -> GenerationInput
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_error_messages_command: (Array[String] arguments) -> Integer
+
+    # @rbs () -> OptionParser
+    def error_messages_option_parser: () -> OptionParser
+
+    # @rbs (String input_path) -> IR::Automaton
+    def automaton_for_error_messages: (String input_path) -> IR::Automaton
+
+    # @rbs (String input_path) -> IR::Automaton
+    def automaton_from_ir_for_messages: (String input_path) -> IR::Automaton
+
+    # @rbs (IR::Automaton automaton, String input_path) -> void
+    def write_error_messages: (IR::Automaton automaton, String input_path) -> void
+
+    # @rbs () -> { max_tokens: Integer, max_configurations: Integer }
+    def error_message_search_limits: () -> { max_tokens: Integer, max_configurations: Integer }
+
+    # @rbs (Integer value, String option) -> Integer
+    def positive_messages_limit: (Integer value, String option) -> Integer
+
+    # @rbs (ErrorMessages::Update update) -> void
+    def write_error_message_update_report: (ErrorMessages::Update update) -> void
+
+    # @rbs (String path) -> Integer
+    def messages_file_mode: (String path) -> Integer
+  end
+end

data/sig/ibex/cli/explain.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/cli/explain.rb with RBS::Inline
+
+module Ibex
+  # Dedicated command-line view for selected parser conflicts.
+  module CLIExplain
+    private def print_help: (OptionParser) -> Integer
+
+    private def input_path: (Array[String]) -> String
+
+    private def positive_counterexample_limit: (Integer, String) -> Integer
+
+    private def normalize_grammar_path: (String) -> IR::Grammar
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_explain_command: (Array[String] arguments) -> Integer
+
+    # @rbs () -> OptionParser
+    def explain_option_parser: () -> OptionParser
+
+    # @rbs (OptionParser options) -> void
+    def add_explain_search_options: (OptionParser options) -> void
+  end
+end