mt-lang 0.3.30 → 0.3.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6d13cde9fca875b324ff3e0cb3b892c371e2445ac5e061d138bd0dc8b284b88
-  data.tar.gz: 2a91eedc02120e0d042bc6bafbfc783a4eefb5bbc44c34940e1ee9be6917405e
+  metadata.gz: 16833c6b95c7e580f12199a381802f47ac628b7252f4bc1647714098cbd4f824
+  data.tar.gz: 296b0547096ceee9d394edc13df6f042e2b8ed6d42c98b4745e1b39885407b85
 SHA512:
-  metadata.gz: 478dc59b852c703b5cf63ce3cd77a92d6de305424c96cfa7dbeda97ed1882f2d8c52f5770893dc99a3077cb1599cbf0602c6e54b773f219ce859b8b9275c7258
-  data.tar.gz: d221d15fe3c3192ee0b10b61101f5234e8b92830f878051c6e2641aca334b7d165c9668bf410a727b4964f02d45805322044470a9e406b971ab7508650d60a00
+  metadata.gz: '080aa9b4ad981dce767373642fe8c81fef77bf4b4c364b60e2b5dc633e7e1a2f593187ebcc3903a15aebec587bd6989a844dfd8fd842fb8b61fc855a5ba9ce86'
+  data.tar.gz: b9c60e1298c8fb8195401875f3d77358965741c1537cb674696d71ca1b5ef8f8ce5289d7a4e3491bbca24bd485481d6fd65df531a975237c08da888539c30b9e

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`. The `+` operator concatenates `str` values: `"hello" + " " + "world"` produces `"hello world"`. For loops or repeated concatenation, prefer `string.String`.
+- string: `"hello"` -> `str`. The `+` operator concatenates `str` values (see §12).
 - 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: `+ - * / %` (additionally, `+` on `str` concatenates)
+- arithmetic: `+ - * / %`
 - bitwise: `~ & | ^ << >>`
 - comparison: `== != < <= > >=`
 - assignment: `= += -= *= /= %= &= |= ^= <<= >>=`
@@ -332,6 +332,8 @@ Rules:
 
 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 (`|`, `&`, `^`, `~`).
 
+Struct and variant values support `==` and `!=`: structs compare field by field when all fields are comparable, variants compare the active arm and its payload. Recursive variants compare cyclic fields by pointer identity. Untagged `union` fields and non-comparable types (`proc`, `span`, `simd`, `SoA`, `Task`, `dyn`) are rejected — use `equal[T]` there.
+
 Generic variants and structs are supported, for example `Option[int]`.
 
 ## 6. Interfaces And Methods
@@ -808,7 +810,7 @@ Type constructors:
 
 - `ptr[T]`
 - `const_ptr[T]`
-- `own[T]` — owning heap pointer: auto-dereferences like `ref` but storable, returnable, and nullable. Created via `heap.must_alloc[T](count)`. Compiles to `T*`.
+- `own[T]` — owning heap pointer with auto-deref; storable, returnable, nullable (compiles to `T*`)
 - `ref[T]`
 - `span[T]`
 - `array[T, N]`
@@ -819,9 +821,9 @@ Type constructors:
 - `fn(params...) -> R`
 - `proc(params...) -> R`
 - `SoA[T, N]` — Structure-of-Arrays: each struct field becomes a separate array of length `N`; access `soa[i].field` reads from column `field` at row `i`
-- `simd[T, N]` — SIMD vector: `N` numeric lanes (128 or 256 bits). Component-wise `+` `-` `*` `/` `%` `&` `|` `^` `~` `<<` `>>`. Lane access via `[i]` (compile-time index). Lowers to GCC/Clang vector extensions for portable x86/ARM vector code.
+- `simd[T, N]` — SIMD vector of `N` numeric lanes (128 or 256 bits); component-wise `+` `-` `*` `/` `%` `&` `|` `^` `~` `<<` `>>`; lane access via `[i]`. Lowers to GCC/Clang vector extensions.
 - `dyn[InterfaceName]` — runtime interface value (fat pointer: `{ void* data, void* vtable }`). Constructed via `adapt[Interface](value: ref[T])`. @see §6.
-- `atomic[T]` — atomic value for lock-free concurrent access. `T` must be a primitive integer or `bool`. Methods: `load() -> T`, `store(value: T)`, `add(value: T) -> T`, `sub(value: T) -> T`, `exchange(value: T) -> T`. All operations use sequential consistency. Lowers to C11 `_Atomic T` with `__atomic_*` builtins.
+- `atomic[T]` — lock-free atomic value (`T` = primitive integer or `bool`) with `load`/`store`/`add`/`sub`/`exchange`; sequential consistency. Lowers to C11 `_Atomic T`.
 - `(T, U)` — tuple type. Positional fields auto-named `_0`, `_1`. Named fields use `(x = T, y = U)`. Copy by value, returns supported.
 
 When a `span[T]` is expected, an addressable `array[T, N]` value may be passed directly via implicit boundary coercion. For explicit conversion, `array.as_span()` returns `span[T]` without requiring a boundary context.
@@ -1141,8 +1143,8 @@ Current compiler rejects:
 
 ### Operator and expression restrictions
 
-- `+` does not support `str`/`cstr` concatenation; use format strings or `std.str` helpers
-- `==` and `!=` are not supported on struct types; use `equal[T]`.  Variant types support `==`/`!=` (generates per-variant comparison helper).
+- `+` concatenates `str`; `cstr` and mixed `str`/`cstr` concatenation are not supported
+- `==`/`!=` on structs and variants requires all fields equality-comparable; use `equal[T]` otherwise
 - range expressions are restricted to `for`-loop iterables and range-index assignment targets
 - functions, methods, generic functions, and variant arms must be called — they are not usable as bare values
 - `read(...)` of a raw pointer requires `unsafe`

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> (the <code>+</code> operator on <code>str</code> concatenates, allocating a new heap-backed string)</td></tr>
+      <tr><td>Arithmetic</td><td><code>+ - * / %</code></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>
@@ -1149,6 +1149,25 @@ variant Result[T, E]:
     <strong>Prelude types.</strong> <code>Option[T]</code> and <code>Result[T, E]</code> are auto-imported — no <code>import</code> statement is needed. They are available in every Milk Tea source file. Their extending methods (<code>is_some</code>, <code>unwrap</code>, <code>is_success</code>, <code>map_error</code>, etc.) are always accessible.
   </div>
 
+  <h3>Struct &amp; Variant Equality</h3>
+  <p>Structs and variants support <code>==</code> and <code>!=</code> with field-wise comparison. A struct compares equal when every field compares equal; a variant compares equal when the same arm is active and its payload fields are equal. Every field must be equality-comparable (nested structs, arrays, nullable values, <code>str</code>, enums, flags, pointers, ...). Recursive variants embed cyclic fields as pointers and compare those by pointer identity. Untagged <code>union</code> fields and non-comparable types (<code>proc</code>, <code>span</code>, <code>simd</code>, <code>SoA</code>, <code>Task</code>, <code>dyn</code>) are rejected; use <code>equal[T](...)</code> there.</p>
+<div class="code-wrap">
+<button class="copy-btn" onclick="copyCode(this)">Copy</button>
+<pre><code>struct Vec2:
+    x: float
+    y: float
+
+variant Shape:
+    circle(radius: float)
+    square(side: float)
+
+function same_point(a: Vec2, b: Vec2) -&gt; bool:
+    return a == b
+
+function same_shape(a: Shape, b: Shape) -&gt; bool:
+    return a == b</code></pre>
+</div>
+
   <h3>Opaque</h3>
   <p>For C handles whose layout is unknown. Opaque types may implement interfaces, enabling constrained generics and <code>dyn</code> dispatch over C handles.</p>
 <div class="code-wrap">
@@ -1966,8 +1985,8 @@ MSG</code></pre>
       <tr><td><code>%</code> requires integer operands</td><td></td></tr>
       <tr><td>Bitwise ops require matching types</td><td>Integer or flags types</td></tr>
       <tr><td>Shift ops require integer operands</td><td></td></tr>
-      <tr><td>No implicit struct equality</td><td>Structs cannot be compared with <code>==</code>/<code>!=</code>. Use <code>equal[T](a, b)</code>. Variants <em>do</em> support <code>==</code> and <code>!=</code> with generated per-type comparison.</td></tr>
-      <tr><td>No <code>str</code>/<code>cstr</code> concatenation</td><td>Use format strings or <code>std.str</code> helpers</td></tr>
+      <tr><td>Aggregate equality requires comparable fields</td><td>Structs and variants support <code>==</code>/<code>!=</code> when every field is equality-comparable. Untagged <code>union</code> fields and non-comparable types (<code>proc</code>, <code>span</code>, <code>simd</code>, <code>SoA</code>, <code>Task</code>, <code>dyn</code>) are rejected — use <code>equal[T](a, b)</code> there. Recursive variants compare cyclic fields by pointer identity.</td></tr>
+      <tr><td>No <code>cstr</code> concatenation</td><td><code>+</code> concatenates <code>str</code>; <code>cstr</code> and mixed <code>str</code>/<code>cstr</code> are rejected</td></tr>
       <tr><td>Compile-time constant fit</td><td>Exact compile-time numeric constants (literals, <code>const</code> values) fit an explicit numeric target without a manual cast when representable exactly</td></tr>
       <tr><td>Integer-to-float at typed boundaries</td><td>A primitive integer expression may flow into an expected float type for explicit typed locals, assignments, returns, function arguments, or field initializers. Integer arithmetic stays integer arithmetic until that final boundary cast.</td></tr>
     </table>
@@ -2408,8 +2427,8 @@ import std.math  # intentionally available for downstream</code></pre>
     <li>Conditions must be <code>bool</code>; no truthy/falsy coercion</li>
     <li>Mixed signed/unsigned arithmetic requires explicit cast; non-widening integer conversions (narrowing, signed → unsigned) need explicit <code>T&lt;-value</code></li>
     <li>Enum and flags values do not implicitly coerce to backing integers</li>
-    <li><code>+</code> does not support <code>str</code>/<code>cstr</code> concatenation</li>
-    <li><code>==</code> and <code>!=</code> not supported on struct types; use <code>equal[T]</code></li>
+    <li><code>+</code> concatenates <code>str</code>; <code>cstr</code> and mixed <code>str</code>/<code>cstr</code> are not concatenable</li>
+    <li><code>==</code>/<code>!=</code> on structs and variants requires all fields equality-comparable; use <code>equal[T]</code> for non-comparable types</li>
     <li>A statement cannot begin with a binary operator (including <code>+</code>, <code>-</code>, <code>and</code>, <code>or</code>, <code>is</code>, <code>..</code>); continuation requires ending the previous line with the operator or wrapping in <code>()</code></li>
     <li>Bare function and method names are not usable as values (cannot be assigned or passed without calling). Use <code>fn(...)</code> function pointer types or <code>proc(...)</code> closures for callable values.</li>
   </ul>

data/docs/language-design.md

@@ -755,13 +755,15 @@ Explicit specialization arguments may be type references like `bytes_for[int](4)
 
 Built-in operators should match familiar C behavior where possible:
 
-- arithmetic: `+ - * / %` (the `+` operator on `str` concatenates, allocating a new heap-backed string)
+- arithmetic: `+ - * / %`
 - comparison: `== != < <= > >=`
 - boolean: `and or not`
 - bitwise: `& | ^ ~ << >>`
 
 No user-defined operator overloading.
 
+The `+` operator also concatenates two `str` values, allocating a new heap-backed string; `cstr` values are not concatenable. This is the one operator exception to the arithmetic rules, and it is described in the text-construction rule under Design rules §1.
+
 Built-in vector, matrix, and quaternion types support component-wise arithmetic with the standard operators:
 
 - Vectors (`vecN`/`ivecN`): `+`, `-`, `*` (component-wise same-type); `*`, `/` (scalar); unary `-`

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. 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.
+- string: `"hello"` (`str`). String escapes: `\n`, `\r`, `\t`, `\0`, `\"`, `\'`, `\\`; any other `\x` sequence is taken literally, and hex byte escapes (`\xNN`) are character-literal only. `str + str` concatenates (§5.3); see §12 for text-building details.
 - cstring: `c"hello"` (`cstr`)
 - heredoc string: `<<-TAG ... TAG` (`str`)
 - heredoc cstring: `c<<-TAG ... TAG` (`cstr`)
@@ -412,6 +412,60 @@ const IS_AFTER:   bool = State.running > State.idle
 
 Flags values also support bitwise operators (`|`, `&`, `^`, `~`) where both operands share the same flags type.
 
+### 3.4b Struct and variant equality
+
+Struct and variant values support `==` and `!=`. The compiler generates a
+field-wise comparison helper per compared aggregate type.
+
+Rules for structs:
+
+- Two struct values compare equal when every field compares equal, in field
+  order. Comparison is field-by-field, never a raw byte compare.
+- A struct is equality-comparable when every field is itself
+  equality-comparable: primitives, enums, flags, `str`, pointers, `ref[T]`,
+  `fn(...)`, opaque, other comparable structs, comparable variants, arrays of
+  comparable elements, and value nullables of comparable bases.
+- Untagged `union` fields and non-comparable field types (`proc`, `span`,
+  `simd`, `SoA`, `Task`, `dyn`) are rejected with a field-level error. Use
+  `equal[T](...)` for those.
+
+Rules for variants:
+
+- Two variant values compare equal when the same arm is active and every
+  payload field of that arm compares equal. No-payload arms compare by
+  discriminant only.
+- Recursive (cyclic) variants are supported: the C backend embeds cyclic
+  fields as pointers, and those fields compare by pointer identity. A
+  separately-constructed recursive value therefore compares unequal to
+  another value of identical shape.
+- Variant arm payload bindings (`match v: Token.ident as p:`) compare as
+  payload structs.
+
+General rules:
+
+- `==`/`!=` on struct and variant constants folds at compile time.
+- Comparison operands must have the same aggregate type.
+- The canonical `equal[T](...)` hook remains available for types without
+  `==` support and for custom equality semantics.
+
+Example:
+
+```mt
+struct Vec2:
+    x: float
+    y: float
+
+variant Shape:
+    circle(radius: float)
+    square(side: float)
+
+function same_point(a: Vec2, b: Vec2) -> bool:
+    return a == b
+
+function same_shape(a: Shape, b: Shape) -> bool:
+    return a == b
+```
+
 ### 3.5 Interfaces
 
 ```mt
@@ -1015,9 +1069,11 @@ Rules:
 8. `==`, `!=`
 9. `<`, `<=`, `>`, `>=`
 10. `<<`, `>>`
-11. `+`, `-` (additionally, `+` on `str` concatenates; each `+` allocates a new heap-backed `str`)
+11. `+`, `-`
 12. `*`, `/`, `%`
 
+The `+` operator also concatenates two `str` operands, producing a new heap-backed `str` (§2.3). It does not concatenate `cstr` or mixed `str`/`cstr` operands.
+
 ### 5.4 Assignment operators
 
 - `=`
@@ -1322,7 +1378,7 @@ Custom formatting hook notes:
 - `read(...)` of raw pointer requires `unsafe`
 - pointer casts require `unsafe`
 - `reinterpret[...]` requires `unsafe`, non-array concrete sized types, and equal-size source and target types.
-- variant types support `==` and `!=` (generates per-variant comparison helper)
+- struct and variant types support `==` and `!=` (generates a per-type comparison helper; see §3.4b)
 
 ## 10. Async Semantics
 
@@ -1564,8 +1620,8 @@ The compiler intentionally rejects the following patterns. These are design cons
 
 ### 13.7 Operator and expression restrictions
 
-- `+` does not support `str`/`cstr` concatenation
-- `==` and `!=` are not supported on struct types; use `equal[T]`
+- `+` concatenates `str`; `cstr` and mixed `str`/`cstr` are not concatenable
+- `==`/`!=` on structs and variants requires all fields equality-comparable; use `equal[T]` otherwise (§3.4b)
 - range expressions are restricted to `for`-loop iterables and range-index assignment targets
 - functions, methods, generic functions, and variant arms must be called — they are not usable as bare values
 - `read(...)` of a raw pointer requires `unsafe`

data/lib/milk_tea/base.rb

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

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

@@ -47,6 +47,7 @@ module MilkTea
         when IR::Binary
           return emit_string_equality_expression(expression) if string_equality_expression?(expression)
           return emit_variant_equality_expression(expression) if variant_equality_expression?(expression)
+          return emit_struct_equality_expression(expression) if struct_equality_expression?(expression)
           return emit_nullable_null_comparison(expression) if nullable_null_comparison?(expression)
 
           emit_binary_expression(expression)
@@ -181,8 +182,27 @@ module MilkTea
       end
 
       def variant_equality_helper_name(type)
-        variant = type.is_a?(Types::VariantArmPayload) ? type.variant_type : type
-        "mt_variant_eq_#{named_type_c_name(variant)}"
+        return "mt_struct_eq_#{named_type_c_name(type)}" if type.is_a?(Types::VariantArmPayload)
+
+        "mt_variant_eq_#{named_type_c_name(type)}"
+      end
+
+      def struct_equality_expression?(expression)
+        EQUALITY_OPERATORS.include?(expression.operator) && struct_equality_type?(expression.left.type)
+      end
+
+      def struct_equality_type?(type)
+        type.is_a?(Types::Struct) && !type.is_a?(Types::Union) && !type.is_a?(Types::VariantArmPayload)
+      end
+
+      def emit_struct_equality_expression(expression)
+        helper_name = struct_equality_helper_name(expression.left.type)
+        call = "#{helper_name}(#{emit_expression(expression.left)}, #{emit_expression(expression.right)})"
+        expression.operator == "!=" ? "!#{call}" : call
+      end
+
+      def struct_equality_helper_name(type)
+        "mt_struct_eq_#{named_type_c_name(type)}"
       end
 
       def nullable_value_type?(type)

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

@@ -298,41 +298,131 @@ module MilkTea
       end
 
       def uses_variant_equality_helper?
-        emitted_functions.any? { |function| function_uses_variant_equality?(function) }
+        !variant_equality_types.empty?
       end
 
-      def function_uses_variant_equality?(function)
-        function.body.any? { |statement| statement_uses_variant_equality?(statement) }
+      def uses_struct_equality_helper?
+        !struct_equality_types.empty?
       end
 
-      def statement_uses_variant_equality?(statement)
-        case statement
-        when IR::LocalDecl
-          expression_uses_variant_equality?(statement.value)
-        when IR::ExpressionStmt
-          expression_uses_variant_equality?(statement.expression)
-        when IR::ReturnStmt
-          statement.value && expression_uses_variant_equality?(statement.value)
-        when IR::Assignment
-          expression_uses_variant_equality?(statement.value)
-        when IR::IfStmt
-          expression_uses_variant_equality?(statement.condition)
-        when IR::WhileStmt
-          expression_uses_variant_equality?(statement.condition)
-        else
-          false
+      # Aggregate types (structs and variants) compared with ==/!= anywhere in
+      # the program, transitively closed over value-typed fields so nested
+      # aggregates used inside a comparison also get an equality helper.
+      def aggregate_equality_types
+        @aggregate_equality_types ||= begin
+          types = Set.new
+          emitted_functions.each do |function|
+            function.body.each do |statement|
+              statement_matches_expression_predicate?(
+                statement,
+                expression_pred: ->(expression) { collect_aggregate_equality_from_expression(expression, types) },
+              )
+            end
+          end
+          types
         end
       end
 
-      def expression_uses_variant_equality?(expression)
-        return false unless expression
+      def struct_equality_types
+        @struct_equality_types ||= aggregate_equality_types.select { |type| struct_equality_type?(type) || type.is_a?(Types::VariantArmPayload) }
+      end
+
+      def variant_equality_types
+        @variant_equality_types ||= aggregate_equality_types.select { |type| type.is_a?(Types::Variant) }
+      end
 
+      def aggregate_equality_type?(type)
+        struct_equality_type?(type) || type.is_a?(Types::Variant) || type.is_a?(Types::VariantArmPayload)
+      end
+
+      def collect_aggregate_equality_from_expression(expression, types)
         case expression
         when IR::Binary
-          EQUALITY_OPERATORS.include?(expression.operator) &&
-            (expression.left.type.is_a?(Types::Variant) || expression.left.type.is_a?(Types::VariantArmPayload))
+          collect_aggregate_equality_from_expression(expression.left, types)
+          collect_aggregate_equality_from_expression(expression.right, types)
+          if EQUALITY_OPERATORS.include?(expression.operator) && aggregate_equality_type?(expression.left.type)
+            collect_aggregate_equality_dependencies(expression.left.type, types)
+          end
         when IR::Call
-          expression.arguments.any? { |arg| expression_uses_variant_equality?(arg) }
+          collect_aggregate_equality_from_expression(expression.callee, types) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_aggregate_equality_from_expression(argument, types) }
+        when IR::Member
+          collect_aggregate_equality_from_expression(expression.receiver, types)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_aggregate_equality_from_expression(expression.receiver, types)
+          collect_aggregate_equality_from_expression(expression.index, types)
+        when IR::Unary
+          collect_aggregate_equality_from_expression(expression.operand, types)
+        when IR::Conditional
+          collect_aggregate_equality_from_expression(expression.condition, types)
+          collect_aggregate_equality_from_expression(expression.then_expression, types)
+          collect_aggregate_equality_from_expression(expression.else_expression, types)
+        when IR::ReinterpretExpr, IR::Cast, IR::AddressOf
+          collect_aggregate_equality_from_expression(expression.expression, types)
+        when IR::AggregateLiteral
+          expression.fields.each { |field| collect_aggregate_equality_from_expression(field.value, types) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_aggregate_equality_from_expression(element, types) }
+        when IR::VariantLiteral
+          expression.fields.each { |field| collect_aggregate_equality_from_expression(field.value, types) }
+        end
+        false
+      end
+
+      def collect_aggregate_equality_dependencies(type, types)
+        return if types.include?(type)
+
+        case type
+        when Types::Variant
+          types << type
+          type.arm_names.each do |arm_name|
+            (type.arm(arm_name) || {}).each_value { |field_type| collect_value_field_equality_dependencies(field_type, types) }
+          end
+        when Types::VariantArmPayload
+          types << type
+          arm_fields = type.variant_type.arm(type.arm_name) || {}
+          arm_fields.each_value { |field_type| collect_value_field_equality_dependencies(field_type, types) }
+        when Types::Struct
+          return unless struct_equality_type?(type)
+
+          types << type
+          type.fields.each_value { |field_type| collect_value_field_equality_dependencies(field_type, types) }
+        end
+      end
+
+      def collect_value_field_equality_dependencies(type, types)
+        case type
+        when Types::Nullable
+          collect_value_field_equality_dependencies(type.base, types)
+        when Types::Struct, Types::Variant
+          collect_aggregate_equality_dependencies(type, types)
+        when Types::VariantArmPayload
+          collect_aggregate_equality_dependencies(type, types)
+        when Types::GenericInstance
+          collect_value_field_equality_dependencies(array_element_type(type), types) if array_type?(type)
+        end
+      end
+
+      def aggregate_equality_needs_string_view?
+        aggregate_equality_types.any? { |type| aggregate_contains_string_view?(type) }
+      end
+
+      def aggregate_contains_string_view?(type, visiting = nil)
+        return false unless type
+        return false if visiting&.key?(type)
+
+        visiting = (visiting || {}).merge(type => true)
+        case type
+        when Types::StringView
+          true
+        when Types::Struct
+          type.fields.any? { |_name, field_type| aggregate_contains_string_view?(field_type, visiting) }
+        when Types::Variant
+          type.arm_names.any? { |arm_name| (type.arm(arm_name) || {}).any? { |_field_name, field_type| aggregate_contains_string_view?(field_type, visiting) } }
+        when Types::Nullable
+          aggregate_contains_string_view?(type.base, visiting)
+        when Types::GenericInstance
+          type.arguments.any? { |argument| aggregate_contains_string_view?(argument, visiting) }
         else
           false
         end

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

@@ -64,7 +64,10 @@ module MilkTea
       end
 
       def emit_variant_equality_helpers
-        emitted_aggregate_variants.flat_map { |variant_decl| emit_variant_equality_helper(variant_decl) }
+        variant_decls_by_linkage = (emitted_aggregate_variants + collect_generic_variant_decls).each_with_object({}) { |decl, map| map[decl.linkage_name] = decl }
+        variant_equality_types
+          .filter_map { |type| variant_decls_by_linkage[named_type_c_name(type)] }
+          .flat_map { |variant_decl| emit_variant_equality_helper(variant_decl) }
       end
 
       def emit_variant_equality_helper(variant_decl)
@@ -79,25 +82,14 @@ module MilkTea
             lines << "#{INDENT * 3}return true;"
           else
             arm.fields.each do |field|
-              field_type = field.type
-              left_expr = "left.data.#{sanitize_c_identifier(arm.name)}.#{sanitize_c_identifier(field.name)}"
-              right_expr = "right.data.#{sanitize_c_identifier(arm.name)}.#{sanitize_c_identifier(field.name)}"
-              if field_type.is_a?(Types::StringView)
-                lines << "#{INDENT * 3}if (!mt_str_equal(#{left_expr}, #{right_expr})) return false;"
-              elsif field_type.is_a?(Types::Variant)
-                lines << "#{INDENT * 3}if (!mt_variant_eq_#{named_type_c_name(field_type)}(#{left_expr}, #{right_expr})) return false;"
-              elsif field_type.is_a?(Types::Nullable)
-                if c_backend_pointer_like_type?(field_type.base)
-                  lines << "#{INDENT * 3}if (#{left_expr} != #{right_expr}) return false;"
-                else
-                  lines << "#{INDENT * 3}if (#{left_expr}.has_value != #{right_expr}.has_value) return false;"
-                  lines << "#{INDENT * 3}if (#{left_expr}.has_value && #{left_expr}.value != #{right_expr}.value) return false;"
-                end
-              elsif field_type.is_a?(Types::Primitive) || field_type.is_a?(Types::EnumBase)
-                lines << "#{INDENT * 3}if (#{left_expr} != #{right_expr}) return false;"
-              else
-                lines << "#{INDENT * 3}if (#{left_expr} != #{right_expr}) return false;"
-              end
+              emit_field_equality_guards(
+                lines,
+                "left.data.#{sanitize_c_identifier(arm.name)}.#{sanitize_c_identifier(field.name)}",
+                "right.data.#{sanitize_c_identifier(arm.name)}.#{sanitize_c_identifier(field.name)}",
+                field.type,
+                outer_c:,
+                indent: 3,
+              )
             end
             lines << "#{INDENT * 3}return true;"
           end
@@ -109,6 +101,83 @@ module MilkTea
         lines
       end
 
+      def emit_struct_equality_helpers
+        struct_decls_by_linkage = (emitted_aggregate_structs + collect_generic_struct_decls).each_with_object({}) { |decl, map| map[decl.linkage_name] = decl }
+        struct_equality_types
+          .filter_map { |type| type.is_a?(Types::VariantArmPayload) ? type : struct_decls_by_linkage[named_type_c_name(type)] }
+          .flat_map { |decl_or_type| emit_struct_equality_helper(decl_or_type) }
+      end
+
+      def emit_struct_equality_helper(struct_decl_or_type)
+        if struct_decl_or_type.is_a?(IR::StructDecl)
+          outer_c = struct_decl_or_type.linkage_name
+          fields = struct_decl_or_type.fields
+        else
+          payload = struct_decl_or_type
+          outer_c = named_type_c_name(payload)
+          arm_fields = payload.variant_type.arm(payload.arm_name) || {}
+          fields = arm_fields.map { |name, field_type| IR::Field.new(name:, type: field_type) }
+        end
+
+        lines = ["static bool mt_struct_eq_#{outer_c}(struct #{outer_c} left, struct #{outer_c} right) {"]
+        fields.each do |field|
+          emit_field_equality_guards(
+            lines,
+            "left.#{sanitize_c_identifier(field.name)}",
+            "right.#{sanitize_c_identifier(field.name)}",
+            field.type,
+            outer_c:,
+          )
+        end
+        lines << "#{INDENT}return true;"
+        lines << "}"
+        lines
+      end
+
+      def emit_field_equality_guards(lines, left, right, type, outer_c: nil, indent: 1)
+        pad = INDENT * indent
+        case type
+        when Types::StringView
+          lines << "#{pad}if (!mt_str_equal(#{left}, #{right})) return false;"
+        when Types::Variant
+          if aggregate_field_creates_cycle?(type, outer_c)
+            lines << "#{pad}if (#{left} != #{right}) return false;"
+          else
+            lines << "#{pad}if (!mt_variant_eq_#{named_type_c_name(type)}(#{left}, #{right})) return false;"
+          end
+        when Types::VariantArmPayload
+          if aggregate_field_creates_cycle?(type.variant_type, outer_c)
+            lines << "#{pad}if (#{left} != #{right}) return false;"
+          else
+            lines << "#{pad}if (!mt_struct_eq_#{named_type_c_name(type)}(#{left}, #{right})) return false;"
+          end
+        when Types::Struct
+          if aggregate_field_creates_cycle?(type, outer_c)
+            lines << "#{pad}if (#{left} != #{right}) return false;"
+          else
+            lines << "#{pad}if (!mt_struct_eq_#{named_type_c_name(type)}(#{left}, #{right})) return false;"
+          end
+        when Types::Nullable
+          if c_backend_pointer_like_type?(type.base)
+            lines << "#{pad}if (#{left} != #{right}) return false;"
+          else
+            lines << "#{pad}if (#{left}.has_value != #{right}.has_value) return false;"
+            lines << "#{pad}if (#{left}.has_value) {"
+            emit_field_equality_guards(lines, "#{left}.value", "#{right}.value", type.base, outer_c:, indent: indent + 1)
+            lines << "#{pad}}"
+          end
+        else
+          if array_type?(type)
+            count = array_length(type)
+            lines << "#{pad}for (uintptr_t index = 0; index < #{count}; index++) {"
+            emit_field_equality_guards(lines, "#{left}[index]", "#{right}[index]", array_element_type(type), outer_c:, indent: indent + 1)
+            lines << "#{pad}}"
+          else
+            lines << "#{pad}if (#{left} != #{right}) return false;"
+          end
+        end
+      end
+
       def emit_async_memory_helpers
         [
           "#define MT_ASYNC_HEADER_SIZE (sizeof(uint64_t) + sizeof(uintptr_t))",

data/lib/milk_tea/core/c_backend.rb

@@ -236,17 +236,45 @@ module MilkTea
         lines << ""
       end
 
+      if uses_variant_equality_helper? || uses_struct_equality_helper?
+        lines.concat(emit_aggregate_equality_forward_declarations)
+        lines << ""
+      end
       if uses_variant_equality_helper?
         unless uses_str_equality_helper?
-          variant_needs_str_eq = emitted_aggregate_variants.any? { |v| v.arms.any? { |a| a.fields.any? { |f| f.type.is_a?(Types::StringView) } } }
-          if variant_needs_str_eq
-            lines.concat(emit_string_type) unless uses_string_view?
-            lines.concat(emit_str_equality_helper)
-          end
+          emit_str_equality_support(lines) if aggregate_equality_needs_string_view?
         end
         lines.concat(emit_variant_equality_helpers)
         lines << ""
       end
+      if uses_struct_equality_helper?
+        unless uses_str_equality_helper?
+          emit_str_equality_support(lines) if aggregate_equality_needs_string_view?
+        end
+        lines.concat(emit_struct_equality_helpers)
+        lines << ""
+      end
+    end
+
+    def emit_aggregate_equality_forward_declarations
+      lines = []
+      struct_equality_types.each do |type|
+        c = named_type_c_name(type)
+        lines << "static bool mt_struct_eq_#{c}(struct #{c} left, struct #{c} right);"
+      end
+      variant_equality_types.each do |type|
+        c = named_type_c_name(type)
+        lines << "static bool mt_variant_eq_#{c}(struct #{c} left, struct #{c} right);"
+      end
+      lines
+    end
+
+    def emit_str_equality_support(lines)
+      return if @emitted_aggregate_str_equality_support
+
+      @emitted_aggregate_str_equality_support = true
+      lines.concat(emit_string_type) unless uses_string_view?
+      lines.concat(emit_str_equality_helper)
     end
 
     def emit_function_forward_declarations(lines)

data/lib/milk_tea/core/compile_time.rb

@@ -31,10 +31,35 @@ module MilkTea
       return left == right if left.is_a?(String) && right.is_a?(String)
       return left == right if boolean_value?(left) && boolean_value?(right)
       return left == right if left.is_a?(Types::Base) && right.is_a?(Types::Base)
+      return struct_equality_result(left, right) if left.is_a?(Hash) && right.is_a?(Hash)
+      return variant_equality_result(left, right) if left.is_a?(VariantValue) && right.is_a?(VariantValue)
 
       nil
     end
 
+    # Const-time struct values are represented as {field_name => value} hashes;
+    # compare them field by field, mirroring the runtime struct == semantics.
+    def self.struct_equality_result(left, right)
+      return nil unless left.is_a?(Hash) && right.is_a?(Hash)
+      return nil unless left.keys.sort == right.keys.sort
+
+      left.each do |name, value|
+        field_result = equality_result(value, right[name])
+        return nil if field_result.nil?
+        return false if field_result == false
+      end
+      true
+    end
+
+    # Const-time variant values; fields mirror the runtime arm payload layout.
+    VariantValue = Data.define(:arm, :fields)
+
+    def self.variant_equality_result(left, right)
+      return false unless left.arm == right.arm
+
+      struct_equality_result(left.fields, right.fields)
+    end
+
     def self.boolean_value?(value)
       value == true || value == false
     end

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

@@ -78,6 +78,14 @@ module MilkTea
             IR::AggregateField.new(name:, value: lower_const_value_literal(field_type, field_value))
           end
           IR::AggregateLiteral.new(type:, fields:)
+        when CompileTime::VariantValue
+          arm_field_types = type.respond_to?(:arm) ? (type.arm(const_value.arm) || {}) : {}
+          fields = const_value.fields.map do |field_name, field_value|
+            field_type = arm_field_types[field_name]
+            raise LoweringError.new("constant variant arm #{const_value.arm} field #{field_name} not found in #{type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless field_type
+            IR::AggregateField.new(name: field_name, value: lower_const_value_literal(field_type, field_value))
+          end
+          IR::VariantLiteral.new(type:, arm_name: const_value.arm, fields:)
         else
           raise LoweringError.new("unsupported const value type #{const_value.class}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end

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

@@ -270,10 +270,19 @@ module MilkTea
 
         if expected_type.is_a?(Types::Primitive) && expected_type.integer? &&
            value_fits_integer_type?(expression.value, expected_type)
-          expected_type
-        else
-          @ctx.types.fetch("int")
+          return expected_type
         end
+
+        # A bare literal (no suffix, no fitting expected type) picks the
+        # narrowest fixed-width type that holds its value: int -> long -> ulong.
+        # Falling through to int unconditionally emitted overflowing C
+        # (e.g. `int32_t x = 2147483648;`).
+        ["int", "long", "ulong"].each do |name|
+          candidate = @ctx.types.fetch(name)
+          return candidate if value_fits_integer_type?(expression.value, candidate)
+        end
+
+        raise_sema_error("integer literal #{expression.value} does not fit in any integer type", expression)
       end
 
       INTEGER_SUFFIX_TYPES = {
@@ -300,11 +309,23 @@ module MilkTea
           @ctx.types.fetch("double")
         elsif expected_type.is_a?(Types::Primitive) && expected_type.float?
           expected_type
-        else
+        elsif float_literal_fits_in_float?(expression.value)
           @ctx.types.fetch("float")
+        else
+          # A bare float literal beyond float32 range would silently overflow
+          # to infinity in C (`float x = 1e40`); promote to double instead.
+          @ctx.types.fetch("double")
         end
       end
 
+      FLOAT32_MAX_MAGNITUDE = 3.4028234663852886e+38
+
+      def float_literal_fits_in_float?(value)
+        return false unless value.is_a?(Numeric) && value.finite?
+
+        value.abs <= FLOAT32_MAX_MAGNITUDE
+      end
+
       def infer_identifier(expression, scopes:, expected_type: nil)
         binding = lookup_value(expression.name, scopes)
         if binding
@@ -662,8 +683,16 @@ module MilkTea
         when "==", "!="
           unless c_natively_equality_comparable_type?(left_type) && c_natively_equality_comparable_type?(right_type)
             bad_type = c_natively_equality_comparable_type?(right_type) ? left_type : right_type
-            if struct_instance_type?(bad_type)
-              raise_sema_error("operator #{expression.operator} is not supported for struct type #{bad_type}; use equal[#{bad_type}](...) instead")
+            if bad_type.is_a?(Types::Union)
+              raise_sema_error("operator #{expression.operator} is not supported for union type #{bad_type}; use equal[#{bad_type}](...) instead")
+            elsif bad_type.is_a?(Types::Variant)
+              field = first_non_equality_comparable_variant_field(bad_type)
+              field_hint = field ? " (arm '#{field[0]}' field '#{field[1]}' of type #{field[2]} is not equality-comparable)" : ""
+              raise_sema_error("operator #{expression.operator} is not supported for variant type #{bad_type}#{field_hint}; use equal[#{bad_type}](...) instead")
+            elsif struct_instance_type?(bad_type) && !bad_type.is_a?(Types::Variant)
+              field = first_non_equality_comparable_field(bad_type)
+              field_hint = field ? " (field '#{field.first}' of type #{field.last} is not equality-comparable)" : ""
+              raise_sema_error("operator #{expression.operator} is not supported for struct type #{bad_type}#{field_hint}; use equal[#{bad_type}](...) instead")
             else
               raise_sema_error("operator #{expression.operator} is not supported for type #{bad_type}")
             end

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

@@ -902,23 +902,65 @@ module MilkTea
         type.is_a?(Types::Struct) || type.is_a?(Types::Variant)
       end
 
-      def c_natively_equality_comparable_type?(type)
+      def c_natively_equality_comparable_type?(type, visiting = nil)
         return true if type.is_a?(Types::Primitive)
         return true if type.is_a?(Types::EnumBase)
         return true if type.is_a?(Types::Opaque)
-        return true if type.is_a?(Types::Nullable)
+        return true if type.is_a?(Types::Nullable) && equality_comparable_field_type?(type.base, visiting)
         return true if type.is_a?(Types::Null)
         return true if type.is_a?(Types::Function)
         return true if type.is_a?(Types::Error)
         return true if type.is_a?(Types::StringView)
         return true if pointer_type?(type)
         return true if ref_type?(type)
-        return true if type.is_a?(Types::Variant)
+        return true if type.is_a?(Types::Variant) && equality_comparable_variant_type?(type, visiting)
         return true if type.is_a?(Types::VariantArmPayload)
+        return true if equality_comparable_struct_type?(type, visiting)
+
+        false
+      end
+
+      # A struct value is equality-comparable with ==/!= when every field is
+      # itself equality-comparable. Untagged unions are excluded because their
+      # active-field comparison is ambiguous.
+      def equality_comparable_struct_type?(type, visiting = nil)
+        type.is_a?(Types::Struct) && !type.is_a?(Types::Union) &&
+          type.fields.all? { |_name, field_type| equality_comparable_field_type?(field_type, visiting) }
+      end
+
+      def equality_comparable_field_type?(type, visiting = nil)
+        return true if c_natively_equality_comparable_type?(type, visiting)
+        return true if array_type?(type) && equality_comparable_field_type?(array_element_type(type), visiting)
 
         false
       end
 
+      # A variant is equality-comparable when every arm payload field is itself
+      # equality-comparable. A variant that reaches itself through value fields
+      # (a recursive/cyclic variant) is comparable too: the C backend embeds
+      # cyclic fields as pointers, and those fields compare by pointer identity.
+      def equality_comparable_variant_type?(type, visiting = nil)
+        return true if visiting&.key?(type)
+
+        visiting = (visiting || {}).merge(type => true)
+        type.arm_names.all? do |arm_name|
+          (type.arm(arm_name) || {}).all? { |_field_name, field_type| equality_comparable_field_type?(field_type, visiting) }
+        end
+      end
+
+      def first_non_equality_comparable_field(struct_type)
+        struct_type.fields.find { |_name, field_type| !equality_comparable_field_type?(field_type) }
+      end
+
+      def first_non_equality_comparable_variant_field(variant_type)
+        variant_type.arm_names.each do |arm_name|
+          (variant_type.arm(arm_name) || {}).each do |field_name, field_type|
+            return [arm_name, field_name, field_type] unless equality_comparable_field_type?(field_type)
+          end
+        end
+        nil
+      end
+
       def collection_loop_type(type)
         super
       end

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

@@ -301,7 +301,12 @@ module MilkTea
             end
 
             if (receiver_type = resolve_type_expression(member_access_expression.receiver))
-              next resolve_enum_member_const_value(receiver_type, member_access_expression.member)
+              if receiver_type.is_a?(Types::EnumBase)
+                next resolve_enum_member_const_value(receiver_type, member_access_expression.member)
+              end
+              if receiver_type.is_a?(Types::Variant)
+                next CompileTime::VariantValue.new(arm: member_access_expression.member, fields: {})
+              end
             end
 
             next unless member_access_expression.receiver.is_a?(AST::Identifier)
@@ -321,6 +326,31 @@ module MilkTea
 
       def evaluate_compile_time_call(expression, scopes: nil)
         case expression.callee
+        when AST::MemberAccess
+          if (receiver_type = resolve_type_expression(expression.callee.receiver)) && receiver_type.is_a?(Types::Variant)
+            arm_name = expression.callee.member
+            fields = {}
+            expression.arguments.each do |argument|
+              val = CompileTime.evaluate(argument.value, resolve_identifier: lambda { |id|
+                if scopes
+                  binding = lookup_value(id.name, scopes)
+                  return binding.const_value unless binding&.const_value.nil?
+                end
+                resolve_current_module_const_value(id.name)
+              }, resolve_member_access: lambda { |ma|
+                if (member_receiver_type = resolve_type_expression(ma.receiver))
+                  next resolve_enum_member_const_value(member_receiver_type, ma.member) if member_receiver_type.is_a?(Types::EnumBase)
+                  next CompileTime::VariantValue.new(arm: ma.member, fields: {}) if member_receiver_type.is_a?(Types::Variant)
+                end
+                nil
+              }, resolve_call: lambda { |inner_call|
+                evaluate_compile_time_call(inner_call, scopes:)
+              })
+              return nil unless val
+              fields[argument.name] = val
+            end
+            return CompileTime::VariantValue.new(arm: arm_name, fields: fields)
+          end
         when AST::Identifier
           if (struct_type = @ctx.types[expression.callee.name]) && struct_type.is_a?(Types::Struct)
             fields = {}

metadata

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