jade-lang 0.9.0 → 0.10.0

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'

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

@@ -10,6 +10,64 @@ module Jade
           ForwardDeclaration.deep_declare_node(ast, entry, registry)
         end
 
+        # Only the shallow pass still has the declaration being replaced;
+        # by the deep pass the entry holds the winner alone. The deep pass
+        # keeps its kind check to bail out, not to report.
+        def duplicate_type_error(entry, name, span, declaring:)
+          entry.defined_types[name].then do |existing|
+            next nil if existing.nil? || existing.decl_span == span
+
+            Error::DuplicateTypeName.new(
+              entry.name,
+              span,
+              name,
+              declaring:,
+              existing: Error::DuplicateTypeName.kind_of(existing),
+              first_span: existing.decl_span,
+            )
+          end
+        end
+
+        # A constructor is named without its type, so one module cannot hold
+        # two of a name — a union's variant and a struct both define one, and
+        # the second shadows the first. `introduced` is what this declaration
+        # is about to define, each with the span to point at.
+        def duplicate_constructor_errors(entry, name, introduced, declaring:)
+          declared_constructors(entry).then do |seen|
+            introduced.filter_map { duplicate_constructor_error(entry, name, it, seen, declaring) }
+          end
+        end
+
+        def declared_constructors(entry)
+          entry
+            .defined_types
+            .values
+            .flat_map do |symbol|
+              case symbol
+              in Symbol::Union then symbol.variants.map { [it.name, symbol] }
+              in Symbol::Struct then [[symbol.name, symbol]]
+              else []
+              end
+            end
+            .to_h
+        end
+
+        def duplicate_constructor_error(entry, name, (constructor, span), seen, declaring)
+          seen[constructor].then do |owner|
+            next nil if owner.nil? || owner.name == name
+
+            Error::DuplicateConstructorName.new(
+              entry.name,
+              span,
+              constructor,
+              declaring:,
+              type: name,
+              owner:,
+              first_span: owner.decl_span,
+            )
+          end
+        end
+
         def figure_out_type(entry, node)
           case node
           in AST::TypeVar(type:)

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

@@ -83,6 +83,10 @@ module Jade
         end
 
         def handling_exposing_type_expansion(type, name, span, current_entry, importing_module)
+          if importing_module.types[name].is_a?(Symbol::Alias)
+            return Err[Error::AliasExpansion.new(current_entry.name, span, name:)]
+          end
+
           importing_module
             .exposed_type_variants(name)
             .then  do |variants|

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

@@ -8,6 +8,9 @@ module Jade
         def shallow(node, _registry, entry)
           node => AST::InterfaceDeclaration(name:, type_param:, functions:)
 
+          duplicate_type_error(entry, name, node.range, declaring: 'an interface')
+            .then { return Result[entry, [it]] if it }
+
           interface_ref = Symbol.type_ref(entry.name, name)
           type_var = Symbol.var(type_param.name, type_param.range)
 
@@ -28,6 +31,9 @@ module Jade
           node => AST::InterfaceDeclaration(name:, functions:)
 
           symbol = entry.lookup_type(name)
+
+          return Result[entry, []] unless symbol.is_a?(Symbol::Interface)
+
           interface_ref = symbol.to_ref
 
           functions

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

@@ -71,6 +71,10 @@ module Jade
             ]
           end
 
+          if symbol.is_a?(Symbol::Alias)
+            return Result[entry, [Error::AliasExpansion.new(entry.name, span, name:)]]
+          end
+
           symbol
             .constructor_refs
             .reduce(entry) { |acc, ctor| acc.expose(ctor.to_ref) }

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

@@ -8,11 +8,18 @@ module Jade
         def shallow(node, registry, entry)
           node => AST::StructDeclaration(name:, type_params:)
 
+          duplicate_type_error(entry, name, node.range, declaring: 'a struct')
+            .then { return Result[entry, [it]] if it }
+
+          # The struct is still declared, so a signature naming it does not
+          # report a second, misleading error.
+          errors = duplicate_constructor_errors(entry, name, [[name, node.range]], declaring: :struct)
+
           type_params
             .map { Symbol.var(it.name, it.range) }
             .then { Symbol.predeclared_struct(name, it, node.range) }
             .then { entry.define(it) }
-            .then { Result[it, []] }
+            .then { Result[it, errors] }
         end
 
         def deep(node, entry, _)
@@ -20,6 +27,8 @@ module Jade
 
           symbol = entry.lookup_type(name)
 
+          return Result[entry, []] unless symbol.is_a?(Symbol::Struct)
+
           figure_out_type(entry, record_type)
             .map do |record_type_symbol|
               constructor_fn_symbol = Symbol.constructor(

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

@@ -0,0 +1,37 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module TypeAliasDeclaration
+        extend self
+        extend Helper
+
+        def shallow(node, registry, entry)
+          node => AST::TypeAliasDeclaration(name:, type_params:)
+
+          duplicate_type_error(entry, name, node.range, declaring: 'a type alias')
+            .then { return Result[entry, [it]] if it }
+
+          type_params
+            .map { Symbol.var(it.name, it.range) }
+            .then { Symbol.predeclared_alias(name, it, node.range) }
+            .then { entry.define(it) }
+            .then { Result[it, []] }
+        end
+
+        def deep(node, entry, _)
+          node => AST::TypeAliasDeclaration(name:, body_type:)
+
+          symbol = entry.lookup_type(name)
+
+          return Result[entry, []] unless symbol.is_a?(Symbol::Alias)
+
+          figure_out_type(entry, body_type)
+            .map do |body_symbol|
+              entry.define(symbol.with(body: body_symbol))
+            end
+            .then { to_declaration_result(entry, it) }
+        end
+      end
+    end
+  end
+end

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

@@ -8,13 +8,20 @@ module Jade
         def shallow(node, registry, entry)
           node => AST::TypeDeclaration(name:, type_params:, variants:)
 
+          duplicate_type_error(entry, name, node.range, declaring: 'a type')
+            .then { return Result[entry, [it]] if it }
+
+          # The type is still declared, so a signature naming it does not
+          # report a second, misleading error.
+          errors = duplicate_constructor_errors(entry, name, variants.map { [it.name, it.range] }, declaring: :variant)
+
           predeclared_variants = variants
             .map { |var| Symbol.predeclared_constructor(var.name, var.range) }
 
           type_params.map { Symbol.var(it.name, it.range) }
             .then { Symbol.union(name, it, predeclared_variants, node.range) }
             .then { entry.define(it) }
-            .then { Result[it, []] }
+            .then { Result[it, errors] }
         end
 
         def deep(node, entry, _)
@@ -22,6 +29,8 @@ module Jade
 
           symbol = entry.lookup_type(name)
 
+          return Result[entry, []] unless symbol.is_a?(Symbol::Union)
+
           variants
             .map do |var|
               var.args.map { figure_out_type(entry, it) }

data/lib/jade/frontend/forward_declaration.rb

@@ -11,6 +11,7 @@ require 'jade/frontend/forward_declaration/import_declaration'
 require 'jade/frontend/forward_declaration/interop_import_declaration'
 require 'jade/frontend/forward_declaration/module'
 require 'jade/frontend/forward_declaration/struct_declaration'
+require 'jade/frontend/forward_declaration/type_alias_declaration'
 require 'jade/frontend/forward_declaration/type_declaration'
 require 'jade/frontend/forward_declaration/interface_declaration'
 
@@ -60,6 +61,7 @@ module Jade
         in AST::InteropImportDeclaration then InteropImportDeclaration
         in AST::Module then Module
         in AST::StructDeclaration then StructDeclaration
+        in AST::TypeAliasDeclaration then TypeAliasDeclaration
         in AST::TypeDeclaration then TypeDeclaration
         in AST::InterfaceDeclaration then InterfaceDeclaration
         else

data/lib/jade/frontend/pattern_analysis/exhaustiveness.rb

@@ -4,17 +4,58 @@ module Jade
       module Exhaustiveness
         extend self
 
-        def assert(patterns, range, env, registry, expected)
-          Matrix[
-            patterns.map { [node_to_matrix_pattern(it)] },
-            [expected],
-          ]
-            .missing_patterns(env)
+        def assert(patterns, range, env, expected)
+          Matrix[patterns.map { [Pattern.from_node(it)] }, [expected]]
+            .then { Witnesses.missing(it, env) }
+            .then { it.with(rows: coalesced(it.rows)) }
             .then { to_errors(it, range, env) }
         end
 
         private
 
+        # Splitting a column cuts it at every bound any pattern mentions, so
+        # one hole can come back as several touching pieces. Report the hole.
+        def coalesced(rows)
+          joined = rows
+            .combination(2)
+            .lazy
+            .filter_map { |(left, right)| join(left, right)&.then { [left, right, it] } }
+            .first
+
+          return rows if joined.nil?
+
+          joined => [left, right, combined]
+
+          coalesced(rows - [left, right] + [combined])
+        end
+
+        def join(left, right)
+          return if left.size != right.size
+
+          differing = left.each_index.reject { left[it] == right[it] }
+
+          return if differing.size != 1
+
+          index = differing.first
+
+          span(left[index], right[index])
+            &.then { |joined| left.take(index) + [joined] + left.drop(index + 1) }
+        end
+
+        def span(left, right)
+          case [left, right]
+          in [Interval(from:, to: Integer => last), Interval(from: ^(last + 1), to:)]
+            Interval[from, to]
+
+          in [Constructor(constructor: name, args: left_args),
+              Constructor(constructor: ^name, args: right_args)]
+            join(left_args, right_args)&.then { Constructor[name, it] }
+
+          else
+            nil
+          end
+        end
+
         def to_errors(matrix, range, env)
           return [] if matrix.empty?
 
@@ -22,43 +63,6 @@ module Jade
             .new(env.entry_name, range, missing_patterns: matrix.rows)
             .then { [it] }
         end
-
-        def node_to_matrix_pattern(pattern_node)
-          case pattern_node
-          in AST::Pattern::Record(fields:)
-            Record[
-              fields
-                .map(&:name)
-                .zip(fields.map(&:pattern))
-                .to_h
-                .transform_values { node_to_matrix_pattern(it) },
-            ]
-
-          in AST::Pattern::Constructor(constructor:, patterns:)
-            Constructor[
-              constructor.symbol.qualified_name,
-              patterns.map { node_to_matrix_pattern(it) },
-            ]
-
-          in AST::Pattern::List(patterns:, rest:)
-            # Rewrite [x, y | xs] / [x, y] into nested Cons/Nil constructors
-            tail = rest ? Wildcard[] : Constructor['List.Nil', []]
-            patterns
-              .map { node_to_matrix_pattern(it) }
-              .reverse
-              .reduce(tail) { |acc, head| Constructor['List.Cons', [head, acc]] }
-
-          in AST::Pattern::Binding | AST::Pattern::Wildcard
-            Wildcard[]
-
-          in AST::Pattern::Literal(literal: { value:, symbol: })
-            Literal[
-              value,
-              symbol.qualified_name,
-            ]
-
-          end
-        end
       end
     end
   end