kapusta 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5e4a7dc8e3d044580b58064b4632706c2115964847d674c23bbe39a625e0b6e
-  data.tar.gz: b17a395b81ab568829022273e5df9ee5a186c052d6a1e4c843df631dfe1d6f76
+  metadata.gz: b547075d7dcb73121e61dc17577cb8262265eaffb6ee0d74b88a74ce83c8e09a
+  data.tar.gz: 877f490eca3f0d4419e38b4619f77470aff18ddd8fede555f2963beb8db5994f
 SHA512:
-  metadata.gz: d3e8ca629130a695a67a1c210ab06869518e2d232084e01a8cb6d180094e2b10b0cbc3f65c191a9a7a6b1e70727f1563f28e3637264cc7776a58c2e16e554991
-  data.tar.gz: 71695c0adf8e37705c9b9b85263e495578bcdd0d442c2d56ad09b1a6386640003164adf98d932c499472ae81d5c3d4a909898b907417e6d6463384b855b2fa33
+  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)
 ```

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

@@ -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
@@ -385,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
@@ -429,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/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/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.0'
 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.0
 platform: ruby
 authors:
 - Evgenii Morozov