mt-lang 0.3.41 → 0.3.43

data/lib/milk_tea/core/types/registry.rb

@@ -21,40 +21,63 @@ module MilkTea
       end
 
       def self.nullable(base)
-        _intern([:nullable, base]) { Nullable.new(base) }
+        _intern([:nullable, type_signature(base)]) { Nullable.new(base) }
       end
 
       def self.generic_instance(name, arguments)
         args = arguments.freeze
-        _intern([:generic, name, args]) { GenericInstance.new(name, args) }
+        _intern([:generic, name, args.map { |a| type_signature(a) }.freeze]) { GenericInstance.new(name, args) }
       end
 
       def self.span(element_type)
-        _intern([:span, element_type]) { Span.new(element_type) }
+        _intern([:span, type_signature(element_type)]) { Span.new(element_type) }
       end
 
       def self.task(result_type)
-        _intern([:task, result_type]) { Task.new(result_type) }
+        _intern([:task, type_signature(result_type)]) { Task.new(result_type) }
       end
 
       def self.string_view
         _intern([:string_view]) { StringView.new }
       end
 
-      # Param signature for intern keys. Parameter#eql? is name-insensitive
-      # (assignability must not depend on parameter names), so arrays of
-      # Parameter objects would conflate fn(value: int) with fn(arg0: int) in
-      # the intern pool. Embedding names here keeps distinct signatures
-      # distinct across independent programs sharing a long-lived pool (the LSP
-      # never resets the registry between checks).
+      # Name-sensitive signature for intern keys. Parameter#eql? is
+      # name-insensitive (assignability must not depend on parameter names), so
+      # Function/Proc objects (and any wrapper containing them) that differ only
+      # in parameter names collide under Hash/==. Pool keys that embed such
+      # types raw therefore conflate fn(value: int) with fn(arg0: int) in a
+      # long-lived pool (the LSP never resets the registry between checks),
+      # leaking one program's parameter names into another's generated C.
+      # Embedding names here keeps distinct signatures distinct.
+      def self.type_signature(type)
+        case type
+        when Function
+          [:function, type.name, param_signature(type.params), type_signature(type.return_type), type_signature(type.receiver_type), type.receiver_editable, type.variadic, type.external]
+        when Proc
+          [:proc, param_signature(type.params), type_signature(type.return_type)]
+        when Nullable
+          [:nullable, type_signature(type.base)]
+        when GenericInstance
+          [:generic, type.name, type.arguments.map { |a| type_signature(a) }]
+        when Tuple
+          [:tuple, type.element_types.map { |t| type_signature(t) }, type.field_names]
+        when Span
+          [:span, type_signature(type.element_type)]
+        when Task
+          [:task, type_signature(type.result_type)]
+        else
+          type
+        end
+      end
+
       def self.param_signature(params)
-        params.map { |p| [p.name, p.type, p.mutable, p.passing_mode, p.boundary_type] }
+        params.map { |p| [p.name, type_signature(p.type), p.mutable, p.passing_mode, p.boundary_type] }
       end
 
       def self.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
         params_frozen = params.freeze
         param_key = param_signature(params_frozen)
-        _intern([:function, name, param_key, return_type, receiver_type, receiver_editable, variadic, external]) {
+        _intern([:function, name, param_key, type_signature(return_type), type_signature(receiver_type), receiver_editable, variadic, external]) {
           Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
         }
       end
@@ -62,7 +85,7 @@ module MilkTea
       def self.proc(params:, return_type:)
         params_frozen = params.freeze
         param_key = param_signature(params_frozen)
-        _intern([:proc, param_key, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
+        _intern([:proc, param_key, type_signature(return_type)]) { Proc.new(params: params_frozen, return_type: return_type) }
       end
 
       def self.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)
@@ -74,15 +97,15 @@ module MilkTea
       def self.tuple(element_types, field_names: nil)
         et_frozen = element_types.freeze
         fn_frozen = field_names&.freeze
-        _intern([:tuple, et_frozen, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
+        _intern([:tuple, et_frozen.map { |t| type_signature(t) }.freeze, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
       end
 
       def self.soa(element_type, count:)
-        _intern([:soa, element_type, count]) { SoA.new(element_type, count: count) }
+        _intern([:soa, type_signature(element_type), count]) { SoA.new(element_type, count: count) }
       end
 
       def self.simd(element_type, lane_count:)
-        _intern([:simd, element_type, lane_count]) { Simd.new(element_type, lane_count: lane_count) }
+        _intern([:simd, type_signature(element_type), lane_count]) { Simd.new(element_type, lane_count: lane_count) }
       end
 
       def self.lifetime_ref(name)

data/lib/milk_tea/lsp/server/hover.rb

@@ -1330,7 +1330,6 @@ module MilkTea
           end
           return nil unless idx && tokens[idx].type == :identifier
 
-          type_name = tokens[idx].lexeme
           type = resolve_arm_receiver_type(facts, tokens, idx)
 
           arm = if type.respond_to?(:arm)

data/lib/milk_tea/lsp/server/text_documents.rb

@@ -86,7 +86,7 @@ module MilkTea
           rescue StandardError
             nil
           end
-          clear_shared_module_cache if previous_content != disk_content
+          @workspace.clear_shared_module_cache if previous_content != disk_content
           unless defined?(@pull_diagnostics_active) && @pull_diagnostics_active
             @protocol.write_notification('textDocument/publishDiagnostics', {
               uri: uri,

data/lib/milk_tea/tooling/docs_app.rb

@@ -18,7 +18,7 @@ module MilkTea
       "Files & I/O" => %w[fs path stdio],
       "System" => %w[ctype errno process time c],
       "Network & HTTP" => %w[net http uri cookie curl],
-      "Game & Graphics" => %w[raylib box2d flecs enet cgltf cjson],
+      "Game & Graphics" => %w[raylib box2d box3d flecs enet cgltf cjson],
       "Algorithms & AI" => %w[fsm behavior_tree goap],
       "Database & Matching" => %w[sqlite3 pcre2],
       "Utilities" => %w[cli terminal span spatial asset_pack],