import org.gradle.model.internal.type.ModelType;

import javax.annotation.Nullable;
import java.util.Optional;

import static java.util.stream.Collectors.toList;

public class DefaultTypeValidationContext extends ProblemRecordingTypeValidationContext {

    public static final String MISSING_NORMALIZATION_ANNOTATION = "MISSING_NORMALIZATION_ANNOTATION";

    }

    private PerformanceReportScenario queryAndSortExecutionData(List<PerformanceTestExecutionResult> teamCityExecutionsOfSameScenario) {
        List<String> teamcityBuildIds = teamCityExecutionsOfSameScenario
            .stream()
            .map(PerformanceTestExecutionResult::getTeamCityBuildId)
            .filter(StringUtils::isNotBlank)
            .collect(toList());

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class CrossVersionPerformanceTestHistory implements PerformanceTestHistory {
    private final PerformanceExperiment experiment;
    private final List<String> versions;
    private final List<String> branches;
    private final List<CrossVersionPerformanceResults> newestFirst;
    private List<CrossVersionPerformanceResults> oldestFirst;

    /**
     * Wraps the given items in a mutable list.
     */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> toList(T... items) {
        logDeprecation(7);
        ArrayList<T> coll = new ArrayList<T>();
        Collections.addAll(coll, items);
        return coll;
    }

    /**
     * Wraps the given items in a mutable list.
     */

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

	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

     * Wraps the given items in a mutable list.
     */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> toList(T... items) {
        ArrayList<T> coll = new ArrayList<T>();
        Collections.addAll(coll, items);
        return coll;
    }

    /**
     * Wraps the given items in a mutable list.
     */
    public static <T> List<T> toList(Iterable<? extends T> items) {

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