cmd/compile: retain source positions of arguments to inlined calls

Arguments to inlined calls are hidden from setPos as follows:

    args := as.Rlist
    as.Rlist.Set(nil)
    // setPos...
    as.Rlist.Set(args.Slice())

Previously, this code had no effect since the value of as was
overwritten by the assignment in the retvars loop.

Fixes #19799.

Change-Id: Iaf97259f82fdba8b236136337cc42b2774c7fef5
Reviewed-on: https://go-review.googlesource.com/44351
Run-TryBot: David Lazar <lazard@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index 54317d99d83922c468a85ae266de608df6b806dc..dfa13e3c3b3561619db5500bb5f304e7181e976d 100644 (file)
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -726,9 +726,9 @@ func mkinlcall1(n *Node, fn *Node, isddd bool) *Node {
 
        // Zero the return parameters.
        for _, n := range retvars {
-               as = nod(OAS, n, nil)
-               as = typecheck(as, Etop)
-               ninit.Append(as)
+               ras := nod(OAS, n, nil)
+               ras = typecheck(ras, Etop)
+               ninit.Append(ras)
        }
 
        retlabel := autolabel(".i")

diff --git a/test/fixedbugs/issue19799.go b/test/fixedbugs/issue19799.go
new file mode 100644 (file)
index 0000000..cb675d7
--- /dev/null
+++ b/test/fixedbugs/issue19799.go
@@ -0,0 +1,71 @@
+// run
+
+// Copyright 2017 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
+
+import (
+       "os"
+       "runtime"
+)
+
+func foo(x int) int {
+       return x + 1
+}
+
+func test() {
+       defer func() {
+               if r := recover(); r != nil {
+                       pcs := make([]uintptr, 10)
+                       n := runtime.Callers(0, pcs)
+                       pcs = pcs[:n]
+                       frames := runtime.CallersFrames(pcs)
+                       for {
+                               f, more := frames.Next()
+                               if f.Function == "main.foo" {
+                                       println("did not expect to see call to foo in stack trace")
+                                       os.Exit(1)
+                               }
+                               if !more {
+                                       break
+                               }
+                       }
+               }
+       }()
+       var v []int
+       foo(v[0])
+}
+
+func bar(x ...int) int {
+       return x[0] + 1
+}
+
+func testVariadic() {
+       defer func() {
+               if r := recover(); r != nil {
+                       pcs := make([]uintptr, 10)
+                       n := runtime.Callers(0, pcs)
+                       pcs = pcs[:n]
+                       frames := runtime.CallersFrames(pcs)
+                       for {
+                               f, more := frames.Next()
+                               if f.Function == "main.bar" {
+                                       println("did not expect to see call to bar in stack trace")
+                                       os.Exit(1)
+                               }
+                               if !more {
+                                       break
+                               }
+                       }
+               }
+       }()
+       var v []int
+       bar(v[0])
+}
+
+func main() {
+       test()
+       testVariadic()
+}