kapusta 0.13.2 → 0.14.0

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

@@ -7,24 +7,19 @@ module Kapusta
         private
 
         def emit_fn(args, env, current_scope)
-          if args[0].is_a?(Vec)
-            emit_lambda(args[0], args[1..], env, current_scope)
-          else
-            name_sym = args[0]
-            pattern = args[1]
-            body = args[2..]
-            emit_error!(:fn_no_params) unless name_sym.is_a?(Sym) && pattern.is_a?(Vec)
-
-            fn_env = env.child
-            ruby_name = define_local(fn_env, name_sym.name)
-            <<~RUBY.chomp
-              lambda do
-                #{ruby_name} = nil
-                #{ruby_name} = #{emit_lambda(pattern, body, fn_env, current_scope)}
-                #{ruby_name}
-              end.call
-            RUBY
-          end
+          parsed = Language.parse_function_args(args)
+          emit_error!(:fn_no_params) unless parsed
+          return emit_lambda(parsed.params, parsed.body, env, current_scope) if parsed.anonymous?
+
+          fn_env = env.child
+          ruby_name = define_local(fn_env, parsed.name.name)
+          <<~RUBY.chomp
+            lambda do
+              #{ruby_name} = nil
+              #{ruby_name} = #{emit_lambda(parsed.params, parsed.body, fn_env, current_scope)}
+              #{ruby_name}
+            end.call
+          RUBY
         end
 
         def emit_lambda(pattern, body, env, current_scope)
@@ -89,19 +84,21 @@ module Kapusta
         end
 
         def register_self_method_binding(form, env)
-          name_sym = form.items[1]
+          name_sym = Language.parse_function_form(form)&.name
           return unless name_sym.is_a?(Sym) && !name_sym.dotted?
 
           ruby_name = Kapusta.kebab_to_snake(name_sym.name)
           return unless direct_method_name?(ruby_name)
 
-          env.define(name_sym.name, Env::SelfMethodBinding.new(ruby_name))
+          parsed = Language.parse_function_form(form)
+          env.define(name_sym.name, Env::SelfMethodBinding.new(ruby_name, multi_return_body?(parsed.body)))
         end
 
         def emit_toplevel_method_definition(form, env)
-          name_sym = form.items[1]
-          pattern = form.items[2]
-          body = form.items[3..]
+          parsed = Language.parse_function_form(form)
+          name_sym = parsed.name
+          pattern = parsed.params
+          body = parsed.body
           return [nil, env] if name_sym.dotted?
           return [nil, env] unless simple_parameter_pattern?(pattern)
 
@@ -109,27 +106,30 @@ module Kapusta
           return [nil, env] unless ruby_name
           return [nil, env] if captures_outer_binding?(body, env, pattern_names(pattern))
 
-          env.define(name_sym.name, Env::MethodBinding.new(ruby_name))
+          env.define(name_sym.name, Env::MethodBinding.new(ruby_name, multi_return_body?(body)))
           definition = emit_direct_method_definition(name_sym, pattern, body, env)
-          if needs_toplevel_method_bridge?(ruby_name)
-            definition = join_code(definition, emit_toplevel_method_bridge(ruby_name))
-          end
           [definition, env]
         end
 
+        def multi_return_body?(body)
+          Language.list_head?(body.last, 'values')
+        end
+
         def emit_named_fn_assignment(form, env, current_scope)
-          name_sym = form.items[1]
+          parsed = Language.parse_function_form(form)
+          name_sym = parsed.name
           ruby_name = define_local(env, name_sym.name)
           fn_env = env.child
           fn_env.define(name_sym.name, ruby_name)
-          lambda_code = emit_lambda(form.items[2], form.items[3..], fn_env, current_scope)
+          lambda_code = emit_lambda(parsed.params, parsed.body, fn_env, current_scope)
           ["#{ruby_name} = nil\n#{ruby_name} = #{lambda_code}", env]
         end
 
         def emit_method_definition(form, env)
-          name_sym = form.items[1]
-          pattern = form.items[2]
-          body = form.items[3..]
+          parsed = Language.parse_function_form(form)
+          name_sym = parsed.name
+          pattern = parsed.params
+          body = parsed.body
           direct_definition = emit_direct_method_definition(name_sym, pattern, body, env)
           return direct_definition if direct_definition
 
@@ -184,23 +184,6 @@ module Kapusta
           end
         end
 
-        def needs_toplevel_method_bridge?(ruby_name)
-          %w[context describe example it specify].include?(ruby_name)
-        end
-
-        def emit_toplevel_method_bridge(ruby_name)
-          method_name = ruby_name.to_sym.inspect
-          if mruby3_target?
-            return [
-              "define_singleton_method(#{method_name}) do |*args|",
-              indent("Object.instance_method(#{method_name}).bind(self).call(*args)"),
-              'end'
-            ].join("\n")
-          end
-
-          "define_singleton_method(#{method_name}, Object.instance_method(#{method_name}).bind(self))"
-        end
-
         def emit_method_body(pattern, body, env)
           validate_fn_params!(pattern)
           return emit_simple_method_body(pattern, body, env) if simple_parameter_pattern?(pattern)
@@ -271,26 +254,29 @@ module Kapusta
         end
 
         def emit_let_parts(args, env, current_scope, result:)
-          bindings = args[0]
+          parsed = Language.parse_let_args(args)
+          bindings = parsed.bindings
           emit_error!(:let_odd_bindings) if bindings.items.length.odd?
           emit_error!(:let_no_body) if args.length < 2
 
-          body = args[1..]
           child_env = env.child
           binding_codes = []
-          items = bindings.items
-          i = 0
-          while i < items.length
-            pattern = items[i]
-            value_form = items[i + 1]
+          parsed.binding_pairs.each do |pattern, value_form|
             check_destructure_value!(pattern, value_form)
+            if (constant_code = kapusta_require_module_constant(value_form)) && pattern.is_a?(Sym)
+              require_code = emit_expr(value_form, child_env, current_scope)
+              bind_code, child_env = emit_constant_require_bind(pattern, require_code, constant_code, child_env)
+              mark_mutability(child_env, pattern.name, mutable: false)
+              binding_codes << bind_code
+              next
+            end
+
             value_code = emit_expr(value_form, child_env, current_scope)
             bind_code, child_env = emit_pattern_bind(pattern, value_code, child_env)
             walk_pattern_syms(pattern) { |sym| mark_mutability(child_env, sym, mutable: false) }
             binding_codes << bind_code
-            i += 2
           end
-          body_code, = emit_sequence(body, child_env, current_scope,
+          body_code, = emit_sequence(parsed.body, child_env, current_scope,
                                      allow_method_definitions: false,
                                      result:)
           [join_binding_codes(binding_codes), body_code]
@@ -317,15 +303,24 @@ module Kapusta
         end
 
         def emit_local_form(form, env, current_scope, allow_constant: false)
-          emit_error!(:local_arity, form: form.head.name) unless form.items.length == 3
+          parsed = Language.parse_binding_form(form)
+          emit_error!(:local_arity, form: form.head.name) unless parsed
 
-          target = form.items[1]
-          value_code = emit_expr(form.items[2], env, current_scope)
+          target = parsed.target
+          value_form = parsed.value
 
           if target.is_a?(Sym)
             validate_binding_symbol!(target)
-            if allow_constant && form.head.name == 'local' &&
-               constant_value?(form.items[2]) &&
+            if parsed.head == 'local' && (constant_code = kapusta_require_module_constant(value_form))
+              require_code = emit_expr(value_form, env, current_scope)
+              bind_code, env = emit_constant_require_bind(target, require_code, constant_code, env)
+              mark_mutability(env, target.name, mutable: false)
+              return ["#{bind_code}\nnil", env]
+            end
+
+            value_code = emit_expr(value_form, env, current_scope)
+            if allow_constant && parsed.head == 'local' &&
+               constant_value?(value_form) &&
                (constant_name = constant_name_for(target.name))
               env.define(target.name, constant_name)
               mark_mutability(env, target.name, mutable: false)
@@ -333,14 +328,23 @@ module Kapusta
             end
 
             ruby_name = define_local(env, target.name)
-            mark_mutability(env, target.name, mutable: form.head.name == 'var')
+            mark_mutability(env, target.name, mutable: parsed.mutable?)
             ["#{ruby_name} = #{value_code}\nnil", env]
           else
+            value_code = emit_expr(value_form, env, current_scope)
             bind_code, env = emit_pattern_bind(target, value_code, env)
             [join_code(bind_code, 'nil'), env]
           end
         end
 
+        def emit_constant_require_bind(target, require_code, constant_code, env)
+          validate_binding_symbol!(target)
+          return [require_code, env] if target.name == '_'
+
+          ruby_name = define_local(env, target.name)
+          ["#{require_code}\n#{ruby_name} = #{constant_code}", env]
+        end
+
         def constant_name_for(source_name)
           candidate = source_name.tr('-', '_').upcase
           candidate if candidate.match?(/\A[A-Z][A-Z0-9_]*\z/)
@@ -354,7 +358,7 @@ module Kapusta
         end
 
         def check_destructure_value!(pattern, value_form)
-          return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
+          return unless pattern.is_a?(Vec) || pattern.is_a?(List) || pattern.is_a?(HashLit)
 
           case value_form
           when String, Numeric, Symbol, true, false
@@ -372,7 +376,7 @@ module Kapusta
           case pattern
           when Sym
             yield pattern unless pattern.name == '_'
-          when Vec
+          when Vec, List
             pattern.items.each do |item|
               next if item.is_a?(Sym) && ['&', '...'].include?(item.name)
 
@@ -390,24 +394,29 @@ module Kapusta
           (@binding_mutability ||= {}).fetch(ruby_name, true)
         end
 
-        def emit_local_expr(args, env, current_scope)
-          code, = emit_local_form(List.new([Sym.new('local'), *args]), env.child, current_scope)
+        def emit_local_expr(head, args, env, current_scope)
+          parsed = Language.parse_binding_args(head, args)
+          emit_error!(:local_arity, form: head) unless parsed
+
+          synthetic = List.new([Sym.new(head), parsed.target, parsed.value])
+          code, = emit_local_form(synthetic, env.child, current_scope)
           "lambda do\n#{indent(code)}\nend.call"
         end
 
         def emit_global_expr(args, _env, _current_scope)
-          emit_error!(:global_arity) unless args.length == 2
-          unless args[0].is_a?(Sym)
-            emit_error!(:global_non_symbol_name, type: args[0].class.name.downcase, value: args[0].inspect)
+          parsed = Language.parse_global_args(args)
+          emit_error!(:global_arity) unless parsed
+          unless parsed.name.is_a?(Sym)
+            emit_error!(:global_non_symbol_name, type: parsed.name.class.name.downcase, value: parsed.name.inspect)
           end
 
-          name = args[0].name
-          "$#{global_name(name)} = #{emit_expr(args[1], Env.new, :toplevel)}\nnil"
+          "$#{global_name(parsed.name.name)} = #{emit_expr(parsed.value, Env.new, :toplevel)}\nnil"
         end
 
         def emit_set_form(form, env, current_scope)
-          target = form.items[1]
-          value_code = emit_expr(form.items[2], env, current_scope)
+          parsed = Language.parse_set_form(form)
+          target = parsed.target
+          value_code = emit_expr(parsed.value, env, current_scope)
 
           if target.is_a?(Sym) && !target.dotted?
             binding = env.lookup_if_defined(target.name)
@@ -437,15 +446,22 @@ module Kapusta
         end
 
         def emit_set_expr(args, env, current_scope)
-          target = args[0]
-          value_code = emit_expr(args[1], env, current_scope)
-          emit_set_target(target, value_code, env, current_scope)
+          parsed = Language.parse_set_args(args)
+          emit_set_target(parsed.target, emit_expr(parsed.value, env, current_scope), env, current_scope)
         end
 
         def emit_set_target(target, value_code, env, current_scope)
           case target
           when Sym
-            if target.dotted?
+            if target.colonized?
+              base_code, segments = multihash_base(target.colon_segments, env)
+              receiver = simple_expression?(base_code) ? base_code : parenthesize(base_code)
+              prefix = segments[0...-1].map do |segment|
+                "[#{Kapusta.kebab_to_snake(segment).to_sym.inspect}]"
+              end.join
+              key = Kapusta.kebab_to_snake(segments.last).to_sym.inspect
+              emit_assignment("#{receiver}#{prefix}[#{key}]", value_code)
+            elsif target.dotted?
               base_code, segments = multisym_base(target.segments, env)
               receiver = emit_method_path(base_code, segments[0...-1])
               last = segments.last
@@ -463,19 +479,14 @@ module Kapusta
               emit_assignment(binding, value_code)
             end
           when List
-            head = target.head
-            if head.is_a?(Sym) && head.name == '.'
-              object_code = emit_expr(target.items[1], env, current_scope)
-              keys = target.items[2..].map { |item| emit_expr(item, env, current_scope) }
+            if (dot_target = Language.parse_dot_target(target))
+              object_code = emit_expr(dot_target.object, env, current_scope)
+              keys = dot_target.keys.map { |item| emit_expr(item, env, current_scope) }
               receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
               prefix = keys[0...-1].map { |k| "[#{k}]" }.join
               emit_assignment("#{receiver}#{prefix}[#{keys.last}]", value_code)
-            elsif head.is_a?(Sym) && head.name == 'ivar'
-              emit_assignment("@#{Kapusta.kebab_to_snake(target.items[1].name)}", value_code)
-            elsif head.is_a?(Sym) && head.name == 'cvar'
-              emit_assignment("@@#{Kapusta.kebab_to_snake(target.items[1].name)}", value_code)
-            elsif head.is_a?(Sym) && head.name == 'gvar'
-              emit_assignment("$#{global_name(target.items[1].name)}", value_code)
+            elsif (sigil = Language.parse_sigil_form(target))
+              emit_sigil_assignment(sigil, value_code)
             else
               emit_error!(:bad_set_target, target: target.inspect)
             end
@@ -483,6 +494,17 @@ module Kapusta
             emit_error!(:bad_set_target, target: target.inspect)
           end
         end
+
+        def emit_sigil_assignment(sigil, value_code)
+          name = sigil.name
+          emit_error!(:bad_set_target, target: sigil.inspect) unless name.is_a?(Sym)
+
+          case sigil.kind
+          when :ivar then emit_assignment("@#{Kapusta.kebab_to_snake(name.name)}", value_code)
+          when :cvar then emit_assignment("@@#{Kapusta.kebab_to_snake(name.name)}", value_code)
+          when :gvar then emit_assignment("$#{global_name(name.name)}", value_code)
+          end
+        end
       end
     end
   end

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

@@ -9,37 +9,32 @@ module Kapusta
         private
 
         def emit_icollect(args, env, current_scope)
-          emit_error!(:icollect_no_iterator) unless args[0].is_a?(Vec) && args[0].items.length >= 2
+          parsed = Language.parse_iteration_args(args)
+          emit_error!(:icollect_no_iterator) unless parsed.bindings.is_a?(Vec) && parsed.bindings.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
+          emit_iteration(parsed.bindings, env, current_scope, method: 'filter_map') do |iter_env|
+            emit_sequence(parsed.body, iter_env, current_scope, allow_method_definitions: false).first
           end
         end
 
         def emit_collect(args, env, current_scope)
+          parsed = Language.parse_iteration_args(args)
           result_var = temp('result')
-          values_form = simple_values_call(args[1]) if args.length == 2
-          emit_iteration(args[0], env, current_scope,
+          values_form = Language.parse_values_form(parsed.body[0]) if parsed.body.length == 1
+          emit_iteration(parsed.bindings, 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
+              body = emit_sequence(parsed.body, 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_form = values_form.key
+          val_form = values_form.value
           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}"
@@ -60,32 +55,29 @@ module Kapusta
 
         def emit_fcollect(args, env, current_scope)
           result_var = temp('result')
-          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
-          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope, allow_method_definitions: false)
+          loop_form = Language.parse_counted_for_args(args)
+          parsed = parse_counted_for_bindings(loop_form, env, current_scope)
+          body_code, = emit_sequence(loop_form.body, parsed[:loop_env], current_scope,
+                                     allow_method_definitions: false)
           collecting_body = emit_array_collection_step(result_var, body_code)
           loop_code = emit_counted_loop(**parsed, current_scope:, body_code: collecting_body)
           emit_collection_result(result_var, '[]', loop_code)
         end
 
         def emit_accumulate(args, env, current_scope)
-          bindings = args[0].items
-          emit_error!(:accumulate_no_iterator) if bindings.length < 4
-
-          acc_name = bindings[0]
-          init_code = emit_expr(bindings[1], env, current_scope)
-          iter_items = bindings[2..]
-          iter_expr = iter_items.last
-          binding_pats = iter_items[0...-1]
+          parsed = Language.parse_accumulate_args(args)
+          emit_error!(:accumulate_no_iterator) if parsed.items.length < 4
 
+          init_code = emit_expr(parsed.initial, env, current_scope)
           body_env = env.child
-          acc_var = define_local(body_env, acc_name.name)
+          acc_var = define_local(body_env, parsed.acc_name.name)
 
-          inject_code = try_emit_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
-                                        init_code, args[1..])
+          inject_code = try_emit_inject(parsed.iter_expr, parsed.binding_pats, body_env, env, current_scope,
+                                        acc_var, init_code, parsed.body)
           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)
+          iter_code = emit_iteration(Vec.new(parsed.iter_items), body_env, current_scope) do |iter_env|
+            body_code, = emit_sequence(parsed.body, iter_env, current_scope, allow_method_definitions: false)
             emit_sequence_value_assignment(acc_var, body_code)
           end
           [
@@ -108,18 +100,18 @@ module Kapusta
         end
 
         def emit_faccumulate(args, env, current_scope)
-          bindings = args[0].items
-          emit_error!(:accumulate_no_iterator) if bindings.length < 5
+          parsed = Language.parse_faccumulate_args(args)
+          emit_error!(:accumulate_no_iterator) if parsed.items.length < 5
 
           body_env = env.child
-          acc_var = define_local(body_env, bindings[0].name)
-          loop_var = define_local(body_env, bindings[2].name)
-
-          init_code = emit_expr(bindings[1], env, current_scope)
-          start_code = emit_expr(bindings[3], env, current_scope)
-          finish_code = emit_expr(bindings[4], env, current_scope)
-          step_code = bindings[5] ? emit_expr(bindings[5], env, current_scope) : nil
-          body_code, = emit_sequence(args[1..], body_env, current_scope, allow_method_definitions: false)
+          acc_var = define_local(body_env, parsed.acc_name.name)
+          loop_var = define_local(body_env, parsed.counter.name)
+
+          init_code = emit_expr(parsed.initial, env, current_scope)
+          start_code = emit_expr(parsed.start, env, current_scope)
+          finish_code = emit_expr(parsed.finish, env, current_scope)
+          step_code = parsed.step ? emit_expr(parsed.step, env, current_scope) : nil
+          body_code, = emit_sequence(parsed.body, body_env, current_scope, allow_method_definitions: false)
 
           receiver =
             if step_code

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

@@ -53,7 +53,7 @@ module Kapusta
         end
 
         def if_form?(form)
-          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'if'
+          Language.list_head?(form, 'if')
         end
 
         def emit_case(args, env, current_scope, mode)
@@ -78,28 +78,28 @@ module Kapusta
         def build_case_parts(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?
+          parsed = Language.parse_case_args(args)
+          emit_error!(:case_no_patterns) if parsed.clauses.empty?
+          emit_error!(:case_odd_patterns) if parsed.clauses.length.odd?
 
-          value_code = emit_expr(args[0], env, current_scope)
-          if simple_case_subject?(args[0]) && simple_expression?(value_code)
-            body = emit_case_body(value_code, clauses, env, current_scope, mode)
+          value_code = emit_expr(parsed.subject, env, current_scope)
+          if simple_case_subject?(parsed.subject) && simple_expression?(value_code)
+            body = emit_case_body(value_code, parsed, env, current_scope, mode)
             emit_error!(:case_unsupported) unless body
             return [value_code, nil, body]
           end
 
           value_var = temp('case_value')
-          body = emit_case_body(value_var, clauses, env, current_scope, mode)
+          body = emit_case_body(value_var, parsed, env, current_scope, mode)
           emit_error!(:case_unsupported) unless body
           [value_code, value_var, body]
         end
 
-        def emit_case_body(value_var, clauses, env, current_scope, mode)
-          return try_emit_compat_case(value_var, clauses, env, current_scope, mode) if mruby3_target?
+        def emit_case_body(value_var, parsed, env, current_scope, mode)
+          return try_emit_compat_case(value_var, parsed, env, current_scope, mode) if mruby3_target?
 
-          try_emit_native_case(value_var, clauses, env, current_scope, mode) ||
-            try_emit_compat_case(value_var, clauses, env, current_scope, mode)
+          try_emit_native_case(value_var, parsed, env, current_scope, mode) ||
+            try_emit_compat_case(value_var, parsed, env, current_scope, mode)
         end
 
         def simple_case_subject?(form)
@@ -110,29 +110,28 @@ module Kapusta
           end
         end
 
-        def try_emit_native_case(value_var, clauses, env, current_scope, mode)
-          arms = collect_case_arms(clauses) do |pattern, body, where_guards|
+        def try_emit_native_case(value_var, parsed, env, current_scope, mode)
+          arms = collect_case_arms(parsed.complete_arms) 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)
+          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(parsed.complete_arms)
           ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
-        def collect_case_arms(clauses)
+        def collect_case_arms(arm_pairs)
           arms = []
           i = 0
-          while i < clauses.length
-            pattern = clauses[i]
-            body = clauses[i + 1]
+          while i < arm_pairs.length
+            pattern, body = arm_pairs[i]
             inner, where_guards = extract_pattern_and_guards(pattern)
-            sub_patterns = or_pattern?(inner) ? inner.items[1..] : [inner]
+            sub_patterns = Language.parse_or_pattern(inner)&.alternatives || [inner]
             sub_arms = sub_patterns.map { |sub| yield sub, body, where_guards }
             return if sub_arms.any?(&:nil?)
 
             arms.concat(sub_arms)
-            i += 2
+            i += 1
           end
           arms
         end
@@ -151,8 +150,8 @@ module Kapusta
           ["in #{plan[:pattern]}#{guard_clause}", indent(body_code)].join("\n")
         end
 
-        def try_emit_compat_case(value_var, clauses, env, current_scope, mode)
-          arms = collect_case_arms(clauses) do |pattern, body, where_guards|
+        def try_emit_compat_case(value_var, parsed, env, current_scope, mode)
+          arms = collect_case_arms(parsed.complete_arms) do |pattern, body, where_guards|
             try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
           end
           return unless arms
@@ -160,15 +159,16 @@ module Kapusta
           emit_compat_case_lines(arms)
         end
 
-        def wildcard_last?(clauses)
-          last_pattern = clauses[-2]
+        def wildcard_last?(arm_pairs)
+          last_pattern = arm_pairs.last&.first
           last_pattern.is_a?(Sym) && last_pattern.name == '_'
         end
 
         def extract_pattern_and_guards(pattern)
-          return [pattern, []] unless where_pattern?(pattern)
+          parsed = Language.parse_where_pattern(pattern)
+          return [pattern, []] unless parsed
 
-          [pattern.items[1], pattern.items[2..]]
+          [parsed.inner, parsed.guards]
         end
 
         def try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
@@ -251,16 +251,18 @@ module Kapusta
         end
 
         def emit_for_statement(args, env, current_scope)
-          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
-          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope,
+          loop_form = Language.parse_counted_for_args(args)
+          parsed = parse_counted_for_bindings(loop_form, env, current_scope)
+          body_code, = emit_sequence(loop_form.body, parsed[:loop_env], current_scope,
                                      allow_method_definitions: false,
                                      result: false)
           emit_counted_loop(**parsed, current_scope:, body_code:)
         end
 
         def emit_each_statement(args, env, current_scope)
-          emit_iteration(args[0], env, current_scope) do |iter_env|
-            emit_sequence(args[1..], iter_env, current_scope,
+          parsed = Language.parse_iteration_args(args)
+          emit_iteration(parsed.bindings, env, current_scope) do |iter_env|
+            emit_sequence(parsed.body, iter_env, current_scope,
                           allow_method_definitions: false,
                           result: false).first
           end