Commit 1bf16b1723445ba307ca556dc050d6d13bb0ebff | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-07-22 23:18:47-07:00
committer	GitHub <noreply@github.com> 2023-07-22 23:18:47-07:00
log	1bf16b1723445ba307ca556dc050d6d13bb0ebff
tree	88c1eddc872ff02e0e3d0ac0a2b93a0a66a602c1
parent	1ae839cd248c9eee8a9ff0643d7b80628f5f5533
parent	c804abc7f6948a14e806104dd5ded6cabc5665be
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #16495 from ziglang/bun

fix recent compiler regressions found when compiling bun

3 files changed, 67 insertions(+), 34 deletions(-)

src/Sema.zig+63-31

 @@ -30706,6 +30706,41 @@ fn analyzeIsNonErrComptimeOnly(
     const set_ty = ip.errorUnionSet(operand_ty.toIntern());
     switch (set_ty) {
         .anyerror_type => {},
+        .adhoc_inferred_error_set_type => if (sema.fn_ret_ty_ies) |ies| blk: {
+            // If the error set is empty, we must return a comptime true or false.
+            // However we want to avoid unnecessarily resolving an inferred error set
+            // in case it is already non-empty.
+            switch (ies.resolved) {
+                .anyerror_type => break :blk,
+                .none => {},
+                else => |i| if (ip.indexToKey(i).error_set_type.names.len != 0) break :blk,
+            }
+            if (maybe_operand_val != null) break :blk;
+            // Try to avoid resolving inferred error set if possible.
+            if (ies.errors.count() != 0) return .none;
+            switch (ies.resolved) {
+                .anyerror_type => return .none,
+                .none => {},
+                else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) {
+                    0 => return .bool_true,
+                    else => return .none,
+                },
+            }
+            for (ies.inferred_error_sets.keys()) |other_ies_index| {
+                if (set_ty == other_ies_index) continue;
+                const other_resolved =
+                    try sema.resolveInferredErrorSet(block, src, other_ies_index);
+                if (other_resolved == .anyerror_type) {
+                    ies.resolved = .anyerror_type;
+                    return .none;
+                }
+                if (ip.indexToKey(other_resolved).error_set_type.names.len != 0)
+                    return .none;
+            }
+            return .bool_true;
+        },
         else => switch (ip.indexToKey(set_ty)) {
             .error_set_type => |error_set_type| {
                 if (error_set_type.names.len == 0) return .bool_true;
 @@ -30719,41 +30754,38 @@ fn analyzeIsNonErrComptimeOnly(
                     .none => {},
                     else => |i| if (ip.indexToKey(i).error_set_type.names.len != 0) break :blk,
                 }
-                if (maybe_operand_val == null) {
+                if (maybe_operand_val != null) break :blk;
-                    if (sema.fn_ret_ty_ies) |ies| {
+                if (sema.fn_ret_ty_ies) |ies| {
-                        if (set_ty == .adhoc_inferred_error_set_type or
+                    if (ies.func == func_index) {
-                            ies.func == func_index)
+                        // Try to avoid resolving inferred error set if possible.
-                        {
+                        if (ies.errors.count() != 0) return .none;
-                            // Try to avoid resolving inferred error set if possible.
+                        switch (ies.resolved) {
-                            if (ies.errors.count() != 0) return .none;
+                            .anyerror_type => return .none,
-                            switch (ies.resolved) {
+                            .none => {},
-                                .anyerror_type => return .none,
+                            else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) {
-                                .none => {},
+                                0 => return .bool_true,
-                                else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) {
+                                else => return .none,
-                                    0 => return .bool_true,
+                            },
-                                    else => return .none,
+                        }
-                                },
+                        for (ies.inferred_error_sets.keys()) |other_ies_index| {
-                            }
+                            if (set_ty == other_ies_index) continue;
-                            for (ies.inferred_error_sets.keys()) |other_ies_index| {
+                            const other_resolved =
-                                if (set_ty == other_ies_index) continue;
+                                try sema.resolveInferredErrorSet(block, src, other_ies_index);
-                                const other_resolved =
+                            if (other_resolved == .anyerror_type) {
-                                    try sema.resolveInferredErrorSet(block, src, other_ies_index);
+                                ies.resolved = .anyerror_type;
-                                if (other_resolved == .anyerror_type) {
+                                return .none;
-                                    ies.resolved = .anyerror_type;
-                                    return .none;
-                                }
-                                if (ip.indexToKey(other_resolved).error_set_type.names.len != 0)
-                                    return .none;
                             }
-                            return .bool_true;
+                            if (ip.indexToKey(other_resolved).error_set_type.names.len != 0)
+                                return .none;
                         }
-                    }
-                    const resolved_ty = try sema.resolveInferredErrorSet(block, src, set_ty);
-                    if (resolved_ty == .anyerror_type)
-                        break :blk;
-                    if (ip.indexToKey(resolved_ty).error_set_type.names.len == 0)
                         return .bool_true;
+                    }
                 }
+                const resolved_ty = try sema.resolveInferredErrorSet(block, src, set_ty);
+                if (resolved_ty == .anyerror_type)
+                    break :blk;
+                if (ip.indexToKey(resolved_ty).error_set_type.names.len == 0)
+                    return .bool_true;
             },
             else => unreachable,
         },

src/type.zig+2-1

src/value.zig+2-2

...	@@ -483,10 +483,10 @@ pub const Value = struct {	...	@@ -483,10 +483,10 @@ pub const Value = struct {
483	}	483	}
484		484
485	pub fn getFunction(val: Value, mod: *Module) ?InternPool.Key.Func {	485	pub fn getFunction(val: Value, mod: *Module) ?InternPool.Key.Func {
486	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	486	return if (val.ip_index != .none) switch (mod.intern_pool.indexToKey(val.toIntern())) {
487	.func => \|x\| x,	487	.func => \|x\| x,
488	else => null,	488	else => null,
489	};	489	} else null;
490	}	490	}
491		491
492	pub fn getExternFunc(val: Value, mod: *Module) ?InternPool.Key.ExternFunc {	492	pub fn getExternFunc(val: Value, mod: *Module) ?InternPool.Key.ExternFunc {

...	@@ -2065,7 +2065,7 @@ pub const Type = struct {	...	@@ -2065,7 +2065,7 @@ pub const Type = struct {
2065	pub fn errorSetIsEmpty(ty: Type, mod: *Module) bool {	2065	pub fn errorSetIsEmpty(ty: Type, mod: *Module) bool {
2066	const ip = &mod.intern_pool;	2066	const ip = &mod.intern_pool;
2067	return switch (ty.toIntern()) {	2067	return switch (ty.toIntern()) {
2068	.anyerror_type => false,	2068	.anyerror_type, .adhoc_inferred_error_set_type => false,
2069	else => switch (ip.indexToKey(ty.toIntern())) {	2069	else => switch (ip.indexToKey(ty.toIntern())) {
2070	.error_set_type => \|error_set_type\| error_set_type.names.len == 0,	2070	.error_set_type => \|error_set_type\| error_set_type.names.len == 0,
2071	.inferred_error_set_type => \|i\| switch (ip.funcIesResolved(i).*) {	2071	.inferred_error_set_type => \|i\| switch (ip.funcIesResolved(i).*) {
...	@@ -2084,6 +2084,7 @@ pub const Type = struct {	...	@@ -2084,6 +2084,7 @@ pub const Type = struct {
2084	const ip = &mod.intern_pool;	2084	const ip = &mod.intern_pool;
2085	return switch (ty.toIntern()) {	2085	return switch (ty.toIntern()) {
2086	.anyerror_type => true,	2086	.anyerror_type => true,
		2087	.adhoc_inferred_error_set_type => false,
2087	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2088	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {
2088	.inferred_error_set_type => \|i\| ip.funcIesResolved(i).* == .anyerror_type,	2089	.inferred_error_set_type => \|i\| ip.funcIesResolved(i).* == .anyerror_type,
2089	else => false,	2090	else => false,