jade-lang 0.12.1 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b6d2de0940d8842121c48456180fa3cbc04345d0bf991c31f8e008019c4e017
-  data.tar.gz: 425323f1b3c92b1d817b088a3973b86c94f7743fe185197cb5d60c680281184f
+  metadata.gz: fd36bbcd9dc0af93f281ebf187acafe5eb8b19d9cb868375a4261a2c8346e3c8
+  data.tar.gz: 631ba0267189d7d59bf014fe44fb07bec65d657bc0f87ba809bee8bfd577c503
 SHA512:
-  metadata.gz: 0da5c33762fdac3b212474c72925c1d47c48b915f7b4a6877a6328b3c07ac15430e0f97c5647d714886d498c94850a1a448100ae29cfd73d7f97abc3bfc2248c
-  data.tar.gz: ee26d40ebaa14f0587675692a83d977f6e7eae0ba80c342929847636c9c5509778fa7e19977974deb2421bf7cab0e17a066cafd4188f121d6165347cd1a4b3b4
+  metadata.gz: 7343d1d44fc2eab19f07360d5d87369c3707e005b51493a58911c07ef52e6c6832e270a54741e325d0ccbdbd65d7ea5f7b6b744fa21bea6bcc68c7d14d235534
+  data.tar.gz: 31c9091262b1472f3e51a5797bf1b6ab13359693b774f2912b62d3a53e185124260a6c493cff2d1a5cf7f712b87367ce3fcd346da1577e568d349519441331ae

data/CHANGELOG.md

@@ -6,6 +6,21 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.12.2] - 2026-09-24
+
+### Fixed
+
+- **A hoisted dictionary is built on first use, not while the module loads.**
+  One can hold the result of calling a module function, and that function's
+  own body can name another dictionary — emitted as constants in the order
+  they were written, the second was still undefined while the first was being
+  built, and requiring the module raised `uninitialized constant DICT_6`.
+  Whether it happened depended on the order the dictionaries were discovered
+  in, so adding an unrelated function could break a module that compiled
+  yesterday. They are memoised singleton methods now, cleared on each load so
+  a reloaded module does not keep dictionaries closing over classes the
+  reload replaced.
+
 ## [0.12.1] - 2026-09-21
 
 Both of these make code compile that should have compiled, so they ride a

data/lib/jade/codegen/context.rb

@@ -56,6 +56,20 @@ module Jade
         @dict_consts = prev
       end
 
+      # The module the dictionary methods are defined on, so a reference from
+      # inside `Internal` still finds them.
+      def dict_owner
+        @dict_owner
+      end
+
+      def with_dict_owner(owner)
+        prev = @dict_owner
+        @dict_owner = owner
+        yield
+      ensure
+        @dict_owner = prev
+      end
+
       # When set, references with this name emit as `self` (and field accesses
       # on them as bare method calls). Used to rewrite operator-impl lambda
       # bodies — `(a, b) -> { a.amount == b.amount }` becomes

data/lib/jade/codegen/function_call.rb

@@ -140,7 +140,8 @@ module Jade
         table = Codegen.dict_consts or return source
         return source if Codegen.dict_env.values.any? { source.include?(it) }
 
-        table[source] ||= "DICT_#{table.size}"
+        table[source] ||= "dict_#{table.size}"
+        "::#{Codegen.dict_owner}.#{table[source]}"
       end
 
       # Polymorphic fn referenced as a value (not called). Wraps the fn with

data/lib/jade/codegen.rb

@@ -109,10 +109,12 @@ module Jade
         outer, inner, wrappers =
           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('.'))
+              with_dict_owner(to_qualified(name)) 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
@@ -365,9 +367,25 @@ module Jade
     # weighed against its specialized form, say), and a discarded one can
     # still have claimed a constant. Keep the ones that survived, and the
     # ones those refer to.
+    # Memoised methods rather than constants: a dictionary can hold the
+    # result of calling a module function, and that function's own body can
+    # name another dictionary. Constants are evaluated in the order they are
+    # written, so that dependency could reach forward to one not defined
+    # yet; a method body runs when it is first called, by which time every
+    # definition exists.
     def referenced_dicts(table, body)
       reachable_dicts(table, body.join(Pretty.newline))
-        .map { |source, const| "#{const} = #{source}.freeze" }
+        .map { |source, const| dict_method(const, source) }
+    end
+
+    # The nil assignment runs on every load, so a reloaded module rebuilds
+    # its dictionaries rather than keeping ones that close over the classes
+    # the reload just replaced.
+    def dict_method(const, source)
+      [
+        "@#{const} = nil",
+        Pretty.block("def self.#{const}", "@#{const} ||= #{source}.freeze"),
+      ].join(Pretty.newline(2))
     end
 
     # A kept dictionary can name another one, so widen the search text

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.12.1'
+  VERSION = '0.12.2'
 end

metadata

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