kapusta 0.13.2 → 0.15.0

data/lib/kapusta/formatter.rb

@@ -1,113 +1,33 @@
 # frozen_string_literal: true
 
 require_relative '../kapusta'
+require_relative 'formatter/ast_helpers'
+require_relative 'formatter/cli'
+require_relative 'formatter/line_helpers'
+require_relative 'formatter/validator'
 
 module Kapusta
   class Formatter
     MAX_WIDTH = 80
     INDENT = 2
     STDIN_PATH = '-'
-
-    PIPELINE_FORMS = %w[-> ->> -?> -?>> doto].freeze
+    BODY_ONLY_HEADS = %w[do finally].freeze
+    SINGLE_PREFIX_BODY_HEADS = %w[
+      while when unless for each icollect collect fcollect accumulate faccumulate
+    ].freeze
+    CASE_HEADS = %w[case match].freeze
+    private_constant :BODY_ONLY_HEADS, :SINGLE_PREFIX_BODY_HEADS, :CASE_HEADS
+    include ASTHelpers
+    include CLI
+    include LineHelpers
+    include Validator
 
     def self.format(source, path: nil)
       new([]).send(:format_source, source, path)
     end
 
-    def initialize(argv)
-      @mode = :stdout
-      @files = []
-      @version = false
-      parse_args(argv)
-    end
-
-    def run
-      if @version
-        puts "kapfmt #{Kapusta::VERSION}"
-        return 0
-      end
-
-      validate_args!
-
-      formatted = @files.map do |path|
-        original = read_source(path)
-        validate_kapusta_source(original, path)
-        [path, original, format_source(original, path)]
-      end
-
-      case @mode
-      when :stdout
-        $stdout.write(formatted.first[2])
-      when :fix
-        formatted.each do |path, _original, rewritten|
-          raise Error, 'Cannot use --fix with stdin (-).' if stdin_path?(path)
-
-          File.write(path, rewritten)
-        end
-      when :check
-        dirty = formatted.reject { |_path, original, rewritten| original == rewritten }
-        dirty.each do |path, _original, _rewritten|
-          warn "Not formatted: #{path}"
-        end
-        return 1 unless dirty.empty?
-      end
-
-      0
-    rescue Kapusta::Error => e
-      warn e.formatted
-      1
-    end
-
     private
 
-    def validate_kapusta_source(source, path)
-      Kapusta::Compiler.compile(source, path:)
-    end
-
-    def parse_args(argv)
-      argv.each do |arg|
-        case arg
-        when '--fix'
-          ensure_mode!(:fix)
-        when '--check'
-          ensure_mode!(:check)
-        when '--version', '-v'
-          @version = true
-        when '--help', '-h'
-          print_help
-          exit 0
-        else
-          @files << arg
-        end
-      end
-    end
-
-    def ensure_mode!(mode)
-      raise Error, 'Use at most one of --fix or --check.' if @mode != :stdout && @mode != mode
-
-      @mode = mode
-    end
-
-    def validate_args!
-      raise Error, 'Usage: kapfmt [--fix] [--check] FILENAME...' if @files.empty?
-      raise Error, 'stdin (-) may only be specified once.' if @files.count { |path| stdin_path?(path) } > 1
-      raise Error, 'Cannot use --fix with stdin (-).' if @mode == :fix && @files.any? { |path| stdin_path?(path) }
-
-      return unless @mode == :stdout && @files.length != 1
-
-      raise Error, 'Without --fix or --check, kapfmt accepts exactly one file.'
-    end
-
-    def read_source(path)
-      return File.read(path) unless stdin_path?(path)
-
-      @stdin_read ||= false
-      raise Error, 'stdin (-) may only be specified once.' if @stdin_read
-
-      @stdin_read = true
-      $stdin.read
-    end
-
     def format_source(source, path = nil)
       forms = Reader.read_all(source, preserve_comments: true)
       entries = top_level_entries(forms)
@@ -125,10 +45,6 @@ module Kapusta
       raise Error.new(e.message, path:)
     end
 
-    def separator_for(_previous, _current)
-      "\n"
-    end
-
     def top_level_entries(forms)
       entries = []
       leading_comments = []
@@ -160,18 +76,6 @@ module Kapusta
       parts.join("\n")
     end
 
-    def comment?(form)
-      form.is_a?(Comment)
-    end
-
-    def blank_line?(form)
-      form.is_a?(BlankLine)
-    end
-
-    def non_semantic?(form)
-      comment?(form) || blank_line?(form)
-    end
-
     def render(form, indent, layout: nil, top_level: false, force_expand: false)
       flat = flat_render(form)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(form, top_level:, layout:)
@@ -200,7 +104,11 @@ module Kapusta
       rendered = render(inner, indent + prefix.length, force_expand:)
       lines = rendered.lines(chomp: true)
       pad = ' ' * prefix.length
-      lines.each_with_index.map { |line, i| i.zero? ? "#{prefix}#{line}" : "#{pad}#{line}" }.join("\n")
+      lines.each_with_index.map do |line, i|
+        next '' if line.empty?
+
+        i.zero? ? "#{prefix}#{line}" : "#{pad}#{line}"
+      end.join("\n")
     end
 
     def flat_render(form)
@@ -212,33 +120,11 @@ module Kapusta
       when Sym
         form.name
       when Vec
-        return if contains_comments?(form.items)
-        return if multiline_in_source?(form)
-
-        rendered = form.items.map { |item| flat_render(item) }
-        return if rendered.any?(&:nil?)
-
-        "[#{rendered.join(' ')}]"
+        flat_render_vec(form)
       when HashLit
-        return if contains_comments?(form.entries)
-        return if multiline_in_source?(form)
-
-        rendered = form.pairs.map { |key, value| flat_hash_pair(key, value) }
-        return if rendered.any?(&:nil?)
-
-        "{#{rendered.join(' ')}}"
+        flat_render_hash(form)
       when List
-        return render_sigil(form) if form.sigil
-        return if contains_comments?(form.items)
-        return "##{flat_render(semantic_items(form.items)[1])}" if hashfn_literal?(form)
-        return if multiline_in_source?(form)
-        return if let_with_multiple_bindings?(form)
-        return if let_with_nested_binding_value?(form)
-
-        rendered = form.items.map { |item| flat_render(item) }
-        return if rendered.any?(&:nil?)
-
-        "(#{rendered.join(' ')})"
+        flat_render_list(form)
       when Quasiquote
         inner = flat_render(form.form)
         inner ? "`#{inner}" : nil
@@ -255,46 +141,78 @@ module Kapusta
       end
     end
 
+    def flat_render_vec(vec)
+      return if contains_comments?(vec.items)
+      return if multiline_in_source?(vec)
+
+      flat_delimited_render(vec.items, '[', ']') { |item| flat_render(item) }
+    end
+
+    def flat_render_hash(hash)
+      return if contains_comments?(hash.entries)
+      return if multiline_in_source?(hash)
+
+      flat_hash_render(hash.pairs)
+    end
+
+    def flat_render_list(list)
+      return render_sigil(list) if list.sigil
+      return if contains_comments?(list.items)
+      return flat_render_hashfn(list) if hashfn_literal?(list)
+      return if multiline_in_source?(list)
+      return if let_with_multiple_bindings?(list)
+      return if let_with_nested_binding_value?(list)
+
+      flat_delimited_render(list.items, '(', ')') { |item| flat_render(item) }
+    end
+
+    def flat_render_hashfn(list)
+      rendered = flat_render(semantic_items(list.items)[1])
+      "##{rendered}" if rendered
+    end
+
     def render_list(list, indent, top_level: false)
       return '()' if list.items.empty?
       return "##{render(semantic_items(list.items)[1], indent, top_level:)}" if hashfn_literal?(list)
 
-      head = list_head(list)
-      return render_generic_list(list, indent) unless head
+      return render_generic_list(list, indent) unless list_head(list)
 
-      head_name = head.is_a?(Sym) ? head.name : nil
+      name = head_name(list)
       raw_args = list_raw_rest(list)
 
-      case head_name
-      when 'fn', 'defn', 'lambda', 'λ', 'macro' then render_fn(head_name, list, indent, top_level:)
+      case name
+      when *Compiler::Language::FUNCTION_DEFINITION_HEADS, 'macro'
+        render_fn(name, list, indent, top_level:)
       when 'let' then render_let(list, indent)
-      when 'do', 'finally' then render_prefix_body_form(head_name, [], raw_args, indent)
+      when *BODY_ONLY_HEADS then render_prefix_body_form(name, [], raw_args, indent)
       when 'try' then render_try(list, indent)
-      when 'while', 'when', 'unless', 'for', 'each', 'icollect', 'collect', 'fcollect', 'accumulate', 'faccumulate'
-        raw_prefix, raw_body = split_raw_items(raw_args, 1)
-        render_prefix_body_form(head_name, raw_prefix, raw_body, indent)
-      when 'module'
-        raw_prefix, raw_body = split_raw_items(raw_args, 1)
-        render_prefix_body_form('module', raw_prefix, raw_body, indent)
+      when *SINGLE_PREFIX_BODY_HEADS then render_single_prefix_body_form(name, raw_args, indent)
       when 'class' then render_class(list, indent)
+      when 'module' then render_module(list, indent)
       when 'catch' then render_catch(list, indent)
       when 'if' then render_if(list, indent)
-      when 'case', 'match'
-        if contains_comments?(raw_args)
-          render_sequential_head_form(head_name, raw_args, indent)
-        else
-          render_case(head_name, list_rest(list), indent)
-        end
-      when *PIPELINE_FORMS then render_pipeline(head_name, raw_args, indent)
+      when *CASE_HEADS then render_case_or_match(name, list, raw_args, indent)
+      when *Compiler::Language::PIPELINE_HEADS then render_pipeline(name, raw_args, indent)
       else
         render_call(list, indent)
       end
     end
 
+    def render_single_prefix_body_form(head, raw_args, indent)
+      raw_prefix, raw_body = split_raw_items(raw_args, 1)
+      render_prefix_body_form(head, raw_prefix, raw_body, indent)
+    end
+
+    def render_case_or_match(head, list, raw_args, indent)
+      return render_sequential_head_form(head, raw_args, indent) if contains_comments?(raw_args)
+
+      render_case(head, list_rest(list), indent)
+    end
+
     def render_fn(head, list, indent, top_level: false)
       args = list_rest(list)
       raw_args = list_raw_rest(list)
-      prefix_length = args[0].is_a?(Sym) && args[1].is_a?(Vec) ? 2 : 1
+      prefix_length = Compiler::Language.parse_function_args(args)&.prefix_length || 1
       raw_prefix, raw_body = split_raw_items(raw_args, prefix_length)
       force = top_level || fn_body_has_quasi_list?(raw_body)
       render_prefix_body_form(head, raw_prefix, raw_body, indent, force_body_multiline: force)
@@ -312,11 +230,19 @@ module Kapusta
     def render_class(list, indent)
       args = list_rest(list)
       raw_args = list_raw_rest(list)
-      prefix = args[1].is_a?(Vec) ? args.take(2) : args.take(1)
-      raw_prefix, raw_body = split_raw_items(raw_args, prefix.length)
+      prefix_length = Compiler::Language.parse_class_args(args).prefix_length
+      raw_prefix, raw_body = split_raw_items(raw_args, prefix_length)
       render_prefix_body_form('class', raw_prefix, raw_body, indent)
     end
 
+    def render_module(list, indent)
+      args = list_rest(list)
+      raw_args = list_raw_rest(list)
+      prefix_length = Compiler::Language.parse_module_args(args).prefix_length
+      raw_prefix, raw_body = split_raw_items(raw_args, prefix_length)
+      render_prefix_body_form('module', raw_prefix, raw_body, indent)
+    end
+
     def render_try(list, indent)
       args = list_rest(list)
       return render_sequential_head_form('try', list_raw_rest(list), indent) if contains_comments?(list_raw_rest(list))
@@ -341,10 +267,10 @@ module Kapusta
     end
 
     def render_let(list, indent)
-      bindings = list_rest(list).first
+      parsed = Compiler::Language.parse_let_args(list_rest(list))
+      bindings = parsed.bindings
       raw_args = list_raw_rest(list)
       raw_prefix, raw_body = split_raw_items(raw_args, 1)
-      body = list_rest(list).drop(1)
       unless bindings.is_a?(Vec)
         return render_prefix_body_form('let', raw_prefix, raw_body, indent,
                                        layouts: [:pairwise])
@@ -358,7 +284,7 @@ module Kapusta
       rendered_bindings = render_let_bindings(bindings, indent)
       lines = rendered_bindings.lines(chomp: true)
       lines[0] = "(let #{lines[0]}"
-      body.each do |form|
+      parsed.body.each do |form|
         lines << indent_block(render(form, indent + INDENT), INDENT)
       end
       append_suffix(lines, ')')
@@ -406,52 +332,50 @@ module Kapusta
       end
 
       body_forms.each do |form|
-        if blank_line?(form)
-          lines << ''
-          next
-        end
-        if comment?(form)
-          lines << indent_block(render(form, indent + INDENT), INDENT)
-          next
-        end
-
-        body = render(
-          form,
-          indent + INDENT,
-          force_expand: force_body_multiline && force_multiline_body?(form)
-        )
-        lines << indent_block(body, INDENT)
+        append_body_form(lines, form, indent, force_body_multiline:)
       end
 
       append_suffix(lines, ')')
     end
 
+    def append_body_form(lines, form, indent, force_body_multiline: false)
+      if blank_line?(form)
+        lines << ''
+        return
+      end
+      if comment?(form)
+        lines << indent_block(render(form, indent + INDENT), INDENT)
+        return
+      end
+
+      body = render(
+        form,
+        indent + INDENT,
+        force_expand: force_body_multiline && force_multiline_body?(form)
+      )
+      lines << indent_block(body, INDENT)
+    end
+
     def render_if(list, indent)
       args = list_rest(list)
       return render_sequential_head_form('if', list_raw_rest(list), indent) if contains_comments?(list_raw_rest(list))
 
       lines = []
-      hanging = ' ' * '(if '.length
+      hanging = if_hanging
 
       if args.length == 3
         flat = flat_render(list)
         return flat if inline_three_arg_if?(args) && flat && fits?(flat, indent)
 
-        lines << "(if #{render(args[0], indent + '(if '.length)}"
-        lines << prefix_continuation(hanging, render(args[1], indent + '(if '.length))
-        lines << prefix_continuation(hanging, render(args[2], indent + '(if '.length))
+        append_if_form(lines, args[0], indent, '(if ')
+        append_if_form(lines, args[1], indent, hanging)
+        append_if_form(lines, args[2], indent, hanging)
         return append_suffix(lines, ')')
       end
 
       index = 0
       if args.length >= 2
-        first_pair = render_pair(args[0], args[1], indent + '(if '.length)
-        if first_pair
-          lines << "(if #{first_pair}"
-        else
-          lines << "(if #{render(args[0], indent + '(if '.length)}"
-          lines << prefix_continuation(hanging, render(args[1], indent + '(if '.length))
-        end
+        append_if_pair(lines, args[0], args[1], indent, '(if ')
         index = 2
       else
         lines << '(if'
@@ -460,16 +384,10 @@ module Kapusta
       while index < args.length
         remaining = args.length - index
         if remaining >= 2
-          pair = render_pair(args[index], args[index + 1], indent + '(if '.length)
-          if pair
-            lines << "#{hanging}#{pair}"
-          else
-            lines << prefix_continuation(hanging, render(args[index], indent + '(if '.length))
-            lines << prefix_continuation(hanging, render(args[index + 1], indent + '(if '.length))
-          end
+          append_if_pair(lines, args[index], args[index + 1], indent, hanging)
           index += 2
         else
-          lines << prefix_continuation(hanging, render(args[index], indent + '(if '.length))
+          append_if_form(lines, args[index], indent, hanging)
           index += 1
         end
       end
@@ -477,19 +395,44 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
+    def append_if_pair(lines, condition, branch, indent, prefix)
+      pair = render_pair(condition, branch, if_value_indent(indent))
+      if pair
+        lines << "#{prefix}#{pair}"
+      else
+        append_if_form(lines, condition, indent, prefix)
+        append_if_form(lines, branch, indent, if_hanging)
+      end
+    end
+
+    def append_if_form(lines, form, indent, prefix)
+      lines << prefix_continuation(prefix, render(form, if_value_indent(indent)))
+    end
+
+    def if_value_indent(indent)
+      indent + '(if '.length
+    end
+
+    def if_hanging
+      ' ' * '(if '.length
+    end
+
     def prefix_continuation(prefix, rendered)
-      first_line, *rest = rendered.lines(chomp: true)
+      prefix_lines(prefix, rendered.lines(chomp: true)).join("\n")
+    end
+
+    def prefix_lines(prefix, lines)
+      first_line, *rest = lines
       pad = ' ' * prefix.length
-      ["#{prefix}#{first_line}", *rest.map { |line| "#{pad}#{line}" }].join("\n")
+      ["#{prefix}#{first_line}", *rest.map { |line| line.empty? ? '' : "#{pad}#{line}" }]
     end
 
     def render_case(head, args, indent)
-      subject = args.first
-      clauses = args.drop(1)
+      parsed = Compiler::Language.parse_case_args(args)
       lines = ['(case']
 
-      if subject
-        rendered_subject = render(subject, indent + INDENT)
+      if parsed.subject
+        rendered_subject = render(parsed.subject, indent + INDENT)
         if single_line?(rendered_subject) && fits?("(#{head} #{rendered_subject}", indent)
           lines[0] = "(#{head} #{rendered_subject}"
         else
@@ -498,24 +441,27 @@ module Kapusta
         end
       end
 
-      clauses.each_slice(2) do |pair|
-        pattern, value = pair
-        if pair.length == 2
-          pair = render_pair(pattern, value, indent + INDENT)
-          if pair
-            lines << indent_block(pair, INDENT)
-          else
-            lines << indent_block(render(pattern, indent + INDENT), INDENT)
-            lines << indent_block(render(value, indent + INDENT), INDENT)
-          end
-        else
-          lines << indent_block(render(pattern, indent + INDENT), INDENT)
-        end
-      end
+      parsed.arm_pairs.each { |arm| append_case_arm(lines, arm, indent) }
 
       append_suffix(lines, ')')
     end
 
+    def append_case_arm(lines, arm, indent)
+      pattern, value = arm
+      unless arm.length == 2
+        lines << indent_block(render(pattern, indent + INDENT), INDENT)
+        return
+      end
+
+      rendered_pair = render_pair(pattern, value, indent + INDENT)
+      if rendered_pair
+        lines << indent_block(rendered_pair, INDENT)
+      else
+        lines << indent_block(render(pattern, indent + INDENT), INDENT)
+        lines << indent_block(render(value, indent + INDENT), INDENT)
+      end
+    end
+
     def render_pipeline(head, args, indent)
       base = "(#{head}"
       lines = [base]
@@ -547,7 +493,7 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
-    def render_call(list, indent)
+    def render_call(list, indent, force_hang: false)
       head = flat_render(list_head(list))
       raise Error, "cannot format form head: #{list_head(list).inspect}" unless head
 
@@ -555,7 +501,7 @@ module Kapusta
       lines = [base]
       args = list_raw_rest(list)
       semantic_length = semantic_items(args).length
-      hang_subsequent_args = hang_call_args?(list, indent)
+      hang_subsequent_args = force_hang || hang_call_args?(list, base, indent)
 
       semantic_index = 0
       hanging = nil
@@ -565,6 +511,8 @@ module Kapusta
           next
         elsif semantic_index.zero?
           hanging = append_first_call_arg(lines, arg, base, indent, semantic_length)
+        elsif append_packed_call_arg?(list, lines, arg, indent)
+          nil
         elsif hanging && hang_subsequent_args
           lines << prefix_continuation(hanging, render(arg, indent + hanging.length))
         else
@@ -597,33 +545,172 @@ module Kapusta
       hanging
     end
 
-    def hang_call_args?(list, indent)
-      return false unless operator_call?(list)
+    def append_packed_call_arg?(list, lines, arg, indent)
+      return false unless packable_call_arg?(list, arg)
+
+      packed = packed_call_arg(lines.last, list, arg, indent)
+      if packed
+        lines[-1] = packed.first
+        lines.concat(packed.drop(1))
+        return true
+      end
+
+      false
+    end
+
+    def packable_call_arg?(list, arg)
+      return false if fn_form?(arg)
+      return true if packable_collection_call_arg?(list, arg)
+
+      pack_call_args?(list) && flat_render(arg)
+    end
+
+    def packable_collection_call_arg?(list, arg)
+      return true if arg.is_a?(Vec)
+
+      arg.is_a?(HashLit) && packable_hash_call_arg?(list)
+    end
+
+    def packed_call_arg(current_line, list, arg, indent)
+      packable_call_arg_renderings(list, arg, indent + current_line.length + 1).each do |rendered|
+        first_line, *rest = rendered.lines(chomp: true)
+        candidate = "#{current_line} #{first_line}"
+        next unless inline_arg_fits?(candidate, indent)
+
+        hanging = ' ' * (current_line.length + 1)
+        return [candidate, *rest.map { |line| "#{hanging}#{line}" }]
+      end
+
+      nil
+    end
+
+    def packable_call_arg_renderings(list, arg, indent)
+      [
+        flat_collection_render(arg),
+        flat_render(arg),
+        multiline_packable_call_arg_rendering(list, arg, indent)
+      ].compact.uniq
+    end
+
+    def multiline_packable_call_arg_rendering(list, arg, indent)
+      return render(arg, indent) if arg.is_a?(Vec)
+      return render(arg, indent) if local_hash_call_arg?(list, arg)
+
+      nil
+    end
+
+    def local_hash_call_arg?(list, arg)
+      arg.is_a?(HashLit) && head_name(list) == 'local'
+    end
+
+    def flat_collection_render(form)
+      case form
+      when Vec
+        flat_delimited_render(form.items, '[', ']') { |item| flat_render(item) }
+      when HashLit
+        return if contains_comments?(form.entries)
+
+        flat_hash_render(form.pairs)
+      end
+    end
+
+    def flat_delimited_render(items, open, close)
+      return if contains_comments?(items)
+
+      rendered = items.map do |item|
+        item.is_a?(Array) ? yield(*item) : yield(item)
+      end
+      return if rendered.any?(&:nil?)
+
+      "#{open}#{rendered.join(' ')}#{close}"
+    end
+
+    def flat_hash_render(pairs)
+      rendered = pairs.map { |pair| flat_hash_pair(pair) }
+      return if rendered.any?(&:nil?)
+
+      "{#{rendered.join(' ')}}"
+    end
+
+    def hang_call_args?(list, base, indent)
+      return true if source_hangs_call_args?(list, base)
+      return true if set_function_value?(list)
 
       flat = flat_call_render(list)
-      flat && !fits?(flat, indent)
+      return false unless flat
+
+      overflowing = !fits?(flat, indent)
+      return true if overflowing && hanging_overflow_call?(list)
+
+      operator_call?(list) && overflowing
+    end
+
+    def pack_call_args?(list)
+      head_name(list)&.match?(/\A[a-z0-9_-][\w-]*\./)
+    end
+
+    def packable_hash_call_arg?(list)
+      head_name(list) == 'local' || pack_call_args?(list)
+    end
+
+    def hanging_overflow_call?(list)
+      hash_first_call_arg?(list) || pack_call_args?(list)
+    end
+
+    def hash_first_call_arg?(list)
+      list_rest(list).first.is_a?(HashLit)
+    end
+
+    def set_function_value?(list)
+      head_name(list) == 'set' && fn_form?(list_rest(list)[1])
+    end
+
+    def source_hangs_call_args?(list, base)
+      return false unless list.respond_to?(:column) && list.column
+
+      args = list_rest(list)
+      return false if args.length < 2
+
+      expected_column = list.column + base.length + 1
+      args.drop(1).all? do |arg|
+        arg.respond_to?(:column) && arg.column == expected_column
+      end
     end
 
     def operator_call?(list)
-      head = list_head(list)
-      head.is_a?(Sym) && head.name.match?(/\A[^\w.]+\z/)
+      head_name(list)&.match?(/\A[^\w.]+\z/)
+    end
+
+    def ordinary_call_form?(list)
+      name = head_name(list)
+      name && !Compiler::Language::SPECIAL_FORMS.include?(name)
     end
 
     def flat_call_render(list)
       head = flat_render(list_head(list))
       return unless head
 
-      rendered_args = semantic_items(list_raw_rest(list)).map { |arg| flat_render(arg) }
+      rendered_args = semantic_items(list_raw_rest(list)).map { |arg| flat_call_arg_render(arg) }
       return if rendered_args.any?(&:nil?)
 
       "(#{[head, *rendered_args].join(' ')})"
     end
 
+    def flat_call_arg_render(arg)
+      collection = flat_collection_render(arg)
+      return collection if collection
+
+      flat_render(arg)
+    end
+
     def render_vec(vec, indent, layout: nil, top_level: false, force_expand: false)
       flat = flat_render(vec)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(vec, top_level:, layout:)
 
       return render_pairwise_vec(vec, indent) if layout == :pairwise && !contains_comments?(vec.items)
+      if multiline_in_source?(vec) && multiline_vec_items_should_separate?(vec) && !contains_comments?(vec.items)
+        return render_multiline_vec(vec, indent)
+      end
       return render_filled_vec(vec, indent) if !contains_comments?(vec.items) && !vec.items.empty?
 
       lines = ['[']
@@ -633,6 +720,42 @@ module Kapusta
       append_suffix(lines, ']')
     end
 
+    def render_multiline_vec(vec, indent)
+      return '[]' if vec.items.empty?
+
+      lines = []
+      vec.items.each_with_index do |item, idx|
+        prefix = idx.zero? ? '[' : ' '
+        lines.concat(prefix_lines(prefix, render_multiline_vec_item(item, indent + 1).lines.map(&:chomp)))
+      end
+      lines[-1] = "#{lines[-1]}]"
+      lines.join("\n")
+    end
+
+    def render_multiline_vec_item(item, indent)
+      return render_call(item, indent, force_hang: true) if hanging_multiline_vec_call_item?(item)
+
+      render(item, indent)
+    end
+
+    def hanging_multiline_vec_call_item?(item)
+      item.is_a?(List) && multiline_in_source?(item) && ordinary_call_form?(item)
+    end
+
+    def multiline_vec_items_should_separate?(vec)
+      multiline_vec_items_on_separate_lines?(vec) || semantic_items(vec.items).all? { |item| collection?(item) }
+    end
+
+    def multiline_vec_items_on_separate_lines?(vec)
+      items = semantic_items(vec.items)
+      return false if items.length < 2
+
+      lines = items.filter_map { |item| item.line if item.respond_to?(:line) }
+      return true if lines.length < 2
+
+      lines.uniq.length == lines.length
+    end
+
     def render_filled_vec(vec, indent)
       output_lines = ['[']
 
@@ -688,16 +811,16 @@ module Kapusta
     def render_let_bindings(bindings, indent)
       return render(bindings, indent + '(let '.length, force_expand: true) if contains_comments?(bindings.items)
 
-      hanging = render_hanging_pairwise_vec(bindings)
+      hanging = render_hanging_pairwise_vec(bindings, indent)
       hanging || render(bindings, indent + '(let '.length, layout: :pairwise)
     end
 
-    def render_hanging_pairwise_vec(vec)
+    def render_hanging_pairwise_vec(vec, indent)
       pairs = vec.items.each_slice(2).to_a
       return unless pairs.all? { |pair| pair.length == 2 }
 
       rendered_pairs = pairs.map do |left, right|
-        render_binding_pair(left, right)
+        render_binding_pair(left, right, indent)
       end
       return if rendered_pairs.any?(&:nil?)
 
@@ -725,7 +848,7 @@ module Kapusta
 
         key, value = entry
         first_pair = output_lines.empty?
-        if hash_shorthand?(key, value)
+        if hash_pair_shorthand?(entry)
           output_lines << "#{first_pair ? '{' : ' '}: #{value.name}"
           next
         end
@@ -745,8 +868,9 @@ module Kapusta
       output_lines.join("\n")
     end
 
-    def flat_hash_pair(key, value)
-      return ": #{value.name}" if hash_shorthand?(key, value)
+    def flat_hash_pair(pair)
+      key, value = pair
+      return ": #{value.name}" if hash_pair_shorthand?(pair)
 
       rendered_value = flat_render(value)
       return unless rendered_value
@@ -772,14 +896,15 @@ module Kapusta
       fits?(pair, indent) ? pair : nil
     end
 
-    def render_binding_pair(left, right)
+    def render_binding_pair(left, right, indent)
       left_rendered = flat_render(left)
       return unless left_rendered
 
-      right_rendered = render(right, '(let ['.length + left_rendered.length + 1)
+      right_indent = indent + '(let ['.length + left_rendered.length + 1
+      right_rendered = render(right, right_indent)
       first_line, *rest = right_rendered.lines(chomp: true)
       pair = "#{left_rendered} #{first_line}"
-      return unless pair.length <= MAX_WIDTH
+      return unless fits?(pair, indent + '(let ['.length)
 
       return pair if rest.empty?
 
@@ -787,8 +912,8 @@ module Kapusta
       ([pair] + rest.map { |line| "#{continuation}#{line}" }).join("\n")
     end
 
-    def hash_shorthand?(key, value)
-      key.is_a?(Symbol) && value.is_a?(Sym) && key == Kapusta.kebab_to_snake(value.name).to_sym
+    def hash_pair_shorthand?(pair)
+      pair.respond_to?(:shorthand?) && pair.shorthand?
     end
 
     def hashfn_literal?(form)
@@ -809,11 +934,10 @@ module Kapusta
       return true unless head.is_a?(Sym)
 
       case head.name
-      when 'fn', 'lambda', 'λ', 'macro', 'when', 'unless', 'for', 'each', 'icollect', 'collect', 'fcollect',
-           'accumulate', 'faccumulate'
+      when *Compiler::Language::FLAT_BODY_HEADS
         !top_level
       else
-        !%w[let case match try catch finally do -> ->> -?> -?>> doto].include?(head.name)
+        !Compiler::Language.never_flat_head?(head.name)
       end
     end
 
@@ -826,18 +950,13 @@ module Kapusta
       return false unless head.is_a?(Sym)
 
       case head.name
-      when 'if', 'case', 'match', 'let', 'try', 'catch', 'finally', 'do', 'for', '->', '->>', '-?>', '-?>>', 'doto',
-           'fn', 'lambda', 'λ', 'macro'
+      when *Compiler::Language::MULTILINE_BODY_HEADS
         true
       else
         false
       end
     end
 
-    def multiline_in_source?(form)
-      form.respond_to?(:multiline_source) && form.multiline_source
-    end
-
     def let_with_multiple_bindings?(form)
       head = list_head(form)
       return false unless head.is_a?(Sym) && head.name == 'let'
@@ -860,25 +979,12 @@ module Kapusta
       end
     end
 
-    def contains_collection?(form)
-      case form
-      when List then semantic_items(form.items).any? { |item| collection?(item) }
-      when Vec then form.items.any? { |item| collection?(item) }
-      when HashLit then form.pairs.any? { |k, v| collection?(k) || collection?(v) }
-      else false
-      end
-    end
-
-    def collection?(form)
-      form.is_a?(List) || form.is_a?(Vec) || form.is_a?(HashLit)
-    end
-
     def fn_form?(form)
       return false unless form.is_a?(List)
 
       head = list_head(form)
       head.is_a?(Sym) &&
-        %w[fn lambda λ].include?(head.name)
+        Compiler::Language.function_head?(head.name)
     end
 
     def inline_three_arg_if?(args)
@@ -897,33 +1003,6 @@ module Kapusta
       end
     end
 
-    def stdin_path?(path)
-      path == STDIN_PATH
-    end
-
-    def fits?(text, indent)
-      !text.include?("\n") && indent + text.length <= MAX_WIDTH
-    end
-
-    def single_line?(text)
-      !text.include?("\n")
-    end
-
-    def indent_block(text, amount)
-      prefix = ' ' * amount
-      text.lines.map { |line| "#{prefix}#{line}" }.join
-    end
-
-    def append_suffix(lines, suffix)
-      updated = lines.dup
-      if updated[-1].lstrip.start_with?(';')
-        updated << suffix
-      else
-        updated[-1] = "#{updated[-1]}#{suffix}"
-      end
-      updated.join("\n")
-    end
-
     def render_generic_list(list, indent)
       lines = ['(']
       list.items.each do |item|
@@ -959,47 +1038,6 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
-    def contains_comments?(items)
-      items.any? { |item| non_semantic?(item) }
-    end
-
-    def semantic_items(items)
-      items.reject { |item| non_semantic?(item) }
-    end
-
-    def list_head(list)
-      semantic_items(list.items).first
-    end
-
-    def list_rest(list)
-      semantic_items(list.items).drop(1)
-    end
-
-    def list_raw_rest(list)
-      index = list.items.index { |item| !comment?(item) }
-      return list.items if index.nil?
-
-      list.items[(index + 1)..] || []
-    end
-
-    def split_raw_items(items, semantic_count)
-      split_index = 0
-      seen = 0
-
-      while split_index < items.length && seen < semantic_count
-        seen += 1 unless comment?(items[split_index])
-        split_index += 1
-      end
-
-      [items.take(split_index), items.drop(split_index)]
-    end
-
-    def print_help
-      puts 'Usage: kapfmt [--fix] [--check] FILENAME...'
-      puts
-      puts 'Formats Kapusta source using the built-in Kapusta reader and pretty-printer.'
-    end
-
     class Error < Kapusta::Error; end
   end
 end