cmd/compile: fix instantiation of types referenced during inlining

CL 352870 added extra phase for instantiation after inlining, to take
care of the new fully-instantiated types. However, when fetching inlined
body of these types's methods, we need to allow OADDR operations on
untyped expressions, the same as what main inlining phase does.

The problem does not show up, until CL 371554, which made the compiler
do not re-typecheck while importing, thus leaving a OXDOT node to be
marked as address taken when it's not safe to do that.

Fixes #50437

Change-Id: I20076b872182c520075a4f8b84230f5bcb05b341
Reviewed-on: https://go-review.googlesource.com/c/go/+/375574
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>
Trust: Dan Scales <danscales@google.com>
Reviewed-by: Keith Randall <khr@golang.org>

src/cmd/compile/internal/gc/main.go

@@ -248,7 +248,12 @@ func Main(archInit func(*ssagen.ArchInfo)) {
 		// If any new fully-instantiated types were referenced during
 		// inlining, we need to create needed instantiations.
 		if len(typecheck.GetInstTypeList()) > 0 {
+			// typecheck.IncrementalAddrtaken must be false when loading
+			// an inlined body. See comment in typecheck.ImportedBody function.
+			old := typecheck.IncrementalAddrtaken
+			typecheck.IncrementalAddrtaken = false
 			noder.BuildInstantiations(false)
+			typecheck.IncrementalAddrtaken = old
 		}
 	}
 	noder.MakeWrappers(typecheck.Target) // must happen after inlining

src/cmd/compile/internal/typecheck/subr.go

@@ -80,7 +80,7 @@ func markAddrOf(n ir.Node) ir.Node {
 	if IncrementalAddrtaken {
 		// We can only do incremental addrtaken computation when it is ok
 		// to typecheck the argument of the OADDR. That's only safe after the
-		// main typecheck has completed.
+		// main typecheck has completed, and not loading the inlined body.
 		// The argument to OADDR needs to be typechecked because &x[i] takes
 		// the address of x if x is an array, but not if x is a slice.
 		// Note: OuterValue doesn't work correctly until n is typechecked.

test/typeparam/issue50437.dir/a.go

@@ -0,0 +1,43 @@
+// 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 a
+
+type MarshalOptions struct {
+	*typedArshalers[MarshalOptions]
+}
+
+func Marshal(in interface{}) (out []byte, err error) {
+	return MarshalOptions{}.Marshal(in)
+}
+
+func (mo MarshalOptions) Marshal(in interface{}) (out []byte, err error) {
+	err = mo.MarshalNext(in)
+	return nil, err
+}
+
+func (mo MarshalOptions) MarshalNext(in interface{}) error {
+	a := new(arshaler)
+	a.marshal = func(MarshalOptions) error { return nil }
+	return a.marshal(mo)
+}
+
+type arshaler struct {
+	marshal func(MarshalOptions) error
+}
+
+type typedArshalers[Options any] struct {
+	m M
+}
+
+func (a *typedArshalers[Options]) lookup(fnc func(Options) error) (func(Options) error, bool) {
+	a.m.Load(nil)
+	return fnc, false
+}
+
+type M struct {}
+
+func (m *M) Load(key any) (value any, ok bool) {
+	return
+}

test/typeparam/issue50437.dir/b.go

@@ -0,0 +1,11 @@
+// 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 b
+
+import "./a"
+
+func f() {
+	a.Marshal(map[int]int{})
+}

test/typeparam/issue50437.go

@@ -0,0 +1,7 @@
+// compiledir -G=3
+
+// Copyright 2021 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 ignored