mt-lang 0.2.13 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34c858250b3d56b9c9e2184e4cf3a29d180b176e49d77be5bffd52063a458718
-  data.tar.gz: 8ad1e294bd42fc71273ee495ff91b632b788a835c1f4d96203f298d6e2b6db6b
+  metadata.gz: 684d2aada4af1e2b5fc1c0685e26004ed9442931692cb25007777b09df77dbe5
+  data.tar.gz: 5f16c0ce02404a51f4ac8dd8c12b8047fb4ae5ab442b1269ba7ce8c58809a065
 SHA512:
-  metadata.gz: ebd5cae94ad9eaa939d265bbc31d57a1b29ecb53b2abf8e3437b6264d0ce635ca21a64bbaeb930b4526c34a633fd5f8742ed579c3b7aa1ad63e4c953e98d3651
-  data.tar.gz: 977bea5a674e4a5a0b7eade459a18a7c7aaf1eb157c7e09bd7c13f4baf2665461e480943e8c8a509f21f399e5e9315c1c9b70d75d500bad20b7d9301af29aed6
+  metadata.gz: 9e129d1a7a428094755af01cb5bb98c29fb78ee9003b6938cb4335eb0e58763804a9e1c902f5d1563111a20c7b70ca69f4497f11c4cf476ed5b9ef8696ccc9ed
+  data.tar.gz: ffc46a4a1658c84a2fa6d2d7d6331b98164487c488112055adc9a2f20367074f26a02002d0a36ec493f9f9738ac2123f80a2e1e04fbaa5b364a54509898a2644

data/lib/milk_tea/base.rb

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

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"

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

@@ -285,6 +285,7 @@ module MilkTea
             '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' => {
@@ -313,21 +314,23 @@ module MilkTea
         token = context&.fetch(:token, nil)
         token_kind = token&.type || :none
         unless token&.type == :identifier
-          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
+          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)
@@ -362,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
@@ -462,11 +466,11 @@ module MilkTea
             docs ||= BUILTIN_TYPE_DOCS[name]
           elsif (binding = facts.values[name])
             signature = value_hover_signature(binding)
-          elsif (member_info = find_member_in_types(facts, name))
+          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 (arm_sig = find_variant_arm_in_types(facts, name))
+          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])
@@ -522,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
@@ -550,19 +554,6 @@ module MilkTea
             end
           end
 
-          unless signature
-            unless token_index && tokens && (tokens[previous_non_trivia_token_index(tokens, token_index)]&.type == :dot || call_argument_token?(tokens, token_index))
-              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
-            end
-          end
           end
 
           return nil unless signature
@@ -998,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),
@@ -1015,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
@@ -1030,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),
@@ -1511,6 +1504,22 @@ module MilkTea
         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)
 

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.13
+  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.13 installed!
+  Milk Tea 0.2.14 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH