*
     * @see getCallableSymbols
     */
    public fun getCallableSymbols(vararg names: Name): Sequence<KaCallableSymbol> =
        getCallableSymbols(names.toList())

    /**
     * Return a sequence of [KaClassifierSymbol] which current scope contain if classifier name matches [nameFilter]. The sequence includes:

               Stream.concat(getDelegate().get${cap}().stream(), Stream.of(${v}))
                        .collect(Collectors.toList())));
        #else
        update(getDelegate().with${cap}(
               Stream.concat(getDelegate().get${cap}().stream(), Stream.of(${v}.getDelegate()))
                        .collect(Collectors.toList())));
        ${v}.childrenTracking = this::replace;
        #end
    }

	var empty T
	if t != empty {
		return t
	}
	return def
}

// Empty returns an empty T type
func Empty[T any]() T {
	var empty T
	return empty
}

// ToList returns an empty list if t is nil, or a list with a single element
func ToList[T any](t *T) []T {
	if t == nil {
		return nil
	}
	return []T{*t}
}

// TypeName returns the name of the type
func TypeName[T any]() string {
	var empty T

import org.gradle.tooling.provider.model.ParameterizedToolingModelBuilder;

import java.util.List;
import java.util.Objects;

import static java.util.stream.Collectors.toList;
import static org.gradle.plugins.ide.internal.tooling.ToolingModelBuilderSupport.buildFromTask;

/**
 * Builds the {@link IsolatedGradleProjectInternal} that contains information about a project and its tasks.
 */

        }).collect(Collectors.toList());
    }

    @Override
    public Collection<IncludedBuildState> getIncludedBuildsForPluginResolution() {
        BuildState thisBuild = gradle.getOwner();
        return buildRegistry.getIncludedBuilds().stream().filter(build ->
            build != thisBuild && !build.isImplicitBuild() && !build.isPluginBuild()
        ).collect(Collectors.toList());
    }

    @Override

                .filter(c -> c.isAnnotationPresent(Inject.class))
                .collect(toList());

        List<Method> factoryMethods = Arrays.stream(cls.getDeclaredMethods())
                .filter(method -> method.getReturnType() == cls && Modifier.isStatic(method.getModifiers()))
                .collect(toList());
        List<Method> injectFactoryMethods = factoryMethods.stream()

import org.gradle.kotlin.dsl.provider.KotlinScriptClassPathProvider;

import javax.inject.Inject;
import java.io.File;

import static com.google.common.collect.Iterables.getOnlyElement;
import static java.util.stream.Collectors.toList;

/**
 * Extracts Kotlin DSL runtime generated sources.
 *
 * Current implementation extracts these from the wrapper's API jars.
 * This is not correct as it should do this with the built distribution instead.
 *

            assertThat("Has errors", richReport.errors.map { it.message }, CoreMatchers.equalTo(errors.toList()))
        }

        fun assertHasWarnings(vararg warnings: String) {
            assertThat("Has warnings", richReport.warnings.map { it.message }, CoreMatchers.equalTo(warnings.toList()))
        }

        fun assertHasInformation(vararg information: String) {

	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if version != "10" {
		t.Errorf("unexpected version %v", version)
	}

	podList := internal.PodList{ListMeta: metav1.ListMeta{ResourceVersion: "10"}}
	version, err = meta.NewAccessor().ResourceVersion(&podList)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if version != "10" {
		t.Errorf("unexpected version %v", version)
	}
}

     *
     * @see getCallableSignatures
     */
    public fun getCallableSignatures(vararg names: Name): Sequence<KaCallableSignature<*>> = withValidityAssertion {
        getCallableSignatures(names.toList())
    }

    /**
     * Return a sequence of [KaClassifierSymbol] which current scope contain if classifier name matches [nameFilter]. The sequence includes: