jade-lang 0.9.0 → 0.10.0

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

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

@@ -0,0 +1,220 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      # One shape a column's first pattern can take. `arg_types` are the
+      # columns it opens up when a row is specialized on it.
+      ConstructorCase = Data.define(:name, :arg_types) do
+        def arity
+          arg_types.size
+        end
+
+        def matches?(pattern)
+          pattern in Constructor(constructor: ^(name))
+        end
+
+        def witness(args)
+          Constructor[name, args]
+        end
+      end
+
+      # A literal the rows mention. Types whose values are literals have no
+      # enumerable set of these, so one is only ever split on because some row
+      # asked for it by name.
+      ValueCase = Data.define(:value) do
+        def name
+          value
+        end
+
+        def arity
+          0
+        end
+
+        def arg_types
+          []
+        end
+
+        def matches?(pattern)
+          pattern in Literal(value: ^(value))
+        end
+
+        def witness(_args)
+          Literal[value]
+        end
+      end
+
+      # A stretch of the integer line no pattern in the column divides any
+      # further, so it is either wholly matched or wholly missed.
+      IntervalCase = Data.define(:from, :to) do
+        def arity
+          0
+        end
+
+        def arg_types
+          []
+        end
+
+        def matches?(pattern)
+          case pattern
+          in Interval then pattern.covers?(self)
+          in Literal(value: Integer => n) then n == from && n == to
+          else false
+          end
+        end
+
+        def witness(_args)
+          Interval[from, to]
+        end
+      end
+
+      # The cases a column of a given type can be split into, and whether they
+      # account for every value of that type. When they don't, a row headed by
+      # a wildcard covers ground no case names, so the column cannot be
+      # decided by splitting alone.
+      Split = Data.define(:cases, :total) do
+        def covering(head)
+          cases.select { it.matches?(head) }
+        end
+
+        def touched_by?(heads)
+          cases.any? { |kase| heads.any? { kase.matches?(it) } }
+        end
+
+        def covered_by?(heads)
+          total && cases.any? &&
+            cases.all? { |kase| heads.any? { kase.matches?(it) } }
+        end
+      end
+
+      module Signature
+        extend self
+
+        UNIT = Split[[], true]
+        OPEN = Split[[], false]
+
+        def of(type, heads, env)
+          case type
+          in Type::Application(constructor: Type::Constructor(name:), args:)
+            named(type, name, args, heads, env)
+
+          else
+            OPEN
+          end
+        end
+
+        # No value of this type exists, so no row over it can be reached and
+        # nothing about it can be missing.
+        def uninhabited?(type)
+          name_of(type) == 'Basics.Never'
+        end
+
+        # A single-shape type is destructured into its fields rather than split
+        # into cases, so the columns behind it stay checkable.
+        def expandable?(type, env)
+          return true if type in Type::AnonymousRecord
+
+          env.lookup_def(name_of(type)).is_a?(TypeChecking::StructDef)
+        end
+
+        def fields(type, env)
+          case type
+          in Type::AnonymousRecord(fields:) then fields
+          else env.lookup_def(name_of(type)).body.fields
+          end
+        end
+
+        private
+
+        def name_of(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name:)) then name
+          else nil
+          end
+        end
+
+        def named(type, name, args, heads, env)
+          case name
+          in 'Basics.Bool'
+            Split[
+              [ConstructorCase['Basics.True', []], ConstructorCase['Basics.False', []]],
+              true,
+            ]
+
+          in /^Tuple\.Tuple[2-4]$/
+            Split[[ConstructorCase[name, args]], true]
+
+          in 'List.List'
+            args => [element]
+
+            Split[
+              [
+                ConstructorCase['List.Nil', []],
+                ConstructorCase['List.Cons', [element, type]],
+              ],
+              true,
+            ]
+
+          in 'Basics.Int'
+            integers(heads)
+
+          in 'Basics.Float' | 'String.String'
+            OPEN
+
+          else
+            union(type, name, env)
+          end
+        end
+
+        # Every bound in the column cuts the line in two, and the pieces
+        # between consecutive cuts are the coarsest split that still lets each
+        # pattern be answered whole. The pieces partition Int, so the result is
+        # total even though Int cannot be enumerated: a stretch no pattern
+        # names comes back as a gap rather than as an open column.
+        def integers(heads)
+          cuts = heads.flat_map { cuts_of(it) }.compact.uniq.sort
+
+          return OPEN if cuts.empty?
+
+          [nil, *cuts]
+            .zip([*cuts.map { it - 1 }, nil])
+            .map { |(from, to)| IntervalCase[from, to] }
+            .then { Split[it, true] }
+        end
+
+        def cuts_of(head)
+          case head
+          in Interval(from: Integer | nil => from, to: Integer | nil => to)
+            [from, to && to + 1]
+          in Literal(value: Integer => n) then [n, n + 1]
+          else []
+          end
+        end
+
+        def union(type, name, env)
+          type_def = env.lookup_def(name)
+
+          # A type the user cannot destructure from here — reached through an
+          # imported struct's field, or an opaque intrinsic. Any pattern they
+          # can write against it is trivially exhaustive.
+          return UNIT if type_def.nil? || type_def.opaque?
+          return OPEN unless type_def.is_a?(TypeChecking::TypeDef)
+
+          type_def
+            .constructors
+            .map { ConstructorCase[it.name, instantiate(it.args, type_def, type)] }
+            .then { Split[it, true] }
+        end
+
+        def instantiate(args, type_def, type)
+          args.map do |arg|
+            next arg unless arg.is_a?(Type::Var)
+
+            type_def
+              .type_params
+              .find_index { arg.name == it.name }
+              .then { type.args.at(it) }
+          end
+        end
+      end
+    end
+  end
+end