Merge pull request #10649 from ziglang/stage2-tuples

stage2: implement tuples

1 files changed, 205 insertions, 54 deletions

diff --git a/src/Sema.zig b/src/Sema.zig
index aca844218e..d3802a1784 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2628,6 +2628,7 @@ fn validateUnionInit(
             // Otherwise, the bitcast should be preserved and a store instruction should be
             // emitted to store the constant union value through the bitcast.
         },
+        .alloc => {},
         else => |t| {
             if (std.debug.runtime_safety) {
                 std.debug.panic("unexpected AIR tag for union pointer: {s}", .{@tagName(t)});
@@ -10694,12 +10695,77 @@ fn zirArrayInit(
     }
 }
 
-fn zirArrayInitAnon(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is_ref: bool) CompileError!Air.Inst.Ref {
+fn zirArrayInitAnon(
+    sema: *Sema,
+    block: *Block,
+    inst: Zir.Inst.Index,
+    is_ref: bool,
+) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
+    const extra = sema.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
+    const operands = sema.code.refSlice(extra.end, extra.data.operands_len);
+
+    const types = try sema.arena.alloc(Type, operands.len);
+    const values = try sema.arena.alloc(Value, operands.len);
+
+    const opt_runtime_src = rs: {
+        var runtime_src: ?LazySrcLoc = null;
+        for (operands) |operand, i| {
+            const elem = sema.resolveInst(operand);
+            types[i] = sema.typeOf(elem);
+            const operand_src = src; // TODO better source location
+            if (try sema.resolveMaybeUndefVal(block, operand_src, elem)) |val| {
+                values[i] = val;
+            } else {
+                values[i] = Value.initTag(.unreachable_value);
+                runtime_src = operand_src;
+            }
+        }
+        break :rs runtime_src;
+    };
 
-    _ = is_ref;
-    return sema.fail(block, src, "TODO: Sema.zirArrayInitAnon", .{});
+    const tuple_ty = try Type.Tag.tuple.create(sema.arena, .{
+        .types = types,
+        .values = values,
+    });
+
+    const runtime_src = opt_runtime_src orelse {
+        const tuple_val = try Value.Tag.@"struct".create(sema.arena, values);
+        if (!is_ref) return sema.addConstant(tuple_ty, tuple_val);
+
+        var anon_decl = try block.startAnonDecl();
+        defer anon_decl.deinit();
+        const decl = try anon_decl.finish(
+            try tuple_ty.copy(anon_decl.arena()),
+            try tuple_val.copy(anon_decl.arena()),
+        );
+        return sema.analyzeDeclRef(decl);
+    };
+
+    if (is_ref) {
+        const alloc = try block.addTy(.alloc, tuple_ty);
+        for (operands) |operand, i_usize| {
+            const i = @intCast(u32, i_usize);
+            const field_ptr_ty = try Type.ptr(sema.arena, .{
+                .mutable = true,
+                .@"addrspace" = target_util.defaultAddressSpace(sema.mod.getTarget(), .local),
+                .pointee_type = types[i],
+            });
+            const field_ptr = try block.addStructFieldPtr(alloc, i, field_ptr_ty);
+            _ = try block.addBinOp(.store, field_ptr, sema.resolveInst(operand));
+        }
+
+        return alloc;
+    }
+
+    const element_refs = try sema.arena.alloc(Air.Inst.Ref, operands.len);
+    for (operands) |operand, i| {
+        element_refs[i] = sema.resolveInst(operand);
+    }
+
+    try sema.requireRuntimeBlock(block, runtime_src);
+    return block.addVectorInit(tuple_ty, element_refs);
 }
 
 fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -13540,10 +13606,50 @@ fn elemVal(
             // TODO: If the index is a vector, the result should be a vector.
             return elemValArray(sema, block, array, elem_index, array_src, elem_index_src);
         },
+        .Struct => {
+            // Tuple field access.
+            const index_val = try sema.resolveConstValue(block, elem_index_src, elem_index);
+            const index = @intCast(u32, index_val.toUnsignedInt());
+            return tupleField(sema, block, array, index, array_src, elem_index_src);
+        },
         else => unreachable,
     }
 }
 
+fn tupleField(
+    sema: *Sema,
+    block: *Block,
+    tuple: Air.Inst.Ref,
+    field_index: u32,
+    tuple_src: LazySrcLoc,
+    field_index_src: LazySrcLoc,
+) CompileError!Air.Inst.Ref {
+    const tuple_ty = sema.typeOf(tuple);
+    const tuple_info = tuple_ty.castTag(.tuple).?.data;
+
+    if (field_index > tuple_info.types.len) {
+        return sema.fail(block, field_index_src, "index {d} outside tuple of length {d}", .{
+            field_index, tuple_info.types.len,
+        });
+    }
+
+    const field_ty = tuple_info.types[field_index];
+    const field_val = tuple_info.values[field_index];
+
+    if (field_val.tag() != .unreachable_value) {
+        return sema.addConstant(field_ty, field_val); // comptime field
+    }
+
+    if (try sema.resolveMaybeUndefVal(block, tuple_src, tuple)) |tuple_val| {
+        if (tuple_val.isUndef()) return sema.addConstUndef(field_ty);
+        const field_values = tuple_val.castTag(.@"struct").?.data;
+        return sema.addConstant(field_ty, field_values[field_index]);
+    }
+
+    try sema.requireRuntimeBlock(block, tuple_src);
+    return block.addStructFieldVal(tuple, field_index, field_ty);
+}
+
 fn elemValArray(
     sema: *Sema,
     block: *Block,
@@ -13901,17 +14007,19 @@ fn coerce(
             else => {},
         },
         .Array => switch (inst_ty.zigTypeTag()) {
-            .Vector => return sema.coerceVectorInMemory(block, dest_ty, dest_ty_src, inst, inst_src),
+            .Vector => return sema.coerceArrayLike(block, dest_ty, dest_ty_src, inst, inst_src),
             .Struct => {
                 if (inst == .empty_struct) {
                     return arrayInitEmpty(sema, dest_ty);
                 }
+                if (inst_ty.isTuple()) {
+                    return sema.coerceTupleToArray(block, dest_ty, dest_ty_src, inst, inst_src);
+                }
             },
             else => {},
         },
         .Vector => switch (inst_ty.zigTypeTag()) {
-            .Array => return sema.coerceVectorInMemory(block, dest_ty, dest_ty_src, inst, inst_src),
-            .Vector => return sema.coerceVectors(block, dest_ty, dest_ty_src, inst, inst_src),
+            .Array, .Vector => return sema.coerceArrayLike(block, dest_ty, dest_ty_src, inst, inst_src),
             else => {},
         },
         .Struct => {
@@ -14276,12 +14384,30 @@ fn storePtr2(
     uncasted_operand: Air.Inst.Ref,
     operand_src: LazySrcLoc,
     air_tag: Air.Inst.Tag,
-) !void {
+) CompileError!void {
     const ptr_ty = sema.typeOf(ptr);
     if (ptr_ty.isConstPtr())
-        return sema.fail(block, src, "cannot assign to constant", .{});
+        return sema.fail(block, ptr_src, "cannot assign to constant", .{});
 
     const elem_ty = ptr_ty.childType();
+
+    // To generate better code for tuples, we detect a tuple operand here, and
+    // analyze field loads and stores directly. This avoids an extra allocation + memcpy
+    // which would occur if we used `coerce`.
+    const operand_ty = sema.typeOf(uncasted_operand);
+    if (operand_ty.castTag(.tuple)) |payload| {
+        const tuple_fields_len = payload.data.types.len;
+        var i: u32 = 0;
+        while (i < tuple_fields_len) : (i += 1) {
+            const elem_src = operand_src; // TODO better source location
+            const elem = try tupleField(sema, block, uncasted_operand, i, operand_src, elem_src);
+            const elem_index = try sema.addIntUnsigned(Type.usize, i);
+            const elem_ptr = try sema.elemPtr(block, ptr_src, ptr, elem_index, elem_src);
+            try sema.storePtr2(block, src, elem_ptr, elem_src, elem, elem_src, .store);
+        }
+        return;
+    }
+
     const operand = try sema.coerce(block, elem_ty, uncasted_operand, operand_src);
     if ((try sema.typeHasOnePossibleValue(block, src, elem_ty)) != null)
         return;
@@ -14847,10 +14973,8 @@ fn coerceEnumToUnion(
     return sema.failWithOwnedErrorMsg(msg);
 }
 
-/// Coerces vectors/arrays which have the same in-memory layout. This can be used for
-/// both coercing from and to vectors.
-/// TODO (affects the lang spec) delete this in favor of always using `coerceVectors`.
-fn coerceVectorInMemory(
+/// If the lengths match, coerces element-wise.
+fn coerceArrayLike(
     sema: *Sema,
     block: *Block,
     dest_ty: Type,
@@ -14860,7 +14984,7 @@ fn coerceVectorInMemory(
 ) !Air.Inst.Ref {
     const inst_ty = sema.typeOf(inst);
     const inst_len = inst_ty.arrayLen();
-    const dest_len = dest_ty.arrayLen();
+    const dest_len = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLen());
 
     if (dest_len != inst_len) {
         const msg = msg: {
@@ -14879,22 +15003,50 @@ fn coerceVectorInMemory(
     const dest_elem_ty = dest_ty.childType();
     const inst_elem_ty = inst_ty.childType();
     const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_elem_ty, inst_elem_ty, false, target, dest_ty_src, inst_src);
-    if (in_memory_result != .ok) {
-        // TODO recursive error notes for coerceInMemoryAllowed failure
-        return sema.fail(block, inst_src, "expected {}, found {}", .{ dest_ty, inst_ty });
+    if (in_memory_result == .ok) {
+        if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |inst_val| {
+            // These types share the same comptime value representation.
+            return sema.addConstant(dest_ty, inst_val);
+        }
+        try sema.requireRuntimeBlock(block, inst_src);
+        return block.addBitCast(dest_ty, inst);
     }
 
-    if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |inst_val| {
-        // These types share the same comptime value representation.
-        return sema.addConstant(dest_ty, inst_val);
+    const element_vals = try sema.arena.alloc(Value, dest_len);
+    const element_refs = try sema.arena.alloc(Air.Inst.Ref, dest_len);
+    var runtime_src: ?LazySrcLoc = null;
+
+    for (element_vals) |*elem, i| {
+        const index_ref = try sema.addConstant(
+            Type.usize,
+            try Value.Tag.int_u64.create(sema.arena, i),
+        );
+        const elem_src = inst_src; // TODO better source location
+        const elem_ref = try elemValArray(sema, block, inst, index_ref, inst_src, elem_src);
+        const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);
+        element_refs[i] = coerced;
+        if (runtime_src == null) {
+            if (try sema.resolveMaybeUndefVal(block, elem_src, coerced)) |elem_val| {
+                elem.* = elem_val;
+            } else {
+                runtime_src = elem_src;
+            }
+        }
     }
 
-    try sema.requireRuntimeBlock(block, inst_src);
-    return block.addBitCast(dest_ty, inst);
+    if (runtime_src) |rs| {
+        try sema.requireRuntimeBlock(block, rs);
+        return block.addVectorInit(dest_ty, element_refs);
+    }
+
+    return sema.addConstant(
+        dest_ty,
+        try Value.Tag.array.create(sema.arena, element_vals),
+    );
 }
 
 /// If the lengths match, coerces element-wise.
-fn coerceVectors(
+fn coerceTupleToArray(
     sema: *Sema,
     block: *Block,
     dest_ty: Type,
@@ -14919,30 +15071,15 @@ fn coerceVectors(
         return sema.failWithOwnedErrorMsg(msg);
     }
 
-    const target = sema.mod.getTarget();
-    const dest_elem_ty = dest_ty.childType();
-    const inst_elem_ty = inst_ty.childType();
-    const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_elem_ty, inst_elem_ty, false, target, dest_ty_src, inst_src);
-    if (in_memory_result == .ok) {
-        if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |inst_val| {
-            // These types share the same comptime value representation.
-            return sema.addConstant(dest_ty, inst_val);
-        }
-        try sema.requireRuntimeBlock(block, inst_src);
-        return block.addBitCast(dest_ty, inst);
-    }
-
     const element_vals = try sema.arena.alloc(Value, dest_len);
     const element_refs = try sema.arena.alloc(Air.Inst.Ref, dest_len);
-    var runtime_src: ?LazySrcLoc = null;
+    const dest_elem_ty = dest_ty.childType();
 
-    for (element_vals) |*elem, i| {
-        const index_ref = try sema.addConstant(
-            Type.usize,
-            try Value.Tag.int_u64.create(sema.arena, i),
-        );
+    var runtime_src: ?LazySrcLoc = null;
+    for (element_vals) |*elem, i_usize| {
+        const i = @intCast(u32, i_usize);
         const elem_src = inst_src; // TODO better source location
-        const elem_ref = try elemValArray(sema, block, inst, index_ref, inst_src, elem_src);
+        const elem_ref = try tupleField(sema, block, inst, i, inst_src, elem_src);
         const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);
         element_refs[i] = coerced;
         if (runtime_src == null) {
@@ -15833,19 +15970,22 @@ fn resolveStructLayout(
     ty: Type,
 ) CompileError!void {
     const resolved_ty = try sema.resolveTypeFields(block, src, ty);
-    const struct_obj = resolved_ty.castTag(.@"struct").?.data;
-    switch (struct_obj.status) {
-        .none, .have_field_types => {},
-        .field_types_wip, .layout_wip => {
-            return sema.fail(block, src, "struct {} depends on itself", .{ty});
-        },
-        .have_layout, .fully_resolved_wip, .fully_resolved => return,
-    }
-    struct_obj.status = .layout_wip;
-    for (struct_obj.fields.values()) |field| {
-        try sema.resolveTypeLayout(block, src, field.ty);
+    if (resolved_ty.castTag(.@"struct")) |payload| {
+        const struct_obj = payload.data;
+        switch (struct_obj.status) {
+            .none, .have_field_types => {},
+            .field_types_wip, .layout_wip => {
+                return sema.fail(block, src, "struct {} depends on itself", .{ty});
+            },
+            .have_layout, .fully_resolved_wip, .fully_resolved => return,
+        }
+        struct_obj.status = .layout_wip;
+        for (struct_obj.fields.values()) |field| {
+            try sema.resolveTypeLayout(block, src, field.ty);
+        }
+        struct_obj.status = .have_layout;
     }
-    struct_obj.status = .have_layout;
+    // otherwise it's a tuple; no need to resolve anything
 }
 
 fn resolveUnionLayout(
@@ -16642,6 +16782,17 @@ pub fn typeHasOnePossibleValue(
             }
             return Value.initTag(.empty_struct_value);
         },
+
+        .tuple => {
+            const tuple = ty.castTag(.tuple).?.data;
+            for (tuple.values) |val| {
+                if (val.tag() == .unreachable_value) {
+                    return null; // non-comptime field
+                }
+            }
+            return Value.initTag(.empty_struct_value);
+        },
+
         .enum_numbered => {
             const resolved_ty = try sema.resolveTypeFields(block, src, ty);
             const enum_obj = resolved_ty.castTag(.enum_numbered).?.data;