ibex 0.2.0 → 0.4.0

data/lib/ibex/codegen/report.rb

@@ -12,23 +12,25 @@ module Ibex
       #     Array[String] lines,
       #     IR::AutomatonState state,
       #     IR::Grammar grammar,
-      #     Array[IR::counterexample] examples,
+      #     Array[LALR::search_counterexample] examples,
       #     Hash[Integer, String] labels
       #   ) -> void
       #   private def self.append_state: (
       #     Array[String] lines,
       #     IR::AutomatonState state,
       #     IR::Grammar grammar,
-      #     Array[IR::counterexample] examples,
+      #     Array[LALR::search_counterexample] examples,
       #     Hash[Integer, String] labels
       #   ) -> void
-      #   private def append_counterexample: (Array[String] lines, IR::counterexample example, IR::Grammar grammar,
+      #   private def append_counterexample: (Array[String] lines, LALR::search_counterexample example,
+      #     IR::Grammar grammar,
       #     Hash[Integer, String] labels) -> void
-      #   private def self.append_counterexample: (Array[String] lines, IR::counterexample example, IR::Grammar grammar,
+      #   private def self.append_counterexample: (Array[String] lines, LALR::search_counterexample example,
+      #     IR::Grammar grammar,
       #     Hash[Integer, String] labels) -> void
-      #   private def append_tree: (Array[String] lines, untyped tree, String indentation, IR::Grammar grammar,
+      #   private def append_tree: (Array[String] lines, Object? tree, String indentation, IR::Grammar grammar,
       #     Hash[Integer, String] labels) -> void
-      #   private def self.append_tree: (Array[String] lines, untyped tree, String indentation, IR::Grammar grammar,
+      #   private def self.append_tree: (Array[String] lines, Object? tree, String indentation, IR::Grammar grammar,
       #     Hash[Integer, String] labels) -> void
       #   private def format_item: (IR::AutomatonItem item, IR::Grammar grammar, Hash[Integer, String] labels) -> String
       #   private def self.format_item: (IR::AutomatonItem item, IR::Grammar grammar,
@@ -37,14 +39,14 @@ module Ibex
       #   private def self.format_action: (IR::parser_action action) -> String
       #   private def symbol_name: (Hash[Integer, String] labels, Integer id) -> String
       #   private def self.symbol_name: (Hash[Integer, String] labels, Integer id) -> String
-      #   private def tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
-      #   private def self.tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
+      #   private def tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, Object? value) -> Object?
+      #   private def self.tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, Object? value) -> Object?
       #   private def display_conflict: (IR::conflict conflict, IR::Grammar grammar,
-      #     Hash[Integer, String] labels) -> Hash[Symbol, untyped]
+      #     Hash[Integer, String] labels) -> Hash[Symbol, Object?]
       #   private def self.display_conflict: (IR::conflict conflict, IR::Grammar grammar,
-      #     Hash[Integer, String] labels) -> Hash[Symbol, untyped]
-      #   private def format_value: (untyped value) -> String
-      #   private def self.format_value: (untyped value) -> String
+      #     Hash[Integer, String] labels) -> Hash[Symbol, Object?]
+      #   private def format_value: (Object? value) -> String
+      #   private def self.format_value: (Object? value) -> String
 
       # @rbs (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> String
       def render(automaton, max_tokens: LALR::Counterexample::DEFAULT_MAX_TOKENS,
@@ -88,10 +90,20 @@ module Ibex
 
       # @rbs skip
       def append_counterexample(lines, example, grammar, labels)
-        label = example[:unifying] ? "unifying counterexample" : "nonunifying witness"
+        label = if example[:unifying]
+                  "unifying counterexample"
+                elsif example[:inconclusive]
+                  "inconclusive reachability witness"
+                else
+                  "nonunifying witness"
+                end
         sentence = example[:sentence].map { |name| tree_label(grammar, labels, name) }
         sentence = sentence.dup.insert(example[:lookahead_index], "•").join(" ")
         lines << "  #{label}: #{sentence}"
+        if example[:inconclusive]
+          search = example.fetch(:search)
+          lines << "    search exhausted after #{search.fetch(:explored)} configurations; no classification was made"
+        end
         example[:interpretations].each do |interpretation|
           lines << "    #{interpretation[:kind]} derivation:"
           append_tree(lines, interpretation[:tree], "      ", grammar, labels)

data/lib/ibex/codegen/ruby.rb

@@ -24,58 +24,6 @@ module Ibex
       include RubyAST
       include RubySyntax
 
-      EMBEDDED_RUNTIME_SOURCES = %w[
-        ../runtime/version.rb
-        ../runtime/table_format.rb
-        ../runtime/location_span.rb
-        ../runtime/cst/kind.rb
-        ../runtime/cst/annotation.rb
-        ../runtime/cst/green/trivia.rb
-        ../runtime/cst/green/token.rb
-        ../runtime/cst/green/node.rb
-        ../runtime/cst/green/cache.rb
-        ../runtime/cst/green/builder.rb
-        ../runtime/cst/source_text.rb
-        ../runtime/cst/syntax_token.rb
-        ../runtime/cst/syntax_node.rb
-        ../runtime/cst/cursor.rb
-        ../runtime/cst/typed_node.rb
-        ../runtime/cst/parse_result.rb
-        ../runtime/cst/editing.rb
-        ../runtime/cst/text_edit.rb
-        ../runtime/cst/rewriter.rb
-        ../runtime/cst/editor.rb
-        ../runtime/cst/diff.rb
-        ../runtime/cst/serialized_tree.rb
-        ../runtime/cst/validator.rb
-        ../runtime/cst/serialize.rb
-        ../runtime/cst/incremental/token_memo.rb
-        ../runtime/cst/incremental/relexer.rb
-        ../runtime/cst/incremental/parse_memo.rb
-        ../runtime/cst/incremental/lexed_syntax.rb
-        ../runtime/cst/incremental/blender.rb
-        ../runtime/cst/incremental/session.rb
-        ../runtime/cst.rb
-        ../runtime/ast_data.rb
-        ../runtime/resource_limits.rb
-        ../runtime/event_sanitizer.rb
-        ../runtime/event.rb
-        ../runtime/observation.rb
-        ../runtime/repair.rb
-        ../runtime/repair_priority_queue.rb
-        ../runtime/repair_search.rb
-        ../runtime/parser_sync_recovery.rb
-        ../runtime/parser.rb
-        ../runtime/lexer_input.rb
-        ../runtime/generated_lexer.rb
-        ../runtime/jsonl_tracer.rb
-        ../runtime/event_jsonl_tracer.rb
-        ../tables/compact.rb
-        ../tables/compact_actions.rb
-        ../tables/compact_productions.rb
-      ].freeze #: Array[String]
-      private_constant :EMBEDDED_RUNTIME_SOURCES
-
       # @rbs @automaton: IR::Automaton
       # @rbs @grammar: IR::Grammar
       # @rbs @table_format: Symbol
@@ -100,6 +48,7 @@ module Ibex
                      cst_trivia: :leading, runtime_require: "ibex/runtime", error_messages: {})
         @automaton = automaton
         @grammar = automaton.grammar
+        reject_foreign_actions
         @table_format = table.to_sym
         @embedded = embedded
         @line_convert = line_convert
@@ -146,22 +95,37 @@ module Ibex
 
       private
 
+      # @rbs () -> void
+      def reject_foreign_actions
+        production = @grammar.productions.find do |entry|
+          entry.action&.code&.include?(foreign_action_sentinel)
+        end
+        return unless production
+
+        location = production.action&.location
+        rendered = location ? "#{location[:file]}:#{location[:line]}:#{location[:column]}" : "(codegen):1:1"
+        raise Ibex::Error,
+              "#{rendered}: cannot generate Ruby from imported C semantic actions; use analysis commands only"
+      end
+
+      # Kept local so the generic generator does not load the optional Bison
+      # importer and its IR validation graph.
+      # @rbs () -> String
+      def foreign_action_sentinel
+        "__ibex_foreign_action_c__"
+      end
+
       # @rbs (Array[String] lines) -> void
       def append_runtime(lines)
         if @embedded
-          EMBEDDED_RUNTIME_SOURCES.each { |path| lines << embedded_source(path) }
+          require "ibex/runtime/embedded_source"
+          lines << Runtime::EmbeddedSource.render
         elsif @runtime_require
           lines << "require #{@runtime_require.inspect}"
         end
         lines << ""
       end
 
-      # @rbs (String relative_path) -> String
-      def embedded_source(relative_path)
-        path = File.expand_path(relative_path, File.dirname(__FILE__))
-        File.read(path).lines.reject { |line| line.start_with?("# frozen_string_literal:") }.join.rstrip
-      end
-
       # @rbs (Array[String] lines) -> void
       def append_tables(lines)
         table_set = Tables.build(@automaton, format: @table_format)
@@ -250,12 +214,12 @@ module Ibex
         @grammar.conversions.empty?
       end
 
-      # @rbs () -> Hash[Symbol, untyped]
+      # @rbs () -> CSTMetadata::metadata
       def cst_metadata
         @cst_metadata ||= CSTMetadata.new(@grammar, trivia_policy: @cst_trivia).build
       end
 
-      # @rbs (untyped value) -> String
+      # @rbs (Object? value) -> String
       def deep_frozen_literal(value)
         case value
         when Array
@@ -272,7 +236,7 @@ module Ibex
         end
       end
 
-      # @rbs (untyped table) -> String
+      # @rbs (Object? table) -> String
       def table_literal(table)
         if table.is_a?(Tables::CompactActions)
           return "Ibex::Tables::CompactActions.packed(#{packed_integers_literal(table.offsets)}, " \
@@ -286,12 +250,12 @@ module Ibex
           "row_count: #{table.row_count}, dense_width: #{table.dense_width})"
       end
 
-      # @rbs (Array[Integer?] values) -> String
+      # @rbs (Array[untyped] values) -> String
       def packed_integers_literal(values)
         Tables::PackedIntegers.encode(values).inspect
       end
 
-      # @rbs (Array[Integer?] values) -> String
+      # @rbs (Array[untyped] values) -> String
       def packed_signed_integers_literal(values)
         Tables::PackedIntegers.encode_signed(values).inspect
       end

data/lib/ibex/codegen/ruby_actions.rb

@@ -48,16 +48,19 @@ module Ibex
         append_composed_orchestrator(lines, production, plan)
       end
 
-      # @rbs (Array[String] lines, IR::Production production, Hash[Symbol, untyped] step, Integer index) -> void
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
       def append_composed_fragment_method(lines, production, step, index)
         source = action_method_source.composed_fragment_method_source(production, step, index)
         if @line_convert
           location = step.fetch(:loc)
           lines << "  class_eval(#{source.dump}, #{location[:file].inspect}, #{location[:line]})"
-        elsif action_method_source.column_sensitive?(step.fetch(:code))
-          lines << source
         else
-          source.lines.each { |line| lines << "  #{line.rstrip}" }
+          code = step.fetch(:code) #: String
+          if action_method_source.column_sensitive?(code)
+            lines << source
+          else
+            source.lines.each { |line| lines << "  #{line.rstrip}" }
+          end
         end
         lines << ""
       end
@@ -67,7 +70,7 @@ module Ibex
         action_method_source.composed_fragment_name(production, index)
       end
 
-      # @rbs (Array[String] lines, IR::Production production, Hash[Symbol, untyped] plan) -> void
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_plan plan) -> void
       def append_composed_orchestrator(lines, production, plan)
         lines << "  private def _ibex_action_#{production.id}" \
                  "(val, _values, _ibex_locations, _ibex_location_stack, _ibex_location, " \
@@ -80,7 +83,7 @@ module Ibex
         lines.push("    _ibex_composed_values.last", "  end", "")
       end
 
-      # @rbs (Array[String] lines, IR::Production production, Hash[Symbol, untyped] step, Integer index) -> void
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
       def append_composed_step(lines, production, step, index)
         inputs = step.fetch(:inputs)
         lines << "    _ibex_step_values = _ibex_composed_values.values_at(#{inputs.join(', ')})"

data/lib/ibex/codegen/ruby_syntax.rb

@@ -5,6 +5,9 @@ module Ibex
   module Codegen
     # Generates typed Red syntax views from @node metadata.
     module RubySyntax
+      # @rbs!
+      #   type syntax_definition = Hash[Symbol, untyped]
+
       private
 
       # @rbs (Array[String] lines) -> void
@@ -18,11 +21,12 @@ module Ibex
         lines.push("  end", "")
       end
 
-      # @rbs () -> Hash[String, Hash[Symbol, untyped]]
+      # @rbs () -> Hash[String, syntax_definition]
       def syntax_node_definitions
         # @type self: Ruby
-        slots = cst_metadata.fetch(:slots)
-        definitions = {} #: Hash[String, Hash[Symbol, untyped]]
+        metadata = cst_metadata #: CSTMetadata::metadata
+        slots = metadata.fetch(:slots)
+        definitions = {} #: Hash[String, syntax_definition]
         @grammar.productions.each do |production|
           node = production.node
           next unless node
@@ -36,7 +40,7 @@ module Ibex
         definitions
       end
 
-      # @rbs (Hash[String, untyped] left, Hash[String, untyped] right) -> Hash[String, untyped]
+      # @rbs (Hash[String, CSTMetadata::field_slot] left, Hash[String, CSTMetadata::field_slot] right) -> Hash[String, CSTMetadata::field_slot]
       def merge_syntax_fields(left, right)
         left.to_h do |name, left_slot|
           right_slot = right.fetch(name)
@@ -48,7 +52,7 @@ module Ibex
         end.freeze
       end
 
-      # @rbs (Array[String] lines, Hash[Symbol, untyped] definition) -> void
+      # @rbs (Array[String] lines, syntax_definition definition) -> void
       def append_syntax_node(lines, definition)
         name = definition.fetch(:name)
         fields = definition.fetch(:fields)
@@ -65,12 +69,13 @@ module Ibex
         lines.push("    end", "")
       end
 
-      # @rbs (Array[String] lines, Hash[String, untyped] fields) -> void
+      # @rbs (Array[String] lines, Hash[String, CSTMetadata::field_slot] fields) -> void
       def append_repetition_accessors(lines, fields)
         repeated = fields.select { |_field, slot| slot.is_a?(Hash) && slot[:extraction] }
         repeated.each do |field, slot|
-          index = slot.fetch(:index)
-          separated = slot.fetch(:extraction) == :separated_list
+          typed_slot = slot #: Hash[Symbol, untyped]
+          index = typed_slot.fetch(:index) #: Integer
+          separated = typed_slot.fetch(:extraction) == :separated_list
           lines << "      def each_#{field}_element = list_items(#{index}, separated: #{separated})"
           next unless separated
 
@@ -80,8 +85,9 @@ module Ibex
         return unless repeated.one?
 
         field, slot = repeated.first
+        typed_slot = slot #: Hash[Symbol, untyped]
         lines << "      alias each_element each_#{field}_element"
-        return unless slot.fetch(:extraction) == :separated_list
+        return unless typed_slot.fetch(:extraction) == :separated_list
 
         lines << "      alias each_separator each_#{field}_separator"
       end

data/lib/ibex/configuration/analysis_grammar.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Configuration
+    # Produces an immutable Grammar IR view suitable for an explicitly
+    # noncanonical analysis algorithm. The source-owned contract remains the
+    # authority; callers must report the override through Configuration::Value.
+    module AnalysisGrammar
+      module_function
+
+      # @rbs (IR::Grammar grammar, Symbol algorithm) -> IR::Grammar
+      def for_algorithm(grammar, algorithm)
+        contract = grammar.parser_contract
+        return grammar unless contract&.algorithm&.explicit
+        return grammar if contract.algorithm.value == algorithm
+
+        analysis_contract = IR::ParserContract.new(
+          algorithm: IR::ParserContract::Entry.new(:algorithm),
+          entries: contract.entries, cst_trivia: contract.cst_trivia
+        )
+        IR::Grammar.new(
+          class_name: grammar.class_name, superclass: grammar.superclass, start: grammar.start,
+          expect: grammar.expect, options: grammar.options, symbols: grammar.symbols,
+          productions: grammar.productions, user_code: grammar.user_code, conversions: grammar.conversions,
+          warnings: grammar.warnings, expect_rr: grammar.expect_rr, user_code_chunks: grammar.user_code_chunks,
+          source_provenance: grammar.source_provenance,
+          parser_parameters: grammar.parser_parameters, value_printers: grammar.value_printers,
+          grammar_tests: grammar.grammar_tests, recovery: grammar.recovery, lexer: grammar.lexer,
+          mode: grammar.mode, starts: grammar.starts, parser_contract: analysis_contract
+        )
+      end
+    end
+  end
+end