// license that can be found in the LICENSE file.

package main

type T struct{}
type P *T

func (t *T) Meth() {}
func (t T) Meth2() {}

func main() {
	t := &T{}
	p := P(t)
	p.Meth()  // ERROR "undefined"
	p.Meth2() // ERROR "undefined"

type T1 struct{}

func (a T1) meth(val int) int { // ERROR "can inline T1.meth"
	return val + 5
}

func getMeth(t1 T1) func(int) int { // ERROR "can inline getMeth"
	return t1.meth // ERROR "t1.meth escapes to heap"
	// ERRORAUTO "inlining call to T1.meth"
}

func ii() { // ERROR "can inline ii"
	var t1 T1
	f := getMeth(t1) // ERROR "inlining call to getMeth" "t1.meth does not escape"
	_ = f(3)
}

type T1 struct{}

func (a T1) meth(val int) int { // ERROR "can inline T1.meth"
	return val + 5
}

func getMeth(t1 T1) func(int) int { // ERROR "can inline getMeth"
	return t1.meth // ERROR "t1.meth escapes to heap"
	// ERRORAUTO "inlining call to T1.meth"
}

func ii() { // ERROR "can inline ii"
	var t1 T1
	f := getMeth(t1) // ERROR "inlining call to getMeth" "t1.meth does not escape"
	_ = f(3)
}

		false,
	)
	println(t.Name())
}

func main() {
	useStructOf()
	useFuncOf()

	var t T
	meth, _ := reflect.TypeOf(t).MethodByName("F")
	ft := meth.Type
	at := ft.In(1)
	v := reflect.New(at).Elem()
	methV := v.MethodByName("M")
	methV.Call([]reflect.Value{v})

func (s S) N() { println("S.N") }

type T float64

func (t T) F(s S) {}

func main() {
	var t T
	meth, _ := reflect.TypeOf(t).MethodByName("F")
	ft := meth.Type
	at := ft.In(1)
	v := reflect.New(at).Elem()
	methV := v.MethodByName("M")
	methV.Call([]reflect.Value{v})

//  limitations under the License.

package loadbalancer

import (
	mesh2 "istio.io/istio/pkg/test/loadbalancersim/mesh"
)

type PrioritySelector func(src *mesh2.Client, dest *mesh2.Node) uint32

func LocalityPrioritySelector(src *mesh2.Client, dest *mesh2.Node) uint32 {
	priority := uint32(2)
	if src.Locality().Region == dest.Locality().Region {
		priority = 1

}

func (lb *weightedConnections) Latency() *timeseries.Instance {
	return lb.helper.Latency()
}

type WeightedConnectionFactory func(src *mesh2.Client, n *mesh2.Node) *WeightedConnection

func EquallyWeightedConnectionFactory() WeightedConnectionFactory {
	return func(src *mesh2.Client, dest *mesh2.Node) *WeightedConnection {
		return &WeightedConnection{
			Connection: src.Mesh().NewConnection(src, dest),
			Weight:     1,
		}
	}
}

		// Report methods of T and *T, preferring those of T.
		pmset := msets.MethodSet(types.NewPointer(T))
		for i, n := 0, pmset.Len(); i < n; i++ {
			meth := pmset.At(i)
			if m := mset.Lookup(meth.Obj().Pkg(), meth.Obj().Name()); m != nil {
				meth = m
			}
			result = append(result, meth)
		}

	}
	return result

3    eth1            ff0200000000000000000001ffac8928     2 00000006 0
3    eth1            ff020000000000000000000000000001     1 0000000C 0
4    eth2            ff0200000000000000000001ffac8932     2 00000006 0
4    eth2            ff020000000000000000000000000001     1 0000000C 0
5    eth0.100        ff0200000000000000000001ffac891e     1 00000004 0
5    eth0.100        ff020000000000000000000000000001     1 0000000C 0

 */
 
package org.gradle.internal.extensibility

class TestPluginConvention1 {
    String a = 'a1'
    String b = 'b'
    String c = 'c' 

    String meth() {
        'called1'
    }

    String meth(String arg) {
        'called1' + arg
    }