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.internal.gradle.DefaultProjectIdentifier;
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;

/**

        }).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

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.
 *

        }

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

        fun assertHasAccepted(vararg accepted: Pair<String, List<String>>) {

     *
     * @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:

                .collect(Collectors.toList());
    }

    @Override
    public List<Profile> getActiveProfiles(
            Collection<Profile> profiles, ProfileActivationContext context, ModelProblemCollector problems) {
        Collection<String> activatedIds = new HashSet<>(context.getActiveProfileIds());
        Collection<String> deactivatedIds = new HashSet<>(context.getInactiveProfileIds());

    }

    private fun getClassLikeDeclarationsByClassId(classId: ClassId): Sequence<KtClassLikeDeclaration> {
        if (classId.isLocal) {
            return emptySequence()
        }

        if (kotlinFile.packageFqName != classId.packageFqName) {
            return emptySequence()
        }

        data class Task(val chunks: List<Name>, val element: KtElement)

        Map<ResolvedVariant, List<TransformedVariant>> variantToTransforms = failure.getTransformedVariants().stream().collect(Collectors.groupingBy(
            TransformedVariant::getRoot,
            () -> new TreeMap<>(Comparator.comparing(variant -> variant.asDescribable().getDisplayName())),
            Collectors.collectingAndThen(Collectors.toList(), list -> list.stream().sorted(variantComparator).collect(Collectors.toList()))));

     */
    public static List<File> mergeToClasspath(
        ArtifactCollection originalDependencies,
        ArtifactCollection externalDependencies,
        ArtifactCollection projectDependencies
    ) {
        List<OriginalArtifactIdentifier> identifiers = originalDependencies.getArtifacts().stream()
            .map(OriginalArtifactIdentifier::of)