mt-lang 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 990a1e0ede945713a31152caccc4a7de798dc6ead6078d46d5a376f19054a52a
-  data.tar.gz: 97d7877587ca50ab673212d1d0d80d6d60ad8f97a74c439965feb32c2f5a4e37
+  metadata.gz: 726a973cae08da6d7927931a6fa51adc8106fd483709dede501b7e551e1d9103
+  data.tar.gz: 666501d1a75719851869d1467d7498e84c2b4fd18da6d52a41912343d2f52f43
 SHA512:
-  metadata.gz: c04b4d611724c8b4f42ae14929b3d8d98b4aa4da5157f7c3ee765afb6356be643b6ada8c96ed45a8e61103e71792c7855c25d87f65865b9609cdb0cc85544507
-  data.tar.gz: 82416c2665d49928f0d6dd5e9b8f225177f9df0f782e973339545a6375cc673e082bccc3bbb6126cbdc50875dc6fa29880b5e23b8e3ccd458934b32f5d2f6718
+  metadata.gz: 618b5705f9b727ce7d07b6ccf6576aa92d0380d7f4609393790fb8c64df1a3c7bd409151eabc800d95ca01d6636c8e26d43840758db90502ccf2757ad6800190
+  data.tar.gz: e9a6840730d61fee0b57c3339779169a31e91d84626230cc353c1e9b31a1e748b58a0b5c205d904bbb32ba0951bfd4874df3374c378a62c8a6e8277bc1fccffe

data/README.md

@@ -364,6 +364,8 @@ Method kinds:
 - `function` -> value receiver
 - `editable function` -> editable receiver
 - `static function` -> no receiver
+- `const function` -> value receiver, compile-time-evaluable
+- `static const function` -> no receiver, compile-time-evaluable
 
 Methods may appear inside a struct body (desugared to an `extending` block) or in a separate
 `extending` declaration:
@@ -424,6 +426,8 @@ const RESULT: int = square(5)   # folded to 25 at compile time
 
 `const function` also generates a normal runtime function, callable from ordinary runtime code.
 
+`const` applies to methods as well: `const function` (value receiver) and `static const function` (no receiver) methods fold when called from a compile-time context and also generate normal runtime functions. `editable const function`, `async const function`, and `const` on interface methods are rejected.
+
 External functions:
 
 ```mt

data/docs/index.html

@@ -556,6 +556,14 @@ function make_buffer[N: int]() -> str_buffer[N]:
     var buf: str_buffer[N]
     return buf
 
+## ── inline if with a compile-time type comparison ───────────────────
+function size_label[T]() -> str:
+    inline if T == int:
+        return "32-bit"
+    inline if T == float:
+        return "float"
+    return "other"
+
 ## ── Error handling with Result[T, E] ────────────────────────────────
 enum LoadError: ubyte
     not_found = 1
@@ -575,6 +583,12 @@ function load_pair() -> Result[bool, LoadError]:
     io.print_line(f"Loaded #{first.name} and #{second.name}")
     return Result[bool, LoadError].success(value = true)
 
+## ── Foreign FFI: raw external + foreign projection ──────────────────
+external function atoi(input: cstr) -> int
+
+## foreign function projects a raw ABI call into ordinary Milk Tea types
+foreign function parse_int_foreign(input: str as cstr) -> int = atoi
+
 ## ── Events (fixed-capacity pub/sub, zero heap during dispatch) ──────
 struct DamageEvent:
     target_id: EntityId
@@ -601,6 +615,19 @@ async function load_scores() -> int:
 ## ── Compile-time constants for inline if ─────────────────────────────
 const DEBUG: bool = false
 
+## ── when: compile-time conditional (only the chosen branch is emitted) ──
+enum Backend: ubyte
+    gl     = 1
+    vulkan = 2
+const TARGET_BACKEND: Backend = Backend.gl
+
+function backend_label() -> str:
+    when TARGET_BACKEND:
+        Backend.gl:
+            return "OpenGL"
+        Backend.vulkan:
+            return "Vulkan"
+
 ## ── Main entry point ────────────────────────────────────────────────
 function main() -> int:
     ## Local declarations: let (immutable), var (mutable)
@@ -727,12 +754,22 @@ function main() -> int:
         Action.idle:
             pass
 
+    ## is: variant arm membership test
+    if action is Action.attack:
+        io.print_line("action is an attack")
+
     ## match expression
     let label = match player.level:
         1: "beginner"
         2: "novice"
         _: "advanced"
 
+    ## Struct equality: field-wise ==/!=
+    let stats_a = Entity.Stats(attack = 10, defense = 5, speed = 1.0)
+    let stats_b = Entity.Stats(attack = 10, defense = 5, speed = 1.0)
+    if stats_a == stats_b:
+        io.print_line("stats equal")
+
     ## Explicit cast: T<-value
     let raw_kind = ubyte<-player.entity.kind
     let ratio = float<-score
@@ -795,6 +832,12 @@ function main() -> int:
     inline if DEBUG:
         io.print_line("debug mode")
 
+    ## Foreign FFI, when, and inline-if type dispatch
+    let parsed_int = parse_int_foreign("42")
+    io.print_line(f"FFI parsed: #{parsed_int}")
+    io.print_line(f"Backend: #{backend_label()}")
+    io.print_line(f"int label: #{size_label[int]()}")
+
     ## ── Concurrency ─────────────────────────────────────────────────────
     ## parallel for: data-parallel loop dispatched across CPU cores
     var positions = array[float, 4](0.0, 1.0, 2.0, 3.0)
@@ -829,7 +872,7 @@ function main() -> int:
 </div>
 
   <div class="callout tip">
-    <strong>Tip:</strong> This example covers imports, constants, <code>const function</code>, type aliases, enums, flags, structs (nested, attributed), variants, interfaces, <code>extending</code> methods, generics with constraints, value parameter generics, <code>Result</code> error handling with <code>?</code> and guard binding, events, closures (<code>proc</code>), <code>async</code>/<code>await</code>, concurrency (<code>parallel for</code>, <code>parallel:</code>, <code>detach</code> + <code>gather</code>, <code>atomic[T]</code>), native vector types, arrays, spans, collections, <code>for</code>/<code>while</code>/<code>match</code>/<code>if</code>, variant membership test (<code>is</code>), parallel <code>for</code>, <code>defer</code>, <code>unsafe</code>, <code>ref[T]</code>, <code>own[T]</code>, <code>dyn[Interface]</code>, format strings, heredocs, <code>str_buffer</code>, compile-time reflection, <code>inline for</code>/<code>inline if</code>, <code>static_assert</code>, and explicit casts. See the sections below for full details on each feature.
+    <strong>Tip:</strong> This example covers imports, constants, <code>const function</code>, type aliases, enums, flags, structs (nested, attributed), variants, interfaces, foreign functions (<code>external</code> / <code>foreign function</code>), <code>extending</code> methods, generics with constraints, value parameter generics, <code>Result</code> error handling with <code>?</code> and guard binding, events, closures (<code>proc</code>), <code>async</code>/<code>await</code>, concurrency (<code>parallel for</code>, <code>parallel:</code>, <code>detach</code> + <code>gather</code>, <code>atomic[T]</code>), native vector types, arrays, spans, collections, <code>for</code>/<code>while</code>/<code>match</code>/<code>if</code>, variant membership test (<code>is</code>), parallel <code>for</code>, <code>defer</code>, <code>unsafe</code>, <code>ref[T]</code>, <code>own[T]</code>, <code>dyn[Interface]</code>, format strings, heredocs, <code>str_buffer</code>, compile-time reflection, <code>when</code>, <code>inline for</code>/<code>inline if</code> (including type comparison), struct <code>==</code>/<code>!=</code>, <code>static_assert</code>, and explicit casts. See the sections below for full details on each feature.
   </div>
 </section>
 
@@ -1221,7 +1264,7 @@ struct NPC implements Damageable:
 </div>
 
   <h3>Methods (extending)</h3>
-  <p>Three kinds: <code>function</code> (value receiver), <code>editable function</code> (editable receiver), <code>static function</code> (no receiver).</p>
+  <p>Method kinds: <code>function</code> (value receiver), <code>editable function</code> (editable receiver), <code>static function</code> (no receiver), plus compile-time-evaluable <code>const function</code> and <code>static const function</code>. <code>editable const function</code>, <code>async const function</code>, and <code>const</code> on interface methods are rejected.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>extending Counter:
@@ -1394,6 +1437,7 @@ function say_hello(name: str):
 
   <h3>const function</h3>
   <p>Evaluable at compile time. Generates both a compile-time constant-folding path and a normal runtime function. Recursive calls between <code>const</code> functions are supported. Use <code>const function</code> for reusable compile-time logic; use a block-bodied <code>const X -&gt; T: ...</code> for one-shot computed constants.</p>
+  <p><code>const</code> also applies to methods: <code>const function</code> (value receiver) and <code>static const function</code> (no receiver) fold when called from a compile-time context. <code>editable const function</code>, <code>async const function</code>, and <code>const</code> on interface methods are rejected.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>const function square(x: int) -> int:
@@ -1656,6 +1700,31 @@ unsafe:
 <section id="compile-time">
   <h2>Compile-Time Control Flow</h2>
 
+  <h3>Block-bodied <code>const</code> and <code>const function</code></h3>
+  <p>Block-bodied <code>const</code> initializers and <code>const function</code> bodies are evaluated at compile time, and the result is folded into the emitted C. Supported surface: literals (character literals fold to their byte value), other <code>const</code> values, arithmetic, <code>str</code> concatenation, <code>if</code>/<code>while</code>/<code>for</code> with <code>break</code> and <code>continue</code>, <code>match</code> expressions, index and range access, struct member access, <code>let</code>/<code>var</code> with destructuring and <code>else:</code> / <code>else as error:</code> guards, assignment (including compound), numeric prefix casts, calls to other const functions and const methods, and the reflection builtins.</p>
+<div class="code-wrap">
+<button class="copy-btn" onclick="copyCode(this)">Copy</button>
+<pre><code>## str concatenation folds to a literal
+const GREET: str = "hello" + " " + "world"
+
+## match expressions fold
+const LABEL -&gt; str:
+    return match 2:
+        1: "one"
+        2: "two"
+        _: "other"
+
+## const methods fold too
+struct Rect:
+    w: int
+    h: int
+    const function area() -&gt; int:
+        return this.w * this.h
+
+const R: Rect = Rect(w = 10, h = 20)
+const AREA: int = R.area()   ## folded to 200 at compile time</code></pre>
+</div>
+
   <h3>when</h3>
   <p>Evaluates discriminant at compile time; only the chosen branch is type-checked and emitted. <code>when</code> may also appear at module level to conditionally include declarations, imports, or type definitions.</p>
 <div class="code-wrap">

data/docs/language-design.md

@@ -79,7 +79,7 @@ The intended reductions are deliberate:
 
 If a new feature introduces a second ordinary way to express the same concept, the language should delete one of them instead of documenting both.
 
-The compile-time evaluation surface is described in [Compile-Time Evaluation](compile-time.md).
+The compile-time evaluation surface is described in the [language manual](language-manual.md): block-bodied `const` and `const function` limits in §3.2 and §3.7a, and `when` plus the `inline` statements in §4.7–§4.11.
 
 ## Overall shape
 
@@ -716,7 +716,7 @@ type FileHandle = ptr[libc.FILE]
 
 ### Generics
 
-Generics are useful, but they must stay boring. The compile-time surface is documented in [Compile-Time Evaluation](compile-time.md); generic bodies participate in that surface by using `when`, `inline for`, `inline while`, `inline match`, `inline if`, `type`-returning functions, `const function`, and block-bodied `const` initializers (`const X -> T: ...`) at the lexical positions where the compile-time rules allow them.
+Generics are useful, but they must stay boring. The compile-time surface is documented in the [language manual](language-manual.md); generic bodies participate in that surface by using `when`, `inline for`, `inline while`, `inline match`, `inline if`, `type`-returning functions, `const function`, and block-bodied `const` initializers (`const X -> T: ...`) at the lexical positions where the compile-time rules allow them.
 
 Allowed in v1:
 

data/docs/language-manual.md

@@ -208,7 +208,7 @@ const NEXT_POW2 -> int:
     return n
 ```
 
-The block body is evaluated at compile time. Allowed inside the block: literals, names of other `const` values, arithmetic, control flow (`if`/`else if`/`else`, `while`, `for`), `let` and `var` declarations, calls to other compile-time functions, and calls to whitelisted builtins (`size_of`, `align_of`, `offset_of`, `fields_of`, `members_of`, `attributes_of`).
+The block body is evaluated at compile time. Allowed inside the block: literals (character literals fold to their byte value), names of other `const` values, arithmetic, `str` concatenation (`+`), control flow (`if`/`else if`/`else`, `while`, `for`, with `break` and `continue`), `match` expressions, index and range access (`arr[i]`, `s[i]`, `arr[start..stop]`, `s[start..stop]`), struct member access, `let` and `var` declarations (including tuple/struct destructuring and `else:` / `else as error:` guard forms), assignment (including compound assignment to block-local struct fields and array elements), numeric prefix casts (`T<-value`), calls to other compile-time functions and const methods, and calls to whitelisted builtins (`size_of`, `align_of`, `offset_of`, `fields_of`, `members_of`, `attributes_of`).
 
 Rules:
 
@@ -524,6 +524,8 @@ Kinds:
 - `function` (value receiver)
 - `editable function` (editable receiver)
 - `static function` (no receiver)
+- `const function` (value receiver, compile-time-evaluable)
+- `static const function` (no receiver, compile-time-evaluable)
 
 Names such as `init` and `default` are ordinary static functions. There is no constructor keyword or hidden initializer syntax.
 
@@ -531,6 +533,9 @@ Method capabilities:
 
 - async methods are supported
 - generic methods are supported
+- `const function` and `static const function` methods follow the same compile-time body rules as a block-bodied `const` (§3.2). Called from a compile-time context, the call is constant-folded; they also generate normal runtime functions.
+- `editable const function` and `async const function` are rejected.
+- `const` is not allowed on interface methods.
 
 ### 3.7 Functions
 
@@ -591,10 +596,11 @@ const SQUARE_5: int = square(5)  # folded to 25 at compile time
 
 Rules:
 
-- The body must be evaluable at compile time (literals, `const` values, arithmetic, `if`/`else`, `while`, `for`, `let`/`var`, calls to other `const` functions, and whitelisted builtins).
+- The body follows the same compile-time rules as a block-bodied `const` (§3.2).
 - Generates a normal runtime function as well — callable from ordinary runtime code.
 - Called from `const` initializers, `when` discriminants, `inline for` bodies, and other compile-time contexts.
 - Recursive calls between `const` functions are supported.
+- `const` applies to methods as well: `const function` (value receiver) and `static const function` (no receiver) methods fold when called from compile-time contexts (§3.6).
 
 ### 3.8 External functions
 

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/compile_time/method_folding.rb

@@ -116,7 +116,7 @@ module MilkTea
         func && func.respond_to?(:ast) && func.ast.respond_to?(:const) && func.ast.const
       end
 
-      def comptime_const_method_body(binding, arguments, scopes:, receiver_value:)
+      def comptime_const_method_body(binding, arguments, scopes:, receiver_value:, arg_evaluator: nil)
         method = binding.ast
         return nil unless method.respond_to?(:body) && method.body
         return nil if binding.type_params.any?
@@ -130,7 +130,11 @@ module MilkTea
         end
 
         method.params.each_with_index do |param, idx|
-          arg_value = comptime_eval(arguments[idx].value, scopes)
+          arg_value = if arg_evaluator
+            arg_evaluator.call(arguments[idx].value)
+          else
+            comptime_eval(arguments[idx].value, scopes)
+          end
           return nil unless arg_value
 
           initial_vars[param.name] = arg_value

data/lib/milk_tea/core/compile_time.rb

@@ -713,20 +713,31 @@ module MilkTea
         return unless @checker.respond_to?(:comptime_method_binding_for_receiver)
         return unless @checker.respond_to?(:comptime_const_method_body)
 
+        arg_evaluator = ->(expr) { evaluate_expression(expr, scopes:) }
+
         receiver = call_expr.callee.receiver
-        return unless receiver.is_a?(AST::Identifier)
-        return unless @variables.key?(receiver.name)
+        if receiver.is_a?(AST::Identifier) && @variables.key?(receiver.name)
+          receiver_value = @variables[receiver.name]
+          return nil if receiver_value.nil? || receiver_value.is_a?(Types::Base)
+
+          receiver_type = @variable_types[receiver.name]
+          return nil unless receiver_type
+
+          binding = @checker.comptime_method_binding_for_receiver(receiver_type, call_expr.callee.member)
+          return nil unless binding
 
-        receiver_value = @variables[receiver.name]
-        return nil if receiver_value.nil? || receiver_value.is_a?(Types::Base)
+          return @checker.comptime_const_method_body(binding, call_expr.arguments, scopes:, receiver_value:, arg_evaluator:)
+        end
+
+        return nil unless @checker.respond_to?(:resolve_type_expression)
 
-        receiver_type = @variable_types[receiver.name]
+        receiver_type = @checker.resolve_type_expression(receiver)
         return nil unless receiver_type
 
         binding = @checker.comptime_method_binding_for_receiver(receiver_type, call_expr.callee.member)
         return nil unless binding
 
-        @checker.comptime_const_method_body(binding, call_expr.arguments, scopes:, receiver_value:)
+        @checker.comptime_const_method_body(binding, call_expr.arguments, scopes:, receiver_value: nil, arg_evaluator:)
       end
 
       def try_const_function_call(call_expr, scopes:)
@@ -774,9 +785,12 @@ module MilkTea
         elsif call_expr.callee.respond_to?(:name)
           call_expr.callee.name
         end
-        return unless callee_name
 
-        type = types[callee_name]
+        type = if callee_name
+          types[callee_name]
+        elsif call_expr.callee.is_a?(AST::MemberAccess) && @checker.respond_to?(:resolve_type_expression)
+          @checker.resolve_type_expression(call_expr.callee)
+        end
         return unless type.is_a?(Types::Struct)
 
         fields = {}

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

@@ -1875,6 +1875,10 @@ module MilkTea
           @lowerer.resolve_type_ref(type_ref)
         end
 
+        def resolve_type_expression(expression)
+          @lowerer.resolve_type_expression(expression)
+        end
+
         def comptime_struct_field_names(type_name)
           @lowerer.comptime_struct_field_names(type_name)
         end
@@ -1883,8 +1887,8 @@ module MilkTea
           @lowerer.comptime_method_binding_for_receiver(receiver_type, member)
         end
 
-        def comptime_const_method_body(binding, arguments, scopes: nil, receiver_value: nil)
-          @lowerer.comptime_const_method_body(binding, arguments, scopes:, receiver_value:)
+        def comptime_const_method_body(binding, arguments, scopes: nil, receiver_value: nil, arg_evaluator: nil)
+          @lowerer.comptime_const_method_body(binding, arguments, scopes:, receiver_value:, arg_evaluator:)
         end
 
         def comptime_expression_type(expression, scopes: nil)

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

@@ -190,7 +190,8 @@ module MilkTea
               "return type mismatch: expected #{return_type}, got #{value_type}",
               expression: statement.value,
               contextual_int_to_float: contextual_int_to_float_target?(return_type),
-              line: statement.line,
+              line: (statement.line unless statement.value),
+              column: (statement.column unless statement.value),
             )
           when AST::DeferStmt
             with_loop_barrier do

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

@@ -424,6 +424,17 @@ module MilkTea
             receiver_value = comptime_member_receiver_value(expression.callee.receiver, scopes)
             return comptime_const_method_body(method_binding, expression.arguments, scopes:, receiver_value:)
           end
+
+          if (struct_type = resolve_type_expression(expression.callee)) && struct_type.is_a?(Types::Struct)
+            fields = {}
+            expression.arguments.each do |argument|
+              val = evaluate_compile_time_const_value(argument.value, scopes:)
+              return nil unless val
+
+              fields[argument.name] = val
+            end
+            return fields
+          end
         when AST::Identifier
           if (struct_type = @ctx.types[expression.callee.name]) && struct_type.is_a?(Types::Struct)
             fields = {}

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

@@ -459,8 +459,8 @@ module MilkTea
           return nil if prefix.empty?
           return nil unless @current_completion_trigger_kind == TRIGGER_KIND_INCOMPLETE
 
-          content = @workspace.get_content(uri)
-          line_prefix = (content.split("\n", -1)[lsp_line] || '')[0...lsp_char]
+          lines = @workspace.document_lines(uri)
+          line_prefix = (lines[lsp_line] || '')[0...lsp_char]
           cached = @completion_session_cache[[uri, lsp_line]]
           return nil unless cached
           return nil unless line_prefix.start_with?(cached[:line_prefix])
@@ -473,8 +473,8 @@ module MilkTea
         def store_completion_session(uri, lsp_line, lsp_char, prefix, response)
           return if prefix.empty?
 
-          content = @workspace.get_content(uri)
-          line_prefix = (content.split("\n", -1)[lsp_line] || '')[0...lsp_char]
+          lines = @workspace.document_lines(uri)
+          line_prefix = (lines[lsp_line] || '')[0...lsp_char]
           key = [uri, lsp_line]
           @completion_session_cache[key] = {
             line_prefix: line_prefix,
@@ -875,8 +875,7 @@ module MilkTea
         end
 
         def import_completions(uri, lsp_line, lsp_char)
-          content = @workspace.get_content(uri)
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line = lines[lsp_line] || ''
           stripped = line.lstrip
           return nil unless stripped.start_with?('import ')
@@ -936,9 +935,7 @@ module MilkTea
         end
 
         def attribute_completions(facts, uri, line, char)
-          content = @workspace.get_content(uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 
@@ -980,9 +977,7 @@ module MilkTea
         def format_string_completions(facts, uri, line, char)
           return nil unless facts
 
-          content = @workspace.get_content(uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 
@@ -1045,9 +1040,7 @@ module MilkTea
         def named_argument_completions(facts, uri, line, char)
           return nil unless facts
 
-          content = @workspace.get_content(uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 
@@ -1109,9 +1102,7 @@ module MilkTea
         def specialization_completions(facts, _uri, line, char)
           return nil unless facts
 
-          content = @workspace.get_content(_uri)
-          return nil unless content
-          lines = content.split("\n", -1)
+          lines = @workspace.document_lines(_uri)
           line_text = lines[line] || ''
           return nil if line_text.empty?
 

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

@@ -295,9 +295,8 @@ module MilkTea
         end
 
         def current_word_prefix(uri, lsp_line, lsp_char)
-          content = @workspace.get_content(uri)
-          lines   = content.split("\n", -1)
-          line    = lines[lsp_line] || ''
+          lines = @workspace.document_lines(uri)
+          line  = lines[lsp_line] || ''
           # Walk backwards from cursor to find start of current word
           char_idx = [lsp_char - 1, line.length - 1].min
           return '' if char_idx < 0

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

@@ -284,6 +284,8 @@ module MilkTea
         def invalidate_cache(uri, clear_last_good: false)
           @tokens_cache.delete(uri)
           @ast_cache.delete(uri)
+          @definition_token_index.delete(uri)
+          @line_cache.delete(uri)
           @symbols_cache.delete(uri)
           @doc_comments_cache.delete(uri)
           @facts_cache_mutex.synchronize do

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

@@ -48,7 +48,6 @@ module MilkTea
         private
 
         def candidate_definition_uris(name, exclude_uri: nil)
-          matcher = definition_line_matcher(name)
           open_uris, indexed_uris = @document_state_mutex.synchronize do
             [@open_documents.keys, @indexed_documents.keys]
           end
@@ -57,33 +56,33 @@ module MilkTea
           warmed_candidates = nil
           warmed_uris = nil
           @definition_cache_mutex.synchronize do
-            warmed_candidates = @definition_candidate_uris[name].dup
+            warmed_candidates = @definition_candidate_uris[name].to_a
             warmed_uris = @definition_names_by_uri.keys.to_set
           end
 
-          matches = warmed_candidates.to_a.filter_map do |doc_uri|
-            next if doc_uri == exclude_uri
-
-            doc_uri
-          end
+          matches = warmed_candidates.reject { |doc_uri| doc_uri == exclude_uri }
 
+          # One-time lazy index: extract each document's definition names and
+          # cache them so repeat lookups are Set-membership checks instead of
+          # re-scanning every indexed document's full content with a regex on
+          # each lookup (which scaled with total workspace bytes).
           ordered_uris.each do |doc_uri|
             next if doc_uri == exclude_uri
             next if warmed_uris.include?(doc_uri)
 
             content = get_content(doc_uri)
             next if content.empty?
-            next unless content.match?(matcher)
 
             warm_definition_candidates_for_uri(doc_uri, content)
-            matches << doc_uri
           end
 
-          matches.uniq
-        end
+          @definition_cache_mutex.synchronize do
+            @definition_candidate_uris[name].each do |doc_uri|
+              matches << doc_uri unless doc_uri == exclude_uri
+            end
+          end
 
-        def definition_line_matcher(name)
-          /#{DEFINITION_LINE_PREFIX}#{Regexp.escape(name)}\b/
+          matches.uniq
         end
 
         def cache_definition_entry(name, entry)

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

@@ -126,13 +126,18 @@ module MilkTea
           total = paths.length
           paths.each_with_index do |path, idx|
             file_uri = path_to_uri(path)
+            content = nil
             @document_state_mutex.synchronize do
-              @indexed_documents[file_uri] ||= begin
+              content = @indexed_documents[file_uri] ||= begin
                 File.read(path)
               rescue StandardError
                 nil
               end
             end
+            # Warm the definition-name index for this file so later global
+            # definition lookups hit Set-membership checks instead of scanning
+            # every indexed document's content.
+            warm_definition_candidates_for_uri(file_uri, content) if content
             if progress && total > 0
               pct = ((idx + 1) * 100 / total).clamp(0, 100)
               progress.call(pct, "#{idx + 1}/#{total} files")

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

@@ -79,10 +79,9 @@ module MilkTea
         # Scan text up to the cursor to find the innermost open function call context.
         # Returns { name:, active_parameter: } or nil if not inside a call.
         def find_call_context(uri, lsp_line, lsp_char)
-          content = get_content(uri)
-          return nil if content.empty?
+          lines = document_lines(uri)
+          return nil if lines.empty?
 
-          lines = content.split("\n", -1)
           cursor_line = lines[lsp_line] || ''
           prefix = lsp_line.positive? ? lines[0...lsp_line].join("\n") + "\n" : ''
           text = prefix + cursor_line[0...lsp_char]
@@ -150,14 +149,19 @@ module MilkTea
         end
 
         def token_contains_position?(token, target_line, target_char)
-          segments = token.lexeme.split("\n", -1)
-          end_line = token.line + segments.length - 1
-          return false if target_line < token.line || target_line > end_line
+          return false if target_line < token.line
+
+          lexeme = token.lexeme
+          unless lexeme.include?("\n")
+            return false if target_line > token.line
 
-          if segments.length == 1
-            return token.column <= target_char && target_char < (token.column + segments.first.length)
+            return token.column <= target_char && target_char < (token.column + lexeme.length)
           end
 
+          segments = lexeme.split("\n", -1)
+          end_line = token.line + segments.length - 1
+          return false if target_line > end_line
+
           if target_line == token.line
             return token.column <= target_char && target_char <= (token.column + segments.first.length - 1)
           end
@@ -178,8 +182,7 @@ module MilkTea
         end
 
         def find_dot_receiver_path(uri, lsp_line, lsp_char)
-          content = get_content(uri)
-          lines = content.split("\n", -1)
+          lines = document_lines(uri)
           line_str = lines[lsp_line] || ''
 
           idx = [lsp_char - 1, line_str.length - 1].min
@@ -222,39 +225,56 @@ module MilkTea
         # (def, struct, union, enum, flags, variant, type, const, var) for the given name.
         # Returns the identifier Token, or nil if not found.
         def find_definition_token(uri, name, before_line: nil, before_char: nil)
-          tokens = get_tokens(uri)
-          return nil if tokens.nil?
-
-          nearest = nil
-          tokens.each_cons(2) do |kw_tok, id_tok|
-            next unless DEFINITION_KEYWORDS.include?(kw_tok.type)
-            next unless id_tok.type == :identifier && id_tok.lexeme == name
+          candidates = definition_token_index(uri)[name]
+          return nil if candidates.nil? || candidates.empty?
 
-            if before_line
-              next if id_tok.line > before_line
-              next if id_tok.line == before_line && before_char && id_tok.column >= before_char
-            end
-
-            if nearest.nil? || id_tok.line > nearest.line || (id_tok.line == nearest.line && id_tok.column > nearest.column)
-              nearest = id_tok
+          if before_line
+            matches = candidates.select do |tok|
+              tok.line < before_line || (tok.line == before_line && (!before_char || tok.column < before_char))
             end
+            return matches.max_by { |tok| [tok.line, tok.column] } unless matches.empty?
           end
 
-          return nearest if nearest
+          candidates.first
+        end
 
-          tokens.each_cons(2) do |kw_tok, id_tok|
-            next unless DEFINITION_KEYWORDS.include?(kw_tok.type)
-            next unless id_tok.type == :identifier && id_tok.lexeme == name
+        # Return the cached line array for +uri+, so hot request paths (e.g.
+        # completion) do not re-split the whole document once per helper.
+        def document_lines(uri)
+          @document_state_mutex.synchronize do
+            return @line_cache[uri] if @line_cache.key?(uri)
+          end
 
-            return id_tok
+          lines = get_content(uri).split("\n", -1)
+          @document_state_mutex.synchronize do
+            @line_cache[uri] = lines
           end
-          nil
+          lines
         end
 
         private
 
         # ── Symbol extraction (token-based, no AST position requirement) ────────
 
+        # Lazily build a per-uri map of definition identifier tokens keyed by
+        # name, so repeated definition lookups are O(definitions-with-name)
+        # instead of re-scanning the document's full token stream each time.
+        def definition_token_index(uri)
+          @definition_token_index[uri] ||= begin
+            tokens = get_tokens(uri)
+            index = Hash.new { |hash, key| hash[key] = [] }
+            if tokens
+              tokens.each_cons(2) do |kw_tok, id_tok|
+                next unless DEFINITION_KEYWORDS.include?(kw_tok.type)
+                next unless id_tok.type == :identifier
+
+                index[id_tok.lexeme] << id_tok
+              end
+            end
+            index
+          end
+        end
+
         def extract_symbols_from_tokens(uri)
           tokens = get_tokens(uri)
           return [] if tokens.nil?

data/lib/milk_tea/lsp/workspace.rb

@@ -37,7 +37,7 @@ module MilkTea
       # adjacent tokens, and the inner keyword (e.g. :function) is always followed
       # by the identifier. If the lexer ever merges a compound keyword into a
       # single token type (e.g. :const_function), it must be added here.
-      DEFINITION_KEYWORDS = %i[function struct union enum flags variant type const var let extending opaque interface event].freeze
+      DEFINITION_KEYWORDS = %i[function struct union enum flags variant type const var let extending opaque interface event].to_set.freeze
       DOC_COMMENT_PREFIX = '##'
       DOC_TAG_PATTERN = /\A\s*@([A-Za-z_][A-Za-z0-9_-]*)(?:\s+(.*))?\z/
       DEFINITION_LINE_PREFIX = /^(?:\s)*(?:(?:public|foreign|external)\s+)*(?:function|struct|union|enum|flags|variant|type|const|var|let|extending|opaque|interface|event)\s+/m
@@ -55,6 +55,8 @@ module MilkTea
         @tokens_cache = {}   # uri -> [Token]
         @last_good_tokens_cache = {} # uri -> last known-good [Token]
         @ast_cache = {}      # uri -> AST::SourceFile (nil on parse failure)
+        @definition_token_index = {} # uri -> { name => [Token] } definition tokens by name
+        @line_cache = {} # uri -> [String] split lines, refreshed on invalidation
         @facts_cache = {} # uri -> SemanticAnalyzer::Facts (projection of cached tooling snapshot facts)
         @tooling_snapshot_cache = {} # uri -> SemanticAnalyzer::ToolingSnapshot (facts may be nil on structural failure)
         @symbols_cache = {}  # uri -> [{name, kind, line, column}]
@@ -103,6 +105,8 @@ module MilkTea
         @tokens_cache.clear
         @last_good_tokens_cache.clear
         @ast_cache.clear
+        @definition_token_index.clear
+        @line_cache.clear
         @facts_cache.clear
         @tooling_snapshot_cache.clear
         @symbols_cache.clear

data/lib/milk_tea/tooling/cli/commands/run.rb

@@ -72,11 +72,12 @@ module MilkTea
           argv: @argv.dup,
           **options.except(:timings)
         )
-        unless @out.equal?($stdout) || preview_notice_emitted
+        live = $stdout.tty?
+        unless (@out.equal?($stdout) && live) || preview_notice_emitted
           @out.write(result.stdout)
         end
         @out.flush if @out.respond_to?(:flush)
-        @err.write(result.stderr) unless @err.equal?($stderr)
+        @err.write(result.stderr) unless @err.equal?($stderr) && live
         info("[cached]") if result.cached
         result.exit_status
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -629,7 +629,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.4.0 installed!
+  Milk Tea 0.4.2 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH