You can get all of this information by calling runtime.Caller.

We could choose to implement runtime.Caller directly in the compiler if that seems to be useful.

i think if the string generated at compile time (then sent to the other function) would be more efficient than inspecting stack trace at runtime.

I'm saying that if this seems important then we could implement runtime.Caller in the compiler such that the string is determined at compile time.

It's not obvious to me that we need two different ways to get the same information.

but i'm really not sure if we could get info about the caller at compile time '__')

The compiler can trivially compute the file and line results of runtime.Caller(0) at compile time.

It takes a little more work to trace the PC result passed into runtime.FuncForPC, but that too is doable.

I mean, if there's function A and B that calls function C, wouldn't that be require runtime instead of compile time?

func A() { C() }
func B() { C() }
func C() { can be A or B }

also if using __SOURCE__ it's more controllable, since we could do something like this:

func A() { B(__SOURCE__) }
func X() { B(__SOURCE__) }
func B(src) { C(src) }
func C(src) { use the src } // which can be A or X

runtime.Caller is expensive
in Performance-sensitive case
__FILE__ __LINE__ is a better way

There's an element of this that isn't only about performance. This would be helpful for quick insert print style debugging. I know we have delve and other tools, but sometimes print style debugging ftw.

The fact that runtime.Caller returns multiple values makes this a little inconvenient because it can't be inlined into the fmt.Printf, but a scope fixes that.

func A() {
	{
		_, file, line, _ := runtime.Caller(0)
		fmt.Printf("%s:%d i was here", file, line)
	}
	// ...
	{
		_, file, line, _ := runtime.Caller(0)
		fmt.Printf("%s:%d i was here", file, line)
	}
	// ...
}

__FILE__ and __LINE__ constants would be more convenient.

func A() {
	fmt.Printf("%s:%d i was here", __FILE__, __LINE__)
	// ...
	fmt.Printf("%s:%d i was here", __FILE__, __LINE__)
	// ...
}

I'm not sure this is compelling enough, but I know I'd definitely use it if it existed.