}

        withBuildScript(
            """
            plugins {
                my
            }

            inline fun <reified T> typeOf(value: T) = typeOf<T>()

            println("closureExtension: " + typeOf(closureExtension))

            val casted = closureExtension as groovy.lang.Closure<*>
            println(casted.call("some"))
            """
        )

    @Test
    fun recognizesLambdaType() {
        assertEquals(typeOf<Int>(), customConfigureLambdas.getTypeConfiguredByLambda(typeOf<MyFunctionalInterface<Int>>()))
        assertTrue { customConfigureLambdas.isConfigureLambdaForType(typeOf<Int>(), typeOf<MyFunctionalInterface<Int>>()) }
        assertFalse { customConfigureLambdas.isConfigureLambdaForType(typeOf<String>(), typeOf<MyFunctionalInterface<Int>>()) }
    }

    @Test

                      bar: typeOf(Capability),
                      boo: typeOf(Child),
                      baz: new TypeOf<List<String>>() {},
                      cat: typeOf(Thing),
                      meo: typeOf(Thing)]
    }

    def "can configure extensions by name"() {
        given:
        container.add "foo", extension

        when:

        val extensions = mock<ExtensionContainer>()
        doNothing().`when`(extensions).add(any<TypeOf<SomeExtension<*>>>(), any(), any())

        val instance = SomeExtension("some")
        extensions.add<SomeExtension<String>>("name", instance)

        inOrder(extensions) {
            verify(extensions).add(typeOf<SomeExtension<String>>(), "name", instance)
            verifyNoMoreInteractions()
        }
    }

 */
package org.gradle.kotlin.dsl

import org.gradle.api.reflect.TypeOf


/**
 * Creates an instance of [TypeOf] for the given parameterized type.
 *
 * @param T the type
 * @return the [TypeOf] that captures the generic type of the given parameterized type
 */
inline fun <reified T> typeOf(): TypeOf<T> =

	// This function returns false if the name does not refer to a known object type.
	Resolve(name string) (TypeRef, bool)
}

// TypeRef refers an object type that can be looked up for its fields.
type TypeRef interface {
	ref.Type

	// CELType wraps the TypeRef to be a type that is understood by CEL.
	CELType() *types.Type

	// Field finds the field by the field name, or false if the field is not known.

)

const object = common.RootTypeReferenceName

type TypeResolver struct {
}

// Resolve resolves the TypeRef for the given type name
// that starts with "Object".
// This is the unstructured version, which means the
// returned TypeRef does not refer to the schema.
func (r *TypeResolver) Resolve(name string) (common.TypeRef, bool) {
	if !strings.HasPrefix(name, object) {
		return nil, false
	}
	return NewTypeRef(name), true

#include <stdio.h>

#undef nil
#define nil ((void*)0)
#define nelem(x) (sizeof(x)/sizeof((x)[0]))

typedef uint32_t uint32;
typedef uint64_t uint64;
typedef uintptr_t uintptr;

/*
 * The beginning of the per-goroutine structure,
 * as defined in ../pkg/runtime/runtime.h.
 * Just enough to edit these two fields.
 */
typedef struct G G;
struct G
{
	uintptr stacklo;
	uintptr stackhi;
};

/*

package org.gradle.kotlin.dsl.accessors

import org.gradle.api.reflect.TypeOf.typeOf

import org.gradle.kotlin.dsl.typeOf

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class KotlinTypeStringTest {

    @Test
    fun `#kotlinTypeStringFor array type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<Array<String>>()),
            equalTo("Array<String>")

)

var compareTests = [][]reflect.Value{
	ct(reflect.TypeOf(int(0)), -1, 0, 1),
	ct(reflect.TypeOf(int8(0)), -1, 0, 1),
	ct(reflect.TypeOf(int16(0)), -1, 0, 1),
	ct(reflect.TypeOf(int32(0)), -1, 0, 1),
	ct(reflect.TypeOf(int64(0)), -1, 0, 1),
	ct(reflect.TypeOf(uint(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint8(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint16(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint32(0)), 0, 1, 5),
	ct(reflect.TypeOf(uint64(0)), 0, 1, 5),