kapusta 0.4.1 → 0.7.0

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

@@ -4,24 +4,58 @@ module Kapusta
   module Compiler
     module EmitterModules
       module Collections
+        include LuaCompat::Emission
+
         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)
           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_hash_collection_step(result_var, body)
+          values_form = simple_values_call(args[1]) if args.length == 2
+          emit_iteration(args[0], env, current_scope,
+                         method: 'each_with_object({})', extra_block_param: result_var) do |iter_env|
+            if values_form
+              emit_collect_values_step(result_var, values_form, iter_env, current_scope)
+            else
+              body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
+              emit_hash_collection_step(result_var, body)
+            end
+          end
+        end
+
+        def simple_values_call(form)
+          return unless form.is_a?(List) && form.items.length == 3
+
+          head = form.head
+          form if head.is_a?(Sym) && head.name == 'values'
+        end
+
+        def emit_collect_values_step(result_var, values_form, iter_env, current_scope)
+          key_form = values_form.items[1]
+          val_form = values_form.items[2]
+          key_code = emit_expr(key_form, iter_env, current_scope)
+          val_code = emit_expr(val_form, iter_env, current_scope)
+          assignment = "#{result_var}[#{key_code}] = #{val_code}"
+          guards = []
+          guards << "#{key_code}.nil?" unless definitely_non_nil?(key_form)
+          guards << "#{val_code}.nil?" unless definitely_non_nil?(val_form)
+          return assignment if guards.empty?
+
+          "#{assignment} unless #{guards.join(' || ')}"
+        end
+
+        def definitely_non_nil?(form)
+          case form
+          when Numeric, String, ::Symbol, TrueClass, FalseClass then true
+          else false
           end
-          emit_collection_result(result_var, '{}', iter_code)
         end
 
         def emit_fcollect(args, env, current_scope)
@@ -35,27 +69,48 @@ 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)
+          emit_lua_compat_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                 init_code, body_forms)
+        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,51 +167,32 @@ module Kapusta
           end
         end
 
-        def emit_iteration(bindings_vec, env, current_scope)
+        def emit_iteration(bindings_vec, env, current_scope, method: 'each', extra_block_param: nil, &block)
+          emit_error!(:each_no_binding) unless bindings_vec.is_a?(Vec)
+
           items = bindings_vec.items
           iter_expr = items.last
           binding_pats = items[0...-1]
 
-          if iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
-            case iter_expr.head.name
-            when 'ipairs'
-              body_env = env.child
-              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
-              coll_code = emit_expr(iter_expr.items[1], env, current_scope)
-              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)
-              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}|"
-              return iteration_block(header, bind_code, body_code)
-            when 'pairs'
-              body_env = env.child
-              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 = yield(body_env)
-              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|"
-              return iteration_block(header, bind_code, body_code)
-            end
-          end
+          lua_iteration = emit_lua_compat_iteration(iter_expr, binding_pats, env, current_scope,
+                                                    method:, extra_block_param:, &block)
+          return lua_iteration if lua_iteration
 
           coll_code = emit_expr(iter_expr, env, current_scope)
           if binding_pats.length == 1
             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)
+            body_code = block.call(body_env)
+            params = extra_block_param ? "#{value_var}, #{extra_block_param}" : value_var
+            iteration_block("#{coll_code}.#{method} do |#{params}|", 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)
+            body_code = block.call(body_env)
+            params = extra_block_param ? "#{parts_var}, #{extra_block_param}" : "*#{parts_var}"
+            iteration_block("#{coll_code}.#{method} do |#{params}|", 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,17 +57,38 @@ module Kapusta
         end
 
         def emit_case(args, env, current_scope, mode)
+          emit_error!(:case_no_subject) if args.empty?
+
+          clauses = args[1..]
+          emit_error!(:case_no_patterns) if clauses.empty?
+          emit_error!(:case_odd_patterns) if clauses.length.odd?
+
+          value_code = emit_expr(args[0], env, current_scope)
+          if simple_case_subject?(args[0]) && simple_expression?(value_code)
+            body = try_emit_native_case(value_code, clauses, env, current_scope, mode)
+            emit_error!(:case_unsupported) unless body
+            return body
+          end
+
           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)}"),
+            indent("#{value_var} = #{value_code}"),
             indent(body),
             'end).call'
           ].join("\n")
         end
 
+        def simple_case_subject?(form)
+          case form
+          when Sym then !form.dotted?
+          when Numeric, String, Symbol, true, false, nil then true
+          else false
+          end
+        end
+
         def try_emit_native_case(value_var, clauses, env, current_scope, mode)
           arms = []
           i = 0
@@ -89,10 +109,15 @@ module Kapusta
             arms.concat(sub_arms)
             i += 2
           end
-          arms << ['else', indent('nil')].join("\n")
+          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(clauses)
           ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
+        def wildcard_last?(clauses)
+          last_pattern = clauses[-2]
+          last_pattern.is_a?(Sym) && last_pattern.name == '_'
+        end
+
         def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
           allow_pins = !where_guards.empty? && mode == :case
           plan = native_pattern_plan(pattern, env, mode:, allow_pins:)

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,17 +104,15 @@ 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::Sym.new(#{emit_expr(args[0], 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!("#{name} must appear at the top level and is consumed by the macro expander")
           else
-            emit_error!("unknown special form: #{name}")
+            emit_error!(:unknown_special_form, name:)
           end
         end
 
@@ -138,6 +144,9 @@ module Kapusta
         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")
@@ -425,16 +427,17 @@ module Kapusta
         def emit_sym(sym, env)
           name = sym.name
           return 'self' if name == 'self'
-          return 'Float::INFINITY' if name == 'math.huge'
 
           if (binding = env.lookup_if_defined(sym))
             return binding_value_code(binding)
           end
+
+          emit_error!(:unexpected_vararg) if name == '...'
           return emit_multisym_value(sym, env) if sym.dotted?
           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 +461,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
@@ -225,12 +246,60 @@ module Kapusta
         end
 
         def compile_native_hash(pattern, env, mode:, allow_pins:, state:)
-          pairs = pattern.pairs.map do |key, value|
-            raise PatternNotTranslatable unless key.is_a?(Symbol)
-
+          sym_pairs, other_pairs = pattern.pairs.partition { |key, _| key.is_a?(Symbol) }
+          sym_parts = sym_pairs.map do |key, value|
             "#{key}: #{compile_native_pattern(value, env, mode:, allow_pins:, state:)}"
           end
-          "{#{pairs.join(', ')}}"
+          return "{#{sym_parts.join(', ')}}" if other_pairs.empty?
+
+          capture = temp('hash')
+          sym_pattern = sym_parts.empty? ? 'Hash' : "{#{sym_parts.join(', ')}}"
+          other_pairs.each do |key, value|
+            compile_native_hash_value(value, capture, compile_native_hash_key(key), env, mode:, state:)
+          end
+          "#{sym_pattern} => #{capture}"
+        end
+
+        def compile_native_hash_key(key)
+          case key
+          when Symbol, String, Numeric, true, false then key.inspect
+          when nil then 'nil'
+          else raise PatternNotTranslatable
+          end
+        end
+
+        def compile_native_hash_value(value, capture, key_code, env, mode:, state:)
+          lookup = "#{capture}[#{key_code}]"
+          case value
+          when Sym
+            name = value.name
+            return if name == '_'
+
+            if nil_allowing_pattern_name?(name)
+              raise PatternNotTranslatable if state[:bound_names].key?(name)
+
+              state[:bound_names][name] = true
+              state[:binding_names] << name
+              state[:guards] << "(#{sanitize_local(name)} = #{lookup}; true)"
+            else
+              binding = mode == :match ? env.lookup_if_defined(name) : nil
+              if state[:bound_names].key?(name)
+                raise PatternNotTranslatable
+              elsif binding
+                state[:guards] << "#{lookup} == #{binding_value_code(binding)}"
+              else
+                state[:bound_names][name] = true
+                state[:binding_names] << name
+                state[:guards] << "!(#{sanitize_local(name)} = #{lookup}).nil?"
+              end
+            end
+          when nil
+            state[:guards] << "#{lookup}.nil?"
+          when Symbol, String, Numeric, true, false
+            state[:guards] << "#{lookup} == #{value.inspect}"
+          else
+            raise PatternNotTranslatable
+          end
         end
 
         def compile_native_pin(pattern, env, mode:, allow_pins:)

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
 
@@ -107,7 +128,7 @@ module Kapusta
             code, current_env = emit_form_in_sequence(form, current_env, current_scope,
                                                       allow_method_definitions:,
                                                       result_needed: result && index == forms.length - 1)
-            codes << code
+            codes << code unless code.empty?
           end
           [codes.join("\n"), current_env]
         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)

data/lib/kapusta/compiler/emitter.rb

@@ -31,7 +31,7 @@ module Kapusta
 
       def emit_file(forms)
         env = Env.new
-        body = emit_forms_with_headers(forms, env, :toplevel)
+        body = emit_forms_with_headers(forms, env, :toplevel, result: false)
         "#{body}\n"
       end
     end