mt-lang 0.2.7 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b02adcca2cd2665b97f3a32f18130ed355dad80950220475ff623ccc6254250b
-  data.tar.gz: f23de0c1d00fc7f9bd8f6275a921c2b92824b3920425b3fc9f0e1734ecfe2a1a
+  metadata.gz: 9047d861f94f1e5b66f531712466e32779a0a86bd02db452e36cd8990980ee5c
+  data.tar.gz: 3e9d1c7f06e70e2a9e3b84b8df4e8ee64b92be6e34f6bc970ca0b2ef69683c8e
 SHA512:
-  metadata.gz: f29063940f36a621591a64f017e3357aef18db3b7f576f1a0af056514ffee08b67bf1ffd45dc6c2066fd6f27103b5a8e3bced0139415dd558a3e3a0dad5a7cc9
-  data.tar.gz: 4a07fd8a9469cec594b55a41fd7bb7f6220a5baa8653ec4a297d5e06ac80e79f4e1a3b4b69cde79185acb2863d1fe7372e5c9cd2d439a95d3bbe46423d5e2c9d
+  metadata.gz: 4144e09654664b0dd4eaf7d697fe077381c965902564297d32002807be4b9100861ca8c7c7e065b983e90b91dba4b86f22f52eaa4eae47fa1d68dee1cb1acc36
+  data.tar.gz: a712ee592463d961523bd2c8481be6993843f277c51bd3947f34bd8d3e32ae8d245ead8985f31d2621cefd8cc1ec705eba1749aca99324cdd3061adb5ef13ce2

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.7"
+  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/lowering/functions.rb

@@ -80,7 +80,7 @@ module MilkTea
       def resolve_extending_receiver_type(analysis, type_name)
         if type_name.is_a?(AST::TypeRef)
           generic_type = resolve_named_generic_type_for_analysis(analysis, type_name.name.parts)
-          if generic_type.is_a?(Types::GenericStructDefinition)
+          if generic_type.is_a?(Types::GenericStructDefinition) || generic_type.is_a?(Types::GenericVariantDefinition)
             validate_methods_receiver_type_arguments!(type_name, generic_type)
             return generic_type
           end

data/lib/milk_tea/core/lowering/resolve.rb

@@ -430,6 +430,8 @@ module MilkTea
             [:get, nil, nil, nil]
           elsif (type = @ctx.types[callee.name]).is_a?(Types::Struct) || type.is_a?(Types::StringView) || task_type?(type) || type.is_a?(Types::Vector) || type.is_a?(Types::Matrix) || type.is_a?(Types::Quaternion)
             [ :struct_literal, nil, nil, type ]
+          elsif (type = @ctx.types[callee.name]).is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
+            raise LoweringError, "generic type #{callee.name} requires type arguments"
           else
             emit_fn = @artifacts.emitted_declarations.find { |d| d.is_a?(IR::Function) && d.name == callee.name }
             if emit_fn
@@ -452,6 +454,10 @@ module MilkTea
               return [:function, external_function_c_name(binding), nil, binding.type, binding]
             end
             imported_type = imported_module.types[callee.member]
+            if imported_type.is_a?(Types::GenericStructDefinition) || imported_type.is_a?(Types::GenericVariantDefinition)
+              raise LoweringError, "generic type #{callee.receiver.name}.#{callee.member} requires type arguments"
+            end
+
             if imported_type.is_a?(Types::Struct) || imported_type.is_a?(Types::StringView) || task_type?(imported_type) || imported_type.is_a?(Types::Vector) || imported_type.is_a?(Types::Matrix) || imported_type.is_a?(Types::Quaternion)
               return [:struct_literal, nil, nil, imported_module.types.fetch(callee.member)]
             end

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/semantic_analyzer/expressions.rb

@@ -1005,7 +1005,7 @@ module MilkTea
           )
 
           check_function_call(callable, expression.arguments, scopes:)
-          callable.owner.send(:check_function, callable) unless callable.type_arguments.empty?
+          validate_specialized_function_body(callable) unless callable.type_arguments.empty?
           callable.type.return_type
         when :method
           callable = specialize_function_binding(
@@ -1018,7 +1018,7 @@ module MilkTea
           raise_sema_error("cannot call editable method #{callable.name} on an immutable receiver") if callable.type.receiver_editable && !assignable_receiver?(receiver, scopes)
 
           check_function_call(callable, expression.arguments, scopes:)
-          callable.owner.send(:check_function, callable) unless callable.type_arguments.empty?
+          validate_specialized_function_body(callable) unless callable.type_arguments.empty?
           callable.type.return_type
         when :callable_value
           check_callable_value_call(callable, expression.arguments, scopes:, callee_expression: expression.callee)

data/lib/milk_tea/core/semantic_analyzer/function_binding.rb

@@ -256,6 +256,22 @@ module MilkTea
         end
       end
 
+      # Validates the body of a specialized (instantiated) function or method
+      # binding.  The owner checker may be in collecting-errors mode, which
+      # would silently swallow body errors into @structural_errors.  We
+      # temporarily disable collect mode on the owner so the caller receives
+      # the SemanticError directly.
+      def validate_specialized_function_body(binding)
+        owner = binding.owner
+        prev_collecting = owner.instance_variable_get(:@collecting_errors)
+        owner.instance_variable_set(:@collecting_errors, false)
+        owner.send(:check_function, binding)
+      rescue SemanticError => e
+        raise unless e.message.include?("cannot assign through immutable")
+      ensure
+        owner.instance_variable_set(:@collecting_errors, prev_collecting) if owner
+      end
+
       # Per-function error collection used by check_collecting_errors.
       # Continues past individual function failures, accumulating SemanticErrors.
       def check_functions_collecting(errors)
@@ -286,13 +302,29 @@ module MilkTea
         end
       end
 
+      # Scans generic method bodies for assignments to this through a
+      # non-editable receiver.  Full body checking is deferred to call-site
+      # specialization, but immutable-this violations are type-independent.
+      def check_generic_method_immutable_this(binding, scopes)
+        this_binding = scopes.first&.values&.find { |v| v.name == "this" }
+        return unless this_binding
+        return if this_binding.mutable
+
+        binding.ast.body&.each do |statement|
+          next unless statement.is_a?(AST::Assignment) && statement.operator == "="
+          next unless statement.target.is_a?(AST::MemberAccess) && statement.target.receiver.is_a?(AST::Identifier) && statement.target.receiver.name == "this"
+
+          raise_sema_error("cannot assign through immutable this", statement.target)
+        end
+      end
+
       def check_function(binding)
         @local_completion_frames = @local_completion_frames.dup if @local_completion_frames.frozen?
 
         previous_type_substitutions = @current_type_substitutions
         previous_specialization_owner = @current_specialization_owner
         started_check = false
-        return if binding.external || binding.type_params.any?
+        return if binding.external
         return if @checked_function_bindings[binding.object_id]
         return if @checking_function_bindings[binding.object_id]
 
@@ -303,6 +335,11 @@ module MilkTea
         with_error_node(binding.ast) do
           with_scope(binding.body_params) do |scopes|
             start_local_completion_frame(binding, scopes)
+            if binding.type_params.any?
+              check_generic_method_immutable_this(binding, scopes)
+              return
+            end
+
             if binding.ast.is_a?(AST::ForeignFunctionDecl)
               record_callable_value_expression_site(binding.ast.mapping) unless binding.ast.mapping.is_a?(AST::Call)
               expression = foreign_mapping_expression(binding.ast)
@@ -337,10 +374,10 @@ module MilkTea
             end
           end
         end
-        @checked_function_bindings[binding.object_id] = true
       ensure
         return unless started_check
 
+        @checked_function_bindings[binding.object_id] = true
         finish_local_completion_frame(binding)
         @preassigned_local_binding_ids = {}
         @nullability_flow_result = nil

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

@@ -304,10 +304,17 @@ module MilkTea
                       end
         display_name = type_name.is_a?(Array) ? type_name.join(".") : type_name
         raise_sema_error("unknown type #{display_name} for struct destructure") unless struct_type
-        raise_sema_error("#{display_name} is not a struct") unless struct_type.is_a?(Types::Struct) || struct_type.is_a?(Types::Tuple)
-        ensure_assignable!(value_type, struct_type, "cannot destructure #{value_type} as #{display_name}")
-
-        fields = struct_type.fields
+        if struct_type.is_a?(Types::GenericStructDefinition)
+          if value_type.is_a?(Types::StructInstance) && value_type.definition == struct_type
+            fields = value_type.fields
+          else
+            raise_sema_error("generic type #{display_name} requires type arguments")
+          end
+        else
+          raise_sema_error("#{display_name} is not a struct") unless struct_type.is_a?(Types::Struct) || struct_type.is_a?(Types::Tuple)
+          ensure_assignable!(value_type, struct_type, "cannot destructure #{value_type} as #{display_name}")
+          fields = struct_type.fields
+        end
         raise_sema_error("destructure pattern has #{statement.destructure_bindings.length} bindings but #{display_name} has #{fields.length} fields") unless statement.destructure_bindings.length == fields.length
 
         current_scope = current_actual_scope(scopes)

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -36,7 +36,7 @@ module MilkTea
 
     def to_diagnostic(path: nil)
       Diagnostic.new(
-        path:,
+        path: @path || path,
         line: @line,
         column: @column,
         length: @length,

data/lib/milk_tea/lsp/diagnostics.rb

@@ -87,8 +87,17 @@ module MilkTea
             sema_start = total_start ? monotonic_time : nil
             sema_snapshot ||= SemanticAnalyzer.tooling_snapshot(ast, imported_modules: imported_modules.fetch(:modules), path: path, allow_missing_imports: true)
             sema_facts = sema_snapshot.facts
+            cross_by_uri = {}
+            target_path = path.is_a?(String) ? File.expand_path(path) : nil
             sema_snapshot.diagnostics.reject { |diagnostic| redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths) }
-                           .each { |diagnostic| diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema') }
+                           .each do |diagnostic|
+                             if target_path && diagnostic.path && File.expand_path(diagnostic.path) != target_path
+                               target_uri = path_to_uri(diagnostic.path)
+                               (cross_by_uri[target_uri] ||= []) << format_tooling_diagnostic(diagnostic, stage: 'sema')
+                             else
+                               diagnostics << format_tooling_diagnostic(diagnostic, stage: 'sema')
+                             end
+                           end
             sema_ms = elapsed_ms(sema_start) if sema_start
           rescue StandardError => e
             log_diagnostics_warning("Error collecting diagnostics: #{e.message}")
@@ -142,7 +151,7 @@ module MilkTea
           log_diagnostics_warning("Error collecting lint diagnostics: #{e.message}")
         end
 
-        { diagnostics: diagnostics, facts: sema_facts, sema_snapshot: sema_snapshot }
+        { diagnostics: diagnostics, cross_file_diagnostics: cross_by_uri, facts: sema_facts, sema_snapshot: sema_snapshot }
       ensure
         if total_start
           lint_breakdown = lint_profile&.summary(limit: 12)
@@ -196,7 +205,15 @@ module MilkTea
       def self.redundant_unknown_import_diagnostic?(diagnostic, unresolved_import_paths)
         return false unless diagnostic&.message.to_s.start_with?("unknown import ")
 
-        unresolved_import_paths.include?(diagnostic.message.delete_prefix("unknown import "))
+        import_path = diagnostic.message.to_s.match(/unknown import (.+)$/)&.captures&.first
+        return false unless import_path
+
+        unresolved_import_paths.include?(import_path)
+      end
+
+    def self.path_to_uri(path)
+        escaped_path = path.split('/').map { |seg| CGI.escape(seg).gsub('+', '%20') }.join('/')
+        "file://#{escaped_path}"
       end
 
       def self.uri_to_path(uri)

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

@@ -366,7 +366,8 @@ module MilkTea
         return { kind: 'full', items: [] } unless uri
 
         content = @workspace.get_content(uri)
-        diagnostics = @workspace.collect_diagnostics(uri)
+        result = @workspace.collect_diagnostics(uri)
+        diagnostics = result
         fingerprint = diagnostics_fingerprint(content, diagnostics)
         previous_result_id = params['previousResultId']
         cached = @diagnostic_report_cache[uri]
@@ -384,6 +385,16 @@ module MilkTea
           fingerprint: fingerprint
         }
 
+        cross = @workspace.cross_file_diagnostics
+        if cross&.any?
+          cross.each do |target_uri, items|
+            @protocol.write_notification('textDocument/publishDiagnostics', {
+              uri: target_uri,
+              diagnostics: items
+            })
+          end
+        end
+
         {
           kind: 'full',
           resultId: result_id,

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

@@ -473,7 +473,7 @@ module MilkTea
 
         current_type = first_type
         chain_segments[1..].each do |seg|
-          field_owner = project_field_receiver_type_for_completion(current_type)
+          field_owner = project_field_receiver_type_for_completion(current_type, facts)
           if field_owner.respond_to?(:field) && (field_type = field_owner.field(seg))
             current_type = field_type
           else
@@ -674,7 +674,7 @@ module MilkTea
       def completion_items_for_value_receiver(facts, receiver_type, prefix)
         items = []
 
-        field_receiver_type = project_field_receiver_type_for_completion(receiver_type)
+        field_receiver_type = project_field_receiver_type_for_completion(receiver_type, facts)
         if field_receiver_type.respond_to?(:fields)
           field_receiver_type.fields.each do |fname, ftype|
             next unless prefix.empty? || fname.start_with?(prefix)
@@ -763,8 +763,20 @@ module MilkTea
         dispatch_receiver_type == receiver_type ? receiver_type : dispatch_receiver_type
       end
 
-      def project_field_receiver_type_for_completion(type)
-        project_receiver_type_for_completion(type)
+      def project_field_receiver_type_for_completion(type, facts = nil)
+        type = project_receiver_type_for_completion(type)
+        return type.definition if type.is_a?(Types::StructInstance)
+        return field_type_from_struct_definition(type, facts) if facts
+
+        type
+      end
+
+      def field_type_from_struct_definition(type, facts)
+        return type unless type.is_a?(Types::GenericInstance)
+        return type if ref_type_name?(type) || pointer_type_name?(type)
+
+        struct_def = facts.types[type.name]
+        struct_def if struct_def&.respond_to?(:fields)
       end
 
       def project_method_receiver_type_for_completion(type)
@@ -778,8 +790,8 @@ module MilkTea
         type
       end
 
-      def field_owner_type(receiver_type)
-        aggregate_type = project_field_receiver_type_for_completion(receiver_type)
+      def field_owner_type(receiver_type, facts = nil)
+        aggregate_type = project_field_receiver_type_for_completion(receiver_type, facts)
         return aggregate_type.definition if aggregate_type.is_a?(Types::StructInstance)
 
         aggregate_type

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

@@ -247,7 +247,7 @@ module MilkTea
         return nil unless current_type
 
           chain[:segments][1..hovered_segment[:position]].each do |segment|
-            field_receiver_type = project_field_receiver_type_for_completion(current_type)
+            field_receiver_type = project_field_receiver_type_for_completion(current_type, facts)
             if field_receiver_type.respond_to?(:field) && (field_type = field_receiver_type.field(segment[:name]))
               return field_definition_location(current_uri, field_receiver_type, segment[:name]) if segment[:token_index] == token_index
 

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

@@ -133,6 +133,16 @@ module MilkTea
                 diagnostics: diagnostics
               })
               notify_diagnostic_errors(uri, diagnostics)
+
+              cross = @workspace.cross_file_diagnostics
+              if cross&.any?
+                cross.each do |target_uri, items|
+                  @protocol.write_notification('textDocument/publishDiagnostics', {
+                    uri: target_uri,
+                    diagnostics: items
+                  })
+                end
+              end
             end
           elsif perf_logging?
             @diagnostics_perf[:dropped_stale] += 1

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
@@ -649,7 +852,7 @@ module MilkTea
         return nil unless current_type
 
           chain[:segments][1..hovered_segment[:position]].each do |segment|
-            field_receiver_type = project_field_receiver_type_for_completion(current_type)
+            field_receiver_type = project_field_receiver_type_for_completion(current_type, facts)
             if field_receiver_type.respond_to?(:field) && (field_type = field_receiver_type.field(segment[:name]))
               source_location = field_definition_location(current_uri, field_receiver_type, segment[:name])
 
@@ -787,7 +990,7 @@ module MilkTea
         return nil unless receiver_info
 
         field_name = tokens[token_index].lexeme
-        receiver_type = project_field_receiver_type_for_completion(receiver_info[:type])
+        receiver_type = project_field_receiver_type_for_completion(receiver_info[:type], facts)
         return nil unless receiver_type.respond_to?(:field)
 
         field_type = receiver_type.field(field_name)
@@ -809,7 +1012,7 @@ module MilkTea
 
         field_name = tokens[token_index].lexeme
         if receiver_info
-          receiver_type = project_field_receiver_type_for_completion(receiver_info[:type])
+          receiver_type = project_field_receiver_type_for_completion(receiver_info[:type], facts)
           if receiver_type.respond_to?(:field)
             field_type = receiver_type.field(field_name)
             if field_type
@@ -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)
@@ -1421,7 +1623,7 @@ module MilkTea
           def_index = tokens.index(definition_token)
           if def_index
             prev = previous_non_trivia_token_index(tokens, def_index)
-            if prev && tokens[prev].type == :identifier
+            if prev
               case tokens[prev].lexeme
               when "let" then kind = :let
               when "var" then kind = :var

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

@@ -961,7 +961,7 @@ module MilkTea
         resolve_receiver_value_type(facts, receiver_tok).then do |receiver_type|
           next false unless receiver_type
 
-          field_receiver_type = project_field_receiver_type_for_completion(receiver_type)
+          field_receiver_type = project_field_receiver_type_for_completion(receiver_type, facts)
           next false unless field_receiver_type.respond_to?(:field)
 
           callable_semantic_type?(field_receiver_type.field(name))

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/lsp/workspace/analysis.rb

@@ -158,9 +158,9 @@ module MilkTea
                           ast = get_ast(uri)
                           return @last_good_tooling_snapshot_cache[uri] if ast.nil?
 
-                          result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast)
-                          facts = result[:analysis]
-                          MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path: uri) } || []).freeze)
+                           result = MilkTea::SemanticAnalyzer.check_collecting_errors(ast, path:)
+                           facts = result[:analysis]
+                           MilkTea::SemanticAnalyzer::ToolingSnapshot.new(facts:, diagnostics: (Array(result[:errors]).map { |e| e.to_diagnostic(path:) } || []).freeze)
                         end
               if snapshot&.facts
                 @last_good_tooling_snapshot_cache[uri] = snapshot

data/lib/milk_tea/lsp/workspace/collection.rb

@@ -56,10 +56,12 @@ module MilkTea
               )
               collect_ms = elapsed_ms(collect_start) if collect_start
               diagnostics = result[:diagnostics]
+              cross_by_uri = result[:cross_file_diagnostics] || {}
               facts = result[:facts]
               snapshot = result[:sema_snapshot]
               @facts_cache_mutex.synchronize do
                 if @facts_generation[uri] == generation
+                  @cross_file_diagnostics = cross_by_uri
                   @tooling_snapshot_cache[uri] = snapshot if snapshot
                   @last_good_tooling_snapshot_cache[uri] = snapshot if snapshot&.facts
                   @facts_cache[uri] = facts if facts
@@ -93,6 +95,10 @@ module MilkTea
           end
         end
       end
+
+      def cross_file_diagnostics
+        @facts_cache_mutex.synchronize { @cross_file_diagnostics }
+      end
     end
   end
 end

data/lib/milk_tea/tooling/cli.rb

@@ -684,12 +684,17 @@ module MilkTea
         diagnostics = sort_by_location(diagnostics)
 
         if diagnostics.any? || closure_errors.any?
-          source = read_source_file(path)
+          main_source = read_source_file(path)
+          main_abs = File.expand_path(path)
           diagnostics.each do |d|
+            same_file = !d.respond_to?(:path) || d.path.nil? || File.expand_path(d.path) == main_abs
+            source = same_file ? main_source : nil
             @err.puts(ErrorFormatter.format(d, source:, color: error_color?(@err)))
           end
           closure_errors.each do |d|
-            @err.puts(ErrorFormatter.format(d, color: error_color?(@err)))
+            same_file = !d.respond_to?(:path) || d.path.nil? || File.expand_path(d.path) == main_abs
+            source = same_file ? main_source : nil
+            @err.puts(ErrorFormatter.format(d, source:, color: error_color?(@err)))
           end
           all_diagnostics.concat(diagnostics)
           all_diagnostics.concat(closure_errors)
@@ -711,9 +716,9 @@ module MilkTea
       parts << "#{info_count} #{info_count == 1 ? 'note' : 'notes'}" if info_count > 0
       body = parts.join("; ")
       if error_count > 0
-        @err.puts("error: could not check due to #{body}")
+        @err.puts("#{body} found")
       elsif warning_count > 0
-        @err.puts("warning: #{body}")
+        @err.puts("#{body}")
       end
       final_error_count = error_count + (resolution[:warnings_as_errors] ? warning_count : 0)
       final_error_count > 0 ? 1 : 0

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.7
+  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.7 installed!
+  Milk Tea 0.2.10 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH