ibex 0.1.0 → 0.2.0

data/lib/ibex/lalr/direct_lookaheads.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "set"
+
+module Ibex
+  module LALR
+    # Builds an LR(0) collection and propagates LALR(1) lookaheads directly
+    # over item occurrences. Canonical LR(1) states are never materialized.
+    class DirectLookaheads
+      AUGMENTED_PRODUCTION = -1 #: Integer
+      EMPTY_PRODUCTIONS = Array.new(0).freeze #: Array[IR::Production]
+      EMPTY_NODES = Array.new(0).freeze #: Array[lookahead_node]
+      private_constant :EMPTY_PRODUCTIONS, :EMPTY_NODES
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @sets: Analysis::Sets
+      # @rbs @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+      # @rbs @augmented_rhs: Array[Integer]
+      # @rbs @production_rhs: Array[Array[Integer]]
+      # @rbs @augmented_item_cores: Array[item_core]
+      # @rbs @production_item_cores: Array[Array[item_core]]
+      # @rbs @terminal_ids: Array[Integer]
+      # @rbs @terminal_masks: Array[Integer]
+
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets) -> void
+      def initialize(grammar, sets)
+        @grammar = grammar
+        @sets = sets
+        @productions_by_lhs = grammar.productions.group_by(&:lhs)
+        start = grammar.symbol(grammar.start) || raise(Ibex::Error, "missing start symbol")
+        @augmented_rhs = [start.id].freeze
+        @production_rhs = grammar.productions.map(&:rhs).freeze
+        @augmented_item_cores = item_cores_for(AUGMENTED_PRODUCTION, @augmented_rhs.length)
+        @production_item_cores = grammar.productions.map do |production|
+          item_cores_for(production.id, production.rhs.length)
+        end.freeze
+        @terminal_ids = grammar.terminals.map(&:id).freeze
+        @terminal_masks = @terminal_ids.map { |id| 1 << id }.freeze
+      end
+
+      # @rbs () -> [Array[packed_items], transitions]
+      def build
+        states, transitions = lr0_collection
+        lookaheads = empty_lookaheads(states)
+        propagation = propagation_graph(states, transitions, lookaheads)
+        lookaheads.fetch(0).fetch(item_core(AUGMENTED_PRODUCTION, 0)) << 0
+        propagate(lookaheads, propagation)
+        [lookaheads, transitions]
+      end
+
+      private
+
+      # @rbs () -> [Array[core_set], transitions]
+      def lr0_collection
+        seed = Set[item_core(AUGMENTED_PRODUCTION, 0)] #: core_set
+        states = [closure(seed)]
+        transitions = [] #: transitions
+        indexes = { item_key(states.first) => 0 }
+        cursor = 0
+        while cursor < states.length
+          transitions[cursor] = {}
+          kernels = shifted_kernels(states.fetch(cursor))
+          kernels.keys.sort.each do |symbol_id|
+            target = closure(kernels.fetch(symbol_id))
+            key = item_key(target)
+            target_id = indexes[key] ||= begin
+              states << target
+              states.length - 1
+            end
+            transitions.fetch(cursor)[symbol_id] = target_id
+          end
+          cursor += 1
+        end
+        [states, transitions]
+      end
+
+      # @rbs (core_set seed) -> core_set
+      def closure(seed)
+        items = seed.dup
+        queue = seed.to_a
+        cursor = 0
+        while cursor < queue.length
+          production_id, dot = queue.fetch(cursor)
+          cursor += 1
+          symbol = @grammar.symbol_by_id(rhs_for(production_id)[dot])
+          next unless symbol&.nonterminal?
+
+          @productions_by_lhs.fetch(symbol.id, EMPTY_PRODUCTIONS).each do |production|
+            item = item_core(production.id, 0)
+            queue << item if items.add?(item)
+          end
+        end
+        items
+      end
+
+      # @rbs (core_set items) -> Hash[Integer, core_set]
+      def shifted_kernels(items)
+        kernels = {} #: Hash[Integer, core_set]
+        items.each do |production_id, dot|
+          symbol_id = rhs_for(production_id)[dot]
+          next unless symbol_id
+
+          (kernels[symbol_id] ||= Set.new) << item_core(production_id, dot + 1)
+        end
+        kernels
+      end
+
+      # @rbs (Array[core_set] states) -> Array[packed_items]
+      def empty_lookaheads(states)
+        states.map do |items|
+          items.to_h { |item| [item, Set.new] } #: packed_items
+        end
+      end
+
+      # @rbs (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) ->
+      #   Hash[lookahead_node, Array[lookahead_node]]
+      def propagation_graph(states, transitions, lookaheads)
+        edges = Hash.new { |hash, key| hash[key] = [] } #: Hash[lookahead_node, Array[lookahead_node]]
+        states.each_with_index do |items, state_id|
+          items.each do |production_id, dot|
+            add_transition_edge(edges, transitions, state_id, production_id, dot)
+            add_closure_relations(edges, lookaheads, state_id, production_id, dot)
+          end
+        end
+        edges.each_value(&:uniq!)
+        edges
+      end
+
+      # @rbs (Hash[lookahead_node, Array[lookahead_node]] edges, transitions transitions,
+      #   Integer state_id, Integer production_id, Integer dot) -> void
+      def add_transition_edge(edges, transitions, state_id, production_id, dot)
+        symbol_id = rhs_for(production_id)[dot]
+        return unless symbol_id
+
+        target_state = transitions.fetch(state_id).fetch(symbol_id)
+        source = [state_id, production_id, dot] #: lookahead_node
+        target = [target_state, production_id, dot + 1] #: lookahead_node
+        edges[source] << target
+      end
+
+      # @rbs (Hash[lookahead_node, Array[lookahead_node]] edges, Array[packed_items] lookaheads,
+      #   Integer state_id, Integer production_id, Integer dot) -> void
+      def add_closure_relations(edges, lookaheads, state_id, production_id, dot)
+        rhs = rhs_for(production_id)
+        symbol = @grammar.symbol_by_id(rhs[dot])
+        return unless symbol&.nonterminal?
+
+        suffix = rhs.drop(dot + 1)
+        spontaneous = terminal_ids(@sets.first_of_sequence(suffix))
+        source = [state_id, production_id, dot] #: lookahead_node
+        @productions_by_lhs.fetch(symbol.id, EMPTY_PRODUCTIONS).each do |production|
+          target_item = item_core(production.id, 0)
+          lookaheads.fetch(state_id).fetch(target_item).merge(spontaneous)
+          if @sets.sequence_nullable?(suffix)
+            target = [state_id, production.id, 0] #: lookahead_node
+            edges[source] << target
+          end
+        end
+      end
+
+      # @rbs (Array[packed_items] lookaheads, Hash[lookahead_node, Array[lookahead_node]] edges) -> void
+      def propagate(lookaheads, edges)
+        queue = lookaheads.each_with_index.flat_map do |items, state_id|
+          items.filter_map do |(production_id, dot), tokens|
+            next if tokens.empty?
+
+            [state_id, production_id, dot] #: lookahead_node
+          end
+        end #: Array[lookahead_node]
+        queued = queue.to_h { |node| [node, true] } #: Hash[lookahead_node, bool]
+        cursor = 0
+        while cursor < queue.length
+          source = queue.fetch(cursor)
+          cursor += 1
+          queued.delete(source)
+          source_set = node_set(lookaheads, source)
+          edges.fetch(source, EMPTY_NODES).each do |target|
+            target_set = node_set(lookaheads, target)
+            previous_size = target_set.size
+            target_set.merge(source_set)
+            next if target_set.size == previous_size || queued[target]
+
+            queue << target
+            queued[target] = true
+          end
+        end
+      end
+
+      # @rbs (Array[packed_items] lookaheads, lookahead_node node) -> Set[Integer]
+      def node_set(lookaheads, node)
+        state_id, production_id, dot = node
+        lookaheads.fetch(state_id).fetch(item_core(production_id, dot))
+      end
+
+      # @rbs (Integer bits) -> Array[Integer]
+      def terminal_ids(bits)
+        selected = [] #: Array[Integer]
+        index = 0
+        while index < @terminal_ids.length
+          selected << @terminal_ids[index] if bits.anybits?(@terminal_masks[index])
+          index += 1
+        end
+        selected
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        return @augmented_rhs if production_id == AUGMENTED_PRODUCTION
+
+        @production_rhs.fetch(production_id)
+      end
+
+      # @rbs (Integer production_id, Integer rhs_length) -> Array[item_core]
+      def item_cores_for(production_id, rhs_length)
+        Array.new(rhs_length + 1) do |dot|
+          [production_id, dot].freeze #: item_core
+        end.freeze
+      end
+
+      # @rbs (Integer production_id, Integer dot) -> item_core
+      def item_core(production_id, dot)
+        raise IndexError, "invalid item dot: #{dot}" if dot.negative?
+        return @augmented_item_cores.fetch(dot) if production_id == AUGMENTED_PRODUCTION
+        raise IndexError, "invalid production id: #{production_id}" if production_id.negative?
+
+        @production_item_cores.fetch(production_id).fetch(dot)
+      end
+
+      # @rbs (core_set items) -> Array[item_core]
+      def item_key(items)
+        items.to_a.sort
+      end
+    end
+  end
+end

data/lib/ibex/lalr/ielr_partition.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "set"
+
+module Ibex
+  module LALR
+    # Deterministically merges compatible canonical LR(1) states and splits
+    # partitions until their outgoing transitions are congruent.
+    class IELRPartition
+      AUGMENTED_PRODUCTION = -1 #: Integer
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @states: Array[item_set]
+      # @rbs @transitions: transitions
+      # @rbs @contributions: Array[Hash[Integer, Set[Array[untyped]]]]
+
+      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions) -> void
+      def initialize(grammar, states, transitions)
+        @grammar = grammar
+        @states = states
+        @transitions = transitions
+        @contributions = Array.new(states.length) { |state_id| action_contributions(state_id) }
+      end
+
+      # @rbs () -> [Array[packed_items], transitions]
+      def build
+        partitions = refine_transitions(initial_partitions)
+        indexes = partition_indexes(partitions)
+        items = partitions.map { |members| merge_items(members) }
+        transitions = partitions.map do |members|
+          @transitions.fetch(members.first).to_h do |symbol_id, target|
+            [symbol_id, indexes.fetch(target)]
+          end
+        end
+        [items, transitions]
+      end
+
+      private
+
+      # @rbs () -> Array[state_partition]
+      def initial_partitions
+        cores = {} #: Hash[Array[item_core], Array[Integer]]
+        @states.each_with_index do |items, state_id|
+          cores[core_key(items)] ||= []
+          cores.fetch(core_key(items)) << state_id
+        end
+        cores.values.flat_map { |members| compatible_partitions(members) }
+      end
+
+      # @rbs (Array[Integer] members) -> Array[state_partition]
+      def compatible_partitions(members)
+        partitions = [] #: Array[state_partition]
+        members.each do |state_id|
+          partition = partitions.find { |candidate| compatible?(candidate + [state_id]) }
+          partition ? partition << state_id : partitions << [state_id]
+        end
+        partitions
+      end
+
+      # A canonical member may gain an action only where it previously had no
+      # action. Every nonempty member cell must equal the merged cell.
+      # @rbs (state_partition members) -> bool
+      def compatible?(members)
+        merged = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[Array[untyped]]]
+        members.each do |state_id|
+          @contributions.fetch(state_id).each { |token_id, actions| merged[token_id].merge(actions) }
+        end
+        merged.all? do |token_id, actions|
+          members.all? do |state_id|
+            member_actions = @contributions.fetch(state_id)[token_id]
+            member_actions.nil? || member_actions.empty? || member_actions == actions
+          end
+        end
+      end
+
+      # @rbs (Array[state_partition] partitions) -> Array[state_partition]
+      def refine_transitions(partitions)
+        loop do
+          indexes = partition_indexes(partitions)
+          refined = partitions.flat_map do |members|
+            members.group_by { |state_id| transition_signature(state_id, indexes) }.values
+          end
+          return partitions if refined == partitions
+
+          partitions = refined
+        end
+      end
+
+      # @rbs (Integer state_id, Hash[Integer, Integer] indexes) -> Array[[Integer, Integer]]
+      def transition_signature(state_id, indexes)
+        @transitions.fetch(state_id).map do |symbol_id, target|
+          [symbol_id, indexes.fetch(target)] #: [Integer, Integer]
+        end.sort
+      end
+
+      # @rbs (Array[state_partition] partitions) -> Hash[Integer, Integer]
+      def partition_indexes(partitions)
+        indexes = {} #: Hash[Integer, Integer]
+        partitions.each_with_index do |members, partition_id|
+          members.each { |state_id| indexes[state_id] = partition_id }
+        end
+        indexes
+      end
+
+      # @rbs (state_partition members) -> packed_items
+      def merge_items(members)
+        merged = Hash.new { |hash, key| hash[key] = Set.new } #: packed_items
+        members.each do |state_id|
+          @states.fetch(state_id).each do |production_id, dot, lookahead|
+            merged[[production_id, dot]] << lookahead
+          end
+        end
+        merged
+      end
+
+      # @rbs (Integer state_id) -> Hash[Integer, Set[Array[untyped]]]
+      def action_contributions(state_id)
+        actions = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[Integer, Set[Array[untyped]]]
+        @transitions.fetch(state_id).each_key do |symbol_id|
+          symbol = @grammar.symbol_by_id(symbol_id)
+          actions[symbol_id] << [:shift] if symbol&.terminal?
+        end
+        @states.fetch(state_id).each do |production_id, dot, lookahead|
+          next unless dot == rhs_for(production_id).length
+
+          action = production_id.negative? ? [:accept] : [:reduce, production_id]
+          actions[lookahead] << action
+        end
+        actions
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        if production_id.negative?
+          name = @grammar.starts.fetch(-production_id - 1)
+          start = @grammar.symbol(name) || raise(Ibex::Error, "missing start symbol #{name}")
+          return [start.id]
+        end
+
+        @grammar.productions.fetch(production_id).rhs
+      end
+
+      # @rbs (item_set items) -> Array[item_core]
+      def core_key(items)
+        items.map do |production_id, dot, _lookahead|
+          [production_id, dot] #: item_core
+        end.uniq.sort
+      end
+    end
+  end
+end

data/lib/ibex/lalr/on_error_reductions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LALR
+    # Delays syntax-error detection by filling only otherwise erroneous table
+    # cells with one uniquely highest-priority declared reduction.
+    module OnErrorReductions
+      # @rbs (IR::Grammar grammar, Array[IR::AutomatonState] states) -> Array[IR::AutomatonState]
+      def apply(grammar, states)
+        priorities = reduction_priorities(grammar)
+        return states if priorities.empty?
+
+        terminal_ids = grammar.terminals.reject { |terminal| terminal.name == "error" }.map(&:id)
+        states.map { |state| apply_state(grammar, state, priorities, terminal_ids) }
+      end
+      module_function :apply
+
+      # @rbs (IR::Grammar grammar) -> Hash[Integer, Integer]
+      def reduction_priorities(grammar)
+        priorities = {} #: Hash[Integer, Integer]
+        grammar.recovery[:on_error_reduce].each_with_index do |names, priority|
+          names.each do |name|
+            symbol = grammar.symbol(name) || raise(Ibex::Error, "missing on-error reduction symbol #{name}")
+            priorities[symbol.id] = priority
+          end
+        end
+        priorities
+      end
+
+      # @rbs (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities,
+      #   Array[Integer] terminal_ids) -> IR::AutomatonState
+      def apply_state(grammar, state, priorities, terminal_ids)
+        production_id = selected_production(grammar, state, priorities)
+        return state unless production_id
+
+        reduction = { type: :reduce, production: production_id } #: IR::reduce_action
+        actions = state.actions.dup
+        terminal_ids.each do |token_id|
+          action = actions[token_id]
+          actions[token_id] = reduction if action.nil? || action[:type] == :error
+        end
+        IR::AutomatonState.new(
+          id: state.id, items: state.items, transitions: state.transitions,
+          actions: actions, gotos: state.gotos, default_action: state.default_action,
+          conflicts: state.conflicts
+        )
+      end
+
+      # @rbs (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities) -> Integer?
+      def selected_production(grammar, state, priorities)
+        candidates = state.items.filter_map do |item|
+          next if item.production.negative?
+
+          production = grammar.productions.fetch(item.production)
+          next unless item.dot == production.rhs.length
+
+          priority = priorities[production.lhs]
+          [priority, production.id] if priority
+        end.uniq
+        highest = candidates.filter_map(&:first).max
+        return unless highest
+
+        productions = candidates.filter_map { |priority, production| production if priority == highest }.uniq
+        productions.one? ? productions.fetch(0) : nil
+      end
+
+      module_function :reduction_priorities, :apply_state, :selected_production
+
+      class << self
+        private :reduction_priorities, :apply_state, :selected_production
+      end
+    end
+  end
+end

data/lib/ibex/lalr.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "lalr/conflict"
+require_relative "lalr/on_error_reductions"
 require_relative "lalr/default_reductions"
+require_relative "lalr/build_metrics"
+require_relative "lalr/direct_lookaheads"
+require_relative "lalr/ielr_partition"
 require_relative "lalr/builder"
 require_relative "lalr/conflict_search_limits"
 require_relative "lalr/conflict_search"
@@ -12,9 +16,12 @@ module Ibex
     # @rbs!
     #   type lr_item = [Integer, Integer, Integer]
     #   type item_core = [Integer, Integer]
+    #   type core_set = Set[item_core]
     #   type item_set = Set[lr_item]
     #   type packed_items = Hash[item_core, Set[Integer]]
     #   type transitions = Array[Hash[Integer, Integer]]
+    #   type lookahead_node = [Integer, Integer, Integer]
+    #   type state_partition = Array[Integer]
     #   type derivation_node = Hash[Symbol, untyped]
     #   type search_status = :conflict | :shifted | :accepted
     #   type search_entry = [search_status, ConflictSearch::Configuration]

data/lib/ibex/location.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  # Immutable source range suitable for lexer tokens and parser diagnostics.
+  #
+  # Coordinates are one-based. Byte offsets are optional, zero-based, and
+  # half-open. Keeping both forms lets Unicode-aware lexers report human
+  # columns without losing an exact source slice.
+  class Location
+    attr_reader :file #: String?
+    attr_reader :line #: Integer
+    attr_reader :column #: Integer
+    attr_reader :end_line #: Integer
+    attr_reader :end_column #: Integer
+    attr_reader :start_byte #: Integer?
+    attr_reader :end_byte #: Integer?
+    attr_reader :source_line #: String?
+
+    # @rbs (?file: String?, line: Integer, column: Integer, ?end_line: Integer?,
+    #   ?end_column: Integer?, ?start_byte: Integer?, ?end_byte: Integer?, ?source_line: String?) -> void
+    def initialize(line:, column:, file: nil, end_line: nil, end_column: nil,
+                   start_byte: nil, end_byte: nil, source_line: nil)
+      @file = file&.dup&.freeze
+      @line = positive_coordinate(:line, line)
+      @column = positive_coordinate(:column, column)
+      @end_line = positive_coordinate(:end_line, end_line || line)
+      @end_column = positive_coordinate(:end_column, end_column || column)
+      @start_byte = optional_offset(:start_byte, start_byte)
+      @end_byte = optional_offset(:end_byte, end_byte)
+      @source_line = source_line&.dup&.freeze
+      validate_order!
+      freeze
+    end
+
+    # Return the smallest range covering both locations.
+    # @rbs (Location other) -> Location
+    def join(other)
+      raise ArgumentError, "location files differ" unless file == other.file
+
+      first = before_or_equal?(self, other) ? self : other
+      ending = before_or_equal_end?(self, other) ? other : self
+      self.class.new(
+        file: file, line: first.line, column: first.column,
+        end_line: ending.end_line, end_column: ending.end_column,
+        start_byte: joined_start_byte(other), end_byte: joined_end_byte(other),
+        source_line: first.source_line
+      )
+    end
+
+    # Fold a nonempty collection into one covering range.
+    # @rbs (Enumerable[Location] locations) -> Location
+    def self.join(locations)
+      values = locations.to_a
+      first = values.shift || raise(ArgumentError, "locations must not be empty")
+      values.reduce(first) { |combined, location| combined.join(location) }
+    end
+
+    # @rbs () -> bool
+    def empty?
+      @line == @end_line && @column == @end_column &&
+        (@start_byte.nil? || @end_byte.nil? || @start_byte == @end_byte)
+    end
+
+    # @rbs () -> Hash[Symbol, untyped]
+    def to_h
+      {
+        file: @file, line: @line, column: @column,
+        end_line: @end_line, end_column: @end_column,
+        start_byte: @start_byte, end_byte: @end_byte
+      }.compact
+    end
+
+    private
+
+    # @rbs (Symbol name, untyped value) -> Integer
+    def positive_coordinate(name, value)
+      return value if value.is_a?(Integer) && value.positive?
+
+      raise ArgumentError, "#{name} must be a positive Integer"
+    end
+
+    # @rbs (Symbol name, untyped value) -> Integer?
+    def optional_offset(name, value)
+      return if value.nil?
+      return value if value.is_a?(Integer) && value >= 0
+
+      raise ArgumentError, "#{name} must be a nonnegative Integer or nil"
+    end
+
+    # @rbs () -> void
+    def validate_order!
+      if @end_line < @line || (@end_line == @line && @end_column < @column)
+        raise ArgumentError, "end position precedes start position"
+      end
+
+      start_byte = @start_byte
+      end_byte = @end_byte
+      return unless start_byte && end_byte && end_byte < start_byte
+
+      raise ArgumentError, "end_byte precedes start_byte"
+    end
+
+    # @rbs (Location left, Location right) -> bool
+    def before_or_equal?(left, right)
+      left.line < right.line || (left.line == right.line && left.column <= right.column)
+    end
+
+    # @rbs (Location left, Location right) -> bool
+    def before_or_equal_end?(left, right)
+      left.end_line < right.end_line ||
+        (left.end_line == right.end_line && left.end_column <= right.end_column)
+    end
+
+    # @rbs (Location other) -> Integer?
+    def joined_start_byte(other)
+      return unless @start_byte && other.start_byte
+
+      [@start_byte, other.start_byte].min
+    end
+
+    # @rbs (Location other) -> Integer?
+    def joined_end_byte(other)
+      return unless @end_byte && other.end_byte
+
+      [@end_byte, other.end_byte].max
+    end
+  end
+end

data/lib/ibex/lsp/document_handlers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Applies full-text LSP document notifications to the overlay-backed store.
+    module DocumentHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (untyped raw_params) -> nil
+      def did_open(raw_params)
+        require_running!
+        params = params_hash(raw_params)
+        document = hash_member(params, "textDocument")
+        publications = store.open(
+          string_member(document, "uri"), integer_member(document, "version"), string_member(document, "text")
+        )
+        publish(publications)
+        nil
+      end
+
+      # @rbs (untyped raw_params) -> nil
+      def did_change(raw_params)
+        require_running!
+        params = params_hash(raw_params)
+        document = hash_member(params, "textDocument")
+        changes = params["contentChanges"]
+        unless changes.is_a?(Array) && changes.one? && changes.first.is_a?(Hash) &&
+               !changes.first.key?("range") && !changes.first.key?("rangeLength")
+          raise ProtocolError.new("full sync requires exactly one range-free content change", code: -32_602)
+        end
+
+        source = string_member(changes.fetch(0), "text")
+        publications = store.change(
+          string_member(document, "uri"), integer_member(document, "version"), source
+        )
+        publish(publications)
+        nil
+      end
+
+      # @rbs (untyped raw_params) -> nil
+      def did_save(raw_params)
+        require_running!
+        params = params_hash(raw_params)
+        document = hash_member(params, "textDocument")
+        source = params["text"]
+        unless source.nil? || source.is_a?(String)
+          raise ProtocolError.new("saved document text must be a string", code: -32_602)
+        end
+
+        publish(store.save(string_member(document, "uri"), source: source))
+        nil
+      end
+
+      # @rbs (untyped raw_params) -> nil
+      def did_close(raw_params)
+        require_running!
+        params = params_hash(raw_params)
+        document = hash_member(params, "textDocument")
+        publish(store.close(string_member(document, "uri")))
+        nil
+      end
+    end
+  end
+end