kapusta 0.10.0 → 0.11.1

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,51 +99,63 @@ 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
 
         def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:, result_needed: true)
           with_current_form(form) do
-            if allow_method_definitions &&
-               method_definition_form?(form) &&
-               %i[toplevel module class].include?(current_scope)
-              code, env = emit_definition_form(form, env, current_scope)
-              return [code, env] if code
-            end
+            form = lower_defn_in_sequence(form, current_scope) if defn_form?(form)
+            emit_form_body(form, env, current_scope, allow_method_definitions:, result_needed:)
+          end
+        end
 
-            if named_function_form?(form)
-              emit_named_fn_assignment(form, env, current_scope)
-            elsif local_form?(form)
-              code, env = emit_local_form(form, env, current_scope,
-                                          allow_constant: allow_method_definitions)
-              code = code.delete_suffix("\nnil") unless result_needed
-              [code, env]
-            elsif do_form?(form)
-              emit_do_form(form.rest, env, current_scope, result_needed:)
-            elsif sequence_statement_form?(form)
-              emit_sequence_statement_form(form, env, current_scope, result_needed:)
-            elsif set_new_local_form?(form, env)
-              emit_set_form(form, env, current_scope)
-            else
-              [emit_expr(form, env, current_scope), env]
-            end
+        def lower_defn_in_sequence(form, current_scope)
+          emit_error!(:defn_outside_header) unless %i[module class].include?(current_scope)
+          lower_defn_to_fn(form)
+        end
+
+        def emit_form_body(form, env, current_scope, allow_method_definitions:, result_needed:)
+          if allow_method_definitions &&
+             method_definition_form?(form) &&
+             %i[toplevel module class].include?(current_scope)
+            code, env = emit_definition_form(form, env, current_scope)
+            return [code, env] if code
+          end
+
+          if named_function_form?(form)
+            emit_named_fn_assignment(form, env, current_scope)
+          elsif local_form?(form)
+            code, env = emit_local_form(form, env, current_scope,
+                                        allow_constant: allow_method_definitions)
+            code = code.delete_suffix("\nnil") unless result_needed
+            [code, env]
+          elsif do_form?(form)
+            emit_do_form(form.rest, env, current_scope, result_needed:)
+          elsif sequence_statement_form?(form)
+            emit_sequence_statement_form(form, env, current_scope, result_needed:)
+          elsif set_new_local_form?(form, env)
+            emit_set_form(form, env, current_scope)
+          else
+            [emit_expr(form, env, current_scope), env]
           end
         end
 
@@ -182,6 +224,26 @@ module Kapusta
             %w[fn lambda λ].include?(form.head.name) && form.items[1].is_a?(Sym)
         end
 
+        def defn_form?(form)
+          form.is_a?(List) && !form.empty? && form.head.is_a?(Sym) && form.head.name == 'defn'
+        end
+
+        def lower_defn_to_fn(form)
+          name_sym = form.items[1]
+          emit_error!(:fn_no_params) unless name_sym.is_a?(Sym)
+
+          fn_sym = Sym.new('fn')
+          fn_sym.line = form.head.line
+          fn_sym.column = form.head.column
+          self_sym = Sym.new("self.#{name_sym.name}")
+          self_sym.line = name_sym.line
+          self_sym.column = name_sym.column
+          new_list = List.new([fn_sym, self_sym, *form.items[2..]])
+          new_list.line = form.line
+          new_list.column = form.column
+          new_list
+        end
+
         def method_definition_form?(form)
           named_function_form?(form)
         end

data/lib/kapusta/compiler/macro_expander.rb

@@ -57,9 +57,9 @@ module Kapusta
       def expand(form)
         case form
         when List then expand_list(form)
-        when Vec then copy_position(Vec.new(form.items.map { |item| expand(item) }), form)
+        when Vec then Kapusta.copy_position(Vec.new(form.items.map { |item| expand(item) }), form)
         when HashLit
-          copy_position(
+          Kapusta.copy_position(
             HashLit.new(form.entries.map do |entry|
               entry.is_a?(Array) ? [expand(entry[0]), expand(entry[1])] : entry
             end),
@@ -70,14 +70,6 @@ module Kapusta
         end
       end
 
-      def copy_position(target, source)
-        return target unless target.respond_to?(:line=) && source.respond_to?(:line)
-
-        target.line ||= source.line
-        target.column ||= source.column
-        target
-      end
-
       def expand_list(list)
         return list if list.empty?
 
@@ -100,11 +92,11 @@ module Kapusta
           if @macros.key?(key)
             args = list.rest
             result = invoke_macro(key, args)
-            return copy_position(expand(result), list)
+            return Kapusta.copy_position(expand(result), list)
           end
         end
 
-        copy_position(List.new(list.items.map { |item| expand(item) }), list)
+        Kapusta.copy_position(List.new(list.items.map { |item| expand(item) }), list)
       end
 
       def lookup_key(name)

data/lib/kapusta/compiler/macro_lowerer.rb

@@ -34,15 +34,15 @@ module Kapusta
 
       def lower(form)
         case form
-        when Quasiquote then copy_position(lower_quasi(form.form), form)
+        when Quasiquote then Kapusta.copy_position(lower_quasi(form.form), form)
         when Unquote, UnquoteSplice
           raise @error_class, Kapusta::Errors.format(:unquote_outside_quasiquote)
         when AutoGensym
           raise @error_class, Kapusta::Errors.format(:auto_gensym_outside_quasiquote, name: form.name)
-        when List then copy_position(List.new(form.items.map { |item| lower(item) }), form)
-        when Vec then copy_position(Vec.new(form.items.map { |item| lower(item) }), form)
+        when List then Kapusta.copy_position(List.new(form.items.map { |item| lower(item) }), form)
+        when Vec then Kapusta.copy_position(Vec.new(form.items.map { |item| lower(item) }), form)
         when HashLit
-          copy_position(
+          Kapusta.copy_position(
             HashLit.new(form.entries.map do |entry|
               entry.is_a?(Array) ? [lower(entry[0]), lower(entry[1])] : entry
             end),
@@ -94,14 +94,6 @@ module Kapusta
         form.is_a?(List) && form.head.is_a?(Sym) && FN_HEADS.include?(form.head.name)
       end
 
-      def copy_position(target, source)
-        return target unless target.respond_to?(:line=) && source.respond_to?(:line)
-
-        target.line ||= source.line
-        target.column ||= source.column
-        target
-      end
-
       def lower_quasi(form)
         case form
         when AutoGensym then gensym_local_for(form.name)

data/lib/kapusta/compiler/normalizer.rb

@@ -12,9 +12,9 @@ module Kapusta
       def normalize(form)
         case form
         when List then normalize_list(form)
-        when Vec then inherit_position(Vec.new(form.items.map { |item| normalize(item) }), form)
+        when Vec then Kapusta.copy_position(Vec.new(form.items.map { |item| normalize(item) }), form)
         when HashLit
-          inherit_position(
+          Kapusta.copy_position(
             HashLit.new(form.pairs.map { |key, value| [normalize_hash_key(key), normalize(value)] }),
             form
           )
@@ -37,7 +37,7 @@ module Kapusta
 
         head = list.head
         items = list.items.map { |item| normalize(item) }
-        return inherit_position(List.new(items), list) unless head.is_a?(Sym)
+        return Kapusta.copy_position(List.new(items), list) unless head.is_a?(Sym)
 
         case head.name
         when 'when'
@@ -45,39 +45,31 @@ module Kapusta
 
           cond = items[1]
           body = wrap_do(items[2..])
-          inherit_position(List.new([Sym.new('if'), cond, body]), list)
+          Kapusta.copy_position(List.new([Sym.new('if'), cond, body]), list)
         when 'unless'
           raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
 
           cond = items[1]
           body = wrap_do(items[2..])
-          inherit_position(List.new([Sym.new('if'), List.new([Sym.new('not'), cond]), body]), list)
+          Kapusta.copy_position(List.new([Sym.new('if'), List.new([Sym.new('not'), cond]), body]), list)
         when 'tset'
           raise compiler_error(:tset_no_value, list) if items.length < 4
 
-          inherit_position(
+          Kapusta.copy_position(
             List.new([Sym.new('set'), List.new([Sym.new('.'), items[1], items[2]]), items[3]]),
             list
           )
         when *LuaCompat::SPECIAL_FORMS
           normalize_lua_compat_form(head.name, items)
         when '->', '->>', '-?>', '-?>>'
-          inherit_position(normalize(thread(items[1..], head.name)), list)
+          Kapusta.copy_position(normalize(thread(items[1..], head.name)), list)
         when 'doto'
-          inherit_position(normalize(doto(items[1..])), list)
+          Kapusta.copy_position(normalize(doto(items[1..])), list)
         else
-          inherit_position(List.new(items), list)
+          Kapusta.copy_position(List.new(items), list)
         end
       end
 
-      def inherit_position(target, source)
-        return target unless target.respond_to?(:line=) && source.respond_to?(:line)
-
-        target.line ||= source.line
-        target.column ||= source.column
-        target
-      end
-
       def compiler_error(code, form, **args)
         line = form.respond_to?(:line) ? form.line : nil
         column = form.respond_to?(:column) ? form.column : nil

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,10 @@ module Kapusta
       dot_no_args: 'expected table argument',
       each_no_binding: 'expected binding table',
       empty_call: 'expected a function, macro, or special to call',
+      defn_outside_header: 'defn outside class or module',
+      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,17 +15,24 @@ module Kapusta
           bindings[name] || parent&.lookup(name)
         end
       end
-
-      SKIPPED_HEADS = %w[macros quasi-sym quasi-list
-                         quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym].freeze
+      EndMarker = Struct.new(:line, :column, :end_column, :target, keyword_init: true)
 
       DISPATCHERS = {
+        'macros' => :skip,
+        'quasi-sym' => :skip,
+        'quasi-list' => :skip,
+        'quasi-list-tail' => :skip,
+        'quasi-vec' => :skip,
+        'quasi-vec-tail' => :skip,
+        'quasi-hash' => :skip,
+        'quasi-gensym' => :skip,
         'let' => :walk_let,
         'local' => :walk_local_var,
         'var' => :walk_local_var,
         'global' => :walk_global,
         'set' => :walk_set,
         'fn' => :walk_fn,
+        'defn' => :walk_fn,
         'lambda' => :walk_fn,
         'λ' => :walk_fn,
         'for' => :walk_for,
@@ -48,7 +55,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 +66,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 +75,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 +154,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
@@ -217,10 +251,12 @@ module Kapusta
           return
         end
 
-        return if SKIPPED_HEADS.include?(head.name)
-
         dispatcher = DISPATCHERS[head.name]
-        return send(dispatcher, list, scope) if dispatcher
+        if dispatcher
+          return if dispatcher == :skip
+
+          return send(dispatcher, list, scope)
+        end
 
         list.items.each { |item| walk_form(item, scope) }
       end
@@ -351,28 +387,30 @@ module Kapusta
       def walk_fn(list, scope)
         items = list.items
         if items[1].is_a?(Vec)
+          name_sym = nil
           params = items[1]
           body = items[2..]
-          fn_scope = make_scope(scope, :fn)
-          bind_param_vec(params, fn_scope)
-          body.each { |form| walk_form(form, fn_scope) }
         elsif items[1].is_a?(Sym) && items[2].is_a?(Vec)
           name_sym = items[1]
           params = items[2]
           body = items[3..]
+        else
+          items[1..]&.each { |item| walk_form(item, scope) }
+          return
+        end
+
+        fn_scope = make_scope(scope, :fn)
+        if name_sym
           kind = if method_definition_context?
                    :method
                  else
                    (scope == @root_scope ? :toplevel_fn : :fn_local)
                  end
-          fn_scope = make_scope(scope, :fn)
           binding = add_binding(name_sym, scope, kind, lexical: kind != :method)
           fn_scope.bindings[name_sym.name] = binding unless kind == :method
-          bind_param_vec(params, fn_scope)
-          body.each { |form| walk_form(form, fn_scope) }
-        else
-          items[1..]&.each { |item| walk_form(item, scope) }
         end
+        bind_param_vec(params, fn_scope)
+        body.each { |form| walk_form(form, fn_scope) }
       end
 
       def method_definition_context?
@@ -557,40 +595,35 @@ module Kapusta
         end
       end
 
-      def bind_param_vec(vec, scope)
-        items = vec.items
+      def each_pattern_item(items)
         i = 0
         while i < items.length
-          item = items[i]
-          if item.is_a?(Sym) && item.name == '&'
-            rest = items[i + 1]
-            bind_pattern(rest, scope, :fn_param) if rest.is_a?(Sym) && rest.name != '_'
+          if items[i].is_a?(Sym) && items[i].name == '&'
+            yield :rest, items[i + 1]
             i += 2
-          elsif item.is_a?(Sym) && ['...', '_'].include?(item.name)
-            i += 1
           else
-            bind_pattern(item, scope, :fn_param)
+            yield :item, items[i]
             i += 1
           end
         end
       end
 
-      def bind_vec_pattern(vec, scope, kind)
-        items = vec.items
-        i = 0
-        while i < items.length
-          item = items[i]
-          if item.is_a?(Sym) && item.name == '&'
-            rest = items[i + 1]
-            bind_pattern(rest, scope, kind) if rest
-            i += 2
-          else
-            bind_pattern(item, scope, kind)
-            i += 1
+      def bind_param_vec(vec, scope)
+        each_pattern_item(vec.items) do |kind, item|
+          if kind == :rest
+            bind_pattern(item, scope, :fn_param) if item.is_a?(Sym) && item.name != '_'
+          elsif !(item.is_a?(Sym) && ['...', '_'].include?(item.name))
+            bind_pattern(item, scope, :fn_param)
           end
         end
       end
 
+      def bind_vec_pattern(vec, scope, kind)
+        each_pattern_item(vec.items) do |item_kind, item|
+          bind_pattern(item, scope, kind) if item_kind == :item || item
+        end
+      end
+
       def bind_hash_pattern(hash, scope, kind)
         hash.pairs.each do |pair|
           bind_pattern(pair[1], scope, kind)