kapusta 0.3.0 → 0.5.0

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

@@ -7,12 +7,11 @@ module Kapusta
         private
 
         def emit_icollect(args, env, current_scope)
-          result_var = temp('result')
-          iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
-            body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
-            emit_array_collection_step(result_var, body)
+          emit_error!(:icollect_no_iterator) unless args[0].is_a?(Vec) && args[0].items.length >= 2
+
+          emit_iteration(args[0], env, current_scope, method: 'filter_map') do |iter_env|
+            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
           end
-          emit_collection_result(result_var, '[]', iter_code)
         end
 
         def emit_collect(args, env, current_scope)
@@ -35,27 +34,69 @@ module Kapusta
 
         def emit_accumulate(args, env, current_scope)
           bindings = args[0].items
+          emit_error!(:accumulate_no_iterator) if bindings.length < 4
+
           acc_name = bindings[0]
-          iter_bindings = Vec.new(bindings[2..])
-          loop_env = env.child
-          acc_var = define_local(loop_env, acc_name.name)
-          iter_code = emit_iteration(iter_bindings, loop_env, current_scope) do |iter_env|
-            iter_env.define(acc_name.name, acc_var)
-            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first.then do |body|
-              emit_sequence_value_assignment(acc_var, body)
-            end
+          init_code = emit_expr(bindings[1], env, current_scope)
+          iter_items = bindings[2..]
+          iter_expr = iter_items.last
+          binding_pats = iter_items[0...-1]
+
+          body_env = env.child
+          acc_var = define_local(body_env, acc_name.name)
+
+          inject_code = try_emit_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                        init_code, args[1..])
+          return inject_code if inject_code
+
+          iter_code = emit_iteration(Vec.new(iter_items), body_env, current_scope) do |iter_env|
+            body_code, = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false)
+            emit_sequence_value_assignment(acc_var, body_code)
           end
           [
             '(-> do',
-            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
+            indent("#{acc_var} = #{init_code}"),
             indent(iter_code),
             indent(acc_var),
             'end).call'
           ].join("\n")
         end
 
+        def try_emit_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var, init_code, body_forms)
+          return unless iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
+
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          case iter_expr.head.name
+          when 'ipairs'
+            value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+            if ignored_pattern?(binding_pats[0])
+              body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+              return inject_block(coll_code, "#{acc_var}, #{value_var}", init_code, value_bind || '', body_code)
+            end
+            index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
+            bind_code = [index_bind, value_bind].compact.join("\n")
+            body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+            inject_block("#{coll_code}.each_with_index", "#{acc_var}, (#{value_var}, #{index_var})",
+                         init_code, bind_code, body_code)
+          when 'pairs'
+            key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
+            value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+            bind_code = [key_bind, value_bind].compact.join("\n")
+            body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+            inject_block(coll_code, "#{acc_var}, (#{key_var}, #{value_var})",
+                         init_code, bind_code, body_code)
+          end
+        end
+
+        def inject_block(receiver, params, init_code, bind_code, body_code)
+          inner = join_code(bind_code, body_code)
+          ["#{receiver}.inject(#{init_code}) do |#{params}|", indent(inner), 'end'].join("\n")
+        end
+
         def emit_faccumulate(args, env, current_scope)
           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
@@ -112,7 +153,9 @@ module Kapusta
           end
         end
 
-        def emit_iteration(bindings_vec, env, current_scope)
+        def emit_iteration(bindings_vec, env, current_scope, method: 'each')
+          emit_error!(:each_no_binding) unless bindings_vec.is_a?(Vec)
+
           items = bindings_vec.items
           iter_expr = items.last
           binding_pats = items[0...-1]
@@ -126,12 +169,13 @@ module Kapusta
               if ignored_pattern?(binding_pats[0])
                 bind_code = value_bind || ''
                 body_code = yield(body_env)
-                return iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
+                return iteration_block("#{coll_code}.#{method} do |#{value_var}|", bind_code, body_code)
               end
               index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
               bind_code = [index_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
-              header = "#{coll_code}.each_with_index do |#{value_var}, #{index_var}|"
+              receiver = method == 'each' ? "#{coll_code}.each_with_index" : "#{coll_code}.each_with_index.#{method}"
+              header = "#{receiver} do |#{value_var}, #{index_var}|"
               return iteration_block(header, bind_code, body_code)
             when 'pairs'
               body_env = env.child
@@ -139,7 +183,7 @@ module Kapusta
               value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
               bind_code = [key_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
-              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|"
+              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.#{method} do |#{key_var}, #{value_var}|"
               return iteration_block(header, bind_code, body_code)
             end
           end
@@ -149,14 +193,14 @@ module Kapusta
             body_env = env.child
             value_var, bind_code = bind_iteration_param(binding_pats[0], 'value', body_env)
             body_code = yield(body_env)
-            iteration_block("#{coll_code}.each do |#{value_var}|", bind_code || '', body_code)
+            iteration_block("#{coll_code}.#{method} do |#{value_var}|", bind_code || '', body_code)
           else
             parts_var = temp('parts')
             body_env = env.child
             pairs = binding_pats.each_with_index.map { |pattern, i| [pattern, "#{parts_var}[#{i}]"] }
             bind_code, body_env = emit_iteration_bindings(pairs, body_env)
             body_code = yield(body_env)
-            iteration_block("#{coll_code}.each do |*#{parts_var}|", bind_code, body_code)
+            iteration_block("#{coll_code}.#{method} do |*#{parts_var}|", bind_code, body_code)
           end
         end
 

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

@@ -11,8 +11,7 @@ module Kapusta
         end
 
         def build_if(args, env, current_scope)
-          return 'nil' if args.empty?
-          return emit_expr(args[0], env, current_scope) if args.length == 1
+          emit_error!(:if_no_body) if args.length < 2
 
           cond = emit_expr(args[0], env, current_scope)
           truthy = emit_if_branch(args[1], env, current_scope)
@@ -58,9 +57,13 @@ module Kapusta
         end
 
         def emit_case(args, env, current_scope, mode)
+          clauses = args[1..]
+          emit_error!(:case_no_patterns) if clauses.empty?
+          emit_error!(:case_odd_patterns) if clauses.length.odd?
+
           value_var = temp('case_value')
-          body = try_emit_native_case(value_var, args[1..], env, current_scope, mode)
-          emit_error!('case/match clauses use patterns this compiler cannot translate') unless body
+          body = try_emit_native_case(value_var, clauses, env, current_scope, mode)
+          emit_error!(:case_unsupported) unless body
           [
             '(-> do',
             indent("#{value_var} = #{emit_expr(args[0], env, current_scope)}"),

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

@@ -7,17 +7,19 @@ module Kapusta
         private
 
         def emit_expr(form, env, current_scope)
-          case form
-          when Sym then emit_sym(form, env)
-          when Vec then "[#{form.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
-          when HashLit
-            "{#{form.pairs.map do |key, value|
-              "#{emit_hash_key(key, env, current_scope)} => #{emit_expr(value, env, current_scope)}"
-            end.join(', ')}}"
-          when List then emit_list(form, env, current_scope)
-          when String, Symbol, Numeric, true, false, nil then form.inspect
-          else
-            emit_error!("cannot emit form: #{form.inspect}")
+          with_current_form(form) do
+            case form
+            when Sym then emit_sym(form, env)
+            when Vec then "[#{form.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
+            when HashLit
+              "{#{form.pairs.map do |key, value|
+                "#{emit_hash_key(key, env, current_scope)} => #{emit_expr(value, env, current_scope)}"
+              end.join(', ')}}"
+            when List then emit_list(form, env, current_scope)
+            when String, Symbol, Numeric, true, false, nil then form.inspect
+            else
+              emit_error!(:cannot_emit_form, form: form.inspect)
+            end
           end
         end
 
@@ -29,7 +31,7 @@ module Kapusta
         end
 
         def emit_list(list, env, current_scope)
-          return 'nil' if list.empty?
+          emit_error!(:empty_call) if list.empty?
 
           head = list.head
           args = list.rest
@@ -43,6 +45,11 @@ module Kapusta
             return emit_self_call(head.name, args, env, current_scope)
           end
 
+          case head
+          when Numeric, String, Symbol, true, false, nil
+            emit_error!(:cannot_call_literal, value: head.inspect)
+          end
+
           emit_callable_call(emit_expr(head, env, current_scope), args, env, current_scope)
         end
 
@@ -51,6 +58,7 @@ module Kapusta
           when 'fn', 'lambda', 'λ' then emit_fn(args, env, current_scope)
           when 'let' then emit_let(args, env, current_scope)
           when 'local', 'var' then emit_local_expr(args, env, current_scope)
+          when 'global' then emit_global_expr(args, env, current_scope)
           when 'set' then emit_set_expr(args, env, current_scope)
           when 'if' then emit_if(args, env, current_scope)
           when 'case' then emit_case(args, env, current_scope, :case)
@@ -96,14 +104,51 @@ module Kapusta
           when '/' then emit_div(args, env, current_scope)
           when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
           when 'print' then emit_print(args, env, current_scope)
+          when 'quasi-sym' then "Kapusta::MacroSym.new(#{emit_expr(args[0], env, current_scope)})"
+          when 'quasi-list' then "Kapusta::List.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
+          when 'quasi-list-tail' then emit_quasi_list_tail(args, env, current_scope)
+          when 'quasi-vec' then "Kapusta::Vec.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
+          when 'quasi-vec-tail' then emit_quasi_vec_tail(args, env, current_scope)
+          when 'quasi-hash' then emit_quasi_hash(args, env, current_scope)
+          when 'quasi-gensym' then emit_quasi_gensym(args[0], env, current_scope)
+          when 'macro', 'macros', 'import-macros'
+            emit_error!(:special_must_be_toplevel, name:)
           else
-            emit_error!("unknown special form: #{name}")
+            emit_error!(:unknown_special_form, name:)
+          end
+        end
+
+        def emit_quasi_list_tail(args, env, current_scope)
+          head_items = args[0]
+          tail_expr = emit_expr(args[1], env, current_scope)
+          head_code = head_items.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')
+          "Kapusta::List.new([#{head_code}, *#{parenthesize(tail_expr)}])"
+        end
+
+        def emit_quasi_vec_tail(args, env, current_scope)
+          head_items = args[0]
+          tail_expr = emit_expr(args[1], env, current_scope)
+          head_code = head_items.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')
+          "Kapusta::Vec.new([#{head_code}, *#{parenthesize(tail_expr)}])"
+        end
+
+        def emit_quasi_gensym(arg, env, current_scope)
+          "Kapusta::Compiler::MacroExpander.fresh_gensym(#{emit_expr(arg, env, current_scope)})"
+        end
+
+        def emit_quasi_hash(args, env, current_scope)
+          pairs = args.each_slice(2).map do |key, value|
+            "[#{emit_expr(key, env, current_scope)}, #{emit_expr(value, env, current_scope)}]"
           end
+          "Kapusta::HashLit.new([#{pairs.join(', ')}])"
         end
 
         def emit_concat(args, env, current_scope)
           return '""' if args.empty?
 
+          args.each do |arg|
+            emit_error!(:vararg_with_operator) if arg.is_a?(Sym) && arg.name == '...'
+          end
           args.map { |arg| emit_string_part(arg, env, current_scope) }.join(' + ')
         end
 

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

@@ -7,6 +7,8 @@ module Kapusta
         private
 
         def emit_lookup(args, env, current_scope)
+          emit_error!(:dot_no_args) if args.empty?
+
           object_code = emit_expr(args[0], env, current_scope)
           keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }
           return object_code if keys.empty?
@@ -91,7 +93,7 @@ module Kapusta
 
         def emit_module_wrapper(name_sym, body)
           segments = constant_segments(name_sym)
-          emit_error!("invalid module name: #{name_sym.name}") unless segments
+          emit_error!(:invalid_module_name, name: name_sym.name) unless segments
           inner = build_nested_module(segments, body)
           ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
         end
@@ -105,7 +107,7 @@ module Kapusta
 
         def emit_class_wrapper(name_sym, supers, env, body)
           segments = constant_segments(name_sym)
-          emit_error!("invalid class name: #{name_sym.name}") unless segments
+          emit_error!(:invalid_class_name, name: name_sym.name) unless segments
           super_code = class_super_code(supers, env)
           inner = build_nested_class(segments, super_code, body)
           ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
@@ -434,7 +436,7 @@ module Kapusta
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)
 
-          emit_error!("undefined symbol: #{name}")
+          emit_error!(:undefined_symbol, name:)
         end
 
         def emit_gvar(sym)
@@ -458,7 +460,7 @@ module Kapusta
               const_path << segments[idx]
               idx += 1
             end
-            emit_error!("bad multisym: #{segments.join('.')}") if const_path.empty?
+            emit_error!(:bad_multisym, path: segments.join('.')) if const_path.empty?
 
             [const_path.join('::'), segments[idx..]]
           end

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

@@ -10,6 +10,7 @@ module Kapusta
           if pattern.is_a?(Sym)
             return ['', env] if pattern.name == '_'
 
+            validate_binding_symbol!(pattern)
             ruby_name = define_local(env, pattern)
             return ["#{ruby_name} = #{value_code}", env]
           end
@@ -17,7 +18,26 @@ module Kapusta
           native = try_emit_native_pattern_bind(pattern, value_code, env)
           return native if native
 
-          emit_error!("destructure pattern this compiler cannot translate: #{pattern.inspect}")
+          emit_error!(:destructure_unsupported, pattern: pattern.inspect)
+        end
+
+        def validate_binding_symbol!(sym)
+          name = sym.name
+          emit_error!(:shadowed_special, name:) if Compiler::SPECIAL_FORMS.include?(name)
+          return unless sym.is_a?(MacroSym)
+
+          emit_error!(:macro_unsafe_bind, name:)
+        end
+
+        def validate_destructure_pattern!(pattern)
+          items = pattern.items
+          items.each_with_index do |item, idx|
+            emit_error!(:bind_table_dots) if item.is_a?(Sym) && item.name == '...'
+            next unless item.is_a?(Sym) && item.name == '&'
+
+            emit_error!(:rest_not_last) if idx + 2 < items.length
+            emit_error!(:rest_not_last) if idx + 1 >= items.length
+          end
         end
 
         def try_emit_native_pattern_bind(pattern, value_code, env)
@@ -32,6 +52,7 @@ module Kapusta
         end
 
         def try_emit_native_vec_bind(pattern, value_code, env)
+          validate_destructure_pattern!(pattern)
           parts = []
           deferred = []
           current_env = env
@@ -79,8 +100,7 @@ module Kapusta
             if sub.is_a?(Sym)
               raise PatternNotTranslatable if sub.name == '_'
 
-              bind_name = sub.name.start_with?('?') ? sub.name.delete_prefix('?') : sub.name
-              ruby_name = define_local(current_env, bind_name)
+              ruby_name = define_local(current_env, sub.name)
               lines << "#{ruby_name} = #{access}"
             else
               sub_code, current_env = try_emit_native_pattern_bind(sub, access, current_env) ||
@@ -96,8 +116,7 @@ module Kapusta
           when Sym
             return ['_', env, nil] if pattern.name == '_'
 
-            bind_name = pattern.name.start_with?('?') ? pattern.name.delete_prefix('?') : pattern.name
-            ruby_name = define_local(env, bind_name)
+            ruby_name = define_local(env, pattern.name)
             [ruby_name, env, nil]
           when Vec
             inner = []
@@ -137,8 +156,7 @@ module Kapusta
 
           return '*' if sym.name == '_'
 
-          bind_name = sym.name.start_with?('?') ? sym.name.delete_prefix('?') : sym.name
-          "*#{define_local(env, bind_name)}"
+          "*#{define_local(env, sym.name)}"
         end
 
         class PatternNotTranslatable < StandardError; end
@@ -179,12 +197,11 @@ module Kapusta
           return '_' if name == '_'
 
           if nil_allowing_pattern_name?(name)
-            bind_name = name.start_with?('?') ? name.delete_prefix('?') : name
-            raise PatternNotTranslatable if state[:bound_names].key?(bind_name)
+            raise PatternNotTranslatable if state[:bound_names].key?(name)
 
-            state[:bound_names][bind_name] = true
-            state[:binding_names] << bind_name
-            sanitize_local(bind_name)
+            state[:bound_names][name] = true
+            state[:binding_names] << name
+            sanitize_local(name)
           else
             binding = mode == :match ? env.lookup_if_defined(name) : nil
             if state[:bound_names].key?(name)

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

@@ -6,8 +6,27 @@ module Kapusta
       module Support
         private
 
-        def emit_error!(message)
-          raise Error, "#{@path}: #{message}"
+        def emit_error!(code, **args)
+          form = current_form
+          line = form.respond_to?(:line) ? form.line : nil
+          column = form.respond_to?(:column) ? form.column : nil
+          raise Error.new(Kapusta::Errors.format(code, **args), path: @path, line:, column:)
+        end
+
+        def with_current_form(form)
+          @form_stack ||= []
+          @form_stack.push(form) if positionable?(form)
+          yield
+        ensure
+          @form_stack.pop if positionable?(form)
+        end
+
+        def current_form
+          (@form_stack ||= []).last
+        end
+
+        def positionable?(form)
+          form.respond_to?(:line) && form.respond_to?(:column)
         end
 
         def emit_forms_with_headers(forms, env, current_scope, result: true)
@@ -67,27 +86,29 @@ module Kapusta
         end
 
         def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:, result_needed: true)
-          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
+          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
 
-          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)
-            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]
+            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)
+              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
         end
 
@@ -228,6 +249,7 @@ module Kapusta
         end
 
         def parse_counted_for_bindings(bindings, env, current_scope)
+          emit_error!(:counted_no_range) if bindings.length < 3
           name_sym = bindings[0]
           loop_env = env.child
           ruby_name = define_local(loop_env, name_sym.name)
@@ -263,7 +285,8 @@ module Kapusta
 
         def sanitize_local(name)
           base = Kapusta.kebab_to_snake(name.respond_to?(:name) ? name.name : name)
-          base = base.gsub('?', '_q').gsub('!', '_bang')
+          base = base.sub(/\A\?/, 'q_').gsub('?', '_q')
+          base = base.sub(/\A!/, 'bang_').gsub('!', '_bang')
           base = base.gsub(/[^a-zA-Z0-9_]/, '_')
           if base.empty? || base.match?(/\A\d/) || base.match?(/\A[A-Z]/) || self.class::RUBY_KEYWORDS.include?(base)
             base = "_#{base}"