check.declare(check.scope, name, lhs[i], scopePos)
			}

		case varDecl:
			top := len(check.delayed)

			lhs0 := make([]*Var, len(d.spec.Names))
			for i, name := range d.spec.Names {
				lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil)
			}

			// initialize all variables
			for i, obj := range lhs0 {
				var lhs []*Var
				var init ast.Expr
				switch len(d.spec.Values) {
				case len(d.spec.Names):

pkg go/types, func NewStruct([]*Var, []string) *Struct
pkg go/types, func NewTuple(...*Var) *Tuple
pkg go/types, func NewTypeName(token.Pos, *Package, string, Type) *TypeName
pkg go/types, func NewVar(token.Pos, *Package, string, Type) *Var
pkg go/types, func ObjectString(Object, Qualifier) string
pkg go/types, func RelativeTo(*Package) Qualifier
pkg go/types, func SelectionString(*Selection, Qualifier) string

// callsite: returns2.go:19:13|0 flagstr "" flagval 0 score 1 mask 16384 maskstr "returnFeedsConcreteToInterfaceCallAdj"
// <endcallsites>
// <endfuncpreamble>
func T_return_feeds_iface_call() {
	b := newBar(10)
	b.Plark()
}

// returns2.go T_multi_return_feeds_iface_call 29 0 1
// <endpropsdump>
// {"Flags":0,"ParamFlags":null,"ResultFlags":null}

// Copyright 2013 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 "fmt"

func NewBar() *Bar { return nil }

func (x *Foo) Method() (int, error) {
	for y := range x.m {
		_ = y.A
	}
	return 0, nil
}

type Foo struct {
	m map[*Bar]int
}

type Bar struct {
	A *Foo

            }
            dependencies {
                implementation("${build.group}:${build.buildName}")
            }
        """
        file("src/main/java/Foo.java") << """
            class Foo { Bar newBar() { return new Bar(); }}
        """

        then:
        succeeds("build")
        executed(":${build.buildName}:compileJava")
        executed(":compileJava")
        build.assertProjectPluginApplied()

		{"NewSlice", Func, 5},
		{"NewStruct", Func, 5},
		{"NewTerm", Func, 18},
		{"NewTuple", Func, 5},
		{"NewTypeName", Func, 5},
		{"NewTypeParam", Func, 18},
		{"NewUnion", Func, 18},
		{"NewVar", Func, 5},
		{"Nil", Type, 5},
		{"Object", Type, 5},
		{"ObjectString", Func, 5},
		{"Package", Type, 5},
		{"PkgName", Type, 5},
		{"Pointer", Type, 5},
		{"Qualifier", Type, 5},

	**xxx = *yy
}

func foo18(y int) { // ERROR "moved to heap: y$"
	*xxx = &y
}

func foo19(y int) {
	**xxx = y
}

type Bar struct {
	i  int
	ii *int
}

func NewBar() *Bar {
	return &Bar{42, nil} // ERROR "&Bar{...} escapes to heap$"
}

func NewBarp(x *int) *Bar { // ERROR "leaking param: x$"
	return &Bar{42, x} // ERROR "&Bar{...} escapes to heap$"
}

	**xxx = *yy
}

func foo18(y int) { // ERROR "moved to heap: y$"
	*xxx = &y
}

func foo19(y int) {
	**xxx = y
}

type Bar struct {
	i  int
	ii *int
}

func NewBar() *Bar {
	return &Bar{42, nil} // ERROR "&Bar{...} escapes to heap$"
}

func NewBarp(x *int) *Bar { // ERROR "leaking param: x$"
	return &Bar{42, x} // ERROR "&Bar{...} escapes to heap$"
}