Commit d9742acc232a2af4f98e0fbb9f749737a126e6d1 | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-06-29 17:53:52-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-06-29 17:53:52-07:00
log	d9742acc232a2af4f98e0fbb9f749737a126e6d1
tree	e8e28732fab6a70ca261dbb13654be44a202881e
parent	7999374b21795a7b8fac7af0b2e326d39bd1e839

Sema: detect one-possible-value types after function calls

produces better Air for backends

2 files changed, 28 insertions(+), 15 deletions(-)

src
- Air.zig
- Sema.zig

src/Air.zig+15-7

 @@ -1141,6 +1141,20 @@ pub const Inst = struct {
         pub fn toType(ref: Ref) Type {
             return .fromInterned(ref.toInterned().?);
         }
+        pub fn fromIntern(ip_index: InternPool.Index) Ref {
+            return switch (ip_index) {
+                .none => .none,
+                else => {
+                    assert(@intFromEnum(ip_index) >> 31 == 0);
+                    return @enumFromInt(@as(u31, @intCast(@intFromEnum(ip_index))));
+                },
+            };
+        }
+        pub fn fromValue(v: Value) Ref {
+            return .fromIntern(v.toIntern());
+        }
     };
     /// All instructions have an 8-byte payload, which is contained within
 @@ -1754,13 +1768,7 @@ pub fn deinit(air: *Air, gpa: std.mem.Allocator) void {
 }
 pub fn internedToRef(ip_index: InternPool.Index) Inst.Ref {
-    return switch (ip_index) {
+    return .fromIntern(ip_index);
-        .none => .none,
-        else => {
-            assert(@intFromEnum(ip_index) >> 31 == 0);
-            return @enumFromInt(@as(u31, @intCast(@intFromEnum(ip_index))));
-        },
-    };
 }
 /// Returns `null` if runtime-known.

src/Sema.zig+13-8

...	@@ -8060,7 +8060,7 @@ fn analyzeCall(	...	@@ -8060,7 +8060,7 @@ fn analyzeCall(
8060	};	8060	};
8061		8061
8062	try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).@"struct".fields.len + runtime_args.len);	8062	try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).@"struct".fields.len + runtime_args.len);
8063	const result = try block.addInst(.{	8063	const maybe_opv = try block.addInst(.{
8064	.tag = call_tag,	8064	.tag = call_tag,
8065	.data = .{ .pl_op = .{	8065	.data = .{ .pl_op = .{
8066	.operand = runtime_func,	8066	.operand = runtime_func,
...	@@ -8072,7 +8072,7 @@ fn analyzeCall(	...	@@ -8072,7 +8072,7 @@ fn analyzeCall(
8072	sema.appendRefsAssumeCapacity(runtime_args);	8072	sema.appendRefsAssumeCapacity(runtime_args);
8073		8073
8074	if (ensure_result_used) {	8074	if (ensure_result_used) {
8075	try sema.ensureResultUsed(block, sema.typeOf(result), call_src);	8075	try sema.ensureResultUsed(block, sema.typeOf(maybe_opv), call_src);
8076	}	8076	}
8077		8077
8078	if (call_tag == .call_always_tail) {	8078	if (call_tag == .call_always_tail) {
...	@@ -8082,10 +8082,10 @@ fn analyzeCall(	...	@@ -8082,10 +8082,10 @@ fn analyzeCall(
8082	.pointer => func_or_ptr_ty.childType(zcu),	8082	.pointer => func_or_ptr_ty.childType(zcu),
8083	else => unreachable,	8083	else => unreachable,
8084	};	8084	};
8085	return sema.handleTailCall(block, call_src, runtime_func_ty, result);	8085	return sema.handleTailCall(block, call_src, runtime_func_ty, maybe_opv);
8086	}	8086	}
8087		8087
8088	if (resolved_ret_ty.toIntern() == .noreturn_type) {	8088	if (ip.isNoReturn(resolved_ret_ty.toIntern())) {
8089	const want_check = c: {	8089	const want_check = c: {
8090	if (!block.wantSafety()) break :c false;	8090	if (!block.wantSafety()) break :c false;
8091	if (func_val != null) break :c false;	8091	if (func_val != null) break :c false;
...	@@ -8099,6 +8099,11 @@ fn analyzeCall(	...	@@ -8099,6 +8099,11 @@ fn analyzeCall(
8099	return .unreachable_value;	8099	return .unreachable_value;
8100	}	8100	}
8101		8101
		8102	const result: Air.Inst.Ref = if (try sema.typeHasOnePossibleValue(sema.typeOf(maybe_opv))) \|opv\|
		8103	.fromValue(opv)
		8104	else
		8105	maybe_opv;
		8106
8102	return result;	8107	return result;
8103	}	8108	}
8104		8109
...	@@ -8335,7 +8340,7 @@ fn analyzeCall(	...	@@ -8335,7 +8340,7 @@ fn analyzeCall(
8335	break :result try sema.resolveAnalyzedBlock(block, call_src, &child_block, &inlining.merges, need_debug_scope);	8340	break :result try sema.resolveAnalyzedBlock(block, call_src, &child_block, &inlining.merges, need_debug_scope);
8336	};	8341	};
8337		8342
8338	const result: Air.Inst.Ref = if (try sema.resolveValue(result_raw)) \|result_val\| r: {	8343	const maybe_opv: Air.Inst.Ref = if (try sema.resolveValue(result_raw)) \|result_val\| r: {
8339	const val_resolved = try sema.resolveAdHocInferredErrorSet(block, call_src, result_val.toIntern());	8344	const val_resolved = try sema.resolveAdHocInferredErrorSet(block, call_src, result_val.toIntern());
8340	break :r Air.internedToRef(val_resolved);	8345	break :r Air.internedToRef(val_resolved);
8341	} else r: {	8346	} else r: {
...	@@ -8347,7 +8352,7 @@ fn analyzeCall(	...	@@ -8347,7 +8352,7 @@ fn analyzeCall(
8347	};	8352	};
8348		8353
8349	if (block.isComptime()) {	8354	if (block.isComptime()) {
8350	const result_val = (try sema.resolveValue(result)).?;	8355	const result_val = (try sema.resolveValue(maybe_opv)).?;
8351	if (want_memoize and sema.allow_memoize and !result_val.canMutateComptimeVarState(zcu)) {	8356	if (want_memoize and sema.allow_memoize and !result_val.canMutateComptimeVarState(zcu)) {
8352	_ = try pt.intern(.{ .memoized_call = .{	8357	_ = try pt.intern(.{ .memoized_call = .{
8353	.func = func_val.?.toIntern(),	8358	.func = func_val.?.toIntern(),
...	@@ -8359,10 +8364,10 @@ fn analyzeCall(	...	@@ -8359,10 +8364,10 @@ fn analyzeCall(
8359	}	8364	}
8360		8365
8361	if (ensure_result_used) {	8366	if (ensure_result_used) {
8362	try sema.ensureResultUsed(block, sema.typeOf(result), call_src);	8367	try sema.ensureResultUsed(block, sema.typeOf(maybe_opv), call_src);
8363	}	8368	}
8364		8369
8365	return result;	8370	return maybe_opv;
8366	}	8371	}
8367		8372
8368	fn handleTailCall(sema: Sema, block: Block, call_src: LazySrcLoc, func_ty: Type, result: Air.Inst.Ref) !Air.Inst.Ref {	8373	fn handleTailCall(sema: Sema, block: Block, call_src: LazySrcLoc, func_ty: Type, result: Air.Inst.Ref) !Air.Inst.Ref {