a) why it is calling main.(*Array[go.shape.struct {}]).method(SB) instead concrete type main.(*Array[main.myVal]).method?

The implementation of your method is in the shaped version. The concrete type version is just a wrapper which calls into the shape version. (That call may be inlined in some cases, so the implementation of your method may be in the concrete type version, but only when your method body is small.)

The wrapper exists mostly for method tables, to inject a dictionary argument before calling into the shaped method.

b) main.(*Array[go.shape.struct {}]).method doesn't exploit knowledge of concrete type (myVal) and performs indirect call to GetValue():

Right. The shaped method is intended to handle all instantiations with the same-shaped argument. So if you had a type myVal2 struct{} with a different GetValue method, the same main.(*Array[go.shape.struct {}]).method would work for it as well.

c) what is even more stranger, compiler generates unused concrete type main.(*Array[main.myVal]).method but it doesn't exploit type knowledge as well and instead calls main.(*Array[go.shape.struct {}]).method(SB):

Yes, that's unused here. It's only a wrapper intended for method tables, like if you put myVal into a non-empty interface that has a GetValue method.

See https://go.googlesource.com/proposal/+/refs/heads/master/design/generics-implementation-gcshape.md for gory details.

I'm going to close this, as it is working as intended. Changes to this implementation would require more than just a bug.

@randall77 but what can be smaller than this method which doesn't get inlined?

func (_ myVal) GetValue() int {
        return 5
}

The inlining that could happen is main.(*Array[go.shape.struct {}]).method into main.(*Array[main.myVal]).method.
myVal.GetValue would not get inlined into main.(*Array[go.shape.struct {}]).method because the callsite is indirect, as you noticed.