feat: tuple syntax cutover — Tuple(...) type + .(...) value

Replace the bare-paren tuple grammar with explicit, position-unambiguous
forms, mirroring how structs work:

  type     `(A, B)`        -> `Tuple(A, B)`          (named keeps `:`)
  value    `(a, b)`        -> `.(a, b)`              (named uses `=`)
  typed    (new)           -> `Tuple(A, B).(a, b)`   (like `Point.{...}`)
  failable `-> (T, !)`     -> `-> T !`
           `-> (T1, T2, !)`-> `-> Tuple(T1, T2) !`   (channel outside Tuple)

Bare `(...)` is now grouping only, everywhere; a comma in bare parens is a
hard error with a migration hint. Grouping, function types `(A, B) -> R`,
param lists, lambdas, and match bindings are unaffected.

`Tuple(...)` is strictly a TYPE in every position (including `size_of` /
`type_info` args); a tuple VALUE comes only from `.(...)` (anonymous) or
`Tuple(...).(...)` (explicitly typed). A bare `Tuple(1, 2)` is a tuple
type with non-type elements -> rejected.

The ~110 tuple-bearing corpus files were migrated with a one-shot
AST-aware migrator (the `sx migrate` tool from the prior commit, removed
here). New examples: 0130 (new syntax), 0131 (typed construction), 1060
(named-tuple failable return). 1116 golden updated for the new hint text.

src/ir/expr_typer.zig

@@ -361,6 +361,13 @@ pub const ExprTyper = struct {
                 return self.l.target_type orelse .unresolved;
             },
             .tuple_literal => |tl| {
+                // Explicitly-typed `Tuple(A, B).( ... )`: the literal's type is
+                // the carried tuple type (preserves field names for the named
+                // form), exactly like `Name.{ ... }` infers to `Name`.
+                if (tl.type_expr) |te| {
+                    const tuple_ty = self.l.resolveTypeWithBindings(te);
+                    if (tuple_ty != .unresolved) return tuple_ty;
+                }
                 var field_types = std.ArrayList(TypeId).empty;
                 defer field_types.deinit(self.l.alloc);
                 for (tl.elements) |elem| {

src/ir/lower.zig

@@ -950,6 +950,38 @@ pub const Lowering = struct {
                 }
             }
         }
+        // A `Tuple(...)` element must denote a TYPE; a VALUE-literal element —
+        // e.g. the `1` in `Tuple(i32, 1)` — is a user error. Diagnose it loudly
+        // here (the same message the `.( ... )`-in-type path emits) BEFORE
+        // `resolveCompound` would intern a tuple carrying an `.unresolved`
+        // field. Only the unambiguous value literals are rejected: an
+        // `error_type_expr` element (`-> Tuple(A, B) !` desugaring), names,
+        // and the structural type shapes are all legitimate tuple elements.
+        if (node.data == .tuple_type_expr) {
+            for (node.data.tuple_type_expr.field_types) |ft| {
+                // A signed numeric literal (`Tuple(i32, -1)`) arrives as a
+                // `negate` unary over an int/float literal — reject it as the
+                // literal it wraps, not as a generic non-type.
+                const probe = if (ft.data == .unary_op and ft.data.unary_op.op == .negate)
+                    ft.data.unary_op.operand
+                else
+                    ft;
+                switch (probe.data) {
+                    .int_literal,
+                    .float_literal,
+                    .string_literal,
+                    .bool_literal,
+                    .null_literal,
+                    => {
+                        if (self.diagnostics) |diags| {
+                            diags.addFmt(.err, ft.span, "tuple type element is not a type (found `{s}`); a tuple used as a type must list only types, e.g. `Tuple(i32, i32)`", .{@tagName(probe.data)});
+                        }
+                        return .unresolved;
+                    },
+                    else => {},
+                }
+            }
+        }
         // Structural type shapes — `*T`, `[*]T`, `[]T`, `?T`, `[N]T`, functions,
         // PLAIN closures, and PLAIN tuples — are owned by
         // `TypeResolver.resolveCompound` (A2.3b). Element types recurse through

src/ir/lower/error.zig

@@ -323,12 +323,20 @@ pub fn buildFailableTuple(self: *Lowering, ret_ty: TypeId, value_refs: []const R
 /// dropped) for a multi-value one. Callers must pass a value-carrying
 /// tuple — a pure `-> !`'s success type is `void`, handled separately.
 pub fn failableSuccessType(self: *Lowering, op_ty: TypeId) TypeId {
-    const fields = self.module.types.get(op_ty).tuple.fields;
+    const tup = self.module.types.get(op_ty).tuple;
+    const fields = tup.fields;
     const n_vals = fields.len - 1;
     if (n_vals == 1) return fields[0];
+    // Carry the value-field names through, dropping the trailing error-slot
+    // name, so a named failable tuple `-> Tuple(x: A, y: B) !` yields a value
+    // type `(x: A, y: B)` whose `.x`/`.y` fields stay addressable.
+    const succ_names: ?[]const types.StringId = if (tup.names) |ns|
+        self.alloc.dupe(types.StringId, ns[0..n_vals]) catch unreachable
+    else
+        null;
     return self.module.types.intern(.{ .tuple = .{
         .fields = self.alloc.dupe(TypeId, fields[0..n_vals]) catch unreachable,
-        .names = null,
+        .names = succ_names,
     } });
 }
 

src/ir/lower/expr.zig

@@ -1932,6 +1932,26 @@ pub fn lowerTupleLiteral(self: *Lowering, tl: *const ast.TupleLiteral) Ref {
         if (elem.value.data == .spread_expr) has_spread = true;
     }
 
+    // Explicitly-typed construction `Tuple(A, B).( ... )`: the literal carries
+    // its tuple type, exactly like `Name.{ ... }` for structs. Resolve it and
+    // drive element lowering through it as the target tuple — the produced
+    // value equals what the anonymous `.( ... )` form yields against that type.
+    // An ambient contextual `target_type` (annotation / call slot), if present
+    // and a tuple, is honored over the explicit one only when the explicit type
+    // fails to resolve; otherwise the explicit type wins.
+    const saved_explicit_target = self.target_type;
+    var restore_explicit_target = false;
+    if (tl.type_expr) |te| {
+        const tuple_ty = self.resolveTypeWithBindings(te);
+        if (tuple_ty != .unresolved) {
+            self.target_type = tuple_ty;
+            restore_explicit_target = true;
+        }
+    }
+    defer if (restore_explicit_target) {
+        self.target_type = saved_explicit_target;
+    };
+
     // Contextual target tuple field types. Without a spread we require
     // exact arity (existing behavior); with a spread we index positionally
     // by output position (so `(..sources)` into a `(VL(T0), …)` field coerces
@@ -2771,10 +2791,14 @@ pub fn lowerExpr(self: *Lowering, node: *const Node) Ref {
         .optional_type_expr,
         .array_type_expr,
         .function_type_expr,
+        .tuple_type_expr,
         => blk: {
             const ty = self.resolveTypeWithBindings(node);
             // The resolver diagnosed any unresolved leaf; don't mint a Type
-            // value around the failure sentinel.
+            // value around the failure sentinel. For `Tuple(...)` this is also
+            // where a standalone `Tuple(1, 2)` value-expression is rejected —
+            // `resolveTupleTypeWithBindings` diagnoses the non-type element and
+            // returns `.unresolved`, so no value is fabricated.
             if (ty == .unresolved) break :blk self.emitError("unknown_expr", node.span);
             break :blk self.builder.constType(ty);
         },

src/ir/lower/generic.zig

@@ -288,6 +288,7 @@ pub fn isStaticTypeArg(self: *Lowering, node: *const Node) bool {
         .optional_type_expr,
         .function_type_expr,
         .tuple_literal,
+        .tuple_type_expr,
         .call,
         => return true,
         else => return false,
@@ -355,7 +356,7 @@ pub fn resolveTupleLiteralTypeArg(self: *Lowering, node: *const Node) TypeId {
     for (node.data.tuple_literal.elements) |el| {
         if (!type_bridge.isTypeShapedAstNode(el.value, &self.module.types)) {
             if (self.diagnostics) |diags| {
-                diags.addFmt(.err, el.value.span, "tuple type element is not a type (found `{s}`); a tuple used as a type must list only types, e.g. `(i32, i32)`", .{@tagName(el.value.data)});
+                diags.addFmt(.err, el.value.span, "tuple type element is not a type (found `{s}`); a tuple used as a type must list only types, e.g. `Tuple(i32, i32)`", .{@tagName(el.value.data)});
             }
             return .unresolved;
         }
@@ -468,6 +469,7 @@ pub fn resolveTypeArg(self: *Lowering, node: *const Node) TypeId {
         // `(COnly, i64)`) is rejected exactly as in a normal annotation, instead
         // of `type_bridge.resolveAstType`'s ungated global lookup (E4).
         .tuple_literal,
+        .tuple_type_expr,
         .pointer_type_expr,
         .many_pointer_type_expr,
         .array_type_expr,

src/ir/type_resolver.zig

@@ -254,7 +254,18 @@ pub const TypeResolver = struct {
                 for (tt.field_types) |ft| if (ft.data == .spread_expr) break :blk null;
                 var field_ids = std.ArrayList(TypeId).empty;
                 defer field_ids.deinit(table.alloc);
-                for (tt.field_types) |ft| field_ids.append(table.alloc, inner.resolveInner(ft)) catch return .unresolved;
+                for (tt.field_types) |ft| {
+                    const fid = inner.resolveInner(ft);
+                    // A non-type tuple element (e.g. the `1` in `Tuple(i32, 1)`)
+                    // resolves to `.unresolved`; never intern a tuple carrying it
+                    // — that bogus type would reach LLVM emission and panic. The
+                    // user-facing diagnostic is emitted by the literal-rejection
+                    // arm in `resolveTypeArg` (lower.zig, the `tuple_type_expr`
+                    // check); here we just refuse to fabricate the type,
+                    // propagating the sentinel up.
+                    if (fid == .unresolved) break :blk .unresolved;
+                    field_ids.append(table.alloc, fid) catch return .unresolved;
+                }
                 // Preserve field names for a named tuple `(x: T, y: U)` when the
                 // name and field counts agree (so `t.x` resolves).
                 var name_ids: ?[]const StringId = null;