mt-lang 0.2.11 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 440292bdf9bb8c311ff6172c6b063defbae416862b2f3369b70c4249bcc09f37
-  data.tar.gz: 4793a630eff4f1672659c682e3fb9df769e6d7aaf20facc3742216b7af8fe388
+  metadata.gz: 34c858250b3d56b9c9e2184e4cf3a29d180b176e49d77be5bffd52063a458718
+  data.tar.gz: 8ad1e294bd42fc71273ee495ff91b632b788a835c1f4d96203f298d6e2b6db6b
 SHA512:
-  metadata.gz: ba82f455b038f4bfcf2b3d2748db4327fec835bf676f854578aca8c21f5614836b693385c70679cbece42917a7a2093a405029f4e6b7a7fa9dcb2c0a1af13257
-  data.tar.gz: 51f8316e7466ae58c141168a3f350c2104fc61a859d41e1a21316a7d56c11d7ea0ca49113f7c6aa69fe9bf2a06c055ff6d6d94fa0d931096d76ddc1e38610ccd
+  metadata.gz: ebd5cae94ad9eaa939d265bbc31d57a1b29ecb53b2abf8e3437b6264d0ce635ca21a64bbaeb930b4526c34a633fd5f8742ed579c3b7aa1ad63e4c953e98d3651
+  data.tar.gz: 977bea5a674e4a5a0b7eade459a18a7c7aaf1eb157c7e09bd7c13f4baf2665461e480943e8c8a509f21f399e5e9315c1c9b70d75d500bad20b7d9301af29aed6

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.11"
+  VERSION = "0.2.13"
 
   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

@@ -581,8 +581,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/hover.rb

@@ -272,6 +272,34 @@ module MilkTea
           'Subscription' => 'Opaque handle returned by `event.subscribe`. Pass to `event.unsubscribe` to remove a listener.',
         }.freeze
 
+        BUILTIN_TYPE_METHOD_SIGNATURES = {
+          'atomic' => {
+            'load' => 'function load() -> T',
+            'store' => 'static function store(value: T) -> void',
+            'add' => 'static function add(value: T) -> T',
+            'sub' => 'static function sub(value: T) -> T',
+            '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',
+            'wait' => 'function wait() -> Task[Result[T, EventError]]',
+          },
+          'str_buffer' => {
+            'assign' => 'static function assign(value: str) -> void',
+            'append' => 'static function append(value: str) -> void',
+            'assign_format' => 'static function assign_format(fmt: str) -> void',
+            'append_format' => 'static function append_format(fmt: str) -> void',
+            'clear' => 'static function clear() -> void',
+            'len' => 'static function len() -> ptr_uint',
+            'capacity' => 'static function capacity() -> ptr_uint',
+            'as_str' => 'static function as_str() -> str',
+            'as_cstr' => 'static function as_cstr() -> cstr',
+          },
+        }.freeze
+
       def handle_hover(params)
         stages = new_perf_stages
         total_start = stages ? monotonic_time : nil
@@ -285,7 +313,8 @@ module MilkTea
         token = context&.fetch(:token, nil)
         token_kind = token&.type || :none
         unless token&.type == :identifier
-          info = builtin_keyword_hover_info(token)
+          info = builtin_keyword_hover_info(token) ||
+                 BUILTIN_CALL_HOVER_INFO[token.lexeme]&.slice(:signature, :docs)
           if info
             result_state = 'hit'
             return {
@@ -390,6 +419,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)
@@ -427,11 +457,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 (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))
+            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)
@@ -465,6 +510,27 @@ module MilkTea
             end
           end
 
+          unless signature
+            if dot_receiver
+              receiver_name = dot_receiver
+              receiver_binding = resolve_local_hover_binding(facts, receiver_name, lsp_line + 1, lsp_char + 1) ||
+                                 facts.values[receiver_name] ||
+                                 facts.functions[receiver_name]
+              if receiver_binding && receiver_binding.type
+                receiver_type = receiver_binding.respond_to?(:storage_type) ? receiver_binding.storage_type : receiver_binding.type
+                methods = methods_for_receiver_type(facts, receiver_type)
+                if (method_binding = methods[name])
+                  signature = method_signature(method_binding)
+                else
+                  type_base = receiver_type.to_s[/^([a-z_]+)/, 1]
+                  if type_base && (method_sigs = BUILTIN_TYPE_METHOD_SIGNATURES[type_base])
+                    signature = method_sigs[name]
+                  end
+                end
+              end
+            end
+          end
+
           unless signature
             if token_index && (builtin_info = builtin_hover_info(name, tokens, token_index))
               signature = builtin_info[:signature]
@@ -473,14 +539,28 @@ module MilkTea
           end
 
           unless signature
-            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])
+            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
+
+          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
@@ -490,6 +570,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(
@@ -1341,6 +1423,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
@@ -1354,6 +1473,39 @@ 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
@@ -1394,7 +1546,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
@@ -1449,6 +1601,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
 
         {
@@ -1689,6 +1853,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
 
@@ -1715,9 +1887,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.13
 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.11 installed!
+  Milk Tea 0.2.13 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH