kapusta 0.11.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ba2ee0fbbd336f3604e9c51014a458c0a54eefcb30939fc6f2a72ba25941fb6
-  data.tar.gz: 687f46ff98b74d65d523404ba9350fd62921eada8e105f4fe0d9215eac036118
+  metadata.gz: b547075d7dcb73121e61dc17577cb8262265eaffb6ee0d74b88a74ce83c8e09a
+  data.tar.gz: 877f490eca3f0d4419e38b4619f77470aff18ddd8fede555f2963beb8db5994f
 SHA512:
-  metadata.gz: 070c9c5f4435f2e825f0bdb70ceb25f3cc5eba62745cae80f9d348aa4fc886d74a5f8ed06a93a62d572adbfadfbce5e93b3e37993a5d637e68d615af6e1ecfa7
-  data.tar.gz: fc1697cfb31821c867c468666eee7bb3cd6af985c446cba8ea35e3c50c5928750a0989ce31c250d2c1d47f79b4f338e319a17cb00abb314c7213a1e3f2eb89e1
+  metadata.gz: cddc220382f4c7f59788f4624f9e86f55bc58fe2b3fa6978f4e6d8bebaa870ff73be57786ecf2db94f14d6db460b3f485b6f82195e7fd21e255c7a7612ab50c2
+  data.tar.gz: 6c653e095b1c3d406f95e7f1659b615a2a59eaa21ef77e709cfc2dfc398d3526fb493f5054cb541acd36b203e690dbc28626e951e3e8f9d5e27366c0d5885834

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)
 ```
@@ -103,6 +104,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 | `string.format`, `table.insert`, etc. | use Ruby methods and stdlib instead                   |
 | `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
 | `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)             |
+| `(.. "x: " nil)` errors at runtime    | `(.. "x: " nil)` produces `"x: "` (Ruby `nil.to_s`)   |
 | `with-open`, `tail!`                  | not provided                                          |
 
 Kapusta-specific additions:

data/examples/arrange-coins.kap

@@ -0,0 +1,32 @@
+(fn arrange-coins [n]
+  (let [rows (faccumulate [acc {:sum 0 :rows 0} i 1 n]
+               (let [new-sum (+ (. acc :sum) i)]
+                 (if (<= new-sum n)
+                     {:sum new-sum :rows i}
+                     acc)))
+        used (faccumulate [acc {:sum 0 :rows 0} i 1 n]
+               (let [new-sum (+ (. acc :sum) i)]
+                 (if (<= new-sum n)
+                     {:sum new-sum :rows i}
+                     acc)))]
+    [(. rows :rows) (. used :sum)]))
+
+(let [[r u] (arrange-coins 0)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 1)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 5)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 8)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 10)]
+  (print r)
+  (print u))

data/examples/array-sign.kap

@@ -0,0 +1,24 @@
+(fn sign [n]
+  (if (> n 0) 1
+      (< n 0) -1
+      0))
+
+(fn array-sign [nums]
+  (accumulate [acc 1 _ n (ipairs nums)]
+    (* acc (sign n))))
+
+(fn join [tbl sep]
+  (var s "")
+  (each [_ x (ipairs tbl)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(fn debug-sign [label nums]
+  (local pretty #(.. "[" (join $ ", ") "]"))
+  (.. "case[" label "] in " (pretty nums) " out " (array-sign nums)))
+
+(print (debug-sign "mixed" [-1 -2 -3 -4 3 2 1]))
+(print (debug-sign "withzero" [1 5 0 2 -3]))
+(print (debug-sign "allneg" [-1 1 -1 1 -1]))

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/case-vs-match.kap

@@ -0,0 +1,23 @@
+(fn debug-data [packet seq]
+  (local no-nil #(or $ "nil"))
+  (let [[_ packet-seq] packet]
+    (.. "packet[:ping, " (no-nil packet-seq) "] seq " (no-nil seq))))
+
+(fn show-case [packet seq]
+  (case packet
+    [:ping seq] (debug-data packet seq)
+    _ "other"))
+
+(fn show-match [packet seq]
+  (match packet
+    [:ping seq] (debug-data packet seq)
+    _ "other"))
+
+(print (.. "case: " (show-case [:ping 42] 7)))
+(print (.. "case: " (show-case [:ping 42] nil)))
+(print (.. "case: " (show-case [:ping nil] nil)))
+(print (.. "case: " (show-case [:ping 42] 42)))
+(print (.. "match: " (show-match [:ping 42] 7)))
+(print (.. "match: " (show-match [:ping 42] nil)))
+(print (.. "match: " (show-match [:ping nil] nil)))
+(print (.. "match: " (show-match [:ping 42] 42)))

data/examples/divisibility-stats.kap

@@ -0,0 +1,16 @@
+(fn divisibility-stats [n]
+  (let [threes (faccumulate [acc 0 i 1 n]
+                 (let [step (if (= 0 (% i 3)) 1 0)]
+                   (+ acc step)))
+        fives (faccumulate [acc 0 i 1 n]
+                (let [step (if (= 0 (% i 5)) 1 0)]
+                  (+ acc step)))]
+    [threes fives]))
+
+(let [[t f] (divisibility-stats 30)]
+  (print t)
+  (print f))
+
+(let [[t f] (divisibility-stats 100)]
+  (print t)
+  (print f))

data/examples/equal-sums.kap

@@ -0,0 +1,7 @@
+(fn equal-sums? [a b]
+  (= (accumulate [s 0 _ x (ipairs a)] (+ s x))
+     (accumulate [s 0 _ x (ipairs b)] (+ s x))))
+
+(print (equal-sums? [1 2 3] [3 2 1]))
+(print (equal-sums? [1 2 3] [4 5 6]))
+(print (equal-sums? [0] [0]))

data/examples/fennel-parity-examples.txt

@@ -1,11 +1,16 @@
 ackermann
 anonymous-greeter
+array-sign
+arrange-coins
+case-vs-match
 classify-wallet
 climbing-stairs
 convert-temperature
 count-effects
 describe
 destructure
+divisibility-stats
+equal-sums
 even-squares
 factorial
 falling-drops
@@ -15,9 +20,9 @@ gcd
 hashfn
 leap-year
 macros-dbg
+macros-import
 macros-import-helpers
 macros-import-whole
-macros-import
 macros-multi
 macros-swap
 macros-thrice-if
@@ -26,10 +31,12 @@ macros-when-let
 match
 max-achievable
 min-max
+nested-nil-pattern
+non-constant-local
 or-patterns
-power-of-three
 packet-router
 points
+power-of-three
 primes
 safe-lookup
 shapes

data/examples/mruby-runtime-examples.txt

@@ -3,6 +3,7 @@ accumulator
 ackermann
 anagram
 anonymous-greeter
+arrange-coins
 bank-account
 baseball-game
 best-time-to-buy-sell-stock
@@ -11,6 +12,7 @@ binary-to-decimal
 block-sort
 bst-iterator
 calc
+case-vs-match
 circle
 classify-wallet
 climbing-stairs
@@ -20,8 +22,9 @@ count-effects
 counter
 describe
 destructure
-doto-hygiene
+divisibility-stats
 doto
+doto-hygiene
 egg-count
 even-squares
 exceptions
@@ -38,9 +41,9 @@ kwargs
 leap-year
 length-of-last-word
 macros-dbg
+macros-import
 macros-import-helpers
 macros-import-whole
-macros-import
 macros-multi
 macros-swap
 macros-thrice-if
@@ -53,6 +56,7 @@ max-achievable
 maximum-subarray
 min-max
 module-header
+nested-nil-pattern
 move-zeroes
 number-of-1-bits
 number-of-steps
@@ -84,8 +88,8 @@ thread-styles
 threading
 tic-tac-toe
 tset
-two-sum-hash
 two-sum
+two-sum-hash
 ugly-number
 underscore-patterns
 valid-parentheses-1

data/examples/nested-nil-pattern.kap

@@ -0,0 +1,7 @@
+(fn check [packet]
+  (case packet
+    [:ping seq] (.. "got " seq)
+    _ "other"))
+
+(print (check [:ping 42]))
+(print (check [:ping nil]))

data/examples/non-constant-local.kap

@@ -0,0 +1,11 @@
+(local hash-fn #(or $ "nil"))
+(local regular-fn (fn [x] (+ x 1)))
+(local lambda-fn (λ [x] (* x 2)))
+(local vec-binding [10 20 30])
+(local hash-binding {:a 1})
+
+(print (hash-fn nil))
+(print (regular-fn 5))
+(print (lambda-fn 5))
+(print (length vec-binding))
+(print (. hash-binding :a))

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

@@ -57,7 +57,7 @@ module Kapusta
 
         def build_simple_block_parts(pattern, body, env, current_scope)
           body_env = env.child
-          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
+          params = pattern.items.map { |sym| define_local(body_env, sym, shadow: true) }
           body_code, = emit_sequence(body, body_env, current_scope,
                                      allow_method_definitions: false, result: false)
           [params, body_code]
@@ -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
@@ -296,7 +308,9 @@ module Kapusta
 
           if target.is_a?(Sym)
             validate_binding_symbol!(target)
-            if allow_constant && form.head.name == 'local' && (constant_name = constant_name_for(target.name))
+            if allow_constant && form.head.name == 'local' &&
+               constant_value?(form.items[2]) &&
+               (constant_name = constant_name_for(target.name))
               env.define(target.name, constant_name)
               mark_mutability(env, target.name, mutable: false)
               return ["#{constant_name} = #{value_code}\nnil", env]
@@ -316,6 +330,13 @@ module Kapusta
           candidate if candidate.match?(/\A[A-Z][A-Z0-9_]*\z/)
         end
 
+        def constant_value?(value_form)
+          case value_form
+          when Numeric, String, ::Symbol, true, false, nil then true
+          else false
+          end
+        end
+
         def check_destructure_value!(pattern, value_form)
           return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
 
@@ -376,7 +397,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
@@ -420,7 +441,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

@@ -111,30 +111,23 @@ module Kapusta
           bindings = args[0].items
           emit_error!(:accumulate_no_iterator) if bindings.length < 5
 
-          acc_name = bindings[0]
-          loop_name = bindings[2]
-          loop_env = env.child
-          acc_var = define_local(loop_env, acc_name.name)
-          loop_var = define_local(loop_env, loop_name.name)
-          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          accumulating_body = emit_sequence_value_assignment(acc_var, body_code)
-          loop_code = emit_counted_loop(
-            ruby_name: loop_var,
-            start_code: emit_expr(bindings[3], env, current_scope),
-            finish_code: emit_expr(bindings[4], env, current_scope),
-            step_code: bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1',
-            until_form: nil,
-            loop_env:,
-            current_scope:,
-            body_code: accumulating_body
-          )
-          [
-            '(-> do',
-            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
-            indent(loop_code),
-            indent(acc_var),
-            'end).call'
-          ].join("\n")
+          body_env = env.child
+          acc_var = define_local(body_env, bindings[0].name)
+          loop_var = define_local(body_env, bindings[2].name)
+
+          init_code = emit_expr(bindings[1], env, current_scope)
+          start_code = emit_expr(bindings[3], env, current_scope)
+          finish_code = emit_expr(bindings[4], env, current_scope)
+          step_code = bindings[5] ? emit_expr(bindings[5], env, current_scope) : nil
+          body_code, = emit_sequence(args[1..], body_env, current_scope, allow_method_definitions: false)
+
+          receiver =
+            if step_code
+              "#{parenthesize(start_code)}.step(#{finish_code}, #{step_code})"
+            else
+              "(#{start_code}..#{finish_code})"
+            end
+          inject_block(receiver, "#{acc_var}, #{loop_var}", init_code, '', body_code)
         end
 
         def emit_hashfn(args, env, current_scope)

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

@@ -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
@@ -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

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]
@@ -170,14 +174,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 +344,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/compiler/normalizer.rb

@@ -139,6 +139,8 @@ module Kapusta
 
       def doto(forms)
         value = forms.first
+        return value if forms[1..].empty?
+
         temp = gensym('doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
@@ -147,7 +149,8 @@ module Kapusta
             List.new([form, temp])
           end
         end
-        List.new([Sym.new('let'), Vec.new([temp, value]), *body, temp])
+        fn = List.new([Sym.new('fn'), Vec.new([temp]), *body])
+        List.new([Sym.new(':'), value, :tap, fn])
       end
 
       def gensym(prefix)

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/formatter.rb

@@ -555,30 +555,18 @@ module Kapusta
       lines = [base]
       args = list_raw_rest(list)
       semantic_length = semantic_items(args).length
+      hang_subsequent_args = hang_call_args?(list, indent)
 
       semantic_index = 0
+      hanging = nil
       args.each do |arg|
         if comment?(arg)
           lines << indent_block(render(arg, indent + INDENT), INDENT)
           next
-        end
-
-        if semantic_index.zero?
-          first = render(
-            arg,
-            indent + base.length + 1,
-            force_expand: semantic_length == 1 && fn_form?(arg)
-          )
-          first_line, *rest = first.lines(chomp: true)
-          candidate = "#{base} #{first_line}"
-
-          if lines.length == 1 && fits?(candidate, indent)
-            lines[0] = candidate
-            hanging = ' ' * (base.length + 1)
-            rest.each { |line| lines << "#{hanging}#{line}" }
-          else
-            lines << indent_block(first, INDENT)
-          end
+        elsif semantic_index.zero?
+          hanging = append_first_call_arg(lines, arg, base, indent, semantic_length)
+        elsif hanging && hang_subsequent_args
+          lines << prefix_continuation(hanging, render(arg, indent + hanging.length))
         else
           lines << indent_block(render(arg, indent + INDENT), INDENT)
         end
@@ -589,6 +577,48 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
+    def append_first_call_arg(lines, arg, base, indent, semantic_length)
+      first = render(
+        arg,
+        indent + base.length + 1,
+        force_expand: semantic_length == 1 && fn_form?(arg)
+      )
+      first_line, *rest = first.lines(chomp: true)
+      candidate = "#{base} #{first_line}"
+
+      unless lines.length == 1 && fits?(candidate, indent)
+        lines << indent_block(first, INDENT)
+        return
+      end
+
+      hanging = ' ' * (base.length + 1)
+      lines[0] = candidate
+      rest.each { |line| lines << "#{hanging}#{line}" }
+      hanging
+    end
+
+    def hang_call_args?(list, indent)
+      return false unless operator_call?(list)
+
+      flat = flat_call_render(list)
+      flat && !fits?(flat, indent)
+    end
+
+    def operator_call?(list)
+      head = list_head(list)
+      head.is_a?(Sym) && head.name.match?(/\A[^\w.]+\z/)
+    end
+
+    def flat_call_render(list)
+      head = flat_render(list_head(list))
+      return unless head
+
+      rendered_args = semantic_items(list_raw_rest(list)).map { |arg| flat_render(arg) }
+      return if rendered_args.any?(&:nil?)
+
+      "(#{[head, *rendered_args].join(' ')})"
+    end
+
     def render_vec(vec, indent, layout: nil, top_level: false, force_expand: false)
       flat = flat_render(vec)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(vec, top_level:, layout:)
@@ -800,8 +830,7 @@ module Kapusta
            'fn', 'lambda', 'λ', 'macro'
         true
       else
-        flat = flat_render(form)
-        flat && flat.length > 40
+        false
       end
     end
 

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/lsp.rb

@@ -15,8 +15,38 @@ module Kapusta
     METHOD_NOT_FOUND = -32_601
     FULL_SYNC = 1
 
+    def self.debug?
+      %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+    end
+
     def self.start(input: $stdin, output: $stdout, log: $stderr)
-      new(input:, output:, log:).run
+      server = new(input:, output:, log:)
+      install_signal_handlers(log)
+      server.run
+      debug_log(log, 'run returned, calling exit!(0)')
+      exit!(0)
+    end
+
+    def self.install_signal_handlers(log)
+      %w[TERM INT HUP].each do |sig|
+        Signal.trap(sig) do
+          debug_log(log, "signal #{sig} received, exiting")
+          exit!(0)
+        rescue StandardError
+          exit!(0)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def self.debug_log(log, message)
+      return unless debug?
+
+      log.write("kapusta-ls[debug pid=#{Process.pid}]: #{message}\n")
+      log.flush
+    rescue StandardError
+      nil
     end
 
     def self.uri_to_path(uri)
@@ -34,7 +64,7 @@ module Kapusta
       @input = input.binmode
       @output = output.binmode
       @log = log
-      @debug = %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+      @debug = LSP.debug?
       @sources = {}
       @workspace_index = WorkspaceIndex.new
       @initialized = false
@@ -42,9 +72,11 @@ module Kapusta
     end
 
     def run
+      debug('run loop start')
       until (message = read_message).nil?
         handle(message)
       end
+      debug('stdin EOF, run loop exiting')
     end
 
     private
@@ -83,8 +115,14 @@ module Kapusta
 
     def write_message(payload)
       body = JSON.generate(payload)
+      tag = payload[:id] ? "response id=#{payload[:id]}" : "notify #{payload[:method]}"
+      debug("write begin (#{tag}, #{body.bytesize} bytes)")
       @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
       @output.flush
+      debug("write done (#{tag})")
+    rescue Errno::EPIPE, IOError => e
+      debug("write failed (#{e.class}: #{e.message}), exiting")
+      exit!(0)
     end
 
     def handle(message)
@@ -92,9 +130,11 @@ module Kapusta
       id = message['id']
       params = message['params'] || {}
 
+      debug("dispatch begin method=#{method.inspect} id=#{id.inspect}")
       return handle_pre_init(method, id, params) unless @initialized || method == 'initialize' || method == 'exit'
 
       dispatch(method, id, params)
+      debug("dispatch end method=#{method.inspect} id=#{id.inspect}")
     rescue StandardError => e
       log("#{e.class}: #{e.message}")
       log(e.backtrace.first(5).join("\n"))
@@ -116,8 +156,12 @@ module Kapusta
       when 'initialized' then nil
       when 'shutdown'
         @shutdown = true
+        debug('shutdown received, replying and arming watchdog')
         reply(id, nil)
-      when 'exit' then exit(@shutdown ? 0 : 1)
+        arm_shutdown_watchdog
+      when 'exit'
+        debug("exit notification received (shutdown=#{@shutdown}), calling exit!")
+        exit!(@shutdown ? 0 : 1)
       when 'textDocument/didOpen' then on_did_open(params)
       when 'textDocument/didChange' then on_did_change(params)
       when 'textDocument/didSave' then on_did_save(params)
@@ -300,14 +344,28 @@ module Kapusta
       notify('textDocument/publishDiagnostics', params)
     end
 
+    def arm_shutdown_watchdog(seconds: 2)
+      Thread.new do
+        sleep seconds
+        debug("shutdown watchdog firing after #{seconds}s, forcing exit")
+        exit!(0)
+      end
+    end
+
     def log(message)
       @log.puts "kapusta-ls: #{message}"
+      @log.flush
+    rescue StandardError
+      nil
     end
 
     def debug(message)
       return unless @debug
 
-      @log.puts "kapusta-ls[debug]: #{message}"
+      @log.write("kapusta-ls[debug pid=#{Process.pid}]: #{message}\n")
+      @log.flush
+    rescue StandardError
+      nil
     end
   end
 end

data/lib/kapusta/version.rb

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

data/spec/examples_spec.rb

@@ -76,6 +76,29 @@ RSpec.describe 'examples' do
     expect(run_example('ackermann.kap')).to eq("9\n61\n")
   end
 
+  it 'non-constant-local.kap' do
+    expect(run_example('non-constant-local.kap')).to eq(<<~OUT)
+      "nil"
+      6
+      10
+      3
+      1
+    OUT
+  end
+
+  it 'case-vs-match.kap' do
+    expect(run_example('case-vs-match.kap')).to eq(<<~OUT)
+      "case: packet[:ping, 42] seq 42"
+      "case: packet[:ping, 42] seq 42"
+      "case: other"
+      "case: packet[:ping, 42] seq 42"
+      "match: other"
+      "match: other"
+      "match: packet[:ping, nil] seq nil"
+      "match: packet[:ping, 42] seq 42"
+    OUT
+  end
+
   it 'accumulator.kap' do
     expect(run_example('accumulator.kap')).to eq("22\n")
   end
@@ -92,6 +115,30 @@ RSpec.describe 'examples' do
     expect(run_example('circle.kap')).to eq("78.53975\n31.4159\n")
   end
 
+  it 'arrange-coins.kap' do
+    expect(run_example('arrange-coins.kap')).to eq(<<~OUT)
+      0
+      0
+      1
+      1
+      2
+      3
+      3
+      6
+      4
+      10
+    OUT
+  end
+
+  it 'divisibility-stats.kap' do
+    expect(run_example('divisibility-stats.kap')).to eq(<<~OUT)
+      10
+      6
+      33
+      20
+    OUT
+  end
+
   it 'anagram.kap' do
     expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
   end
@@ -444,15 +491,10 @@ RSpec.describe 'examples' do
     OUT
   end
 
-  it 'underscore-patterns.kap on mruby keeps loose nil and strict fallback separate' do
-    path = File.join(EXAMPLES_DIR, 'underscore-patterns.kap')
-    ruby = compile_example('underscore-patterns.kap', target: :mruby3)
-
-    expect(run_mruby_source(ruby, path:)).to eq(<<~OUT)
-      5
-      nil
-      5
-      "fallback"
+  it 'nested-nil-pattern.kap' do
+    expect(run_example('nested-nil-pattern.kap')).to eq(<<~OUT)
+      "got 42"
+      "other"
     OUT
   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.11.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -31,6 +31,8 @@ files:
 - examples/ackermann.kap
 - examples/anagram.kap
 - examples/anonymous-greeter.kap
+- examples/arrange-coins.kap
+- examples/array-sign.kap
 - examples/bank-account.kap
 - examples/baseball-game.kap
 - examples/best-time-to-buy-sell-stock.kap
@@ -40,6 +42,7 @@ files:
 - examples/blocks-and-kwargs.kap
 - examples/bst-iterator.kap
 - examples/calc.kap
+- examples/case-vs-match.kap
 - examples/circle.kap
 - examples/classify-wallet.kap
 - examples/climbing-stairs.kap
@@ -49,9 +52,11 @@ files:
 - examples/counter.kap
 - examples/describe.kap
 - examples/destructure.kap
+- examples/divisibility-stats.kap
 - examples/doto-hygiene.kap
 - examples/doto.kap
 - examples/egg-count.kap
+- examples/equal-sums.kap
 - examples/even-squares.kap
 - examples/exceptions.kap
 - examples/factorial.kap
@@ -87,6 +92,8 @@ files:
 - examples/module-header.kap
 - examples/move-zeroes.kap
 - examples/mruby-runtime-examples.txt
+- examples/nested-nil-pattern.kap
+- examples/non-constant-local.kap
 - examples/number-of-1-bits.kap
 - examples/number-of-steps.kap
 - examples/or-patterns.kap