jade-lang 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6886eb468004c2c500090b0a919a1a369e31b36039b3a6ef583bb74bc5e7326b
-  data.tar.gz: eaa9bb82c455efa0ca5c9e86eefe7d6ae6a56b1a9c8d695ae484500b69c1e049
+  metadata.gz: 1cb9527b610f268fc9ae7d784abcbf41018cf99f91b0bdaea462a655a8f12bfb
+  data.tar.gz: d888ed1e08771d41147879b5576c0b894f94795af1e4f849f6ca31044661366b
 SHA512:
-  metadata.gz: 5a27df2bd32afa406b3205ca40ea047231cfe95c169cc38918b453278675d889ff9038ef93a2d08fd5caeb94683cc47cc5d498c8a5daa0e086a7f98630f733d7
-  data.tar.gz: e7fd05fc7622d6268f6ad109e8c6ad2b44df4961f668515d4eafb69767fa437d9b34d13276946723b58486d1393698fb713dba7a484965524753d913e779a9ee
+  metadata.gz: 95f7b32d5542bb1d386d18a7e1e8749de7a7f5c6ecfffaacee351dcb0d4205d698269954fe4fc023f2fed3cc7fe9f32c0f6344f9415770916ea6237be3f16e8f
+  data.tar.gz: 897851f20e95afe86c92a7c4fe104299b46a4239644f06ea26c5580f5d47660834560e5c218336efc3d569f56e5754b8c68e45b1e68524166d347bdf5d178bb6

data/CHANGELOG.md

@@ -6,6 +6,94 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.4.0]
+
+### Changed
+
+- **Port arguments are encoded on the way out**, the mirror of the return value
+  being decoded on the way back. A port declared `Instant, Int -> Task(Instant,
+  Never)` used to hand Ruby a live `Jade::Clock::Instant` while demanding an ISO
+  string back; both sides are now the wire form. **Every argument type needs an
+  `Encodable` instance** — a port taking one without it is a compile error
+  (``Port `shift` cannot encode argument 1 (`Shape`): no Encodable instance``)
+  rather than a value leaking Jade's internals into Ruby. Declare the argument
+  as `Decode.Value` to opt out and pass it untouched. A port whose arguments are
+  primitives is unaffected; one taking a struct, a `Clock`/`Calendar`/`Decimal`
+  type, or a type variable now receives encoded data, so its Ruby side needs
+  updating.
+
+### Added
+
+- `Show`, an interface rendering a value the way Jade writes it: `show(B(2))`
+  is `"B(2)"`, `show(Point(3, 4))` is `"Point { x: 3, y: 4 }"`, a list shows
+  through its elements. Instances ship for the primitives and derive for
+  unions, structs and records — including a variant that mixes a type
+  parameter with a concrete type. A function shows as `<function>` rather than
+  refusing. `Never` has an instance too, so an annotated `Result(a, Never)` —
+  what a port-free task returns — is showable; it raises rather than printing
+  a plausible string, since it has no values to render.
+- `Debug.log(label, value)` prints `label: value` to stderr and returns the
+  value untouched, so it drops into a pipeline without changing it.
+- `Encodable` and `Decodable` derive for tuples, `Dict` and `Set`, from their
+  elements' instances — the same way `List` and `Maybe` already did. The
+  combinators (`Encode.tuple`, `Decode.dict`, …) existed all along; nothing
+  resolved them, so a `(String, Int)` port argument or a `Task(Dict(k, v), e)`
+  arm was rejected for want of an instance. A tuple crosses as a positional
+  array, a dict as `[key, value]` pairs, a set as an array that drops
+  duplicates on the way back. Adds the two functions the set instances needed,
+  `Encode.set` and `Decode.set`.
+- `Encodable` and `Decodable` instances for `Decode.Value`, both the identity,
+  plus the `Decode.value` and `Encode.value` functions behind them. `Value` is
+  the un-decoded value, and it opted out of conversion only as a whole arm or
+  argument: `List(Value)`, `Maybe(Value)`, and a struct with a `Value` field
+  had no instance to derive from and were rejected at the boundary.
+- A parse error inside a `uses`, `interface`, or `implements` block where the
+  entries are separated by newlines instead of commas says so, instead of only
+  reporting the next entry as an unexpected token.
+
+### Fixed
+
+- `Eq` derives for a union whose variants carry concrete types. `B(1) == B(1)`
+  over `type Box = B(Int) | Empty` took the compiler down with a
+  `NoMatchingPatternError`; `Just(1) == Just(1)` only worked because `Maybe`'s
+  payload is a type parameter. Variants mixing a parameter with a concrete
+  type derive too.
+- Diagnostic source excerpts are sliced by byte offset. Spans and line starts
+  are the lexer's byte offsets, but the excerpt was cut and measured in
+  characters, so one multi-byte glyph anywhere earlier in the file shifted every
+  later excerpt and its caret — `def notify_channel(…)` printed as
+  `f notify_channel(…)`.
+- Exhaustiveness checking no longer collapses when the scrutinee is a tuple.
+  `case (a, b)` over two `Maybe`s reported `Missing cases: (_, _)` with all four
+  arms present, and the `else` that silenced it hid genuinely missing cases from
+  then on. Two bugs: a tuple's element types were replaced with fresh type
+  variables, and specializing on a constructor dropped the types of every column
+  after it. A constructor the first column never mentions is now answered from
+  the rows that would have covered it, which is also what keeps a recursive type
+  from expanding forever — the recursion guard that used to do that job is gone,
+  and with it the false "exhaustive" verdicts it caused on any second column.
+- The missing-constructor diagnostic tells you which `exposing` list is missing
+  the `(..)`. When the defining module already exposes `Route(..)` and it's the
+  importer's `import Routes exposing (Route)` that brought in the type alone, it
+  no longer sends you to the wrong file. It also fires for a variant whose name
+  differs from its type's (`Home` of `Route`), which previously got no hint.
+
+## [0.3.1]
+
+### Fixed
+
+- A module whose dependency failed to compile is no longer type checked. It
+  reached for bindings the broken module never produced and raised through the
+  compiler, naming the importer rather than the module at fault, and the
+  original error was never reported. Dependents now say which dependency
+  failed, and modules broken independently of each other are all still
+  reported.
+- The load-path line at the top of every compiled entry module appends the
+  application's `lib` instead of prepending it. At position 0 it shadowed, for
+  the whole process, any gem sharing a name with a directory under `lib` —
+  `sidekiq/`, `sentry/`, `warden/`. The line exists so `uses App::Thing` can
+  resolve `lib/app/thing.rb`; it never needed to outrank gems.
+
 ## [0.3.0]
 
 ### Changed
@@ -99,7 +187,9 @@ Initial release.
 - `jade` CLI dispatcher: `fmt`, `lsp`, `q`.
 - Language server and headless query interface for editor/agent tooling.
 
-[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/agustinrhcp/jade/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/agustinrhcp/jade/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/agustinrhcp/jade/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/agustinrhcp/jade/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/agustinrhcp/jade/compare/v0.1.0...v0.1.1

data/README.md

@@ -148,7 +148,7 @@ at compile time, no annotation needed. You can define your own, with
 implementations dispatched by type:
 
 ```jade
-module Shows exposing (describe)
+module Labels exposing (person_label)
 
 struct Person = {
   name: String,
@@ -156,18 +156,18 @@ struct Person = {
 }
 
 
-interface Show(a) with
-  show : a -> String
+interface Labelled(a) with
+  label : a -> String
 end
 
 
-implements Show(Person) with
-  show: (p) -> { p.name ++ " (" ++ String.from_int(p.age) ++ ")" }
+implements Labelled(Person) with
+  label: (p) -> { p.name ++ " (" ++ String.from_int(p.age) ++ ")" }
 end
 
 
-def describe(p: Person) -> String
-  show(p)
+def person_label(p: Person) -> String
+  label(p)
 end
 ```
 
@@ -357,8 +357,9 @@ pre-commit hook.
 ## Standard library
 
 `Basics`, `String`, `Char`, `List`, `Dict`, `Set`, `Tuple`, `Maybe`, `Result`,
-`Task`, `Decode`, `Encode`, `Bytes`, `Calendar`, `Clock`, `Decimal`. Stdlib operations
-compile inline rather than through a runtime dispatch layer.
+`Task`, `Decode`, `Encode`, `Bytes`, `Calendar`, `Clock`, `Decimal`, `Show`,
+`Debug`. Stdlib operations compile inline rather than through a runtime
+dispatch layer.
 
 ## Docs
 
@@ -374,8 +375,8 @@ compile inline rather than through a runtime dispatch layer.
 
 Early and experimental — being tried out on small projects.
 
-**In progress:** `Comparable` / `Show` derivation for user types, partial
-record types in signatures, a stable REPL.
+**In progress:** `Comparable` derivation for user types, partial record types
+in signatures, a stable REPL.
 
 **Not great for:** throwaway scripts, libraries you ship to other Ruby
 projects (they'd inherit the dependency), and performance-critical hot paths

data/lib/jade/codegen/function_call.rb

@@ -180,7 +180,7 @@ module Jade
         in Symbol::InteropFunction
           registry
             .lookup(callee.symbol.to_ref)
-            .then { PortDecoder.task_call(it, registry, dictionaries) }
+            .then { PortCodec.task_call(it, registry, dictionaries) }
 
         in Symbol::StdlibFunction => symbol if symbol.constraints.any?
           dictionaries

data/lib/jade/codegen/inlines.rb

@@ -16,6 +16,15 @@ module Jade
       }.freeze
 
       INLINES = {
+        'Debug.log'         => ->(l, v) { "Jade::Debug.log(#{l}, #{v})" },
+        'Show.int_show'   => ->(n)    { "#{n}.to_s" },
+        'Show.float_show' => ->(f)    { "#{f}.to_s" },
+        'Show.bool_show'  => ->(b)    { "#{b}.to_s" },
+        'Show.str_show'   => ->(s)    { "#{s}.inspect" },
+        'Show.char_show'  => ->(c)    { "#{c}.inspect" },
+        # Never is uninhabited, so reaching this is a compiler bug, not a
+        # rendering problem — say so rather than print a plausible string.
+        'Show.never_show' => ->(_)    { 'fail("Show.never_show: Never has no values")' },
         'Basics.identity'   => ->(a)    { a },
         'Basics.always'     => ->(x)    { "->(_) { #{x} }" },
         'Basics.int_add'    => ->(a, b) { "(#{a} + #{b})" },
@@ -191,6 +200,7 @@ module Jade
         Decode.optional_field
         Decode.required
         Decode.sequence
+        Decode.set
         Decode.string
         Decode.string_enum
         Decode.succeed
@@ -198,6 +208,7 @@ module Jade
         Decode.tuple3
         Decode.tuple4
         Decode.type_
+        Decode.value
         Decode.variant
         Encode.bool
         Encode.dict
@@ -209,10 +220,12 @@ module Jade
         Encode.null
         Encode.nullable
         Encode.object
+        Encode.set
         Encode.string
         Encode.tuple
         Encode.tuple3
         Encode.tuple4
+        Encode.value
         Encode.variant
         Task.and_then
         Task.fail

data/lib/jade/codegen/{port_decoder.rb → port_codec.rb}

@@ -1,18 +1,20 @@
 module Jade
   module Codegen
-    module PortDecoder
+    module PortCodec
       extend self
 
-      PASS = "Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]"
+      PASS_DECODER = "Jade::Decode::Decoder[Jade::Decode::Desc::Pass[]]"
+      PASS_ENCODER = "->(v) { v }"
 
       # `dictionaries` is the call site's constraint-attachment list; only
-      # used when an arm is a Dict marker.
+      # used when an arm or a parameter is a Dict marker.
       def task_call(interop_fn, registry, dictionaries = [])
         [
           interop_fn.interop_module_name,
           ":#{interop_fn.name}",
-          decoder(interop_fn, :ok, registry, dictionaries),
-          decoder(interop_fn, :err, registry, dictionaries),
+          codec(interop_fn.decoders.fetch(:ok), 'decoder', interop_fn, registry, dictionaries),
+          codec(interop_fn.decoders.fetch(:err), 'decoder', interop_fn, registry, dictionaries),
+          encoders(interop_fn, registry, dictionaries),
         ]
           .join(', ')
           .then { "Jade::Runtime.task_call(#{it})" }
@@ -20,32 +22,42 @@ module Jade
 
       private
 
-      # Per-arm decoder. PortResolution stamps one of:
-      # - :pass — Decode.Value or Never arm, no decoder needed
+      def encoders(interop_fn, registry, dictionaries)
+        interop_fn
+          .encoders
+          .map { codec(it, 'encoder', interop_fn, registry, dictionaries) }
+          .join(', ')
+          .then { "[#{it}]" }
+      end
+
+      # Per-arm, per-argument codec. PortResolution stamps one of:
+      # - :pass — Decode.Value or Never, nothing to convert
       # - Symbol::Implementation — concrete OR partial impl (with marker
       #   deps for free vars). We push a synthetic dict_env mapping the
       #   port's vars to the call-site dictionaries so generate_impl_dispatch
       #   can resolve markers uniformly.
-      # - Symbol::InteropFunction::Dict — bare-var arm, decoder comes
+      # - Symbol::InteropFunction::Dict — bare-var position; the codec comes
       #   from the caller's threaded dictionary at the given constraint index
-      def decoder(interop_fn, arm, registry, dictionaries)
-        case interop_fn.decoders.fetch(arm)
+      def codec(resolution, kind, interop_fn, registry, dictionaries)
+        case resolution
         in Symbol::InteropFunction::PASS
-          PASS
+          kind == 'decoder' ? PASS_DECODER : PASS_ENCODER
 
         in Symbol::Implementation => impl
-          emit_impl_decoder(impl, interop_fn, dictionaries, registry)
+          emit_impl_codec(impl, kind, interop_fn, dictionaries, registry)
 
         in Symbol::InteropFunction::Dict(constraint_index:)
-          "#{FunctionCall.dispatch_value(dictionaries.fetch(constraint_index), registry)}[\"decoder\"]"
+          FunctionCall
+            .dispatch_value(dictionaries.fetch(constraint_index), registry)
+            .then { "#{it}[#{kind.inspect}]" }
         end
       end
 
-      def emit_impl_decoder(impl, interop_fn, dictionaries, registry)
+      def emit_impl_codec(impl, kind, interop_fn, dictionaries, registry)
         synthetic_env = build_synthetic_dict_env(impl, interop_fn, dictionaries, registry)
 
         Codegen.with_dict_env(synthetic_env) {
-          FunctionCall.generate_impl_dispatch(impl, registry).fetch('decoder')
+          FunctionCall.generate_impl_dispatch(impl, registry).fetch(kind)
         }
       end
 

data/lib/jade/codegen.rb

@@ -19,7 +19,7 @@ require 'jade/codegen/transforms/fold_shape'
 require 'jade/codegen/function_declaration'
 require 'jade/codegen/function_call'
 require 'jade/codegen/implementation'
-require 'jade/codegen/port_decoder'
+require 'jade/codegen/port_codec'
 
 module Jade
   module Codegen
@@ -159,7 +159,7 @@ module Jade
           in Symbol::InteropFunction => sym
             registry
               .lookup(sym.to_ref)
-              .then { PortDecoder.task_call(it, registry) }
+              .then { PortCodec.task_call(it, registry) }
 
           in Symbol::StdlibFunction(codegen:)
             codegen
@@ -393,8 +393,12 @@ module Jade
       node.is_a?(AST::ImportDeclaration) || node.is_a?(AST::InteropImportDeclaration)
     end
 
+    # Appended, not prepended: this exists so `uses App::Thing` can find
+    # `lib/app/thing.rb`, and an application's lib directory routinely holds
+    # directories named after the gems it depends on. At position 0 those
+    # shadow the real gems for the whole process.
     def load_path
-      '$LOAD_PATH.unshift(File.expand_path("lib"))'
+      '$LOAD_PATH.push(File.expand_path("lib")).uniq!'
     end
   end
 end

data/lib/jade/debug.rb

@@ -0,0 +1,59 @@
+module Jade
+  module Debug
+    extend self
+
+    MAX_DEPTH = 12
+
+    def log(label, value)
+      warn("#{label}: #{render(value)}")
+      value
+    end
+
+    def render(value, depth = 0)
+      return '…' if depth > MAX_DEPTH
+
+      case value
+      when ::String then value.inspect
+      when ::Symbol then value.to_s
+      when nil then 'Nothing'
+      when true, false, ::Integer, ::Float then value.to_s
+      when ::Array then render_list(value, depth)
+      when ::Hash then render_record(value, depth)
+      when ::Data then render_variant(value, depth)
+      when ::Proc then '<function>'
+      else value.inspect
+      end
+    end
+
+    private
+
+    def render_list(items, depth)
+      '[' + items.map { render(it, depth + 1) }.join(', ') + ']'
+    end
+
+    def render_record(fields, depth)
+      return '{}' if fields.empty?
+
+      '{ ' + fields.map { |k, v| "#{k}: #{render(v, depth + 1)}" }.join(', ') + ' }'
+    end
+
+    def render_variant(value, depth)
+      name = constructor_name(value)
+      args = value.deconstruct
+
+      return '(' + args.map { render(it, depth + 1) }.join(', ') + ')' if name.match?(/\ATuple\d+\z/)
+      return name if args.empty?
+      return "#{name}(#{args.map { render(it, depth + 1) }.join(', ')})" if positional?(value)
+
+      "#{name} " + render_record(value.to_h, depth)
+    end
+
+    def positional?(value)
+      value.members.each_with_index.all? { |m, i| m.to_s == "_#{i + 1}" }
+    end
+
+    def constructor_name(value)
+      value.class.name.to_s.split('::').last.then { it.empty? ? 'Anonymous' : it }
+    end
+  end
+end

data/lib/jade/diagnostics/renderer.rb

@@ -49,13 +49,13 @@ module Jade::Diagnostics
     def span_block(label, severity:)
       loc = location_of(label.source, label.span.begin)
       end_offset = [label.span.end - 1, 0].max
-      end_loc = location_of(label.source, [end_offset, label.source.text.length - 1].min)
+      end_loc = location_of(label.source, [end_offset, label.source.text.bytesize - 1].min)
       multiline = end_loc.line > loc.line
       gutter_w = (multiline ? end_loc.line : loc.line).to_s.length
       blank = " " * gutter_w
       col_offset = loc.col - 1
       first_line = extract_line(label.source, loc.line).chomp
-      span_len = [multiline ? first_line.length - col_offset : label.span.size, 1].max
+      span_len = [multiline ? first_line.length - col_offset : span_width(label), 1].max
       caret = severity == :secondary ? "-" : "^"
       underline = " " * col_offset + caret * span_len
       ann_text = label.message ? " #{label.message}" : ""
@@ -91,15 +91,26 @@ module Jade::Diagnostics
 
     Location = Data.define(:line, :col)
 
+    # Spans and line starts are byte offsets — the lexer's — while everything
+    # drawn here is counted in characters: slice the text by byte offset, then
+    # measure the result.
     def location_of(source, offset)
       (source.line_starts.rindex { _1 <= offset } || 0)
-        .then { Location[it + 1, offset - source.line_starts[it] + 1] }
+        .then { Location[it + 1, column_of(source, source.line_starts[it], offset)] }
+    end
+
+    def column_of(source, line_start, offset)
+      source.text.byteslice(line_start, offset - line_start).length + 1
+    end
+
+    def span_width(label)
+      label.source.text.byteslice(label.span.begin, label.span.size).length
     end
 
     def extract_line(source, line_number)
       s = source.line_starts[line_number - 1]
-      e = source.line_starts[line_number] || source.text.length
-      source.text[s...e]
+      e = source.line_starts[line_number] || source.text.bytesize
+      source.text.byteslice(s, e - s)
     end
 
     def color(severity)

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

@@ -47,8 +47,8 @@ module Jade
         end
 
         def fn_type_to_interop(interop_mod_name, function_node, symbol, entry, registry)
-          lifted_errors = Interop::Lowering
-            .validate(symbol.return_type, registry, entry)
+          lifted_errors = [symbol.return_type, *symbol.params]
+            .flat_map { Interop::Lowering.validate(it, registry, entry) }
             .map { Error::TypeNotLowerable.new(entry, function_node.range, message: it.message) }
 
           Symbol
@@ -57,7 +57,8 @@ module Jade
               symbol.params,
               symbol.return_type,
               interop_mod_name.name,
-              constraints: implicit_decodable_constraints(symbol.return_type),
+              constraints: implicit_decodable_constraints(symbol.return_type) +
+                implicit_encodable_constraints(symbol.params),
             )
             .then { [it, lifted_errors] }
         end
@@ -78,6 +79,15 @@ module Jade
           end
         end
 
+        # Arguments travel the other way, so a free variable in a parameter
+        # needs the caller's Encodable instance rather than its Decodable one.
+        def implicit_encodable_constraints(params)
+          params
+            .flat_map { collect_var_names(it) }
+            .uniq
+            .map { ['Encode.Encodable', it] }
+        end
+
         def collect_var_names(type_sym)
           case type_sym
           in Symbol::Variable(name:)

data/lib/jade/frontend/pattern_analysis/matrix.rb

@@ -39,7 +39,7 @@ module Jade
           with(rows: rows + other.rows)
         end
 
-        def missing_patterns(env, seen_recursive_types = ::Set.new)
+        def missing_patterns(env)
           if types.empty?
             return rows.empty? ? Matrix[[[]], types] : Matrix.empty
           end
@@ -49,37 +49,72 @@ module Jade
           return Matrix.empty if never?(type)
           return Matrix.wildcard(types) if rows.empty?
 
-          if infinite?(type) || type_var?(type) || seen_recursive_types.include?(type)
-            matrix = default
-              .missing_patterns(env, seen_recursive_types)
+          heads = head_constructors
 
-            matrix
-              .map { [Wildcard[]] + it }
+          if infinite?(type) || type_var?(type)
+            unmatched_column(env)
 
           elsif expandable?(type, env)
-            expand(env).missing_patterns(env, seen_recursive_types)
+            expand(env).missing_patterns(env)
+
+          elsif heads.empty?
+            unmatched_column(env)
 
           else
-            new_seen = seen_recursive_types | ::Set[type]
             constructors_of(type, env)
               .reduce(Matrix.empty.with(types:)) do |acc, constructor|
-                missing = specialize(constructor)
-                  .missing_patterns(env, new_seen)
-
-                missing
-                  .map do |row|
-                    new_args = row.take(constructor.args.size)
-                    tail = row.drop(constructor.args.size)
-
-                  [Constructor[constructor.name, new_args]] + tail
-                end
-                .then { acc.concat(it) }
+                witnesses(constructor, env, heads.include?(constructor.name))
+                  .then { acc.concat(it) }
               end
           end
         end
 
         protected
 
+        # Nothing in this column narrows anything — a type with no constructors
+        # to enumerate, or one every row left open. Whatever is missing lives in
+        # the columns after it.
+        def unmatched_column(env)
+          default
+            .missing_patterns(env)
+            .map { [Wildcard[]] + it }
+        end
+
+        # A constructor the first column matches is explored by specializing on
+        # it. One it never matches can only be missing as a whole, so its
+        # witnesses come from the rows that would have covered it — the ones
+        # headed by a wildcard. Recursing there instead of into the constructor
+        # is what keeps a recursive type from expanding forever.
+        def witnesses(constructor, env, matched)
+          return Matrix.empty if constructor.args.any? { never?(it) }
+
+          arity = constructor.args.size
+
+          if matched
+            specialize(constructor)
+              .missing_patterns(env)
+              .map { [Constructor[constructor.name, it.take(arity)]] + it.drop(arity) }
+
+          else
+            default
+              .missing_patterns(env)
+              .map { [Constructor[constructor.name, Array.new(arity) { Wildcard[] }]] + it }
+          end
+        end
+
+        def head_constructors
+          rows.filter_map { head_constructor(it.first) }
+        end
+
+        def head_constructor(pattern)
+          case pattern
+          in Constructor(constructor: name) then name
+          in Literal(value: true) then 'Basics.True'
+          in Literal(value: false) then 'Basics.False'
+          in Literal | Record | Wildcard then nil
+          end
+        end
+
         def expandable?(type, env)
           case type
           in Type::AnonymousRecord
@@ -125,9 +160,8 @@ module Jade
               TypeChecking::ConstructorDef['Basics.True', 'Basics.Bool', []],
               TypeChecking::ConstructorDef['Basics.False', 'Basics.Bool', []],
             ]
-          in Type::Application(constructor: Type::Constructor(name: /^Tuple\.Tuple([2-4])$/ => name))
-            n = name[-1].to_i
-            [TypeChecking::Definition.constructor(name, name, Array.new(n) { env.fresh })]
+          in Type::Application(constructor: Type::Constructor(name: /^Tuple\.Tuple[2-4]$/ => name), args:)
+            [TypeChecking::Definition.constructor(name, name, args)]
 
           in Type::Application(constructor: Type::Constructor(name: 'List.List'), args: [elem_type])
             [
@@ -181,7 +215,7 @@ module Jade
               end
             end
             .then { with(rows: it) }
-            .then { it.with(types: constructor.args) }
+            .then { it.with(types: constructor.args + types.drop(1)) }
         end
 
         def default

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

@@ -17,7 +17,7 @@ module Jade
                 entry.name,
                 node.range,
                 name:,
-                exposed_type_module: exposed_type_origin(name, entry, registry),
+                hint: constructor_hint(name, entry, registry),
                 candidates: scope.bindings.keys.select { it.match?(/\A[A-Z]/) },
               ))
               .then do
@@ -49,14 +49,40 @@ module Jade
             &.then { klass.new(entry.name, span, arity: it) }
         end
 
-        def exposed_type_origin(name, entry, registry)
-          type_ref = entry.imported_types[name]
-          return nil unless type_ref
+        # An imported module owning a constructor by this name is the whole
+        # story: either it keeps its constructors private, or it exposes them
+        # and the import here asked for the type alone.
+        def constructor_hint(name, entry, registry)
+          entry
+            .imports
+            .filter_map { hint_for(it.module_name, name, registry) }
+            .first
+        end
+
+        def hint_for(module_name, name, registry)
+          target = registry.get(module_name)
+          return nil if target.nil? || Stdlib.is_stdlib?(target)
+
+          type_name = owning_type(target, name)
+          return nil unless type_name && target.exposed_type(type_name)
 
-          target_entry = registry.get(type_ref.module_name)
-          return nil if target_entry.nil? || Stdlib.is_stdlib?(target_entry)
+          exposes_constructor?(target, type_name, name)
+            .then { it ? :import : :expose }
+            .then { Error::ConstructorNotFound::Hint[module_name, type_name, it] }
+        end
+
+        def owning_type(target, name)
+          target
+            .defined_types
+            .find { |_, sym| sym.constructor_refs.any? { it.name == name } }
+            &.first
+        end
 
-          type_ref.module_name
+        def exposes_constructor?(target, type_name, name)
+          target
+            .exposed_type_variants(type_name)
+            .to_a
+            .any? { it.name == name }
         end
       end
     end