jade-lang 0.11.3 → 0.12.1

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

@@ -0,0 +1,53 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class NarrowedSignature < Jade::Error
+          def initialize(entry, span, function_name:, var:, found:)
+            @function_name = function_name
+            @var = var
+            @found = found
+            super(entry:, span:)
+          end
+
+          def message
+            case @found
+            in Type::Var
+              "`#{@function_name}` says `#{@var}` and `#{@found}` can be different " \
+                'types, but its body needs them to be the same'
+            else
+              "`#{@function_name}` says it works for any `#{@var}`, but its body only " \
+                "works when `#{@var}` is #{shown}"
+            end
+          end
+
+          def label
+            'narrower than its signature'
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[
+              :help,
+              'write the type the body needs in the signature, or make the body ' \
+                'work for any type',
+            ]]
+          end
+
+          private
+
+          def shown
+            kept, renamed = @found
+              .unbound_vars
+              .uniq(&:id)
+              .partition { it.name && it.name != @var }
+
+            renamed
+              .zip(('a'..'z').to_a - [@var, *kept.map(&:name)])
+              .to_h { |(var, letter)| [var.id, Type.var(var.id, letter)] }
+              .then { Substitution[it].apply(@found).to_s }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,7 @@ 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/narrowed_signature'
 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'
@@ -24,5 +25,6 @@ require 'jade/frontend/type_checking/error/unresolved_constraint'
 require 'jade/frontend/type_checking/error/implementation_type_mismatch'
 require 'jade/frontend/type_checking/error/implementation_function_constraint'
 require 'jade/frontend/type_checking/error/cross_module_requirement'
+require 'jade/frontend/type_checking/error/narrowed_method_variable'
 require 'jade/frontend/type_checking/error/undeclared_requirement'
 require 'jade/frontend/type_checking/error/missing_implementation'

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

@@ -33,10 +33,13 @@ module Jade
                 [pattern_state, expr_result.constraints]
               end
 
-            PatternAnalysis::Exhaustiveness
-              .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)
+            final_state
+              .defer_patterns([pattern], pattern.range, expr_result.type)
+              .unify_result(
+                expr_result.with(constraints: residual_cs),
+                expected.type,
+                &type_mismatch(state, node)
+              )
           end
 
           private

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

@@ -86,12 +86,7 @@ module Jade
             patterns = branches.map(&:pattern)
             type     = result.apply(state.env.substitution).type
 
-            [
-              PatternAnalysis::Exhaustiveness.assert(patterns, node.range, state.env, type),
-              PatternAnalysis::Redundancy.assert(patterns, state.env, type),
-            ]
-              .flatten
-              .then { state.add_errors(it) }
+            state.defer_patterns(patterns, node.range, type)
           end
 
           def mistyped_patterns?(node, state)

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

@@ -12,7 +12,7 @@ module Jade
             state
               .env
               .lookup(symbol.qualified_name)
-              .then { state.unify_result(it, expected.type) }
+              .then { state.unify_result(it, expected.type, &type_mismatch(state, node)) }
           end
         end
       end

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

@@ -41,6 +41,7 @@ module Jade
                   function_name: node.name,
                 )
               end
+              .then { |st| report_narrowing(st, node, symbol, registry, fn_type) }
               .then do |st|
                 next st if st.env.bindings[symbol.qualified_name].is_a?(Scheme) && !st.skip_constraints
 
@@ -58,6 +59,26 @@ module Jade
               end
               .then { [it, Result.init(Type.unit)] }
           end
+
+          private
+
+          def report_narrowing(state, node, symbol, registry, fn_type)
+            Type
+              .from_symbol(registry.lookup(symbol), registry, state.env.var_gen)
+              .first
+              .then { Narrowing.against_declaration(it, state.env.substitution.apply(fn_type)) }
+              .then { it ? state.add_errors([narrowed(it, state, node)]) : state }
+          end
+
+          def narrowed((var, found), state, node)
+            Error::NarrowedSignature.new(
+              state.env.entry_name,
+              node.range,
+              function_name: node.name,
+              var: var.name,
+              found:,
+            )
+          end
         end
       end
     end

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

@@ -36,6 +36,17 @@ module Jade
 
             result
           end
+
+          def type_mismatch(state, node)
+            ->(error) do
+              Error::TypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: error.expected,
+                actual: error.actual,
+              )
+            end
+          end
         end
       end
     end

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

@@ -58,7 +58,7 @@ module Jade
                   Expected.check(expected_type),
                   interface_qname,
                   concrete_type,
-                  iface_fn_type,
+                  [iface_fn_type, t_var],
                 )
               end
               .then { [it, Result.init(Type.unit)] }
@@ -151,11 +151,19 @@ module Jade
             end
           end
 
-          def record_requirements(state, constraints, head_type, sig_type, interface_qname, impl_fn, fn_name)
+          def record_requirements(state, constraints, head_type, signature, interface_qname, impl_fn, fn_name)
+            signature => [sig_type, t_var]
             substitution = state.env.substitution
             head_vars = substitution.apply(head_type).unbound_vars.map(&:id).to_set
             names = signature_names(sig_type, substitution)
 
+            narrowed = Narrowing.against_method(sig_type, t_var, head_vars, substitution)
+            unless narrowed.empty?
+              return state.add_errors(
+                narrowed.map { narrowing(state, impl_fn, interface_qname, fn_name, it) },
+              )
+            end
+
             free = constraints
               .map { substitution.apply(it) }
               .select { it.type.is_a?(Type::Var) && !head_vars.include?(it.type.id) }
@@ -171,6 +179,19 @@ module Jade
               )
           end
 
+          def narrowing(state, impl_fn, interface_qname, fn_name, narrowed)
+            narrowed => [var_name, bound_to]
+
+            Error::NarrowedMethodVariable.new(
+              state.env.entry_name,
+              impl_fn.range,
+              interface: interface_qname,
+              fn_name:,
+              var_name:,
+              bound_to: bound_to.to_s,
+            )
+          end
+
           def signature_names(sig_type, substitution)
             sig_type
               .unbound_vars

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

@@ -54,10 +54,7 @@ module Jade
                 in AST::Pattern::Binding | AST::Pattern::Wildcard
                   acc
                 else
-                  concrete_t = body_state.env.substitution.apply(t)
-                  PatternAnalysis::Exhaustiveness
-                    .assert([p], p.range, acc.env, concrete_t)
-                    .then { acc.add_errors(it) }
+                  acc.defer_patterns([p], p.range, t)
                 end
               end
 

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

@@ -12,7 +12,14 @@ module Jade
             if items.empty?
               Type.list.apply([state.fresh])
                 .then { Result.init(it) }
-                .then { return state.unify_result(it, expected.type, expected.rigid_vars) }
+                .then do
+                  return state.unify_result(
+                    it,
+                    expected.type,
+                    expected.rigid_vars,
+                    &type_mismatch(state, node)
+                  )
+                end
             end
 
             head, *rest = items
@@ -29,7 +36,14 @@ module Jade
 
             Result
               .init(Type.list.apply([items_result.type]), items_result.constraints)
-              .then { items_state.unify_result(it, expected.type, expected.rigid_vars) }
+              .then do
+                items_state.unify_result(
+                  it,
+                  expected.type,
+                  expected.rigid_vars,
+                  &type_mismatch(items_state, node)
+                )
+              end
           end
 
           private

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

@@ -0,0 +1,93 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      # Unification is symmetric, so pinning a variable a declaration
+      # quantifies simply binds it, and a call site instantiating that
+      # declaration afresh never sees that it did. Two places can do it: a
+      # function's own body, and an implementation against the method it
+      # implements.
+      module Narrowing
+        extend self
+
+        # Against a fresh copy of the declaration, since a narrowing collected
+        # in an earlier round is already part of the generalised type and the
+        # substitution no longer shows it.
+        def against_declaration(declared, actual)
+          pairs(declared, actual).then do |found|
+            found.find { |(_, type)| !type.is_a?(Type::Var) } || merged(found)
+          end
+        end
+
+
+        # An implementation is the other place a quantified variable can be
+        # pinned: the method promises a variable each call site settles, and
+        # unification will happily bind it to the implementation's own.
+        #
+        # The interface's own parameter is exempt — binding that to the
+        # implemented type is what an implementation is.
+        def against_method(sig_type, t_var, head_vars, substitution)
+          sig_type
+            .unbound_vars
+            .reject { it.id == t_var.id }
+            .filter_map { pinned(it, substitution.apply(it), head_vars) }
+            .uniq(&:first)
+        end
+
+        private
+
+        # Pinned to one of the implemented type's own variables is the common
+        # case, and naming it reads as nonsense when the two are spelled alike.
+        def pinned(var, applied, head_vars)
+          case applied
+          in Type::Var(id:) if !head_vars.include?(id) then nil
+          in Type::Var then [var.name, 'the type this implements']
+          else [var.name, "`#{applied}`"]
+          end
+        end
+
+        def merged(found)
+          found
+            .uniq { |(var, _)| var.id }
+            .group_by { |(_, type)| type.id }
+            .values
+            .find { it.size > 1 }
+            &.then { |((var, _), (other, _))| [var, other] }
+        end
+
+        def pairs(declared, actual)
+          case declared
+          in Type::Var
+            [[declared, actual]]
+
+          in Type::Application(constructor:, args:)
+            pairs(constructor, actual.constructor) + zipped(args, actual.args)
+
+          in Type::Function(args:, return_type:)
+            zipped(args, actual.args) + pairs(return_type, actual.return_type)
+
+          in Type::AnonymousRecord(fields:, row_var:)
+            fields.flat_map { |name, type| pairs(type, actual.fields.fetch(name)) } +
+              row_pairs(row_var, fields, actual)
+
+          else
+            []
+          end
+        end
+
+        def zipped(declared, actual)
+          declared
+            .zip(actual)
+            .flat_map { |(d, a)| pairs(d, a) }
+        end
+
+        def row_pairs(row_var, fields, actual)
+          return [] unless row_var
+
+          (actual.fields.keys - fields.keys).empty? && actual.row_var ?
+            pairs(row_var, actual.row_var) :
+            [[row_var, actual]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      # The coverage and redundancy of every `case` in a definition, decided
+      # against the substitution inference ended with rather than the one in
+      # scope where the patterns were written.
+      module PatternChecks
+        extend self
+
+        def run(state)
+          state
+            .pattern_checks
+            .flat_map { |(patterns, range, type)| errors_for(patterns, range, type, state.env) }
+            .then { state.add_errors(it) }
+        end
+
+        private
+
+        def errors_for(patterns, range, type, env)
+          resolved = env.substitution.apply(type)
+
+          [
+            PatternAnalysis::Exhaustiveness.assert(patterns, range, env, resolved),
+            PatternAnalysis::Redundancy.assert(patterns, env, resolved),
+          ].flatten
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,16 @@
 module Jade
   module Frontend
     module TypeChecking
-      State = Data.define(:env, :errors, :skip_constraints, :impl_requirements) do
+      State = Data.define(:env, :errors, :skip_constraints, :impl_requirements, :pattern_checks) do
         def self.init(env, skip_constraints: false)
-          new(env, [], skip_constraints, {})
+          new(env, [], skip_constraints, {}, [])
+        end
+
+        # Coverage is decided once inference is done: a pattern in a lambda is
+        # checked before the call that gives the lambda's parameter its type,
+        # so the subject can still be a variable here.
+        def defer_patterns(patterns, range, type)
+          with(pattern_checks: pattern_checks + [[patterns, range, type]])
         end
 
         def require_impl(key, constraints)

data/lib/jade/frontend/type_checking.rb

@@ -7,6 +7,8 @@ require 'jade/frontend/type_checking/error'
 require 'jade/frontend/type_checking/expected'
 require 'jade/frontend/type_checking/inference'
 require 'jade/frontend/type_checking/loader'
+require 'jade/frontend/type_checking/narrowing'
+require 'jade/frontend/type_checking/pattern_checks'
 require 'jade/frontend/type_checking/port_resolution'
 require 'jade/frontend/type_checking/requirements'
 require 'jade/frontend/type_checking/result'
@@ -27,7 +29,7 @@ module Jade
           .load(entry, registry)
           .then { collect_constraints(entry, registry, it) }
           .then { check_node(entry.ast, registry, State.init(it), Expected.infer(it.fresh)) }
-          .then { |state, _| Requirements.reconcile(entry, registry, state) }
+          .then { |state, _| Requirements.reconcile(entry, registry, PatternChecks.run(state)) }
           .then { |amended, state| complete(amended, state, registry) }
           .and_then { PortResolution.resolve(it, registry) }
       end
@@ -126,11 +128,6 @@ module Jade
           .is_a?(Symbol::InteropFunction)
       end
 
-      def check_repl(node, registry, env = Env.new)
-        check_node(node, registry, env, Expected.infer(env.fresh))
-          .to_result
-      end
-
       def check_node(node, registry, state, expected_type)
         case node
         in AST::Body then Inference::Body

data/lib/jade/frontend.rb

@@ -46,28 +46,6 @@ module Jade
        end
     end
 
-    def run_repl(ast, registry, current_entry, scope, env, var_gen)
-      registry ||= registry_with_basics
-      current_entry ||= entry_with_basics('JadeRepl')
-      scope ||= SemanticAnalysis::Scope.new
-      env ||= TypeChecking::Env.new
-      var_gen ||= TypeChecking::VarGen.new
-
-      ForwardDeclaration
-        .declare(ast, registry, current_entry)
-        .then { |entry| FixityFixer.fix(ast).then { [it, entry] } }
-        .then do |fixed_ast, updated_entry|
-          updated_registry = registry.update_module(updated_entry)
-          SemanticAnalysis
-            .analyze_repl(fixed_ast, updated_registry, scope, updated_entry)
-            .and_then do |(enhanced_ast, new_scope)|
-              enhanced_ast = Desugaring.desugar_resolved(enhanced_ast, updated_registry)
-              TypeChecking.check_repl(enhanced_ast, updated_registry, env, var_gen)
-                .map { |type, new_env| [enhanced_ast, type, updated_registry, updated_entry, new_scope, new_env] }
-            end
-        end
-    end
-
     def run_up_to_semantic_analysis(ast)
       registry, current_entry = entry_with_basics(ast)
 

data/lib/jade/parsing/error.rb

@@ -52,6 +52,21 @@ module Jade
       def message
         "#{context_prefix}Unexpected end of input, expected #{expected}"
       end
+
+      def to_diagnostic(registry = nil, source: nil)
+        super.then do |diagnostic|
+          diagnostic.primary => { source: labelled, span: }
+          next diagnostic unless labelled && span.nil?
+
+          diagnostic.with(primary: diagnostic.primary.with(span: last_character(labelled.text)))
+        end
+      end
+
+      private
+
+      def last_character(text)
+        text.b.rstrip.bytesize.then { it.zero? ? nil : (it - 1)...it }
+      end
     end
 
     class UnexpectedTokenError < Error

data/lib/jade/registry.rb

@@ -75,5 +75,5 @@ module Jade
     end
   end
 
-  ImportEntry = Data.define(:module_name, :alias, :unqualified_symbols, :qualified_symbols)
+  ImportEntry = Data.define(:module_name, :alias, :unqualified_symbols, :qualified_symbols, :implicit)
 end

data/lib/jade/stdlib/compiled.rb

@@ -39,7 +39,14 @@ module Jade
       def resolve_imports(entry)
         imports
           .reduce(entry) do |acc, stdlib|
-            ImportEntry[stdlib.entry.name, stdlib.entry.name, stdlib.default_imports, stdlib.entry.exposes]
+            ImportEntry
+              .new(
+                module_name: stdlib.entry.name,
+                alias: stdlib.entry.name,
+                unqualified_symbols: stdlib.default_imports,
+                qualified_symbols: stdlib.entry.exposes,
+                implicit: true,
+              )
               .then { acc.import(it) }
           end
       end

data/lib/jade/stdlib/dict.rb

@@ -69,6 +69,18 @@ module Jade
         end
       end
 
+      function(
+        :show_with,
+        { show_key: 'k -> String', show_value: 'v -> String', dict: 'Dict(k, v)' },
+        'String',
+        private: true,
+      ) do |show_key, show_value, dict|
+        dict.hash
+          .map { |k, v| "#{show_key.call(k)}: #{show_value.call(v)}" }
+          .join(', ')
+          .then { "Dict(#{it})" }
+      end
+
       function(:keys, { dict: 'Dict(k, v)' }, 'List(k)')
       function(:values, { dict: 'Dict(k, v)' }, 'List(v)')
       function(:to_list, { dict: 'Dict(k, v)' }, 'List(Tuple2(k, v))')

data/lib/jade/stdlib/intrinsics.rb

@@ -285,7 +285,14 @@ module Jade
         # TODO: This is the same code from stdlib that auto imports stuff.
         imports
           .reduce(entry) do |acc, stdlib|
-            ImportEntry[stdlib.entry.name, stdlib.entry.name, stdlib.default_imports, stdlib.entry.exposes]
+            ImportEntry
+              .new(
+                module_name: stdlib.entry.name,
+                alias: stdlib.entry.name,
+                unqualified_symbols: stdlib.default_imports,
+                qualified_symbols: stdlib.entry.exposes,
+                implicit: true,
+              )
               .then { acc.import(it) }
           end
       end

data/lib/jade/stdlib/set.rb

@@ -24,6 +24,18 @@ module Jade
         constraints: [['Basics.Eq', 'a']],
       )
 
+      function(
+        :show_with,
+        { show_value: 'a -> String', set: 'Set(a)' },
+        'String',
+        private: true,
+      ) do |show_value, set|
+        set.hash.keys
+          .map { show_value.call(it) }
+          .join(', ')
+          .then { "Set(#{it})" }
+      end
+
       function(:"empty?", { set: 'Set(a)' }, 'Bool')
       function(:size, { set: 'Set(a)' }, 'Int')
 

data/lib/jade/stdlib.rb

@@ -107,7 +107,14 @@ module Jade
     def add_imports(entry)
       (STDLIBS - EXTENSIONS)
         .reduce(entry) do |acc, stdlib|
-          ImportEntry[stdlib.entry.name, stdlib.entry.name, stdlib.default_imports, stdlib.entry.exposes]
+          ImportEntry
+            .new(
+              module_name: stdlib.entry.name,
+              alias: stdlib.entry.name,
+              unqualified_symbols: stdlib.default_imports,
+              qualified_symbols: stdlib.entry.exposes,
+              implicit: true,
+            )
             .then { acc.import(it) }
         end
     end

data/lib/jade/symbol/ambiguous.rb

@@ -0,0 +1,5 @@
+module Jade
+  module Symbol
+    Ambiguous = Data.define(:name, :modules)
+  end
+end

data/lib/jade/symbol.rb

@@ -1,5 +1,6 @@
 require 'jade/symbol/base'
 
+require 'jade/symbol/ambiguous'
 require 'jade/symbol/anonymous_record'
 require 'jade/symbol/constructor'
 require 'jade/symbol/derived_function'

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.11.3'
+  VERSION = '0.12.1'
 end