diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 8f45405e94..9e3cd732f0 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -1081,120 +1081,6 @@ test "comptime break operand passing through runtime switch converted to runtime
     try comptime S.doTheTest('b');
 }
 
-test "no dependency loop for alignment of self struct" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const S = struct {
-        fn doTheTest() !void {
-            var a: namespace.A = undefined;
-            a.d = .{ .g = &buf };
-            a.d.g[3] = 42;
-            a.d.g[3] += 1;
-            try expect(a.d.g[3] == 43);
-        }
-
-        var buf: [10]u8 align(@alignOf([*]u8)) = undefined;
-
-        const namespace = struct {
-            const B = struct { a: A };
-            const A = C(B);
-        };
-
-        pub fn C(comptime B: type) type {
-            return struct {
-                d: D(F) = .{},
-
-                const F = struct { b: B };
-            };
-        }
-
-        pub fn D(comptime F: type) type {
-            return struct {
-                g: [*]align(@alignOf(F)) u8 = undefined,
-            };
-        }
-    };
-    try S.doTheTest();
-}
-
-test "no dependency loop for alignment of self bare union" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const S = struct {
-        fn doTheTest() !void {
-            var a: namespace.A = undefined;
-            a.d = .{ .g = &buf };
-            a.d.g[3] = 42;
-            a.d.g[3] += 1;
-            try expect(a.d.g[3] == 43);
-        }
-
-        var buf: [10]u8 align(@alignOf([*]u8)) = undefined;
-
-        const namespace = struct {
-            const B = union { a: A, b: void };
-            const A = C(B);
-        };
-
-        pub fn C(comptime B: type) type {
-            return struct {
-                d: D(F) = .{},
-
-                const F = struct { b: B };
-            };
-        }
-
-        pub fn D(comptime F: type) type {
-            return struct {
-                g: [*]align(@alignOf(F)) u8 = undefined,
-            };
-        }
-    };
-    try S.doTheTest();
-}
-
-test "no dependency loop for alignment of self tagged union" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
-
-    const S = struct {
-        fn doTheTest() !void {
-            var a: namespace.A = undefined;
-            a.d = .{ .g = &buf };
-            a.d.g[3] = 42;
-            a.d.g[3] += 1;
-            try expect(a.d.g[3] == 43);
-        }
-
-        var buf: [10]u8 align(@alignOf([*]u8)) = undefined;
-
-        const namespace = struct {
-            const B = union(enum) { a: A, b: void };
-            const A = C(B);
-        };
-
-        pub fn C(comptime B: type) type {
-            return struct {
-                d: D(F) = .{},
-
-                const F = struct { b: B };
-            };
-        }
-
-        pub fn D(comptime F: type) type {
-            return struct {
-                g: [*]align(@alignOf(F)) u8 = undefined,
-            };
-        }
-    };
-    try S.doTheTest();
-}
-
 test "equality of pointers to comptime const" {
     const a: i32 = undefined;
     comptime assert(&a == &a);
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index e6a3558646..37dc873d60 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -1249,20 +1249,6 @@ test "store to comptime field" {
     }
 }
 
-test "struct field init value is size of the struct" {
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-
-    const namespace = struct {
-        const S = extern struct {
-            size: u8 = @sizeOf(S),
-            blah: u16,
-        };
-    };
-    var s: namespace.S = .{ .blah = 1234 };
-    _ = &s;
-    try expect(s.size == 4);
-}
-
 test "under-aligned struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -1710,41 +1696,19 @@ test "comptimeness of optional and error union payload is analyzed properly" {
     try std.testing.expectEqual(3, x);
 }
 
-test "initializer uses own alignment" {
-    const S = struct {
-        x: u32 = @alignOf(@This()) + 1,
-    };
-
-    var s: S = .{};
-    _ = &s;
-    try expectEqual(4, @alignOf(S));
-    try expectEqual(@as(usize, 5), s.x);
-}
-
-test "initializer uses own size" {
-    const S = struct {
-        x: u32 = @sizeOf(@This()) + 1,
-    };
-
-    var s: S = .{};
-    _ = &s;
-    try expectEqual(4, @sizeOf(S));
-    try expectEqual(@as(usize, 5), s.x);
-}
-
 test "initializer takes a pointer to a variable inside its struct" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
     const namespace = struct {
         const S = struct {
-            s: *S = &S.instance,
-            var instance: S = undefined;
+            x: *u32 = &S.int,
+            var int: u32 = undefined;
         };
 
         fn doTheTest() !void {
             var foo: S = .{};
             _ = &foo;
-            try expectEqual(&S.instance, foo.s);
+            try expectEqual(&S.int, foo.x);
         }
     };
 
@@ -1775,22 +1739,6 @@ test "circular dependency through pointer field of a struct" {
     try expect(outer.middle.inner == null);
 }
 
-test "field calls do not force struct field init resolution" {
-    const S = struct {
-        x: u32 = blk: {
-            _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution
-            break :blk 123;
-        },
-        dummyFn: *const fn () void = undefined,
-        fn make() @This() {
-            return .{};
-        }
-    };
-    var s: S = .{};
-    _ = &s;
-    try expect(s.x == 123);
-}
-
 test "tuple with comptime-only field" {
     const S = struct {
         fn getTuple() struct { comptime_int } {
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 9badc9dabd..b081d9b33a 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1796,55 +1796,6 @@ test "reinterpret packed union inside packed struct" {
     try S.doTheTest();
 }
 
-test "inner struct initializer uses union layout" {
-    const namespace = struct {
-        const U = union {
-            a: struct {
-                x: u32 = @alignOf(U) + 1,
-            },
-            b: struct {
-                y: u16 = @sizeOf(U) + 2,
-            },
-        };
-    };
-
-    {
-        const u: namespace.U = .{ .a = .{} };
-        try expectEqual(4, @alignOf(namespace.U));
-        try expectEqual(@as(usize, 5), u.a.x);
-    }
-
-    {
-        const u: namespace.U = .{ .b = .{} };
-        try expectEqual(@as(usize, @sizeOf(namespace.U) + 2), u.b.y);
-    }
-}
-
-test "inner struct initializer uses packed union layout" {
-    const namespace = struct {
-        const U = packed union {
-            a: packed struct {
-                x: u32 = @alignOf(U) + 1,
-            },
-            b: packed struct(u32) {
-                y: u16 = @sizeOf(U) + 2,
-                padding: u16 = 0,
-            },
-        };
-    };
-
-    {
-        const u: namespace.U = .{ .a = .{} };
-        try expectEqual(4, @alignOf(namespace.U));
-        try expectEqual(@as(usize, 5), u.a.x);
-    }
-
-    {
-        const u: namespace.U = .{ .b = .{} };
-        try expectEqual(@as(usize, @sizeOf(namespace.U) + 2), u.b.y);
-    }
-}
-
 test "extern union initialized via reintepreted struct field initializer" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;