jade-lang 0.11.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e5a1b96ecfb6952330c6dcb8bd01b6994b0ca8cff936a59112d5c9606412bd4
-  data.tar.gz: 066f030bb094a9d73b17acb2754f59aed7fc1bb3204e2f68be0df5e2830ad037
+  metadata.gz: 5529a34cf9b8a3d407d78642bca0281ec0a422dcded4f5875636e85f7018d7e4
+  data.tar.gz: c8da773021523ebb4d93836d8c8dee0ba0dca6acf4115f32ff46443a8dfbf08e
 SHA512:
-  metadata.gz: b1c1f5397cfab8dafce1c63ee630c7032995be651c0ea2fcb7af51e2cff134a0f8b94c21897f53cf561c5106906c56c2267f2275d57ba6e42d6a6e7b013d003d
-  data.tar.gz: b29cbd43c8125fa086563761c9935cd3cf207ad0d10749fe701c129d0660023323698cead0c48d3bea559ee27b31441fa41c00f6697725a634c326f23777f771
+  metadata.gz: 26bab9740a9f008e4611a52210ec002f314e1fec4169239cd1a4aaa37eb090829a6fd20f4742ab475c169e4dc856652deddf12eca95f862f413668accdeda724
+  data.tar.gz: 243a05ffe69948767ccb7900b4e2cf443dccdb50d540f6cd16998863a6917e2742718769b742c0d0bf9f1e121aa4ee51cd85b70084ea7f26d669a1e49bf14d54

data/CHANGELOG.md

@@ -4,6 +4,30 @@ 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

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

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.11.2'
+  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.2
+  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