kapusta 0.12.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5e4a7dc8e3d044580b58064b4632706c2115964847d674c23bbe39a625e0b6e
-  data.tar.gz: b17a395b81ab568829022273e5df9ee5a186c052d6a1e4c843df631dfe1d6f76
+  metadata.gz: 9324827934a0647689027ecf5fc6bf83708fe536cd904dc04d1f9c0594c37581
+  data.tar.gz: 736a8f7d8158fc4502415168f5791d7af8b98f392800255576c1d0182ef920c6
 SHA512:
-  metadata.gz: d3e8ca629130a695a67a1c210ab06869518e2d232084e01a8cb6d180094e2b10b0cbc3f65c191a9a7a6b1e70727f1563f28e3637264cc7776a58c2e16e554991
-  data.tar.gz: 71695c0adf8e37705c9b9b85263e495578bcdd0d442c2d56ad09b1a6386640003164adf98d932c499472ae81d5c3d4a909898b907417e6d6463384b855b2fa33
+  metadata.gz: 62e4118362c7fbe7ae034470a01ddf37a0bb826fb142e2611d72b09ded1777e52bf2b078cf48c0283dda6f0a8c5989ec31f60d0913cf16ec3ac9ccabf2c40626
+  data.tar.gz: 5fbd5b3a7809eff626c43203b1c36761efac10cb5663ca345ace26fbea731da63402909be6a04f22aedaca80945e1db3456209a6ac335b8fc4a2152bcc198395

data/README.md

@@ -87,6 +87,7 @@ def ack(m, n)
     ack(m - 1, ack(m, n - 1))
   end
 end
+
 p ack(2, 3)
 p ack(3, 3)
 ```

data/examples/bst-iterator.kap

@@ -15,7 +15,7 @@
 
 (fn initialize [root]
   (set @stack [])
-  (self.push-left root))
+  (push-left root))
 
 (fn push-left [node]
   (var n node)
@@ -27,7 +27,7 @@
 (fn next []
   (let [stack @stack
         node (stack.pop)]
-    (self.push-left (node.right))
+    (push-left (node.right))
     (node.val)))
 
 (fn has-next? []

data/examples/zoo-animal-1.kap

@@ -2,4 +2,4 @@
   (fn initialize [name] (set (ivar name) name))
   (fn name [] (ivar name))
   (fn kingdom [] "animalia")
-  (fn label [] (.. (self.name) " the animal")))
+  (fn label [] (.. name " the animal")))

data/examples/zoo-animal-inheritance-2.kap

@@ -1,7 +1,7 @@
 (require "./zoo-animal-1")
 
 (class Zoo.Dog [Zoo.Animal]
-  (fn label [] (.. (self.name) " the dog"))
+  (fn label [] (.. name " the dog"))
   (fn bark [] "woof"))
 
 (let [dog (Zoo.Dog.new "Poppy")]

data/lib/kapusta/compiler/emitter/bindings.rb

@@ -18,11 +18,11 @@ module Kapusta
             fn_env = env.child
             ruby_name = define_local(fn_env, name_sym.name)
             <<~RUBY.chomp
-              (-> do
+              lambda do
                 #{ruby_name} = nil
                 #{ruby_name} = #{emit_lambda(pattern, body, fn_env, current_scope)}
                 #{ruby_name}
-              end).call
+              end.call
             RUBY
           end
         end
@@ -81,9 +81,21 @@ module Kapusta
         end
 
         def emit_definition_form(form, env, current_scope)
-          return [emit_method_definition(form, env), env] unless current_scope == :toplevel
+          return emit_toplevel_method_definition(form, env) if current_scope == :toplevel
 
-          emit_toplevel_method_definition(form, env)
+          code = emit_method_definition(form, env)
+          register_self_method_binding(form, env)
+          [code, env]
+        end
+
+        def register_self_method_binding(form, env)
+          name_sym = form.items[1]
+          return unless name_sym.is_a?(Sym) && !name_sym.dotted?
+
+          ruby_name = Kapusta.kebab_to_snake(name_sym.name)
+          return unless direct_method_name?(ruby_name)
+
+          env.define(name_sym.name, Env::SelfMethodBinding.new(ruby_name))
         end
 
         def emit_toplevel_method_definition(form, env)
@@ -234,7 +246,7 @@ module Kapusta
 
           binding = env.lookup_if_defined(name)
           return false if binding.nil?
-          return false if method_binding?(binding)
+          return false if callable_method_binding?(binding)
           return false if constant_binding?(binding)
 
           true
@@ -247,9 +259,9 @@ module Kapusta
         def emit_let(args, env, current_scope)
           binding_code, body_code = emit_let_parts(args, env, current_scope, result: true)
           [
-            '(-> do',
+            'lambda do',
             indent(join_code(binding_code, body_code)),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 
@@ -281,7 +293,23 @@ module Kapusta
           body_code, = emit_sequence(body, child_env, current_scope,
                                      allow_method_definitions: false,
                                      result:)
-          [binding_codes.reject(&:empty?).join("\n"), body_code]
+          [join_binding_codes(binding_codes), body_code]
+        end
+
+        def join_binding_codes(binding_codes)
+          codes = binding_codes.reject(&:empty?)
+          return '' if codes.empty?
+
+          result = codes.first.dup
+          codes.each_cons(2) do |prev, curr|
+            separator = block_binding?(prev) || block_binding?(curr) ? "\n\n" : "\n"
+            result << separator << curr
+          end
+          result
+        end
+
+        def block_binding?(code)
+          code.match?(/\bdo\b/) && code.match?(/\bend\b/)
         end
 
         def join_code(*chunks)
@@ -364,7 +392,7 @@ module Kapusta
 
         def emit_local_expr(args, env, current_scope)
           code, = emit_local_form(List.new([Sym.new('local'), *args]), env.child, current_scope)
-          "(-> do\n#{indent(code)}\nend).call"
+          "lambda do\n#{indent(code)}\nend.call"
         end
 
         def emit_global_expr(args, _env, _current_scope)
@@ -385,7 +413,7 @@ module Kapusta
             binding = env.lookup_if_defined(target.name)
             ruby_name =
               if binding
-                emit_error!(:cannot_set_method_binding, name: target.name) if method_binding?(binding)
+                emit_error!(:cannot_set_method_binding, name: target.name) if callable_method_binding?(binding)
 
                 binding
               else
@@ -429,7 +457,7 @@ module Kapusta
               end
             else
               binding = env.lookup(target.name)
-              emit_error!(:cannot_set_method_binding, name: target.name) if method_binding?(binding)
+              emit_error!(:cannot_set_method_binding, name: target.name) if callable_method_binding?(binding)
               emit_error!(:expected_var, name: target.name) unless mutable_binding?(env, target.name)
 
               emit_assignment(binding, value_code)

data/lib/kapusta/compiler/emitter/collections.rb

@@ -89,11 +89,11 @@ module Kapusta
             emit_sequence_value_assignment(acc_var, body_code)
           end
           [
-            '(-> do',
+            'lambda do',
             indent("#{acc_var} = #{init_code}"),
             indent(iter_code),
             indent(acc_var),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 
@@ -221,11 +221,11 @@ module Kapusta
 
         def emit_collection_result(result_var, initial_code, iter_code)
           [
-            '(-> do',
+            'lambda do',
             indent("#{result_var} = #{initial_code}"),
             indent(iter_code),
             indent(result_var),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 

data/lib/kapusta/compiler/emitter/control_flow.rb

@@ -61,10 +61,10 @@ module Kapusta
           return body unless value_var
 
           [
-            '(-> do',
+            'lambda do',
             indent("#{value_var} = #{value_code}"),
             indent(body),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 
@@ -212,30 +212,30 @@ module Kapusta
 
         def emit_while(args, env, current_scope)
           <<~RUBY.chomp
-            (-> do
+            lambda do
               #{indent(emit_while_statement(args, env, current_scope))}
               nil
-            end).call
+            end.call
           RUBY
         end
 
         def emit_for(args, env, current_scope)
           loop_code = emit_for_statement(args, env, current_scope)
           <<~RUBY.chomp
-            (-> do
+            lambda do
               #{indent(loop_code)}
               nil
-            end).call
+            end.call
           RUBY
         end
 
         def emit_each(args, env, current_scope)
           iter_code = emit_each_statement(args, env, current_scope)
           <<~RUBY.chomp
-            (-> do
+            lambda do
               #{iter_code}
               nil
-            end).call
+            end.call
           RUBY
         end
 

data/lib/kapusta/compiler/emitter/interop.rb

@@ -35,7 +35,7 @@ module Kapusta
           if literal_name && binary_operator_call?(literal_name.to_s, positional, kwargs, block_form)
             return emit_binary_operator_call(receiver, literal_name.to_s, positional[0])
           end
-          if literal_name && direct_method_name?(literal_name.to_s)
+          if literal_name && colon_call_direct_method_name?(literal_name.to_s)
             return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(literal_name.to_s),
                                            positional, kwargs, block_form, env, current_scope)
           end
@@ -80,13 +80,17 @@ module Kapusta
         end
 
         def emit_module_expr(args, env)
-          body = emit_sequence(args[1..], env, :module, allow_method_definitions: true, result: false).first
+          body = with_class_body do
+            emit_sequence(args[1..], env.child, :module, allow_method_definitions: true, result: false).first
+          end
           emit_module_wrapper(args[0], body)
         end
 
         def emit_class_expr(args, env)
           name_sym, supers, body_forms = split_class_args(args)
-          body = emit_sequence(body_forms, env, :class, allow_method_definitions: true, result: false).first
+          body = with_class_body do
+            emit_sequence(body_forms, env.child, :class, allow_method_definitions: true, result: false).first
+          end
           emit_class_wrapper(name_sym, supers, env,
                              body)
         end
@@ -95,7 +99,7 @@ module Kapusta
           segments = constant_segments(name_sym)
           emit_error!(:invalid_module_name, name: name_sym.name) unless segments
           inner = build_nested_module(segments, body)
-          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
+          ['lambda do', indent(inner), indent(segments.join('::')), 'end.call'].join("\n")
         end
 
         def emit_direct_module_header(name_sym, body)
@@ -110,7 +114,7 @@ module Kapusta
           emit_error!(:invalid_class_name, name: name_sym.name) unless segments
           super_code = class_super_code(supers, env)
           inner = build_nested_class(segments, super_code, body)
-          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
+          ['lambda do', indent(inner), indent(segments.join('::')), 'end.call'].join("\n")
         end
 
         def emit_direct_class_header(name_sym, supers, body, env)
@@ -298,7 +302,7 @@ module Kapusta
         end
 
         def emit_bound_call(binding, args, env, current_scope)
-          return emit_self_method_binding_call(binding, args, env, current_scope) if method_binding?(binding)
+          return emit_self_method_binding_call(binding, args, env, current_scope) if callable_method_binding?(binding)
 
           emit_error!(:cannot_call_constant, name: binding) if constant_binding?(binding)
 
@@ -438,10 +442,15 @@ module Kapusta
           return emit_multisym_value(sym, env) if sym.dotted?
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)
+          return Kapusta.kebab_to_snake(name) if implicit_self_method?(name)
 
           emit_error!(:undefined_symbol, name:)
         end
 
+        def implicit_self_method?(name)
+          in_class_body? && direct_method_name?(Kapusta.kebab_to_snake(name))
+        end
+
         def emit_gvar(sym)
           "$#{global_name(sym.name)}"
         end
@@ -479,6 +488,10 @@ module Kapusta
           Kapusta.kebab_to_snake(name).match?(/\A[a-z_]\w*[!?=]?\z/)
         end
 
+        def colon_call_direct_method_name?(name)
+          Kapusta.kebab_to_snake(name).match?(/\A[a-zA-Z_]\w*[!?=]?\z/)
+        end
+
         def global_name(name)
           Kapusta.kebab_to_snake(name).gsub(/[^a-zA-Z0-9_]/, '_')
         end
@@ -492,6 +505,7 @@ module Kapusta
           /\A-?\d+(?:\.\d+)?\z/, # number
           /\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # local + .m/[k] chain
           /\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # const + chain
+          /\A\([^()\n]*\)(?:\.[a-zA-Z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # (expr).chain
           /\A:[a-zA-Z_]\w*[!?=]?\z/, # :symbol
           /\A"(?:[^"\\]|\\.)*"\z/, # "string"
           /\A'(?:[^'\\]|\\.)*'\z/, # 'string'

data/lib/kapusta/compiler/emitter/support.rb

@@ -41,29 +41,29 @@ module Kapusta
 
         def emit_form_run(forms, start, env, current_scope, header_form: nil)
           i = start
-          codes = []
+          entries = []
           while i < forms.length
             form = forms[i]
             if end_form?(form)
               validate_end_form!(form)
               with_current_form(form) { emit_error!(:end_outside_header) } unless header_form
-              return [codes.join("\n"), i + 1]
+              return [join_definition_aware(entries, current_scope), i + 1]
             end
 
             if bodyless_header?(form)
               header_code, i = emit_bodyless_header(form, forms, i + 1, env)
-              codes << header_code
+              entries << [form, header_code]
               next
             end
 
             code, env = emit_form_in_sequence(form, env, current_scope,
                                               allow_method_definitions: true,
                                               result_needed: false)
-            codes << code
+            entries << [form, code]
             i += 1
           end
           with_current_form(header_form) { emit_error!(:unclosed_header) } if header_form
-          [codes.join("\n"), i]
+          [join_definition_aware(entries, current_scope), i]
         end
 
         def end_form?(form)
@@ -109,12 +109,16 @@ module Kapusta
               inner_code, next_i = emit_bodyless_header(inner[0], forms, body_start, env)
               [emit_direct_module_header(name_sym, inner_code) || emit_module_wrapper(name_sym, inner_code), next_i]
             else
-              body, next_i = emit_form_run(forms, body_start, env, :module, header_form: form)
+              body, next_i = with_class_body do
+                emit_form_run(forms, body_start, env.child, :module, header_form: form)
+              end
               [emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body), next_i]
             end
           else
             name_sym, supers, = split_class_args(form.items[1..])
-            body, next_i = emit_form_run(forms, body_start, env, :class, header_form: form)
+            body, next_i = with_class_body do
+              emit_form_run(forms, body_start, env.child, :class, header_form: form)
+            end
             code = emit_direct_class_header(name_sym, supers, body, env) ||
                    emit_class_wrapper(name_sym, supers, env, body)
             [code, next_i]
@@ -154,11 +158,38 @@ module Kapusta
             emit_sequence_statement_form(form, env, current_scope, result_needed:)
           elsif set_new_local_form?(form, env)
             emit_set_form(form, env, current_scope)
+          elsif !result_needed && class_or_module_form?(form)
+            [emit_class_or_module_statement(form, env), env]
           else
             [emit_expr(form, env, current_scope), env]
           end
         end
 
+        def class_or_module_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) &&
+            %w[class module].include?(form.head.name)
+        end
+
+        def emit_class_or_module_statement(form, env)
+          args = form.rest
+          if form.head.name == 'module'
+            name_sym = args[0]
+            body = with_class_body do
+              emit_sequence(args[1..], env.child, :module, allow_method_definitions: true,
+                                                           result: false).first
+            end
+            emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body)
+          else
+            name_sym, supers, body_forms = split_class_args(args)
+            body = with_class_body do
+              emit_sequence(body_forms, env.child, :class, allow_method_definitions: true,
+                                                           result: false).first
+            end
+            emit_direct_class_header(name_sym, supers, body, env) ||
+              emit_class_wrapper(name_sym, supers, env, body)
+          end
+        end
+
         def emit_do_form(forms, env, current_scope, result_needed: true)
           body, new_env = emit_sequence(forms, env, current_scope,
                                         allow_method_definitions: false,
@@ -170,14 +201,41 @@ module Kapusta
 
         def emit_sequence(forms, env, current_scope, allow_method_definitions:, result: true)
           current_env = env
-          codes = []
+          entries = []
           forms.each_with_index do |form, index|
             code, current_env = emit_form_in_sequence(form, current_env, current_scope,
                                                       allow_method_definitions:,
                                                       result_needed: result && index == forms.length - 1)
-            codes << code unless code.empty?
+            entries << [form, code] unless code.empty?
+          end
+          [join_definition_aware(entries, current_scope), current_env]
+        end
+
+        def join_definition_aware(entries, current_scope)
+          return '' if entries.empty?
+
+          result = +entries.first[1]
+          entries.each_cons(2) do |(prev_form, _), (curr_form, curr_code)|
+            sep = blank_between_definitions?(prev_form, curr_form, current_scope) ? "\n\n" : "\n"
+            result << sep << curr_code
+          end
+          result
+        end
+
+        def blank_between_definitions?(prev_form, curr_form, current_scope)
+          return false unless %i[toplevel module class].include?(current_scope)
+
+          definition_form?(prev_form) || definition_form?(curr_form)
+        end
+
+        def definition_form?(form)
+          return false unless form.is_a?(List) && !form.empty? && form.head.is_a?(Sym)
+
+          case form.head.name
+          when 'defn', 'class', 'module' then true
+          when 'fn', 'lambda', 'λ' then form.items[1].is_a?(Sym)
+          else false
           end
-          [codes.join("\n"), current_env]
         end
 
         def sequence_statement_form?(form)
@@ -313,8 +371,30 @@ module Kapusta
           binding.is_a?(Env::MethodBinding)
         end
 
+        def in_class_body?
+          @class_body_depth.positive?
+        end
+
+        def with_class_body
+          @class_body_depth += 1
+          yield
+        ensure
+          @class_body_depth -= 1
+        end
+
+        def self_method_binding?(binding)
+          binding.is_a?(Env::SelfMethodBinding)
+        end
+
+        def callable_method_binding?(binding)
+          method_binding?(binding) || self_method_binding?(binding)
+        end
+
         def binding_value_code(binding)
-          method_binding?(binding) ? "method(#{binding.ruby_name.to_sym.inspect})" : binding
+          return "method(#{binding.ruby_name.to_sym.inspect})" if method_binding?(binding)
+          return binding.ruby_name if self_method_binding?(binding)
+
+          binding
         end
 
         def parse_counted_for_bindings(bindings, env, current_scope)

data/lib/kapusta/compiler/emitter.rb

@@ -28,6 +28,7 @@ module Kapusta
         @path = path
         @target = target
         @temp_index = 0
+        @class_body_depth = 0
       end
 
       def emit_file(forms)

data/lib/kapusta/env.rb

@@ -3,6 +3,7 @@
 module Kapusta
   class Env
     MethodBinding = Struct.new(:ruby_name)
+    SelfMethodBinding = Struct.new(:ruby_name)
 
     def initialize(parent = nil)
       @parent = parent

data/lib/kapusta/lsp/definition.rb

@@ -17,7 +17,7 @@ module Kapusta
         return unless target
 
         case target.kind
-        when :local, :toplevel_fn, :constant
+        when :local, :toplevel_fn, :constant, :method
           location_for_binding(uri, target.binding) if target.binding
         when :macro
           locations_for_macro(uri, target.binding, workspace_index)

data/lib/kapusta/lsp/rename.rb

@@ -32,6 +32,8 @@ module Kapusta
         case target.kind
         when :local
           rename_local(uri, target, new_name)
+        when :method
+          rename_method(uri, target, new_name)
         when :toplevel_fn, :free_toplevel
           return error('cross-file rename requires a workspace') unless workspace_index
 
@@ -128,8 +130,6 @@ module Kapusta
         end
 
         if binding
-          return if binding.kind == :method
-
           return constant_target(walker, binding, seg) if %i[module class].include?(binding.kind)
 
           return local_target(walker, binding, seg)
@@ -138,7 +138,6 @@ module Kapusta
         if reference
           target = reference.target
           if target
-            return if target.kind == :method
             return constant_target(walker, target, seg, sym:) if %i[module class].include?(target.kind)
 
             return local_target(walker, target, seg, sym:)
@@ -164,6 +163,7 @@ module Kapusta
         kind = case binding.kind
                when :toplevel_fn then :toplevel_fn
                when :macro, :macro_import then :macro
+               when :method then :method
                else :local
                end
         Target.new(
@@ -207,6 +207,22 @@ module Kapusta
         }
       end
 
+      def rename_method(uri, target, new_name)
+        return error("invalid identifier: #{new_name}") unless Identifier.valid_local?(new_name)
+        return error('cannot resolve binding') unless target.binding
+
+        walker = target.walker
+        binding = target.binding
+
+        occs = [binding]
+        walker.references.each do |r|
+          occs << r if r.target.equal?(binding)
+        end
+
+        edits = occs.map { |o| text_edit_first_segment(o, new_name) }
+        { changes: { uri => edits } }
+      end
+
       def rename_local(uri, target, new_name)
         return error("invalid identifier: #{new_name}") unless Identifier.valid_local?(new_name)
         return error('cannot resolve binding') unless target.binding

data/lib/kapusta/lsp/scope_walker.rb

@@ -76,6 +76,17 @@ module Kapusta
 
       def walk_top(forms)
         walk_form_run(forms, 0, @root_scope)
+        resolve_late_references
+      end
+
+      def resolve_late_references
+        @references.each do |r|
+          next if r.target
+          next unless r.scope
+
+          target = r.scope.lookup(r.name)
+          r.target = target if target
+        end
       end
 
       def walk_form_run(forms, start, scope, header_target: nil)
@@ -164,7 +175,8 @@ module Kapusta
             if body.length == 1 && bodyless_header?(body[0])
               walk_bodyless_header(body[0], forms, body_start, scope)
             else
-              walk_form_run(forms, body_start, scope, header_target: binding)
+              body_scope = make_scope(scope, :module)
+              walk_form_run(forms, body_start, body_scope, header_target: binding)
             end
           end
         when 'class'
@@ -172,7 +184,8 @@ module Kapusta
           supers&.items&.each { |item| walk_form(item, scope) }
           binding = name_sym.is_a?(Sym) ? add_constant_binding(name_sym, scope, :class) : nil
           inside_class do
-            walk_form_run(forms, body_start, scope, header_target: binding)
+            body_scope = make_scope(scope, :class)
+            walk_form_run(forms, body_start, body_scope, header_target: binding)
           end
         end
       end
@@ -406,7 +419,7 @@ module Kapusta
                  else
                    (scope == @root_scope ? :toplevel_fn : :fn_local)
                  end
-          binding = add_binding(name_sym, scope, kind, lexical: kind != :method)
+          binding = add_binding(name_sym, scope, kind, lexical: true)
           fn_scope.bindings[name_sym.name] = binding unless kind == :method
         end
         bind_param_vec(params, fn_scope)
@@ -558,10 +571,11 @@ module Kapusta
         add_constant_binding(name_sym, scope, kind) if name_sym.is_a?(Sym)
 
         body = list.items[body_start..] || []
+        body_scope = make_scope(scope, kind)
         if kind == :class
-          inside_class { body.each { |form| walk_form(form, scope) } }
+          inside_class { body.each { |form| walk_form(form, body_scope) } }
         else
-          inside_module_or_class { body.each { |form| walk_form(form, scope) } }
+          inside_module_or_class { body.each { |form| walk_form(form, body_scope) } }
         end
       end
 

data/lib/kapusta/version.rb

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

data/spec/lsp_spec.rb

@@ -234,7 +234,7 @@ RSpec.describe Kapusta::LSP do
     end
   end
 
-  it 'does not offer rename for method definitions after a bodyless class header' do
+  it 'offers rename for method definitions after a bodyless class header' do
     text = "(class Counter)\n(fn initialize [start] start)\n"
     responses = run(
       frame_initialize,
@@ -242,7 +242,60 @@ RSpec.describe Kapusta::LSP do
       frame_prepare_rename(uri: 'file:///x.kap', **cursor_at(text, 'initialize'))
     )
 
-    expect(result_for(responses)['result']).to be_nil
+    expect(result_for(responses)['result']).to include('placeholder' => 'initialize')
+  end
+
+  it 'renames a class method and its bare-self call sites within a file' do
+    text = "(class Greeter)\n" \
+           "(fn initialize [name] (set @name name))\n" \
+           "(fn greeting [] (.. \"Hello, \" (label)))\n" \
+           "(fn label [] @name)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_rename(uri: 'file:///x.kap', **cursor_at(text, 'label'), new_name: 'who')
+    )
+    edits = result_for(responses)['result']['documentChanges'].first['edits']
+
+    expect(edits.map { |e| e['newText'] }).to all(eq('who'))
+    expect(edits.map { |e| [e['range']['start']['line'], e['range']['start']['character']] })
+      .to contain_exactly([2, 31], [3, 4])
+  end
+
+  it 'jumps from a bare-self method call to the class method definition' do
+    text = "(class Greeter)\n" \
+           "(fn label [] 1)\n" \
+           "(fn greeting [] (label))\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_definition(uri: 'file:///x.kap', line: 2, character: 17)
+    )
+    result = result_for(responses)['result']
+
+    expect(result).to eq(
+      'uri' => 'file:///x.kap',
+      'range' => {
+        'start' => { 'line' => 1, 'character' => 4 },
+        'end' => { 'line' => 1, 'character' => 9 }
+      }
+    )
+  end
+
+  it 'renames a class method when the cursor is on a bare-self call site' do
+    text = "(class Greeter)\n" \
+           "(fn label [] 1)\n" \
+           "(fn greeting [] (label))\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_rename(uri: 'file:///x.kap', line: 2, character: 17, new_name: 'who')
+    )
+    edits = result_for(responses)['result']['documentChanges'].first['edits']
+
+    expect(edits.map { |e| e['newText'] }).to all(eq('who'))
+    expect(edits.map { |e| [e['range']['start']['line'], e['range']['start']['character']] })
+      .to contain_exactly([1, 4], [2, 17])
   end
 
   it 'does not let class methods shadow top-level function references' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.1
 platform: ruby
 authors:
 - Evgenii Morozov