jade-lang 0.9.0 → 0.10.1

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

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

@@ -0,0 +1,72 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      # Maranget's other half: can any value reach `row` that the rows above it
+      # did not already take? A branch that is not useful is dead code.
+      module Usefulness
+        extend self
+
+        def useful?(matrix, row, env)
+          return matrix.empty? if matrix.types.empty?
+
+          type = matrix.types.first
+
+          return false if Signature.uninhabited?(type)
+          return expanded(matrix, row, env) if Signature.expandable?(type, env)
+
+          # The row under test cuts the column too, so its own bounds have to
+          # be in the split or it will not line up with the cases.
+          split = Signature.of(type, matrix.heads + [row.first], env)
+
+          case row.first
+          in Wildcard
+            open_column(matrix, row, split, env)
+
+          in Interval
+            split.covering(row.first).any? { narrowed(matrix, row, it, env) }
+
+          in Literal(value:)
+            split
+              .covering(row.first)
+              .then { it.empty? ? [ValueCase[value]] : it }
+              .any? { narrowed(matrix, row, it, env) }
+
+          # Deadness is a proof. A constructor this column's type does not have
+          # yields none, so the branch stands.
+          in Constructor
+            split
+              .covering(row.first)
+              .then { it.empty? || it.any? { narrowed(matrix, row, it, env) } }
+          end
+        end
+
+        private
+
+        # A wildcard reaches whatever the rows above left open. When they name
+        # every case of the type there is no such ground, and the question
+        # moves inside the cases instead.
+        def open_column(matrix, row, split, env)
+          if split.covered_by?(matrix.heads)
+            split.cases.any? { narrowed(matrix, row, it, env) }
+          else
+            useful?(matrix.default, row.drop(1), env)
+          end
+        end
+
+        def narrowed(matrix, row, kase, env)
+          head = row.first
+          args =
+            kase.matches?(head) ? head.args : Array.new(kase.arity) { Wildcard[] }
+
+          useful?(matrix.specialize(kase), args + row.drop(1), env)
+        end
+
+        def expanded(matrix, row, env)
+          fields = Signature.fields(matrix.types.first, env)
+
+          useful?(matrix.expand(env), matrix.expand_row(row, fields), env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Jade
+  module Frontend
+    module PatternAnalysis
+      # Maranget's witness generation: the patterns a match would need to add
+      # to become exhaustive. An empty result means it already is.
+      module Witnesses
+        extend self
+
+        def missing(matrix, env)
+          return exhausted_columns(matrix) if matrix.types.empty?
+
+          type = matrix.types.first
+
+          return Matrix.empty if Signature.uninhabited?(type)
+          return Matrix.wildcard(matrix.types) if matrix.empty?
+          return expanded(matrix, env) if Signature.expandable?(type, env)
+
+          heads = matrix.heads
+          split = Signature.of(type, heads, env)
+
+          return unmatched_column(matrix, env) unless split.touched_by?(heads)
+
+          split
+            .cases
+            .reduce(Matrix.empty(matrix.types)) do |acc, kase|
+              witnesses(matrix, kase, env, heads.any? { kase.matches?(it) })
+                .then { acc.concat(it) }
+            end
+        end
+
+        private
+
+        def expanded(matrix, env)
+          missing(matrix.expand(env), env)
+        end
+
+        def exhausted_columns(matrix)
+          matrix.empty? ? Matrix[[[]], []] : Matrix.empty
+        end
+
+        # Nothing in this column narrows anything — a type with no cases to
+        # enumerate, or one every row left open. Whatever is missing lives in
+        # the columns after it.
+        def unmatched_column(matrix, env)
+          missing(matrix.default, env)
+            .map { [Wildcard[]] + it }
+            .with(types: matrix.types)
+        end
+
+        # A case 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 case is what keeps a
+        # recursive type from expanding forever.
+        def witnesses(matrix, kase, env, matched)
+          return Matrix.empty if kase.arg_types.any? { Signature.uninhabited?(it) }
+
+          found =
+            if matched
+              missing(matrix.specialize(kase), env)
+                .map { [kase.witness(it.take(kase.arity))] + it.drop(kase.arity) }
+
+            else
+              missing(matrix.default, env)
+                .map { [kase.witness(Array.new(kase.arity) { Wildcard[] })] + it }
+            end
+
+          found.with(types: matrix.types)
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/pattern_analysis.rb

@@ -1,40 +1,7 @@
+require 'jade/frontend/pattern_analysis/pattern'
+require 'jade/frontend/pattern_analysis/signature'
 require 'jade/frontend/pattern_analysis/matrix'
+require 'jade/frontend/pattern_analysis/witnesses'
+require 'jade/frontend/pattern_analysis/usefulness'
 require 'jade/frontend/pattern_analysis/exhaustiveness'
-
-module Jade
-  module Frontend
-    module PatternAnalysis
-      Wildcard = Data.define do
-        def wildcard?; true; end
-        def to_s; '_'; end
-      end
-
-      Literal = Data.define(:value, :type) do
-        def wildcard?; false; 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 to_s
-          fields_str = fields.map { |k, v| "#{k}: #{v}" }.join(', ')
-          "{ #{fields_str} }"
-        end
-      end
-    end
-  end
-end
+require 'jade/frontend/pattern_analysis/redundancy'

data/lib/jade/frontend/semantic_analysis/error/implementation_on_alias.rb

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class ImplementationOnAlias < Jade::Error
+          def initialize(entry, span, interface:, alias_name:)
+            super(entry:, span:)
+            @interface = interface
+            @alias_name = alias_name
+          end
+
+          def message
+            "Cannot implement `#{@interface}` for type alias `#{@alias_name}`; " \
+              "an alias is its body, so use a `struct` or a single-variant `type`"
+          end
+
+          def label
+            "no impls on type aliases"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error/no_base_case.rb

@@ -0,0 +1,45 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class NoBaseCase < Jade::Error
+          HELP = {
+            'struct' => 'wrap the field in something that has an empty case: ' \
+                        '`Maybe(%<name>s)` can be `Nothing`, `List(%<name>s)` can be empty',
+            'type' => 'add a variant that does not mention `%<name>s`, ' \
+                      'the way `Nothing` does for `Maybe`',
+          }.freeze
+
+          def initialize(entry, span, name:, kind:)
+            @name = name
+            @kind = kind
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@name}` can never be built: every `#{@name}` needs a `#{@name}` " \
+              'inside it first'
+          end
+
+          def label
+            'nothing here stops the recursion'
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :note,
+                "a type may refer to itself; `#{@name}` just has no case that " \
+                  "stops, so there is no smallest `#{@name}` to start from",
+              ],
+              Jade::Diagnostics::Annotation[
+                :help,
+                format(HELP.fetch(@kind), name: @name),
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/semantic_analysis/error/placeholder_not_allowed.rb

@@ -2,18 +2,30 @@ module Jade
   module Frontend
     module SemanticAnalysis
       module Error
+        # `Rect(w: _, h: 2)` where `Rect` is `Rect(Int, Int)`: positional, so
+        # `w:` names nothing. A variant carrying a record takes the hole.
         class PlaceholderNotAllowed < Jade::Error
-          def initialize(entry, span, field:)
+          def initialize(entry, span, field:, name:)
             @field = field
+            @name = name
             super(entry:, span:)
           end
 
           def message
-            "`#{@field}: _` is only allowed when constructing a struct"
+            "`#{@name}` is a union variant; its arguments are positional " \
+              "and have no names, so `#{@field}:` has nothing to refer to"
           end
 
           def label
-            "not allowed here"
+            'not allowed here'
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[
+              :help,
+              "write `#{@name}(_, x)` positionally, or pipe into the " \
+                "first argument with `|> #{@name}(x)`",
+            ]]
           end
         end
       end

data/lib/jade/frontend/semantic_analysis/error/recursive_type_alias.rb

@@ -0,0 +1,24 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class RecursiveTypeAlias < Jade::Error
+          def initialize(entry, span, name:, cycle:)
+            super(entry:, span:)
+            @name = name
+            @cycle = cycle
+          end
+
+          def message
+            "Type alias `#{@name}` is recursive (cycle: #{@cycle.join(' -> ')}); " \
+              "an alias must be finite, so use a `type` for a recursive shape"
+          end
+
+          def label
+            "recursive type alias"
+          end
+        end
+      end
+    end
+  end
+end