mt-lang 0.2.8 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcc2383591d95c6043caebcb271aba6b70650528dafbb1a3cd8b906e74a5a6b6
-  data.tar.gz: 2e264acc4e563b29caf921062ca9156f92869d101b1f16f6516f9b412061a1c9
+  metadata.gz: 440292bdf9bb8c311ff6172c6b063defbae416862b2f3369b70c4249bcc09f37
+  data.tar.gz: 4793a630eff4f1672659c682e3fb9df769e6d7aaf20facc3742216b7af8fe388
 SHA512:
-  metadata.gz: 17ef473e87741d685323aa279e434ce56a24b7c30cc4b48f61cbb7d4b7c49d47300c7cbad1e4211740fc35ecc29bf36ee941fa0b4bb18ac0fc19d04aee69d7ab
-  data.tar.gz: 9952dc4f2a306b443cbd57c4840965c8c7e870f8f9f976643b063635c64e371c0f8e903ea3446b124cd0b7e9ddf6754807c924e90426c1bfe789124bc08d6d44
+  metadata.gz: ba82f455b038f4bfcf2b3d2748db4327fec835bf676f854578aca8c21f5614836b693385c70679cbece42917a7a2093a405029f4e6b7a7fa9dcb2c0a1af13257
+  data.tar.gz: 51f8316e7466ae58c141168a3f350c2104fc61a859d41e1a21316a7d56c11d7ea0ca49113f7c6aa69fe9bf2a06c055ff6d6d94fa0d931096d76ddc1e38610ccd

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -227,8 +227,8 @@ module MilkTea
     RangeExpr = Data.define(:start_expr, :end_expr, :line, :column)
     ExpressionList = Data.define(:elements, :line, :column)
     IfExpr = Data.define(:condition, :then_expression, :else_expression)
-    MatchExpr = Data.define(:expression, :arms, :line, :column, :length) do
-      def initialize(expression:, arms:, line: nil, column: nil, length: nil) = super
+    MatchExpr = Data.define(:expression, :arms, :line, :column, :length, :desugared_from_is) do
+      def initialize(expression:, arms:, line: nil, column: nil, length: nil, desugared_from_is: false) = super
     end
     UnsafeExpr = Data.define(:expression, :line, :column, :length) do
       def initialize(expression:, line: nil, column: nil, length: nil) = super

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

@@ -141,6 +141,7 @@ module MilkTea
             line:,
             column:,
             length: previous.lexeme.length,
+            desugared_from_is: true,
           )
         end
         expr

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

@@ -8,19 +8,270 @@ module MilkTea
 
         KEYWORD_HOVER_INFO = {
           'size_of' => {
-            signature: 'size_of(expr) -> int',
-            docs: '`size_of(expr)` evaluates the compile-time size (in bytes) of the expression\'s type.',
+            signature: 'size_of(Type) -> ptr_uint',
+            docs: '`size_of(Type)` evaluates the compile-time size (in bytes) of the type.',
           },
           'align_of' => {
-            signature: 'align_of(expr) -> int',
-            docs: '`align_of(expr)` evaluates the compile-time alignment (in bytes) of the expression\'s type.',
+            signature: 'align_of(Type) -> ptr_uint',
+            docs: '`align_of(Type)` evaluates the compile-time alignment (in bytes) of the type.',
           },
           'offset_of' => {
-            signature: 'offset_of(Type, field) -> int',
+            signature: 'offset_of(Type, field) -> ptr_uint',
             docs: '`offset_of(Type, field)` evaluates the compile-time byte offset of `field` within `Type`.',
           },
         }.freeze
 
+        LANGUAGE_KEYWORD_HOVER_INFO = {
+          'let' => {
+            signature: 'let',
+            docs: 'Immutable local variable declaration: `let name = value` or `let name: Type`. Supports `else` guard with `T?`, `Option[T]`, or `Result[T, E]`.',
+          },
+          'var' => {
+            signature: 'var',
+            docs: 'Mutable local or module-level variable: `var name: Type = initializer`. Supports `else` guard. Module `var` requires explicit type.',
+          },
+          'const' => {
+            signature: 'const',
+            docs: 'Compile-time constant, requires explicit type and initializer. Block-bodied form `const NAME -> TYPE:` evaluates at compile time.',
+          },
+          'function' => {
+            signature: 'function',
+            docs: 'Ordinary function declaration: `function name(params) -> ReturnType:`. Parameters are non-rebindable. Return type defaults to `void`.',
+          },
+          'async' => {
+            signature: 'async',
+            docs: 'Marks a function as async; the declared return type is lifted to `Task[T]`. Use `await` inside async functions.',
+          },
+          'await' => {
+            signature: 'await',
+            docs: 'Awaits a `Task[T]` inside an async function, yielding the unwrapped `T`. Only allowed in async function bodies.',
+          },
+          'struct' => {
+            signature: 'struct',
+            docs: 'Value-type struct with named, typed fields: `struct Name: field: Type`. Supports generics, nested structs, and `implements`.',
+          },
+          'enum' => {
+            signature: 'enum',
+            docs: 'Integer-backed enumeration: `enum Name: BackingType`. Backing type defaults to `int`. Values auto-increment from 0 or the last explicit value.',
+          },
+          'flags' => {
+            signature: 'flags',
+            docs: 'Bitmask type backed by an integer primitive: `flags Name: uint`. Members must be compile-time integer constants.',
+          },
+          'union' => {
+            signature: 'union',
+            docs: 'Overlapped storage union: `union Name: field1: Type1, field2: Type2`. All fields share the same memory.',
+          },
+          'variant' => {
+            signature: 'variant',
+            docs: 'Tagged union: `variant Name: arm1(field: Type), arm2`. Arms may carry named payload fields. No-payload arms are bare identifiers.',
+          },
+          'opaque' => {
+            signature: 'opaque',
+            docs: 'Externally-defined type with unknown layout: `opaque Name`. May declare `implements` for interface conformance.',
+          },
+          'type' => {
+            signature: 'type',
+            docs: 'Type alias: `type Name = ExistingType`. Generic type parameters are supported.',
+          },
+          'interface' => {
+            signature: 'interface',
+            docs: 'Declares a method contract: `interface Name: function method(params) -> T`. Implemented via `implements`; used at runtime via `dyn[Interface]`.',
+          },
+          'extending' => {
+            signature: 'extending',
+            docs: 'Extends an existing type with methods: `extending Type: function method():`. Supports `function`, `editable function`, and `static function`.',
+          },
+          'implements' => {
+            signature: 'implements',
+            docs: 'Nominal interface conformance on `struct` or `opaque`: `struct Foo implements Interface`. Must be declared on the type definition.',
+          },
+          'editable' => {
+            signature: 'editable',
+            docs: 'Method receiver modifier: `editable function`. Grants mutable access to `this`. Used in interfaces and extending blocks.',
+          },
+          'static' => {
+            signature: 'static',
+            docs: 'Static method modifier: `static function`. No `this` receiver. Used in interfaces and extending blocks for constructors and utilities.',
+          },
+          'import' => {
+            signature: 'import',
+            docs: 'Module import: `import module.path` or `import module.path as alias`. Module lookup resolves `a.b.c` to `a/b/c.mt`.',
+          },
+          'public' => {
+            signature: 'public',
+            docs: 'Export visibility modifier: `public function`, `public type`, etc. Rejected on `extending`, `external`, and `static_assert` declarations.',
+          },
+          'if' => {
+            signature: 'if',
+            docs: 'Conditional branch: `if condition:`. Condition must be `bool`. Supports `else if` and `else`. Inline form: `if cond: stmt else: stmt`.',
+          },
+          'else' => {
+            signature: 'else',
+            docs: 'Else branch for `if`. Chains as `else if condition:` for additional branches. Supports inline single-statement form `else: stmt`.',
+          },
+          'match' => {
+            signature: 'match',
+            docs: 'Pattern match on enum, variant, integer, `str`, or tuple. Expression form produces a value. Must be exhaustive without `_` wildcard.',
+          },
+          'for' => {
+            signature: 'for',
+            docs: 'Loop: `for i in 0..count:` (exclusive range) or `for item in iterable:`. Multi-iteration `for left, right in xs, ys:` iterates arrays/spans in lockstep.',
+          },
+          'while' => {
+            signature: 'while',
+            docs: 'Conditional loop: `while condition:`. Condition must be `bool`. Supports `break`, `continue`, and `defer` inside the body.',
+          },
+          'return' => {
+            signature: 'return',
+            docs: 'Returns a value from a function. Not allowed inside `defer` blocks.',
+          },
+          'break' => {
+            signature: 'break',
+            docs: 'Exits the nearest enclosing `for`, `while`, or `parallel for` loop.',
+          },
+          'continue' => {
+            signature: 'continue',
+            docs: 'Skips to the next iteration of the nearest enclosing `for` or `while` loop.',
+          },
+          'defer' => {
+            signature: 'defer',
+            docs: 'Defers an expression or block to function exit: `defer expr` or `defer:`. Multiple defers execute in LIFO order. `return` is not allowed inside.',
+          },
+          'unsafe' => {
+            signature: 'unsafe',
+            docs: 'Required for pointer indexing, raw pointer dereference, pointer arithmetic, pointer casts, and `reinterpret[...]`. Single-expr or block form.',
+          },
+          'external' => {
+            signature: 'external',
+            docs: 'Raw C ABI surface: `external function name(params) -> T`. No body, supports variadic `...`. Also marks external files with `external` header.',
+          },
+          'foreign' => {
+            signature: 'foreign',
+            docs: 'Foreign function bridging: `foreign function name(params) -> T = c.FuncName`. Supports `in`, `out`, `inout`, and `consuming` parameter modes.',
+          },
+          'consuming' => {
+            signature: 'consuming',
+            docs: 'Foreign function parameter mode: takes ownership of the argument. The caller\'s binding is consumed. Only on `foreign function` params.',
+          },
+          'when' => {
+            signature: 'when',
+            docs: 'Compile-time conditional: `when CONSTANT:`. Only the chosen branch is type-checked and emitted. Requires `else` unless exhaustive.',
+          },
+          'inline' => {
+            signature: 'inline',
+            docs: 'Compile-time unrolling modifier: `inline for` (loop unrolling), `inline while`, `inline match`, `inline if`. Only the active branch emits code.',
+          },
+          'emit' => {
+            signature: 'emit',
+            docs: 'Emits a declaration at compile time: `emit function ...`. Only allowed inside `const function` or `inline` bodies.',
+          },
+          'parallel' => {
+            signature: 'parallel',
+            docs: 'Concurrency construct: `parallel for i in 0..N:` (data-parallel loop) or `parallel:` block (concurrent statement dispatch). Uses OS threads via libuv.',
+          },
+          'detach' => {
+            signature: 'detach',
+            docs: 'Spawns work on a separate thread, returning a `Handle`: `let h = detach func()`. Use `gather` to wait. Supports global function calls only.',
+          },
+          'gather' => {
+            signature: 'gather',
+            docs: 'Blocks until one or more `detach` handles complete: `gather h1, h2`. Takes one or more `Handle` values.',
+          },
+          'event' => {
+            signature: 'event',
+            docs: 'Typed publisher/subscriber: `event name[capacity]` or `event name[capacity](PayloadType)`. Supports `subscribe`, `emit`, `unsubscribe`, `wait`.',
+          },
+          'attribute' => {
+            signature: 'attribute',
+            docs: 'Declares a reusable declaration attribute: `attribute[target, ...] name(params)`. Targets: struct, field, callable, const, event, enum, flags, union, variant.',
+          },
+          'proc' => {
+            signature: 'proc',
+            docs: 'Ref-counted closure: `proc(params...) -> T: body`. Captures values by value. Storable in structs, arrays, and tuples.',
+          },
+          'fn' => {
+            signature: 'fn',
+            docs: 'Function pointer type: `fn(params...) -> T`. Points to module-level functions. No captured state; capture-free.',
+          },
+          'dyn' => {
+            signature: 'dyn',
+            docs: 'Runtime interface value: `dyn[Interface]`. A fat pointer carrying a data pointer and vtable. Constructed via `adapt[Interface](value)`.',
+          },
+          'is' => {
+            signature: 'is',
+            docs: 'Variant arm membership test: `expr is Variant.arm`. Desugars to a `match` expression evaluating to `bool`. Supports `not` negation.',
+          },
+          'pass' => {
+            signature: 'pass',
+            docs: 'Explicit no-op statement for intentionally empty block bodies.',
+          },
+          'null' => {
+            signature: 'null',
+            docs: 'Null value for nullable types (`T?`). Use typed `null[T]` when context cannot determine the target type.',
+          },
+          'true' => {
+            signature: 'true',
+            docs: 'Boolean literal `true`. Type is `bool`.',
+          },
+          'false' => {
+            signature: 'false',
+            docs: 'Boolean literal `false`. Type is `bool`.',
+          },
+          'static_assert' => {
+            signature: 'static_assert',
+            docs: 'Compile-time assertion: `static_assert(condition, message)`. Fails compilation if the compile-time condition is false.',
+          },
+        }.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
@@ -35,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
@@ -166,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])
@@ -183,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)
@@ -1132,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
@@ -1184,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}",
@@ -1260,10 +1524,9 @@ module MilkTea
         return nil unless token
 
         info = KEYWORD_HOVER_INFO[token.lexeme]
-        return nil unless info
-        return nil unless [:size_of, :align_of, :offset_of].include?(token.type)
+        return info if info && [:size_of, :align_of, :offset_of].include?(token.type)
 
-        info
+        LANGUAGE_KEYWORD_HOVER_INFO[token.lexeme]
       end
 
       def render_builtin_specialization(tokens)

data/lib/milk_tea/lsp/server.rb

@@ -58,7 +58,7 @@ module MilkTea
       KEYWORD_TOKEN_TYPES = Token::KEYWORDS.values.to_set.freeze
       DEFAULT_LIBRARY_TYPE_NAMES = Types::BUILTIN_TYPE_NAMES.to_set.freeze
       BUILTIN_FUNCTION_NAMES = %w[
-        ref_of const_ptr_of ptr_of read fatal reinterpret array span zero default adapt get
+        ref_of const_ptr_of ptr_of read fatal reinterpret array span zero default adapt get field_of callable_of has_attribute attribute_of attribute_arg fields_of members_of attributes_of
       ].to_set.freeze
       BUILTIN_ASSOCIATED_HOOK_NAMES = %w[hash equal order].to_set.freeze
       BUILTIN_CALL_HOVER_INFO = {
@@ -68,7 +68,7 @@ module MilkTea
         },
         'ref_of' => {
           signature: 'builtin ref_of(value) -> ref[T]',
-          docs: '`ref_of(x)` borrows a mutable safe lvalue as `ref[T]`.'
+          docs: '`ref_of(x)` borrows a safe lvalue as `ref[T]`.'
         },
         'const_ptr_of' => {
           signature: 'builtin const_ptr_of(value) -> const_ptr[T]',
@@ -76,7 +76,7 @@ module MilkTea
         },
         'ptr_of' => {
           signature: 'builtin ptr_of(value) -> ptr[T]',
-          docs: '`ptr_of(x)` takes the address of a mutable safe lvalue as `ptr[T]`.'
+          docs: '`ptr_of(x)` takes the address of a safe lvalue as `ptr[T]`.'
         },
         'read' => {
           signature: 'builtin read(value) -> T',
@@ -130,6 +130,18 @@ module MilkTea
           signature: 'builtin attribute_of(target, attribute_name) -> attribute_handle',
           docs: '`attribute_of(target, attribute_name)` returns the applied attribute handle for the resolved target-and-attribute pair; use `has_attribute(...)` when absence is expected.'
         },
+        'fields_of' => {
+          signature: 'builtin fields_of(Type) -> array[field_handle, N]',
+          docs: '`fields_of(Type)` returns all struct fields as a compile-time `array[field_handle, N]`, in declaration order. Use with `inline for` for reflective field iteration.'
+        },
+        'members_of' => {
+          signature: 'builtin members_of(Type) -> array[member_handle, N]',
+          docs: '`members_of(Type)` returns all members of an enum or flags type as a compile-time `array[member_handle, N]`. Each handle exposes `.name` and `.value`.'
+        },
+        'attributes_of' => {
+          signature: 'builtin attributes_of(target [, name]) -> array[attribute_handle, N]',
+          docs: '`attributes_of(target)` returns all attributes applied to a type, field, or callable as a compile-time array. `attributes_of(target, name)` filters by attribute kind.'
+        },
       }.freeze
       OPERATOR_TOKEN_TYPES = %i[
         amp colon comma caret dot lparen rparen pipe lbracket rbracket question

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -586,6 +586,8 @@ module MilkTea
         return unless statement.type
         return unless statement.value
 
+        return if statement.type.nullable
+
         declared_name = type_ref_name(statement.type)
         return unless declared_name
 
@@ -666,6 +668,7 @@ module MilkTea
       # enum/int/str bool-matches are never misreported.
       def check_prefer_is_variant(match_expr)
         return unless @sema_facts
+        return if match_expr.desugared_from_is
 
         arms = match_expr.arms
         return unless arms.size == 2
@@ -771,6 +774,8 @@ module MilkTea
         return if stmts.any?(&:nil?)
         return unless stmts.all? { |s| inline_simple_statement?(s) }
 
+        return if visually_inline_if?(statement, stmts)
+
         emit_conciseness_hint(
           "prefer-inline-if",
           line: statement.line,
@@ -779,6 +784,15 @@ module MilkTea
         )
       end
 
+      def visually_inline_if?(statement, stmts)
+        n = statement.branches.length
+        statement.branches.each_with_index.all? { |b, i|
+          stmts[i].respond_to?(:line) && stmts[i].line == b.line
+        } && (
+          stmts[n].respond_to?(:line) && statement.else_line && stmts[n].line == statement.else_line
+        )
+      end
+
       # prefer-conditional-expression: if/match whose every branch either
       # returns a value or assigns the same lvalue can become an expression form
       # (`return if …: … else: …` or `x = match …`).

metadata

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