cmd/compile: copy captured dictionary var to local var

When starting a closure that needs a dictionary, copy the closure
variable to a local variable. This lets child closures capture that
dictionary variable correctly.

This is a better fix for #47684, which does not cause problems
like #47723.

Fixes #47723
Update #47684

Change-Id: Ib5d9ffc68a5142e28daa7d0d75683e7a35508540
Reviewed-on: https://go-review.googlesource.com/c/go/+/343871
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>

diff --git a/src/cmd/compile/internal/ir/name.go b/src/cmd/compile/internal/ir/name.go
index 48fe57212470a42ce24cea0a06729785138a704c..a2eec05013e1092076ec62524c1f3235bc5d1fd1 100644 (file)
--- a/src/cmd/compile/internal/ir/name.go
+++ b/src/cmd/compile/internal/ir/name.go
@@ -404,9 +404,7 @@ func CaptureName(pos src.XPos, fn *Func, n *Name) *Name {
        if n.Op() != ONAME || n.Curfn == nil {
                return n // okay to use directly
        }
-       if n.IsClosureVar() && n.Sym().Name != ".dict" {
-               // Note: capturing dictionary closure variables is ok. This makes
-               // sure the generated code is correctly optimized.
+       if n.IsClosureVar() {
                base.FatalfAt(pos, "misuse of CaptureName on closure variable: %v", n)
        }
 

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index e8eee5290e2ff21f9b9958789236f8d7e6bd5b8c..4ed1850597b7c600207a2bf7d30ca0e4ca549c09 100644 (file)
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -1087,13 +1087,25 @@ func (subst *subster) node(n ir.Node) ir.Node {
                        ir.FinishCaptureNames(oldfn.Pos(), saveNewf, newfn)
                        newfn.ClosureVars = append(newfn.ClosureVars, subst.namelist(oldfn.ClosureVars)...)
 
+                       // Copy that closure variable to a local one.
+                       // Note: this allows the dictionary to be captured by child closures.
+                       // See issue 47723.
+                       ldict := ir.NewNameAt(x.Pos(), subst.info.gf.Sym().Pkg.Lookup(".dict"))
+                       typed(types.Types[types.TUINTPTR], ldict)
+                       ldict.Class = ir.PAUTO
+                       ldict.Curfn = newfn
+                       newfn.Dcl = append(newfn.Dcl, ldict)
+                       as := ir.NewAssignStmt(x.Pos(), ldict, cdict)
+                       as.SetTypecheck(1)
+                       newfn.Body.Append(as)
+
                        // Create inst info for the instantiated closure. The dict
                        // param is the closure variable for the dictionary of the
                        // outer function. Since the dictionary is shared, use the
                        // same entries for startSubDict, dictLen, dictEntryMap.
                        cinfo := &instInfo{
                                fun:           newfn,
-                               dictParam:     cdict,
+                               dictParam:     ldict,
                                gf:            subst.info.gf,
                                gfInfo:        subst.info.gfInfo,
                                startSubDict:  subst.info.startSubDict,
@@ -1110,7 +1122,7 @@ func (subst *subster) node(n ir.Node) ir.Node {
                        outerinfo := subst.info
                        subst.info = cinfo
                        // Make sure type of closure function is set before doing body.
-                       newfn.Body = subst.list(oldfn.Body)
+                       newfn.Body.Append(subst.list(oldfn.Body)...)
                        subst.info = outerinfo
                        subst.newf = saveNewf
                        ir.CurFunc = saveNewf

diff --git a/test/typeparam/issue47723.go b/test/typeparam/issue47723.go
new file mode 100644 (file)
index 0000000..9ef6040
--- /dev/null
+++ b/test/typeparam/issue47723.go
@@ -0,0 +1,23 @@
+// run -gcflags=-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 main
+
+func f[_ any]() int {
+       var a [1]int
+       _ = func() int {
+               return func() int {
+                       return 0
+               }()
+       }()
+       return a[func() int {
+               return 0
+       }()]
+}
+
+func main() {
+       f[int]()
+}