cmd/compile: fix ICE when checking implicit dot for method call

CL 414836 limited the check for implicit dot for method call enabled by
a type bound. However, the checking condition for ODOTMETH only is not
right. For example, for promoted method, we have a OXDOT node instead,
and we still have to check for implicit dot in this case.

However, if the base type and embedded types have the same method name,
e.g in issue #53419, typecheck.AddImplicitDots will be confused and
result in an ambigus selector.

To fix this, we ensure methods for the base type are computed, then only
do the implicit dot check if we can find a matched method.

Fixes #54348

Change-Id: Iefe84ff330830afe35c5daffd499824db108da23
Reviewed-on: https://go-review.googlesource.com/c/go/+/422274
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Auto-Submit: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 6fcb31b472ecb56583f26952c2e07d521f434271..5a41d2f1f0f732410dda56b9084a8f89a9bc8f1c 100644 (file)
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -1656,9 +1656,11 @@ func (g *genInst) getDictionarySym(gf *ir.Name, targs []*types.Type, isMeth bool
                                var nameNode *ir.Name
                                se := call.X.(*ir.SelectorExpr)
                                if se.X.Type().IsShape() {
-                                       // This is a method call enabled by a type bound.
                                        tparam := se.X.Type()
-                                       if call.X.Op() == ir.ODOTMETH {
+                                       // Ensure methods on all instantiating types are computed.
+                                       typecheck.CalcMethods(tparam)
+                                       if typecheck.Lookdot1(nil, se.Sel, tparam, tparam.AllMethods(), 0) != nil {
+                                               // This is a method call enabled by a type bound.
                                                // We need this extra check for method expressions,
                                                // which don't add in the implicit XDOTs.
                                                tmpse := ir.NewSelectorExpr(src.NoXPos, ir.OXDOT, se.X, se.Sel)

diff --git a/test/fixedbugs/issue54348.go b/test/fixedbugs/issue54348.go
new file mode 100644 (file)
index 0000000..15b2f75
--- /dev/null
+++ b/test/fixedbugs/issue54348.go
@@ -0,0 +1,22 @@
+// run
+
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+func main() {
+       F[T[int]]()
+}
+
+func F[X interface{ M() }]() {
+       var x X
+       x.M()
+}
+
+type T[X any] struct{ E }
+
+type E struct{}
+
+func (h E) M() {}