ibex-runtime 0.2.0

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "green/token" unless defined?(Ibex::Runtime::CST::GreenToken)
+
+module Ibex
+  module Runtime
+    module CST
+      # Raised when source-coordinate APIs are used on a trivia-dropped tree.
+      class TriviaDroppedError < StandardError; end
+
+      # Lightweight Red facade for one Green token occurrence.
+      class SyntaxToken
+        attr_reader :green #: GreenToken
+        attr_reader :parent #: SyntaxNode
+        attr_reader :index #: Integer
+        attr_reader :offset #: Integer
+
+        # @rbs (green: GreenToken, parent: SyntaxNode, index: Integer, offset: Integer) -> void
+        def initialize(green:, parent:, index:, offset:)
+          @green = green
+          @parent = parent
+          @index = index
+          @offset = offset
+          freeze
+        end
+
+        # @rbs () -> Integer
+        def kind = @green.kind
+
+        # @rbs () -> String
+        def kind_name = @parent.kinds.name(kind)
+
+        # @rbs () -> String
+        def symbol = kind_name
+
+        # @rbs () -> String
+        def text = @green.text
+
+        # Compatibility projection for the legacy token API. Semantic lexer
+        # values remain on the parser value path; syntax exposes source bytes.
+        # @rbs () -> String
+        def value = text
+
+        # @rbs () -> Array[GreenTrivia]
+        def leading_trivia = @green.leading
+
+        # @rbs () -> Array[untyped]
+        def children = []
+
+        # @rbs () -> String
+        def full_text = @green.to_source
+        alias to_source full_text
+
+        # @rbs () -> Range[Integer]
+        def full_span
+          ensure_coordinates!
+          @offset...(@offset + @green.full_width)
+        end
+
+        # @rbs () -> Range[Integer]
+        def span
+          ensure_coordinates!
+          (@offset + @green.leading_width)...(@offset + @green.full_width - @green.trailing_width)
+        end
+
+        # @rbs () -> Ibex::Location
+        def location = @parent.source_text.location(span)
+
+        # @rbs () -> bool
+        def error? = @parent.kinds.error?(kind)
+
+        # @rbs () -> bool
+        def missing? = @green.flags.anybits?(Flags::CONTAINS_MISSING)
+
+        # @rbs () -> bool
+        def contains_error? = @green.flags.anybits?(Flags::CONTAINS_ERROR)
+
+        # @rbs (GreenNode | GreenToken | SyntaxNode | SyntaxToken replacement) -> SyntaxNode
+        def replace_with(replacement) = Editing.replace(self, replacement)
+
+        # @rbs (String value) -> SyntaxNode
+        def with_text(value)
+          replace_with(
+            GreenToken.new(
+              kind: @green.kind, text: value, leading: @green.leading, trailing: @green.trailing,
+              flags: @green.flags, expected_kind: @green.expected_kind
+            )
+          )
+        end
+
+        # @rbs (Array[GreenTrivia] trivia) -> SyntaxNode
+        def with_leading(trivia)
+          replace_with(
+            GreenToken.new(
+              kind: @green.kind, text: @green.text, leading: trivia, trailing: @green.trailing,
+              flags: @green.flags, expected_kind: @green.expected_kind
+            )
+          )
+        end
+
+        # @rbs (Array[GreenTrivia] trivia) -> SyntaxNode
+        def with_trailing(trivia)
+          replace_with(
+            GreenToken.new(
+              kind: @green.kind, text: @green.text, leading: @green.leading, trailing: trivia,
+              flags: @green.flags, expected_kind: @green.expected_kind
+            )
+          )
+        end
+
+        # @rbs () -> (SyntaxNode | SyntaxToken)?
+        def next_sibling = @parent.children[@index + 1]
+
+        # @rbs () -> (SyntaxNode | SyntaxToken)?
+        def prev_sibling
+          return if @index.zero?
+
+          @parent.children[@index - 1]
+        end
+
+        # @rbs () -> SyntaxNode
+        def root = @parent.root
+
+        # @rbs (SyntaxToken other) -> bool
+        def same_node?(other)
+          root.equal?(other.root) && @green.equal?(other.green) && @offset == other.offset
+        end
+
+        # @rbs (untyped other) -> bool
+        def ==(other)
+          other.is_a?(SyntaxToken) && @green == other.green
+        end
+
+        # @rbs () -> Array[untyped]
+        def deconstruct = []
+
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        def deconstruct_keys(_keys)
+          {
+            kind: :token, symbol: symbol, value: value, location: location,
+            leading_trivia: leading_trivia
+          }.freeze
+        end
+
+        # @rbs () -> Hash[Symbol, untyped]
+        def to_h = deconstruct_keys(nil)
+
+        private
+
+        # @rbs () -> void
+        def ensure_coordinates!
+          return unless @parent.trivia_policy == :drop
+
+          raise TriviaDroppedError, "source coordinates are unavailable when CST trivia is dropped"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Runtime
+    module CST
+      # One byte-oriented source replacement.
+      class TextEdit
+        class << self
+          # Sort and merge adjacent edits while rejecting intersecting source ranges.
+          # All edits remain expressed against the unedited source.
+          # @rbs (Array[TextEdit] edits) -> Array[TextEdit]
+          def normalize(edits)
+            raise ArgumentError, "edits must contain only TextEdit values" unless edits.all?(TextEdit)
+
+            merge_adjacent(
+              edits.each_with_index.sort_by do |edit, index|
+                [edit.start, edit.delete_length.zero? ? 0 : 1, index]
+              end.map(&:first)
+            ).freeze
+          end
+
+          private
+
+          # @rbs (Array[TextEdit] ordered) -> Array[TextEdit]
+          def merge_adjacent(ordered)
+            normalized = [] #: Array[TextEdit]
+            ordered.each do |edit|
+              previous = normalized.last
+              unless previous
+                normalized << edit
+                next
+              end
+
+              merge_with_previous(normalized, previous, edit)
+            end
+            normalized
+          end
+
+          # @rbs (Array[TextEdit] normalized, TextEdit previous, TextEdit edit) -> void
+          def merge_with_previous(normalized, previous, edit)
+            previous_end = previous.start + previous.delete_length
+            raise ArgumentError, "text edits overlap" if edit.start < previous_end
+
+            if edit.start == previous_end
+              normalized[-1] = TextEdit.new(
+                start: previous.start,
+                delete_length: previous.delete_length + edit.delete_length,
+                insert_text: previous.insert_text + edit.insert_text
+              )
+            else
+              normalized << edit
+            end
+          end
+        end
+
+        attr_reader :start #: Integer
+        attr_reader :delete_length #: Integer
+        attr_reader :insert_text #: String
+
+        # @rbs (start: Integer, delete_length: Integer, insert_text: String) -> void
+        def initialize(start:, delete_length:, insert_text:)
+          raise ArgumentError, "start must be non-negative" if start.negative?
+          raise ArgumentError, "delete_length must be non-negative" if delete_length.negative?
+
+          @start = start
+          @delete_length = delete_length
+          @insert_text = insert_text.b.freeze
+          freeze
+        end
+
+        # @rbs () -> Range[Integer]
+        def range = @start...(@start + @delete_length)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "syntax_node" unless defined?(Ibex::Runtime::CST::SyntaxNode)
+
+module Ibex
+  module Runtime
+    module CST
+      # Grammar-generated typed view over one Red syntax node.
+      class TypedNode
+        # @rbs! type element = SyntaxNode | SyntaxToken
+
+        attr_reader :node #: SyntaxNode
+
+        # @rbs (SyntaxNode node) -> void
+        def initialize(node)
+          @node = node
+          freeze
+        end
+
+        # @rbs () -> Integer
+        def kind = @node.kind
+
+        # @rbs () -> String
+        def kind_name = @node.kind_name
+
+        # @rbs (Integer index) -> element
+        def child_at_slot(index) = @node.child_at(index)
+
+        # @rbs (Integer index) -> SyntaxNode
+        def node_at_slot(index)
+          child = child_at_slot(index)
+          return child if child.is_a?(SyntaxNode)
+
+          raise TypeError, "CST slot #{index} is not a syntax node"
+        end
+
+        # @rbs (Integer index) -> SyntaxToken
+        def token_at_slot(index)
+          child = child_at_slot(index)
+          return child if child.is_a?(SyntaxToken)
+
+          raise TypeError, "CST slot #{index} is not a syntax token"
+        end
+
+        # @rbs () -> Array[element]
+        def deconstruct = @node.deconstruct
+
+        # @rbs (Array[Symbol]?) -> Hash[Symbol, untyped]
+        def deconstruct_keys(keys) = @node.deconstruct_keys(keys)
+
+        # @rbs () -> String
+        def to_source = @node.to_source
+
+        protected
+
+        # Flatten a lowered repetition helper and enumerate elements or separators.
+        # @rbs (Integer index, separated: bool, ?separators: bool) -> Enumerator[element, void]
+        def list_items(index, separated:, separators: false)
+          root = node_at_slot(index)
+          flattened = [] #: Array[element]
+          flatten_list(root, root.kind, flattened)
+          return flattened.each unless separated
+
+          selected = [] #: Array[element]
+          flattened.each_with_index do |item, item_index|
+            selected << item if separators == item_index.odd?
+          end
+          selected.each
+        end
+
+        private
+
+        # @rbs (SyntaxNode current, Integer helper_kind, Array[element] result) -> void
+        def flatten_list(current, helper_kind, result)
+          current.children.each do |child|
+            if child.is_a?(SyntaxNode) && child.kind == helper_kind
+              flatten_list(child, helper_kind, result)
+            else
+              result << child
+            end
+          end
+        end
+      end
+    end
+  end
+end