mt-lang 0.3.27 → 0.3.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 802d8ba551d2f4712c3dc174ade901063ef797baf33a87ad8a2b902db2916b24
-  data.tar.gz: 322d7781ae7fcbf67108bf260b63caf8889facf0382c3d7e248e124868a0bbd0
+  metadata.gz: d6d13cde9fca875b324ff3e0cb3b892c371e2445ac5e061d138bd0dc8b284b88
+  data.tar.gz: 2a91eedc02120e0d042bc6bafbfc783a4eefb5bbc44c34940e1ee9be6917405e
 SHA512:
-  metadata.gz: afd649faf27c7327ab60c9050c56eb66416fd022fbb11a2d8b8f16438a021732fdec0a65e76a16649f6b35ec7c070d2e0873b56a02ff0d8aa8c1505ffb72d685
-  data.tar.gz: eee26037932660079c5b1352eac96ef923766930c42d611895206c66276ef31a313213cc3b104046f4ff0048af7035bb77a2aa4cf270c79a08aa0e203e31bb85
+  metadata.gz: 478dc59b852c703b5cf63ce3cd77a92d6de305424c96cfa7dbeda97ed1882f2d8c52f5770893dc99a3077cb1599cbf0602c6e54b773f219ce859b8b9275c7258
+  data.tar.gz: d221d15fe3c3192ee0b10b61101f5234e8b92830f878051c6e2641aca334b7d165c9668bf410a727b4964f02d45805322044470a9e406b971ab7508650d60a00

data/README.md

@@ -94,7 +94,7 @@ Supported literals:
 - floats: `3.14`, `1.2e-3`, `1.0f` (float suffix), `1.0d` (double suffix)
 - character: `'a'`, `'\n'`, `'\t'`, `'\\'`, `'\''`, `'\0'`, `'\x41'`. Type is `ubyte`. Escape sequences: `\n`, `\r`, `\t`, `\\`, `\'`, `\"`, `\0` (null byte), `\xNN` (hex byte).
 - booleans: `true`, `false`
-- string: `"hello"` -> `str`
+- string: `"hello"` -> `str`. The `+` operator concatenates `str` values: `"hello" + " " + "world"` produces `"hello world"`. For loops or repeated concatenation, prefer `string.String`.
 - cstring: `c"hello"` -> `cstr`
 - heredoc string: `<<-TAG ... TAG`
 - heredoc cstring: `c<<-TAG ... TAG`
@@ -106,7 +106,7 @@ Common punctuation and operators:
 - delimiters: `(` `)` `[` `]`
 - access and separators: `:` `,` `.`
 - type markers: `->` `?`
-- arithmetic: `+ - * / %`
+- arithmetic: `+ - * / %` (additionally, `+` on `str` concatenates)
 - bitwise: `~ & | ^ << >>`
 - comparison: `== != < <= > >=`
 - assignment: `= += -= *= /= %= &= |= ^= <<= >>=`
@@ -249,6 +249,10 @@ struct Vec2:
     x: float
     y: float
 
+    # Methods may also be defined directly inside the struct body:
+    function length_sq() -> float:
+        return this.x * this.x + this.y * this.y
+
 @[packed]
 struct Header:
     tag: ubyte
@@ -310,6 +314,7 @@ variant Token:
 Rules:
 
 - `struct` and `opaque` may declare nominal interface conformance with `implements`.
+- `struct` bodies may contain `function`, `editable function`, and `static function` declarations directly — they desugar to `extending` blocks targeting the enclosing struct. This is pure syntactic sugar; the compiler emits identical code as a separate `extending` block.
 - `attribute[target, ...]` declares reusable declaration attributes for `struct`, `field`, `callable`, `const`, `event`, `enum`, `flags`, `union`, and `variant` targets.
 - Attributes are applied with one or more leading `@[name(...)]` blocks. Built-in `packed`, `align(bytes)`, and `deprecated(message)` are predefined attributes.
 - `variant` arms may carry named payload fields.
@@ -358,11 +363,31 @@ Method kinds:
 - `editable function` -> editable receiver
 - `static function` -> no receiver
 
+Methods may appear inside a struct body (desugared to an `extending` block) or in a separate
+`extending` declaration:
+
+```mt
+struct Counter:
+    value: int
+
+    function read() -> int:
+        return this.value
+
+    editable function bump() -> void:
+        this.value += 1
+
+    static function zero() -> Counter:
+        return Counter(value = 0)
+```
+
+Both inline and `extending` forms lower to identical C code.
+
 Method notes:
 
 - Async methods are supported.
 - Generic methods are supported.
 - There is no constructor keyword. Names like `init` and `default` are ordinary static methods.
+- Methods may be defined inside struct bodies directly (as syntactic sugar for `extending`) or in separate `extending` blocks. Both forms lower to the same C code; the inline form is preferred when the struct and its core methods appear in the same file.
 
 ## 7. Functions, Externals, And Foreign Functions
 
@@ -912,7 +937,7 @@ See module source for full method surface. Iterator forms:
 
 Text categories:
 
-- `str` -> string view
+- `str` -> string view. The `+` operator concatenates two `str` values, allocating a new heap-backed string. For loops or repeated concatenation, prefer `string.String` for amortized performance.
 - `cstr` -> C ABI string
 - `str_buffer[N]` -> fixed-capacity mutable UTF-8 text buffer
 

data/docs/index.html

@@ -961,7 +961,7 @@ let total = (
       <tr><td>Delimiters</td><td><code>( ) [ ]</code></td></tr>
       <tr><td>Separators / Access</td><td><code>: , .</code></td></tr>
       <tr><td>Type markers</td><td><code>-&gt;</code> <code>?</code></td></tr>
-      <tr><td>Arithmetic</td><td><code>+ - * / %</code></td></tr>
+      <tr><td>Arithmetic</td><td><code>+ - * / %</code> (the <code>+</code> operator on <code>str</code> concatenates, allocating a new heap-backed string)</td></tr>
       <tr><td>Bitwise</td><td><code>~ &amp; | ^ &lt;&lt; &gt;&gt;</code></td></tr>
       <tr><td>Comparison</td><td><code>== != &lt; &lt;= &gt; &gt;=</code></td></tr>
       <tr><td>Assignment</td><td><code>= += -= *= /= %= &amp;= |= ^= &lt;&lt;= &gt;&gt;=</code></td></tr>
@@ -1243,7 +1243,7 @@ let d: dyn[Drawable] = adapt[Drawable](ref_of(entity))</code></pre>
       <tr><td><code>ptr_int</code> <code>ptr_uint</code></td><td>Pointer-sized integers</td></tr>
       <tr><td><code>float</code> <code>double</code></td><td>Floating-point</td></tr>
       <tr><td><code>void</code></td><td>No value</td></tr>
-      <tr><td><code>str</code></td><td>UTF-8 string view (borrowed)</td></tr>
+      <tr><td><code>str</code></td><td>UTF-8 string view (borrowed). The <code>+</code> operator concatenates two <code>str</code> values, allocating a new heap-backed string.</td></tr>
       <tr><td><code>cstr</code></td><td>NUL-terminated C string</td></tr>
       <tr><td><code>vec2</code> <code>vec3</code> <code>vec4</code></td><td>Float vectors with <code>.x .y .z .w</code></td></tr>
       <tr><td><code>ivec2</code> <code>ivec3</code> <code>ivec4</code></td><td>Integer vectors</td></tr>

data/docs/language-design.md

@@ -38,7 +38,7 @@ If code allocates, takes an address, dereferences a raw pointer, performs an FFI
 
 FFI visibility belongs at the declaration site. Raw `external` files expose exact ABI types. Imported foreign declarations may project those raw types into ordinary Milk Tea types, but the projection rule, temporary-storage rule, and ownership rule must be declared there instead of repeated at every call site.
 
-The same rule applies to text construction. Plain string literals and format string literals are borrowed `str` values. Any surface that builds owned text must say so explicitly, for example `std.fmt.format(f"...")` when ownership must escape.
+The same rule applies to text construction. Plain string literals and format string literals are borrowed `str` values. The `+` operator on `str` allocates a new heap-backed `str` — the one everyday convenience that does allocate. For loops or amortized building, `string.String` and `str_buffer[N]` remain the explicit surfaces with visible cost. Any other surface that builds owned text must say so explicitly, for example `std.fmt.format(f"...")` when ownership must escape.
 
 ### 2. C is the ABI ground truth
 
@@ -755,7 +755,7 @@ Explicit specialization arguments may be type references like `bytes_for[int](4)
 
 Built-in operators should match familiar C behavior where possible:
 
-- arithmetic: `+ - * / %`
+- arithmetic: `+ - * / %` (the `+` operator on `str` concatenates, allocating a new heap-backed string)
 - comparison: `== != < <= > >=`
 - boolean: `and or not`
 - bitwise: `& | ^ ~ << >>`

data/docs/language-manual.md

@@ -124,7 +124,7 @@ Supported literals:
 - integer: `42`, `0xff`, `0b1010`, with `_` separators. Integer type suffixes: `42u` (`uint`), `0xFFub` (`ubyte`), `100z` (`ptr_uint`), `7i` (`int`), `-1l` (`long`), etc.
 - float: `3.14`, `1.2e-3`, `1.1920929E-7`, `1.0f` (float suffix), `1.0d` (double suffix)
 - character: `'a'`, `'\n'`, `'\t'`, `'\\'`, `'\''`, `'\0'`, `'\x41'`. Type is `ubyte`. Escape sequences: `\n`, `\r`, `\t`, `\\`, `\'`, `\"`, `\0` (null), `\xNN` (hex byte).
-- string: `"hello"` (`str`). Supported string escapes are `\n`, `\r`, `\t`, `\0` (null), `\"`, `\'`, and `\\`; any other `\x` sequence is taken literally. Hex byte escapes (`\xNN`) are character-literal only, not string-literal.
+- string: `"hello"` (`str`). Supported string escapes are `\n`, `\r`, `\t`, `\0` (null), `\"`, `\'`, and `\\`; any other `\x` sequence is taken literally. Hex byte escapes (`\xNN`) are character-literal only, not string-literal. The `+` operator concatenates `str` values: `"hello" + " " + "world"` produces `"hello world"`. Each `+` allocates a new heap-backed `str`; for loops or repeated concatenation, prefer `string.String` for amortized performance.
 - cstring: `c"hello"` (`cstr`)
 - heredoc string: `<<-TAG ... TAG` (`str`)
 - heredoc cstring: `c<<-TAG ... TAG` (`cstr`)
@@ -300,7 +300,25 @@ Callable and `ref[...]` rules:
 struct Vec2:
     x: float
     y: float
+```
+
+`struct` bodies may also contain `function`, `editable function`, and `static function` declarations directly — they desugar to `extending` blocks targeting the enclosing struct. This is pure syntactic sugar and produces identical C code. See §3.6 for the method kind rules.
+
+```mt
+struct Counter:
+    value: int
+
+    function read() -> int:
+        return this.value
+
+    editable function bump() -> void:
+        this.value += 1
+
+    static function zero() -> Counter:
+        return Counter(value = 0)
+```
 
+```mt
 union Number:
     i: int
     f: float
@@ -417,7 +435,25 @@ Rules:
 
 ### 3.6 Methods
 
+Methods may appear directly inside a struct body (desugared to an `extending` block) or in a separate `extending` declaration. Both forms lower to identical C code.
+
+```mt
+# Inline form (sugar)
+struct Counter:
+    value: int
+
+    function read() -> int:
+        return this.value
+
+    editable function bump() -> void:
+        this.value += 1
+
+    static function zero() -> Counter:
+        return Counter(value = 0)
+```
+
 ```mt
+# Equivalent extending form
 extending Counter:
     function read() -> int:
         return this.value
@@ -979,7 +1015,7 @@ Rules:
 8. `==`, `!=`
 9. `<`, `<=`, `>`, `>=`
 10. `<<`, `>>`
-11. `+`, `-`
+11. `+`, `-` (additionally, `+` on `str` concatenates; each `+` allocates a new heap-backed `str`)
 12. `*`, `/`, `%`
 
 ### 5.4 Assignment operators

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/c_backend/feature_detection.rb

@@ -289,6 +289,14 @@ module MilkTea
         emitted_functions.any? { |function| function_uses_str_equality?(function) }
       end
 
+      def uses_str_concat_helper?
+        return @uses_str_concat if defined?(@uses_str_concat)
+
+        @uses_str_concat = emitted_functions.any? do |function|
+          function_uses_named_call?(function, %w[mt_str_concat])
+        end
+      end
+
       def uses_variant_equality_helper?
         emitted_functions.any? { |function| function_uses_variant_equality?(function) }
       end

data/lib/milk_tea/core/c_backend/runtime_helpers.rb

@@ -42,6 +42,27 @@ module MilkTea
         ]
       end
 
+      def emit_str_concat_helper
+        [
+          "#define MT_STR_CONCAT_BUF_SIZE 65536",
+          "",
+          "static _Thread_local char mt_str_concat_buf[MT_STR_CONCAT_BUF_SIZE];",
+          "static _Thread_local uintptr_t mt_str_concat_offset = 0;",
+          "",
+          "static mt_str mt_str_concat(mt_str a, mt_str b) {",
+          "#{INDENT}uintptr_t total = a.len + b.len;",
+          "#{INDENT}if (mt_str_concat_offset + total > MT_STR_CONCAT_BUF_SIZE) {",
+          "#{INDENT * 2}mt_str_concat_offset = 0;",
+          "#{INDENT}}",
+          "#{INDENT}char* buf = mt_str_concat_buf + mt_str_concat_offset;",
+          "#{INDENT}if (a.len > 0) memcpy(buf, a.data, a.len);",
+          "#{INDENT}if (b.len > 0) memcpy(buf + a.len, b.data, b.len);",
+          "#{INDENT}mt_str_concat_offset += total;",
+          "#{INDENT}return (mt_str){ .data = buf, .len = total };",
+          "}",
+        ]
+      end
+
       def emit_variant_equality_helpers
         emitted_aggregate_variants.flat_map { |variant_decl| emit_variant_equality_helper(variant_decl) }
       end

data/lib/milk_tea/core/c_backend.rb

@@ -146,6 +146,10 @@ module MilkTea
         lines.concat(emit_str_equality_helper)
         lines << ""
       end
+      if uses_str_concat_helper?
+        lines.concat(emit_str_concat_helper)
+        lines << ""
+      end
       if uses_str_buffer_helpers?
         lines.concat(emit_utf8_validation_helpers)
         lines << ""

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

@@ -1387,6 +1387,10 @@ module MilkTea
           left = cast_expression(left, operand_type) if operand_type
           right = cast_expression(right, operand_type) if operand_type
 
+          if expression.operator == "+" && left_type == @ctx.types.fetch("str") && right_type == @ctx.types.fetch("str")
+            return IR::Call.new(callee: "mt_str_concat", arguments: [left, right], type:)
+          end
+
           expanded = lower_vector_binary_operation(expression.operator, left, left_type, right, right_type, type)
           return expanded if expanded
 

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

@@ -369,7 +369,7 @@ module MilkTea
         AST::AttributeDecl.new(name: name_token.lexeme, targets:, params:, visibility:, line:, column: name_token.column)
       end
 
-      def parse_struct_decl(packed: false, alignment: nil, visibility: :private, attributes: [])
+      def parse_struct_decl(packed: false, alignment: nil, visibility: :private, attributes: [], inline_methods: true)
         line = previous.line
         name_token = consume_name("expected struct name")
         name = name_token.lexeme
@@ -377,13 +377,32 @@ module MilkTea
         implements = parse_implements_clause
         c_name = parse_optional_c_name
         packed, alignment = parse_struct_layout_attributes(attributes) if attributes.any?
-        members = parse_recoverable_block do
-          parse_struct_member
+        receiver_type_param_names = type_params.map(&:name)
+        members = with_type_param_names(receiver_type_param_names) do
+          parse_recoverable_block do
+            parse_struct_member
+          end
         end
         fields = members.filter_map { |kind, member| member if kind == :field }
         events = members.filter_map { |kind, member| member if kind == :event }
         nested_types = members.filter_map { |kind, member| member if kind == :nested_type }
-        AST::StructDecl.new(name:, type_params:, implements:, c_name:, fields:, events:, nested_types:, attributes:, packed:, alignment:, visibility:, lifetime_params:, line:, column: name_token.column)
+        methods = members.filter_map { |kind, member| member if kind == :method }
+        struct_decl = AST::StructDecl.new(name:, type_params:, implements:, c_name:, fields:, events:, nested_types:, attributes:, packed:, alignment:, visibility:, lifetime_params:, line:, column: name_token.column)
+
+        if inline_methods && methods.any?
+          type_ref_args = type_params.map do |tp|
+            AST::TypeArgument.new(
+              value: AST::TypeRef.new(name: AST::QualifiedName.new(parts: [tp.name]), arguments: [], nullable: false, line: tp.line, column: tp.column),
+              line: tp.line,
+              column: tp.column,
+            )
+          end
+          type_ref = AST::TypeRef.new(name: AST::QualifiedName.new(parts: [name]), arguments: type_ref_args, nullable: false, line: name_token.line, column: name_token.column)
+          extending_block = AST::ExtendingBlock.new(type_name: type_ref, methods:, line: name_token.line, column: name_token.column)
+          [struct_decl, extending_block]
+        else
+          struct_decl
+        end
       end
 
       def parse_struct_decl_params
@@ -429,8 +448,24 @@ module MilkTea
         [lifetime_params, type_params]
       end
 
+      def check_method_start?
+        saved = @current
+        match(:public)
+        match(:async)
+        match(:editable) if check(:editable)
+        match(:static) if check(:static)
+        result = check(:function)
+        @current = saved
+        result
+      end
+
       def parse_struct_member
         field_attributes = parse_attribute_applications
+
+        if check_method_start?
+          return [:method, parse_method_def(attributes: field_attributes)]
+        end
+
         visibility, visibility_token = parse_visibility
 
         if match(:event)
@@ -438,7 +473,7 @@ module MilkTea
         end
 
         if match(:struct)
-          return [:nested_type, parse_struct_decl(visibility:, attributes: field_attributes)]
+          return [:nested_type, parse_struct_decl(visibility:, attributes: field_attributes, inline_methods: false)]
         end
 
         raise error(visibility_token, "public is only allowed on struct events") if visibility == :public

data/lib/milk_tea/core/parser.rb

@@ -154,13 +154,23 @@ module MilkTea
       until eof?
         if errors
           begin
-            declarations << parse_declaration
+            result = parse_declaration
+            if result.is_a?(Array)
+              declarations.concat(result)
+            else
+              declarations << result
+            end
           rescue ParseError => e
             errors << e
             synchronize_to_top_level_boundary
           end
         else
-          declarations << parse_declaration
+          result = parse_declaration
+          if result.is_a?(Array)
+            declarations.concat(result)
+          else
+            declarations << result
+          end
         end
         skip_newlines
       end

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

@@ -612,8 +612,8 @@ module MilkTea
 
           left_type
         when "+", "-", "*", "/"
-          if expression.operator == "+" && (string_like_type?(left_type) || string_like_type?(right_type))
-            raise_sema_error("operator + does not support str/cstr concatenation; use continued string literals for static text or string.String/str_buffer for dynamic text")
+          if expression.operator == "+" && left_type == @ctx.types.fetch("str") && right_type == @ctx.types.fetch("str")
+            return left_type
           end
 
           pointer_result = pointer_arithmetic_result(expression.operator, left_type, right_type)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.27
+  version: 0.3.30
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -149,9 +149,6 @@ files:
 - docs/index.html
 - docs/language-design.md
 - docs/language-manual.md
-- docs/self-host-contract.md
-- docs/self-host-plan.md
-- docs/self-host-progress.md
 - lib/milk_tea.rb
 - lib/milk_tea/base.rb
 - lib/milk_tea/bindings.rb
@@ -627,7 +624,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.27 installed!
+  Milk Tea 0.3.30 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH