expressir 2.4.35-arm-linux → 2.4.37-arm-linux

data/lib/expressir/lsp/document.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Lsp
+    # An open document: source text, last good AST, and the LSP position
+    # translations that the protocol needs. Offsets crossing the boundary
+    # are byte offsets into the UTF-8 text; LSP positions are 0-based
+    # UTF-16 line/character pairs.
+    class Document
+      IDENTIFIER = /[A-Za-z][A-Za-z0-9_]*/
+      NAME_WINDOW = 1024
+
+      Token = Struct.new(:text, :start_byte, :byte_length, keyword_init: true) do
+        def end_byte
+          start_byte + byte_length
+        end
+      end
+
+      SYMBOL_KINDS = {
+        Model::Declarations::Schema => 3,     # Namespace
+        Model::Declarations::Entity => 5,     # Class
+        Model::Declarations::Type => 26,      # TypeParameter
+        Model::Declarations::Function => 12,  # Function
+        Model::Declarations::Procedure => 6,  # Method
+        Model::Declarations::Rule => 11,      # Interface
+        Model::Declarations::Constant => 14,  # Constant
+        Model::Declarations::Attribute => 8,  # Field
+        Model::Declarations::Variable => 13,  # Variable
+      }.freeze
+
+      attr_reader :uri, :path, :text, :file, :parse_error
+
+      def initialize(uri:, text:, path: nil)
+        @uri = uri
+        @path = path || uri_path(uri)
+        @text = text.to_s
+        @parse_error = nil
+        parse!
+      end
+
+      def update(text)
+        text = text.to_s
+        return if text == @text
+
+        @text = text
+        parse!
+      end
+
+      def schemas
+        Array(@file&.schemas)
+      end
+
+      def schema_containing(byte)
+        schemas.select { |schema| schema.source_offset.to_i <= byte }
+          .max_by(&:source_offset)
+      end
+
+      def symbols
+        return [] unless @file
+
+        position_index.nodes.filter_map do |entry|
+          node = entry[:node]
+          kind = SYMBOL_KINDS[node.class]
+          next unless kind && node.respond_to?(:id) && node.id && entry[:line]
+
+          {
+            "name" => node.id.to_s,
+            "kind" => kind,
+            "range" => line_range(entry[:line], entry[:end_line] || entry[:line]),
+            "selectionRange" => range_for(node),
+          }
+        end
+      end
+
+      def reference_nodes
+        nodes_of_type(Model::References::SimpleReference)
+      end
+
+      def declaration_nodes
+        nodes_of_type(Model::ModelElement).select do |node|
+          SYMBOL_KINDS.key?(node.class) && node.respond_to?(:id) && node.id
+        end
+      end
+
+      def token_at(position)
+        byte = byte_offset(position["line"], position["character"])
+        return nil unless byte
+
+        line_start = line_starts[position["line"]]
+        line_text = text.byteslice(line_start,
+                                   line_end_byte(position["line"]) - line_start)
+        column = byte - line_start
+        matches = line_text.to_s.b.to_enum(:scan, IDENTIFIER)
+        matches.each do
+          match = Regexp.last_match
+          next unless column.between?(match.begin(0), match.end(0))
+
+          return Token.new(text: match[0],
+                           start_byte: line_start + match.begin(0),
+                           byte_length: match[0].bytesize)
+        end
+        nil
+      end
+
+      def position(byte)
+        byte = 0 if byte.nil? || byte.negative?
+        byte = text.bytesize if byte > text.bytesize
+        line = line_starts.bsearch_index { |start| start > byte }
+        line = line ? line - 1 : line_starts.length - 1
+        prefix = text.byteslice(line_starts[line], byte - line_starts[line]).to_s
+        { "line" => line, "character" => utf16_length(prefix) }
+      end
+
+      def range(start_byte, length)
+        { "start" => position(start_byte),
+          "end" => position(start_byte + length) }
+      end
+
+      def range_for(node)
+        length = node.respond_to?(:id) && node.id ? node.id.to_s.bytesize : 1
+        range(name_offset(node), length)
+      end
+
+      def name_offset(node)
+        offset = node.source_offset.to_i
+        return offset if node.is_a?(Model::Declarations::Attribute)
+
+        if node.respond_to?(:id) && node.id
+          window = text.byteslice(offset, NAME_WINDOW).to_s
+          match = /\b#{Regexp.escape(node.id.to_s)}\b/i.match(window)
+          return offset + match.begin(0) if match
+        end
+        offset
+      end
+
+      def line_range(start_line, end_line)
+        start_byte = line_starts[start_line - 1] || text.bytesize
+        end_byte = line_end_byte(end_line - 1)
+        { "start" => position(start_byte), "end" => position(end_byte) }
+      end
+
+      def byte_offset(line, character)
+        start = line_starts[line]
+        return nil unless start
+
+        byte = start
+        units = 0
+        text.byteslice(start, line_end_byte(line) - start).to_s.each_char do |char|
+          break if units >= character
+
+          units += utf16_code_units(char)
+          byte += char.bytesize
+        end
+        byte
+      end
+
+      private
+
+      def parse!
+        @file = Expressir::Express::Parser.from_exp(@text,
+                                                    include_source: true)
+        @collector = nil
+        @line_starts = nil
+        @parse_error = nil
+      rescue StandardError => e
+        @parse_error = e
+      end
+
+      def position_index
+        Express::NodePositionIndex.new(@file, Express::LineMap.new(@text.b))
+      end
+
+      def nodes_of_type(type)
+        collector.nodes.grep(type)
+      end
+
+      def collector
+        @collector ||= Collector.new.tap { |instance| instance.visit(@file) }
+      end
+
+      class Collector < Express::ModelVisitor
+        attr_reader :nodes
+
+        def initialize
+          super
+          @nodes = []
+        end
+
+        def visit(node)
+          @nodes << node
+          super
+        end
+      end
+
+      def line_starts
+        @line_starts ||= begin
+          bytes = @text.b
+          starts = [0]
+          index = 0
+          while (index = bytes.index("\n", index))
+            starts << (index + 1)
+            index += 1
+          end
+          starts
+        end
+      end
+
+      def line_end_byte(line)
+        following = line_starts[line + 1]
+        following ? following - 1 : @text.bytesize
+      end
+
+      def utf16_length(string)
+        string.each_char.sum { |char| utf16_code_units(char) }
+      end
+
+      def utf16_code_units(char)
+        char.ord > 0xFFFF ? 2 : 1
+      end
+
+      def uri_path(uri)
+        uri.to_s.delete_prefix("file://")
+      end
+    end
+  end
+end

data/lib/expressir/lsp/server.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Expressir
+  module Lsp
+    # JSON-RPC 2.0 transport over stdio (or any IO pair) implementing the
+    # LSP 3.17 subset: lifecycle, text sync, diagnostics, symbols,
+    # definition, references, hover and rename.
+    class Server
+      SUPPORTED_CHARACTERS = "utf-16"
+
+      def initialize(input: $stdin, output: $stdout)
+        @input = input
+        @output = output
+        @workspace = Workspace.new
+        @shutdown = false
+        @exit = false
+      end
+
+      def run
+        while (message = read_message)
+          dispatch(message)
+          break if @exit
+        end
+        @shutdown ? 0 : 1
+      end
+
+      private
+
+      def dispatch(message)
+        method = message["method"]
+        return respond_error(message, -32601, "unknown method #{method}") if method.nil?
+
+        case method
+        when "initialize" then respond(message, initialize_result)
+        when "initialized", "$/cancelRequest" then nil
+        when "shutdown"
+          @shutdown = true
+          respond(message, nil)
+        when "exit" then @exit = true
+        when "textDocument/didOpen" then did_open(message["params"])
+        when "textDocument/didChange" then did_change(message["params"])
+        when "textDocument/didSave" then did_save(message["params"])
+        when "textDocument/didClose" then did_close(message["params"])
+        when "textDocument/documentSymbol"
+          respond(message, @workspace.symbols(uri_of(message)))
+        when "textDocument/definition"
+          respond(message, @workspace.definition(uri_of(message), position_of(message)))
+        when "textDocument/references"
+          respond(message, @workspace.references(
+                             uri_of(message), position_of(message),
+                             include_declaration: include_declaration?(message)
+                           ))
+        when "textDocument/hover"
+          respond(message, @workspace.hover(uri_of(message), position_of(message)))
+        when "textDocument/prepareRename"
+          respond(message, @workspace.prepare_rename(uri_of(message), position_of(message)))
+        when "textDocument/rename"
+          respond(message, @workspace.rename(
+                             uri_of(message), position_of(message),
+                             message.dig("params", "newName").to_s
+                           ))
+        else
+          respond_error(message, -32601, "unknown method #{method}") if message["id"]
+        end
+      rescue StandardError => e
+        respond_error(message, -32603, e.message) if message["id"]
+      end
+
+      def initialize_result
+        {
+          "capabilities" => {
+            "positionEncoding" => SUPPORTED_CHARACTERS,
+            "textDocumentSync" => {
+              "openClose" => true,
+              "change" => 1,
+              "save" => { "includeText" => false },
+            },
+            "documentSymbolProvider" => true,
+            "definitionProvider" => true,
+            "referencesProvider" => true,
+            "hoverProvider" => true,
+            "renameProvider" => { "prepareProvider" => true },
+          },
+          "serverInfo" => {
+            "name" => "expressir-lsp",
+            "version" => Expressir::VERSION,
+          },
+        }
+      end
+
+      def did_open(params)
+        document = params.fetch("textDocument")
+        @workspace.open(uri: document.fetch("uri"),
+                        text: document.fetch("text", ""))
+        publish_diagnostics(document.fetch("uri"))
+      end
+
+      def did_change(params)
+        uri = params.dig("textDocument", "uri")
+        change = Array(params["contentChanges"]).last || {}
+        @workspace.change(uri: uri, text: change.fetch("text", ""))
+        publish_diagnostics(uri)
+      end
+
+      def did_save(params)
+        publish_diagnostics(params.dig("textDocument", "uri"))
+      end
+
+      def did_close(params)
+        uri = params.dig("textDocument", "uri")
+        @workspace.close(uri)
+        notify("textDocument/publishDiagnostics",
+               "uri" => uri, "diagnostics" => [])
+      end
+
+      def publish_diagnostics(uri)
+        return unless uri
+
+        notify("textDocument/publishDiagnostics",
+               "uri" => uri,
+               "diagnostics" => @workspace.diagnostics(uri))
+      end
+
+      def uri_of(message)
+        message.dig("params", "textDocument", "uri")
+      end
+
+      def position_of(message)
+        message.dig("params", "position") || { "line" => 0, "character" => 0 }
+      end
+
+      def include_declaration?(message)
+        message.dig("params", "context", "includeDeclaration") != false
+      end
+
+      def respond(message, result)
+        write("jsonrpc" => "2.0", "id" => message["id"], "result" => result)
+      end
+
+      def respond_error(message, code, text)
+        write("jsonrpc" => "2.0", "id" => message["id"],
+              "error" => { "code" => code, "message" => text.to_s })
+      end
+
+      def notify(method, params)
+        write("jsonrpc" => "2.0", "method" => method, "params" => params)
+      end
+
+      def read_message
+        headers = read_headers
+        return nil unless headers
+
+        length = headers["content-length"].to_i
+        body = @input.read(length)
+        return nil if body.nil? || body.empty?
+
+        JSON.parse(body)
+      end
+
+      def read_headers
+        headers = {}
+        loop do
+          line = @input.gets
+          return nil unless line
+
+          line = line.sub(/\r?\n\z/, "")
+          break if line.empty?
+
+          name, value = line.split(":", 2)
+          headers[name.downcase] = value.to_s.strip
+        end
+        headers
+      end
+
+      def write(payload)
+        json = JSON.generate(payload)
+        @output.write("Content-Length: #{json.bytesize}\r\n\r\n#{json}")
+        @output.flush
+      end
+    end
+  end
+end