mt-lang 0.3.30 → 0.3.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6d13cde9fca875b324ff3e0cb3b892c371e2445ac5e061d138bd0dc8b284b88
-  data.tar.gz: 2a91eedc02120e0d042bc6bafbfc783a4eefb5bbc44c34940e1ee9be6917405e
+  metadata.gz: 0210a7132e7230d11f390c51bf60c7ff5a19b0d7716737b3ed5ac89b4a773842
+  data.tar.gz: 54d1170e9f9630b6747062b2ee8d285cb3b8cb83f5399469ba3b7908f81ad654
 SHA512:
-  metadata.gz: 478dc59b852c703b5cf63ce3cd77a92d6de305424c96cfa7dbeda97ed1882f2d8c52f5770893dc99a3077cb1599cbf0602c6e54b773f219ce859b8b9275c7258
-  data.tar.gz: d221d15fe3c3192ee0b10b61101f5234e8b92830f878051c6e2641aca334b7d165c9668bf410a727b4964f02d45805322044470a9e406b971ab7508650d60a00
+  metadata.gz: 2ca666aaa8bceb581fbe3a54c315127a3dbe3bb1a7a122027d9af44f96c3095d352d3f10f65f3e4d31b4992bca017eca600e7216c16a9a71ec81f1d0fb8091a7
+  data.tar.gz: 6d143563d49aae6636133feaa6bac2b0bee00e468d972c48db3d665692624341f4d5cbbe880fe9ba91aa0aec7da0c253df1facc5d4c405ddcd44778e67ca7ca9

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.32"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/bindings/bindgen/emitter.rb

@@ -76,19 +76,12 @@ module MilkTea
           fields = Array(node["inner"]).select { |child| child["kind"] == "FieldDecl" }
           fields.each do |field|
             field_type = aggregate_field_type(field, owner_name: name, aggregate_node: node)
-            mt_name, = bindgen_field_name(emitted_name(aggregate_field_name(field, aggregate_node: node)))
+            mt_name = emitted_name(aggregate_field_name(field, aggregate_node: node))
             lines << "    #{mt_name}: #{field_type}"
           end
           lines
         end
 
-        def bindgen_field_name(name)
-          name = emitted_name(name)
-          return [name, nil] unless Token::KEYWORDS.key?(name)
-
-          ["#{name}_", nil]
-        end
-
         def bindgen_param_name(name)
           name = emitted_name(name)
           return [name, nil] unless generated_binding_name_conflict?(name)

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))",