equalTo(inaccessible(type, nonAvailable(type.kotlinString)))
        )
    }

    @Test
    fun `public type is represented as Accessible`() {

        val typeString = "existing.Type"

        val classPath = classPathWithPublicType(typeString)
        classLoaderFor(classPath).useToRun {
            val type = schemaTypeFor(typeString)
            val projectSchema = availableProjectSchemaFor(

                domainObject,
                typeOf<NamedDomainObjectProvider<DomainObject>>()
            )
        }
    }

    @Test
    fun `val domainObject by registering(type)`() {

        val domainObjectProvider = mockDomainObjectProviderFor(DomainObject())
        val container = mock<PolymorphicDomainObjectContainer<Any>> {

import org.junit.Test


@Suppress("deprecation")
class ProjectExtensionsTest {

    abstract class CustomConvention

    @Test
    fun `can get generic project extension by type`() {

        val project = mock<Project>()
        val convention = mock<org.gradle.api.plugins.Convention>()
        val extension = mock<NamedDomainObjectContainer<List<String>>>()

func (p *I1) val() int { return 1 } // ERROR "receiver.*interface|invalid pointer or interface receiver"

type Val interface {
	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"

            verify(extensionContainer).configure(eq(extensionType), any<Action<JacocoTaskExtension>>())
            verifyNoMoreInteractions()
        }
    }

    @Test
    fun `can get generic extension by type`() {

        val extensionAware = mock<ExtensionAware>()
        val extensions = mock<ExtensionContainer>()
        val extension = mock<NamedDomainObjectContainer<List<String>>>()

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

// Issue 5698: can define a key type with slices.

package main

type Key struct {
	a int16 // the compiler was confused by the padding.
	b []int
}

type Val struct{}

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

import "sync"

type Val[T any] struct {
	mu  sync.RWMutex
	val T
}

func (v *Val[T]) Has() {
	v.mu.RLock()

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

var V val[int]

type val[T any] struct {
	valx T
}

func (v *val[T]) Print() {
	v.print1()
}

func (v *val[T]) print1() {
	println(v.valx)
}

func (v *val[T]) fnprint1() {
	println(v.valx)
}

func FnPrint[T any](v *val[T]) {

    @Test
    fun `type-checks assignment of subtype to superclass type`() {
        val result = schema.resolve(
            """
            superClassProp = sub()
            """.trimIndent()
        )

        assertEquals(1, result.assignments.size)
    }

    @Test
    fun `type-checks assignment of subtype to super interface type`() {
        val result = schema.resolve(
            """

            optional(
                expression * zeroOrMore(token(COMMA) * expression) * optional(token(COMMA))
            )
        )

    val parenthesizedType by debug {
        paren(type)
    }

    val parenthesizedExpression by debug {
        paren(expression)
    }

    val valueArgument by debug {
        optional(annotation) * optional(simpleIdentifier * token(EQ)) * optional(token(MUL)) * expression