jade-lang 0.9.0 → 0.10.1

data/lib/jade/frontend/type_checking/constraints.rb

@@ -6,7 +6,19 @@ module Jade
       module Constraints
         extend self
 
-        def resolve(constraint, registry, entry_name)
+        # A derived instance is built by asking for its components' instances,
+        # so a type that contains itself asks for the one being built. Nothing
+        # ties that knot yet, so the walk is cut here rather than left to run
+        # out of stack.
+        def resolve(constraint, registry, entry_name, in_progress = ::Set[])
+          key = [constraint.interface, constraint.type.to_s]
+
+          if in_progress.include?(key)
+            Error::RecursiveDerivation
+              .new(entry_name, constraint.origin&.range, constraint:)
+              .then { return Err[it] }
+          end
+
           if constraint.type in Type::Var
             Error::UnresolvedConstraint
               .new(entry_name, constraint.origin&.range, constraint:)
@@ -23,7 +35,7 @@ module Jade
                     constraint.type,
                     constraint.origin,
                   )
-                .then { resolve(it, registry, entry_name) } => Ok[resolved]
+                .then { resolve(it, registry, entry_name, in_progress) } => Ok[resolved]
 
                 resolved
               end
@@ -34,7 +46,9 @@ module Jade
 
           if Deriving.derivable?(constraint.interface)
             Deriving
-              .derive(constraint, registry, entry_name) { resolve(it, registry, entry_name) }
+              .derive(constraint, registry, entry_name) do
+                resolve(it, registry, entry_name, in_progress + [key])
+              end
               .then { return it }
           end
 
@@ -87,6 +101,7 @@ module Jade
             in Type::Application(constructor:) then constructor.name
             in Type::PartialApplication(constructor:) then constructor.name
             in Type::Constructor(name:) then name
+            in Type::Displayable => t then t.render
             else constraint.type.to_s
             end
 

data/lib/jade/frontend/type_checking/error/display.rb

@@ -0,0 +1,49 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        # Inference ids (`t8894`) are counters: they change between
+        # compiles, and two occurrences of one variable look unrelated
+        # unless you notice the digits match. Read out as `a`, `b`, `c`;
+        # the ids themselves stay internal.
+        module Display
+          extend self
+
+          LETTERS = ('a'..'z').to_a.freeze
+
+          Naming = Data.define(:substitution) do
+            def [](type)
+              substitution.apply(type).to_s
+            end
+
+            # Spells out the body of an alias, for the one type a message is
+            # about. Nested positions keep the short name.
+            def annotated(type)
+              substitution.apply(type).then do |applied|
+                applied.is_a?(Type::Displayable) ? applied.annotated : applied.to_s
+              end
+            end
+          end
+
+          # Every type in one message at once, so a variable is the same
+          # letter on both sides of it.
+          def naming(*types)
+            types
+              .flat_map(&:unbound_vars)
+              .uniq(&:id)
+              .select { it.name.nil? }
+              .each_with_index
+              .to_h { |var, i| [var.id, Type.var(var.id, letter(i))] }
+              .then { Naming[Substitution.new(it)] }
+          end
+
+          private
+
+          def letter(index)
+            LETTERS[index] || "t#{index - LETTERS.size + 1}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/division_by_zero.rb

@@ -0,0 +1,31 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class DivisionByZero < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            'Cannot divide by zero.'
+          end
+
+          def label
+            'this divisor is zero'
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                'division takes a `NonZero`. A literal other than zero is one; ' \
+                  'for a value, `non_zero(n)` gives a `Maybe(NonZero(a))`',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/empty_range_pattern.rb

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class EmptyRangePattern < Jade::Error
+          include PatternProblem
+          def initialize(entry, span, from:, to:)
+            @from = from
+            @to = to
+            super(entry:, span:)
+          end
+
+          def message
+            "#{@from}..#{@to} matches nothing, because #{@from} is greater " \
+              "than #{@to}."
+          end
+
+          def label
+            'empty range'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/function_body_type_mismatch.rb

@@ -9,12 +9,13 @@ module Jade
           end
 
           def message
-            "There's a problem with the body of `#{@function_name}` definition: " ++
-              "it returns #{@actual} but its signature says it should be #{@expected}"
+            "There\u0027s a problem with the body of `#{@function_name}` definition: " \
+              "it returns #{naming.annotated(@actual)} but its signature says it should be " \
+              "#{naming.annotated(@expected)}"
           end
 
           def label
-            "returns #{@actual}, expected #{@expected}"
+            "returns #{naming[@actual]}, expected #{naming[@expected]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/function_call_type_mismatch.rb

@@ -3,9 +3,15 @@ module Jade
     module TypeChecking
       module Error
         class FunctionCallTypeMismatch < TypeMismatch
-          def initialize(entry, span, expected:, actual:, infix:)
+          def initialize(
+            entry, span, expected:, actual:, infix:, lifted_placeholder:,
+            callee_name:, arg_names:
+          )
             super
             @infix = infix
+            @lifted_placeholder = lifted_placeholder
+            @callee_name = callee_name
+            @arg_names = arg_names
           end
 
           def message
@@ -13,22 +19,119 @@ module Jade
             in AST::InfixOperator(value:)
               infix_error(value)
             else
-              "Function call mismatch, expected #{@expected} but found #{@actual}"
+              "Function call mismatch, expected #{naming[@expected]} but found #{naming[@actual]}"
             end
           end
 
+          def notes
+            return non_zero_note if wanted_non_zero?
+            return placeholder_note if one_too_many_for_the_placeholder?
+            return arity_note if wrong_arity?
+            return under_applied_note if under_applied
+
+            []
+          end
+
           private
 
+          # The only type nobody can construct directly, so saying what was
+          # expected is not enough to act on.
+          def wanted_non_zero?
+            @expected in Type::Function(
+              args: [*, Type::Application(constructor: Type::Constructor(name: 'Basics.NonZero'))]
+            )
+          end
+
+          def non_zero_note
+            help(
+              'a divisor has to be known not to be zero. A literal other than ' \
+                'zero is; for a value, `non_zero(n)` gives a `Maybe(NonZero(a))`',
+            )
+          end
+
+          def placeholder_note
+            ('a `_` makes this a function waiting for that argument, and the ' \
+              'call has one argument too many for that. If you piped into it, ' \
+              '`|>` already supplies the first argument, so drop the `_`')
+              .then { help(it) }
+          end
+
+          def arity_note
+            "#{subject(@callee_name, 'this')} takes #{count(@expected.args.size)}, " \
+              "#{@actual.args.size} given"
+              .then { help(it) }
+          end
+
+          # An argument that arrives as a function returning what was wanted
+          # is a constructor or function that has not been given everything
+          # it needs.
+          def under_applied_note
+            @actual
+              .args[under_applied]
+              .args
+              .size
+              .then { count(it) }
+              .then { "#{under_applied_subject} needs #{it}" }
+              .then { help(it) }
+          end
+
+          def under_applied_subject
+            subject(@arg_names[under_applied], "argument #{under_applied + 1}")
+          end
+
+          def under_applied
+            return nil unless comparable_calls?
+            return nil unless @expected.args.size == @actual.args.size
+
+            @expected.args.zip(@actual.args).index do |want, got|
+              got.is_a?(Type::Function) &&
+                !want.is_a?(Type::Function) &&
+                got.return_type == want
+            end
+          end
+
+          def wrong_arity?
+            comparable_calls? && @expected.args.size != @actual.args.size
+          end
+
+          def comparable_calls?
+            !@infix && (@expected in Type::Function) && (@actual in Type::Function)
+          end
+
+          def subject(name, fallback)
+            name ? "`#{name}`" : fallback
+          end
+
+          def count(n)
+            "#{n} #{n == 1 ? 'argument' : 'arguments'}"
+          end
+
+          def help(text)
+            [Jade::Diagnostics::Annotation[:help, text]]
+          end
+
+          # `xs |> f(_, y)` reads as though the `_` marks where the piped
+          # value goes, but `|>` has already put it in front of it.
+          def one_too_many_for_the_placeholder?
+            return false unless @lifted_placeholder
+            return false unless @expected in Type::Function
+            return false unless @actual in Type::Function
+
+            @actual.args.size == @expected.args.size + 1
+          end
+
           def infix_error(operator)
             if @expected.args.first != @actual.args.first
-              return "Left side of (#{operator}) expects #{@expected.args.first} but found #{@actual.args.first}"
+              return "Left side of (#{operator}) expects #{naming[@expected.args.first]} " \
+                "but found #{naming[@actual.args.first]}"
             end
 
             if @expected.args.last != @actual.args.last
-              return "Right side of (#{operator}) expects #{@expected.args.last} but found #{@actual.args.last}"
+              return "Right side of (#{operator}) expects #{naming[@expected.args.last]} " \
+                "but found #{naming[@actual.args.last]}"
             end
 
-            "Function call mismatch, expected #{@expected} but found #{@actual}"
+            "Function call mismatch, expected #{naming[@expected]} but found #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/if_branch_type_mismatch.rb

@@ -10,7 +10,7 @@ module Jade
 
           def message
             "The #{@branch} branch of this if statement is expected to return" +
-              " #{@expected} but got #{@actual}"
+              " #{naming[@expected]} but got #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/if_branches_type_mismatch.rb

@@ -9,7 +9,7 @@ module Jade
 
           def message
             "If branches must return the same type. The then branch produces " +
-              "#{@expected} but the else branch produces #{@actual}"
+              "#{naming[@expected]} but the else branch produces #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/if_condition_type_mismatch.rb

@@ -8,7 +8,7 @@ module Jade
           end
 
           def message
-            "If condition expects #{@expected} but found #{@actual}"
+            "If condition expects #{naming[@expected]} but found #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/implementation_type_mismatch.rb

@@ -11,7 +11,7 @@ module Jade
 
           def message
             "Implementation of #{@interface}.#{@fn_name}: " \
-              "expected #{@expected} but the provided function has type #{@actual}"
+              "expected #{naming[@expected]} but the provided function has type #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/list_item_type_mismatch.rb

@@ -10,7 +10,7 @@ module Jade
 
           def message
             "The #{ordinal(@actual_index)} item does not match the previous items in the list, " +
-              "expected #{@expected} but found #{@actual}"
+              "expected #{naming[@expected]} but found #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/missing_patterns.rb

@@ -3,21 +3,37 @@ module Jade
     module TypeChecking
       module Error
         class MissingPatterns < Jade::Error
+          LISTED = 10
+
           def initialize(entry, span, missing_patterns:)
             @missing_patterns = missing_patterns
             super(entry:, span:)
           end
 
           def message
-            patterns_str = @missing_patterns
+            "Pattern match is not exhaustive. Missing cases:\n#{listed}#{rest}"
+          end
+
+          def label
+            "non-exhaustive pattern match"
+          end
+
+          private
+
+          def listed
+            @missing_patterns
+              .take(LISTED)
               .map { |row| row.map(&:to_s).join(', ') }
               .map { "  #{it}" }
               .join("\n")
-            "Pattern match is not exhaustive. Missing cases:\n#{patterns_str}"
           end
 
-          def label
-            "non-exhaustive pattern match"
+          # A table split at every bound can leave hundreds of holes, and a
+          # three-hundred-line error is not one anybody reads.
+          def rest
+            return '' if @missing_patterns.size <= LISTED
+
+            "\n  … and #{@missing_patterns.size - LISTED} more"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/pattern_type_mismatch.rb

@@ -2,9 +2,15 @@ module Jade
   module Frontend
     module TypeChecking
       module Error
+        # A pattern the checker could not make sense of. Coverage is a claim
+        # about the patterns as written, so one of these silences it.
+        module PatternProblem; end
+
         class PatternTypeMismatch < TypeMismatch
+          include PatternProblem
+
           def message
-            "Pattern is trying to match #{@expected} with #{@actual}"
+            "Pattern is trying to match #{naming[@expected]} with #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/range_pattern_type.rb

@@ -0,0 +1,29 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class RangePatternType < PatternTypeMismatch
+          def message
+            "A range pattern only matches Int, and this one is matching " \
+              "#{naming[@expected]}."
+          end
+
+          def label
+            'range pattern on a type that is not Int'
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :note,
+                'Int is the only type a range covers checkably: 0..2 and ' \
+                  '3..12 sit next to each other with nothing in between ' \
+                  'them to be missed',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/record_access_type_mismatch.rb

@@ -4,8 +4,8 @@ module Jade
       module Error
         class RecordAccessTypeMismatch  < TypeMismatch
           def message
-            "Something is off with this record access, it expects #{@expected} " +
-              "but found #{@actual}"
+            "Something is off with this record access, it expects #{naming[@expected]} " +
+              "but found #{naming[@actual]}"
           end
         end
       end

data/lib/jade/frontend/type_checking/error/record_update_type_mismatch.rb

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        # An update produces a record of its own, which then has to be the
+        # record the surrounding code wanted. Changing a field's type is the
+        # usual way to break that, and any other disagreement lands here too.
+        class RecordUpdateTypeMismatch < TypeMismatch
+          def message
+            "This update produces #{naming.annotated(@actual)}, " \
+              "but #{naming.annotated(@expected)} was expected"
+          end
+
+          def label
+            "produces #{naming[@actual]}, expected #{naming[@expected]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/recursive_derivation.rb

@@ -0,0 +1,25 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class RecursiveDerivation < Jade::Error
+          attr_reader :constraint
+
+          def initialize(entry, span, constraint:)
+            @constraint = constraint
+            super(entry:, span:)
+          end
+
+          def message
+            "#{@constraint.interface} cannot be derived for #{@constraint.type} " \
+              'because it contains itself; write the implementation by hand'
+          end
+
+          def label
+            "#{@constraint.type} is recursive"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/type_mismatch.rb

@@ -10,11 +10,19 @@ module Jade
           end
 
           def message
-            "Expected #{@expected} but got #{@actual}"
+            "Expected #{naming.annotated(@expected)} but got #{naming.annotated(@actual)}"
           end
 
           def label
-            "expected #{@expected}, got #{@actual}"
+            "expected #{naming[@expected]}, got #{naming[@actual]}"
+          end
+
+          attr_reader :expected, :actual
+
+          private
+
+          def naming
+            @naming ||= Display.naming(@expected, @actual)
           end
         end
       end

data/lib/jade/frontend/type_checking/error/unreachable_branch.rb

@@ -0,0 +1,22 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class UnreachableBranch < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            'This branch can never match. The branches above it already cover ' \
+              'every value that would reach it.'
+          end
+
+          def label
+            'unreachable branch'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,18 +1,25 @@
 require 'jade/error'
 
+require 'jade/frontend/type_checking/error/display'
 require 'jade/frontend/type_checking/error/type_mismatch'
 
 require 'jade/frontend/type_checking/error/case_of_branches_type_mismatch'
 require 'jade/frontend/type_checking/error/derivation_failed'
+require 'jade/frontend/type_checking/error/recursive_derivation'
 require 'jade/frontend/type_checking/error/function_body_type_mismatch'
 require 'jade/frontend/type_checking/error/function_call_type_mismatch'
 require 'jade/frontend/type_checking/error/if_branch_type_mismatch'
 require 'jade/frontend/type_checking/error/if_branches_type_mismatch'
 require 'jade/frontend/type_checking/error/if_condition_type_mismatch'
 require 'jade/frontend/type_checking/error/missing_patterns'
+require 'jade/frontend/type_checking/error/division_by_zero'
+require 'jade/frontend/type_checking/error/unreachable_branch'
 require 'jade/frontend/type_checking/error/list_item_type_mismatch'
 require 'jade/frontend/type_checking/error/pattern_type_mismatch'
+require 'jade/frontend/type_checking/error/empty_range_pattern'
+require 'jade/frontend/type_checking/error/range_pattern_type'
 require 'jade/frontend/type_checking/error/record_access_type_mismatch'
+require 'jade/frontend/type_checking/error/record_update_type_mismatch'
 require 'jade/frontend/type_checking/error/unresolved_constraint'
 require 'jade/frontend/type_checking/error/implementation_type_mismatch'
 require 'jade/frontend/type_checking/error/missing_implementation'

data/lib/jade/frontend/type_checking/inference/assign.rb

@@ -34,7 +34,7 @@ module Jade
               end
 
             PatternAnalysis::Exhaustiveness
-              .assert([pattern], pattern.range, final_state.env, registry, expr_result.type)
+              .assert([pattern], pattern.range, final_state.env, expr_result.type)
               .then { final_state.add_errors(it) }
               .unify_result(expr_result.with(constraints: residual_cs), expected.type)
           end

data/lib/jade/frontend/type_checking/inference/case_of.rb

@@ -46,7 +46,7 @@ module Jade
                   expr_result,
                 )
               end
-              .then { |st, cs| [check_exhaustiveness(node, st, registry, expr_result), cs] }
+              .then { |st, cs| [check_patterns(node, st, expr_result), cs] }
               .then do |st, cs|
                 first_result
                   .with(constraints: cs)
@@ -75,17 +75,34 @@ module Jade
             )
           end
 
-          def check_exhaustiveness(node, state, registry, result)
+          # Coverage is a claim about the patterns as written. When one of them
+          # failed to type there is nothing coherent to claim, and saying it
+          # anyway buries the real error under invented ones.
+          def check_patterns(node, state, result)
             node => AST::CaseOf(branches:)
 
+            return state if mistyped_patterns?(node, state)
+
             patterns = branches.map(&:pattern)
             type     = result.apply(state.env.substitution).type
 
-            PatternAnalysis::Exhaustiveness
-              .assert(patterns, node.range, state.env, registry, type)
+            [
+              PatternAnalysis::Exhaustiveness.assert(patterns, node.range, state.env, type),
+              PatternAnalysis::Redundancy.assert(patterns, state.env, type),
+            ]
+              .flatten
               .then { state.add_errors(it) }
           end
 
+          def mistyped_patterns?(node, state)
+            state
+              .errors
+              .any? do |error|
+                error.is_a?(Error::PatternProblem) &&
+                  node.range.cover?(error.span.begin)
+              end
+          end
+
           def infer_branch(node, registry, env, expected, expression_result)
             node => AST::CaseOfBranch(pattern:, body:)