kapusta 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 326afa9f8872d9d92bf4c3ca32fa5c15f78559691aa447a23472a4042a4f3a4c
-  data.tar.gz: 625c013cad69a7e2229ea99a64796c2de90f9fd9665152c74cbd6753c67319f0
+  metadata.gz: 85bcd0988a353fb851e5ff955c2b5196f39193e1c3c8fb6ca4a111d6260e774d
+  data.tar.gz: 80efbc138038947b866eaac96ef21d5cdccd04a461a25f2e17cbd7ce925ceaec
 SHA512:
-  metadata.gz: 2768ae288a6011b651f7e084af68717a3cf6486a45483985fe8eeb7ed9fa9ea3f2ce18c6db77b94e74b130cc10c84c486970569eee760fb82ae858070486049b
-  data.tar.gz: 04245b8c5e76773abe1f6c9efde7c64242eaec147e8f07c3d91239a893c25cf2477e4e2b7cec518aa2e82ee948238088d37f68731f41f807aebb6c911c2d03e8
+  metadata.gz: 16d02e652b9221990ac027423e677a8f27c285d582c6bfb368f585140305e1c48dff5add4a8491a7996b5be99e34efd761e7fb280d8932fc6548622939b166b4
+  data.tar.gz: 8ab10f9991b7029d9366e47d434a9e9166568b870369f1fe585007fbe2cf9b750c84e8eb3b8fb015db255977eef80fd3255750fa99006d577a9564b640d84319

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

@@ -148,10 +148,7 @@ module Kapusta
           return unless ruby_name
           return if captures_outer_binding?(body, env, pattern_names(pattern))
 
-          body_env = env.child
-          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
-          body_code, = emit_sequence(body, body_env, :toplevel,
-                                     allow_method_definitions: false, result: false)
+          params, body_code = build_simple_block_parts(pattern, body, env, :toplevel)
           header = params.empty? ? "def #{ruby_name}" : "def #{ruby_name}(#{params.join(', ')})"
           [
             header,

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

@@ -111,27 +111,30 @@ module Kapusta
         end
 
         def try_emit_native_case(value_var, clauses, env, current_scope, mode)
+          arms = collect_case_arms(clauses) do |pattern, body, where_guards|
+            try_native_arm(pattern, body, where_guards, env, current_scope, mode)
+          end
+          return unless arms
+
+          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(clauses)
+          ["case #{value_var}", *arms, 'end'].join("\n")
+        end
+
+        def collect_case_arms(clauses)
           arms = []
           i = 0
           while i < clauses.length
             pattern = clauses[i]
             body = clauses[i + 1]
-            inner, where_guards = if where_pattern?(pattern)
-                                    [pattern.items[1], pattern.items[2..]]
-                                  else
-                                    [pattern, []]
-                                  end
+            inner, where_guards = extract_pattern_and_guards(pattern)
             sub_patterns = or_pattern?(inner) ? inner.items[1..] : [inner]
-            sub_arms = sub_patterns.map do |sub|
-              try_native_arm(sub, body, where_guards, env, current_scope, mode)
-            end
+            sub_arms = sub_patterns.map { |sub| yield sub, body, where_guards }
             return if sub_arms.any?(&:nil?)
 
             arms.concat(sub_arms)
             i += 2
           end
-          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(clauses)
-          ["case #{value_var}", *arms, 'end'].join("\n")
+          arms
         end
 
         def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
@@ -149,25 +152,11 @@ module Kapusta
         end
 
         def try_emit_compat_case(value_var, clauses, env, current_scope, mode)
-          arms = []
-          i = 0
-          while i < clauses.length
-            pattern = clauses[i]
-            body = clauses[i + 1]
-            inner, where_guards = if where_pattern?(pattern)
-                                    [pattern.items[1], pattern.items[2..]]
-                                  else
-                                    [pattern, []]
-                                  end
-            sub_patterns = or_pattern?(inner) ? inner.items[1..] : [inner]
-            sub_arms = sub_patterns.map do |sub|
-              try_compat_arm(sub, body, where_guards, value_var, env, current_scope, mode)
-            end
-            return if sub_arms.any?(&:nil?)
-
-            arms.concat(sub_arms)
-            i += 2
+          arms = collect_case_arms(clauses) do |pattern, body, where_guards|
+            try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
           end
+          return unless arms
+
           emit_compat_case_lines(arms)
         end
 
@@ -176,6 +165,12 @@ module Kapusta
           last_pattern.is_a?(Sym) && last_pattern.name == '_'
         end
 
+        def extract_pattern_and_guards(pattern)
+          return [pattern, []] unless where_pattern?(pattern)
+
+          [pattern.items[1], pattern.items[2..]]
+        end
+
         def try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
           allow_pins = !where_guards.empty? && mode == :case
           arm_env = env.child
@@ -185,11 +180,11 @@ module Kapusta
           where_guard_codes = where_guards.map { |g| emit_expr(g, arm_env, current_scope) }
           if where_guard_codes.empty?
             guard_codes = plan[:conditions]
-            prelude     = plan[:prelude]
+            prelude = plan[:prelude]
           else
             prelude_guards = plan[:prelude].map { |line| "begin #{line}; true end" }
             guard_codes = plan[:conditions] + prelude_guards + where_guard_codes
-            prelude     = []
+            prelude = []
           end
           body_code = emit_expr(body, arm_env, current_scope)
           [guard_codes, prelude, body_code]

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

@@ -84,6 +84,7 @@ module Kapusta
           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 'defn' then emit_error!(:defn_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

@@ -483,20 +483,28 @@ module Kapusta
           Kapusta.kebab_to_snake(name).gsub(/[^a-zA-Z0-9_]/, '_')
         end
 
+        SIMPLE_EXPRESSION_PATTERNS = [
+          /\A[a-z_]\w*\z/, # local
+          /\A@@?[a-z_]\w*\z/, # @ivar / @@cvar
+          /\A\$[a-zA-Z_]\w*\z/, # $gvar
+          /\A[A-Z]\w*(?:::[A-Z]\w*)*\z/, # Constant / A::B::C
+          /\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/, # bare call foo(...)
+          /\A-?\d+(?:\.\d+)?\z/, # number
+          /\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # local + .m/[k] chain
+          /\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # const + chain
+          /\A:[a-zA-Z_]\w*[!?=]?\z/, # :symbol
+          /\A"(?:[^"\\]|\\.)*"\z/, # "string"
+          /\A'(?:[^'\\]|\\.)*'\z/, # 'string'
+          /\A\[[^\[\]\n]*\]\z/ # [flat, array]
+        ].freeze
+        private_constant :SIMPLE_EXPRESSION_PATTERNS
+
+        SIMPLE_EXPRESSION_KEYWORDS = %w[nil true false self].freeze
+        private_constant :SIMPLE_EXPRESSION_KEYWORDS
+
         def simple_expression?(code)
-          code.match?(/\A[a-z_]\w*\z/) ||
-            code.match?(/\A@@?[a-z_]\w*\z/) ||
-            code.match?(/\A\$[a-zA-Z_]\w*\z/) ||
-            code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/) ||
-            code.match?(/\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/) ||
-            code.match?(/\A-?\d+(?:\.\d+)?\z/) ||
-            code.match?(/\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
-            code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
-            code.match?(/\A:[a-zA-Z_]\w*[!?=]?\z/) ||
-            code.match?(/\A"(?:[^"\\]|\\.)*"\z/) ||
-            code.match?(/\A'(?:[^'\\]|\\.)*'\z/) ||
-            code.match?(/\A\[[^\[\]\n]*\]\z/) ||
-            %w[nil true false self].include?(code) ||
+          SIMPLE_EXPRESSION_PATTERNS.any? { |re| code.match?(re) } ||
+            SIMPLE_EXPRESSION_KEYWORDS.include?(code) ||
             negation_simple?(code)
         end
 

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

@@ -56,20 +56,13 @@ module Kapusta
           parts = []
           deferred = []
           current_env = env
-          items = pattern.items
-          i = 0
-          while i < items.length
-            if items[i].is_a?(Sym) && items[i].name == '&'
-              sub = items[i + 1]
-              raise PatternNotTranslatable unless sub.is_a?(Sym)
-
+          each_pattern_item(pattern.items) do |kind, sub|
+            if kind == :rest
               parts << native_rest_target(sub, current_env)
-              i += 2
             else
-              code, current_env, follow_up = native_destructure_target(items[i], current_env, allow_follow_up: true)
+              code, current_env, follow_up = native_destructure_target(sub, current_env, allow_follow_up: true)
               parts << code
               deferred << follow_up if follow_up
-              i += 1
             end
           end
           if deferred.empty?
@@ -122,17 +115,13 @@ module Kapusta
             inner = []
             current = env
             deferred = []
-            items = pattern.items
-            i = 0
-            while i < items.length
-              if items[i].is_a?(Sym) && items[i].name == '&'
-                inner << native_rest_target(items[i + 1], current)
-                i += 2
+            each_pattern_item(pattern.items) do |kind, sub|
+              if kind == :rest
+                inner << native_rest_target(sub, current)
               else
-                code, current, follow_up = native_destructure_target(items[i], current)
+                code, current, follow_up = native_destructure_target(sub, current)
                 inner << code
                 deferred << follow_up if follow_up
-                i += 1
               end
             end
             raise PatternNotTranslatable unless deferred.empty?
@@ -225,36 +214,26 @@ module Kapusta
           state[:conditions] << "#{value_code}.length >= #{min_length}"
 
           index = 0
-          i = 0
-          while i < items.length
-            if rest_pattern_marker?(items, i)
-              sub = items[i + 1]
+          each_pattern_item(items) do |kind, sub|
+            if kind == :rest
               raise PatternNotTranslatable unless sub.is_a?(Sym)
 
               unless sub.name == '_'
                 ruby = define_local(arm_env, sub.name)
                 state[:prelude] << "#{ruby} = #{value_code}[#{index}..]"
               end
-              i += 2
             else
-              compile_compat_pattern(items[i], "#{value_code}[#{index}]", env, arm_env,
+              compile_compat_pattern(sub, "#{value_code}[#{index}]", env, arm_env,
                                      mode:, allow_pins:, state:)
               index += 1
-              i += 1
             end
           end
         end
 
         def compat_sequence_min_length(items)
           count = 0
-          i = 0
-          while i < items.length
-            if rest_pattern_marker?(items, i)
-              i += 2
-            else
-              count += 1
-              i += 1
-            end
+          each_pattern_item(items) do |kind, _sub|
+            count += 1 if kind == :item
           end
           count
         end
@@ -346,11 +325,9 @@ module Kapusta
         def compile_native_sequence(items, env, mode:, allow_pins:, state:)
           parts = []
           has_rest = false
-          i = 0
-          while i < items.length
-            if rest_pattern_marker?(items, i)
+          each_pattern_item(items) do |kind, sub|
+            if kind == :rest
               has_rest = true
-              sub = items[i + 1]
               raise PatternNotTranslatable unless sub.is_a?(Sym)
 
               if sub.name == '_'
@@ -360,10 +337,8 @@ module Kapusta
                 state[:binding_names] << sub.name
                 parts << "*#{sanitize_local(sub.name)}"
               end
-              i += 2
             else
-              parts << compile_native_pattern(items[i], env, mode:, allow_pins:, state:)
-              i += 1
+              parts << compile_native_pattern(sub, env, mode:, allow_pins:, state:)
             end
           end
           parts << '*' unless has_rest
@@ -464,16 +439,8 @@ module Kapusta
             pattern.name == '_' ? [] : [pattern.name]
           when Vec
             names = []
-            items = pattern.items
-            i = 0
-            while i < items.length
-              if items[i].is_a?(Sym) && items[i].name == '&'
-                names.concat(pattern_names(items[i + 1]))
-                i += 2
-              else
-                names.concat(pattern_names(items[i]))
-                i += 1
-              end
+            each_pattern_item(pattern.items) do |_kind, sub|
+              names.concat(pattern_names(sub))
             end
             names
           when HashLit
@@ -504,8 +471,18 @@ module Kapusta
           name.length > 1 && (name.start_with?('?') || name.start_with?('_'))
         end
 
-        def rest_pattern_marker?(items, index)
-          items[index].is_a?(Sym) && items[index].name == '&'
+        def each_pattern_item(items)
+          i = 0
+          while i < items.length
+            item = items[i]
+            if item.is_a?(Sym) && item.name == '&'
+              yield :rest, items[i + 1]
+              i += 2
+            else
+              yield :item, item
+              i += 1
+            end
+          end
         end
       end
     end

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

@@ -123,29 +123,39 @@ module Kapusta
 
         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
 
@@ -214,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,53 +37,39 @@ 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 '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?
 
           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/errors.rb

@@ -25,6 +25,7 @@ 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)',

data/lib/kapusta/lsp/scope_walker.rb

@@ -17,10 +17,15 @@ module Kapusta
       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
-
       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,
@@ -246,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
@@ -380,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?
@@ -586,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)

data/lib/kapusta/lsp/workspace_index.rb

@@ -35,7 +35,7 @@ module Kapusta
       end
 
       def remove(uri)
-        path = uri_to_path(uri)
+        path = LSP.uri_to_path(uri)
         if path && File.file?(path)
           store(uri, File.read(path))
         else
@@ -178,7 +178,7 @@ module Kapusta
       end
 
       def resolve_module_uris(importing_uri, module_label)
-        importing_path = uri_to_path(importing_uri)
+        importing_path = LSP.uri_to_path(importing_uri)
         return [] unless importing_path
 
         base_dir = File.dirname(importing_path)
@@ -209,17 +209,6 @@ module Kapusta
       def path_to_uri(path)
         "file://#{URI::DEFAULT_PARSER.escape(File.expand_path(path))}"
       end
-
-      def uri_to_path(uri)
-        return unless uri.is_a?(String)
-
-        parsed = URI.parse(uri)
-        return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
-
-        uri
-      rescue URI::InvalidURIError
-        nil
-      end
     end
   end
 end

data/lib/kapusta/lsp.rb

@@ -19,6 +19,17 @@ module Kapusta
       new(input:, output:, log:).run
     end
 
+    def self.uri_to_path(uri)
+      return unless uri.is_a?(String)
+
+      parsed = URI.parse(uri)
+      return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
+
+      uri
+    rescue URI::InvalidURIError
+      nil
+    end
+
     def initialize(input:, output:, log:)
       @input = input.binmode
       @output = output.binmode
@@ -150,8 +161,8 @@ module Kapusta
 
     def on_initialize(params)
       folders = params['workspaceFolders'] || []
-      roots = folders.filter_map { |f| uri_to_path(f['uri']) }
-      roots << uri_to_path(params['rootUri']) if params['rootUri']
+      roots = folders.filter_map { |f| LSP.uri_to_path(f['uri']) }
+      roots << LSP.uri_to_path(params['rootUri']) if params['rootUri']
       roots.compact!
       roots.uniq!
       debug("initialize: roots=#{roots.inspect}")
@@ -213,7 +224,7 @@ module Kapusta
       entry = @sources[uri]
       return [] unless entry
 
-      Formatting.text_edits(entry[:text], uri_to_path(uri))
+      Formatting.text_edits(entry[:text], LSP.uri_to_path(uri))
     end
 
     def definition(params)
@@ -283,23 +294,12 @@ module Kapusta
     end
 
     def publish_diagnostics(uri, text, version)
-      diagnostics = Diagnostics.collect(text, uri_to_path(uri))
+      diagnostics = Diagnostics.collect(text, LSP.uri_to_path(uri))
       params = { uri:, diagnostics: }
       params[:version] = version unless version.nil?
       notify('textDocument/publishDiagnostics', params)
     end
 
-    def uri_to_path(uri)
-      return unless uri
-
-      parsed = URI.parse(uri)
-      return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
-
-      uri
-    rescue URI::InvalidURIError
-      uri
-    end
-
     def log(message)
       @log.puts "kapusta-ls: #{message}"
     end

data/lib/kapusta/support.rb

@@ -4,4 +4,12 @@ module Kapusta
   def self.kebab_to_snake(name)
     name.tr('-', '_')
   end
+
+  def self.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
 end

data/lib/kapusta/version.rb

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

data/spec/examples_errors_spec.rb

@@ -92,6 +92,11 @@ RSpec.describe 'examples-errors' do
       .to eq("destructure-literal-table.kap:4:1: could not destructure literal\n")
   end
 
+  it 'defn-outside-header.kap' do
+    expect(run_error_example('defn-outside-header.kap'))
+      .to eq("defn-outside-header.kap:1:1: defn outside class or module\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")

metadata

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