concat (++) of anytype function parameter for runtime call

[trgwii]

Zig Version

0.11.0-dev.1863+a63134a4a

Steps to Reproduce and Observed Behavior

Given the following code:

const std = @import("std");

fn concat(x: anytype) []const u8 {
    return x ++ " world";
}

pub fn main() !void {
    std.debug.print("comptime: {s}\n", .{comptime concat("hello")});
    std.debug.print("runtime : {s}\n", .{concat("hello")});
    std.debug.print("inline  : {s}\n", .{@call(.always_inline, concat, .{"hello"})});
}

zig run concat.zig produces:

comptime: hello world
runtime : hellrld
inline  : hello world

zig run -O ReleaseFast concat.zig produces:

comptime: hello world
runtime : 
inline  : hello world

Expected Behavior

I would either expect a compile error complaining about ++ being used at runtime, or I would expect ++ to force comptime evaluation, and give the following output:

comptime: hello world
runtime : hello world
inline  : hello world

EDIT: I think the best option is ++ forcing comptime evaluation, so it'll compile error with "can't resolve comptime value" or whatever for actual runtime values, and just work if the value is comptime-known.

[jacobly0]

Runtime ++ creates a value on the stack which cannot be returned as a pointer. This is invalid for the same reason that dereferencing the result of the following function is:

fn f() *u32 {
    var x: u32 = 42;
    return &x;
}

[andrewrk]

related: #3180

[trgwii]

Runtime ++ creates a value on the stack which cannot be returned as a pointer. This is invalid for the same reason that dereferencing the result of the following function is:

fn f() *u32 {
    var x: u32 = 42;
    return &x;
}

But why is it a runtime ++ when both parameters are comptime-known?

[jacobly0]

Parameters are never comptime-known unless they are marked comptime, the function is called at comptime, or a value with a comptime-only type is passed to an anytype parameter. The type of a string literal is a const pointer to a zero terminated array which is not a comptime-only type (as in, you are allowed to have runtime values with that type).

[mlugg]

(they're also comptime-known if the function is marked inline and the parameter was comptime-known at the call site)

Note that the reason the operands don't have to be comptime-known here is that their lengths are known by their types, since the type passed in is e.g. *const [5:0]u8. That means the compiler can emit code to concatenate these into a local buffer at runtime, since the buffer length is known at compile time.