mt-lang 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9047d861f94f1e5b66f531712466e32779a0a86bd02db452e36cd8990980ee5c
-  data.tar.gz: 3e9d1c7f06e70e2a9e3b84b8df4e8ee64b92be6e34f6bc970ca0b2ef69683c8e
+  metadata.gz: 440292bdf9bb8c311ff6172c6b063defbae416862b2f3369b70c4249bcc09f37
+  data.tar.gz: 4793a630eff4f1672659c682e3fb9df769e6d7aaf20facc3742216b7af8fe388
 SHA512:
-  metadata.gz: 4144e09654664b0dd4eaf7d697fe077381c965902564297d32002807be4b9100861ca8c7c7e065b983e90b91dba4b86f22f52eaa4eae47fa1d68dee1cb1acc36
-  data.tar.gz: a712ee592463d961523bd2c8481be6993843f277c51bd3947f34bd8d3e32ae8d245ead8985f31d2621cefd8cc1ec705eba1749aca99324cdd3061adb5ef13ce2
+  metadata.gz: ba82f455b038f4bfcf2b3d2748db4327fec835bf676f854578aca8c21f5614836b693385c70679cbece42917a7a2093a405029f4e6b7a7fa9dcb2c0a1af13257
+  data.tar.gz: 51f8316e7466ae58c141168a3f350c2104fc61a859d41e1a21316a7d56c11d7ea0ca49113f7c6aa69fe9bf2a06c055ff6d6d94fa0d931096d76ddc1e38610ccd

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.10"
+  VERSION = "0.2.11"
 
   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,54 @@ 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
+
       def handle_hover(params)
         stages = new_perf_stages
         total_start = stages ? monotonic_time : nil
@@ -238,7 +286,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 +426,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 +444,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)
@@ -1335,7 +1394,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 +1446,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.11
 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.11 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH