mt-lang 0.3.39 → 0.3.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d9af5865fb54b82fbf9169cdf8f8feef652af6a2b84cbd8e63e35f99b33ac08
-  data.tar.gz: 2c5d57827cc19e8de3ee5fff7e576860aa4ae30fa5f7b588eba80c9e95227e02
+  metadata.gz: 91b5015b218da9925b56895b551063fca825ca776fc336fe898ef17e332aae4e
+  data.tar.gz: 46e4a2da80edfb7c64fc847ee10844c9f5d36572df35105ab6ed51e2455d347a
 SHA512:
-  metadata.gz: 9fc438f51cba2f5a65bd3a8ea3441fb87f26018be991146e060a828b036ba9d5eebde4f5546ce344f276ba68e5f1a99b4fe92b026c839c3f77740b15c108a4eb
-  data.tar.gz: 232a3879248bbd638c7710135047c09dbe4a140758da63c2fc5434df4602750c6459faa3fa843abca99801c6628b963ec747509be17de4c73f408626882dfa22
+  metadata.gz: 0c1dcedaf98ef374c9dd21cded75f8512c755a63e4a3a155e494d9edf098b2d53da3b258edab5d63066a2a9eaa3c2a3883aa69241608509085caf398c1edecc1
+  data.tar.gz: a427c7ad0f2475b7dc5cccadcb6cc143ab195f906b7b9b13407a7e754043fd8550495c7dc750f5f27c92e2eca13477d9f6697650bddd515403526812b1dac06b

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.39"
+  VERSION = "0.3.41"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/ast.rb

@@ -111,8 +111,8 @@ module MilkTea
     InterfaceDecl = Data.define(:name, :type_params, :methods, :visibility, :line, :column) do
       def initialize(name:, type_params: [], methods:, visibility:, line: nil, column: nil) = super
     end
-    ExtendingBlock = Data.define(:type_name, :methods, :line, :column) do
-      def initialize(type_name:, methods:, line: nil, column: nil) = super
+    ExtendingBlock = Data.define(:type_name, :methods, :line, :column, :inline) do
+      def initialize(type_name:, methods:, line: nil, column: nil, inline: false) = super
     end
     InterfaceMethodDecl = Data.define(:name, :params, :return_type, :kind, :async, :attributes, :line, :column) do
       def initialize(name:, params:, return_type:, kind:, async:, attributes: [], line: nil, column: nil) = super

data/lib/milk_tea/core/bindings/attribute_binding.rb

@@ -2,7 +2,7 @@
 
 module MilkTea
   module Bindings
-    AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin, :ast)
+    AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin)
     BUILTIN_ATTRIBUTE_NAMES = %w[packed align deprecated test expect_fatal].freeze
 
     def self.builtin_attribute_binding(name, types)
@@ -14,7 +14,6 @@ module MilkTea
           params: [].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "align"
         AttributeBinding.new(
@@ -23,7 +22,6 @@ module MilkTea
           params: [Types::Registry.parameter("bytes", types.fetch("ptr_uint"))].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "deprecated"
         AttributeBinding.new(
@@ -32,7 +30,6 @@ module MilkTea
           params: [Types::Registry.parameter("message", types.fetch("str"))].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "test"
         AttributeBinding.new(
@@ -41,7 +38,6 @@ module MilkTea
           params: [].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       when "expect_fatal"
         AttributeBinding.new(
@@ -50,7 +46,6 @@ module MilkTea
           params: [].freeze,
           module_name: nil,
           builtin: true,
-          ast: nil,
         )
       end
     end

data/lib/milk_tea/core/bindings/module_binding.rb

@@ -2,7 +2,7 @@
 
 module MilkTea
   module Bindings
-    ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods, :private_implemented_interfaces) do
+    ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods) do
       def private_type?(name)
         private_types.key?(name)
       end

data/lib/milk_tea/core/intrinsics.rb

@@ -84,5 +84,27 @@ module MilkTea
     def string_literal_cstr_compatibility?(expression, expected_type)
       expression.is_a?(AST::StringLiteral) && !expression.cstring && expected_type == BUILTIN_CSTR
     end
+
+    def current_nested_types
+      @current_nested_types
+    end
+
+    # Resolves the receiver type's short name (self-reference) and its own
+    # nested types as a bare-name scope for method bodies and signatures.
+    def method_receiver_nested_scope(receiver_type)
+      return nil unless receiver_type.respond_to?(:name)
+
+      nested = receiver_type.respond_to?(:nested_types) ? receiver_type.nested_types : nil
+      scope = { receiver_type.name => receiver_type }
+      scope = scope.merge(nested) if nested && !nested.empty?
+      scope
+    end
+
+    # Looks up a bare type name, consulting the active method-receiver nested
+    # scope before the module type namespace so nested types self-reference
+    # by their short name inside their own methods.
+    def lookup_named_type(name)
+      (@current_nested_types && @current_nested_types[name]) || @ctx.types[name]
+    end
   end
-end
+end

data/lib/milk_tea/core/lowering/functions.rb

@@ -118,8 +118,10 @@ module MilkTea
         parameter_setup = []
         previous_type_substitutions = @ctx.current_type_substitutions
         previous_value_type_params = @ctx.current_value_type_params
+        previous_nested_types = @current_nested_types
         @ctx.current_type_substitutions = binding.type_substitutions
         @ctx.current_value_type_params = resolve_value_type_params(decl.type_params)
+        @current_nested_types = method_receiver_nested_scope(binding.declared_receiver_type)
 
         return lower_async_function_decl(binding, receiver_type:) if binding.async
 
@@ -179,6 +181,7 @@ module MilkTea
       ensure
         @ctx.current_type_substitutions = previous_type_substitutions
         @ctx.current_value_type_params = previous_value_type_params
+        @current_nested_types = previous_nested_types
       end
 
       def resolve_value_type_params(type_params)

data/lib/milk_tea/core/lowering/resolve.rb

@@ -444,7 +444,7 @@ module MilkTea
           return [:compile_time_builtin, callee.name, nil, compile_time_builtin_function_type(callee.name, arguments, env)]
         end
 
-        type = @ctx.types[callee.name]
+        type = lookup_named_type(callee.name)
         if type.is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
           return [:struct_literal, nil, nil, type]
         end
@@ -606,7 +606,6 @@ module MilkTea
           return [:array_as_span, nil, callee.receiver, Types::Registry.span(array_element_type(field_receiver_type))]
         end
 
-        member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
         member_type = field_receiver_type.respond_to?(:field) ? field_receiver_type.field(callee.member) : nil
         return [:callable_value, nil, nil, member_type, nil] if callable_type?(member_type)
 
@@ -1055,7 +1054,7 @@ module MilkTea
         end
       end
 
-      def type_contains_array_storage?(type, visited = Set.new)
+      def type_contains_array_storage?(type)
         visitor = Types::ContainsArrayStorageVisitor.new
         visitor.visit(type)
         visitor.found?
@@ -1118,62 +1117,6 @@ module MilkTea
         expected_type || null_type
       end
 
-      def common_numeric_type(left_type, right_type)
-        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-        return left_type if left_type == right_type
-        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-        return unless left_type.numeric? && right_type.numeric?
-
-        return common_integer_type(left_type, right_type) if left_type.integer? && right_type.integer?
-        return wider_float_type(left_type, right_type) if left_type.float? && right_type.float?
-
-        float_type, integer_type = left_type.float? ? [left_type, right_type] : [right_type, left_type]
-        return unless integer_type.integer? && integer_type.fixed_width_integer?
-
-        float_type
-      end
-
-      def common_integer_type(left_type, right_type)
-        left_type = left_type.backing_type if left_type.is_a?(Types::EnumBase)
-        right_type = right_type.backing_type if right_type.is_a?(Types::EnumBase)
-        return left_type if left_type == right_type
-        return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
-        return unless left_type.integer? && right_type.integer?
-        return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-
-        # Mirrors the semantic analyzer's rule: same signedness picks the wider
-        # type; mixed signed/unsigned promotes to the narrowest signed type that
-        # holds both operands' full ranges (a strictly-wider signed type covers
-        # an unsigned operand, otherwise widen to the next signed width). Mixing
-        # with a 64-bit unsigned type has no safe signed common type.
-        if left_type.signed_integer? == right_type.signed_integer?
-          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
-        end
-
-        signed_type, unsigned_type = if left_type.signed_integer?
-          [left_type, right_type]
-        else
-          [right_type, left_type]
-        end
-
-        return signed_type if signed_type.integer_width > unsigned_type.integer_width
-
-        signed_type_above_width(unsigned_type.integer_width)
-      end
-
-      def signed_type_above_width(width)
-        case width
-        when 8 then @ctx.types.fetch("short")
-        when 16 then @ctx.types.fetch("int")
-        when 32 then @ctx.types.fetch("long")
-        end
-      end
-
-      def wider_float_type(left_type, right_type)
-        left_type.float_width >= right_type.float_width ? left_type : right_type
-      end
-
       def aggregate_arithmetic_result_type(operator, left_type, right_type)
         if left_type.is_a?(Types::Vector) && right_type.is_a?(Types::Vector) && left_type.name == right_type.name
           return left_type
@@ -1217,7 +1160,7 @@ module MilkTea
         when AST::Identifier
           return current_type_params[expression.name] if current_type_params.key?(expression.name)
 
-          @ctx.types[expression.name]
+          lookup_named_type(expression.name)
         when AST::MemberAccess
           return nil unless expression.receiver.is_a?(AST::Identifier)
 
@@ -1870,10 +1813,6 @@ module MilkTea
         def top_level_function(name)
           @lowerer.instance_variable_get(:@ctx).functions&.[](name)
         end
-
-        def raise_sema_error(message)
-          raise CompileTime::Error, message
-        end
       end
 
       def evaluate_reflection_target_argument(expression, env:)
@@ -2532,7 +2471,7 @@ module MilkTea
                 elsif parts.length == 1 && type_params.key?(parts.first)
                   type_params.fetch(parts.first)
                 elsif parts.length == 1
-                  type = @ctx.types[parts.first]
+                  type = lookup_named_type(parts.first)
                   raise LoweringError.new("unknown type #{parts.first}", line: 0, column: 0, path: @ctx.current_analysis_path) unless type
                   raise LoweringError.new("generic type #{parts.first} requires type arguments", line: 0, column: 0, path: @ctx.current_analysis_path) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
 

data/lib/milk_tea/core/lowering/utils.rb

@@ -155,18 +155,6 @@ module MilkTea
         receiver_type
       end
 
-      def collection_loop_type(type)
-        super
-      end
-
-      def collection_loop_binding_type(iterable_type, element_type)
-        super
-      end
-
-      def collection_loop_ref_element_type?(type)
-        super
-      end
-
       def collection_loop_item_value(iterable_ref, iterable_type, index_ref, element_type)
         if array_type?(iterable_type)
           IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
@@ -248,11 +236,6 @@ module MilkTea
         raise LoweringError.new("cannot index #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
-      def contains_type_var?(type)
-        super
-      end
-
-
       def stored_ref_supported_type?(type, visited = {})
         return true unless type
 

data/lib/milk_tea/core/lowering.rb

@@ -100,7 +100,6 @@ module MilkTea
     include Intrinsics
 
     attr_accessor :bypass_sema_type_cache
-    attr_reader :recorded_expr_types
 
     include Lowering::Scans
     include Lowering::Declarations
@@ -122,6 +121,7 @@ module MilkTea
       @program = program
       @ctx = LoweringContext.new
       @artifacts = Artifacts.new
+      @error_type = Types::Error.new
       @synthetic_proc_counter = 0
       @parallel_for_counter = 0
       @async_binding_counter = 0
@@ -130,7 +130,6 @@ module MilkTea
     end
 
     def lower
-      @recorded_expr_types = {} if @bypass_sema_type_cache
       ir_program, _modules, _synths = lower_and_assemble
       ir_program
     end

data/lib/milk_tea/core/module_binder.rb

@@ -42,7 +42,7 @@ module MilkTea
       end
 
       methods, private_methods = exported_methods(analysis, types)
-      implemented_interfaces, private_implemented_interfaces = exported_interface_implementations(analysis, types, interfaces)
+      implemented_interfaces = exported_interface_implementations(analysis, types, interfaces)
 
       Bindings::ModuleBinding.new(
         name: analysis.module_name,
@@ -62,7 +62,6 @@ module MilkTea
         private_values:,
         private_functions:,
         private_methods:,
-        private_implemented_interfaces:,
       )
     end
 
@@ -102,28 +101,18 @@ module MilkTea
 
     def exported_interface_implementations(analysis, exported_types, exported_interfaces)
       implemented_interfaces = {}
-      private_implemented_interfaces = {}
 
       analysis.implemented_interfaces.each do |receiver_type, interfaces|
-        public_interfaces = []
-        hidden_interfaces = []
-
-        interfaces.each do |interface|
-          visible = exported_method_receiver?(receiver_type, analysis, exported_types) &&
+        public_interfaces = interfaces.select do |interface|
+          exported_method_receiver?(receiver_type, analysis, exported_types) &&
             exported_interface_binding?(interface, analysis, exported_interfaces) &&
             exported_interface_methods?(receiver_type, interface, analysis, exported_types)
-          if visible
-            public_interfaces << interface
-          else
-            hidden_interfaces << interface
-          end
         end
 
         implemented_interfaces[receiver_type] = public_interfaces.freeze unless public_interfaces.empty?
-        private_implemented_interfaces[receiver_type] = hidden_interfaces.freeze unless hidden_interfaces.empty?
       end
 
-      [implemented_interfaces.freeze, private_implemented_interfaces.freeze]
+      implemented_interfaces.freeze
     end
 
     def exported_interface_methods?(receiver_type, interface, analysis, exported_types)

data/lib/milk_tea/core/module_loader.rb

@@ -158,7 +158,30 @@ module MilkTea
 
     def load_file(path)
       resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
-      @ast_cache[resolved_path] ||= parse_file(resolved_path)
+      @ast_cache[resolved_path] ||= cached_or_parse_file(resolved_path)
+    end
+
+    # Parse +resolved_path+, reusing the shared-cache parsed AST when the source
+    # is disk-backed and unchanged. ASTs are immutable Data, so sharing them
+    # across loaders (and worker threads) is safe; node_ids are assigned at
+    # parse time and analyses keep their own per-node result hashes. Source
+    # files covered by source_overrides are always re-parsed so live editor
+    # buffers win.
+    def cached_or_parse_file(resolved_path)
+      if use_shared_cache_for?(resolved_path)
+        mtime = source_mtime(resolved_path)
+        if mtime
+          entry = @shared_cache[[:ast, resolved_path]]
+          return entry[:ast] if entry && entry[:mtime] == mtime
+        end
+      end
+
+      ast = parse_file(resolved_path)
+      if use_shared_cache_for?(resolved_path)
+        mtime = source_mtime(resolved_path)
+        @shared_cache[[:ast, resolved_path]] = { mtime:, ast: } if mtime
+      end
+      ast
     end
 
     def check_file(path)
@@ -166,7 +189,14 @@ module MilkTea
     end
 
     def with_check_context(path, &block)
-      Types::Registry.reset!
+      # NOTE: Types::Registry.reset! is intentionally NOT called here. The LSP
+      # runs check_program_collecting concurrently on diagnostics workers and
+      # the request thread; a reset would clear the global intern pool while
+      # another thread is mid-analysis, causing threads to intern duplicate type
+      # instances. Interning is idempotent and the pool stays small (bounded by
+      # the type universe), so it is safe to let it grow for the process
+      # lifetime. Single-threaded entry points that want a clean slate (Build#build,
+      # server re-initialize) reset explicitly.
       requested_path = File.expand_path(path)
       previous_platform = @platform
       @platform ||= self.class.platform_suffix_for_path(requested_path)
@@ -541,7 +571,7 @@ module MilkTea
       return [resolved_path, nil, @analysis_cache[resolved_path]] if @analysis_cache.key?(resolved_path)
       return [resolved_path, nil, extra_cache[resolved_path]] if extra_cache&.key?(resolved_path)
 
-      if use_shared_cache?
+      if use_shared_cache_for?(resolved_path)
         entry = @shared_cache[resolved_path]
         if entry
           mtime = source_mtime(resolved_path)
@@ -566,7 +596,7 @@ module MilkTea
     end
 
     def update_shared_cache(resolved_path, analysis)
-      return unless use_shared_cache?
+      return unless use_shared_cache_for?(resolved_path)
 
       mtime = source_mtime(resolved_path)
       @shared_cache[resolved_path] = { mtime:, analysis: } if mtime
@@ -691,7 +721,6 @@ module MilkTea
           private_values: full_binding.private_values,
           private_functions: full_binding.private_functions,
           private_methods: full_binding.private_methods,
-          private_implemented_interfaces: full_binding.private_implemented_interfaces,
         )
       end
     end
@@ -728,12 +757,16 @@ module MilkTea
         implemented_interfaces: {}, imports: {},
         private_types: {}, private_interfaces: {}, private_attributes: {},
         private_values: {}, private_functions: {}, private_methods: {},
-        private_implemented_interfaces: {},
       )
     end
 
-    def use_shared_cache?
-      @shared_cache && @source_overrides.empty?
+    # The shared cache stores per-module analyses keyed by resolved path. It is
+    # consulted only for paths NOT covered by source_overrides: source-overridden
+    # files reflect live editor buffers (or in-memory sources) that never match
+    # disk, so their entries would be stale by construction. This lets a single
+    # open document invalidate only itself while imported modules stay cached.
+    def use_shared_cache_for?(resolved_path)
+      @shared_cache && !@source_overrides.key?(resolved_path)
     end
   end
 end

data/lib/milk_tea/core/parser/declarations.rb

@@ -369,10 +369,11 @@ module MilkTea
         AST::AttributeDecl.new(name: name_token.lexeme, targets:, params:, visibility:, line:, column: name_token.column)
       end
 
-      def parse_struct_decl(packed: false, alignment: nil, visibility: :private, attributes: [], inline_methods: true)
+      def parse_struct_decl(packed: false, alignment: nil, visibility: :private, attributes: [], qualified_parts: [])
         line = previous.line
         name_token = consume_name("expected struct name")
         name = name_token.lexeme
+        qualified_name = qualified_parts + [name]
         lifetime_params, type_params = parse_struct_decl_params
         implements = parse_implements_clause
         c_name = parse_optional_c_name
@@ -380,29 +381,33 @@ module MilkTea
         receiver_type_param_names = type_params.map(&:name)
         members = with_type_param_names(receiver_type_param_names) do
           parse_recoverable_block do
-            parse_struct_member
+            parse_struct_member(qualified_name)
           end
         end
         fields = members.filter_map { |kind, member| member if kind == :field }
         events = members.filter_map { |kind, member| member if kind == :event }
         nested_types = members.filter_map { |kind, member| member if kind == :nested_type }
         methods = members.filter_map { |kind, member| member if kind == :method }
+        nested_extending_blocks = members.filter_map { |kind, _, blocks| blocks if kind == :nested_type }.flatten(1)
         struct_decl = AST::StructDecl.new(name:, type_params:, implements:, c_name:, fields:, events:, nested_types:, attributes:, packed:, alignment:, visibility:, lifetime_params:, line:, column: name_token.column)
 
-        if inline_methods && methods.any?
-          type_ref_args = type_params.map do |tp|
-            AST::TypeArgument.new(
-              value: AST::TypeRef.new(name: AST::QualifiedName.new(parts: [tp.name]), arguments: [], nullable: false, line: tp.line, column: tp.column),
-              line: tp.line,
-              column: tp.column,
-            )
-          end
-          type_ref = AST::TypeRef.new(name: AST::QualifiedName.new(parts: [name]), arguments: type_ref_args, nullable: false, line: name_token.line, column: name_token.column)
-          extending_block = AST::ExtendingBlock.new(type_name: type_ref, methods:, line: name_token.line, column: name_token.column)
-          [struct_decl, extending_block]
-        else
-          struct_decl
+        extending_blocks = []
+        extending_blocks << inline_methods_extending_block(qualified_name, type_params, methods, name_token) if methods.any?
+        extending_blocks.concat(nested_extending_blocks)
+
+        extending_blocks.empty? ? struct_decl : [struct_decl, *extending_blocks]
+      end
+
+      def inline_methods_extending_block(qualified_name, type_params, methods, name_token)
+        type_ref_args = type_params.map do |tp|
+          AST::TypeArgument.new(
+            value: AST::TypeRef.new(name: AST::QualifiedName.new(parts: [tp.name]), arguments: [], nullable: false, line: tp.line, column: tp.column),
+            line: tp.line,
+            column: tp.column,
+          )
         end
+        type_ref = AST::TypeRef.new(name: AST::QualifiedName.new(parts: qualified_name), arguments: type_ref_args, nullable: false, line: name_token.line, column: name_token.column)
+        AST::ExtendingBlock.new(type_name: type_ref, methods:, line: name_token.line, column: name_token.column, inline: true)
       end
 
       def parse_struct_decl_params
@@ -459,7 +464,7 @@ module MilkTea
         result
       end
 
-      def parse_struct_member
+      def parse_struct_member(qualified_name)
         field_attributes = parse_attribute_applications
 
         if check_method_start?
@@ -475,7 +480,9 @@ module MilkTea
 
         if check(:struct) && !check_next(:colon)
           advance
-          return [:nested_type, parse_struct_decl(visibility:, attributes: field_attributes, inline_methods: false)]
+          result = parse_struct_decl(visibility:, attributes: field_attributes, qualified_parts: qualified_name)
+          nested_decl, *nested_blocks = result.is_a?(Array) ? result : [result]
+          return [:nested_type, nested_decl, nested_blocks]
         end
 
         raise error(visibility_token, "public is only allowed on struct events") if visibility == :public