jade-lang 0.9.0 → 0.10.1

data/lib/jade/formatter/calls.rb

@@ -12,7 +12,10 @@ module Jade
 
         callee_str = format_node(callee, source:)
         args_strs  = args.map { format_node(it, source:) }
-        Calls.render(callee_str, args_strs, trailing_comma, indent)
+
+        Calls::Call[callee_str, args_strs, indent].then do |call|
+          Calls.render(call, trailing_comma, opened_last: Calls.render_open(args.last, source))
+        end
       end
     end
 
@@ -25,7 +28,10 @@ module Jade
 
         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)
+
+        Calls::Call[callee_str, field_strs, indent].then do |call|
+          Calls.render(call, trailing_comma, opened_last: Calls.render_open_field(fields.last, source))
+        end
       end
     end
 
@@ -33,19 +39,70 @@ module Jade
       extend self
       extend Helper
 
-      def render(callee_str, item_strs, trailing_comma, indent)
-        inline = "#{callee_str}(#{item_strs.join(', ')})"
+      # A trailing block-shaped argument reads as the call's body, the way a
+      # Ruby block does. Only these three grow a body worth hugging.
+      HUGGABLE = [AST::Lambda, AST::List, AST::RecordLiteral].freeze
+
+      # A rendered call, before the decision of how to lay it out: the callee,
+      # its already-formatted arguments, and the column they sit at.
+      Call = Data.define(:callee, :items, :indent)
+
+      def huggable?(node)
+        HUGGABLE.any? { node.is_a?(it) }
+      end
+
+      def render_open(node, source)
+        return nil unless huggable?(node)
+
+        dispatch_for(node).format(node, indent: 0, source:, open: true)
+      end
 
-        if trailing_comma || too_long?(inline, indent)
-          inner = item_strs
-            .map { "#{it.then(&and_indent(indent + 1))}," }
-            .join("\n")
+      def render_open_field(field, source)
+        render_open(field&.value, source)&.then { "#{field.key}: #{it}" }
+      end
 
-          "#{callee_str.then(&and_indent(indent))}(\n#{inner}\n#{INDENT * indent})"
-        else
-          inline.then(&and_indent(indent))
+      def render(call, trailing_comma, opened_last: nil)
+        case [trailing_comma, inline(call), opened_last]
+        in [false, String => fits, _] then fits
+        in [false, nil, String => last] then hug_last(call, last) || explode(call)
+        else explode(call)
         end
       end
+
+      private
+
+      def inline(call)
+        "#{call.callee}(#{call.items.join(', ')})"
+          .then { too_long?(it, call.indent) ? nil : it.then(&and_indent(call.indent)) }
+      end
+
+      # An earlier multi-line argument would leave the head straddling lines.
+      def hug_last(call, last)
+        case [call.items[..-2], last.split("\n")]
+        in [[*head], [_]] then nil
+        in [[*head], _] if head.any? { it.include?("\n") } then nil
+        in [[*head], [opener, *rest]]
+          "#{call.callee}(#{(head + [opener]).join(', ')}"
+            .then { too_long?(it, call.indent) ? nil : hug_lines(it, rest, call.indent) }
+        end
+      end
+
+      def hug_lines(opening, rest, indent)
+        [opening, *rest[..-2], "#{rest.last})"]
+          .join("\n")
+          .then(&and_indent(indent))
+      end
+
+      def explode(call)
+        call.items
+          .map { "#{it.then(&and_indent(call.indent + 1))}," }
+          .join("\n")
+          .then { "#{indent_callee(call)}(\n#{it}\n#{INDENT * call.indent})" }
+      end
+
+      def indent_callee(call)
+        call.callee.then(&and_indent(call.indent))
+      end
     end
   end
 end

data/lib/jade/formatter/collections.rb

@@ -22,12 +22,12 @@ module Jade
       extend self
       extend Helper
 
-      def format(node, indent:, source:)
+      def format(node, indent:, source:, open: false)
         node => AST::List(items:, trailing_comma:)
 
         format_delimited(
           items.map { format_node(it, source:) },
-          '[', ']', trailing_comma, indent,
+          '[', ']', trailing_comma || open, indent,
         )
       end
     end
@@ -36,13 +36,13 @@ module Jade
       extend self
       extend Helper
 
-      def format(node, indent:, source:)
+      def format(node, indent:, source:, open: false)
         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)
+        if trailing_comma || open || too_long?(inline, indent)
           inner = field_strs
             .map { "#{it.then(&and_indent(indent + 1))}," }
             .join("\n")

data/lib/jade/formatter/declarations.rb

@@ -68,24 +68,22 @@ module Jade
           "(#{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
+        format_record_declaration(header, record_type, 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")
+    module TypeAliasDeclaration
+      extend self
+      extend Helper
+
+      def format(node, indent:, source:)
+        node => AST::TypeAliasDeclaration(name:, type_params:, body_type:)
+
+        params_str = type_params.empty? ?
+          "" :
+          "(#{type_params.map(&:name).join(', ')})"
 
-        and_indent(indent)
-          .call("#{header} #{open_brace}")
-          .then { "#{it}\n#{fields_str}\n#{INDENT * indent}}" }
+        format_record_declaration("type alias #{name}#{params_str} =", body_type, indent)
       end
     end
 

data/lib/jade/formatter/helper.rb

@@ -30,6 +30,7 @@ module Jade
         in AST::TypeDeclaration              then TypeDeclaration
         in AST::VariantDeclaration           then VariantDeclaration
         in AST::StructDeclaration            then StructDeclaration
+        in AST::TypeAliasDeclaration         then TypeAliasDeclaration
         in AST::ImportDeclaration            then ImportDeclaration
         in AST::InteropImportDeclaration     then InteropImportDeclaration
         in AST::InteropFunction              then InteropFunction
@@ -113,6 +114,25 @@ module Jade
         Pattern.format(node, source:)
       end
 
+      # A record body past one field goes multi-line, so a `type alias` over a
+      # record breaks the same way as the `struct` beside it.
+      def format_record_declaration(header, body, indent)
+        case body
+        in AST::TypeRecord(fields:, row_var:) if fields.size > 1
+          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}}" }
+
+        else
+          "#{header} #{format_type(body)}".then(&and_indent(indent))
+        end
+      end
+
       def format_type(node)
         Type.format(node)
       end

data/lib/jade/formatter/infix_application.rb

@@ -12,6 +12,11 @@ module Jade
           format_pipe_chain(node, indent, source:)
         when '++'
           format_concat_chain(node, indent, source:)
+        # Spelled tight, the way it is in a pattern. `0 .. n` is nobody's
+        # idea of a range.
+        when '..'
+          "#{format_node(left, source:)}..#{format_node(right, source:)}"
+            .then(&and_indent(indent))
         else
           "#{format_node(left, source:)} #{operator.value} #{format_node(right, source:)}"
             .then(&and_indent(indent))
@@ -58,11 +63,21 @@ module Jade
       # 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:)}" }
+        chain[1..]
+          .map { format_node(it, source:) }
+          .map { continued(it, indent + 1) }
+          .map { "#{INDENT * (indent + 1)}#{op} #{it}" }
+          .then { [format_node(chain.first, indent:, source:), *it] }
+          .join("\n")
+      end
 
-        ([head] + tail).join("\n")
+      # What follows an operand's first line belongs under the operator that
+      # introduced it, not at column zero.
+      def continued(operand, indent)
+        operand
+          .split("\n")
+          .then { |(first, *rest)| [first, *rest.map { "#{INDENT * indent}#{it}" }] }
+          .join("\n")
       end
     end
   end

data/lib/jade/formatter/lambda.rb

@@ -15,23 +15,35 @@ module Jade
         AST::RecordUpdateSugar, AST::RecordAccessSugar,
       ].freeze
 
-      def format(node, indent:, source:)
+      def format(node, indent:, source:, open: false)
         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")
+        format_head(params).then do |head|
+          (inline(head, body, indent, source) unless open) || block(head, body, indent, source)
         end
       end
 
+      # An inline body that broke anyway leaves `-> { Expect.equal(` hanging.
+      def inline(head, body, indent, source)
+        return nil unless inline_body?(body)
+
+        body.expressions.first
+          .then { "#{head} { #{format_node(it, source:)} }" }
+          .then { fits?(it, indent) ? it.then(&and_indent(indent)) : nil }
+      end
+
+      def fits?(line, indent)
+        !line.include?("\n") && !too_long?(line, indent)
+      end
+
+      def block(head, body, indent, source)
+        [
+          "#{head} {".then(&and_indent(indent)),
+          format_node(body, indent: indent + 1, source:),
+          "}".then(&and_indent(indent)),
+        ].join("\n")
+      end
+
       def format_head(params)
         return "->" if params.empty?
 

data/lib/jade/formatter/pattern.rb

@@ -12,6 +12,9 @@ module Jade
         in AST::Pattern::Literal(literal:)
           format_node(literal, source:)
 
+        in AST::Pattern::Range(from:, to:)
+          "#{from&.value}..#{to&.value}"
+
         in AST::Pattern::Binding(name:)
           name
 

data/lib/jade/formatter/type.rb

@@ -26,11 +26,9 @@ module Jade
           end
 
         in AST::TypeFunction(params:, return_type:)
-          params_str = params.empty? ?
-            "()" :
-            params.map { format_atom(it) }.join(', ')
-
-          "#{params_str} -> #{format_atom(return_type)}"
+          params
+            .then { it.empty? ? '()' : it.map { |p| format_atom(p) }.join(', ') }
+            .then { "#{it} -> #{format_atom(return_type)}" }
 
         in AST::TypeRecord(fields:, row_var:)
           fields_str = fields.map { |k, v| "#{k}: #{format(v)}" }.join(", ")

data/lib/jade/frontend/desugaring/placeholder.rb

@@ -7,29 +7,52 @@ module Jade
         extend self
         extend Codegen::Helpers
 
-        def lift(call)
-          return call unless call.args.any?(AST::Placeholder)
-
-          filled_args, names = call
-            .args
-            .reduce([[], []]) do |(args, names), arg|
-              case arg
-              in AST::Placeholder
-                param_synthetic_name(names.size)
-                  .then { [args + [AST::VariableReference[it, nil]], names + [it]] }
-
-              else
-                [args + [arg], names]
-              end
+        def lift(node)
+          case node
+          in AST::FunctionCall(args:)
+            fill(node, args) { |filled| node.with(args: filled) }
+
+          in AST::RecordLiteral(fields:)
+            fill(node, fields.map(&:value)) do |filled|
+              fields
+                .zip(filled)
+                .map { |field, value| field.with(value:) }
+                .then { node.with(fields: it) }
+            end
+          end
+        end
+
+        private
+
+        def fill(node, slots, &rebuild)
+          return node unless slots.any?(AST::Placeholder)
+
+          named(slots)
+            .then { |filled, names| [rebuild.call(filled), names] }
+            .then { |body, names| wrap_in_lambdas(body, names, node.range) }
+        end
+
+        def named(slots)
+          slots.reduce([[], []]) do |(filled, names), slot|
+            case slot
+            in AST::Placeholder
+              param_synthetic_name(names.size)
+                .then { [filled + [AST::VariableReference[it, nil]], names + [it]] }
+
+            else
+              [filled + [slot], names]
+            end
           end
+        end
 
+        def wrap_in_lambdas(body, names, range)
           names
             .reverse
-            .reduce(call.with(args: filled_args)) do |body, name|
+            .reduce(body) do |inner, name|
               AST::Lambda[
                 [AST::Pattern::Binding[name, nil]],
-                AST::Body[[body], nil],
-                call.range,
+                AST::Body[[inner], nil],
+                range,
               ]
             end
         end

data/lib/jade/frontend/desugaring.rb

@@ -38,6 +38,20 @@ module Jade
             end
               .then { desugar(it) }
 
+          # There is no `Basics.(..)` to resolve to: the operator's result
+          # type lives in Range, and Basics is loaded before it.
+          in AST::InfixOperator(value: '..')
+            AST::FunctionCall.new(
+              callee: AST::MemberAccess[
+                AST::ConstructorReference['Range', operator.range],
+                AST::VariableReference['between', operator.range],
+                operator.range,
+              ],
+              args: [desugar(left), desugar(right)],
+              infix: operator,
+              range: node.range,
+            )
+
           else
             AST::FunctionCall.new(
               callee: AST::VariableReference["(#{operator.value})", operator.range],
@@ -98,7 +112,10 @@ module Jade
             .with(items: items.map { desugar(it) })
 
         in AST::RecordLiteral(fields:)
-          fields.map { desugar(it) }.then { node.with(fields: it) }
+          fields
+            .map { desugar(it) }
+            .then { node.with(fields: it) }
+            .then { Placeholder.lift(it) }
 
         in AST::RecordUpdate(fields:)
           fields.map { desugar(it) }.then { node.with(fields: it) }
@@ -130,12 +147,14 @@ module Jade
             end
 
         in AST::Tuple(items:)
-          AST::FunctionCall.new(
-            callee: AST::ConstructorReference["Tuple.Tuple#{items.size}", node.range],
-            args: items.map { desugar(it) },
-            infix: false,
-            range: node.range,
-          )
+          AST::FunctionCall
+            .new(
+              callee: AST::ConstructorReference["Tuple.Tuple#{items.size}", node.range],
+              args: items.map { desugar(it) },
+              infix: false,
+              range: node.range,
+            )
+            .then { Placeholder.lift(it) }
 
         in AST::Pattern::Tuple(patterns:)
           AST::ConstructorReference[
@@ -174,9 +193,10 @@ module Jade
         in AST::Literal | AST::CharLiteral | AST::VariableReference | AST::ConstructorReference |
           AST::TypeDeclaration | AST::ImportDeclaration |
           AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard |
+          AST::Pattern::Range |
           AST::Pattern::Record | AST::InteropImportDeclaration | AST::StructDeclaration |
-          AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration |
-          AST::CurriedConstructor
+          AST::TypeAliasDeclaration | AST::QualifiedAccess | AST::Placeholder |
+          AST::InterfaceDeclaration | AST::CurriedConstructor
 
           node
         end

data/lib/jade/frontend/fixity_fixer.rb

@@ -51,6 +51,7 @@ module Jade
         '>=' => Fixity[4, :none],
         '>' => Fixity[4, :none],
         '<' => Fixity[4, :none],
+        '..' => Fixity[5, :none],
         '&&' => Fixity[3, :right],
         '||' => Fixity[2, :right],
       }.freeze
@@ -97,8 +98,9 @@ module Jade
             .then { node.with(target: it) }
 
         in AST::CaseOf(expression:, branches:)
-          branches.map { fix(it) }
-            .then { node.with(branches:, expression: fix(expression)) }
+          branches
+            .map { fix(it) }
+            .then { node.with(branches: it, expression: fix(expression)) }
 
         in AST::CaseOfBranch(body:)
           node.with(body: fix(body))
@@ -146,8 +148,8 @@ module Jade
 
         in AST::VariableReference | AST::ConstructorReference | AST::TypeDeclaration |
           AST::ImportDeclaration | AST::Literal | AST::CharLiteral | AST::RecordAccessSugar | AST::InteropImportDeclaration |
-          AST::StructDeclaration | AST::QualifiedAccess | AST::Placeholder | AST::InterfaceDeclaration |
-          AST::CurriedConstructor |
+          AST::StructDeclaration | AST::TypeAliasDeclaration | AST::QualifiedAccess |
+          AST::Placeholder | AST::InterfaceDeclaration | AST::CurriedConstructor |
           AST::RecordUpdateSugar
 
           node

data/lib/jade/frontend/forward_declaration/error/alias_expansion.rb

@@ -0,0 +1,23 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class AliasExpansion < Jade::Error
+          def initialize(entry, span, name:)
+            @name = name
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@name}` is a type alias, so `(..)` has nothing to expose; " \
+              'an alias names a shape and has no constructors of its own'
+          end
+
+          def label
+            "write `#{@name}` without `(..)`"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/duplicate_constructor_name.rb

@@ -0,0 +1,45 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        # A struct and a union's variant both define a constructor, and a
+        # constructor is named without its type, so one module holds at most
+        # one of a name.
+        class DuplicateConstructorName < Jade::Error
+          def initialize(entry, span, name, declaring:, type:, owner:, first_span: nil)
+            @name = name
+            @declaring = declaring
+            @type = type
+            @owner = owner
+            @first_span = first_span
+            super(entry:, span:)
+          end
+
+          def message
+            case @owner
+            in Symbol::Struct then "`#{@name}` is already a struct in this module"
+            in Symbol::Union then "`#{@name}` is already a constructor of `#{@owner.name}`"
+            end
+          end
+
+          def label
+            case @declaring
+            in :variant then "`#{@type}` cannot also declare `#{@name}`"
+            in :struct then "cannot declare a struct `#{@name}`"
+            end
+          end
+
+          def secondary
+            return [] unless @first_span
+
+            [[@first_span, 'first declared here']]
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[:help, 'rename one of them']]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error/duplicate_type_name.rb

@@ -0,0 +1,42 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class DuplicateTypeName < Jade::Error
+          KINDS = {
+            Symbol::Interface => 'an interface',
+            Symbol::Union => 'a type',
+            Symbol::Struct => 'a struct',
+            Symbol::Alias => 'a type alias',
+          }.freeze
+
+          def self.kind_of(symbol)
+            KINDS.fetch(symbol.class)
+          end
+
+          def initialize(entry, span, name, declaring:, existing:, first_span: nil)
+            @name = name
+            @declaring = declaring
+            @existing = existing
+            @first_span = first_span
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@name}` is already declared as #{@existing} in this module"
+          end
+
+          def label
+            "cannot declare #{@declaring} `#{@name}`"
+          end
+
+          def secondary
+            return [] unless @first_span
+
+            [[@first_span, 'first declared here']]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/forward_declaration/error.rb

@@ -1,6 +1,9 @@
 require 'jade/error'
 
 require 'jade/frontend/forward_declaration/error/bad_import'
+require 'jade/frontend/forward_declaration/error/alias_expansion'
+require 'jade/frontend/forward_declaration/error/duplicate_constructor_name'
+require 'jade/frontend/forward_declaration/error/duplicate_type_name'
 require 'jade/frontend/forward_declaration/error/exposed_type_not_found'
 require 'jade/frontend/forward_declaration/error/exposed_value_not_found'
 require 'jade/frontend/forward_declaration/error/module_not_found'