mt-lang 0.2.12 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28dc7f8c8824f11189bdd3cf704d10eefa2e144d466b218b5b34b1693531fe94
-  data.tar.gz: 73dcea75aeb6fb9c460e6b574e0bb64dc118ca9cd0a028586bd526d7b00acb49
+  metadata.gz: 684d2aada4af1e2b5fc1c0685e26004ed9442931692cb25007777b09df77dbe5
+  data.tar.gz: 5f16c0ce02404a51f4ac8dd8c12b8047fb4ae5ab442b1269ba7ce8c58809a065
 SHA512:
-  metadata.gz: c3286442bbca94bd51b9c7aa4166f2b854d9f6bd48da3f6860648f303c30c90e39f2ac531315a5f13a148f3591eab1a5a02dabfd935f6ea136dfe0018012db9d
-  data.tar.gz: 53cc3240a7b226d152f831775e508a1db5c030f533d4fb6a88084f6564fcffa86954614e86b37f2c0b7650ae5ef27486e9aea05a6eaffe14b2aa5b2be9be0c8a
+  metadata.gz: 9e129d1a7a428094755af01cb5bb98c29fb78ee9003b6938cb4335eb0e58763804a9e1c902f5d1563111a20c7b70ca69f4497f11c4cf476ed5b9ef8696ccc9ed
+  data.tar.gz: ffc46a4a1658c84a2fa6d2d7d6331b98164487c488112055adc9a2f20367074f26a02002d0a36ec493f9f9738ac2123f80a2e1e04fbaa5b364a54509898a2644

data/lib/milk_tea/base.rb

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

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

@@ -472,20 +472,13 @@ module MilkTea
 
         members = []
         skip_newlines
-        auto_value = 0
         until check(:dedent) || eof?
           member_token = consume_name("expected member name")
           member_name = member_token.lexeme
           if match(:equal)
             value = parse_expression
-            if value.is_a?(AST::IntegerLiteral)
-              auto_value = value.value + 1
-            elsif value.is_a?(AST::UnaryOp) && value.operator == "-" && value.operand.is_a?(AST::IntegerLiteral)
-              auto_value = -value.operand.value + 1
-            end
           else
-            value = AST::IntegerLiteral.new(lexeme: auto_value.to_s, value: auto_value)
-            auto_value += 1
+            value = nil
           end
           consume_end_of_statement
           members << AST::EnumMember.new(name: member_name, value:, line: member_token.line, column: member_token.column)

data/lib/milk_tea/core/semantic_analyzer/type_declaration.rb

@@ -166,6 +166,7 @@ module MilkTea
           module_binding = @ctx.imported_modules[module_path]
           unless module_binding
             install_fallback_builtin_type(module_path)
+            @ctx.imports[module_path] = empty_module_binding(module_path) unless @ctx.imports.key?(module_path)
             next
           end
 
@@ -178,6 +179,19 @@ module MilkTea
         end
       end
 
+      def empty_module_binding(module_path)
+        ModuleBinding.new(
+          name: module_path,
+          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: {},
+        )
+      end
+
       def install_fallback_builtin_type(module_path)
         case module_path
         when "std.option"
@@ -581,8 +595,13 @@ module MilkTea
 
             decl.members.each do |member|
               begin
-                actual_type = infer_expression(member.value, scopes: [], expected_type: backing_type)
-                const_value = evaluate_enum_member_const_value(member.value, enum_type:, member_values:)
+                if member.value
+                  actual_type = infer_expression(member.value, scopes: [], expected_type: backing_type)
+                  const_value = evaluate_enum_member_const_value(member.value, enum_type:, member_values:)
+                else
+                  const_value = (member_values.values.last&.succ || 0)
+                  actual_type = backing_type
+                end
 
                 compatible = types_compatible?(actual_type, backing_type, expression: member.value, scopes: [])
                 compatible ||= actual_type.is_a?(Types::EnumBase) && types_compatible?(actual_type.backing_type, backing_type, expression: member.value, scopes: [])

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

@@ -742,7 +742,7 @@ module MilkTea
       end
 
       def method_dispatch_receiver_type_for_completion(receiver_type)
-        return receiver_type.definition if receiver_type.is_a?(Types::StructInstance)
+        return receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
 
         if receiver_type.is_a?(Types::Nullable)
           dispatch_base_type = method_dispatch_receiver_type_for_completion(receiver_type.base)
@@ -765,7 +765,7 @@ module MilkTea
 
       def project_field_receiver_type_for_completion(type, facts = nil)
         type = project_receiver_type_for_completion(type)
-        return type.definition if type.is_a?(Types::StructInstance)
+        return type.definition if type.is_a?(Types::StructInstance) || type.is_a?(Types::VariantInstance)
         return field_type_from_struct_definition(type, facts) if facts
 
         type
@@ -792,7 +792,7 @@ module MilkTea
 
       def field_owner_type(receiver_type, facts = nil)
         aggregate_type = project_field_receiver_type_for_completion(receiver_type, facts)
-        return aggregate_type.definition if aggregate_type.is_a?(Types::StructInstance)
+        return aggregate_type.definition if aggregate_type.is_a?(Types::StructInstance) || aggregate_type.is_a?(Types::VariantInstance)
 
         aggregate_type
       end

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

@@ -704,7 +704,7 @@ module MilkTea
       end
 
       def interface_receiver_definition_location(current_uri, receiver_type)
-        receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance)
+        receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
 
         if receiver_type.module_name.nil? || receiver_type.module_name.empty?
           token = local_type_definition_token(current_uri, receiver_type.name)
@@ -716,7 +716,7 @@ module MilkTea
       end
 
       def receiver_module_name(receiver_type)
-        receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance)
+        receiver_type = receiver_type.definition if receiver_type.is_a?(Types::StructInstance) || receiver_type.is_a?(Types::VariantInstance)
 
         receiver_type.module_name
       end

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

@@ -281,6 +281,13 @@ module MilkTea
             'exchange' => 'static function exchange(value: T) -> T',
             'compare_exchange' => 'static function compare_exchange(expected: T, desired: T) -> bool',
           },
+          'event' => {
+            'subscribe' => 'function subscribe(listener) -> Result[Subscription, EventError]',
+            'subscribe_once' => 'function subscribe_once(listener) -> Result[Subscription, EventError]',
+            'unsubscribe' => 'function unsubscribe(subscription) -> bool',
+            'emit' => 'function emit() / function emit(payload)',
+            'wait' => 'function wait() -> Task[Result[T, EventError]]',
+          },
           'str_buffer' => {
             'assign' => 'static function assign(value: str) -> void',
             'append' => 'static function append(value: str) -> void',
@@ -307,20 +314,23 @@ module MilkTea
         token = context&.fetch(:token, nil)
         token_kind = token&.type || :none
         unless token&.type == :identifier
-          info = builtin_keyword_hover_info(token)
-          if info
-            result_state = 'hit'
-            return {
-              contents: {
-                kind: 'markdown',
-                value: render_hover_markdown(info)
-              },
-              range: token_to_range(token)
-            }
-          end
+          unless member_access_token?(context)
+            info = builtin_keyword_hover_info(token) ||
+                   BUILTIN_CALL_HOVER_INFO[token.lexeme]&.slice(:signature, :docs)
+            if info
+              result_state = 'hit'
+              return {
+                contents: {
+                  kind: 'markdown',
+                  value: render_hover_markdown(info)
+                },
+                range: token_to_range(token)
+              }
+            end
 
-          result_state = 'not-identifier'
-          return nil
+            result_state = 'not-identifier'
+            return nil
+          end
         end
 
         info = resolve_hover_info(uri, lsp_line, lsp_char, token: token, tokens: context[:tokens], token_index: context[:token_index], stages: stages)
@@ -355,10 +365,11 @@ module MilkTea
           token_index = context[:token_index]
         end
 
-        return nil unless token&.type == :identifier
-
         tokens ||= @workspace.get_tokens(uri) || []
         token_index = tokens.index(token) if token_index.nil?
+        member_access_kw = token_index && keyword_member_access_token?(tokens, token_index)
+        return nil unless token&.type == :identifier || member_access_kw
+
         if token_index
           module_info = module_declaration_info_at(tokens, token_index)
           if module_info
@@ -412,6 +423,7 @@ module MilkTea
         signature = nil
         docs = nil
         source_location = nil
+        resolved_via_type_member = false
 
         if (binding = method_binding_at_token(facts, token))
           signature = method_signature(binding)
@@ -449,11 +461,26 @@ module MilkTea
             type = facts.types[name]
             signature = type_hover_signature(name, type)
             docs ||= BUILTIN_TYPE_DOCS[name]
+          elsif !name.include?(".") && (nested = find_nested_type_by_short_name(facts, name))
+            signature = type_hover_signature(name, nested)
+            docs ||= BUILTIN_TYPE_DOCS[name]
           elsif (binding = facts.values[name])
             signature = value_hover_signature(binding)
+          elsif !BUILTIN_CALL_HOVER_INFO.key?(name) && (member_info = find_member_in_types(facts, name))
+            type, member, value = member_info
+            signature = value ? "#{type.name}.#{member} = #{value}" : "#{type.name}.#{member}"
+            resolved_via_type_member = true
+          elsif !BUILTIN_CALL_HOVER_INFO.key?(name) && (arm_sig = find_variant_arm_in_types(facts, name))
+            signature = arm_sig
+            resolved_via_type_member = true
           elsif (import_binding = facts.imports[name])
             signature = "module #{import_binding.name}"
             source_location = module_definition_location(uri, import_binding.name)
+          elsif (attr_binding = facts.attributes[name])
+            targets = attr_binding.targets.map(&:to_s).join(", ")
+            params_str = attr_binding.params.map { |p| "#{p.name}: #{p.type}" }.join(", ")
+            signature = "attribute [#{targets}] #{name}(#{params_str})"
+            source_location ||= module_definition_location(uri, facts.module_name)
           else
             dot_receiver = @workspace.find_dot_receiver(uri, lsp_line, lsp_char)
           dot_receiver_path = @workspace.find_dot_receiver_path(uri, lsp_line, lsp_char)
@@ -499,7 +526,7 @@ module MilkTea
                 if (method_binding = methods[name])
                   signature = method_signature(method_binding)
                 else
-                  type_base = receiver_type.to_s[/^([a-z_]+)/, 1]
+                  type_base = receiver_type.to_s[/^([A-Za-z_]+)/, 1]
                   if type_base && (method_sigs = BUILTIN_TYPE_METHOD_SIGNATURES[type_base])
                     signature = method_sigs[name]
                   end
@@ -516,18 +543,17 @@ module MilkTea
           end
 
           unless signature
-            unless token_index && tokens && tokens[previous_non_trivia_token_index(tokens, token_index)]&.type == :dot
-              local_def = @workspace.find_definition_token_global(
-                name,
-                preferred_uri: uri,
-                before_line: lsp_line + 1,
-                before_char: lsp_char + 1,
-              )
-              if local_def
-                signature = resolve_lexical_local_hover_signature(local_def[:uri], name, local_def[:token])
-              end
+            if token_index && tokens && parameter_declaration_token?(tokens, token_index)
+              signature = resolve_lexical_local_hover_signature(uri, name, tokens[token_index])
             end
           end
+
+          unless signature
+            if token_index && tokens && attribute_target_token?(tokens, token_index)
+              signature = "attribute target #{name}"
+            end
+          end
+
           end
 
           return nil unless signature
@@ -535,6 +561,8 @@ module MilkTea
 
         definition_entry = if source_location
                              measure_perf_stage(stages, 'definition_entry') { hover_definition_entry_from_location(source_location) }
+                           elsif resolved_via_type_member
+                             nil
                            else
                              measure_perf_stage(stages, 'global_definition') do
                                @workspace.find_definition_token_global(
@@ -961,9 +989,10 @@ module MilkTea
               source_location = field_definition_location(current_uri, field_receiver_type, segment[:name])
 
               if segment[:token_index] == token_index
+                definition_entry = hover_definition_entry_from_location(source_location)
                 return {
                   signature: field_hover_signature(segment[:name], field_type),
-                  docs: nil,
+                  docs: hover_doc_comment_for_definition(definition_entry),
                   source: hover_source_label_from_location(source_location),
                   source_uri: hover_source_uri_from_location(source_location),
                   source_line: hover_source_line_from_location(source_location),
@@ -978,7 +1007,7 @@ module MilkTea
               if segment[:token_index] == token_index
                 return {
                   signature: type_hover_signature(segment[:name], nested),
-                  docs: nil,
+                  docs: BUILTIN_TYPE_DOCS[segment[:name]],
                 }
               end
               current_type = nested
@@ -993,10 +1022,11 @@ module MilkTea
 
           source_location = module_member_binding_location(current_uri, method_info[:module_name], segment[:name], method_info[:binding])
           source_location ||= module_member_definition_location(current_uri, method_info[:module_name], segment[:name])
+          definition_entry = hover_definition_entry_from_location(source_location)
 
           return {
             signature: method_signature(method_info[:binding]),
-            docs: nil,
+            docs: hover_doc_comment_for_definition(definition_entry),
             source: hover_source_label_from_location(source_location),
             source_uri: hover_source_uri_from_location(source_location),
             source_line: hover_source_line_from_location(source_location),
@@ -1386,6 +1416,43 @@ module MilkTea
         "field #{name}: #{type}"
       end
 
+      def find_nested_type_by_short_name(facts, short_name)
+        matches = facts.types.keys.select { |k| k.to_s.end_with?(".#{short_name}") }
+        return nil unless matches.length == 1
+
+        facts.types[matches.first]
+      end
+
+      def find_member_in_types(facts, name)
+        facts.types.reverse_each do |_key, type|
+          next unless type.respond_to?(:members)
+
+          member = type.members.find { |m| m == name }
+          if member
+            value = type.respond_to?(:member_value) ? type.member_value(name) : nil
+            return [type, member, value]
+          end
+        end
+        nil
+      end
+
+      def find_variant_arm_in_types(facts, name)
+        facts.types.reverse_each do |_key, type|
+          arm = nil
+          if type.respond_to?(:arms)
+            arm = type.arms[name]
+          elsif type.respond_to?(:arm_names) && type.arm_names.include?(name)
+            arm = type.arm(name)
+          end
+          next unless arm
+
+          fields = arm.map { |fname, ftype| "#{fname}: #{ftype}" }.join(", ")
+          field_str = fields.empty? ? "" : "(#{fields})"
+          return "#{type.name}.#{name}#{field_str}"
+        end
+        nil
+      end
+
       def builtin_hover_info(name, tokens, token_index)
         specialization_info = builtin_value_specialization_info(name, tokens, token_index)
         return specialization_info if specialization_info
@@ -1399,11 +1466,60 @@ module MilkTea
         builtin_call_hover_info(name, tokens, token_index)
       end
 
+      def parameter_declaration_token?(tokens, index)
+        return false unless index && tokens[index]&.type == :identifier
+
+        prev = previous_non_trivia_token_index(tokens, index)
+        return false unless prev
+        return false unless [:lparen, :comma].include?(tokens[prev].type)
+
+        nxt = next_non_trivia_token_index(tokens, index + 1)
+        nxt && tokens[nxt].type == :colon
+      end
+
+      def attribute_target_token?(tokens, index)
+        return false unless index && tokens[index]&.type == :identifier
+
+        prev = previous_non_trivia_token_index(tokens, index)
+        return false unless prev && [:lbracket, :comma].include?(tokens[prev].type)
+
+        after = next_non_trivia_token_index(tokens, index + 1)
+        return false unless after && [:rbracket, :comma].include?(tokens[after].type)
+
+        true
+      end
+
+      def call_argument_token?(tokens, index)
+        return false unless index && tokens[index]&.type == :identifier
+
+        prev = previous_non_trivia_token_index(tokens, index)
+        return false unless prev && [:lparen, :comma].include?(tokens[prev].type)
+
+        nxt = next_non_trivia_token_index(tokens, index + 1)
+        !nxt || ![:colon, :rbracket, :comma].include?(tokens[nxt].type)
+      end
+
       def builtin_in_member_access_context?(tokens, token_index)
         prev_index = previous_non_trivia_token_index(tokens, token_index)
         prev_index && tokens[prev_index].type == :dot
       end
 
+      def member_access_token?(context)
+        tokens = context[:tokens]
+        token_index = context[:token_index]
+        return false unless tokens && token_index
+        prev = previous_non_trivia_token_index(tokens, token_index)
+        prev && tokens[prev].type == :dot
+      end
+
+      def keyword_member_access_token?(tokens, token_index)
+        return false unless tokens && token_index
+        tok = tokens[token_index]
+        return false unless tok && tok.type != :identifier
+        prev = previous_non_trivia_token_index(tokens, token_index)
+        prev && tokens[prev].type == :dot
+      end
+
       def builtin_value_specialization_info(name, tokens, token_index)
         return nil unless %w[zero default reinterpret].include?(name)
 
@@ -1439,7 +1555,7 @@ module MilkTea
       end
 
       def builtin_type_constructor_hover_info(name, tokens, token_index)
-        return nil unless %w[array span Option Result SoA str_buffer].include?(name)
+        return nil unless %w[array span Option Result SoA str_buffer ref ptr const_ptr own Task atomic].include?(name)
 
         lbracket_index = next_non_trivia_token_index(tokens, token_index + 1)
         return nil unless lbracket_index && tokens[lbracket_index].type == :lbracket
@@ -1494,6 +1610,18 @@ module MilkTea
                   '`Result[T, E]` is the built-in success/failure type with `success(value = ...)` and `failure(error = ...)` arms.'
                 when 'str_buffer'
                   '`str_buffer[N]` is a fixed-capacity mutable UTF-8 text buffer. Methods: `assign`, `append`, `assign_format`, `append_format`, `clear`, `len`, `as_str`, `as_cstr`.'
+                when 'ref'
+                  '`ref[T]` is a non-null borrow reference. Auto-dereferences for member access and method calls. Cannot be stored in module-level variables, constants, or nested containers.'
+                when 'ptr'
+                  '`ptr[T]` is a raw mutable pointer. Indexing, dereference, and arithmetic require `unsafe`. Nullable via `ptr[T]?`.'
+                when 'const_ptr'
+                  '`const_ptr[T]` is a read-only pointer. Does not require `unsafe` for dereference.'
+                when 'own'
+                  '`own[T]` is an owning heap pointer. Auto-dereferences like `ref`. Storable, returnable, and nullable. Allocated via `heap.must_alloc[T](count)`.'
+                when 'Task'
+                  '`Task[T]` is an async task future. Returned by `async function`. Use `await` to unwrap, or `aio.wait`/`aio.run` to drive.'
+                when 'atomic'
+                  '`atomic[T]` is an atomic value for lock-free concurrent access. `T` must be a primitive integer or `bool`. Methods: `load`, `store`, `add`, `sub`, `exchange`.'
                 end
 
         {
@@ -1734,6 +1862,14 @@ module MilkTea
               when "let" then kind = :let
               when "var" then kind = :var
               when "const" then kind = :const
+              when "struct" then kind = :struct_type
+              when "function", "async", "external", "foreign" then kind = :function
+              when "enum" then kind = :enum_type
+              when "flags" then kind = :flags_type
+              when "union" then kind = :union_type
+              when "variant" then kind = :variant_type
+              when "(" then kind = :param
+              when "," then kind = :param
               end
             end
 
@@ -1760,9 +1896,15 @@ module MilkTea
         end
 
         kind ||= :let
+        unless %i[let var const param].include?(kind)
+          kind = kind.to_s.sub(/_type$/, "")
+          return "#{kind} #{name}"
+        end
+
+        display_kind = kind == :param ? "parameter" : kind.to_s
         mutability = kind == :var ? "mutable" : "immutable"
         if type_str && !type_str.empty?
-          "#{kind} #{name}: #{type_str} (#{mutability})"
+          "#{display_kind} #{name}: #{type_str} (#{mutability})"
         else
           "#{kind} #{name} (#{mutability})"
         end

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

@@ -44,47 +44,62 @@ module MilkTea
         while i < tokens.length - 1
           callee = tokens[i]
           next_tok = tokens[i + 1]
-
           prev_tok = i > 0 ? tokens[i - 1] : nil
 
-          if callee.type == :identifier && prev_tok&.type != :function && prev_tok&.type != :dot
-            binding = nil
-            lparen_index = nil
+          binding = nil
+          lparen_index = nil
 
+          if callee.type == :identifier && prev_tok&.type != :function
+            # Direct function call: func(...)
             if next_tok&.type == :lparen
               binding = facts.functions[callee.lexeme]
+              binding ||= facts.imports.each_value.find { |mod| mod.functions.key?(callee.lexeme) }&.functions&.dig(callee.lexeme)
               lparen_index = i + 1
             elsif next_tok&.type == :dot
               member = tokens[i + 2]
               member_lparen = tokens[i + 3]
               if member&.type == :identifier && member_lparen&.type == :lparen
-                module_binding = facts.imports[callee.lexeme]
-                binding = module_binding&.functions&.[](member.lexeme)
+                # Module-qualified call: mod.func(...)
+                mod_binding = facts.imports[callee.lexeme]
+                if mod_binding
+                  binding = mod_binding.functions[member.lexeme]
+                else
+                  # Instance method call: obj.method(...) or Type.static(...)
+                  receiver_type = resolve_dot_receiver_value_type(facts, callee.lexeme, callee.line, callee.column)
+                  receiver_type ||= facts.types[callee.lexeme]
+                  unless receiver_type
+                    receiver_type = facts.imports.each_value.find { |mod| mod.types.key?(callee.lexeme) }&.types&.dig(callee.lexeme)
+                  end
+                  if receiver_type
+                    methods = methods_for_receiver_type(facts, receiver_type)
+                    binding = methods[member.lexeme] || methods["static:#{member.lexeme}"]
+                  end
+                end
                 lparen_index = i + 3
               end
             end
+          end
 
-            if binding && lparen_index
-              arg_starts, closing_index = collect_call_argument_starts(tokens, lparen_index)
-              params_list = binding.type.params
-
-              arg_starts.each_with_index do |arg_tok, index|
-                break if index >= params_list.length
-                next unless position_in_range?(arg_tok.line - 1, arg_tok.column - 1, start_line, start_char, end_line, end_char)
-                next if self_describing_argument_expression?(tokens, arg_tok)
-                param_name = params_list[index].name
-                next if arg_tok.type == :identifier && arg_tok.lexeme == param_name
-
-                hints << {
-                  position: { line: arg_tok.line - 1, character: arg_tok.column - 1 },
-                  label: "#{params_list[index].name}: ",
-                  kind: 2,
-                  paddingRight: true
-                }
-              end
-
-              i = closing_index if closing_index
+          if binding && lparen_index
+            arg_starts, closing_index = collect_call_argument_starts(tokens, lparen_index)
+            params_list = binding.respond_to?(:type) ? binding.type.params : []
+
+            arg_starts.each_with_index do |arg_tok, index|
+              break if index >= params_list.length
+              next unless position_in_range?(arg_tok.line - 1, arg_tok.column - 1, start_line, start_char, end_line, end_char)
+              next if self_describing_argument_expression?(tokens, arg_tok)
+              param_name = params_list[index].name
+              next if arg_tok.type == :identifier && arg_tok.lexeme == param_name
+
+              hints << {
+                position: { line: arg_tok.line - 1, character: arg_tok.column - 1 },
+                label: "#{params_list[index].name}: ",
+                kind: 2,
+                paddingRight: true
+              }
             end
+
+            i = closing_index if closing_index
           end
 
           i += 1
@@ -121,6 +136,12 @@ module MilkTea
           next unless position_in_range?(func.line - 1, func.column - 1, start_line, start_char, end_line, end_char)
 
           binding = facts.functions[func.name]
+          unless binding
+            facts.imports.each_value do |mod|
+              binding = mod.functions[func.name]
+              break if binding
+            end
+          end
           next unless binding
 
           return_type = binding.type.return_type

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

@@ -311,6 +311,30 @@ module MilkTea
           unless scoped.nil?
             return scoped.map { |entry| { range: entry[:range], kind: 1 } }
           end
+
+          binding_id = begin
+            rename_target_binding_id(uri, token, lsp_line, lsp_char, facts)
+          rescue StandardError
+            nil
+          end
+          if binding_id
+            ranges = begin
+              scoped_binding_occurrence_ranges(uri, token.lexeme, facts, binding_id, include_declaration: true)
+            rescue StandardError
+              []
+            end
+            unless ranges.empty?
+              return ranges.map do |range|
+                {
+                  range: {
+                    start: { line: range[:line] - 1, character: range[:column] - 1 },
+                    end: { line: range[:line] - 1, character: range[:column] - 1 + range[:length] },
+                  },
+                  kind: 1,
+                }
+              end
+            end
+          end
         end
 
         toks = @workspace.get_tokens(uri) || []

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

@@ -70,11 +70,6 @@ module MilkTea
         workspace_symbol_changes = workspace_symbol_identity_rename_changes(uri, token, lsp_line, lsp_char, new_name)
         return { changes: workspace_symbol_changes } if workspace_symbol_changes
 
-        if (facts = @workspace.get_facts(uri))
-          module_symbol_changes = module_level_symbol_rename_changes(uri, token, lsp_line, lsp_char, facts, new_name)
-          return { changes: module_symbol_changes } if module_symbol_changes
-        end
-
         lexical_changes = lexical_rename_changes_in_document(uri, token.lexeme, new_name)
         return { changes: lexical_changes } if lexical_changes
 
@@ -202,27 +197,6 @@ module MilkTea
         { uri => edits }
       end
 
-      def module_level_symbol_rename_changes(uri, token, lsp_line, lsp_char, facts, new_name)
-        name = token.lexeme
-        module_level = facts.functions.key?(name) || facts.values.key?(name) || facts.types.key?(name) || facts.interfaces&.key?(name)
-        return nil unless module_level
-
-        related_uris = @workspace.related_open_document_uris(uri)
-        changes = {}
-        [uri, *related_uris].uniq.each do |doc_uri|
-          edits = []
-          doc_tokens = @workspace.get_tokens(doc_uri) || []
-          doc_tokens.each do |tok|
-            next unless tok.type == :identifier && tok.lexeme == name
-            edits << { range: token_to_range(tok), newText: new_name }
-          end
-          changes[doc_uri] = edits unless edits.empty?
-        end
-
-        return nil if changes.empty?
-        changes
-      end
-
       def import_alias_rename_changes(uri, token, lsp_line, lsp_char, facts, new_name)
         alias_name = token.lexeme
         if facts
@@ -286,22 +260,28 @@ module MilkTea
                                 type_name_member_access?(tokens, cursor_index, facts)
         return nil unless cursor_is_enum_member
 
-        edits = tokens.each_with_index.filter_map do |tok, i|
-          next unless tok.type == :identifier && tok.lexeme == token.lexeme
+        changes = {}
+        [uri, *@workspace.related_open_document_uris(uri)].uniq.each do |doc_uri|
+          doc_tokens = @workspace.get_tokens(doc_uri) || []
+          doc_facts = doc_uri == uri ? facts : @workspace.get_facts(doc_uri)
+          edits = doc_tokens.each_with_index.filter_map do |tok, i|
+            next unless tok.type == :identifier && tok.lexeme == token.lexeme
 
-          enum_member_decl = variant_enum_member_declaration?(tokens, i)
-          enum_member_access = type_name_member_access?(tokens, i, facts)
-          next unless enum_member_decl || enum_member_access
+            enum_member_decl = variant_enum_member_declaration?(doc_tokens, i)
+            enum_member_access = type_name_member_access?(doc_tokens, i, doc_facts)
+            next unless enum_member_decl || enum_member_access
 
-          {
-            range: token_to_range(tok),
-            newText: new_name,
-          }
-        end
+            {
+              range: token_to_range(tok),
+              newText: new_name,
+            }
+          end
 
-        return nil if edits.empty?
+          changes[doc_uri] = edits unless edits.empty?
+        end
 
-        { uri => edits }
+        return nil if changes.empty?
+        changes
       end
 
       def scoped_local_reference_locations(uri, token, lsp_line, lsp_char, facts, include_declaration:)
@@ -482,16 +462,28 @@ module MilkTea
         struct_type = find_struct_containing_field(facts, field_name)
         return nil unless struct_type
 
+        changes = collect_struct_field_changes(uri, field_name, new_name)
+        related_uris = @workspace.related_open_document_uris(uri)
+        related_uris.each do |related_uri|
+          next if related_uri == uri
+          related_changes = collect_struct_field_changes(related_uri, field_name, new_name)
+          changes[related_uri] = related_changes if related_changes
+        end
+
+        return nil if changes.empty?
+        changes
+      end
+
+      def collect_struct_field_changes(uri, field_name, new_name)
+        tokens = @workspace.get_tokens(uri) || []
         edits = []
         tokens.each_with_index do |tok, i|
           next unless tok.type == :identifier && tok.lexeme == field_name
-          next unless struct_field_edit_context?(tokens, i, struct_type)
+          next unless struct_field_edit_context?(tokens, i, nil)
 
           edits << { range: token_to_range(tok), newText: new_name }
         end
-
-        return nil if edits.empty?
-        { uri => edits }
+        edits.empty? ? nil : edits
       end
 
       def struct_field_cursor_context?(tokens, index)
@@ -555,17 +547,25 @@ module MilkTea
         receiver_type = method_info[:receiver_type]
         return nil unless receiver_type
 
-        edits = []
-        doc_tokens = @workspace.get_tokens(uri) || []
-        doc_tokens.each_with_index do |tok, i|
-          next unless tok.type == :identifier && tok.lexeme == method_name
-          next unless i > 0 && doc_tokens[i - 1].type == :dot
+        changes = {}
+        [uri, *@workspace.related_open_document_uris(uri)].uniq.each do |doc_uri|
+          edits = []
+          doc_tokens = @workspace.get_tokens(doc_uri) || []
+          doc_tokens.each_with_index do |tok, i|
+            next unless tok.type == :identifier && tok.lexeme == method_name
 
-          edits << { range: token_to_range(tok), newText: new_name }
+            is_call = i > 0 && doc_tokens[i - 1].type == :dot
+            is_def = doc_uri == uri && tok.line == token.line && tok.column == token.column
+            next unless is_call || is_def
+
+            edits << { range: token_to_range(tok), newText: new_name }
+          end
+
+          changes[doc_uri] = edits unless edits.empty?
         end
 
-        return nil if edits.empty?
-        { uri => edits }
+        return nil if changes.empty?
+        changes
       end
 
       def find_method_at_position(uri, token, facts)

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

@@ -28,18 +28,25 @@ module MilkTea
             end
           end
 
-          if (receiver_type = resolve_dot_receiver_value_type(facts, dot_recv, lsp_line + 1, lsp_char + 1))
+          if (receiver_type = resolve_dot_receiver_value_type(facts, dot_recv, lsp_line + 1, lsp_char + 1) ||
+                               resolve_dot_receiver_value_type(facts, dot_recv.sub(/\[.*\]\z/, ""), lsp_line + 1, lsp_char + 1))
             methods = methods_for_receiver_type(facts, receiver_type)
             if (binding = methods[name] || methods["static:#{name}"])
               return [binding, name]
             end
           end
 
-          if (type_receiver = resolve_type_receiver_info(facts, dot_recv, nil))
+          if (type_receiver = resolve_type_receiver_info(facts, dot_recv, nil) ||
+                              resolve_type_receiver_info(facts, dot_recv.sub(/\[.*\]\z/, ""), nil))
             methods = methods_for_receiver_type(facts, type_receiver[:type])
             if (binding = methods[name] || methods["static:#{name}"])
               return [binding, name]
             end
+            if type_receiver[:type].respond_to?(:arms) && (arm = type_receiver[:type].arms[name])
+              if arm.respond_to?(:payload) && arm.payload
+                return [arm.payload, name]
+              end
+            end
           end
         end
 
@@ -60,7 +67,7 @@ module MilkTea
         end
 
         # 6. Type constructor (struct constructor)
-        if (type = facts.types[name])
+        if (type = facts.types[name] || facts.imports.each_value.find { |mod| mod.types.key?(name) }&.types&.dig(name))
           if type.respond_to?(:fields) && !type.fields.empty?
             return [type, name]
           end
@@ -99,12 +106,13 @@ module MilkTea
         end
 
         return nil unless extending
-        facts.types[extending.type_name]
+        facts.types[extending.type_name] ||
+          facts.imports.each_value.find { |mod| mod.types.key?(extending.type_name) }&.types&.dig(extending.type_name)
       end
 
       def build_signature_from_binding(binding, name, ctx)
-        if binding.is_a?(Types::Struct) || binding.is_a?(Types::StructInstance)
-          fields = binding.fields
+        if binding.is_a?(Types::Struct) || binding.is_a?(Types::StructInstance) || binding.is_a?(Types::VariantArmPayload)
+          fields = binding.is_a?(Types::StructInstance) ? binding.definition.fields : binding.fields
           params_list = fields.map { |fname, ftype| Types::Registry.parameter(fname, ftype) }
           return_type_label = binding.is_a?(Types::StructInstance) ? binding.to_s : binding.name
         elsif binding.respond_to?(:[])
@@ -120,6 +128,7 @@ module MilkTea
             activeParameter: ctx[:active_parameter],
           }
         else
+          return nil unless binding.respond_to?(:type) && binding.type.respond_to?(:params)
           params_list = binding.type.params
           return_type_label = binding.type.return_type
         end

data/lib/milk_tea/lsp/workspace/caches.rb

@@ -6,7 +6,15 @@ module MilkTea
       module WorkspaceCaches
         def get_content(uri)
           @document_state_mutex.synchronize do
-            @open_documents[uri] || @indexed_documents[uri] || ''
+            @open_documents[uri] || @indexed_documents[uri] ||
+              begin
+                path = uri_to_path(uri)
+                if path && File.file?(path)
+                  @indexed_documents[uri] = File.read(path)
+                end
+              rescue StandardError
+                nil
+              end || ''
           end
         end
 

data/std/option.mt

@@ -8,6 +8,7 @@ public variant Option[T]:
     none
 
 extending Option[T]:
+    ## Returns true when the option holds a value.
     public function is_some() -> bool:
         match this:
             Option.some:
@@ -15,6 +16,7 @@ extending Option[T]:
             Option.none:
                 return false
 
+    ## Returns true when the option holds no value.
     public function is_none() -> bool:
         match this:
             Option.some:
@@ -22,6 +24,7 @@ extending Option[T]:
             Option.none:
                 return true
 
+    ## Returns the contained value or aborts via fatal.
     public function unwrap() -> T:
         match this:
             Option.some as payload:
@@ -29,6 +32,7 @@ extending Option[T]:
             Option.none:
                 fatal(c"called Option.unwrap on a none value")
 
+    ## Returns the contained value or aborts with the given message.
     public function expect(msg: str) -> T:
         match this:
             Option.some as payload:
@@ -36,6 +40,7 @@ extending Option[T]:
             Option.none:
                 fatal(msg)
 
+    ## Returns the contained value or a default.
     public function unwrap_or(default: T) -> T:
         match this:
             Option.some as payload:
@@ -43,6 +48,7 @@ extending Option[T]:
             Option.none:
                 return default
 
+    ## Returns the contained value or calls a fallback closure.
     public function unwrap_or_else(f: proc() -> T) -> T:
         match this:
             Option.some as payload:

data/std/result.mt

@@ -11,6 +11,7 @@ public variant Result[T, E]:
     failure(error: E)
 
 extending Result[T, E]:
+    ## Returns true when the result holds a success value.
     public function is_success() -> bool:
         match this:
             Result.success:
@@ -18,6 +19,7 @@ extending Result[T, E]:
             Result.failure:
                 return false
 
+    ## Returns true when the result holds a failure value.
     public function is_failure() -> bool:
         match this:
             Result.success:
@@ -25,6 +27,7 @@ extending Result[T, E]:
             Result.failure:
                 return true
 
+    ## Returns the success value or aborts via fatal.
     public function unwrap() -> T:
         match this:
             Result.success as payload:
@@ -32,6 +35,7 @@ extending Result[T, E]:
             Result.failure:
                 fatal(c"called Result.unwrap on a failure value")
 
+    ## Returns the success value or aborts with the given message.
     public function expect(msg: str) -> T:
         match this:
             Result.success as payload:
@@ -39,6 +43,7 @@ extending Result[T, E]:
             Result.failure:
                 fatal(msg)
 
+    ## Returns the failure error value or aborts via fatal.
     public function unwrap_error() -> E:
         match this:
             Result.success:
@@ -46,6 +51,7 @@ extending Result[T, E]:
             Result.failure as payload:
                 return payload.error
 
+    ## Returns the failure error value or aborts with the given message.
     public function expect_error(msg: str) -> E:
         match this:
             Result.success:
@@ -53,6 +59,7 @@ extending Result[T, E]:
             Result.failure as payload:
                 return payload.error
 
+    ## Returns the success value or a default.
     public function unwrap_or(default: T) -> T:
         match this:
             Result.success as payload:
@@ -60,6 +67,7 @@ extending Result[T, E]:
             Result.failure:
                 return default
 
+    ## Returns the success value or calls a fallback closure with the error.
     public function unwrap_or_else(f: proc(error: E) -> T) -> T:
         match this:
             Result.success as payload:
@@ -67,6 +75,7 @@ extending Result[T, E]:
             Result.failure as payload:
                 return f(error=payload.error)
 
+    ## Maps the error through a closure while preserving the success value.
     public function map_error[F](f: proc(error: E) -> F) -> Result[T, F]:
         match this:
             Result.success as payload:
@@ -74,6 +83,7 @@ extending Result[T, E]:
             Result.failure as payload:
                 return Result[T, F].failure(error = f(payload.error))
 
+    ## Converts the result into an Option, discarding the error.
     public function ok() -> Option[T]:
         match this:
             Result.success as payload:
@@ -81,6 +91,7 @@ extending Result[T, E]:
             Result.failure:
                 return Option[T].none
 
+    ## Converts the failure into an Option, discarding the success value.
     public function error() -> Option[E]:
         match this:
             Result.success:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.14
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -583,7 +583,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.2.12 installed!
+  Milk Tea 0.2.14 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH