cmd/compile: restore not-in-heap check for map/channel type

CL 388538 removed unused -G=0 node types.

However, the code for checking not-in-heap types for map and channel
type was also removed, which is likely not intentional.

This CL restores the check, porting removed code to noder.

Updates #54846

Change-Id: I2995836b90e36d2684197fefc9829fddfffe8585
Reviewed-on: https://go-review.googlesource.com/c/go/+/597535
Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Keith Randall <khr@google.com>

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index a95fa03e170ed63846cfd8a0887bdd35786f945d..05f0affe8a8a4320129dfe1fe227535b35b75234 100644 (file)
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -144,6 +144,34 @@ func checkFiles(m posMap, noders []*noder) (*types2.Package, *types2.Info, map[*
        }
        base.ExitIfErrors()
 
+       // Implementation restriction: we don't allow not-in-heap types to
+       // be used as map keys/values, or channel.
+       {
+               for _, file := range files {
+                       syntax.Inspect(file, func(n syntax.Node) bool {
+                               if n, ok := n.(*syntax.TypeDecl); ok {
+                                       switch n := n.Type.(type) {
+                                       case *syntax.MapType:
+                                               typ := n.GetTypeInfo().Type.Underlying().(*types2.Map)
+                                               if isNotInHeap(typ.Key()) {
+                                                       base.ErrorfAt(m.makeXPos(n.Pos()), 0, "incomplete (or unallocatable) map key not allowed")
+                                               }
+                                               if isNotInHeap(typ.Elem()) {
+                                                       base.ErrorfAt(m.makeXPos(n.Pos()), 0, "incomplete (or unallocatable) map value not allowed")
+                                               }
+                                       case *syntax.ChanType:
+                                               typ := n.GetTypeInfo().Type.Underlying().(*types2.Chan)
+                                               if isNotInHeap(typ.Elem()) {
+                                                       base.ErrorfAt(m.makeXPos(n.Pos()), 0, "chan of incomplete (or unallocatable) type not allowed")
+                                               }
+                                       }
+                               }
+                               return true
+                       })
+               }
+       }
+       base.ExitIfErrors()
+
        // Rewrite range over function to explicit function calls
        // with the loop bodies converted into new implicit closures.
        // We do this now, before serialization to unified IR, so that if the