kapusta 0.7.0 → 0.8.0

data/lib/kapusta/lsp/workspace_index.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative '../reader'
+require_relative 'scope_walker'
+
+module Kapusta
+  class LSP
+    class WorkspaceIndex
+      Entry = Struct.new(:uri, :text, :forms, :walker, keyword_init: true)
+
+      MACRO_MODULE_EXTENSIONS = %w[kapm kap].freeze
+      SCAN_EXTENSIONS = %w[kap kapm].freeze
+
+      def initialize(roots: [])
+        @roots = Array(roots)
+        @entries = {}
+      end
+
+      def scan!
+        @roots.each do |root|
+          SCAN_EXTENSIONS.each do |ext|
+            Dir.glob(File.join(root, '**', "*.#{ext}")).each do |path|
+              uri = path_to_uri(path)
+              text = File.read(path)
+              store(uri, text)
+            end
+          end
+        end
+        self
+      end
+
+      def refresh(uri, text)
+        store(uri, text)
+      end
+
+      def remove(uri)
+        path = uri_to_path(uri)
+        if path && File.file?(path)
+          store(uri, File.read(path))
+        else
+          @entries.delete(uri)
+        end
+      end
+
+      def entry(uri)
+        @entries[uri]
+      end
+
+      def entry_count
+        @entries.length
+      end
+
+      def toplevel_fn_definitions(name)
+        result = []
+        @entries.each do |uri, entry|
+          entry.walker.bindings.each do |b|
+            result << [uri, b] if b.kind == :toplevel_fn && b.name == name
+          end
+        end
+        result
+      end
+
+      def constant_definitions_with_prefix(prefix)
+        result = []
+        @entries.each do |uri, entry|
+          entry.walker.bindings.each do |b|
+            next unless %i[module class].include?(b.kind)
+
+            segs = b.sym.dotted? ? b.sym.segments : [b.sym.name]
+            result << [uri, b] if segs == prefix
+          end
+        end
+        result
+      end
+
+      def toplevel_fn_occurrences(name)
+        result = {}
+        @entries.each do |uri, entry|
+          occs = entry.walker.bindings.select do |b|
+            b.kind == :toplevel_fn && b.name == name
+          end
+          occs += entry.walker.references.select do |r|
+            next false unless r.sym.is_a?(Sym) && !r.sym.dotted? && r.name == name
+
+            r.target.nil? || (r.target.kind == :toplevel_fn && r.target.name == name)
+          end
+          result[uri] = occs unless occs.empty?
+        end
+        result
+      end
+
+      def toplevel_definition?(name, except_name: nil)
+        @entries.any? do |_uri, entry|
+          entry.walker.bindings.any? do |b|
+            next false unless file_toplevel_binding?(b)
+            next false if except_name && b.name == except_name
+
+            b.name == name
+          end
+        end
+      end
+
+      def constant_definition_with_prefix?(prefix, except_prefix: nil)
+        @entries.any? do |_uri, entry|
+          entry.walker.bindings.any? do |b|
+            next false unless %i[module class].include?(b.kind)
+            next false if except_prefix && matches_prefix?(b.sym, except_prefix)
+
+            matches_prefix?(b.sym, prefix)
+          end
+        end
+      end
+
+      def each_entry(&)
+        @entries.each(&)
+      end
+
+      def find_macro_definition(importing_uri, module_label, import_key)
+        target_name = import_key.to_s.tr('_', '-')
+        resolve_module_uris(importing_uri, module_label).each do |uri|
+          entry = @entries[uri]
+          next unless entry
+
+          binding = entry.walker.bindings.find do |b|
+            %i[macro toplevel_fn].include?(b.kind) && b.name == target_name
+          end
+          return [uri, binding] if binding
+        end
+        nil
+      end
+
+      def import_resolves_to?(importing_uri, module_label, target_uri)
+        resolve_module_uris(importing_uri, module_label).include?(target_uri)
+      end
+
+      def macro_definition_anywhere?(name, except_uri: nil)
+        @entries.any? do |uri, entry|
+          next false if except_uri && uri == except_uri
+
+          entry.walker.bindings.any? { |b| b.kind == :macro && b.name == name }
+        end
+      end
+
+      def constant_occurrences(prefix)
+        result = {}
+        @entries.each do |uri, entry|
+          occs = []
+          entry.walker.bindings.each do |b|
+            next unless %i[module class].include?(b.kind)
+
+            occs << b if matches_prefix?(b.sym, prefix)
+          end
+          entry.walker.references.each do |r|
+            sym = r.sym
+            next unless sym.is_a?(Sym)
+            next unless r.target.nil?
+            next unless first_segment_capitalized?(sym)
+
+            occs << r if matches_prefix?(sym, prefix)
+          end
+          result[uri] = occs unless occs.empty?
+        end
+        result
+      end
+
+      private
+
+      def file_toplevel_binding?(binding)
+        binding.scope.kind == :file && %i[toplevel_fn local var].include?(binding.kind)
+      end
+
+      def matches_prefix?(sym, prefix)
+        segs = sym.dotted? ? sym.segments : [sym.name]
+        return false if segs.length < prefix.length
+
+        segs[0...prefix.length] == prefix
+      end
+
+      def resolve_module_uris(importing_uri, module_label)
+        importing_path = uri_to_path(importing_uri)
+        return [] unless importing_path
+
+        base_dir = File.dirname(importing_path)
+        snake_stem = module_label.to_s.tr('-', '_')
+        kebab_stem = module_label.to_s.tr('_', '-')
+        uris = []
+        [kebab_stem, snake_stem].uniq.each do |stem|
+          MACRO_MODULE_EXTENSIONS.each do |ext|
+            uris << path_to_uri(File.expand_path("#{stem}.#{ext}", base_dir))
+          end
+        end
+        uris
+      end
+
+      def first_segment_capitalized?(sym)
+        first = sym.dotted? ? sym.segments.first : sym.name
+        first.match?(/\A[A-Z]/)
+      end
+
+      def store(uri, text)
+        forms = Reader.read_all(text)
+        walker = ScopeWalker.analyze(forms)
+        @entries[uri] = Entry.new(uri:, text:, forms:, walker:)
+      rescue Kapusta::Error
+        @entries[uri] = Entry.new(uri:, text:, forms: [], walker: ScopeWalker.analyze([]))
+      end
+
+      def path_to_uri(path)
+        "file://#{URI::DEFAULT_PARSER.escape(File.expand_path(path))}"
+      end
+
+      def uri_to_path(uri)
+        return unless uri.is_a?(String)
+
+        parsed = URI.parse(uri)
+        return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
+
+        uri
+      rescue URI::InvalidURIError
+        nil
+      end
+    end
+  end
+end

data/lib/kapusta/lsp.rb

@@ -3,13 +3,16 @@
 require 'json'
 require 'uri'
 require_relative '../kapusta'
-require_relative 'formatter'
+require_relative 'lsp/definition'
+require_relative 'lsp/diagnostics'
+require_relative 'lsp/formatting'
+require_relative 'lsp/rename'
+require_relative 'lsp/workspace_index'
 
 module Kapusta
   class LSP
     NOT_INITIALIZED = -32_002
     METHOD_NOT_FOUND = -32_601
-    SEVERITY_ERROR = 1
     FULL_SYNC = 1
 
     def self.start(input: $stdin, output: $stdout, log: $stderr)
@@ -20,7 +23,9 @@ module Kapusta
       @input = input.binmode
       @output = output.binmode
       @log = log
+      @debug = %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
       @sources = {}
+      @workspace_index = WorkspaceIndex.new
       @initialized = false
       @shutdown = false
     end
@@ -94,6 +99,7 @@ module Kapusta
     def dispatch(method, id, params)
       case method
       when 'initialize'
+        on_initialize(params)
         @initialized = true
         reply(id, initialize_result)
       when 'initialized' then nil
@@ -106,6 +112,9 @@ module Kapusta
       when 'textDocument/didSave' then on_did_save(params)
       when 'textDocument/didClose' then on_did_close(params)
       when 'textDocument/formatting' then reply(id, formatting(params))
+      when 'textDocument/definition' then reply(id, definition(params))
+      when 'textDocument/prepareRename' then reply(id, prepare_rename(params))
+      when 'textDocument/rename' then handle_rename(id, params)
       else
         reply_error(id, METHOD_NOT_FOUND, "method not found: #{method}")
       end
@@ -131,12 +140,28 @@ module Kapusta
       {
         capabilities: {
           textDocumentSync: { openClose: true, change: FULL_SYNC, save: { includeText: false } },
-          documentFormattingProvider: true
+          documentFormattingProvider: true,
+          definitionProvider: true,
+          renameProvider: { prepareProvider: true }
         },
         serverInfo: { name: 'kapusta-ls', version: Kapusta::VERSION }
       }
     end
 
+    def on_initialize(params)
+      folders = params['workspaceFolders'] || []
+      roots = folders.filter_map { |f| uri_to_path(f['uri']) }
+      roots << uri_to_path(params['rootUri']) if params['rootUri']
+      roots.compact!
+      roots.uniq!
+      debug("initialize: roots=#{roots.inspect}")
+      @workspace_index = WorkspaceIndex.new(roots:)
+      @workspace_index.scan!
+      debug("workspace scan complete: #{@workspace_index.entry_count} files")
+    rescue StandardError => e
+      log("workspace scan failed: #{e.class}: #{e.message}")
+    end
+
     def on_did_open(params)
       doc = params['textDocument'] || {}
       uri = doc['uri']
@@ -144,7 +169,9 @@ module Kapusta
 
       version = doc['version']
       text = doc['text'] || ''
+      debug("didOpen: uri=#{uri} version=#{version} bytes=#{text.bytesize}")
       store(uri, text, version)
+      @workspace_index.refresh(uri, text)
       publish_diagnostics(uri, text, version)
     end
 
@@ -155,7 +182,9 @@ module Kapusta
       return if uri.nil? || changes.empty?
 
       text = changes.last['text']
+      debug("didChange: uri=#{uri} version=#{version} bytes=#{text.bytesize}")
       store(uri, text, version)
+      @workspace_index.refresh(uri, text)
       publish_diagnostics(uri, text, version)
     end
 
@@ -164,6 +193,8 @@ module Kapusta
       entry = @sources[uri]
       return unless entry
 
+      debug("didSave: uri=#{uri}")
+      @workspace_index.refresh(uri, entry[:text])
       publish_diagnostics(uri, entry[:text], entry[:version])
     end
 
@@ -171,7 +202,9 @@ module Kapusta
       uri = params.dig('textDocument', 'uri')
       return unless uri
 
+      debug("didClose: uri=#{uri}")
       @sources.delete(uri)
+      @workspace_index.remove(uri)
       notify('textDocument/publishDiagnostics', { uri:, diagnostics: [] })
     end
 
@@ -180,64 +213,79 @@ module Kapusta
       entry = @sources[uri]
       return [] unless entry
 
-      formatted = Kapusta::Formatter.format(entry[:text], path: uri_to_path(uri))
-      return [] if formatted == entry[:text]
-
-      [{ range: full_range(entry[:text]), newText: formatted }]
-    rescue Kapusta::Error
-      []
+      Formatting.text_edits(entry[:text], uri_to_path(uri))
     end
 
-    def store(uri, text, version)
-      @sources[uri] = { text:, version: }
-    end
+    def definition(params)
+      uri = params.dig('textDocument', 'uri')
+      pos = params['position'] || {}
+      entry = @sources[uri]
+      return unless entry
 
-    def publish_diagnostics(uri, text, version)
-      diagnostics = collect_diagnostics(text, uri_to_path(uri))
-      params = { uri:, diagnostics: }
-      params[:version] = version unless version.nil?
-      notify('textDocument/publishDiagnostics', params)
+      result = Definition.find(uri, entry[:text], pos['line'] || 0, pos['character'] || 0,
+                               workspace_index: @workspace_index)
+      debug("definition: uri=#{uri} pos=#{pos.inspect} result=#{result.inspect}")
+      result
     end
 
-    def collect_diagnostics(text, path)
-      Kapusta.compile(text, path: path || '(buffer)')
-      []
-    rescue Kapusta::Error => e
-      [diagnostic_from(e, text)]
+    def prepare_rename(params)
+      uri = params.dig('textDocument', 'uri')
+      pos = params['position'] || {}
+      entry = @sources[uri]
+      unless entry
+        debug("prepareRename: no source for uri=#{uri.inspect}; tracked=#{@sources.keys.inspect}")
+        return
+      end
+
+      result = Rename.prepare(entry[:text], pos['line'] || 0, pos['character'] || 0)
+      debug("prepareRename: uri=#{uri} pos=#{pos.inspect} result=#{result.inspect}")
+      result
     end
 
-    def diagnostic_from(error, text)
-      line = [(error.line || 1) - 1, 0].max
-      column = [(error.column || 1) - 1, 0].max
+    def handle_rename(id, params)
+      uri = params.dig('textDocument', 'uri')
+      pos = params['position'] || {}
+      new_name = params['newName']
+      entry = @sources[uri]
+      unless entry
+        debug("rename: no source for uri=#{uri.inspect}; tracked=#{@sources.keys.inspect}")
+        return reply(id, nil)
+      end
 
-      {
-        range: {
-          start: { line:, character: column },
-          end: { line:, character: column + token_length(text, line, column) }
-        },
-        severity: SEVERITY_ERROR,
-        source: 'kapusta-ls',
-        message: error.reason
-      }
+      debug("rename: uri=#{uri} pos=#{pos.inspect} newName=#{new_name.inspect}")
+      result = Rename.perform(uri, entry[:text], pos['line'] || 0, pos['character'] || 0,
+                              new_name, workspace_index: @workspace_index)
+      if result[:error]
+        debug("rename error: #{result[:error].inspect}")
+        reply_error(id, result[:error][:code], result[:error][:message])
+      else
+        edit = build_workspace_edit(result[:changes])
+        debug("rename ok: files=#{result[:changes].keys.length} edits=#{result[:changes].values.sum(&:length)}")
+        reply(id, edit)
+      end
     end
 
-    def token_length(text, line, column)
-      source_line = text.lines[line]
-      return 1 unless source_line
+    def build_workspace_edit(changes_by_uri)
+      document_changes = changes_by_uri.map do |uri, edits|
+        sorted = edits.sort_by { |e| [-e[:range][:start][:line], -e[:range][:start][:character]] }
+        version = @sources.dig(uri, :version)
+        {
+          textDocument: { uri:, version: },
+          edits: sorted
+        }
+      end
+      { documentChanges: document_changes }
+    end
 
-      tail = source_line[column..] || ''
-      match = tail.match(/\A[^\s()\[\]{}";`,]+/)
-      match && match[0].length.positive? ? match[0].length : 1
+    def store(uri, text, version)
+      @sources[uri] = { text:, version: }
     end
 
-    def full_range(text)
-      lines = text.split("\n", -1)
-      end_line = [lines.length - 1, 0].max
-      end_character = lines.last ? lines.last.length : 0
-      {
-        start: { line: 0, character: 0 },
-        end: { line: end_line, character: end_character }
-      }
+    def publish_diagnostics(uri, text, version)
+      diagnostics = Diagnostics.collect(text, uri_to_path(uri))
+      params = { uri:, diagnostics: }
+      params[:version] = version unless version.nil?
+      notify('textDocument/publishDiagnostics', params)
     end
 
     def uri_to_path(uri)
@@ -254,5 +302,11 @@ module Kapusta
     def log(message)
       @log.puts "kapusta-ls: #{message}"
     end
+
+    def debug(message)
+      return unless @debug
+
+      @log.puts "kapusta-ls[debug]: #{message}"
+    end
   end
 end

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/spec/examples_errors_spec.rb

@@ -154,7 +154,23 @@ RSpec.describe 'examples-errors' do
 
   it 'import-macros-missing-module.kap' do
     expect(run_error_example('import-macros-missing-module.kap'))
-      .to eq("import-macros-missing-module.kap:4:1: import-macros is not yet supported\n")
+      .to eq("import-macros-missing-module.kap:4:1: import-macros: module nonexistent-module not found\n")
+  end
+
+  it 'import-macros-macro-not-found.kap' do
+    message = 'import-macros: macro missing not exported by module missing-macro-helper'
+    expect(run_error_example('import-macros-macro-not-found.kap'))
+      .to eq("import-macros-macro-not-found.kap:1:1: #{message}\n")
+  end
+
+  it 'import-macros-no-exports.kap' do
+    expect(run_error_example('import-macros-no-exports.kap'))
+      .to eq("import-macros-no-exports.kap:1:1: import-macros: module no-exports-helper has no export table\n")
+  end
+
+  it 'import-macros-module-invalid.kap' do
+    expect(run_error_example('import-macros-module-invalid.kap'))
+      .to eq("import-macros-module-invalid.kap:1:1: import-macros expects a symbol or string module name\n")
   end
 
   it 'invalid-class-name.kap' do

data/spec/examples_spec.rb

@@ -551,4 +551,16 @@ RSpec.describe 'examples' do
       50
     OUT
   end
+
+  it 'macros-import.kap' do
+    expect(run_example('macros-import.kap')).to eq("8\n")
+  end
+
+  it 'macros-import-helpers.kap' do
+    expect(run_example('macros-import-helpers.kap')).to eq("60\n")
+  end
+
+  it 'macros-import-whole.kap' do
+    expect(run_example('macros-import-whole.kap')).to eq("7\n")
+  end
 end