mt-lang 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcc2383591d95c6043caebcb271aba6b70650528dafbb1a3cd8b906e74a5a6b6
-  data.tar.gz: 2e264acc4e563b29caf921062ca9156f92869d101b1f16f6516f9b412061a1c9
+  metadata.gz: 9047d861f94f1e5b66f531712466e32779a0a86bd02db452e36cd8990980ee5c
+  data.tar.gz: 3e9d1c7f06e70e2a9e3b84b8df4e8ee64b92be6e34f6bc970ca0b2ef69683c8e
 SHA512:
-  metadata.gz: 17ef473e87741d685323aa279e434ce56a24b7c30cc4b48f61cbb7d4b7c49d47300c7cbad1e4211740fc35ecc29bf36ee941fa0b4bb18ac0fc19d04aee69d7ab
-  data.tar.gz: 9952dc4f2a306b443cbd57c4840965c8c7e870f8f9f976643b063635c64e371c0f8e903ea3446b124cd0b7e9ddf6754807c924e90426c1bfe789124bc08d6d44
+  metadata.gz: 4144e09654664b0dd4eaf7d697fe077381c965902564297d32002807be4b9100861ca8c7c7e065b983e90b91dba4b86f22f52eaa4eae47fa1d68dee1cb1acc36
+  data.tar.gz: a712ee592463d961523bd2c8481be6993843f277c51bd3947f34bd8d3e32ae8d245ead8985f31d2621cefd8cc1ec705eba1749aca99324cdd3061adb5ef13ce2

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.8"
+  VERSION = "0.2.10"
 
   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/lsp/server/hover.rb

@@ -8,19 +8,222 @@ 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
+
       def handle_hover(params)
         stages = new_perf_stages
         total_start = stages ? monotonic_time : nil
@@ -1260,10 +1463,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.10
 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.10 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH