ibex-runtime 0.2.0 → 0.4.0

data/lib/ibex/runtime/cst/serialize.rb

@@ -10,6 +10,9 @@ module Ibex
 
       # Stable JSON serialization for `ibex_cst` schema version 1.
       module Serialize
+        # @rbs!
+        #   type json_value = String | Integer | bool | nil | Array[json_value] | Hash[String, json_value]
+
         SCHEMA_VERSION = 1 #: Integer
 
         # @rbs (SyntaxNode | SerializedTree value, ?grammar_digest: String?, ?table_format: Integer?,
@@ -67,7 +70,7 @@ module Ibex
         module_function :serialization_tree
         private_class_method :serialization_tree
 
-        # @rbs (Kind kinds) -> Hash[String, untyped]
+        # @rbs (Kind kinds) -> Hash[String, json_value]
         def kinds_document(kinds)
           metadata = kinds.to_h
           {
@@ -83,7 +86,7 @@ module Ibex
         module_function :kinds_document
         private_class_method :kinds_document
 
-        # @rbs (GreenNode | GreenToken element) -> Hash[String, untyped]
+        # @rbs (GreenNode | GreenToken element) -> Hash[String, json_value]
         def element_document(element)
           if element.is_a?(GreenNode)
             raise SerializationError, "annotated Green nodes cannot be serialized" unless element.annotations.empty?
@@ -107,7 +110,7 @@ module Ibex
         module_function :element_document
         private_class_method :element_document
 
-        # @rbs (GreenTrivia trivia) -> Array[untyped]
+        # @rbs (GreenTrivia trivia) -> Array[json_value]
         def trivia_document(trivia) = [trivia.kind, encode_text(trivia.text)]
         module_function :trivia_document
         private_class_method :trivia_document

data/lib/ibex/runtime/cst/syntax_node.rb

@@ -348,7 +348,7 @@ module Ibex
           root.equal?(other.root) && @green.equal?(other.green) && @offset == other.offset
         end
 
-        # @rbs (untyped other) -> bool
+        # @rbs (Object? other) -> bool
         def ==(other)
           other.is_a?(SyntaxNode) && @green == other.green
         end
@@ -356,12 +356,12 @@ module Ibex
         # @rbs () -> Array[element]
         def deconstruct = children
 
-        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, Object?]
         def deconstruct_keys(_keys)
           values = {
             kind: :node, symbol: symbol, production_id: production_id, children: children,
             location: location, trailing_trivia: trailing_trivia
-          } #: Hash[Symbol, untyped]
+          } #: Hash[Symbol, Object?]
           @kinds.fields(kind).each do |name, slot|
             index = slot.is_a?(Hash) ? slot.fetch(:index) : slot
             values[name.to_sym] = child_at(index)
@@ -369,7 +369,7 @@ module Ibex
           values.freeze
         end
 
-        # @rbs () -> Hash[Symbol, untyped]
+        # @rbs () -> Hash[Symbol, Object?]
         def to_h = deconstruct_keys(nil)
 
         protected

data/lib/ibex/runtime/cst/syntax_token.rb

@@ -45,7 +45,7 @@ module Ibex
         # @rbs () -> Array[GreenTrivia]
         def leading_trivia = @green.leading
 
-        # @rbs () -> Array[untyped]
+        # @rbs () -> Array[Object?]
         def children = []
 
         # @rbs () -> String
@@ -127,15 +127,15 @@ module Ibex
           root.equal?(other.root) && @green.equal?(other.green) && @offset == other.offset
         end
 
-        # @rbs (untyped other) -> bool
+        # @rbs (Object? other) -> bool
         def ==(other)
           other.is_a?(SyntaxToken) && @green == other.green
         end
 
-        # @rbs () -> Array[untyped]
+        # @rbs () -> Array[Object?]
         def deconstruct = []
 
-        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, Object?]
         def deconstruct_keys(_keys)
           {
             kind: :token, symbol: symbol, value: value, location: location,
@@ -143,7 +143,7 @@ module Ibex
           }.freeze
         end
 
-        # @rbs () -> Hash[Symbol, untyped]
+        # @rbs () -> Hash[Symbol, Object?]
         def to_h = deconstruct_keys(nil)
 
         private

data/lib/ibex/runtime/cst/typed_node.rb

@@ -46,7 +46,7 @@ module Ibex
         # @rbs () -> Array[element]
         def deconstruct = @node.deconstruct
 
-        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, Object?]
         def deconstruct_keys(keys) = @node.deconstruct_keys(keys)
 
         # @rbs () -> String

data/lib/ibex/runtime/cst/validator.rb

@@ -6,14 +6,18 @@ require "json"
 module Ibex
   module Runtime
     module CST
+      # @rbs!
+      #   type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+      #   type json_object = Hash[String, json_value]
+
       # Structured failure raised for an invalid or incompatible CST document.
       class ValidationError < StandardError
         attr_reader :code #: Symbol
         attr_reader :path #: String
-        attr_reader :expected #: untyped
-        attr_reader :actual #: untyped
+        attr_reader :expected #: json_value
+        attr_reader :actual #: json_value
 
-        # @rbs (code: Symbol, path: String, message: String, ?expected: untyped, ?actual: untyped) -> void
+        # @rbs (code: Symbol, path: String, message: String, ?expected: json_value, ?actual: json_value) -> void
         def initialize(code:, path:, message:, expected: nil, actual: nil)
           @code = code
           @path = path.dup.freeze
@@ -39,8 +43,8 @@ module Ibex
         # @rbs (String source, ?grammar_digest: String?, ?state_count: Integer?,
         #   ?production_count: Integer?) -> SerializedTree
         def validate(source, grammar_digest: nil, state_count: nil, production_count: nil) # rubocop:disable Metrics/MethodLength
-          document = JSON.parse(source)
-          object!(document, "$")
+          document = JSON.parse(source) #: json_value
+          document = object!(document, "$")
           exact_keys!(document, TOP_KEYS, "$")
           value!(document, "ibex_ir", "cst", "$.ibex_ir")
           value!(document, "schema_version", 1, "$.schema_version")
@@ -88,9 +92,9 @@ module Ibex
         end
         module_function :validate
 
-        # @rbs (untyped value) -> Kind
+        # @rbs (json_value value) -> Kind
         def load_kinds(value)
-          object!(value, "$.kinds")
+          value = object!(value, "$.kinds")
           exact_keys!(value, KIND_KEYS, "$.kinds")
           names = array!(value.fetch("names"), "$.kinds.names").map.with_index do |name, index|
             string!(name, "$.kinds.names[#{index}]")
@@ -112,13 +116,13 @@ module Ibex
         module_function :load_kinds
         private_class_method :load_kinds
 
-        # @rbs (untyped value, GreenNode root, String digest, Integer state_count, Integer production_count,
+        # @rbs (json_value value, GreenNode root, String digest, Integer state_count, Integer production_count,
         #   expected_state_count: Integer?, expected_production_count: Integer?) -> ParseMemo?
         def load_memo(value, root, digest, state_count, production_count,
                       expected_state_count:, expected_production_count:)
           return if value.nil?
 
-          object!(value, "$.memo")
+          value = object!(value, "$.memo")
           exact_keys!(value, %w[version left_states], "$.memo")
           value!(value, "version", ParseMemo::VERSION, "$.memo.version")
           states = load_memo_states(value.fetch("left_states"), state_count)
@@ -136,7 +140,7 @@ module Ibex
         module_function :load_memo
         private_class_method :load_memo
 
-        # @rbs (untyped value, Integer state_count) -> Array[Integer?]
+        # @rbs (json_value value, Integer state_count) -> Array[Integer?]
         def load_memo_states(value, state_count)
           array!(value, "$.memo.left_states").map.with_index do |state, index|
             next if state.nil?
@@ -171,9 +175,9 @@ module Ibex
         module_function :validate_memo_length!
         private_class_method :validate_memo_length!
 
-        # @rbs (untyped value, Kind kinds, String path) -> (GreenNode | GreenToken)
+        # @rbs (json_value value, Kind kinds, String path) -> (GreenNode | GreenToken)
         def load_element(value, kinds, path)
-          object!(value, path)
+          value = object!(value, path)
           kind = nonnegative_integer!(value.fetch("k"), "#{path}.k")
           validate_kind!(kind, kinds, "#{path}.k")
           flags = flags!(value.fetch("f"), "#{path}.f")
@@ -199,7 +203,7 @@ module Ibex
         module_function :load_element
         private_class_method :load_element
 
-        # @rbs (untyped value, Kind kinds, String path) -> Array[GreenTrivia]
+        # @rbs (json_value value, Kind kinds, String path) -> Array[GreenTrivia]
         def load_trivia(value, kinds, path)
           array!(value, path).map.with_index do |item, index|
             pair = array!(item, "#{path}[#{index}]")
@@ -218,11 +222,11 @@ module Ibex
         module_function :load_trivia
         private_class_method :load_trivia
 
-        # @rbs (untyped value, String path) -> String
+        # @rbs (json_value value, String path) -> String
         def decode_text(value, path)
           return value.b if value.is_a?(String)
 
-          object!(value, path)
+          value = object!(value, path)
           exact_keys!(value, ["b64"], path)
           encoded = string!(value.fetch("b64"), "#{path}.b64")
           decoded = encoded.unpack1("m0")
@@ -266,25 +270,31 @@ module Ibex
         module_function :validate_kind!
         private_class_method :validate_kind!
 
-        # @rbs (untyped value, String path) -> Hash[String, untyped]
+        # @rbs (json_value value, String path) -> json_object
         def object!(value, path)
-          return value if value.is_a?(Hash)
+          if value.is_a?(Hash)
+            object = value #: json_object
+            return object
+          end
 
           fail_validation(:invalid_type, path, "expected object", actual: value.class.name)
         end
         module_function :object!
         private_class_method :object!
 
-        # @rbs (untyped value, String path) -> Array[untyped]
+        # @rbs (json_value value, String path) -> Array[json_value]
         def array!(value, path)
-          return value if value.is_a?(Array)
+          if value.is_a?(Array)
+            array = value #: Array[json_value]
+            return array
+          end
 
           fail_validation(:invalid_type, path, "expected array", actual: value.class.name)
         end
         module_function :array!
         private_class_method :array!
 
-        # @rbs (untyped value, String path) -> String
+        # @rbs (json_value value, String path) -> String
         def string!(value, path)
           return value if value.is_a?(String)
 
@@ -293,7 +303,7 @@ module Ibex
         module_function :string!
         private_class_method :string!
 
-        # @rbs (untyped value, String path) -> Integer
+        # @rbs (json_value value, String path) -> Integer
         def nonnegative_integer!(value, path)
           return value if value.is_a?(Integer) && !value.negative?
 
@@ -302,7 +312,7 @@ module Ibex
         module_function :nonnegative_integer!
         private_class_method :nonnegative_integer!
 
-        # @rbs (untyped value, String path) -> Integer
+        # @rbs (json_value value, String path) -> Integer
         def positive_integer!(value, path)
           integer = nonnegative_integer!(value, path)
           return integer if integer.positive?
@@ -312,7 +322,7 @@ module Ibex
         module_function :positive_integer!
         private_class_method :positive_integer!
 
-        # @rbs (untyped value, String path) -> Symbol
+        # @rbs (json_value value, String path) -> Symbol
         def trivia_policy!(value, path)
           policy = string!(value, path).to_sym
           return policy if %i[leading balanced drop].include?(policy)
@@ -322,7 +332,7 @@ module Ibex
         module_function :trivia_policy!
         private_class_method :trivia_policy!
 
-        # @rbs (untyped value, String path) -> Integer
+        # @rbs (json_value value, String path) -> Integer
         def flags!(value, path)
           flags = nonnegative_integer!(value, path)
           fail_validation(:invalid_flags, path, "flags contain unknown bits", actual: flags) unless
@@ -334,7 +344,7 @@ module Ibex
         module_function :flags!
         private_class_method :flags!
 
-        # @rbs (untyped value, String path) -> Array[Integer]
+        # @rbs (json_value value, String path) -> Array[Integer]
         def integer_pair!(value, path)
           pair = array!(value, path)
           fail_validation(:invalid_type, path, "expected two integers") unless pair.length == 2
@@ -343,7 +353,7 @@ module Ibex
         module_function :integer_pair!
         private_class_method :integer_pair!
 
-        # @rbs (untyped value, String path) -> Hash[String, Integer]
+        # @rbs (json_value value, String path) -> Hash[String, Integer]
         def string_integer_map!(value, path)
           object!(value, path).to_h do |key, item|
             [
@@ -355,7 +365,7 @@ module Ibex
         module_function :string_integer_map!
         private_class_method :string_integer_map!
 
-        # @rbs (untyped value, String path) -> Hash[Integer, Integer]
+        # @rbs (json_value value, String path) -> Hash[Integer, Integer]
         def integer_integer_map!(value, path)
           object!(value, path).to_h do |key, item|
             integer_key = Integer(string!(key, "#{path}.<key>"), 10)
@@ -394,7 +404,7 @@ module Ibex
         module_function :validate_kind_range!
         private_class_method :validate_kind_range!
 
-        # @rbs (Hash[String, untyped] value, Array[String] expected, String path) -> void
+        # @rbs (json_object value, Array[String] expected, String path) -> void
         def exact_keys!(value, expected, path)
           actual = value.keys.sort
           return if actual == expected.sort
@@ -404,7 +414,7 @@ module Ibex
         module_function :exact_keys!
         private_class_method :exact_keys!
 
-        # @rbs (Hash[String, untyped] value, String key, untyped expected, String path) -> void
+        # @rbs (json_object value, String key, json_value expected, String path) -> void
         def value!(value, key, expected, path)
           actual = value.fetch(key)
           return if actual == expected
@@ -414,7 +424,7 @@ module Ibex
         module_function :value!
         private_class_method :value!
 
-        # @rbs (Symbol code, String path, String message, ?expected: untyped, ?actual: untyped) -> bot
+        # @rbs (Symbol code, String path, String message, ?expected: json_value, ?actual: json_value) -> bot
         def fail_validation(code, path, message, expected: nil, actual: nil)
           raise ValidationError.new(
             code: code, path: path, message: message, expected: expected, actual: actual

data/lib/ibex/runtime/embedded_source.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Runtime
+    # Assembles the installed runtime into one dependency-free Ruby source.
+    module EmbeddedSource
+      FILES = %w[
+        version.rb
+        table_format.rb
+        location_span.rb
+        cst/kind.rb
+        cst/annotation.rb
+        cst/green/trivia.rb
+        cst/green/token.rb
+        cst/green/node.rb
+        cst/green/cache.rb
+        cst/green/builder.rb
+        cst/source_text.rb
+        cst/syntax_token.rb
+        cst/syntax_node.rb
+        cst/cursor.rb
+        cst/typed_node.rb
+        cst/parse_result.rb
+        cst/editing.rb
+        cst/text_edit.rb
+        cst/rewriter.rb
+        cst/editor.rb
+        cst/diff.rb
+        cst/serialized_tree.rb
+        cst/validator.rb
+        cst/serialize.rb
+        cst/incremental/token_memo.rb
+        cst/incremental/relexer.rb
+        cst/incremental/parse_memo.rb
+        cst/incremental/lexed_syntax.rb
+        cst/incremental/blender.rb
+        cst/incremental/session.rb
+        cst.rb
+        ast_data.rb
+        resource_limits.rb
+        event_sanitizer.rb
+        syntax_session.rb
+        event.rb
+        observation.rb
+        repair.rb
+        repair_priority_queue.rb
+        repair_search.rb
+        syntax_repair.rb
+        parser_sync_recovery.rb
+        parser.rb
+        lexer_input.rb
+        generated_lexer.rb
+        event_jsonl_tracer.rb
+        ../tables/compact.rb
+        ../tables/compact_actions.rb
+        ../tables/compact_productions.rb
+      ].freeze #: Array[String]
+      REQUIRE_RELATIVE = /^\s*require_relative\s+["']([^"']+)["']/
+      private_constant :FILES, :REQUIRE_RELATIVE
+
+      # @rbs () -> String
+      def self.render
+        paths = FILES.map { |relative_path| File.expand_path(relative_path, File.dirname(__FILE__)) }
+        validate_manifest!(paths)
+        paths.map { |path| source(path) }.join("\n")
+      end
+
+      # @rbs (Array[String] paths) -> void
+      def self.validate_manifest!(paths)
+        raise "embedded runtime manifest contains duplicate files" unless paths.uniq.length == paths.length
+
+        positions = paths.each_with_index.to_h
+        paths.each_with_index do |path, position|
+          raise "embedded runtime source is missing: #{path}" unless File.file?(path)
+
+          File.foreach(path) do |line|
+            match = REQUIRE_RELATIVE.match(line)
+            next unless match
+
+            dependency = File.expand_path("#{match[1]}.rb", File.dirname(path))
+            dependency_position = positions[dependency]
+            next if dependency_position && dependency_position < position
+
+            raise "embedded runtime dependency must precede #{path}: #{dependency}"
+          end
+        end
+      end
+      private_class_method :validate_manifest!
+
+      # @rbs (String path) -> String
+      def self.source(path)
+        File.read(path).lines.reject { |line| line.start_with?("# frozen_string_literal:") }.join.rstrip
+      end
+      private_class_method :source
+    end
+  end
+end

data/lib/ibex/runtime/event.rb

@@ -7,6 +7,9 @@ module Ibex
   module Runtime
     # One immutable versioned parser observation.
     class Event
+      # @rbs!
+      #   type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
       SCHEMA_VERSION = 1 #: Integer
       IDENTIFIER = "runtime-event" #: String
       TYPES = %i[
@@ -15,9 +18,9 @@ module Ibex
 
       attr_reader :type #: Symbol
       attr_reader :sequence #: Integer
-      attr_reader :data #: Hash[String, untyped]
+      attr_reader :data #: Hash[String, json_value]
 
-      # @rbs (type: Symbol, sequence: Integer, data: Hash[untyped, untyped]) -> void
+      # @rbs (type: Symbol, sequence: Integer, data: Hash[Object?, Object?]) -> void
       def initialize(type:, sequence:, data:)
         raise ArgumentError, "unknown runtime event type #{type.inspect}" unless TYPES.include?(type)
         raise ArgumentError, "runtime event sequence must be positive" unless sequence.positive?
@@ -31,11 +34,11 @@ module Ibex
           "sequence" => @sequence,
           "event" => @type.to_s.freeze,
           "data" => @data
-        }.freeze #: Hash[String, untyped]
+        }.freeze #: Hash[String, json_value]
         freeze
       end
 
-      # @rbs () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, json_value]
       def to_h
         @document
       end

data/lib/ibex/runtime/event_jsonl_tracer.rb

@@ -10,7 +10,7 @@ module Ibex
     class EventJSONLTracer
       # @rbs!
       #   interface _EventTraceOutput
-      #     def puts: (String) -> untyped
+      #     def puts: (String) -> void
       #   end
 
       attr_reader :parser #: Parser