mt-lang 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9047d861f94f1e5b66f531712466e32779a0a86bd02db452e36cd8990980ee5c
-  data.tar.gz: 3e9d1c7f06e70e2a9e3b84b8df4e8ee64b92be6e34f6bc970ca0b2ef69683c8e
+  metadata.gz: 28dc7f8c8824f11189bdd3cf704d10eefa2e144d466b218b5b34b1693531fe94
+  data.tar.gz: 73dcea75aeb6fb9c460e6b574e0bb64dc118ca9cd0a028586bd526d7b00acb49
 SHA512:
-  metadata.gz: 4144e09654664b0dd4eaf7d697fe077381c965902564297d32002807be4b9100861ca8c7c7e065b983e90b91dba4b86f22f52eaa4eae47fa1d68dee1cb1acc36
-  data.tar.gz: a712ee592463d961523bd2c8481be6993843f277c51bd3947f34bd8d3e32ae8d245ead8985f31d2621cefd8cc1ec705eba1749aca99324cdd3061adb5ef13ce2
+  metadata.gz: c3286442bbca94bd51b9c7aa4166f2b854d9f6bd48da3f6860648f303c30c90e39f2ac531315a5f13a148f3591eab1a5a02dabfd935f6ea136dfe0018012db9d
+  data.tar.gz: 53cc3240a7b226d152f831775e508a1db5c030f533d4fb6a88084f6564fcffa86954614e86b37f2c0b7650ae5ef27486e9aea05a6eaffe14b2aa5b2be9be0c8a

data/lib/milk_tea/base.rb

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

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

@@ -87,6 +87,7 @@ module MilkTea
 
       def parse_local_decl(kind)
         line = previous.line
+        column = previous.column
         name_token = nil
         name = nil
         var_type = nil
@@ -145,7 +146,7 @@ module MilkTea
           consume_end_of_statement
         end
 
-        AST::LocalDecl.new(kind:, name:, type: var_type, value:, else_binding:, else_body:, line:, column: name_token&.column || line, destructure_bindings:, destructure_type_name:)
+        AST::LocalDecl.new(kind:, name:, type: var_type, value:, else_binding:, else_body:, line:, column: name_token&.column || column, destructure_bindings:, destructure_type_name:)
       rescue ParseError => e
         raise unless @recovery_errors && name
 

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

@@ -224,6 +224,76 @@ module MilkTea
           },
         }.freeze
 
+        BUILTIN_TYPE_DOCS = {
+          'bool' => '1-byte boolean: `true` or `false`.',
+          'byte' => '8-bit signed integer. Range: -128 to 127.',
+          'ubyte' => '8-bit unsigned integer. Range: 0 to 255. Also used for `char` literals like `\'A\'`.',
+          'char' => '8-bit character type (alias for `ubyte`).',
+          'short' => '16-bit signed integer. Range: -32,768 to 32,767.',
+          'ushort' => '16-bit unsigned integer. Range: 0 to 65,535.',
+          'int' => '32-bit signed integer. Range: -2,147,483,648 to 2,147,483,647. Default enum backing type.',
+          'uint' => '32-bit unsigned integer. Range: 0 to 4,294,967,295.',
+          'long' => '64-bit signed integer.',
+          'ulong' => '64-bit unsigned integer.',
+          'ptr_int' => 'Pointer-sized signed integer. Width matches the target platform pointer size.',
+          'ptr_uint' => 'Pointer-sized unsigned integer. Return type for `size_of`, `align_of`, `offset_of`.',
+          'float' => '32-bit IEEE 754 single-precision float.',
+          'double' => '64-bit IEEE 754 double-precision float.',
+          'void' => 'Empty type for functions with no return value. Not a storable type.',
+          'str' => 'Non-owning UTF-8 string view (pointer + length). Not null-terminated.',
+          'cstr' => 'Null-terminated C string. Used at FFI boundaries.',
+          'vec2' => '2-component float vector. Fields: `.x`, `.y`. Supports component-wise arithmetic.',
+          'vec3' => '3-component float vector. Fields: `.x`, `.y`, `.z`. Supports component-wise arithmetic and `dot`/`cross`/`length` via `std.linear_algebra`.',
+          'vec4' => '4-component float vector. Fields: `.x`, `.y`, `.z`, `.w`. Supports component-wise arithmetic.',
+          'ivec2' => '2-component integer vector. Fields: `.x`, `.y`. Supports component-wise arithmetic.',
+          'ivec3' => '3-component integer vector. Fields: `.x`, `.y`, `.z`. Supports component-wise arithmetic.',
+          'ivec4' => '4-component integer vector. Fields: `.x`, `.y`, `.z`, `.w`. Supports component-wise arithmetic.',
+          'mat3' => '3×3 column-major float matrix. Columns: `.col0`–`.col2` (each `vec3`). Supports `identity`, `transpose` via `std.linear_algebra`.',
+          'mat4' => '4×4 column-major float matrix. Columns: `.col0`–`.col3` (each `vec4`). Supports `identity`, `transpose` via `std.linear_algebra`.',
+          'quat' => 'Quaternion. Fields: `.x`, `.y`, `.z`, `.w`. Layout-compatible with `vec4`. Supports `identity`, `conjugate` via `std.linear_algebra`.',
+          'ptr' => 'Generic pointer type: `ptr[T]`. Raw mutable pointer. Requires `unsafe` for indexing, dereference, and arithmetic.',
+          'const_ptr' => 'Read-only pointer type: `const_ptr[T]`. Immutable pointer, does not require `unsafe` for dereference.',
+          'own' => 'Owning heap pointer: `own[T]`. Auto-dereferences like `ref`. Storable, returnable, and nullable. Allocated via `heap.must_alloc[T](count)`.',
+          'ref' => 'Non-null borrow reference: `ref[T]`. Auto-dereferences for member access and method calls. Cannot be stored in module variables or constants.',
+          'span' => 'Borrowed pointer-plus-length view: `span[T]`. Constructed via `span[T](data = ..., len = ...)`. Arrays coerce implicitly.',
+          'array' => 'Fixed-length array: `array[T, N]`. Constructed via `array[T, N](elements...)`. Omitted trailing elements default to zero.',
+          'str_buffer' => 'Fixed-capacity mutable UTF-8 text buffer: `str_buffer[N]`. Methods: `assign`, `append`, `assign_format`, `append_format`, `clear`, `as_str`, `as_cstr`.',
+          'atomic' => 'Atomic value for lock-free concurrent access: `atomic[T]`. `T` must be a primitive integer or `bool`. Methods: `load`, `store`, `add`, `sub`, `exchange`. Uses C11 `_Atomic`.',
+          'Task' => 'Async task future: `Task[T]`. Returned by `async function`. Use `await` to unwrap, or `aio.wait`/`aio.run` to drive.',
+          'Option' => 'Built-in optional type: `Option[T]`. Arms: `some(value: T)` and `none`. Use `let ... else:` or `?` for safe unwrapping.',
+          'Result' => 'Built-in result type: `Result[T, E]`. Arms: `success(value: T)` and `failure(error: E)`. Use `let ... else:` or `?` for error propagation.',
+          'SoA' => 'Struct-of-Arrays: `SoA[T, N]`. Each struct field becomes a separate array of length `N`. Access `soa[i].field` reads from column `field` at row `i`.',
+          'struct_handle' => 'Compile-time handle for a struct type. Obtained via reflection builtins like `fields_of`.',
+          'field_handle' => 'Compile-time handle for a struct field. Exposes `.name` and `.type`. Obtained via `field_of` and `fields_of`.',
+          'callable_handle' => 'Compile-time handle for a callable declaration. Obtained via `callable_of`. Used with `has_attribute`, `attribute_of`.',
+          'attribute_handle' => 'Compile-time handle for an applied attribute. Obtained via `attribute_of` and `attributes_of`. Use `attribute_arg[T]` to read arguments.',
+          'member_handle' => 'Compile-time handle for an enum or flags member. Exposes `.name` and `.value`. Obtained via `members_of`.',
+          'EventError' => 'Built-in enum returned when event listener capacity is exhausted. Single member: `full`.',
+          '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',
+          },
+          '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
@@ -238,7 +308,16 @@ module MilkTea
         token_kind = token&.type || :none
         unless token&.type == :identifier
           info = builtin_keyword_hover_info(token)
-          return info if info
+          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
@@ -369,6 +448,7 @@ module MilkTea
           elsif facts.types.key?(name)
             type = facts.types[name]
             signature = type_hover_signature(name, type)
+            docs ||= BUILTIN_TYPE_DOCS[name]
           elsif (binding = facts.values[name])
             signature = value_hover_signature(binding)
           elsif (import_binding = facts.imports[name])
@@ -386,6 +466,7 @@ module MilkTea
               signature = value_hover_signature(val)
             elsif module_binding.types.key?(name)
               signature = "type #{name}"
+              docs ||= BUILTIN_TYPE_DOCS[name]
             elsif (binding = module_binding.interfaces[name])
               signature = interface_signature(binding)
               source_location = module_member_definition_location(uri, module_binding.name, name)
@@ -406,6 +487,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]
@@ -414,14 +516,16 @@ 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])
+            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
             end
           end
           end
@@ -1335,7 +1439,7 @@ module MilkTea
       end
 
       def builtin_type_constructor_hover_info(name, tokens, token_index)
-        return nil unless %w[array span Option Result SoA].include?(name)
+        return nil unless %w[array span Option Result SoA str_buffer].include?(name)
 
         lbracket_index = next_non_trivia_token_index(tokens, token_index + 1)
         return nil unless lbracket_index && tokens[lbracket_index].type == :lbracket
@@ -1387,8 +1491,10 @@ module MilkTea
                when 'Option'
                  '`Option[T]` is the built-in optional value type with `some(value = ...)` and `none` arms.'
                when 'Result'
-                 '`Result[T, E]` is the built-in success/failure type with `success(value = ...)` and `failure(error = ...)` arms.'
-               end
+                  '`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`.'
+                end
 
         {
           signature: "builtin type #{specialization}",

metadata

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