jade-lang 0.9.0 → 0.10.0

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/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,17 +1,23 @@
 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/unresolved_constraint'
 require 'jade/frontend/type_checking/error/implementation_type_mismatch'

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:)
 

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

@@ -0,0 +1,50 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        # `/` asks for a `NonZero`, which nothing but `non_zero` can build.
+        # A literal is the exception: the compiler can see whether it is
+        # zero, so `cents / 100` needs no ceremony and `n / 0` is caught
+        # where it is written.
+        module Division
+          extend self
+
+          OPERATOR = '(/)'.freeze
+
+          # Lifted even when the literal is zero: the divide-by-zero error is
+          # the one worth reading, and a type mismatch under it is noise.
+          def lift(node, acc)
+            return acc unless divisor(node)
+
+            acc.with(types: [*acc.types[0..-2], non_zero(acc.types.last)])
+          end
+
+          def by_zero(node, entry_name)
+            return [] unless divisor(node)&.zero?
+
+            [Error::DivisionByZero.new(entry_name, node.args.last.range)]
+          end
+
+          private
+
+          def divisor(node)
+            return nil unless node.args.size == 2 && operator?(node.callee)
+
+            case node.args.last
+            in AST::Literal(value: ::Integer | ::Float => value) then value
+            else nil
+            end
+          end
+
+          def operator?(callee)
+            callee in AST::VariableReference(name: OPERATOR)
+          end
+
+          def non_zero(type)
+            Type.constructor('Basics.NonZero').apply([type])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -28,10 +28,12 @@ module Jade
                 .then { |(new_state, result)| [new_state, acc.add(result)] }
               end
 
+            args_state = args_state.add_errors(Division.by_zero(node, args_state.env.entry_name))
+
             after_callee_state, result_type = unify_callee(
               args_state,
               callee_result,
-              args_acc,
+              Division.lift(node, args_acc),
               node,
               state,
             )
@@ -170,9 +172,32 @@ module Jade
                 expected: e.expected,
                 actual: e.actual,
                 infix: node.infix,
+                lifted_placeholder: lifted_placeholder?(node),
+                callee_name: source_name(node.callee),
+                arg_names: node.args.map { source_name(it) },
               )
             end
           end
+
+          # Desugaring lifted the `_` into a lambda parameter, so a hole
+          # reads as an argument referring to one by the time we get here.
+          def lifted_placeholder?(node)
+            node.args.any? { it in AST::VariableReference(name: /\A__p\d+__\z/) }
+          end
+
+          # What the author called this, where they called it something.
+          def source_name(node)
+            case node
+            in AST::ConstructorReference | AST::VariableReference
+              node.name
+
+            in AST::QualifiedAccess(path:)
+              path.join('.')
+
+            else
+              nil
+            end
+          end
         end
       end
     end

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

@@ -56,7 +56,7 @@ module Jade
                 else
                   concrete_t = body_state.env.substitution.apply(t)
                   PatternAnalysis::Exhaustiveness
-                    .assert([p], p.range, acc.env, registry, concrete_t)
+                    .assert([p], p.range, acc.env, concrete_t)
                     .then { acc.add_errors(it) }
                 end
               end

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

@@ -11,6 +11,32 @@ module Jade
               .then { |s, r| [s.with(env: s.env.pin_type(pattern.id, r.type)), r] }
           end
 
+          def range_type_error(state, pattern)
+            ->(error) do
+              Error::RangePatternType.new(
+                state.env.entry_name, pattern.range,
+                expected: error.expected, actual: error.actual,
+              )
+            end
+          end
+
+          def empty_range(pattern, state, result)
+            pattern => AST::Pattern::Range(from:, to:)
+
+            return [] unless state.env.substitution.apply(result.type) in Type::Application(
+              constructor: Type::Constructor(name: 'Basics.Int'),
+            )
+
+            return [] unless from && to && from.value > to.value
+
+            [Error::EmptyRangePattern.new(
+              state.env.entry_name,
+              pattern.range,
+              from: from.value,
+              to: to.value,
+            )]
+          end
+
           def infer_(pattern, registry, state, expected)
             case pattern
             in AST::Pattern::Record(fields:, symbol:)
@@ -34,6 +60,15 @@ module Jade
                     .unify_result(it, expected.type, &type_error(state, pattern))
                 end
 
+            in AST::Pattern::Range
+              state
+                .unify_result(
+                  Result.init(Type.int),
+                  expected.type,
+                  &range_type_error(state, pattern)
+                )
+                .then { |(st, r)| [st.add_errors(empty_range(pattern, st, r)), r] }
+
             in AST::Pattern::Literal(literal:)
               new_state, literal_result = check(literal, registry, state, expected)
               new_state.unify_result(literal_result, expected.type, &type_error(state, pattern))

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

@@ -0,0 +1,18 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Inference
+        module TypeAliasDeclaration
+          extend Helpers
+          extend self
+
+          def infer(node, _, state, _)
+            node => AST::TypeAliasDeclaration
+
+            [state, Result.init(Type.unit)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ require 'jade/frontend/type_checking/inference/helpers'
 require 'jade/frontend/type_checking/inference/body'
 require 'jade/frontend/type_checking/inference/case_of'
 require 'jade/frontend/type_checking/inference/constructor_reference'
+require 'jade/frontend/type_checking/inference/division'
 require 'jade/frontend/type_checking/inference/function_call'
 require 'jade/frontend/type_checking/inference/function_declaration'
 require 'jade/frontend/type_checking/inference/implementation'
@@ -21,6 +22,7 @@ require 'jade/frontend/type_checking/inference/record_field'
 require 'jade/frontend/type_checking/inference/record_literal'
 require 'jade/frontend/type_checking/inference/record_update'
 require 'jade/frontend/type_checking/inference/struct_declaration'
+require 'jade/frontend/type_checking/inference/type_alias_declaration'
 require 'jade/frontend/type_checking/inference/interface_declaration'
 require 'jade/frontend/type_checking/inference/type_declaration'
 require 'jade/frontend/type_checking/inference/assign'

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

@@ -35,12 +35,22 @@ module Jade
           entry
             .types
             .reduce(env) do |e, (_, sym)|
+              # Aliases are transparent — they get expanded into their
+              # body whenever a TypeRef resolves to one. They never need
+              # to be looked up as definitions during unification.
+              next e if alias_symbol?(sym, registry)
+
               Definition
                 .from_symbol(sym, registry)
                 .then { e.define(sym.qualified_name, it) }
             end
         end
 
+        def alias_symbol?(sym, registry)
+          sym.is_a?(Symbol::Alias) ||
+            (sym.is_a?(Symbol::TypeRef) && registry.lookup(sym).is_a?(Symbol::Alias))
+        end
+
         def load_imports(env, entry, registry)
           entry
             .imports
@@ -65,6 +75,7 @@ module Jade
 
           in Symbol::TypeRef
             return env if env.lookup_def(sym.qualified_name)
+            return env if registry.lookup(sym).is_a?(Symbol::Alias)
 
             Definition
               .from_symbol(sym, registry)

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

@@ -36,9 +36,12 @@ module Jade
 
         private
 
+        # Every port reaching here returns a Task: `NonTaskPort` runs in
+        # semantic analysis and stops compilation before this, which is what
+        # lets `resolve_port` destructure the return type without checking.
         def resolve_value(sym, entry, registry)
           case sym
-          in Symbol::InteropFunction(return_type: Symbol::TypeApplication)
+          in Symbol::InteropFunction
             resolve_port(sym, entry, registry)
 
           else
@@ -47,7 +50,7 @@ module Jade
         end
 
         def resolve_port(interop_fn, entry, registry)
-          interop_fn.return_type => Symbol::TypeApplication(args: [ok_sym, err_sym])
+          ok_sym, err_sym = arm_symbols(interop_fn.return_type)
 
           # Single Type.from_symbol over the whole port so a var appearing in
           # more than one position gets the same Type::Var id. PortCodec relies
@@ -66,6 +69,19 @@ module Jade
           ]
         end
 
+        # The arms are only wanted for their spans, and an alias keeps its
+        # arms in another declaration, so there is often none to point at and
+        # the port's own return type is the best there is.
+        def arm_symbols(return_type)
+          case return_type
+          in Symbol::TypeApplication(constructor: Symbol::TypeRef['Task', 'Task'], args: [ok, err])
+            [ok, err]
+
+          else
+            [nil, nil]
+          end
+        end
+
         # Without the constraints the shared VarGen would still hand every
         # position its own var; `from_symbol` only ties them together through
         # the map it threads across params and return.
@@ -83,7 +99,7 @@ module Jade
         end
 
         def resolve_param(type_sym, type, interop_fn, index, entry, registry)
-          return [Symbol::InteropFunction::PASS, []] if pass_through?(type_sym)
+          return [Symbol::InteropFunction::PASS, []] if pass_through?(type)
 
           case type
           in Type::Var(name:)
@@ -99,7 +115,7 @@ module Jade
         end
 
         def resolve_arm(type_sym, type, interop_fn, arm, entry, registry)
-          return [Symbol::InteropFunction::PASS, []] if pass_through?(type_sym)
+          return [Symbol::InteropFunction::PASS, []] if pass_through?(type)
 
           case type
           in Type::Var(name:)
@@ -156,10 +172,12 @@ module Jade
           end
         end
 
-        def pass_through?(type_sym)
-          case type_sym
-          in Symbol::TypeApplication(constructor: Symbol::TypeRef(module_name:, name:))
-            [module_name, name] in ['Basics', 'Never'] | ['Decode', 'Value']
+        # Asked of the expanded type, so an alias over `Never` or
+        # `Decode.Value` passes through the same as the type it names.
+        def pass_through?(type)
+          case type
+          in Type::Application(constructor: Type::Constructor(name: 'Basics.Never' | 'Decode.Value'))
+            true
 
           else
             false

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

@@ -47,7 +47,7 @@ module Jade
           in Type::Application(args:)
             case apply(type.constructor)
             in Type::PartialApplication(constructor:, args: tail_args)
-              Type::Application[constructor, args.map { apply(it) } + tail_args]
+              Type::Application[constructor, args.map { apply(it) } + tail_args, type.display]
 
             in constructor
               type.with(constructor:, args: args.map { apply(it) })
@@ -60,7 +60,7 @@ module Jade
 
             case apply(row_var)
             in Type::AnonymousRecord(fields: extra_fields, row_var: new_row_var)
-              Type.anonymous_record(applied_fields.merge(extra_fields), new_row_var)
+              Type.anonymous_record(applied_fields.merge(extra_fields), new_row_var, type.display)
 
             in Type::Var => applied_row_var
               type.with(fields: applied_fields, row_var: applied_row_var)

data/lib/jade/frontend/type_checking.rb

@@ -1,3 +1,4 @@
+require 'jade/frontend/type_checking/cascade'
 require 'jade/frontend/type_checking/canonicalize'
 require 'jade/frontend/type_checking/constraints'
 require 'jade/frontend/type_checking/definition'
@@ -97,7 +98,7 @@ module Jade
         # with those constraints — rather than being dropped silently.
 
         state
-          .with(errors: state.errors + errors)
+          .with(errors: Cascade.prune(state.errors + errors))
           .to_result
       end
 
@@ -143,6 +144,7 @@ module Jade
         in AST::QualifiedAccess then Inference::QualifiedAccess
         in AST::RecordAccess then Inference::RecordAccess
         in AST::StructDeclaration then Inference::StructDeclaration
+        in AST::TypeAliasDeclaration then Inference::TypeAliasDeclaration
         in AST::InterfaceDeclaration then Inference::InterfaceDeclaration
         in AST::RecordField then Inference::RecordField
         in AST::RecordLiteral then Inference::RecordLiteral

data/lib/jade/frontend/usage_analysis.rb

@@ -97,7 +97,8 @@ module Jade
         in AST::Pattern::Record(fields:)
           fields.flat_map { walk(it.pattern, :as_value, entry, owner) }
 
-        in AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard
+        in AST::Pattern::Literal | AST::Pattern::Binding | AST::Pattern::Wildcard |
+          AST::Pattern::Range
           []
 
         in AST::Grouping(expression:)
@@ -138,6 +139,9 @@ module Jade
         in AST::StructDeclaration(record_type:, symbol:)
           walk_type(record_type, entry, ReferenceIndex.key_for(symbol))
 
+        in AST::TypeAliasDeclaration(body_type:, symbol:)
+          walk_type(body_type, entry, ReferenceIndex.key_for(symbol))
+
         in AST::InterfaceDeclaration(functions:, symbol:)
           ReferenceIndex.key_for(symbol).then do |declared|
             functions.flat_map { walk_type(it.type, entry, declared) }