val() int
}

var _ = (*Val).val // ERROR "method|type \*Val is pointer to interface, not interface"

var v Val
var pv = &v

var _ = pv.val() // ERROR "undefined|pointer to interface"
var _ = pv.val   // ERROR "undefined|pointer to interface"

func (t *T) g() int { return t.a }

        result[0].method == method1
        result[0].arguments == [1, 2] as Object[]
        result[1].method == method2
        result[1].arguments == [3] as Object[]
        result[2].method == method1
        result[2].arguments == [4, 5] as Object[]
    }

    def "uses provided ClassLoader to locate incoming method invocation"() {
        Class cl = classLoader.parseClass('package org.gradle.test; class TestObj { void doStuff() { } }')

        def class1 = new TestClassResult(1, 'Class1', 1234)
        def method1 = new TestMethodResult(1, "method1", TestResult.ResultType.SUCCESS, 100, 2300)
        def method2 = new TestMethodResult(2, "method2", TestResult.ResultType.FAILURE, 200, 2700).addFailure("message", "stack-trace", "ExceptionType")
        class1.add(method1)
        class1.add(method2)
        def class2 = new TestClassResult(2, 'Class2', 5678)

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

// Issue 3824.
// Method calls are ignored when deciding initialization
// order.

package main

type T int

func (r T) Method1() int { return a }
func (r T) Method2() int { return b }

// dummy1 and dummy2 must be initialized after a and b.
var dummy1 = T(0).Method1()
var dummy2 = T.Method2(0)

// Use a function call to force generating code.
var a = identity(1)

    interface Item4 {
    }

    interface Item5 {
    }

    interface SuperThing {
        Runnable method1();

        List<Item1> method2();

        Map<Set<Item2>, String> method3();
    }

    interface GenericThing {
        Item3[] method1(String p);
        List<Item5>[] method2(String p);
    }

    interface Thing extends SuperThing, GenericThing {
        <T extends Item4> List<T> get();

// A type can be passed to a plugin and converted to interface
// there. So its methods need to be live.

package main

import (
	"plugin"

	"testplugin/method2/p"
)

var t p.T

type I interface{ M() }

func main() {
	pl, err := plugin.Open("method2.so")
	if err != nil {
		panic(err)
	}

	f, err := pl.Lookup("F")
	if err != nil {
		panic(err)
	}

import (
	"runtime"
	"testing"
)

type I1 interface {
	Method1()
}

type I2 interface {
	Method1()
	Method2()
}

type TS uint16
type TM uintptr
type TL [2]uintptr

func (TS) Method1() {}
func (TS) Method2() {}
func (TM) Method1() {}
func (TM) Method2() {}
func (TL) Method1() {}
func (TL) Method2() {}

type T8 uint8
type T16 uint16
type T32 uint32
type T64 uint64

// 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

import "testplugin/method2/p"

func main() {}

        InterceptScope.readsOfPropertiesNamed("property1") | InterceptScope.readsOfPropertiesNamed("property2")
        InterceptScope.methodsNamed("method1")             | InterceptScope.methodsNamed("method2")
    }

    def "method and property scopes with the same name are not equal"() {
        when:
        InterceptScope methodScope = InterceptScope.methodsNamed("name")

        protected int doHash(Method method) {
            return new HashCodeBuilder()
                .append(method.getName())
                .append(method.getParameterTypes())
                .toHashCode();
        }
    };

    /**
     * Equivalence of methods based on method name, the number, type and order of parameters, and return types.
     */