using try on a function with an empty inferred errorset, within a function that does not return an error union, doesn't cause a compile error

[tgschultz]

pub fn isPtr(comptime T: type) bool {
    return std.meta.trait.is(.Pointer)(T);
}

pub fn foo(thing: anytype) !void {
    if(comptime isPtr(@TypeOf(thing))) {
        return error.IsPtr;
    }
}

pub fn main() void {
    const x = @as(usize, 10);
    
    //this causes a compile error, as it should
    //try foo(&x); 

    try foo(x); //this doesn't!
}

I believe this should cause a compile error, as an inferred empty errorset is not the same thing as no errorset.

Related: #5226

[Vexu]

Also related #1386.

[LemonBoy]

This is a side-effect of the aggressive constant-folding and the lazy analysis: ir_analyze_instruction_test_err folds the testErr instruction into a comptime-known false if the error set is empty, making the try essentially a no-op.

Removing the following lines makes the compiler emit an error for this test case (and uncovers a bunch of dead switch arms in the stdlib).

             if (!type_is_global_error_set(err_set_type))
                 err_set_type->data.error_set.err_count == 0)

Is this a good solution? IMO it's not, optimizations should not mask problems in the compiler (unless this is intended, but I highly doubt so).

[nektro]

correct behavior imo