kapusta 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cafef3668504ca08a40ba087c4c2b754bfda02e6f61161f19bcf8d56a254e00
-  data.tar.gz: 501b99f6ec3bfa950865b63b26ec6fd7f5b64977bb86f41d4eff51957602cc84
+  metadata.gz: 326afa9f8872d9d92bf4c3ca32fa5c15f78559691aa447a23472a4042a4f3a4c
+  data.tar.gz: 625c013cad69a7e2229ea99a64796c2de90f9fd9665152c74cbd6753c67319f0
 SHA512:
-  metadata.gz: b774d8f0bbd772e223743a2ec844bec4949a6f1a5a545767c3b608c8ec0c2da055fe9537c68a3cf57573ac80ed75d11d85884245b4fcbd401af16646aaab5283
-  data.tar.gz: 10b6d3f30fdfc760569c40c70e22f2b63dcf124ea3de3cffca2f061642523bc7057c878b81460181950356193c5786a35df28d4fd2b4859c1c38bc2285392f40
+  metadata.gz: 2768ae288a6011b651f7e084af68717a3cf6486a45483985fe8eeb7ed9fa9ea3f2ce18c6db77b94e74b130cc10c84c486970569eee760fb82ae858070486049b
+  data.tar.gz: 04245b8c5e76773abe1f6c9efde7c64242eaec147e8f07c3d91239a893c25cf2477e4e2b7cec518aa2e82ee948238088d37f68731f41f807aebb6c911c2d03e8

data/README.md

@@ -110,6 +110,8 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 Kapusta-specific additions:
 
 - `module` and `class` for Ruby host structure, including file-header forms
+- `(end)` closes a bodyless file-header
+- `(defn name ...)` or `(fn class.name ..)`
 - `ivar` or `@var` / `cvar` or `@@var` / `gvar` or `$var`
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch

data/examples/accumulator.kap

@@ -10,6 +10,8 @@
 (fn value []
   (ivar total))
 
+(end)
+
 (let [acc (Accumulator.new 10)]
   (acc.add! 5)
   (acc.add! 7)

data/examples/bank-account.kap

@@ -19,3 +19,5 @@
   (set (ivar balance)
     (- (ivar balance) amount))
   self)
+
+(end)

data/examples/bst-iterator.kap

@@ -0,0 +1,52 @@
+(class TreeNode)
+
+(fn initialize [val left right]
+  (set @val val)
+  (set @left left)
+  (set @right right))
+
+(fn val [] @val)
+(fn left [] @left)
+(fn right [] @right)
+
+(end)
+
+(class BSTIterator)
+
+(fn initialize [root]
+  (set @stack [])
+  (self.push-left root))
+
+(fn push-left [node]
+  (var n node)
+  (while n
+    (let [stack @stack]
+      (stack.push n))
+    (set n (n.left))))
+
+(fn next []
+  (let [stack @stack
+        node (stack.pop)]
+    (self.push-left (node.right))
+    (node.val)))
+
+(fn has-next? []
+  (let [stack @stack]
+    (not (stack.empty?))))
+
+(end)
+
+(let [root (TreeNode.new 7
+             (TreeNode.new 3 nil nil)
+             (TreeNode.new 15
+               (TreeNode.new 9 nil nil)
+               (TreeNode.new 20 nil nil)))
+      it (BSTIterator.new root)]
+  (print (it.next))
+  (print (it.next))
+  (print (it.has-next?))
+  (print (it.next))
+  (print (it.has-next?))
+  (print (it.next))
+  (print (it.next))
+  (print (it.has-next?)))

data/examples/circle.kap

@@ -11,6 +11,8 @@
 (fn circumference []
   (* 2 pi @radius))
 
+(end)
+
 (let [c (Circle.new 5)]
   (print (c.area))
   (print (c.circumference)))

data/examples/counter.kap

@@ -12,6 +12,8 @@
 (fn self.zero []
   (Counter.new 0))
 
+(end)
+
 (let [c (Counter.new 10)]
   (c.tick)
   (c.tick)

data/examples/hit-counter.kap

@@ -9,6 +9,8 @@
   (set $last-hitter @name)
   @@total)
 
+(end)
+
 (let [a (HitCounter.new "alice")
       b (HitCounter.new "bob")]
   (print (a.hit))

data/examples/module-header.kap

@@ -1,7 +1,9 @@
 ; File header forms map directly to Ruby modules.
 (module HeaderDemo)
 
-(fn self.greet [name]
+(defn greet [name]
   (.. "Hello, " name "!"))
 
-(print (self.greet "Ada"))
+(end)
+
+(print (HeaderDemo.greet "Ada"))

data/examples/mruby-runtime-examples.txt

@@ -9,6 +9,7 @@ best-time-to-buy-sell-stock
 binary-search
 binary-to-decimal
 block-sort
+bst-iterator
 calc
 circle
 classify-wallet
@@ -65,6 +66,7 @@ points
 power-of-three
 primes
 raindrops
+recent-counter
 record
 reverse-integer
 roman-to-integer
@@ -72,6 +74,7 @@ ruby-eval
 safe-lookup
 scopes
 shapes
+signal-harvest
 single-number
 squares
 stack

data/examples/parking-system.kap

@@ -11,6 +11,8 @@
       (and (= car-type 3) (> @small 0)) (do (set @small (- @small 1)) true)
       false))
 
+(end)
+
 (let [parking (ParkingSystem.new 1 1 0)]
   (print (parking.add-car 1))
   (print (parking.add-car 2))

data/examples/recent-counter.kap

@@ -0,0 +1,17 @@
+(class RecentCounter)
+(fn initialize [] (set @pings []))
+(fn ping [t]
+  (let [pings @pings]
+    (pings.push t)
+    (while (< (. pings 0) (- t 3000))
+      (pings.shift))
+    (length pings)))
+(defn warm [history]
+  (let [c (RecentCounter.new)]
+    (each [_ t (ipairs history)] (c.ping t))
+    c))
+(end)
+
+(let [c (RecentCounter.warm [100 200 300])]
+  (print (c.ping 3001))
+  (print (c.ping 3002)))

data/examples/scopes.kap

@@ -10,6 +10,8 @@
 (fn self.total []
   (cvar total))
 
+(end)
+
 (let [a (ScopeCounter.new)
       b (ScopeCounter.new)]
   (print (a.add! 5))

data/examples/signal-harvest.kap

@@ -0,0 +1,16 @@
+(module SignalHarvest)
+
+(local SCREEN-W 1280)
+(local TARGET-SCORE 36)
+
+(defn cell-width [columns]
+  (/ SCREEN-W columns))
+
+(defn win? [score]
+  (>= score TARGET-SCORE))
+
+(end)
+
+(print (SignalHarvest.cell-width 32))
+(print (SignalHarvest.win? 40))
+(print (SignalHarvest.win? 12))

data/examples/stack.kap

@@ -24,6 +24,8 @@
 (fn get-min []
   (. (ivar mins) -1))
 
+(end)
+
 (let [s (MinStack.new)]
   (s.push -2)
   (s.push 0)

data/examples/valid-parentheses-1.kap

@@ -17,3 +17,5 @@
             (stack.push ch)))
       (set i (+ i 1)))
     (and ok (stack.empty?))))
+
+(end)

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

@@ -83,6 +83,7 @@ module Kapusta
           when 'require' then emit_require(args[0], env, current_scope)
           when 'module' then emit_module_expr(args, env)
           when 'class' then emit_class_expr(args, env)
+          when 'end' then emit_error!(:end_outside_header)
           when 'try' then emit_try(args, env, current_scope)
           when 'raise' then emit_raise(args, env, current_scope)
           when 'ivar' then "@#{Kapusta.kebab_to_snake(args[0].name)}"

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

@@ -102,7 +102,7 @@ module Kapusta
           segments = constant_segments(name_sym)
           return unless segments
 
-          [build_nested_module(segments, body), segments.join('::')].join("\n")
+          build_nested_module(segments, body)
         end
 
         def emit_class_wrapper(name_sym, supers, env, body)
@@ -118,7 +118,7 @@ module Kapusta
           return unless segments
 
           super_code = class_super_code(supers, env)
-          [build_nested_class(segments, super_code, body), segments.join('::')].join("\n")
+          build_nested_class(segments, super_code, body)
         end
 
         def constant_segments(name_sym)

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

@@ -34,22 +34,52 @@ module Kapusta
         end
 
         def emit_forms_with_headers(forms, env, current_scope, result: true)
-          i = 0
+          _ = result
+          code, _next = emit_form_run(forms, 0, env, current_scope)
+          code
+        end
+
+        def emit_form_run(forms, start, env, current_scope, header_form: nil)
+          i = start
           codes = []
           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]
+            end
+
             if bodyless_header?(form)
-              codes << emit_bodyless_header(form, forms[(i + 1)..], env, current_scope)
-              break
-            else
-              code, env = emit_form_in_sequence(form, env, current_scope,
-                                                allow_method_definitions: true,
-                                                result_needed: result && i == forms.length - 1)
-              codes << code
-              i += 1
+              header_code, i = emit_bodyless_header(form, forms, i + 1, env)
+              codes << header_code
+              next
             end
+
+            code, env = emit_form_in_sequence(form, env, current_scope,
+                                              allow_method_definitions: true,
+                                              result_needed: false)
+            codes << code
+            i += 1
           end
-          codes.join("\n")
+          with_current_form(header_form) { emit_error!(:unclosed_header) } if header_form
+          [codes.join("\n"), i]
+        end
+
+        def end_form?(form)
+          form.is_a?(List) && !form.empty? && form.head.is_a?(Sym) && form.head.name == 'end'
+        end
+
+        def validate_end_form!(form)
+          with_current_form(form) { emit_error!(:end_with_args) } if form.items.length > 1
+        end
+
+        def validate_header_name!(form, head)
+          name_sym = head == 'module' ? form.items[1] : split_class_args(form.items[1..])[0]
+          return if constant_segments(name_sym)
+
+          code = head == 'module' ? :invalid_module_name : :invalid_class_name
+          emit_error!(code, name: name_sym.respond_to?(:name) ? name_sym.name : name_sym.inspect)
         end
 
         def bodyless_header?(form)
@@ -69,23 +99,25 @@ module Kapusta
           end
         end
 
-        def emit_bodyless_header(form, remaining_forms, env, _current_scope)
+        def emit_bodyless_header(form, forms, body_start, env)
           head = form.head.name
-          name_sym = form.items[1]
-
+          validate_header_name!(form, head)
           if head == 'module'
+            name_sym = form.items[1]
             inner = form.items[2..] || []
-            body =
-              if inner.length == 1 && bodyless_header?(inner[0])
-                emit_bodyless_header(inner[0], remaining_forms, env, :module)
-              else
-                emit_forms_with_headers(remaining_forms, env, :module, result: false)
-              end
-            emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body)
+            if inner.length == 1 && bodyless_header?(inner[0])
+              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)
+              [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 = emit_forms_with_headers(remaining_forms, env, :class, result: false)
-            emit_direct_class_header(name_sym, supers, body, env) || emit_class_wrapper(name_sym, supers, env, body)
+            body, next_i = emit_form_run(forms, body_start, env, :class, header_form: form)
+            code = emit_direct_class_header(name_sym, supers, body, env) ||
+                   emit_class_wrapper(name_sym, supers, env, body)
+            [code, next_i]
           end
         end
 

data/lib/kapusta/compiler/normalizer.rb

@@ -40,6 +40,12 @@ module Kapusta
         return inherit_position(List.new(items), list) unless head.is_a?(Sym)
 
         case head.name
+        when 'defn'
+          name_sym = items[1]
+          raise compiler_error(:fn_no_params, list) unless name_sym.is_a?(Sym)
+
+          self_name = inherit_position(Sym.new("self.#{name_sym.name}"), name_sym)
+          inherit_position(List.new([inherit_position(Sym.new('fn'), head), self_name, *items[2..]]), list)
         when 'when'
           raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
 

data/lib/kapusta/compiler.rb

@@ -10,7 +10,7 @@ module Kapusta
   module Compiler
     class Error < Kapusta::Error; end
     CORE_SPECIAL_FORMS = %w[
-      fn lambda λ let local var global set if when unless case match
+      fn defn lambda λ let local var global set if when unless case match
       while for each do values
       -> ->> -?> -?>> doto
       icollect collect fcollect accumulate faccumulate
@@ -19,7 +19,7 @@ module Kapusta
       ..
       length
       require
-      module class
+      module class end
       try catch finally
       raise
       ivar cvar gvar

data/lib/kapusta/errors.rb

@@ -25,6 +25,9 @@ module Kapusta
       dot_no_args: 'expected table argument',
       each_no_binding: 'expected binding table',
       empty_call: 'expected a function, macro, or special to call',
+      end_outside_header: 'end outside class or module',
+      end_with_args: 'end takes no arguments',
+      unclosed_header: 'class or module not closed with (end)',
       expected_var: 'expected var %{name}',
       fn_no_params: 'expected parameters table',
       global_arity: 'expected name and value',

data/lib/kapusta/formatter.rb

@@ -266,7 +266,7 @@ module Kapusta
       raw_args = list_raw_rest(list)
 
       case head_name
-      when 'fn', 'lambda', 'λ', 'macro' then render_fn(head_name, list, indent, top_level:)
+      when 'fn', 'defn', 'lambda', 'λ', 'macro' then render_fn(head_name, list, indent, top_level:)
       when 'let' then render_let(list, indent)
       when 'do', 'finally' then render_prefix_body_form(head_name, [], raw_args, indent)
       when 'try' then render_try(list, indent)

data/lib/kapusta/lsp/definition.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'rename'
+require_relative '../reader'
+require_relative 'scope_walker'
 
 module Kapusta
   class LSP
@@ -8,6 +10,9 @@ module Kapusta
       module_function
 
       def find(uri, text, line_zero, character, workspace_index:)
+        marker = end_marker_at(text, line_zero, character)
+        return location_for_binding(uri, marker.target) if marker&.target
+
         target = Rename.locate(text, line_zero, character)
         return unless target
 
@@ -23,6 +28,18 @@ module Kapusta
         end
       end
 
+      def end_marker_at(text, line_zero, character)
+        forms = Reader.read_all(text)
+        walker = ScopeWalker.analyze(forms)
+        line = line_zero + 1
+        col = character + 1
+        walker.end_markers.find do |m|
+          m.line == line && col >= m.column && col <= m.end_column
+        end
+      rescue Kapusta::Error
+        nil
+      end
+
       def locations_for_macro(uri, binding, workspace_index)
         return unless binding
 

data/lib/kapusta/lsp/rename.rb

@@ -344,7 +344,9 @@ module Kapusta
       end
 
       def rename_constant(target, new_name, workspace_index)
-        return error("invalid constant segment: #{new_name}") unless Identifier.valid_constant_segment?(new_name)
+        unless Identifier.valid_constant_segment?(new_name)
+          return error("class and module names must start with an uppercase letter (got #{new_name.inspect})")
+        end
 
         prefix = target.segment_prefix
         seg_index = target.segment_index

data/lib/kapusta/lsp/scope_walker.rb

@@ -15,6 +15,7 @@ module Kapusta
           bindings[name] || parent&.lookup(name)
         end
       end
+      EndMarker = Struct.new(:line, :column, :end_column, :target, keyword_init: true)
 
       SKIPPED_HEADS = %w[macros quasi-sym quasi-list
                          quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym].freeze
@@ -26,6 +27,7 @@ module Kapusta
         'global' => :walk_global,
         'set' => :walk_set,
         'fn' => :walk_fn,
+        'defn' => :walk_fn,
         'lambda' => :walk_fn,
         'λ' => :walk_fn,
         'for' => :walk_for,
@@ -48,7 +50,7 @@ module Kapusta
         'gvar' => :walk_sigil_form
       }.freeze
 
-      attr_reader :bindings, :references, :root_scope
+      attr_reader :bindings, :references, :root_scope, :end_markers
 
       def self.analyze(forms)
         walker = new
@@ -59,6 +61,7 @@ module Kapusta
       def initialize
         @bindings = []
         @references = []
+        @end_markers = []
         @scope_seq = 0
         @root_scope = make_scope(nil, :file)
         @gvar_scope = make_scope(nil, :gvars)
@@ -67,17 +70,43 @@ module Kapusta
       end
 
       def walk_top(forms)
-        i = 0
+        walk_form_run(forms, 0, @root_scope)
+      end
+
+      def walk_form_run(forms, start, scope, header_target: nil)
+        i = start
         while i < forms.length
           form = forms[i]
+          if end_form?(form)
+            record_end_marker(form, header_target) if header_target
+            return i + 1
+          end
+
           if bodyless_header?(form)
-            walk_bodyless_header(form, forms[(i + 1)..] || [], @root_scope)
-            break
+            i = walk_bodyless_header(form, forms, i + 1, scope)
+            next
           end
 
-          walk_form(form, @root_scope)
+          walk_form(form, scope)
           i += 1
         end
+        i
+      end
+
+      def record_end_marker(form, target)
+        head = form.head
+        return unless head.is_a?(Sym) && head.respond_to?(:line) && head.line
+
+        @end_markers << EndMarker.new(
+          line: head.line,
+          column: head.column,
+          end_column: head.column + head.name.length,
+          target:
+        )
+      end
+
+      def end_form?(form)
+        form.is_a?(List) && !form.empty? && form.head.is_a?(Sym) && form.head.name == 'end'
       end
 
       def binding_at(line, column)
@@ -120,25 +149,25 @@ module Kapusta
         end
       end
 
-      def walk_bodyless_header(form, remaining_forms, scope)
+      def walk_bodyless_header(form, forms, body_start, scope)
         case form.head.name
         when 'module'
           name_sym = form.items[1]
-          add_constant_binding(name_sym, scope, :module) if name_sym.is_a?(Sym)
+          binding = name_sym.is_a?(Sym) ? add_constant_binding(name_sym, scope, :module) : nil
           body = form.items[2..] || []
           inside_module_or_class do
             if body.length == 1 && bodyless_header?(body[0])
-              walk_bodyless_header(body[0], remaining_forms, scope)
+              walk_bodyless_header(body[0], forms, body_start, scope)
             else
-              remaining_forms.each { |item| walk_form(item, scope) }
+              walk_form_run(forms, body_start, scope, header_target: binding)
             end
           end
         when 'class'
           name_sym, supers, = split_class_args(form.items[1..] || [])
           supers&.items&.each { |item| walk_form(item, scope) }
-          add_constant_binding(name_sym, scope, :class) if name_sym.is_a?(Sym)
+          binding = name_sym.is_a?(Sym) ? add_constant_binding(name_sym, scope, :class) : nil
           inside_class do
-            remaining_forms.each { |item| walk_form(item, scope) }
+            walk_form_run(forms, body_start, scope, header_target: binding)
           end
         end
       end

data/lib/kapusta/lsp.rb

@@ -257,7 +257,8 @@ module Kapusta
                               new_name, workspace_index: @workspace_index)
       if result[:error]
         debug("rename error: #{result[:error].inspect}")
-        reply_error(id, result[:error][:code], result[:error][:message])
+        notify('window/showMessage', { type: 1, message: "Rename: #{result[:error][:message]}" })
+        reply(id, { documentChanges: [] })
       else
         edit = build_workspace_edit(result[:changes])
         debug("rename ok: files=#{result[:changes].keys.length} edits=#{result[:changes].values.sum(&:length)}")

data/lib/kapusta/version.rb

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

data/spec/examples_errors_spec.rb

@@ -92,6 +92,26 @@ RSpec.describe 'examples-errors' do
       .to eq("destructure-literal-table.kap:4:1: could not destructure literal\n")
   end
 
+  it 'end-outside-header.kap' do
+    expect(run_error_example('end-outside-header.kap'))
+      .to eq("end-outside-header.kap:1:1: end outside class or module\n")
+  end
+
+  it 'end-with-args.kap' do
+    expect(run_error_example('end-with-args.kap'))
+      .to eq("end-with-args.kap:5:1: end takes no arguments\n")
+  end
+
+  it 'extra-end.kap' do
+    expect(run_error_example('extra-end.kap'))
+      .to eq("extra-end.kap:7:1: end outside class or module\n")
+  end
+
+  it 'unclosed-header.kap' do
+    expect(run_error_example('unclosed-header.kap'))
+      .to eq("unclosed-header.kap:1:1: class or module not closed with (end)\n")
+  end
+
   it 'destructure-rest-as-table.kap' do
     expect(run_error_example('destructure-rest-as-table.kap'))
       .to eq("destructure-rest-as-table.kap:6:3: unable to bind table ...\n")

data/spec/examples_spec.rb

@@ -487,6 +487,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'signal-harvest.kap' do
+    expect(run_example('signal-harvest.kap')).to eq("40\ntrue\nfalse\n")
+  end
+
   it 'shapes.kap' do
     expect(run_example('shapes.kap')).to eq("78.5\n9\n8\n0\n")
   end
@@ -525,6 +529,19 @@ RSpec.describe 'examples' do
     expect(run_example('two-sum-hash.kap')).to eq("[0, 1]\n[1, 2]\nnil\n")
   end
 
+  it 'bst-iterator.kap' do
+    expect(run_example('bst-iterator.kap')).to eq(<<~OUT)
+      3
+      7
+      true
+      9
+      true
+      15
+      20
+      false
+    OUT
+  end
+
   it 'baseball-game.kap' do
     expect(run_example('baseball-game.kap')).to eq("30\n27\n")
   end
@@ -556,6 +573,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'recent-counter.kap' do
+    expect(run_example('recent-counter.kap')).to eq("4\n5\n")
+  end
+
   it 'reverse-integer.kap' do
     expect(run_example('reverse-integer.kap')).to eq("321\n-321\n21\n0\n")
   end

data/spec/lsp_spec.rb

@@ -268,7 +268,8 @@ RSpec.describe Kapusta::LSP do
         frame_rename(uri: uri['a.kap'], **cursor_at(text_a, 'foo'), new_name: 'bar')
       )
 
-      expect(result_for(responses).dig('error', 'message')).to include('already defined')
+      message = responses.find { |m| m['method'] == 'window/showMessage' }
+      expect(message['params']['message']).to include('already defined')
     end
   end
 
@@ -282,7 +283,8 @@ RSpec.describe Kapusta::LSP do
         frame_rename(uri: uri['a.kap'], **cursor_at(text_a, 'Foo'), new_name: 'Bar')
       )
 
-      expect(result_for(responses).dig('error', 'message')).to include('already defined')
+      message = responses.find { |m| m['method'] == 'window/showMessage' }
+      expect(message['params']['message']).to include('already defined')
     end
   end
 
@@ -304,6 +306,71 @@ RSpec.describe Kapusta::LSP do
     )
   end
 
+  it 'rejects renaming a class to a lowercase name with a clear message' do
+    text = "(class Accumulator)\n\n(end)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_rename(uri: 'file:///x.kap', **cursor_at(text, 'Accumulator'), new_name: 'fff')
+    )
+
+    response = result_for(responses)
+    expect(response['error']).to be_nil
+    expect(response['result']).to eq('documentChanges' => [])
+
+    show_message = responses.find { |m| m['method'] == 'window/showMessage' }
+    expect(show_message).not_to be_nil
+    expect(show_message['params']['type']).to eq(1)
+    expect(show_message['params']['message']).to include('uppercase letter')
+  end
+
+  it 'renames a class declared with a bodyless header closed by (end) and its usages after (end)' do
+    text = "(class Accumulator)\n\n(fn add! [n] n)\n\n(end)\n\n(let [acc (Accumulator.new 10)]\n  (acc.add! 5))\n"
+    with_workspace('a.kap' => text) do |root_uri, uri|
+      responses = run(
+        frame_initialize([root_uri]),
+        frame_did_open(uri['a.kap'], text),
+        frame_rename(uri: uri['a.kap'], **cursor_at(text, 'Accumulator'), new_name: 'Foo')
+      )
+      result = result_for(responses)['result']
+
+      expect(result).not_to be_nil
+      edits = result['documentChanges'].first['edits']
+      expect(edits.map { |e| e['range']['start']['line'] }).to contain_exactly(0, 6)
+      expect(edits.map { |e| e['newText'] }).to all(eq('Foo'))
+    end
+  end
+
+  it 'jumps from (end) to the class header that opened the file scope' do
+    text = "(class Foo)\n\n(fn hi [] 1)\n\n(end)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_definition(uri: 'file:///x.kap', **cursor_at(text, 'end'))
+    )
+    result = result_for(responses)['result']
+
+    expect(result).to eq(
+      'uri' => 'file:///x.kap',
+      'range' => {
+        'start' => { 'line' => 0, 'character' => 7 },
+        'end' => { 'line' => 0, 'character' => 10 }
+      }
+    )
+  end
+
+  it 'jumps from (end) to the matching module header for nested headers' do
+    text = "(module Outer)\n\n(module Inner)\n(fn self.go [] 1)\n(end)\n\n(end)\n"
+    responses = run(
+      frame_initialize,
+      frame_did_open('file:///x.kap', text),
+      frame_definition(uri: 'file:///x.kap', line: 4, character: 1)
+    )
+    result = result_for(responses)['result']
+
+    expect(result['range']['start']).to eq('line' => 2, 'character' => 8)
+  end
+
   it 'jumps to a top-level fn definition across files' do
     text_a = "(fn greet [n] (print n))\n"
     text_b = "(greet 42)\n"
@@ -583,7 +650,8 @@ RSpec.describe Kapusta::LSP do
         frame_rename(uri: uri['a.kap'], **cursor_at(text_a, 'swap!'), new_name: 'flip!')
       )
 
-      expect(result_for(responses).dig('error', 'message')).to include('already defined')
+      message = responses.find { |m| m['method'] == 'window/showMessage' }
+      expect(message['params']['message']).to include('already defined')
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -38,6 +38,7 @@ files:
 - examples/binary-to-decimal.kap
 - examples/block-sort.kap
 - examples/blocks-and-kwargs.kap
+- examples/bst-iterator.kap
 - examples/calc.kap
 - examples/circle.kap
 - examples/classify-wallet.kap
@@ -101,6 +102,7 @@ files:
 - examples/power-of-three.kap
 - examples/primes.kap
 - examples/raindrops.kap
+- examples/recent-counter.kap
 - examples/record.kap
 - examples/regex.kap
 - examples/reverse-integer.kap
@@ -110,6 +112,7 @@ files:
 - examples/scopes.kap
 - examples/shapes.kap
 - examples/shared-macros.kapm
+- examples/signal-harvest.kap
 - examples/single-number.kap
 - examples/squares.kap
 - examples/stack.kap