mt-lang 0.3.10 → 0.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0eb8fe30acd589069404d9a88cba70713a36937acf80299123b7a9b5a909b5da
-  data.tar.gz: 3f7a0240fcfc10f0617e94fdb6d28abe40c1ffbc6bfaa12e87235f4440ffaef6
+  metadata.gz: efa0075ce73ffd0c92161f778399c599c6443e4375194a8bfeda883b3c29ea09
+  data.tar.gz: 978ab66cd06f4261edb72629f528c020890250ed7b57bbd75bee8cbe01e7e6a1
 SHA512:
-  metadata.gz: f9623980449010f1a2895f715153948845edb191cb0164b9e48b615527d6d2aa0809abae016c07fa85197628e2baf190ca08adc2c14b31934b22465b9ca01f45
-  data.tar.gz: 543375cd1021947da13d214f8aacf379d565a6e840564dc9e9233bd7673200d967318c1ef7ca209000182c78fa98c141c2ceddcd9ca1c91d5b221d0caac9d03b
+  metadata.gz: b0516d11fd07ed4c2db9bfaa4d59735821cfc3245aca280118f87593e7fa1fb2fec3be0c8208efc87b91c4cd79215e3a593602b43e1d9811572fcdcced93c280
+  data.tar.gz: 1a27eb0e66b9b15330ae28273b59ddfa430a6e7439811c2ca196b685cb6e8379b56016bb3a6eed60b347582fd013d8ba29f0c7024fbec0c13b67592aff3e0eba

data/README.md

@@ -30,6 +30,7 @@ Package manifests, build workflow, and run workflow are documented separately in
 - External files are the dedicated raw ABI surface, usually for generated or low-level `std.c.*` bindings.
 - Module lookup resolves `a.b.c` to `a/b/c.mt`.
 - Inside a package, the file path relative to `package.source_root` defines the module name; platform-specific files such as `name.linux.mt` still map to module `name`.
+- Circular module imports are supported via forward-declaration bindings and two-pass checking. Cycle members see each other's type declarations in the first pass and full type information in the second pass.
 - In ordinary files, `import` statements appear only at the top.
 - In external files, leading `import` statements are allowed after `external`.
 - Only external files accept `include`, `link`, and `compiler_flag` directives.
@@ -314,6 +315,7 @@ Rules:
 - Compile-time reflection over validated attributes uses `has_attribute`, `attribute_of`, `attribute_arg[T]`, `field_of`, and `callable_of`.
 - `field_of(...)`, `callable_of(...)`, and `attribute_of(...)` produce compile-time handle values with source-visible handle types `field_handle`, `callable_handle`, and `attribute_handle`.
 - The current C backend lowers `packed` / `align(...)` attributes with GNU-style `__attribute__((...))`, so these layout controls currently require a Clang/GCC-family compiler. On Windows that means Clang or GCC-family toolchains such as MinGW; `cl.exe` is not a supported backend for these attributes today. On wasm/browser targets the same feature works through Emscripten `emcc`, which is Clang-based.
+- Keywords and reserved words are accepted as variant arm names, struct/union field names, enum/flags member names, lifetime parameters (`@return`), type parameters (`Box[return]`), and named constructor arguments (`Meta(return = 1)`). Primitive type names (`int`, `str`, `ref`, etc.) remain reserved and cannot be used in these positions.
 
 Enum and flags values support the full set of comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) against values of the same enum type and against their backing integer type. Comparisons use the underlying integer backing values. Flags also support bitwise operators (`|`, `&`, `^`, `~`).
 

data/docs/language-design.md

@@ -490,7 +490,7 @@ Milk Tea has first-class compiler support for multithreading. The threading mode
 parallel for i in 0..entity_count:
     positions[i] += velocities[i] * dt
 
-# Structured fork-join: each do block runs on a separate thread
+# Structured fork-join: each statement runs on a separate thread
 parallel:
     textures = load_textures(path)
     sounds = load_sounds(path)
@@ -501,7 +501,6 @@ Design choices:
 - **Structured, not fire-and-forget.** All `parallel for` and `parallel:` blocks are synchronous barriers — the calling thread blocks until all work completes. This guarantees that captured local variables remain alive for the duration and eliminates lifetime concerns without ownership annotations.
 - **Compile-time safety.** `ref[T]` captures are rejected because mutable aliases across thread boundaries create data races. The `parallel:` block enforces single-writer-or-multiple-readers: if one statement writes a variable, no other block may read or write it.
 - **Value capture, pointer-based arrays.** Scalars and spans are captured by value (the span's data pointer still references the original storage). Arrays are captured as pointers to their first element, so writes in the worker affect the original array.
-- **`do` is a keyword.** It is recognized inside `parallel:` blocks to introduce each concurrent unit of work.
 - **Real OS threads via libuv.** Thread dispatch uses `uv_thread_create` / `uv_thread_join`, consistent with `std.thread` and `std.sync`. CPU count is detected at runtime via `uv_cpu_info`. The first chunk runs on the calling thread to avoid unnecessary dispatch when the workload is small.
 - **No forced dependency.** The build system automatically detects `parallel for` and `parallel:` usage via a sema-level flag and links libuv only when needed.
 

data/docs/language-manual.md

@@ -51,6 +51,7 @@ Rules:
 - Valid platform filename suffixes are `linux`, `windows`, and `wasm`.
 - The platform suffix is not part of the module name. `import a.b.c` stays the same on every target.
 - Milk Tea does not have a source-level conditional compilation syntax such as `#if`, `#ifdef`, or per-declaration platform attributes.
+- Circular module imports are supported. When two modules import each other, the compiler uses forward-declaration bindings for the first pass and full type-checked bindings for the second pass, enabling cross-module type references and constructors in cycle groups.
 
 ## 2. Lexical Rules
 
@@ -360,6 +361,17 @@ Compile-time reflection over validated attributes uses `has_attribute`, `attribu
 
 The current C backend lowers `packed` / `align(...)` attributes with GNU-style `__attribute__((...))`, so these layout controls currently require a Clang/GCC-family compiler. On Windows that means Clang or GCC-family toolchains such as MinGW; `cl.exe` is not a supported backend for these attributes today. On wasm/browser targets the same feature works through Emscripten `emcc`, which is Clang-based.
 
+Language-level keywords and reserved words are accepted as:
+- variant arm names (`return(val: int)`, `if(arg: bool)`)
+- struct and union field names (`return: int`, `let: str`)
+- enum and flags member names (`return = 1`, `if = 6`)
+- variant arm payload field names (`execute(return: int)`)
+- lifetime parameter names (`struct Buf[@return]`)
+- type parameter names (`struct Box[return]`, `identity[type]`)
+- named arguments in struct/variant literals (`Meta(return = 1)`)
+
+Primitive type names (`int`, `str`, `bool`, `ref`, `ptr`, `span`, `type`, etc.) remain reserved and cannot be used as names.
+
 ### 3.4a Enum and flags operators
 
 Enum and flags values support the full set of comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) against values of the same enum type and against their backing integer type. Comparisons use the underlying integer backing values.
@@ -746,7 +758,6 @@ parallel:
 Rules:
 
 - A `parallel:` block must contain at least two statements.
-- `do` is a contextual keyword — only recognized inside `parallel:` blocks, not reserved globally.
 - Each statement must not contain `break`, `continue`, `return`, or `defer`.
 - The compiler enforces single-writer-or-multiple-readers: if a variable is written in one statement, no other block may access it.
 - Captured `ref[T]` values are rejected at compile time.

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -153,17 +153,17 @@ module MilkTea
     VariantArm = Data.define(:name, :fields, :line, :column) do
       def initialize(name:, fields:, line: nil, column: nil) = super
     end
-    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
-      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body, :line, :column) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
     MatchStmt = Data.define(:expression, :arms, :inline, :line, :column, :length) do
       def initialize(expression:, arms:, inline: false, line: nil, column: nil, length: nil) = super
     end
-    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value) do
-      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil) = super
+    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value, :line, :column) do
+      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
-    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
-      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body, :line, :column) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
     WhenStmt = Data.define(:discriminant, :branches, :else_body, :line, :column, :length) do
       def initialize(discriminant:, branches:, else_body:, line: nil, column: nil, length: nil) = super

data/lib/milk_tea/core/lowering/async/normalization.rb

@@ -93,7 +93,7 @@ module MilkTea
         arms = statement.arms.map do |arm|
           arm_env = duplicate_env(env)
           bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
-          AST::MatchArm.new(pattern: arm.pattern, binding_name: arm.binding_name, body: normalize_async_statements(arm.body, counter, arm_env, return_type:))
+          AST::MatchArm.new(pattern: arm.pattern, binding_name: arm.binding_name, body: normalize_async_statements(arm.body, counter, arm_env, return_type:), line: arm.line, column: arm.column)
         end
         expr_setup + [AST::MatchStmt.new(expression:, arms:)]
       when AST::WhileStmt
@@ -307,6 +307,8 @@ module MilkTea
             binding_line: arm.binding_line,
             binding_column: arm.binding_column,
             value: normalized_value,
+            line: arm.line,
+            column: arm.column,
           )]
         end
 
@@ -326,6 +328,8 @@ module MilkTea
                 binding_line: arm.binding_line,
                 binding_column: arm.binding_column,
                 body: pattern_setup + value_setup + [AST::Assignment.new(target: AST::Identifier.new(name: temp_name), operator: "=", value: arm.value)],
+                line: arm.line,
+                column: arm.column,
               )
             end,
             line: expression.line,

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

@@ -372,10 +372,10 @@ module MilkTea
           break if check(:rbracket)
 
           if match(:at)
-            name_token = consume_name("expected lifetime name after @")
+            name_token = consume_name_allowing_keywords("expected lifetime name after @")
             lifetime_params << "@#{name_token.lexeme}"
           else
-            name_token = consume_name("expected type parameter name")
+            name_token = consume_name_allowing_keywords("expected type parameter name")
             if match(:colon)
               value_type = parse_type_ref
               type_params << AST::ValueTypeParam.new(
@@ -419,7 +419,7 @@ module MilkTea
 
         raise error(visibility_token, "public is only allowed on struct events") if visibility == :public
 
-        field_token = consume_name("expected field name")
+        field_token = consume_name_allowing_keywords("expected field name")
         field_name = field_token.lexeme
         consume(:colon, "expected ':' after field name")
         field_type = parse_type_ref
@@ -440,7 +440,7 @@ module MilkTea
         name = name_token.lexeme
         c_name = parse_optional_explicit_c_name
         fields = parse_named_block do
-          field_name = consume_name("expected field name").lexeme
+                       field_name = consume_name_allowing_keywords("expected field name").lexeme
           consume(:colon, "expected ':' after field name")
           field_type = parse_type_ref
           consume_end_of_statement
@@ -471,7 +471,7 @@ module MilkTea
         members = []
         skip_newlines
         until check(:dedent) || eof?
-          member_token = consume_name("expected member name")
+          member_token = consume_name_allowing_keywords("expected member name")
           member_name = member_token.lexeme
           if match(:equal)
             value = parse_expression
@@ -493,10 +493,10 @@ module MilkTea
         name = name_token.lexeme
         type_params = parse_declaration_type_params
         arms = parse_named_block do
-          arm_name = consume_name("expected variant arm name").lexeme
+          arm_name = consume_name_allowing_keywords("expected variant arm name").lexeme
           fields = if match(:lparen)
                      parsed = parse_comma_separated_until(:rparen) do
-                       field_name = consume_name("expected field name").lexeme
+          field_name = consume_name_allowing_keywords("expected field name").lexeme
                        consume(:colon, "expected ':' after field name")
                        field_type = parse_type_ref
                        AST::Field.new(name: field_name, type: field_type)

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

@@ -105,6 +105,8 @@ module MilkTea
             binding_line: binding_token&.line,
             binding_column: binding_token&.column,
             value:,
+            line: pattern.line,
+            column: pattern.column,
           )
         end
       end
@@ -153,6 +155,8 @@ module MilkTea
                 binding_line: nil,
                 binding_column: nil,
                 value: AST::BooleanLiteral.new(value: true),
+                line: arm_pattern.line,
+                column: arm_pattern.column,
               ),
               AST::MatchExprArm.new(
                 pattern: AST::Identifier.new(name: "_", line:, column:),
@@ -160,6 +164,8 @@ module MilkTea
                 binding_line: nil,
                 binding_column: nil,
                 value: AST::BooleanLiteral.new(value: false),
+                line:,
+                column:,
               ),
             ],
             line:,
@@ -338,7 +344,7 @@ module MilkTea
       end
 
       def parse_call_argument
-        if check_name && check_next(:equal)
+        if (check_name || keyword_token?(peek)) && check_next(:equal)
           name = advance.lexeme
           consume(:equal, "expected '=' after named argument name")
           AST::Argument.new(name:, value: parse_expression)

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

@@ -351,6 +351,8 @@ module MilkTea
               binding_line: binding_token&.line,
               binding_column: binding_token&.column,
               value:,
+              line: pattern.line,
+              column: pattern.column,
             )
           end
         else
@@ -362,6 +364,8 @@ module MilkTea
               binding_line: binding_token&.line,
               binding_column: binding_token&.column,
               body:,
+              line: pattern.line,
+              column: pattern.column,
             )
           end
         end
@@ -376,6 +380,8 @@ module MilkTea
           binding_line: binding_token&.line,
           binding_column: binding_token&.column,
           body: recovered_body,
+          line: patterns.first&.line,
+          column: patterns.first&.column,
         )] if recovered_body
 
         raise
@@ -615,6 +621,8 @@ module MilkTea
             binding_line: binding_token.line,
             binding_column: binding_token.column,
             body:,
+            line: pattern.line,
+            column: pattern.column,
           )
           skip_newlines
         end

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

@@ -92,7 +92,7 @@ module MilkTea
 
         first_token = peek
         if match(:at)
-          lt_token = consume_name("expected lifetime name after @")
+          lt_token = consume_name_allowing_keywords("expected lifetime name after @")
           return AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["@#{lt_token.lexeme}"]), arguments: [], nullable: false, lifetime: nil, line: first_token.line, column: first_token.column, length: lt_token.lexeme.length + 1)
         end
         name = parse_qualified_name
@@ -101,7 +101,7 @@ module MilkTea
         if match(:lbracket)
           if check(:at) && name.to_s == "ref"
             match(:at)
-            lt_token = consume_name("expected lifetime name after @")
+            lt_token = consume_name_allowing_keywords("expected lifetime name after @")
             lifetime = "@#{lt_token.lexeme}"
             consume(:comma, "expected ',' after lifetime in type arguments")
           end
@@ -167,7 +167,7 @@ module MilkTea
       end
 
       def parse_function_type_param
-        name_token = consume_name("expected function type parameter name")
+        name_token = consume_name_allowing_keywords("expected function type parameter name")
         name = name_token.lexeme
         consume(:colon, "expected ':' after function type parameter name")
         type = parse_type_ref
@@ -190,7 +190,7 @@ module MilkTea
         return [] unless match(:lbracket)
 
         params = parse_comma_separated_until(:rbracket) do
-          name_token = consume_name("expected type parameter name")
+          name_token = consume_name_allowing_keywords("expected type parameter name")
           name = name_token.lexeme
           if match(:colon)
             value_type = parse_type_ref

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

@@ -208,7 +208,7 @@ module MilkTea
       def resolve_type_param_constraints(type_params)
         type_params.each_with_object({}) do |type_param, constraints|
           if type_param.is_a?(AST::ValueTypeParam)
-            ensure_non_reserved_type_binding_name!(
+            ensure_non_reserved_value_type_name!(
               type_param.name,
               kind_label: "type parameter",
               line: type_param.line,
@@ -218,7 +218,7 @@ module MilkTea
             next
           end
 
-          ensure_non_reserved_type_binding_name!(
+          ensure_non_reserved_value_type_name!(
             type_param.name,
             kind_label: "type parameter",
             line: type_param.line,

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

@@ -482,7 +482,7 @@ module MilkTea
               raise_sema_error("duplicate field #{decl.name}.#{field.name}") if fields.key?(field.name)
               raise_sema_error("duplicate member #{decl.name}.#{field.name}") if events.key?(field.name)
               unless raw_module?
-                ensure_non_reserved_type_binding_name!(
+                ensure_non_reserved_value_type_name!(
                   field.name,
                   kind_label: "field #{decl.name}",
                   line: field.line || decl.line,
@@ -576,7 +576,7 @@ module MilkTea
             decl.members.each do |member|
               raise_sema_error("duplicate member #{decl.name}.#{member.name}") if member_names.include?(member.name)
               unless raw_module?
-                ensure_non_reserved_type_binding_name!(
+                ensure_non_reserved_value_type_name!(
                   member.name,
                   kind_label: "member #{decl.name}",
                   line: member.line || decl.line,
@@ -645,7 +645,7 @@ module MilkTea
               begin
                 raise_sema_error("duplicate arm #{decl.name}.#{arm.name}") if seen_arms.include?(arm.name)
                 unless raw_module?
-                  ensure_non_reserved_type_binding_name!(
+                  ensure_non_reserved_value_type_name!(
                     arm.name,
                     kind_label: "arm #{decl.name}",
                     line: arm.line || decl.line,
@@ -661,7 +661,7 @@ module MilkTea
                   begin
                     raise_sema_error("duplicate field #{arm.name}.#{field.name}") if seen_fields.include?(field.name)
                     unless raw_module?
-                      ensure_non_reserved_type_binding_name!(
+                      ensure_non_reserved_value_type_name!(
                         field.name,
                         kind_label: "field #{decl.name}.#{arm.name}",
                         line: field.line || decl.line,

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

@@ -275,6 +275,12 @@ module MilkTea
           end
 
           if KEYWORD_TOKEN_TYPES.include?(tok.type)
+            return [:typeParameter, []] if keyword_lifetime_or_type_param?(tokens, index)
+            return [:type, []] if keyword_type_annotation?(tokens, index)
+            return [:enumMember, [:declaration]] if variant_enum_member_declaration?(tokens, index)
+            return [:property, [:declaration]] if keyword_field_declaration_token?(tokens, index)
+            return [:property, []] if keyword_member_access?(tokens, index)
+            return [:parameter, []] if keyword_named_argument_token?(tokens, index)
             return [:keyword, []]
           end
 
@@ -550,6 +556,64 @@ module MilkTea
           next_tok&.type == :colon
         end
 
+        def keyword_field_declaration_token?(tokens, index)
+          return false if match_arm_binding_token?(tokens, index)
+          return false if destructure_let_binding?(tokens, index)
+
+          next_tok = next_non_trivia_token(tokens, index + 1)
+          next_tok&.type == :colon
+        end
+
+        def keyword_member_access?(tokens, index)
+          prev_index = previous_non_trivia_token_index(tokens, index)
+          return false unless prev_index
+
+          tokens[prev_index].type == :dot
+        end
+
+        def keyword_lifetime_or_type_param?(tokens, index)
+          prev_index = previous_non_trivia_token_index(tokens, index)
+          return false unless prev_index
+
+          prev_type = tokens[prev_index].type
+          return true if prev_type == :at
+          return true if prev_type == :lbracket
+          return true if prev_type == :comma && inside_type_params?(tokens, prev_index)
+          false
+        end
+
+        def inside_type_params?(tokens, comma_index)
+          i = comma_index - 1
+          while i >= 0
+            t = tokens[i]
+            break if t.type == :lbracket
+            return false if t.type == :newline || t.type == :rbracket || t.type == :lparen
+            i -= 1
+          end
+          return false if i < 0
+
+          prev = previous_non_trivia_token_index(tokens, i)
+          return true if prev && %i[struct variant enum flags function fn proc].include?(tokens[prev].type)
+          return true if prev && tokens[prev].type == :rbracket
+          return true if prev && tokens[prev].type == :identifier
+
+          false
+        end
+
+        def keyword_named_argument_token?(tokens, index)
+          next_tok = next_non_trivia_token(tokens, index + 1)
+          next_tok&.type == :equal
+        end
+
+        def keyword_type_annotation?(tokens, index)
+          tok = tokens[index]
+          prev_index = previous_non_trivia_token_index(tokens, index)
+          return false unless prev_index
+          return false unless %i[colon arrow].include?(tokens[prev_index].type)
+
+          tokens[prev_index].line == tok.line
+        end
+
         def destructure_let_binding?(tokens, index)
           tok = tokens[index]
           return false unless tok&.type == :identifier

data/lib/milk_tea/tooling/cli.rb

@@ -1611,6 +1611,7 @@ module MilkTea
       input_path = nil
       theme_path = nil
       output_path = nil
+      textmate_only = false
 
       until @argv.empty?
         arg = @argv.first
@@ -1629,6 +1630,9 @@ module MilkTea
             @err.puts("snapshot: missing value for --output")
             return 1
           end
+        when "--textmate-only"
+          @argv.shift
+          textmate_only = true
         else
           if arg.start_with?("-")
             @err.puts("snapshot: unknown option #{arg}")
@@ -1674,10 +1678,12 @@ module MilkTea
       args.push("-o", output_path) if output_path
 
       semantic_result = nil
-      begin
-        semantic_result = MilkTea::LSP::Server.semantic_tokens_for_path(input_path)
-      rescue => e
-        @err.puts("snapshot: semantic analysis skipped: #{e.message}")
+      unless textmate_only
+        begin
+          semantic_result = MilkTea::LSP::Server.semantic_tokens_for_path(input_path)
+        rescue => e
+          @err.puts("snapshot: semantic analysis skipped: #{e.message}")
+        end
       end
 
       if semantic_result && semantic_result[:entries] && !semantic_result[:entries].empty?

metadata

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