jade-lang 0.8.0 → 0.10.0

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

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

@@ -5,12 +5,11 @@ module Jade
         def self.wildcard(types)
           types
             .map { Wildcard[] }
-            .then { [it] }
-            .then { Matrix[it, types] }
+            .then { Matrix[[it], types] }
         end
 
         def self.empty(types = [])
-          self.new([], types)
+          Matrix[[], types]
         end
 
         def map
@@ -19,248 +18,58 @@ module Jade
             .then { with(rows: it) }
         end
 
-        def include?(row)
-          rows.include?(row)
-        end
-
-        def size
-          rows.size
-        end
-
         def empty?
           rows.empty?
         end
 
-        def any?
-          rows.any?
-        end
-
         def concat(other)
           with(rows: rows + other.rows)
         end
 
-        def missing_patterns(env)
-          if types.empty?
-            return rows.empty? ? Matrix[[[]], types] : Matrix.empty
-          end
-
-          type = types.first
-
-          return Matrix.empty if never?(type)
-          return Matrix.wildcard(types) if rows.empty?
-
-          heads = head_constructors
-
-          if infinite?(type) || type_var?(type)
-            unmatched_column(env)
-
-          elsif expandable?(type, env)
-            expand(env).missing_patterns(env)
-
-          elsif heads.empty?
-            unmatched_column(env)
-
-          else
-            constructors_of(type, env)
-              .reduce(Matrix.empty.with(types:)) do |acc, constructor|
-                witnesses(constructor, env, heads.include?(constructor.name))
-                  .then { acc.concat(it) }
-              end
-          end
+        def heads
+          rows.map(&:first)
         end
 
-        protected
-
-        # Nothing in this column narrows anything — a type with no constructors
-        # to enumerate, or one every row left open. Whatever is missing lives in
-        # the columns after it.
-        def unmatched_column(env)
-          default
-            .missing_patterns(env)
-            .map { [Wildcard[]] + it }
-        end
-
-        # A constructor the first column matches is explored by specializing on
-        # it. One it never matches can only be missing as a whole, so its
-        # witnesses come from the rows that would have covered it — the ones
-        # headed by a wildcard. Recursing there instead of into the constructor
-        # is what keeps a recursive type from expanding forever.
-        def witnesses(constructor, env, matched)
-          return Matrix.empty if constructor.args.any? { never?(it) }
-
-          arity = constructor.args.size
-
-          if matched
-            specialize(constructor)
-              .missing_patterns(env)
-              .map { [Constructor[constructor.name, it.take(arity)]] + it.drop(arity) }
-
-          else
-            default
-              .missing_patterns(env)
-              .map { [Constructor[constructor.name, Array.new(arity) { Wildcard[] }]] + it }
-          end
-        end
-
-        def head_constructors
-          rows.filter_map { head_constructor(it.first) }
-        end
-
-        def head_constructor(pattern)
-          case pattern
-          in Constructor(constructor: name) then name
-          in Literal(value: true) then 'Basics.True'
-          in Literal(value: false) then 'Basics.False'
-          in Literal | Record | Wildcard then nil
-          end
-        end
-
-        def expandable?(type, env)
-          case type
-          in Type::AnonymousRecord
-            true
-
-          in Type::Application(constructor:)
-            env.lookup_def(constructor.name).is_a?(TypeChecking::StructDef)
-
-          else
-            false
-          end
-        end
-
-        def expand(env)
-          type_fields = 
-            case types.first
-            in Type::AnonymousRecord(fields:)
-              fields
-
-            in Type::Application(constructor:)
-              env.lookup_def(constructor.name).body.fields
-            end
-
-          map do |row|
-            case row.first
-            in Record(fields:)
-              type_fields
-                .map do |(k, v)|
-                  fields[k] || Wildcard[]
-                end + row.drop(1)
-
-            in Wildcard
-              type_fields.map { Wildcard[] } + row.drop(1)
-            end
-          end
-            .with(types: type_fields.values + types.drop(1))
-        end
-
-        def constructors_of(type, env)
-          case type
-          in Type::Application(constructor: Type::Constructor(name: 'Basics.Bool'))
-            [
-              TypeChecking::ConstructorDef['Basics.True', 'Basics.Bool', []],
-              TypeChecking::ConstructorDef['Basics.False', 'Basics.Bool', []],
-            ]
-          in Type::Application(constructor: Type::Constructor(name: /^Tuple\.Tuple[2-4]$/ => name), args:)
-            [TypeChecking::Definition.constructor(name, name, args)]
-
-          in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [elem_type])
-            [
-              TypeChecking::ConstructorDef['List.Nil',  'List.List', []],
-              TypeChecking::ConstructorDef['List.Cons', 'List.List', [elem_type, type]],
-            ]
-
-          else
-            type_def = env.lookup_def(type.constructor.name)
-
-            # Type the user can't destructure from here (transitively reached
-            # through an imported struct field, or opaque intrinsic) —
-            # any pattern they can write is trivially exhaustive.
-            return [] if type_def.nil? || type_def.opaque?
-
-            type_def
-              .constructors
-              .map do |con|
-                con
-                  .args
-                  .map do |arg|
-                    if type_var?(arg)
-                      type_def
-                        .type_params
-                        .find_index { arg.name == it.name }
-                        .then { type.args.at(it) }
-
-                    else
-                      arg
-                    end
-                  end
-                .then { con.with(args: it) }
-              end
-          end
-        end
-
-        def specialize(constructor)
+        # Rows the case can match, each opened up into the columns the case
+        # carries. A row headed by a wildcard matches every case, and says
+        # nothing about the columns it opens.
+        def specialize(kase)
           rows
-            .filter_map do |cols|
-              case cols.first
-              in Literal(value:)
-                next [] + cols.drop(1) if value == false && "Basics.False" == constructor.name
-                next [] + cols.drop(1) if value == true && "Basics.True" == constructor.name
-
-              in Constructor(constructor: cons_name, args:)
-                args + cols.drop(1) if cons_name == constructor.name
-
-              in Wildcard
-                constructor.args.map { Wildcard[] } + cols.drop(1)
+            .filter_map do |row|
+              head = row.first
 
+              if kase.matches?(head)
+                head.args + row.drop(1)
+              elsif head.wildcard?
+                Array.new(kase.arity) { Wildcard[] } + row.drop(1)
               end
             end
-            .then { with(rows: it) }
-            .then { it.with(types: constructor.args + types.drop(1)) }
+            .then { Matrix[it, kase.arg_types + types.drop(1)] }
         end
 
+        # The rows that survive when the first column is decided by no case at
+        # all — only the ones that were not asking about it.
         def default
           rows
             .select { it.first.wildcard? }
             .map { it.drop(1) }
-            .then { with(rows: it) }
-            .with(types: types.drop(1))
+            .then { Matrix[it, types.drop(1)] }
         end
 
-        def add(columns)
-          with(rows: rows.concat(columns))
-        end
-
-        private
-
-        def never?(type)
-          case type
-          in Type::Application(constructor: Type::Constructor(name: 'Basics.Never'))
-            true
-          else
-            false
-          end
-        end
+        def expand(env)
+          fields = Signature.fields(types.first, env)
 
-        def type_var?(type)
-          type.is_a?(Type::Var)
+          map { |row| expand_row(row, fields) }
+            .with(types: fields.values + types.drop(1))
         end
 
-        def infinite?(type)
-          case type
-          in Type::Function
-            true
-
-          in Type::Application(constructor:)
-            case constructor
-            in Type::Constructor(name: 'Basics.Int') then true
-            in Type::Constructor(name: 'Basics.Float') then true
-            in Type::Constructor(name: 'String.String') then true
-            else
-              false
-            end
+        def expand_row(row, fields)
+          case row.first
+          in Record(fields: matched)
+            fields.keys.map { matched[it] || Wildcard[] } + row.drop(1)
 
-          else
-            false
+          in Wildcard
+            fields.keys.map { Wildcard[] } + row.drop(1)
           end
         end
       end

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

@@ -0,0 +1,132 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      Wildcard = Data.define do
+        def wildcard?
+          true
+        end
+
+        def args
+          []
+        end
+
+        def to_s
+          '_'
+        end
+      end
+
+      Literal = Data.define(:value) do
+        def wildcard?
+          false
+        end
+
+        def args
+          []
+        end
+
+        def to_s
+          value.inspect
+        end
+      end
+
+      Constructor = Data.define(:constructor, :args) do
+        def wildcard?
+          false
+        end
+
+        def to_s
+          if constructor.start_with?('Tuple.')
+            "(#{args.map(&:to_s).join(', ')})"
+          else
+            name = constructor.split('.').last
+            args.empty? ? name : "#{name}(#{args.map(&:to_s).join(', ')})"
+          end
+        end
+      end
+
+      Record = Data.define(:fields) do
+        def wildcard?
+          false
+        end
+
+        def args
+          []
+        end
+
+        def to_s
+          fields
+            .map { |k, v| "#{k}: #{v}" }
+            .join(', ')
+            .then { "{ #{it} }" }
+        end
+      end
+
+      # An inclusive span of integers. A nil bound is unbounded on that side.
+      Interval = Data.define(:from, :to) do
+        def wildcard?
+          false
+        end
+
+        def args
+          []
+        end
+
+        def covers?(other)
+          (from.nil? || (other.from && other.from >= from)) &&
+            (to.nil? || (other.to && other.to <= to))
+        end
+
+        def to_s
+          case [from, to]
+          in [nil, nil] then '_'
+          in [n, ^n] then n.to_s
+          else "#{from}..#{to}"
+          end
+        end
+      end
+
+      module Pattern
+        extend self
+
+        def from_node(node)
+          case node
+          in AST::Pattern::Record(fields:)
+            fields
+              .to_h { [it.name, from_node(it.pattern)] }
+              .then { Record[it] }
+
+          in AST::Pattern::Constructor(constructor:, patterns:)
+            patterns
+              .map { from_node(it) }
+              .then { Constructor[constructor.symbol.qualified_name, it] }
+
+          # `[x, y | xs]` and `[x, y]` are the same Cons/Nil spine the checker
+          # already knows how to split.
+          in AST::Pattern::List(patterns:, rest:)
+            patterns
+              .map { from_node(it) }
+              .reverse
+              .reduce(rest ? Wildcard[] : Constructor['List.Nil', []]) do |acc, head|
+                Constructor['List.Cons', [head, acc]]
+              end
+
+          in AST::Pattern::Range(from:, to:)
+            Interval[from&.value, to&.value]
+
+          in AST::Pattern::Binding | AST::Pattern::Wildcard
+            Wildcard[]
+
+          in AST::Pattern::Literal(literal: { value: true })
+            Constructor['Basics.True', []]
+
+          in AST::Pattern::Literal(literal: { value: false })
+            Constructor['Basics.False', []]
+
+          in AST::Pattern::Literal(literal: { value: })
+            Literal[value]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      module Redundancy
+        extend self
+
+        def assert(patterns, env, expected)
+          rows = patterns.map { [Pattern.from_node(it)] }
+
+          rows
+            .each_with_index
+            .filter_map do |row, index|
+              above = Matrix[rows.take(index), [expected]]
+
+              next if Usefulness.useful?(above, row, env)
+
+              TypeChecking::Error::UnreachableBranch
+                .new(env.entry_name, patterns[index].range)
+            end
+        end
+      end
+    end
+  end
+end