ibex 0.2.0 → 0.3.0

data/lib/ibex/lalr.rb

@@ -4,6 +4,18 @@ require_relative "lalr/conflict"
 require_relative "lalr/on_error_reductions"
 require_relative "lalr/default_reductions"
 require_relative "lalr/build_metrics"
+require_relative "lalr/lr0_collection"
+require_relative "lalr/goto_follows"
+require_relative "lalr/lookahead_propagation"
+require_relative "lalr/unreachable_states"
+require_relative "lalr/ielr/bits"
+require_relative "lalr/ielr/inadequacy"
+require_relative "lalr/ielr/item_lookaheads"
+require_relative "lalr/ielr/split_stability"
+require_relative "lalr/ielr/annotator"
+require_relative "lalr/ielr/split_state"
+require_relative "lalr/ielr/state_splitter"
+require_relative "lalr/ielr/pipeline"
 require_relative "lalr/direct_lookaheads"
 require_relative "lalr/ielr_partition"
 require_relative "lalr/builder"
@@ -20,9 +32,29 @@ module Ibex
     #   type item_set = Set[lr_item]
     #   type packed_items = Hash[item_core, Set[Integer]]
     #   type transitions = Array[Hash[Integer, Integer]]
+    #   type build_collection = {
+    #     construction_states: Integer,
+    #     canonical_states: Integer?,
+    #     strategy: Symbol,
+    #     lr0_states: Integer?,
+    #     lr0_items: Integer?,
+    #     canonical_items: Integer?,
+    #     propagation_edges: Integer?,
+    #     ielr_initial_partitions: Integer?,
+    #     ielr_final_partitions: Integer?,
+    #     ielr_annotations: Integer?,
+    #     ielr_annotated_states: Integer?,
+    #     ielr_inadequacies: Integer?,
+    #     ielr_split_stable_discarded: Integer?,
+    #     ielr_lalr_states: Integer?,
+    #     ielr_split_states: Integer?,
+    #     ielr_unreachable_removed: Integer?,
+    #     ielr_remergeable_candidates: Integer?
+    #   }
+    #   type conflict_fingerprint = [Symbol, String, Array[Integer]]
     #   type lookahead_node = [Integer, Integer, Integer]
     #   type state_partition = Array[Integer]
-    #   type derivation_node = Hash[Symbol, untyped]
+    #   type derivation_node = Hash[Symbol, Object?]
     #   type search_status = :conflict | :shifted | :accepted
     #   type search_entry = [search_status, ConflictSearch::Configuration]
     #   type search_result = {
@@ -30,5 +62,24 @@ module Ibex
     #     lookahead_index: Integer,
     #     interpretations: Array[IR::interpretation]
     #   }
+    #   type search_bounds = { max_tokens: Integer, max_configurations: Integer }
+    #   type search_outcome = {
+    #     status: :found | :not_found | :exhausted,
+    #     result: search_result?,
+    #     explored: Integer,
+    #     exhausted: bool,
+    #     bounds: search_bounds
+    #   }
+    #   type search_counterexample = {
+    #     state: Integer,
+    #     type: Symbol,
+    #     symbol_path: Array[String],
+    #     sentence: Array[String],
+    #     lookahead_index: Integer,
+    #     unifying: bool,
+    #     inconclusive: bool,
+    #     search: search_outcome,
+    #     interpretations: Array[IR::interpretation]
+    #   }
   end
 end

data/lib/ibex/location.rb

@@ -62,7 +62,7 @@ module Ibex
         (@start_byte.nil? || @end_byte.nil? || @start_byte == @end_byte)
     end
 
-    # @rbs () -> Hash[Symbol, untyped]
+    # @rbs () -> Hash[Symbol, String | Integer]
     def to_h
       {
         file: @file, line: @line, column: @column,
@@ -73,14 +73,14 @@ module Ibex
 
     private
 
-    # @rbs (Symbol name, untyped value) -> Integer
+    # @rbs (Symbol name, Object? 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?
+    # @rbs (Symbol name, Object? value) -> Integer?
     def optional_offset(name, value)
       return if value.nil?
       return value if value.is_a?(Integer) && value >= 0

data/lib/ibex/lsp/document_handlers.rb

@@ -8,7 +8,7 @@ module Ibex
 
       private
 
-      # @rbs (untyped raw_params) -> nil
+      # @rbs (lsp_value? raw_params) -> nil
       def did_open(raw_params)
         require_running!
         params = params_hash(raw_params)
@@ -20,18 +20,20 @@ module Ibex
         nil
       end
 
-      # @rbs (untyped raw_params) -> nil
+      # @rbs (lsp_value? 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")
+        first_change = changes.is_a?(Array) ? changes.first : nil
+        unless changes.is_a?(Array) && changes.one? && first_change.is_a?(Hash) &&
+               !first_change.key?("range") && !first_change.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")
+        change = changes.fetch(0) #: lsp_object
+        source = string_member(change, "text")
         publications = store.change(
           string_member(document, "uri"), integer_member(document, "version"), source
         )
@@ -39,7 +41,7 @@ module Ibex
         nil
       end
 
-      # @rbs (untyped raw_params) -> nil
+      # @rbs (lsp_value? raw_params) -> nil
       def did_save(raw_params)
         require_running!
         params = params_hash(raw_params)
@@ -53,7 +55,7 @@ module Ibex
         nil
       end
 
-      # @rbs (untyped raw_params) -> nil
+      # @rbs (lsp_value? raw_params) -> nil
       def did_close(raw_params)
         require_running!
         params = params_hash(raw_params)

data/lib/ibex/lsp/initialization_handlers.rb

@@ -8,7 +8,7 @@ module Ibex
 
       private
 
-      # @rbs (untyped raw_params) -> Hash[String, untyped]
+      # @rbs (lsp_value? raw_params) -> lsp_object
       def initialize_workspace(raw_params)
         raise ProtocolError.new("server is already initialized", code: -32_600) unless @state == :uninitialized
 
@@ -23,28 +23,28 @@ module Ibex
         }
       end
 
-      # @rbs (untyped params) -> nil
+      # @rbs (lsp_value? params) -> nil
       def initialized_notification(_params)
         require_state!(:initialized)
         @state = :running
         nil
       end
 
-      # @rbs (untyped params) -> nil
+      # @rbs (lsp_value? params) -> nil
       def shutdown_request(_params)
         require_state!(:running)
         @state = :shutdown
         nil
       end
 
-      # @rbs (untyped params) -> nil
+      # @rbs (lsp_value? params) -> nil
       def exit_notification(_params)
         @exit_status = @state == :shutdown ? 0 : 1
         @exit_requested = true
         nil
       end
 
-      # @rbs () -> Hash[String, untyped]
+      # @rbs () -> lsp_object
       def capabilities
         {
           "positionEncoding" => "utf-16",
@@ -53,18 +53,20 @@ module Ibex
           "referencesProvider" => true,
           "renameProvider" => { "prepareProvider" => true },
           "hoverProvider" => true,
+          "completionProvider" => { "resolveProvider" => false },
           "workspace" => { "workspaceFolders" => { "supported" => true, "changeNotifications" => false } }
         }
       end
 
-      # @rbs (Hash[String, untyped] params) -> Array[String]
+      # @rbs (lsp_object params) -> Array[String]
       def initialization_roots(params)
         folders = params["workspaceFolders"]
         if folders.is_a?(Array) && !folders.empty?
           return folders.map do |folder|
             raise ProtocolError.new("workspaceFolders entries must be objects", code: -32_602) unless folder.is_a?(Hash)
 
-            string_member(folder, "uri")
+            folder_object = folder #: lsp_object
+            string_member(folder_object, "uri")
           end
         end
 

data/lib/ibex/lsp/navigation_handlers.rb

@@ -8,39 +8,53 @@ module Ibex
 
       private
 
-      # @rbs (untyped raw_params) -> Array[Hash[String, untyped]]
+      # @rbs (lsp_object? raw_params) -> Array[lsp_object]
       def definition(raw_params)
-        with_index(raw_params) { |index, path, position| index.definition(path, position) }
+        with_index(raw_params) { |index, path, position| index.definition(path, position) } #: Array[lsp_object]
       end
 
-      # @rbs (untyped raw_params) -> Array[Hash[String, untyped]]
+      # @rbs (lsp_object? raw_params) -> Array[lsp_object]
       def references(raw_params)
         params = params_hash(raw_params)
         context = hash_member(params, "context")
         include_declaration = context["includeDeclaration"] == true
         with_index(params) do |index, path, position|
           index.references(path, position, include_declaration: include_declaration)
-        end
+        end #: Array[lsp_object]
       end
 
-      # @rbs (untyped raw_params) -> Hash[String, untyped]?
+      # @rbs (lsp_object? raw_params) -> lsp_object?
       def prepare_rename(raw_params)
-        with_index(raw_params) { |index, path, position| index.prepare_rename(path, position) }
+        with_index(raw_params) { |index, path, position| index.prepare_rename(path, position) } #: lsp_object?
       end
 
-      # @rbs (untyped raw_params) -> Hash[String, untyped]
+      # @rbs (lsp_object? raw_params) -> lsp_object
       def rename(raw_params)
         params = params_hash(raw_params)
         new_name = string_member(params, "newName")
-        with_index(params) { |index, path, position| index.rename(path, position, new_name) }
+        with_index(params) { |index, path, position| index.rename(path, position, new_name) } #: lsp_object
       end
 
-      # @rbs (untyped raw_params) -> Hash[String, untyped]?
+      # @rbs (lsp_object? raw_params) -> lsp_object?
       def hover(raw_params)
-        with_index(raw_params) { |index, path, position| index.hover(path, position) }
+        with_index(raw_params) do |index, path, position|
+          index.hover(path, position) || ParserConfigurationAssistance.new(store, path).hover(position)
+        end #: lsp_object?
       end
 
-      # @rbs (untyped raw_params) { (SymbolIndex, String, Hash[String, untyped]) -> untyped } -> untyped
+      # @rbs (lsp_object? raw_params) -> lsp_object
+      def completion(raw_params)
+        require_running!
+        params = params_hash(raw_params)
+        document = hash_member(params, "textDocument")
+        path = workspace.path(string_member(document, "uri"))
+        position = hash_member(params, "position")
+        ParserConfigurationAssistance.new(store, path).completion(position)
+      rescue ArgumentError => e
+        raise ProtocolError.new(e.message, code: -32_602)
+      end
+
+      # @rbs (lsp_object? raw_params) { (SymbolIndex, String, lsp_object) -> Object? } -> Object?
       def with_index(raw_params)
         require_running!
         params = params_hash(raw_params)

data/lib/ibex/lsp/parser_configuration_assistance.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Ibex
+  module LSP
+    # Provides static editor assistance for the root parser declaration without evaluating grammar code.
+    class ParserConfigurationAssistance
+      SETTING_VALUES = Frontend::ParserConfigurationSupport::PARSER_SETTING_VALUES #: Hash[String, Array[String]]
+      SETTING_DOCUMENTATION = {
+        "algorithm" => "`parser.algorithm` selects parser-table construction. Values: `slr`, `lalr`, `ielr`, `lr1`.",
+        "entries" => "`parser.entries` selects shared or isolated construction for multiple start symbols. " \
+                     "Values: `shared`, `isolated`.",
+        "cst_trivia" => "`cst.trivia` selects CST trivia ownership. Values: `leading`, `balanced`, `drop`; " \
+                        "requires `pragma cst`."
+      }.freeze #: Hash[String, String]
+      VALUE_DOCUMENTATION = {
+        "slr" => "`slr` — SLR parser-table construction.",
+        "lalr" => "`lalr` — LALR parser-table construction.",
+        "ielr" => "`ielr` — IELR parser-table construction with canonical LR(1) verification support.",
+        "lr1" => "`lr1` — canonical LR(1) parser-table construction.",
+        "shared" => "`shared` — construct multiple entries in one shared automaton.",
+        "isolated" => "`isolated` — construct each of multiple entries independently.",
+        "leading" => "`leading` — attach leading trivia to the following CST node.",
+        "balanced" => "`balanced` — attach trivia between the surrounding CST nodes.",
+        "drop" => "`drop` — omit CST trivia; location and incremental APIs are unavailable."
+      }.freeze #: Hash[String, String]
+
+      # @rbs (DocumentStore store, String path) -> void
+      def initialize(store, path)
+        @store = store
+        @path = path
+      end
+
+      # @rbs (lsp_object position) -> lsp_object
+      def completion(position)
+        source = source!
+        codec = PositionCodec.new(source)
+        offset = codec.byte_offset(position)
+        line_start = line_start(source, offset)
+        return completion_list([]) unless parser_block_open?(source.byteslice(0, line_start) || "")
+
+        prefix = source.byteslice(line_start, offset - line_start) || ""
+        value_match = prefix.match(/\A\s*(algorithm|entries|cst_trivia)\s+([A-Za-z_]*)\z/)
+        if value_match
+          setting = value_match[1] || raise("parser setting capture is missing")
+          return completion_list(value_items(setting))
+        end
+        return completion_list(setting_items) if prefix.match?(/\A\s*[A-Za-z_]*\z/)
+
+        completion_list([])
+      end
+
+      # @rbs (lsp_object position) -> lsp_object?
+      def hover(position)
+        source = source!
+        codec = PositionCodec.new(source)
+        offset = codec.byte_offset(position)
+        start = line_start(source, offset)
+        return unless parser_block_open?(source.byteslice(0, start) || "")
+
+        finish = source.index("\n", start) || source.bytesize
+        line = source.byteslice(start, finish - start) || ""
+        match = line.match(
+          /\A\s*(algorithm|entries|cst_trivia)\s+(slr|lalr|ielr|lr1|shared|isolated|leading|balanced|drop)\s*(?:#.*)?\z/
+        )
+        return unless match
+
+        token, token_start, token_end = hovered_token(match, line, start, offset)
+        return unless token
+
+        documentation = SETTING_DOCUMENTATION[token] || VALUE_DOCUMENTATION[token]
+        {
+          "contents" => { "kind" => "markdown", "value" => documentation },
+          "range" => { "start" => codec.position(token_start), "end" => codec.position(token_end) }
+        }
+      end
+
+      private
+
+      # @rbs () -> String
+      def source!
+        snapshot = @store.snapshot_for(@path)
+        raise ArgumentError, "document is unavailable" unless snapshot
+
+        snapshot.fetch(:source)
+      end
+
+      # @rbs (String source, Integer offset) -> Integer
+      def line_start(source, offset)
+        newline = offset.positive? ? source.rindex("\n", offset - 1) : nil
+        newline ? newline + 1 : 0
+      end
+
+      # @rbs (String source) -> bool
+      def parser_block_open?(source)
+        root = false
+        open = false
+        source.each_line do |line|
+          content = line.sub(/#.*/, "").strip
+          next if content.empty?
+
+          root = true if content.match?(/\Aclass\b/)
+          root = false if content.match?(/\Afragment\b/)
+          open = true if root && content == "parser"
+          open = false if open && content == "end"
+          return false if content.match?(/\Arule\b/)
+        end
+        root && open
+      end
+
+      # @rbs () -> Array[lsp_object]
+      def setting_items
+        SETTING_VALUES.keys.map do |name|
+          completion_item(name, 10, SETTING_DOCUMENTATION.fetch(name))
+        end
+      end
+
+      # @rbs (String setting) -> Array[lsp_object]
+      def value_items(setting)
+        SETTING_VALUES.fetch(setting).map do |name|
+          completion_item(name, 12, VALUE_DOCUMENTATION.fetch(name))
+        end
+      end
+
+      # @rbs (String label, Integer kind, String documentation) -> lsp_object
+      def completion_item(label, kind, documentation)
+        { "label" => label, "kind" => kind, "documentation" => { "kind" => "markdown", "value" => documentation } }
+      end
+
+      # @rbs (Array[lsp_object] items) -> lsp_object
+      def completion_list(items)
+        { "isIncomplete" => false, "items" => items }
+      end
+
+      # @rbs (MatchData match, String line, Integer line_start, Integer offset) -> [String?, Integer, Integer]
+      def hovered_token(match, line, line_start, offset)
+        [1, 2].each do |capture|
+          token = match[capture]
+          next unless token
+
+          before = line[0...match.begin(capture)] || ""
+          start = line_start + before.bytesize
+          finish = start + token.bytesize
+          return [token, start, finish] if offset.between?(start, finish - 1)
+        end
+        [nil, offset, offset]
+      end
+    end
+  end
+end

data/lib/ibex/lsp/position_codec.rb

@@ -2,6 +2,10 @@
 
 module Ibex
   module LSP
+    # @rbs!
+    #   type lsp_value = String | Integer | Float | bool | nil | Array[lsp_value] | Hash[String, lsp_value]
+    #   type lsp_object = Hash[String, lsp_value]
+
     # Converts between frontend byte offsets and zero-based LSP UTF-16 positions.
     class PositionCodec
       # @rbs (String source) -> void
@@ -25,7 +29,7 @@ module Ibex
         { "line" => line, "character" => utf16_length(text) }
       end
 
-      # @rbs (Hash[String, untyped] position) -> Integer
+      # @rbs (lsp_object position) -> Integer
       def byte_offset(position)
         line = integer_member(position, "line")
         character = integer_member(position, "character")
@@ -90,7 +94,7 @@ module Ibex
         raise ArgumentError, "character is outside the document line"
       end
 
-      # @rbs (Hash[String, untyped] position, String name) -> Integer
+      # @rbs (lsp_object position, String name) -> Integer
       def integer_member(position, name)
         value = position[name]
         raise ArgumentError, "#{name} must be an integer" unless value.is_a?(Integer)

data/lib/ibex/lsp/request_handlers.rb

@@ -23,12 +23,13 @@ module Ibex
         "textDocument/prepareRename" => :prepare_rename,
         "textDocument/rename" => :rename,
         "textDocument/hover" => :hover,
+        "textDocument/completion" => :completion,
         "$/cancelRequest" => :cancel_request
       }.freeze #: Hash[String, Symbol]
 
       private
 
-      # @rbs (String method, untyped params) -> untyped
+      # @rbs (String method, lsp_value? params) -> lsp_value?
       def dispatch(method, params)
         handler = HANDLERS[method]
         raise ProtocolError.new("method not found: #{method}", code: -32_601) unless handler
@@ -36,7 +37,7 @@ module Ibex
         send(handler, params)
       end
 
-      # @rbs (untyped params) -> nil
+      # @rbs (lsp_value? params) -> nil
       def cancel_request(_params)
         nil
       end

data/lib/ibex/lsp/request_support.rb

@@ -15,7 +15,7 @@ module Ibex
           params = {
             "uri" => publication.fetch(:uri),
             "diagnostics" => publication.fetch(:diagnostics)
-          } #: Hash[String, untyped]
+          } #: lsp_object
           params["version"] = version if version
           @transport.write_message(
             "jsonrpc" => "2.0", "method" => "textDocument/publishDiagnostics", "params" => params
@@ -29,23 +29,30 @@ module Ibex
         store.snapshot_for(path)&.fetch(:version) != version
       end
 
-      # @rbs (untyped value) -> Hash[String, untyped]
+      # @rbs (lsp_value? value) -> lsp_object
       def params_hash(value)
         return {} if value.nil?
-        return value if value.is_a?(Hash)
+
+        if value.is_a?(Hash)
+          result = value #: lsp_object
+          return result
+        end
 
         raise ProtocolError.new("params must be an object", code: -32_602)
       end
 
-      # @rbs (Hash[String, untyped] value, String name) -> Hash[String, untyped]
+      # @rbs (lsp_object value, String name) -> lsp_object
       def hash_member(value, name)
         member = value[name]
-        return member if member.is_a?(Hash)
+        if member.is_a?(Hash)
+          result = member #: lsp_object
+          return result
+        end
 
         raise ProtocolError.new("#{name} must be an object", code: -32_602)
       end
 
-      # @rbs (Hash[String, untyped] value, String name) -> String
+      # @rbs (lsp_object value, String name) -> String
       def string_member(value, name)
         member = value[name]
         return member if member.is_a?(String)
@@ -53,7 +60,7 @@ module Ibex
         raise ProtocolError.new("#{name} must be a string", code: -32_602)
       end
 
-      # @rbs (Hash[String, untyped] value, String name) -> Integer
+      # @rbs (lsp_object value, String name) -> Integer
       def integer_member(value, name)
         member = value[name]
         return member if member.is_a?(Integer)

data/lib/ibex/lsp/server.rb

@@ -8,14 +8,14 @@ module Ibex
 
       REQUEST_METHODS = %w[
         initialize shutdown textDocument/definition textDocument/references textDocument/prepareRename
-        textDocument/rename textDocument/hover
+        textDocument/rename textDocument/hover textDocument/completion
       ].freeze #: Array[String]
       NOTIFICATION_METHODS = %w[
         initialized exit textDocument/didOpen textDocument/didChange textDocument/didSave textDocument/didClose
         $/cancelRequest
       ].freeze #: Array[String]
 
-      # @rbs (stdin: untyped, stdout: untyped, stderr: untyped) -> void
+      # @rbs (stdin: Transport::_Input, stdout: Transport::_Output, stderr: Object?) -> void
       def initialize(stdin:, stdout:, stderr:)
         @transport = Transport.new(stdin, stdout)
         @stderr = stderr
@@ -37,7 +37,7 @@ module Ibex
 
       private
 
-      # @rbs () -> Hash[String, untyped]?
+      # @rbs () -> lsp_object?
       def read_message
         @transport.read_message
       rescue ProtocolError => e
@@ -47,12 +47,12 @@ module Ibex
         nil
       end
 
-      # @rbs (Hash[String, untyped] message) -> void
+      # @rbs (lsp_object message) -> void
       def process_message(message)
         request_id = safe_request_id(message)
         notification = notification_envelope?(message)
         request_id = validate_envelope(message)
-        method = message.fetch("method")
+        method = message.fetch("method") #: String
         validate_message_kind!(method, message.key?("id"))
         return if request_id.nil? && method.start_with?("$/")
 
@@ -66,13 +66,15 @@ module Ibex
         notification ? log(error.message) : send_error(request_id, error)
       end
 
-      # @rbs (Hash[String, untyped] message) -> (String | Integer)?
+      # @rbs (lsp_object message) -> (String | Integer)?
       def safe_request_id(message)
         value = message["id"]
+        return unless value.is_a?(String) || value.is_a?(Integer)
+
         value if valid_request_id?(value)
       end
 
-      # @rbs (Hash[String, untyped] message) -> bool
+      # @rbs (lsp_object message) -> bool
       def notification_envelope?(message)
         !message.key?("id") && message["jsonrpc"] == "2.0" && message["method"].is_a?(String)
       end
@@ -87,7 +89,7 @@ module Ibex
         raise ProtocolError.new("#{method} must be a notification", code: -32_600)
       end
 
-      # @rbs (Hash[String, untyped] message) -> (String | Integer)?
+      # @rbs (lsp_object message) -> (String | Integer)?
       def validate_envelope(message)
         unless message["jsonrpc"] == "2.0" && message["method"].is_a?(String)
           raise ProtocolError.new("invalid JSON-RPC request", code: -32_600)
@@ -95,14 +97,14 @@ module Ibex
         return nil unless message.key?("id")
 
         request_id = message["id"]
-        unless valid_request_id?(request_id)
+        unless (request_id.is_a?(String) || request_id.is_a?(Integer)) && valid_request_id?(request_id)
           raise ProtocolError.new("request id must be a bounded string or integer", code: -32_600)
         end
 
         request_id
       end
 
-      # @rbs (untyped value) -> bool
+      # @rbs (Object? value) -> bool
       def valid_request_id?(value)
         return false unless value.is_a?(String) || value.is_a?(Integer)
 
@@ -120,7 +122,7 @@ module Ibex
         raise ProtocolError.new("request is invalid in #{@state} server state", code: code)
       end
 
-      # @rbs (String | Integer request_id, untyped result) -> void
+      # @rbs (String | Integer request_id, lsp_value result) -> void
       def send_result(request_id, result)
         @transport.write_message("jsonrpc" => "2.0", "id" => request_id, "result" => result)
       rescue ProtocolError => e