data class StandardKotlinBuildScriptModel(
        private val classPath: List<File> = emptyList(),
        private val sourcePath: List<File> = emptyList(),
        private val implicitImports: List<String> = emptyList(),
        private val editorReports: List<EditorReport> = emptyList(),
        private val exceptions: List<String> = emptyList(),
        private val enclosingScriptProjectDir: File? = null
    ) : KotlinBuildScriptModel {

    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptySet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptyNavigableSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptySortedSet() {
    return Collections.emptySet();
  }

    return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedNavigableMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedSortedMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptyMap() {
    return Collections.emptySet();
  }

        this.tasks = Collections.emptyList();
        this.children = Lists.newArrayList(children);
        this.classpath = Collections.emptyList();
        this.sourceDirectories = Collections.emptyList();
        this.projectDependencies = Collections.emptyList();
        this.projectNatures = Collections.emptyList();
        this.buildCommands = Collections.emptyList();
        this.classpathContainers = Collections.emptyList();

    }

    private
    fun hashCodeFor(
        extensions: TypedProjectSchemaEntryList = emptyList(),
        conventions: TypedProjectSchemaEntryList = emptyList(),
        tasks: TypedProjectSchemaEntryList = emptyList(),
        containerElements: TypedProjectSchemaEntryList = emptyList(),
        configurations: List<String> = emptyList()
    ) = hashCodeFor(
        projectSchemaWith(
            extensions = extensions,

import java.util.Map;

public class EmptySystemLibraries implements SystemLibraries {
    @Override
    public List<File> getIncludeDirs() {
        return Collections.emptyList();
    }

    @Override
    public List<File> getLibDirs() {
        return Collections.emptyList();
    }

    @Override
    public Map<String, String> getPreprocessorMacros() {
        return Collections.emptyMap();
    }

import java.util.List;

import static java.util.Collections.emptyList;

public class LockOutOfDateException extends GraphValidationException {

    private final List<String> errors;

    public LockOutOfDateException(String message) {
        super(message);
        this.errors = emptyList();
    }

    public List<String> getErrors() {
        return errors;
    }

        emptySet()

    override fun getKotlinOnlySubPackagesFqNames(packageFqName: FqName, nameFilter: (Name) -> Boolean): Set<Name> = emptySet()

    override fun getPlatformSpecificSubPackagesFqNames(
        packageFqName: FqName,
        platform: TargetPlatform,
        nameFilter: (Name) -> Boolean,
    ): Set<Name> = emptySet()

                    ids = Collections.singletonList(new UserIDPacket(id.get()));
                    idSignatures = Collections.singletonList(Collections.emptyList());
                } else {
                    ids = Collections.emptyList();
                    idSignatures = Collections.emptyList();
                }

                // unfortunately, the PGPPublicKey constructor is package private, so we need to use reflection

import org.jetbrains.kotlin.psi.KtFile

internal class KtScriptModuleImpl(
    override val directRegularDependencies: List<KtModule> = emptyList(),
    override val directDependsOnDependencies: List<KtModule> = emptyList(),
    override val directFriendDependencies: List<KtModule> = emptyList(),
    override val platform: TargetPlatform = JvmPlatforms.defaultJvmPlatform,
    override val project: Project,
    override val file: KtFile,