jade-lang 0.11.1 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c07abf955aeeae107bd0cbb0f2f9ba95aab3c9240946e96d69521c2ae406f56b
-  data.tar.gz: a6750f4f9734070babfde95fa657a37cec27acc43c705742b63b58691f4c225a
+  metadata.gz: 5529a34cf9b8a3d407d78642bca0281ec0a422dcded4f5875636e85f7018d7e4
+  data.tar.gz: c8da773021523ebb4d93836d8c8dee0ba0dca6acf4115f32ff46443a8dfbf08e
 SHA512:
-  metadata.gz: c485c3028caa4b4ad1da0abd708c9c6c1b935ed26a242f19efbc5440f3e9a46e6236cf9e93912e870c941ba64096ae488499ce351c0dfd04a75084a6e8b9f6c1
-  data.tar.gz: 2176bf5dc17eacdbbc902a3243e8676c2232350846a45913181489ee74ea6ff9f576d9278b0f5bfaffb1d235c7d8337ce6ebd0d03ff141e23d3bc74b95f2f8dd
+  metadata.gz: 26bab9740a9f008e4611a52210ec002f314e1fec4169239cd1a4aaa37eb090829a6fd20f4742ab475c169e4dc856652deddf12eca95f862f413668accdeda724
+  data.tar.gz: 243a05ffe69948767ccb7900b4e2cf443dccdb50d540f6cd16998863a6917e2742718769b742c0d0bf9f1e121aa4ee51cd85b70084ea7f26d669a1e49bf14d54

data/CHANGELOG.md

@@ -4,6 +4,48 @@ 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).
 
+## [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
+
+- **A constraint raised inside a field access reached nothing.**
+  `RecordAccess` built its result from the expected type alone, so whatever
+  the target raised was dropped at the dot. A function whose body is
+  `to_sel(q).cols` therefore recorded no constraint of its own: it took no
+  dictionary parameter, and the interface call inside it fell through to
+  `Runtime.impl_for`, which keys on the argument's own class. That dispatches
+  on `Q` when the interface is over the `c` inside it, and fails at the first
+  call — at run time, though both the types and the call sites were settled
+  when it compiled.
+
+  Deleting the `.cols` from the same program made it work, which is the
+  asymmetry that gave it away. It matters wherever an interface is over a type
+  a struct holds rather than the struct itself.
+
 ## [0.11.1] - 2026-09-15
 
 ### Added

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

@@ -393,7 +393,7 @@ module Jade
       end
 
       def emit(ir, registry)
-        Emitter.emit(ir)
+        Emitter.emit(ir, registry)
       end
     end
   end

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

@@ -24,7 +24,7 @@ module Jade
               )
             end
 
-            Result.init(expected_.type)
+            Result.init(expected_.type, target_result.constraints)
               .then { it.apply(after_state.env.substitution) }
               .then { [after_state, it] }
           end

data/lib/jade/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.11.3
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64