jade-lang 0.1.0

data/lib/jade/error.rb

@@ -0,0 +1,72 @@
+require 'jade/did_you_mean'
+
+module Jade
+  class Error
+    attr_reader :entry, :span
+
+    def initialize(entry:, span:, **rest)
+      @entry = entry
+      @span = span
+    end
+
+    def message
+      fail NotImplementedError
+    end
+
+    def label
+      nil
+    end
+
+    def notes
+      []
+    end
+
+    def queried_name
+      nil
+    end
+
+    def candidates
+      []
+    end
+
+    def to_diagnostic(registry = nil, source: nil)
+      source ||=
+        case entry
+        when String then registry&.get(entry)&.source
+        else entry&.source
+        end
+
+      Jade::Diagnostics::Diagnostic.error(
+        message,
+        primary: Jade::Diagnostics::Label[source, span, label],
+        annotations: notes + did_you_mean_notes,
+      )
+    end
+
+    private
+
+    def did_you_mean_notes
+      return [] if queried_name.nil? || candidates.empty?
+
+      Jade::DidYouMean
+        .suggest(queried_name, candidates)
+        .then { it.empty? ? [] : [help_annotation(it)] }
+    end
+
+    def help_annotation(suggestions)
+      Jade::Diagnostics::Annotation[
+        :help,
+        "did you mean #{suggestions.map { "`#{it}`" }.join(' or ')}?",
+      ]
+    end
+
+    def ordinal(n)
+      if (11..13).cover?(n % 100)
+        'th'
+      else
+        %w[th st nd rd th th th th th th][n % 10]
+      end
+        .then { "#{n}#{it}" }
+    end
+  end
+end

data/lib/jade/formatter/accesses.rb

@@ -0,0 +1,37 @@
+module Jade
+  module Formatter
+    # The three `target.member`-style accesses. Each has a slightly
+    # different `.name` shape (member is an Identifier, qualified is a
+    # raw string), but the formatting is `<target>.<rendered name>`.
+
+    module MemberAccess
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "#{format_node(node.target, source:)}.#{node.name.name}"
+          .then(&and_indent(indent))
+      end
+    end
+
+    module QualifiedAccess
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "#{format_node(node.target, source:)}.#{node.name}"
+          .then(&and_indent(indent))
+      end
+    end
+
+    module RecordAccess
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        "#{format_node(node.target, source:)}.#{node.name.name}"
+          .then(&and_indent(indent))
+      end
+    end
+  end
+end

data/lib/jade/formatter/bindings.rb

@@ -0,0 +1,29 @@
+module Jade
+  module Formatter
+    # `name = expr` and `name <- task` — same shape, different operator.
+
+    module Assign
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::Assign(pattern:, expression:)
+
+        "#{format_pattern(pattern)} = #{format_node(expression, source:)}"
+          .then(&and_indent(indent))
+      end
+    end
+
+    module Bind
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::Bind(pattern:, expression:)
+
+        "#{format_pattern(pattern)} <- #{format_node(expression, source:)}"
+          .then(&and_indent(indent))
+      end
+    end
+  end
+end

data/lib/jade/formatter/body.rb

@@ -0,0 +1,50 @@
+module Jade
+  module Formatter
+    module Body
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::Body(expressions:, dangling_comments:)
+
+        if expressions.empty? && !dangling_comments.empty?
+          dangling_comments
+            .map { |tok| "#{INDENT * indent}#{tok.value}" }
+            .join("\n")
+        else
+          join_expressions(expressions, indent, source:)
+        end
+      end
+
+      private
+
+      # Prettier-style: preserve at most one user-written blank line between
+      # adjacent statements. ≥2 newlines in the source slice between them →
+      # join with `\n\n`. Otherwise → `\n`. If we have no source (synthetic
+      # body), fall back to single newline.
+      def join_expressions(expressions, indent, source:)
+        expressions
+          .each_cons(2)
+          .map { |prev, succ| separator_between(prev, succ, source) }
+          .then { [nil, *it] }
+          .zip(expressions)
+          .map { |sep, expr| "#{sep}#{format_node(expr, indent:, source:)}" }
+          .join
+      end
+
+      def separator_between(prev, succ, source)
+        blank_line_between?(prev, succ, source) ? "\n\n" : "\n"
+      end
+
+      def blank_line_between?(prev, succ, source)
+        return false unless source
+
+        slice = source.text[prev.range.end...succ.range.begin] || ""
+        # A blank line means two newlines separated only by whitespace.
+        # `\n  # comment\n  ` has two newlines but content between them
+        # — not a blank line.
+        slice.match?(/\n[ \t]*\n/)
+      end
+    end
+  end
+end

data/lib/jade/formatter/calls.rb

@@ -0,0 +1,51 @@
+module Jade
+  module Formatter
+    # FunctionCall and KeyedCall share the same break-on-too-long /
+    # respect-trailing-comma logic. Grouped here as siblings.
+
+    module FunctionCall
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::FunctionCall(callee:, args:, trailing_comma:)
+
+        callee_str = format_node(callee, source:)
+        args_strs  = args.map { format_node(it, source:) }
+        Calls.render(callee_str, args_strs, trailing_comma, indent)
+      end
+    end
+
+    module KeyedCall
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::KeyedCall(callee:, fields:, trailing_comma:)
+
+        callee_str = format_node(callee, source:)
+        field_strs = fields.map { "#{it.key}: #{format_node(it.value, source:)}" }
+        Calls.render(callee_str, field_strs, trailing_comma, indent)
+      end
+    end
+
+    module Calls
+      extend self
+      extend Helper
+
+      def render(callee_str, item_strs, trailing_comma, indent)
+        inline = "#{callee_str}(#{item_strs.join(', ')})"
+
+        if trailing_comma || too_long?(inline, indent)
+          inner = item_strs
+            .map { "#{it.then(&and_indent(indent + 1))}," }
+            .join("\n")
+
+          "#{callee_str.then(&and_indent(indent))}(\n#{inner}\n#{INDENT * indent})"
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+    end
+  end
+end

data/lib/jade/formatter/case_of.rb

@@ -0,0 +1,31 @@
+module Jade
+  module Formatter
+    module CaseOf
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::CaseOf(expression:, branches:)
+
+        branches_str = branches
+          .map.with_index { |b, i| format_branch(b, branches, i, indent, source:) }
+          .join("\n")
+
+        [
+          "case #{format_node(expression, source:)}".then(&and_indent(indent)),
+          branches_str,
+          "end".then(&and_indent(indent)),
+        ].join("\n")
+      end
+
+      # The last branch is rendered as `else` when its pattern is a
+      # wildcard — purely sugar; the AST shape is the same.
+      def format_branch(branch, all_branches, i, indent, source:)
+        last_wildcard = i == all_branches.length - 1 &&
+          branch.pattern.is_a?(AST::Pattern::Wildcard)
+
+        CaseOfBranch.format(branch, indent:, source:, as_else: last_wildcard)
+      end
+    end
+  end
+end

data/lib/jade/formatter/case_of_branch.rb

@@ -0,0 +1,59 @@
+module Jade
+  module Formatter
+    # CaseOfBranch is invoked from CaseOf with an extra `as_else:` flag
+    # — it doesn't go through the generic dispatcher, so its `format`
+    # signature differs from siblings on purpose.
+    module CaseOfBranch
+      extend self
+      extend Helper
+
+      # Three shapes, in order of preference:
+      #   - Single-expression body, fits on one line → `in <pat> then <expr>`
+      #   - Single-expression body, doesn't fit / nested case / has a
+      #     leading comment → `in <pat>\n  <body>` (drop `then`).
+      #   - Multi-statement body → same as above.
+      def format(node, indent:, source:, as_else: false)
+        # `else` already conveys "wildcard inline body" — no `then` after.
+        header     = as_else ? "else" : "in #{format_pattern(node.pattern)}"
+        inline_sep = as_else ? "" : " then"
+        body       = unwrap_grouped_case_body(node.body)
+        first      = body.expressions.first
+        single     = body.expressions.length == 1
+        has_leading = !first.leading_comments.empty? ||
+          !body.leading_comments.empty?
+
+        multi_line = ->(child) {
+          [
+            header.then(&and_indent(indent)),
+            format_node(child, indent: indent + 1, source:),
+          ].join("\n")
+        }
+
+        return multi_line.call(first) if single && first.is_a?(AST::CaseOf)
+        return multi_line.call(body) unless single && !has_leading
+
+        first_str = format_node(first, source:)
+        inline    = "#{header}#{inline_sep} #{first_str}"
+
+        if first_str.include?("\n") || too_long?(inline, indent)
+          multi_line.call(first)
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+
+      # Strip `(case … end)` parens around a branch body. With block-form
+      # `case`, the inner `end` terminates the case, so wrapping parens
+      # are redundant — drop them so reformat normalises both shapes.
+      def unwrap_grouped_case_body(body)
+        return body unless body.expressions.length == 1
+
+        first = body.expressions.first
+        return body unless first.is_a?(AST::Grouping) &&
+          first.expression.is_a?(AST::CaseOf)
+
+        AST::Body.new(expressions: [first.expression], range: body.range)
+      end
+    end
+  end
+end

data/lib/jade/formatter/collections.rb

@@ -0,0 +1,78 @@
+module Jade
+  module Formatter
+    # Tuple / List share the open-sep-close shape (delegated to
+    # `format_delimited`). RecordLiteral / RecordUpdate are similar but
+    # carry field-shaped contents and an open-brace prelude.
+
+    module Tuple
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::Tuple(items:, trailing_comma:)
+
+        format_delimited(
+          items.map { format_node(it, source:) },
+          '(', ')', trailing_comma, indent,
+        )
+      end
+    end
+
+    module List
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::List(items:, trailing_comma:)
+
+        format_delimited(
+          items.map { format_node(it, source:) },
+          '[', ']', trailing_comma, indent,
+        )
+      end
+    end
+
+    module RecordLiteral
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::RecordLiteral(fields:, trailing_comma:)
+
+        field_strs = fields.map { "#{it.key}: #{format_node(it.value, source:)}" }
+        inline     = "{ #{field_strs.join(', ')} }"
+
+        if trailing_comma || too_long?(inline, indent)
+          inner = field_strs
+            .map { "#{it.then(&and_indent(indent + 1))}," }
+            .join("\n")
+          "#{INDENT * indent}{\n#{inner}\n#{INDENT * indent}}"
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+    end
+
+    module RecordUpdate
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::RecordUpdate(base:, fields:, trailing_comma:)
+
+        base_str   = format_node(base, source:)
+        field_strs = fields.map { "#{it.key}: #{format_node(it.value, source:)}" }
+        inline     = "{ #{base_str} | #{field_strs.join(', ')} }"
+
+        if trailing_comma || too_long?(inline, indent)
+          inner = field_strs
+            .map { "#{it.then(&and_indent(indent + 1))}," }
+            .join("\n")
+          "#{INDENT * indent}{ #{base_str} |\n#{inner}\n#{INDENT * indent}}"
+        else
+          inline.then(&and_indent(indent))
+        end
+      end
+    end
+  end
+end

data/lib/jade/formatter/declarations.rb

@@ -0,0 +1,178 @@
+module Jade
+  module Formatter
+    # Top-level declaration nodes other than `def` (which lives in its
+    # own file because of the signature break logic).
+
+    module TypeDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::TypeDeclaration(name:, type_params:, variants:)
+
+        params_str = type_params.empty? ?
+          "" :
+          "(#{type_params.map(&:name).join(', ')})"
+        header = "type #{name}#{params_str}"
+
+        if variants.size == 1
+          "#{header} = #{format_node(variants.first, source:)}"
+            .then(&and_indent(indent))
+        else
+          inner = INDENT * (indent + 1)
+          variants_str = variants
+            .map { format_node(it, source:) }
+            .map.with_index { |v, i| "#{inner}#{i == 0 ? '=' : '|'} #{v}" }
+            .join("\n")
+
+          "#{and_indent(indent).call(header)}\n#{variants_str}"
+        end
+      end
+    end
+
+    module VariantDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::VariantDeclaration(name:, args:)
+
+        case args
+        in nil | []
+          name
+
+        in [AST::TypeRecord(fields:, row_var: nil)]
+          fields
+            .map { |k, v| "#{k}: #{format_type(v)}" }
+            .join(', ')
+            .then { "#{name}(#{it})" }
+
+        else
+          args
+            .map { format_type(it) }
+            .join(', ')
+            .then { "#{name}(#{it})" }
+        end
+      end
+    end
+
+    module StructDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::StructDeclaration(name:, type_params:, record_type:)
+
+        params_str = type_params.empty? ?
+          "" :
+          "(#{type_params.map(&:name).join(', ')})"
+        header = "struct #{name}#{params_str} ="
+
+        record_type => AST::TypeRecord(fields:, row_var:)
+
+        if fields.size > 1
+          format_multiline(header, fields, row_var, indent)
+        else
+          "#{header} #{format_type(record_type)}".then(&and_indent(indent))
+        end
+      end
+
+      def format_multiline(header, fields, row_var, indent)
+        open_brace = row_var ? "{ #{row_var.name} |" : "{"
+        fields_str = fields
+          .map { |k, v| "#{k}: #{format_type(v)}".then(&and_indent(indent + 1)) }
+          .join(",\n")
+
+        and_indent(indent)
+          .call("#{header} #{open_brace}")
+          .then { "#{it}\n#{fields_str}\n#{INDENT * indent}}" }
+      end
+    end
+
+    module ImportDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::ImportDeclaration(module_name:, as:, exposing:)
+
+        parts = ["import #{module_name}"]
+        parts << "as #{as.as}" if as
+        parts << format_exposing(exposing) unless exposing in AST::ExposeNone | nil
+
+        parts.join(' ').then(&and_indent(indent))
+      end
+    end
+
+    module InteropImportDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::InteropImportDeclaration(module: interop_module, functions:)
+
+        funcs_str = functions
+          .map { format_node(it, source:).then(&and_indent(indent + 1)) }
+          .join(",\n")
+
+        [
+          "uses #{interop_module.name} with".then(&and_indent(indent)),
+          funcs_str,
+          "end".then(&and_indent(indent)),
+        ].join("\n")
+      end
+    end
+
+    module InterfaceDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::InterfaceDeclaration(name:, type_param:, functions:)
+
+        fns_str = functions
+          .map { format_node(it, indent: indent + 1, source:) }
+          .join(",\n")
+
+        [
+          "interface #{name}(#{type_param.name}) with".then(&and_indent(indent)),
+          fns_str,
+          "end".then(&and_indent(indent)),
+        ].join("\n")
+      end
+    end
+
+    module Implementation
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::Implementation(interface:, applied_type:, extends:, functions:)
+
+        extends_str = extends.empty? ? "" : " extends #{extends.join(', ')}"
+        header = "implements #{interface}(#{format_type(applied_type)})" \
+          "#{extends_str} with"
+        fns_str = functions
+          .map { format_node(it, indent: indent + 1, source:) }
+          .join(",\n")
+
+        [
+          header.then(&and_indent(indent)),
+          fns_str,
+          "end".then(&and_indent(indent)),
+        ].join("\n")
+      end
+    end
+
+    module ImplementationFunction
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::ImplementationFunction(name:, fn:)
+
+        "#{name}: #{format_node(fn, source:)}".then(&and_indent(indent))
+      end
+    end
+  end
+end

data/lib/jade/formatter/exposing.rb

@@ -0,0 +1,48 @@
+module Jade
+  module Formatter
+    module Exposing
+      extend self
+      extend Helper
+
+      def format(node, indent: 0)
+        case node
+        in AST::ExposeAll
+          "exposing (..)"
+
+        in AST::ExposeNone | nil
+          ""
+
+        in AST::ExposeList(items:, trailing_comma:)
+          item_strs = sort(items).map { format_item(it) }
+          inline    = "exposing (#{item_strs.join(', ')})"
+
+          if trailing_comma || too_long?(inline, indent)
+            inner = item_strs.map { "#{INDENT * (indent + 1)}#{it}," }.join("\n")
+            "exposing (\n#{inner}\n#{INDENT * indent})"
+          else
+            inline
+          end
+        end
+      end
+
+      # Types and constructors first, then values — both alphabetised.
+      def sort(items)
+        items.sort_by do |item|
+          case item
+          in AST::ExposeType | AST::ExposeTypeExpand then [0, item.name]
+          in AST::ExposeValue then [1, item.name]
+          end
+        end
+      end
+
+      def format_item(node)
+        case node
+        in AST::ExposeValue(name:)      then name
+        in AST::ExposeType(name:)       then name
+        in AST::ExposeTypeExpand(name:) then "#{name}(..)"
+        in AST::ExposeAs(as:)           then as
+        end
+      end
+    end
+  end
+end