jade-lang 0.1.0

data/lib/jade/formatter/function_declaration.rb

@@ -0,0 +1,72 @@
+module Jade
+  module Formatter
+    module FunctionDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::FunctionDeclaration(
+          name:, params:, return_type:, body:
+        )
+
+        [
+          format_signature(name, params, return_type, indent, source:),
+          format_node(body, indent: indent + 1, source:),
+          "end".then(&and_indent(indent)),
+        ].join("\n")
+      end
+
+      private
+
+      # `def name(params) -> Return`. When the inline form is too long:
+      #   - if return is a breakable record, break the record (params stay
+      #     inline when the resulting header fits).
+      #   - else if there are params, break params multi-line with
+      #     `-> Type` on the close-paren line.
+      #   - else live with the long line.
+      def format_signature(name, params, return_type, indent, source:)
+        return_str    = format_type_atom(return_type)
+        params_inline = format_params_inline(params, source:)
+        inline        = "def #{name}#{params_inline} -> #{return_str}"
+
+        return inline.then(&and_indent(indent)) unless too_long?(inline, indent)
+
+        broken_record = try_break_record_return(name, params_inline, return_type, indent)
+        return broken_record if broken_record
+
+        return inline.then(&and_indent(indent)) if params.empty?
+
+        format_params_multi(name, params, return_str, indent, source:)
+      end
+
+      def format_params_inline(params, source:)
+        return "" if params.empty?
+
+        params.map { format_node(it, source:) }.join(", ").then { "(#{it})" }
+      end
+
+      def try_break_record_return(name, params_inline, return_type, indent)
+        return nil unless Type.breakable_record?(return_type)
+
+        record_multi = Type.format_record_multiline(return_type, indent)
+        header = "def #{name}#{params_inline} -> #{record_multi.lines.first.chomp}"
+        return nil if too_long?(header, indent)
+
+        "def #{name}#{params_inline} -> #{record_multi}"
+          .then(&and_indent(indent))
+      end
+
+      def format_params_multi(name, params, return_str, indent, source:)
+        params_lines = params
+          .map { "#{format_node(it, source:)},".then(&and_indent(indent + 1)) }
+          .join("\n")
+
+        [
+          "def #{name}(".then(&and_indent(indent)),
+          params_lines,
+          ") -> #{return_str}".then(&and_indent(indent)),
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/jade/formatter/helper.rb

@@ -0,0 +1,122 @@
+module Jade
+  module Formatter
+    # Mixin for per-node formatter modules. Provides:
+    #   - INDENT, LINE_LIMIT constants
+    #   - `format_node(node, indent:, source:)` — top-level dispatcher
+    #     that prepends leading comments and appends a trailing one.
+    #   - `and_indent(n)` — prefixes every line of a string with N levels of
+    #     indent, leaving blank lines untouched.
+    #   - `too_long?(line, indent)` — width check against LINE_LIMIT.
+    #   - `format_delimited(...)` — the open/items/close pattern used by
+    #     Tuple, List, and a few callers.
+    #   - `format_pattern`, `format_type`, `format_exposing` — sibling
+    #     walks delegated to their own modules.
+    module Helper
+      def format_node(node, indent: 0, source: nil)
+        leading  = format_leading_comments(node, indent)
+        trailing = format_trailing_comment(node)
+
+        dispatch_for(node)
+          .format(node, indent:, source:)
+          .then { leading + it + trailing }
+      end
+
+      def dispatch_for(node)
+        case node
+        in AST::Module                       then ModuleNode
+        in AST::Body                         then Body
+        in AST::FunctionDeclaration          then FunctionDeclaration
+        in AST::FunctionDeclarationParam     then FunctionDeclarationParam
+        in AST::TypeDeclaration              then TypeDeclaration
+        in AST::VariantDeclaration           then VariantDeclaration
+        in AST::StructDeclaration            then StructDeclaration
+        in AST::ImportDeclaration            then ImportDeclaration
+        in AST::InteropImportDeclaration     then InteropImportDeclaration
+        in AST::InteropFunction              then InteropFunction
+        in AST::InterfaceDeclaration         then InterfaceDeclaration
+        in AST::InterfaceFunctionDecl        then InterfaceFunctionDecl
+        in AST::Assign                       then Assign
+        in AST::Bind                         then Bind
+        in AST::Implementation               then Implementation
+        in AST::ImplementationFunction       then ImplementationFunction
+        in AST::IfThenElse                   then IfThenElse
+        in AST::CaseOf                       then CaseOf
+        in AST::CaseOfBranch                 then CaseOfBranch
+        in AST::Lambda                       then Lambda
+        in AST::InfixApplication             then InfixApplication
+        in AST::FunctionCall                 then FunctionCall
+        in AST::KeyedCall                    then KeyedCall
+        in AST::Placeholder                  then Placeholder
+        in AST::MemberAccess                 then MemberAccess
+        in AST::QualifiedAccess              then QualifiedAccess
+        in AST::RecordAccess                 then RecordAccess
+        in AST::RecordAccessSugar            then RecordAccessSugar
+        in AST::RecordUpdateSugar            then RecordUpdateSugar
+        in AST::Grouping                     then Grouping
+        in AST::Tuple                        then Tuple
+        in AST::List                         then List
+        in AST::RecordLiteral                then RecordLiteral
+        in AST::RecordUpdate                 then RecordUpdate
+        in AST::VariableReference            then VariableReference
+        in AST::ConstructorReference         then ConstructorReference
+        in AST::CharLiteral                  then CharLiteral
+        in AST::Literal                      then Literal
+        end
+      end
+
+      def and_indent(indent)
+        ->(str) {
+          prefix = INDENT * indent
+          str.lines.map { |line| line == "\n" ? line : "#{prefix}#{line}" }.join
+        }
+      end
+
+      def too_long?(line, indent)
+        (INDENT * indent).length + line.length > LINE_LIMIT
+      end
+
+      def format_leading_comments(node, indent)
+        return "" if node.leading_comments.empty?
+
+        node.leading_comments
+          .map { |tok| tok.value.then(&and_indent(indent)) }
+          .join("\n")
+          .then { it + "\n" }
+      end
+
+      def format_trailing_comment(node)
+        return "" if node.trailing_comments.empty?
+
+        " #{node.trailing_comments.first.value}"
+      end
+
+      # Generic open/sep/close formatter shared by Tuple and List. Inline
+      # when it fits and no trailing-comma hint; multi-line otherwise.
+      def format_delimited(strs, open, close, trailing_comma, indent)
+        inline = "#{open}#{strs.join(', ')}#{close}"
+        if trailing_comma || too_long?(inline, indent)
+          inner = strs.map { "#{it.then(&and_indent(indent + 1))}," }.join("\n")
+          "#{INDENT * indent}#{open}\n#{inner}\n#{INDENT * indent}#{close}"
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+
+      def format_pattern(node, source: nil)
+        Pattern.format(node, source:)
+      end
+
+      def format_type(node)
+        Type.format(node)
+      end
+
+      def format_type_atom(node)
+        Type.format_atom(node)
+      end
+
+      def format_exposing(node, indent: 0)
+        Exposing.format(node, indent:)
+      end
+    end
+  end
+end

data/lib/jade/formatter/if_then_else.rb

@@ -0,0 +1,64 @@
+module Jade
+  module Formatter
+    module IfThenElse
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::IfThenElse(condition:, if_branch:, else_branch:)
+
+        cond_str = format_node(condition, source:)
+        try_inline_ternary(cond_str, if_branch, else_branch, indent, source:) ||
+          format_block(cond_str, if_branch, else_branch, indent, source:)
+      end
+
+      # Returns nil when block form is needed: either branch is multi-
+      # statement / has a leading comment, the combined line is too long,
+      # or either single-expression branch already formats across multiple
+      # lines (e.g. a `|>` ladder).
+      def try_inline_ternary(cond_str, if_branch, else_branch, indent, source:)
+        return nil if block_form?(if_branch, else_branch)
+
+        if_str   = single_branch_expr(if_branch, source:)
+        else_str = single_branch_expr(else_branch, source:)
+        inline   = "#{cond_str} ? #{if_str} : #{else_str}"
+
+        return nil if if_str.include?("\n") || else_str.include?("\n")
+        return nil if too_long?(inline, indent)
+
+        inline.then(&and_indent(indent))
+      end
+
+      def format_block(cond_str, if_branch, else_branch, indent, source:)
+        [
+          "if #{cond_str} then".then(&and_indent(indent)),
+          format_node(if_branch, indent: indent + 1, source:),
+          "else".then(&and_indent(indent)),
+          format_node(else_branch, indent: indent + 1, source:),
+          "end".then(&and_indent(indent)),
+        ].join("\n")
+      end
+
+      # Block form needed whenever a branch has more than one expression
+      # or a leading comment that the ternary form would drop.
+      def block_form?(if_branch, else_branch)
+        multi?(if_branch) || multi?(else_branch)
+      end
+
+      def multi?(body)
+        body.expressions.length > 1 ||
+          !body.leading_comments.empty? ||
+          !body.expressions.first.leading_comments.empty?
+      end
+
+      # Format a body known to hold a single expression with no leading
+      # comments. Called only after `block_form?` is false — the raise is
+      # an invariant guard, not a user-facing error.
+      def single_branch_expr(body, source:)
+        raise "formatter invariant: single-expr body expected" if multi?(body)
+
+        format_node(body.expressions.first, source:)
+      end
+    end
+  end
+end

data/lib/jade/formatter/infix_application.rb

@@ -0,0 +1,69 @@
+module Jade
+  module Formatter
+    module InfixApplication
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::InfixApplication(left:, operator:, right:)
+
+        case operator.value
+        when '|>'
+          format_pipe_chain(node, indent, source:)
+        when '++'
+          format_concat_chain(node, indent, source:)
+        else
+          "#{format_node(left, source:)} #{operator.value} #{format_node(right, source:)}"
+            .then(&and_indent(indent))
+        end
+      end
+
+      # `|>` chains of 3 or more arms always render as a ladder; the
+      # vertical shape reads as "transform stage by stage". Two-arm
+      # chains stay inline unless they bust the line budget.
+      def format_pipe_chain(node, indent, source:)
+        chain  = collect_chain(node, '|>')
+        inline = chain.map { format_node(it, source:) }.join(' |> ')
+
+        if chain.length > 2 || too_long?(inline, indent)
+          format_ladder(chain, '|>', indent, source:)
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+
+      # `++` chains stay inline when they fit, ladder when they don't.
+      def format_concat_chain(node, indent, source:)
+        chain  = collect_chain(node, '++')
+        inline = chain.map { format_node(it, source:) }.join(' ++ ')
+
+        if chain.length > 1 && too_long?(inline, indent)
+          format_ladder(chain, '++', indent, source:)
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+
+      # Walk a left-associative chain and return the operands in order
+      # (`a op b op c` → [a, b, c]).
+      def collect_chain(node, op)
+        case node
+        in AST::InfixApplication(left:, operator: AST::InfixOperator(value: ^op), right:)
+          collect_chain(left, op) + [right]
+        else
+          [node]
+        end
+      end
+
+      # Emit a chain ladder: head on its own line, each subsequent
+      # operand prefixed by `op` indented one level deeper.
+      def format_ladder(chain, op, indent, source:)
+        cont = INDENT * (indent + 1)
+        head = format_node(chain.first, indent:, source:)
+        tail = chain[1..].map { "#{cont}#{op} #{format_node(it, source:)}" }
+
+        ([head] + tail).join("\n")
+      end
+    end
+  end
+end

data/lib/jade/formatter/lambda.rb

@@ -0,0 +1,50 @@
+module Jade
+  module Formatter
+    module Lambda
+      extend self
+      extend Helper
+
+      # Atoms (and a few near-atoms) that read fine on a single line
+      # next to the lambda head. Everything else forces the multi-line
+      # `{ body }` shape.
+      INLINE_BODY = [
+        AST::Literal, AST::CharLiteral, AST::VariableReference,
+        AST::ConstructorReference, AST::FunctionCall, AST::RecordAccess,
+        AST::MemberAccess, AST::InfixApplication, AST::RecordLiteral,
+        AST::List, AST::Tuple, AST::Grouping, AST::RecordUpdate,
+        AST::RecordUpdateSugar, AST::RecordAccessSugar,
+      ].freeze
+
+      def format(node, indent:, source:)
+        node => AST::Lambda(params:, body:)
+
+        head = format_head(params)
+
+        if inline_body?(body)
+          "#{head} { #{format_node(body.expressions.first, source:)} }"
+            .then(&and_indent(indent))
+        else
+          [
+            "#{head} {".then(&and_indent(indent)),
+            format_node(body, indent: indent + 1, source:),
+            "}".then(&and_indent(indent)),
+          ].join("\n")
+        end
+      end
+
+      def format_head(params)
+        return "->" if params.empty?
+
+        params
+          .map { format_pattern(it) }
+          .join(', ')
+          .then { "(#{it}) ->" }
+      end
+
+      def inline_body?(body)
+        body.expressions.length == 1 &&
+          INLINE_BODY.any? { body.expressions.first.is_a?(it) }
+      end
+    end
+  end
+end

data/lib/jade/formatter/leaves.rb

@@ -0,0 +1,111 @@
+module Jade
+  module Formatter
+    # Simple leaf nodes: each is at most a one-liner of formatting logic.
+    # Grouped here so the per-node directory doesn't drown in trivia.
+
+    module VariableReference
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node.name.then(&and_indent(indent))
+      end
+    end
+
+    module ConstructorReference
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node.name.then(&and_indent(indent))
+      end
+    end
+
+    module CharLiteral
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "'#{node.value}'".then(&and_indent(indent))
+      end
+    end
+
+    module Literal
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        case node.value
+        in Integer | Float then node.value.to_s
+        in TrueClass       then "True"
+        in FalseClass      then "False"
+        in String          then node.value.inspect
+        end
+          .then(&and_indent(indent))
+      end
+    end
+
+    module Placeholder
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "_".then(&and_indent(indent))
+      end
+    end
+
+    module RecordAccessSugar
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        ".#{node.field_key}".then(&and_indent(indent))
+      end
+    end
+
+    module RecordUpdateSugar
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        ".#{node.field_key}=".then(&and_indent(indent))
+      end
+    end
+
+    module Grouping
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "(#{format_node(node.expression, source:)})".then(&and_indent(indent))
+      end
+    end
+
+    module FunctionDeclarationParam
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "#{node.name}: #{format_type(node.type)}"
+      end
+    end
+
+    module InteropFunction
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "#{node.name} : #{format_type(node.type)}"
+      end
+    end
+
+    module InterfaceFunctionDecl
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "#{node.name} : #{format_type(node.type)}".then(&and_indent(indent))
+      end
+    end
+  end
+end

data/lib/jade/formatter/module_node.rb

@@ -0,0 +1,26 @@
+module Jade
+  module Formatter
+    module ModuleNode
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::Module(name:, exposing:, body:)
+
+        chunks = body.expressions
+          .chunk_while { |a, b|
+            (a in AST::ImportDeclaration) && (b in AST::ImportDeclaration)
+          }
+          .map { |group|
+            group.map { format_node(it, indent:, source:) }.join("\n")
+          }
+
+        header = "module #{name} #{format_exposing(exposing)}"
+        # Two blank lines between top-level chunks so def-to-def boundaries
+        # don't blur with blank lines inside a def body. Module header to
+        # the first chunk stays one blank line.
+        chunks.empty? ? header : "#{header}\n\n#{chunks.join("\n\n\n")}"
+      end
+    end
+  end
+end

data/lib/jade/formatter/pattern.rb

@@ -0,0 +1,61 @@
+module Jade
+  module Formatter
+    module Pattern
+      extend self
+      extend Helper
+
+      def format(node, source: nil)
+        case node
+        in AST::Pattern::Wildcard
+          "_"
+
+        in AST::Pattern::Literal(literal:)
+          format_node(literal, source:)
+
+        in AST::Pattern::Binding(name:)
+          name
+
+        in AST::Pattern::Constructor(constructor:, patterns:)
+          name = format_node(constructor, source:)
+
+          if patterns.nil? || patterns.empty?
+            name
+          else
+            patterns
+              .map { format(it) }
+              .join(', ')
+              .then { "#{name}(#{it})" }
+          end
+
+        in AST::Pattern::Record(fields:)
+          fields
+            .map { format(it) }
+            .join(", ")
+            .then { "{ #{it} }" }
+
+        in AST::Pattern::RecordField(name:, pattern: AST::Pattern::Binding(name: ^name))
+          "#{name}:"
+
+        in AST::Pattern::RecordField(name:, pattern:)
+          "#{name}: #{format(pattern)}"
+
+        in AST::Pattern::Tuple(patterns:)
+          patterns
+            .map { format(it) }
+            .join(', ')
+            .then { "(#{it})" }
+
+        in AST::Pattern::List(patterns:, rest:)
+          heads = patterns.map { format(it) }.join(', ')
+          tail = case rest
+            in AST::Pattern::Binding(name:) then " | #{name}"
+            in AST::Pattern::Wildcard       then " | _"
+            in nil                          then ""
+            end
+
+          "[#{heads}#{tail}]"
+        end
+      end
+    end
+  end
+end

data/lib/jade/formatter/type.rb

@@ -0,0 +1,67 @@
+module Jade
+  module Formatter
+    module Type
+      extend self
+      extend Helper
+
+      def format(node)
+        case node
+        in AST::TypeName(type:)
+          type
+
+        in AST::QualifiedTypeName(path:)
+          path.join(".")
+
+        in AST::TypeVar(type:)
+          type
+
+        in AST::TypeApplication(constructor:, args:)
+          if args.empty?
+            format(constructor)
+          else
+            args
+              .map { format(it) }
+              .join(', ')
+              .then { "#{format(constructor)}(#{it})" }
+          end
+
+        in AST::TypeFunction(params:, return_type:)
+          params_str = params.empty? ?
+            "()" :
+            params.map { format_atom(it) }.join(', ')
+
+          "#{params_str} -> #{format_atom(return_type)}"
+
+        in AST::TypeRecord(fields:, row_var:)
+          fields_str = fields.map { |k, v| "#{k}: #{format(v)}" }.join(", ")
+          row_prefix = row_var ? "#{row_var.name} | " : ""
+
+          "{ #{row_prefix}#{fields_str} }"
+
+        in AST::TypeTuple(items:)
+          items.map { format(it) }.join(', ').then { "(#{it})" }
+        end
+      end
+
+      # Wrap a function type in `(...)` so nested arrows stay unambiguous —
+      # the type parser only accepts a `type_atom` on either side of `->`.
+      def format_atom(node)
+        node.is_a?(AST::TypeFunction) ? "(#{format(node)})" : format(node)
+      end
+
+      def breakable_record?(type)
+        type.is_a?(AST::TypeRecord) && type.fields.size > 1
+      end
+
+      def format_record_multiline(type, indent)
+        type => AST::TypeRecord(fields:, row_var:)
+        open = row_var ? "{ #{row_var.name} |" : "{"
+        fields_str = fields
+          .map { |k, v| "#{k}: #{format(v)},".then(&and_indent(indent + 1)) }
+          .join("\n")
+
+        "#{open}\n#{fields_str}\n#{INDENT * indent}}"
+      end
+    end
+  end
+end

data/lib/jade/formatter.rb

@@ -0,0 +1,38 @@
+require 'jade/formatter/helper'
+require 'jade/formatter/pattern'
+require 'jade/formatter/type'
+require 'jade/formatter/exposing'
+require 'jade/formatter/leaves'
+require 'jade/formatter/accesses'
+require 'jade/formatter/bindings'
+require 'jade/formatter/calls'
+require 'jade/formatter/collections'
+require 'jade/formatter/declarations'
+require 'jade/formatter/module_node'
+require 'jade/formatter/body'
+require 'jade/formatter/function_declaration'
+require 'jade/formatter/lambda'
+require 'jade/formatter/infix_application'
+require 'jade/formatter/if_then_else'
+require 'jade/formatter/case_of'
+require 'jade/formatter/case_of_branch'
+
+module Jade
+  module Formatter
+    extend self
+    extend Helper
+
+    # Constants live at the top-level module so unqualified references
+    # resolve via Ruby's lexical-scope constant lookup from any nested
+    # per-node module (which only `extend`s Helper — `extend` doesn't
+    # bring constants in).
+    INDENT     = "  "
+    LINE_LIMIT = 80
+
+    def format(node, comments:, source:, indent: 0)
+      Frontend::CommentAttacher
+        .attach(node, comments, source)
+        .then { format_node(it, indent:, source:) }
+    end
+  end
+end