import java.util.function.Supplier

abstract class UndeclaredFileAccess extends BuildInputRead {
    final String filePath

    UndeclaredFileAccess(String filePath) {
        this.filePath = filePath
    }

    @Override
    List<String> requiredImports() {
        [
            File.class,
            FileFilter.class,
            FilenameFilter.class,
            Files.class,
            StandardCharsets.class,

import java.io.File


private
sealed class FileTreeSpec


private
class AdaptedFileTreeSpec(val tree: MinimalFileTree) : FileTreeSpec()


private
class FilteredFileTreeSpec(val tree: FileTreeInternal, val patterns: PatternSet) : FileTreeSpec()


private
class FilteredMinimalFileTreeSpec(val tree: FileTreeSpec, val patterns: PatternSet) : FileTreeSpec()


private

     * <p>
     * Shortcut for {@code getService(TypeRegistry.class).require(...)}.
     *
     * @see org.apache.maven.api.services.TypeRegistry#require(String)
     */
    @Nonnull
    Type requireType(@Nonnull String id);

    /**
     * Obtain the {@link Language} from the specified {@code id}.
     * <p>
     * Shortcut for {@code getService(LanguageRegistry.class).require(...)}.
     *

    }

    Injector discover(ClassLoader classLoader);

    Injector bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope);

    Injector bindScope(Class<? extends Annotation> scopeAnnotation, Supplier<Scope> scope);

    Injector bindImplicit(Class<?> cls);

    <T> Injector bindInstance(Class<T> cls, T instance);

    //
    // Bean access
    //

    <T> void injectInstance(T instance);

        buildFile << """
            class SomeBean {
                String value
                SomeBean parent
                SomeBean child

                SomeBean(String value) {
                    println("creating bean")
                    this.value = value
                }
            }

            class SomeTask extends DefaultTask {
                @Internal

    )
}


private
class EnvironmentEncoder : ClassEncoder {

    private
    val refs = IdentityHashMap<Class<*>, Int>()

    override fun WriteContext.encodeClass(type: Class<*>) {
        writeSmallInt(refs.computeIfAbsent(type) { refs.size })
    }

    fun getResultingEnvironment(): Map<Int, Any> =
        refs.invert()
}


private
class EnvironmentDecoder(

import org.gradle.execution.ExecutionAccessListener


internal
class ConfigurationTimeBarrierBasedExecutionAccessChecker(
    private val configurationTimeBarrier: ConfigurationTimeBarrier,
    private val broadcaster: ExecutionAccessListener
) : ExecutionAccessChecker {
    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, getterName: String, consumer: String) {

    public abstract val returnType: KaType
}

public typealias KtFunctionalType = KaFunctionalType

public abstract class KaUsualClassType : KaNonErrorClassType()

public typealias KtUsualClassType = KaUsualClassType

public abstract class KaClassErrorType : KaErrorType {
    public abstract val qualifiers: List<KaClassTypeQualifier>

import javax.inject.Inject
import java.nio.charset.Charset
import java.util.logging.Level

class ConfigurationCacheSupportedTypesIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "restores task fields whose value is instance of #type"() {
        buildFile << """
            import java.util.concurrent.*

            class SomeBean {
                ${type} value
            }

            enum SomeEnum {

import groovy.transform.Canonical
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.test.fixtures.file.TestFile

import static org.gradle.util.internal.GFileUtils.relativePathOf

class MissingScriptFixture {

    static List<Spec> specs() {
        multiLanguageSpecs() + singleLanguageSpecs()
    }

    private static List<Spec> multiLanguageSpecs() {
        [