jade-lang 0.11.3 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5529a34cf9b8a3d407d78642bca0281ec0a422dcded4f5875636e85f7018d7e4
-  data.tar.gz: c8da773021523ebb4d93836d8c8dee0ba0dca6acf4115f32ff46443a8dfbf08e
+  metadata.gz: 1b6d2de0940d8842121c48456180fa3cbc04345d0bf991c31f8e008019c4e017
+  data.tar.gz: 425323f1b3c92b1d817b088a3973b86c94f7743fe185197cb5d60c680281184f
 SHA512:
-  metadata.gz: 26bab9740a9f008e4611a52210ec002f314e1fec4169239cd1a4aaa37eb090829a6fd20f4742ab475c169e4dc856652deddf12eca95f862f413668accdeda724
-  data.tar.gz: 243a05ffe69948767ccb7900b4e2cf443dccdb50d540f6cd16998863a6917e2742718769b742c0d0bf9f1e121aa4ee51cd85b70084ea7f26d669a1e49bf14d54
+  metadata.gz: 0da5c33762fdac3b212474c72925c1d47c48b915f7b4a6877a6328b3c07ac15430e0f97c5647d714886d498c94850a1a448100ae29cfd73d7f97abc3bfc2248c
+  data.tar.gz: ee26d40ebaa14f0587675692a83d977f6e7eae0ba80c342929847636c9c5509778fa7e19977974deb2421bf7cab0e17a066cafd4188f121d6165347cd1a4b3b4

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.1] - 2026-09-21
+
+Both of these make code compile that should have compiled, so they ride a
+patch rather than waiting for a minor.
+
+### Fixed
+
+- **A pattern in a lambda is checked against the type the caller gives it.**
+  Coverage was decided where the pattern was written, which for a lambda is
+  before the call that types its parameter — so the subject was still a
+  variable and anything but a binding or a wildcard was reported as
+  non-exhaustive. `(a, b) = p` inside a `List.map` is the common shape;
+  `Tuple.first` / `Tuple.second` or a one-armed `case` were the workarounds.
+  Coverage and redundancy now run once inference has finished.
+
+### Added
+
+- **`Show` renders a `Dict` and a `Set`.** Both already had `Eq`, so they
+  compared but could not be printed, and anything that shows a value on
+  failure — a test assertion, a debug line — stopped compiling at
+  `Show cannot be derived for Dict(String, Int)`. Keys, values and elements
+  render through their own instances, so a `String` key keeps its quotes and a
+  nested list prints as a list.
+
+## [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

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

data/lib/jade/codegen/inlines.rb

@@ -178,6 +178,8 @@ module Jade
       # Bodies that don't fit a single Ruby expression.
       NO_INLINE = %w[
         Number.checked
+        Dict.show_with
+        Set.show_with
         List.sort_with
         List.sort_by_with
         List.filter_map

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/constraints/deriving/show.rb

@@ -24,6 +24,8 @@ module Jade
             # reason. Contained because derivation is private — see
             # vault jade/plans/jade-test-runner.md for the four layers involved.
             LIST = 'List.List'
+            DICT = 'Dict.Dict'
+            SET = 'Set.Set'
 
             def special_case(constraint, lookup)
               case constraint.type
@@ -33,6 +35,12 @@ module Jade
               in Type::Application(constructor: Type::Constructor(name: LIST), args: [inner])
                 list_show(constraint, inner, lookup)
 
+              in Type::Application(constructor: Type::Constructor(name: DICT), args: [key, value])
+                container_show(constraint, [key, value], 'Dict.show_with', lookup)
+
+              in Type::Application(constructor: Type::Constructor(name: SET), args: [inner])
+                container_show(constraint, [inner], 'Set.show_with', lookup)
+
               else
                 nil
               end
@@ -57,6 +65,22 @@ module Jade
                 end
             end
 
+            # Threads each element's own `show` into the stdlib function that
+            # renders the container.
+            def container_show(constraint, inners, fn, lookup)
+              inners
+                .map { lookup.call(Type.constraint(INTERFACE, it, constraint.origin)) }
+                .then { Results.sequence(it) }
+                .and_then do |deps|
+                  args = deps.each_index.map { [:impl_arg, it, 'show'] } + [[:var, 'value']]
+
+                  Symbol::DerivedFunction
+                    .new(params: ['value'], body: [:call, [:stdlib_fn, fn], args])
+                    .then { Ok[implementation(constraint, { 'show' => it }, deps:)] }
+                end
+            end
+
+
             def constant(text)
               Symbol::DerivedFunction.new(params: ['value'], body: text)
             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