why does golang nil pointer dereference happen in submethods

I have this code

package main

import "fmt"

type Foo struct {
	Bar string
}

func (f *Foo) level4() {
	fmt.Printf("Bar = %s\n", f.Bar)
}

func (f *Foo) level3() {
	f.level4() // panics here, 2 levels down
}

func (f *Foo) level2() {
	f.level3()
}

func (f *Foo) level1() {
	f.level2()
}

type FooWrapper struct {
	foo *Foo
}

func main() {
	w := FooWrapper{}
	w.foo.level1() // expected it to panic here, since foo is nil
}

As expected, running this gives

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x47f454]

However, I expected the nil pointer dereference to happen at w.foo.level1(), since foo is nil. Instead, it calls levels 1, 2 and 3 and panics there. Why is this the case?

playground link

Why is this the case?

Because w.foo.level1() is valid statement and similarly f.level2(), f.level3(), f.level4() are also a valid statement.

try this

func (f *Foo) level1() {
    println("Hello Go")
    f.level2()
}

it will print Hello Go and call f.level2() and also see last call level 4

func (f *Foo) level4() {
    println("Hello Go 4")
    fmt.Printf("Bar = %s\n", f.Bar) 
}

it will print Hello Go 4 but panic on next line it is showing the trace or you can say origin of error

The default value of any pointer type is nil.

As you are constructing your object using

w := FooWrapper{}

The value of foo will be assigned the default nil.

To resolve the problem you should pass a value for foo.

w := FooWrapper{foo: &Foo{Bar: "bar"}}

What I usually do to prevent this issue is to make some constructor function.

func NewFooWrapper() *FooWrapper {
   return &FooWrapper{foo: &Foo{Bar: "bar"}}
}

w := NewFooWrapper()

Or in case the value of foo can't be hardcoded.

func NewFooWrapper(foo *Foo) *FooWrapper {
   return &FooWrapper{foo: foo}
}

w := NewFooWrapper(&Foo{Bar: "bar"})

This makes it more explicit from a coding point of view preventing these errors in other places of code.

You did not initialize the FooWrapper in your main function correctly. Your foo field with type *Foo is nil inside w variable type of FooWrapper because you have not assigned a value for that and the default value for a pointer type variable is nil in Go

Simple correct initialization as follows

    w := FooWrapper{
		foo: &Foo{
			Bar: "bar",
		},
	}

run in playground

output :

Bar = bar

The reason that panic doesn't come in level1(), level2(), level3() is because they are not using any Foo's fields inside those functions. And also in level4() panic occurs not because of the function call, but because it's using f.Bar in print.

In Go,

> If the concrete value inside the interface itself is nil, the method will be called with a nil receiver.

You can find a simple example for this in https://go.dev/tour/methods/12

And also you can find a great explanation for this in Go specs documentation under Calls

> A method call x.m() is valid if the method set of (the type of) x contains m and the argument list can be assigned to the parameter list of m. If x is addressable and &x's method set contains m, x.m() is shorthand for (&x).m()