this.modelRuleSourceDetector = modelRuleSourceDetector;
    }

    public <T> PotentialPlugin<T> inspect(Class<T> type) {
        boolean implementsInterface = Plugin.class.isAssignableFrom(type);
        boolean hasRules = this.modelRuleSourceDetector.hasRules(type);

        if (implementsInterface) {
            @SuppressWarnings("unchecked") Class<? extends Plugin<?>> cast = (Class<? extends Plugin<?>>) type;

type interfaceContainer struct {
	I anInterface
}

type anInterface interface {
	IsU()
}

type implementsInterface struct {
	A string
}

func (*implementsInterface) IsU() {}

func TestIsValueInterface(t *testing.T) {
	intf := &interfaceContainer{
		I: &implementsInterface{
			A: "a",
		},
	}
	iField := reflect.ValueOf(intf).Elem().FieldByName("I")
	if !IsValueInterface(iField) {

	// with older encodings for net.IP. See golang.org/issue/6760.
	// } else if ok, indir := implementsInterface(ut.user, textMarshalerInterfaceType); ok {
	// 	ut.externalEnc, ut.encIndir = xText, indir
	// }

	if ok, indir := implementsInterface(ut.user, gobDecoderInterfaceType); ok {
		ut.externalDec, ut.decIndir = xGob, indir
	} else if ok, indir := implementsInterface(ut.user, binaryUnmarshalerInterfaceType); ok {

    public static final Action<ClassNode> INSTANCE = new ClosureCreationInterceptingVerifier();

    @Override
    public void execute(ClassNode node) {
        if (node.implementsInterface(ClassHelper.GENERATED_CLOSURE_Type)) {
            RulesVisitor.visitGeneratedClosure(node);
            RuleVisitor.visitGeneratedClosure(node);
        }
    }

        then:
        obj.callsPrivateStringMethodWithGString("$foo") == "BAR"
    }

    def "class can implement interface methods using Groovy property"() {
        when:
        def i = create(ImplementsInterface)
        i.prop = "prop"

        then:
        i.prop == "prop"
    }

    def "property missing implementation is invoked exactly once, with actual value"() {
        given:

        } else {
            return Collections.singleton(statement);
        }
    }

    public static MethodNode getGeneratedClosureImplMethod(ClassNode classNode) {
        if (!classNode.implementsInterface(ClassHelper.GENERATED_CLOSURE_Type)) {
            throw new IllegalArgumentException("expecting generated closure class node");
        }

// compiledir

// Copyright 2019 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.

// Issue 33219: gccgo assert in "implements_interface()"