jade-lang 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e5a1b96ecfb6952330c6dcb8bd01b6994b0ca8cff936a59112d5c9606412bd4
-  data.tar.gz: 066f030bb094a9d73b17acb2754f59aed7fc1bb3204e2f68be0df5e2830ad037
+  metadata.gz: 2e6f1ff92a99cc704dd81615de9b97ffd0f7e650ca23adac6c7ede429eeb8ffe
+  data.tar.gz: ba35d16db8a3ff88f46ef726df1f19c27fc93a20366d0acd1faec55764690f9c
 SHA512:
-  metadata.gz: b1c1f5397cfab8dafce1c63ee630c7032995be651c0ea2fcb7af51e2cff134a0f8b94c21897f53cf561c5106906c56c2267f2275d57ba6e42d6a6e7b013d003d
-  data.tar.gz: b29cbd43c8125fa086563761c9935cd3cf207ad0d10749fe701c129d0660023323698cead0c48d3bea559ee27b31441fa41c00f6697725a634c326f23777f771
+  metadata.gz: 9f07bb37ec67df7e734a007eadbf0d4ac0b2309e893f0b29b139ed6f04984478551cab0c5ac7ed0c02a83ffb4cf82353490aed477ec1e51b26c0a5961c3fa799
+  data.tar.gz: 8d87c617b0784d10185cbaaa851d2f34c649ce80ede4b82cafdcde1b4bc569f3e2841e514476fc3c95a4fa6eddf67f09e921f0b838dcf6aa45d8d1bedb34ad3b

data/CHANGELOG.md

@@ -4,6 +4,118 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.12.0] - 2026-09-17
+
+### Breaking
+
+Each of these refuses a program that compiled before. All four were
+accepting something unsound, so the refusal is the fix — but a build that
+passed on 0.11.3 may not pass on this one.
+
+- **A signature wider than its body was accepted.** `def anything -> a`
+  returning `Nothing`, or `def wrap -> Maybe(a)` returning `Just(1)`, type
+  checked: the body quietly fixed the declared variable, and every caller then
+  saw the narrower type. A declared type variable now has to stay a variable
+  through the body. Fixing it to a concrete type, or making two declared
+  variables the same, is an error that says which.
+
+- **A statement at the top level of a module is an error.** `x = 2` between
+  two `def`s type-checked, and a function reading `x` compiled clean, then
+  raised `NameError` at runtime: the binding became a local of the Ruby
+  `module` body, out of every method's reach. A module's top level holds
+  declarations only; a value belongs in a zero-argument `def`.
+
+- **A name imported from two modules picked one without a word.**
+  `import Alpha exposing (name)` beside `import Beta exposing (name)`
+  compiled, and `name` meant whichever import came last. Using it unqualified
+  is now an error naming both modules; qualified uses, and a module that never
+  uses it, still compile. The same goes for constructors and for a type named
+  in a signature. An explicit import still beats one of the stdlib's default
+  imports, now by rule rather than by the order imports were processed in.
+
+- **An implementation could fix a variable the method leaves to the call
+  site.** 0.11.0 let an interface method quantify a variable the interface
+  itself does not name, settled where the method is called. Nothing then
+  checked that the implementation was actually that general:
+
+      interface Runnable(c) with
+        to_select : Q(c) -> Sel(a) with Selectable(a)
+      end
+
+      implements Runnable(Sel(a)) with
+        to_select: (q) -> { q.result }     -- Q(Sel(a)) -> Sel(a), not -> Sel(any)
+      end
+
+  Unification bound the method's `a` to the implementation's, and the binding
+  reached no call site, so `Q(Sel(Row)) -> Sel(Other)` compiled and returned a
+  row of the wrong type. It is refused now, by name, where it is written.
+
+### Fixed
+
+- **A file that ends mid-declaration crashed `jade check`.** The parse error
+  for input that runs out carries no span, since there is no token to point
+  at, and the renderer called `.begin` on it. The diagnostic now points at the
+  last character written, where the missing part belongs, and a label with no
+  span renders as its message alone.
+
+- **A body its signature rejects crashed the compiler.** A list, a bare
+  constructor, or a binding in last position, checked against a type it could
+  not be, reached `nil.call` in `State#unify` — the crash 0.10.1 fixed for
+  record updates, at the call sites that still had no error block.
+  `def limit -> Int` returning `[1]` now reads
+  `Expected Int but got List(Int)`.
+
+- **A dictionary marker kept the var it was attached with.** A constraint
+  records its marker while inference is still running, so it holds whatever
+  type variable it had at that moment. Unification may bind that variable to
+  another one afterwards, and the enclosing function's dict parameter is keyed
+  on the second — so the lookup missed and codegen raised `no dict in scope`,
+  naming itself as the bug.
+
+  It took two constraints on one function to see it: with one, the marker's
+  var and the parameter's var were usually the same. jade-sql wanted a
+  `pluck` — one column of the caller's type out of every row — which needs
+  `Decodable(a)` threaded alongside the error widening, and neither constraint
+  alone reproduced it.
+
+  Codegen now carries the entry's substitution while it emits a body, and
+  resolves a marker's var through it before giving up.
+
+- **`import M exposing (..)` crashed the compiler.** It asked the imported
+  module for `exposed`, which does not exist, so the only way to bring a
+  module's whole surface in unqualified was a `NoMethodError`. It now
+  imports everything the module exposes, constructors included.
+
+- **A string literal's range started one byte in.** `Literal` took its range
+  from the content token, so a diagnostic on `"ab"` underlined `ab"`, and
+  anything editing source by node range landed inside the quotes.
+
+## [0.11.3] - 2026-09-16
+
+### Added
+
+- **A derived body can call a Jade function.** A deriver's body is an
+  s-expression over a fixed vocabulary, and none of it reached an ordinary
+  function: `:stdlib_fn` finds intrinsics, `:struct_constructor` finds
+  constructors, and `:call` needs a callee one of those produced. A deriver
+  that wanted to reuse a function had to rebuild it, and the copy drifts from
+  the original in silence.
+
+      [:call, [:fn, "Sql.Query.selected", [0]], [[:var, "q"]]]
+
+  The name resolves through the registry, which is what knows whether the
+  target is constrained — those are compiled twice, as `name` wrapping the Ruby
+  boundary and `__name__impl__` taking the dictionaries, and the boundary
+  wrapper is the wrong one to call from generated code.
+
+  Dictionaries come from the deriver's own `impl_arg`, one index per
+  constraint, in the order the callee declares them. A count that does not
+  match what the callee takes is refused where it is written, rather than
+  becoming Ruby that loads and misbehaves later. `[:impl_dict, i]` yields a
+  whole dictionary, where `[:impl_arg, i, fn]` yields one function out of one.
+
 ## [0.11.2] - 2026-09-15
 
 ### Fixed

data/lib/jade/ast.rb

@@ -99,7 +99,7 @@ module Jade
       ->(tokens) do
         tokens => [open, token, close]
 
-        Literal[token.value, token.range.begin...close.range.end]
+        Literal[token.value, open.range.begin...close.range.end]
       end
     end
 

data/lib/jade/codegen/context.rb

@@ -22,6 +22,23 @@ module Jade
         @dict_env = prev
       end
 
+      # The substitution of the module being emitted. A dictionary marker is
+      # attached mid-inference, so it holds whatever var the constraint had
+      # then; unification may bind that var to another, and the dict env is
+      # keyed on the second. Module-scoped because every kind of body resolves
+      # markers, not just function declarations.
+      def substitution
+        @substitution
+      end
+
+      def with_substitution(sub)
+        prev = @substitution
+        @substitution = sub
+        yield
+      ensure
+        @substitution = prev
+      end
+
       # Dictionary source => constant name, filled while a module emits.
       # A dictionary built entirely from concrete implementations depends
       # on nothing at the call site, so it is built once at load instead
@@ -58,7 +75,7 @@ module Jade
         @self_var_name = prev
       end
 
-      # False outside a Module so bare expressions (REPL) get the runtime
+      # False outside a Module so bare expressions get the runtime
       # fallback — no constants exist to reference.
       def hoist_records?
         @hoist_records

data/lib/jade/codegen/emitter.rb

@@ -6,19 +6,19 @@ module Jade
       extend self
       extend Helpers
 
-      def emit(ir)
+      def emit(ir, registry = nil)
         case ir
         in [:var, expr]
           expr
 
         in [:!, expr]
-          "!(#{emit(expr)})"
+          "!(#{emit(expr, registry)})"
 
         in [:and, expr1, expr2]
-          "#{emit(expr1)} && #{emit(expr2)}"
+          "#{emit(expr1, registry)} && #{emit(expr2, registry)}"
 
         in [:==, expr1, expr2]
-          "#{emit(expr1)} == #{emit(expr2)}"
+          "#{emit(expr1, registry)} == #{emit(expr2, registry)}"
 
         in Integer | TrueClass | FalseClass | Float
           ir.to_s
@@ -29,24 +29,33 @@ module Jade
         in [:case, subject, branches]
           branches
             .map { [:case_branch, *it] }
-            .map { emit(it) }
+            .map { emit(it, registry) }
             .join("\n")
-            .then { "case #{emit(subject)}\n#{it}\nend" }
+            .then { "case #{emit(subject, registry)}\n#{it}\nend" }
 
         in [:case_branch, pattern, body]
           body
-            .map { emit(it) }.join('; ')
-            .then { "in #{emit(pattern)} then #{it}" }
+            .map { emit(it, registry) }.join('; ')
+            .then { "in #{emit(pattern, registry)} then #{it}" }
 
         in [:call, callee, args]
           args
-            .map { emit(it) }
+            .map { emit(it, registry) }
             .join(', ')
-            .then { "#{emit(callee)}.call(#{it})"}
+            .then { "#{emit(callee, registry)}.call(#{it})"}
 
         in [:impl_arg, index, fn]
           "impl_arg[#{index}]['#{fn}']"
 
+        in [:impl_dict, index]
+          "impl_arg[#{index}]"
+
+        in [:fn, qualified_name]
+          fn_reference(qualified_name, [], registry)
+
+        in [:fn, qualified_name, dict_indices]
+          fn_reference(qualified_name, dict_indices, registry)
+
         in [:stdlib_fn, name]
           "Jade::Runtime.intr(#{name.inspect})"
 
@@ -61,18 +70,18 @@ module Jade
 
         in [:list, exprs]
           exprs
-            .map { emit(it) }
+            .map { emit(it, registry) }
             .join(', ')
             .then { "[#{it}]" }
 
         in [:hash, pairs]
           pairs
-            .map { |key, value| "#{key.inspect} => #{emit(value)}" }
+            .map { |key, value| "#{key.inspect} => #{emit(value, registry)}" }
             .join(', ')
             .then { it.empty? ? '{}' : "{ #{it} }" }
 
         in [:access, expr, key]
-          "#{emit(expr)}.#{key}"
+          "#{emit(expr, registry)}.#{key}"
 
         # patterns
 
@@ -88,6 +97,39 @@ module Jade
         end
       end
 
+      private
+
+      def fn_reference(qualified_name, dict_indices, registry)
+        registry or fail("[:fn, #{qualified_name.inspect}] needs a registry")
+
+        *module_parts, name = qualified_name.split('.')
+
+        Symbol
+          .value_ref(module_parts.join('.'), name)
+          .then { registry.lookup(it) }
+          .then { checked_reference(it, qualified_name, dict_indices, registry) }
+      end
+
+      def checked_reference(symbol, qualified_name, dict_indices, registry)
+        wanted = dict_constraints(symbol, registry).size
+
+        unless wanted == dict_indices.size
+          fail(
+            "#{qualified_name} takes #{wanted} #{wanted == 1 ? 'dictionary' : 'dictionaries'}, " \
+              "#{dict_indices.size} given — a derived body passes one impl_arg " \
+              'index per constraint, in the order the callee declares them'
+          )
+        end
+
+        target = "#{internal(symbol.module_name)}.#{fn_target_name(symbol, registry)}"
+        return "#{internal(symbol.module_name)}.method(:#{fn_target_name(symbol, registry)})" if wanted.zero?
+
+        dict_indices
+          .map { "impl_arg[#{it}]" }
+          .join(', ')
+          .then { "->(*args) { #{target}(*args, #{it}) }" }
+      end
+
     end
   end
 end

data/lib/jade/codegen/function_call.rb

@@ -113,14 +113,21 @@ module Jade
 
       def dispatch_value(entry, registry)
         case entry
-        in Type::Constraint(interface:, type: Type::Var(id:))
-          Codegen.dict_env[[interface, id]]
+        in Type::Constraint(interface:, type: Type::Var(id:) => var)
+          Codegen.dict_env[[interface, id]] || dict_for_bound_var(interface, var)
 
         in Symbol::Implementation
           hoisted(Pretty.hash(generate_impl_dispatch(entry, registry)))
         end
       end
 
+      def dict_for_bound_var(interface, var)
+        Codegen
+          .substitution
+          .apply(var)
+          .then { it.is_a?(Type::Var) ? Codegen.dict_env[[interface, it.id]] : nil }
+      end
+
       # A dictionary built only from concrete implementations is the same
       # object on every call, so it is worth building once. One that names
       # a dict parameter is not: that slot is the caller's, and differs per
@@ -393,7 +400,7 @@ module Jade
       end
 
       def emit(ir, registry)
-        Emitter.emit(ir)
+        Emitter.emit(ir, registry)
       end
     end
   end

data/lib/jade/codegen.rb

@@ -107,11 +107,13 @@ module Jade
         dict_consts = {}
 
         outer, inner, wrappers =
-          with_dict_consts(dict_consts) do
-            with_boundary_cache(boundary_cache) do
-              with_dispatched_methods(collect_dispatched_methods(body, registry)) do
-                with_hoisted_records do
-                  partition_module_body(body.expressions, registry, name.count('.'))
+          with_substitution(registry.get(name).env.substitution) do
+            with_dict_consts(dict_consts) do
+              with_boundary_cache(boundary_cache) do
+                with_dispatched_methods(collect_dispatched_methods(body, registry)) do
+                  with_hoisted_records do
+                    partition_module_body(body.expressions, registry, name.count('.'))
+                  end
                 end
               end
             end

data/lib/jade/diagnostics/renderer.rb

@@ -20,7 +20,7 @@ module Jade::Diagnostics
     def render(diagnostic)
       [
         header(diagnostic),
-        diagnostic.primary&.then { span_block(it, severity: diagnostic.severity) if it.source },
+        diagnostic.primary&.then { primary_block(it, diagnostic.severity) },
         *diagnostic
           .secondary
           .map { span_block(_1, severity: :secondary) },
@@ -41,6 +41,10 @@ module Jade::Diagnostics
 
     private
 
+    def primary_block(label, severity)
+      span_block(label, severity:) if label.source && label.span
+    end
+
     def header(diagnostic)
       "#{bold}#{color(diagnostic.severity)}#{diagnostic.severity}:#{reset} " \
         "#{bold}#{diagnostic.message}#{reset}"

data/lib/jade/entry.rb

@@ -64,19 +64,19 @@ module Jade
     end
 
     def imported_values
-      imports
-        .flat_map(&:unqualified_symbols)
-        .select { it.is_a?(Symbol::ValueRef) }
-        .map { [it.name, it] }
-        .to_h
+      unqualified(Symbol::ValueRef)
     end
 
     def imported_types
-      imports
-        .flat_map(&:unqualified_symbols)
-        .select { it.is_a?(Symbol::TypeRef) }
-        .map { [it.name, it] }
-        .to_h
+      unqualified(Symbol::TypeRef)
+    end
+
+    def ambiguous_values
+      ambiguous(Symbol::ValueRef)
+    end
+
+    def ambiguous_types
+      ambiguous(Symbol::TypeRef)
     end
 
     def values
@@ -128,6 +128,28 @@ module Jade
 
     private
 
+    def unqualified(kind)
+      imports
+        .partition(&:implicit)
+        .map { |group| refs(group, kind).to_h { [it.name, it] } }
+        .then { |(implicit, explicit)| implicit.merge(explicit) }
+    end
+
+    def ambiguous(kind)
+      imports
+        .reject(&:implicit)
+        .then { refs(it, kind) }
+        .uniq(&:qualified_name)
+        .group_by(&:name)
+        .select { |_, candidates| candidates.size > 1 }
+    end
+
+    def refs(imports, kind)
+      imports
+        .flat_map(&:unqualified_symbols)
+        .select { it.is_a?(kind) }
+    end
+
     def interface_snapshot
       value_names = exposes.filter_map { it.is_a?(Symbol::ValueRef) ? it.name : nil }.sort
       type_names  = exposes.filter_map { it.is_a?(Symbol::TypeRef)  ? it.name : nil }.sort

data/lib/jade/frontend/forward_declaration/error/ambiguous_type.rb

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module ForwardDeclaration
+      module Error
+        class AmbiguousType < Jade::Error
+          def initialize(entry, span, name:, modules:)
+            @name = name
+            @modules = modules
+            super(entry:, span:)
+          end
+
+          def message
+            "Type `#{@name}` is imported from both #{sentence(@modules)}"
+          end
+
+          def label
+            'ambiguous'
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[
+              :help,
+              "qualify it, as in `#{@modules.first}.#{@name}`, or drop it from all but one import",
+            ]]
+          end
+
+          private
+
+          def sentence(names)
+            "#{names[0...-1].join(', ')} and #{names.last}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@ require 'jade/error'
 
 require 'jade/frontend/forward_declaration/error/bad_import'
 require 'jade/frontend/forward_declaration/error/alias_expansion'
+require 'jade/frontend/forward_declaration/error/ambiguous_type'
 require 'jade/frontend/forward_declaration/error/duplicate_constructor_name'
 require 'jade/frontend/forward_declaration/error/duplicate_type_name'
 require 'jade/frontend/forward_declaration/error/exposed_type_not_found'

data/lib/jade/frontend/forward_declaration/helper.rb

@@ -123,6 +123,13 @@ module Jade
         private
 
         def require_type(entry, name, span)
+          if !entry.defined_types.key?(name) && (candidates = entry.ambiguous_types[name])
+            return Err[Error::AmbiguousType.new(
+              entry.name, span, name:,
+              modules: candidates.map(&:module_name),
+            )]
+          end
+
           entry.lookup_type(name)
             &.then { Ok[it] } ||
             Err[Error::TypeNotFound.new(

data/lib/jade/frontend/forward_declaration/import_declaration.rb

@@ -19,7 +19,15 @@ module Jade
           end
 
           exposing_to_symbol(exposing, entry, importing_module)
-            .map { ImportEntry[module_name, as&.as || module_name, it, importing_module.exposes] }
+            .map do
+              ImportEntry.new(
+                module_name:,
+                alias: as&.as || module_name,
+                unqualified_symbols: it,
+                qualified_symbols: importing_module.exposes,
+                implicit: false,
+              )
+            end
             .on_err { return Result[entry, it] } => Ok(import_entry)
 
           Result[entry.import(import_entry), []]
@@ -34,7 +42,7 @@ module Jade
         def exposing_to_symbol(exposing, current_entry, importing_module)
           case exposing
           in AST::ExposeNone then Ok[[]]
-          in AST::ExposeAll then Ok[importing_module.exposed]
+          in AST::ExposeAll then Ok[importing_module.exposes.to_a]
           in AST::ExposeList(items:) then handle_exposing_list(items, current_entry, importing_module)
           end
         end

data/lib/jade/frontend/semantic_analysis/constructor_reference.rb

@@ -26,6 +26,11 @@ module Jade
                   .add_errors([it])
               end
 
+          in Symbol::Ambiguous(modules:)
+            Result
+              .init(node, scope)
+              .add_errors([Error::AmbiguousName.new(entry.name, node.range, name:, modules:)])
+
           in symbol
             Result.init(node.with(symbol: symbol.to_ref), scope)
           end

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

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class AmbiguousName < Jade::Error
+          def initialize(entry, span, name:, modules:)
+            @name = name
+            @modules = modules
+            super(entry:, span:)
+          end
+
+          def message
+            "`#{@name}` is imported from both #{sentence(@modules)}"
+          end
+
+          def label
+            'ambiguous'
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[
+              :help,
+              "qualify it, as in `#{@modules.first}.#{@name}`, or drop it from all but one import",
+            ]]
+          end
+
+          private
+
+          def sentence(names)
+            "#{names[0...-1].join(', ')} and #{names.last}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Jade
+  module Frontend
+    module SemanticAnalysis
+      module Error
+        class TopLevelStatement < Jade::Error
+          def initialize(entry, span)
+            super(entry:, span:)
+          end
+
+          def message
+            "Only declarations can appear at the top level of a module"
+          end
+
+          def label
+            'not a declaration'
+          end
+
+          def notes
+            [Jade::Diagnostics::Annotation[
+              :help,
+              'a value belongs in a zero-argument `def`, like `def limit -> Int`',
+            ]]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 require 'jade/error'
 
 require 'jade/frontend/semantic_analysis/error/no_base_case'
+require 'jade/frontend/semantic_analysis/error/ambiguous_name'
 require 'jade/frontend/semantic_analysis/error/circular_extends'
 require 'jade/frontend/semantic_analysis/error/constant_not_callable'
 require 'jade/frontend/semantic_analysis/error/constructor_not_found'
@@ -25,6 +26,7 @@ require 'jade/frontend/semantic_analysis/error/predicate_must_return_bool'
 require 'jade/frontend/semantic_analysis/error/predicate_name_not_allowed'
 require 'jade/frontend/semantic_analysis/error/recursive_type_alias'
 require 'jade/frontend/semantic_analysis/error/shadowing_error'
+require 'jade/frontend/semantic_analysis/error/top_level_statement'
 require 'jade/frontend/semantic_analysis/error/type_args_mismatch'
 require 'jade/frontend/semantic_analysis/error/type_param_required'
 require 'jade/frontend/semantic_analysis/error/unbound_type_variable'

data/lib/jade/frontend/semantic_analysis/module_node.rb

@@ -5,6 +5,17 @@ module Jade
         extend self
         extend Helper
 
+        DECLARATIONS = [
+          AST::FunctionDeclaration,
+          AST::TypeDeclaration,
+          AST::TypeAliasDeclaration,
+          AST::StructDeclaration,
+          AST::InterfaceDeclaration,
+          AST::Implementation,
+          AST::ImportDeclaration,
+          AST::InteropImportDeclaration,
+        ].freeze
+
         def analyze(node, registry, scope, entry)
           node => AST::Module(body:, exposing:)
 
@@ -19,7 +30,16 @@ module Jade
             .combine(node, scope:,
               body: analyze_node(body, registry, scope, entry),
             )
-            .add_errors(exposing_errors)
+            .add_errors(exposing_errors + statement_errors(body, entry))
+        end
+
+        private
+
+        def statement_errors(body, entry)
+          body
+            .expressions
+            .reject { |node| DECLARATIONS.any? { node.is_a?(it) } }
+            .map { Error::TopLevelStatement.new(entry.name, it.range) }
         end
       end
     end

data/lib/jade/frontend/semantic_analysis/variable_reference.rb

@@ -17,6 +17,11 @@ module Jade
                 candidates: scope.bindings.keys,
               )])
 
+          in Symbol::Ambiguous(modules:)
+            Result
+              .init(node.with(symbol: Symbol.var(name, node.range)), scope)
+              .add_errors([Error::AmbiguousName.new(entry.name, node.range, name:, modules:)])
+
           in symbol
             Result.init(node.with(symbol:), scope)
           end

data/lib/jade/frontend/semantic_analysis.rb

@@ -53,11 +53,6 @@ module Jade
           .then { it.errors.any? ? Err[it.errors] : Ok[entry.with(ast: it.node)] }
       end
 
-      def analyze_repl(ast, registry, scope, entry)
-        analyze_node(ast, registry, scope, entry)
-          .then { it.errors.any? ? Err[it.errors] : Ok[[it.node, it.scope]] }
-      end
-
       def analyze_entry(entry, registry)
         analyze(entry, registry)
       end
@@ -66,7 +61,10 @@ module Jade
 
       def initialize_scope(entry)
         entry
-          .values
+          .ambiguous_values
+          .reject { |name, _| entry.defined_values.key?(name) }
+          .to_h { |name, refs| [name, Symbol::Ambiguous[name, refs.map(&:module_name)]] }
+          .then { entry.values.merge(it) }
           .reduce(Scope.new) { |acc, (unq_name, sym)| acc.bind(unq_name, sym) }
       end
 

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

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class NarrowedMethodVariable < Jade::Error
+          def initialize(entry, span, interface:, fn_name:, var_name:, bound_to:)
+            super(entry:, span:)
+            @interface = interface
+            @fn_name   = fn_name
+            @var_name  = var_name
+            @bound_to  = bound_to
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name} fixes `#{@var_name}` to " \
+              "#{@bound_to}, which #{@fn_name} leaves to the call site"
+          end
+
+          def label
+            "fixes `#{@var_name}`"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                "the implementation has to work for every `#{@var_name}` the " \
+                  'method is written for, not one of them',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -36,7 +36,11 @@ module Jade
             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)
+              .unify_result(
+                expr_result.with(constraints: residual_cs),
+                expected.type,
+                &type_mismatch(state, node)
+              )
           end
 
           private

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/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.rb

@@ -7,6 +7,7 @@ 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/port_resolution'
 require 'jade/frontend/type_checking/requirements'
 require 'jade/frontend/type_checking/result'
@@ -126,11 +127,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/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.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.2'
+  VERSION = '0.12.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -126,6 +126,7 @@ files:
 - lib/jade/frontend/forward_declaration/body.rb
 - lib/jade/frontend/forward_declaration/error.rb
 - lib/jade/frontend/forward_declaration/error/alias_expansion.rb
+- lib/jade/frontend/forward_declaration/error/ambiguous_type.rb
 - lib/jade/frontend/forward_declaration/error/bad_import.rb
 - lib/jade/frontend/forward_declaration/error/duplicate_constructor_name.rb
 - lib/jade/frontend/forward_declaration/error/duplicate_type_name.rb
@@ -164,6 +165,7 @@ files:
 - lib/jade/frontend/semantic_analysis/char_literal.rb
 - lib/jade/frontend/semantic_analysis/constructor_reference.rb
 - lib/jade/frontend/semantic_analysis/error.rb
+- lib/jade/frontend/semantic_analysis/error/ambiguous_name.rb
 - lib/jade/frontend/semantic_analysis/error/circular_extends.rb
 - lib/jade/frontend/semantic_analysis/error/constant_not_callable.rb
 - lib/jade/frontend/semantic_analysis/error/constructor_not_found.rb
@@ -189,6 +191,7 @@ files:
 - lib/jade/frontend/semantic_analysis/error/predicate_name_not_allowed.rb
 - lib/jade/frontend/semantic_analysis/error/recursive_type_alias.rb
 - lib/jade/frontend/semantic_analysis/error/shadowing_error.rb
+- lib/jade/frontend/semantic_analysis/error/top_level_statement.rb
 - lib/jade/frontend/semantic_analysis/error/type_args_mismatch.rb
 - lib/jade/frontend/semantic_analysis/error/type_param_required.rb
 - lib/jade/frontend/semantic_analysis/error/unbound_type_variable.rb
@@ -264,6 +267,8 @@ files:
 - lib/jade/frontend/type_checking/error/list_item_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/missing_implementation.rb
 - lib/jade/frontend/type_checking/error/missing_patterns.rb
+- lib/jade/frontend/type_checking/error/narrowed_method_variable.rb
+- lib/jade/frontend/type_checking/error/narrowed_signature.rb
 - lib/jade/frontend/type_checking/error/pattern_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/port_not_decodable.rb
 - lib/jade/frontend/type_checking/error/port_not_encodable.rb
@@ -309,6 +314,7 @@ files:
 - lib/jade/frontend/type_checking/inference/variable_reference.rb
 - lib/jade/frontend/type_checking/instantiation.rb
 - lib/jade/frontend/type_checking/loader.rb
+- lib/jade/frontend/type_checking/narrowing.rb
 - lib/jade/frontend/type_checking/placeholder.rb
 - lib/jade/frontend/type_checking/port_resolution.rb
 - lib/jade/frontend/type_checking/requirements.rb
@@ -381,6 +387,7 @@ files:
 - lib/jade/stdlib/tuple.rb
 - lib/jade/symbol.rb
 - lib/jade/symbol/alias.rb
+- lib/jade/symbol/ambiguous.rb
 - lib/jade/symbol/anonymous_record.rb
 - lib/jade/symbol/base.rb
 - lib/jade/symbol/constructor.rb