import org.jetbrains.kotlin.resolve.references.ReferenceAccess

internal class KotlinFirReferenceContributor : KotlinReferenceProviderContributor {
    override fun registerReferenceProviders(registrar: KotlinPsiReferenceRegistrar) {
        with(registrar) {
            registerProvider(factory = ::KaFirForLoopInReference)
            registerProvider(factory = ::KaFirInvokeFunctionReference)

    entrypoint: 'bash'
    dir: ./cluster/images/etcd
    env:
      - DOCKER_CLI_EXPERIMENTAL=enabled
      - REGISTRY=gcr.io/$PROJECT_ID
      - PUSH_REGISTRY=gcr.io/$PROJECT_ID
      - IMAGE=gcr.io/$PROJECT_ID/etcd
      - BUILD_IMAGE=debian-build
      - TMPDIR=/workspace
      - HOME=/root  # for docker buildx
    args:

import org.gradle.internal.vfs.impl.DefaultSnapshotHierarchy;
import org.gradle.internal.watch.registry.FileWatcherRegistryFactory;
import org.gradle.internal.watch.registry.impl.DarwinFileWatcherRegistryFactory;
import org.gradle.internal.watch.registry.impl.LinuxFileWatcherRegistryFactory;
import org.gradle.internal.watch.registry.impl.WindowsFileWatcherRegistryFactory;
import org.gradle.internal.watch.vfs.BuildLifecycleAwareVirtualFileSystem;

*/

package options

import (
	"k8s.io/kubernetes/pkg/kubelet/config"
)

const (
	// When these values are updated, also update test/utils/image/manifest.go
	defaultPodSandboxImageName    = "registry.k8s.io/pause"
	defaultPodSandboxImageVersion = "3.10"
)

var (
	defaultPodSandboxImage = defaultPodSandboxImageName +
		":" + defaultPodSandboxImageVersion
)

			disk.DrivePath,
		)
	}
}

func metricsHandler() http.Handler {
	registry := prometheus.NewRegistry()

	logger.CriticalIf(GlobalContext, registry.Register(minioVersionInfo))

	logger.CriticalIf(GlobalContext, registry.Register(newMinioCollector()))

	gatherers := prometheus.Gatherers{
		prometheus.DefaultGatherer,
		registry,
	}

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

    xla::CompileOnlyClient* client,
    XlaCompiler::CompilationResult* compilation_result) {
  mlir::DialectRegistry registry;
  mlir::RegisterAllTensorFlowDialects(registry);
  mlir::mhlo::registerAllMhloDialects(registry);
  mlir::MLIRContext context(registry);

  mlir::OwningOpRef<mlir::ModuleOp> mlir_module;
  TF_RETURN_IF_ERROR(DeserializeMlirModule(mlir_computation.mlir_module,

	KubernetesVersion string
	// If provided, a service registry with the name of each map key will be created with the given objects.
	KubernetesObjectsByCluster map[cluster.ID][]runtime.Object
	// If provided, these objects will be used directly for the default cluster ("Kubernetes" or DefaultClusterName)
	KubernetesObjects []runtime.Object
	// If provided, a service registry with the name of each map key will be created with the given objects.

            def location = locationFor(it)
            new JvmToolchainMetadata(detector.getMetadata(location), location)
        }

        def registry = Stub(JavaInstallationRegistry)
        registry.toolchains() >> installations
        registry
    }

    private InstallationLocation locationFor(String version) {
        return InstallationLocation.userDefined(new File("/path/${version}").absoluteFile, "test")

			logger, ctx := ktesting.NewTestContext(t)
			ctx, cancel := context.WithCancel(ctx)
			defer cancel()
			registry := frameworkruntime.Registry{}
			cfgPls := &schedulerapi.Plugins{}
			plugins := append(tt.plugins, &fakebindPlugin{}, &fakeQueueSortPlugin{})
			for _, pl := range plugins {
				tmpPl := pl
				if err := registry.Register(pl.Name(), func(_ context.Context, _ runtime.Object, _ framework.Handle) (framework.Plugin, error) {

        }

        @Provides
        protected DefaultJvmToolchainManagement createToolchainManagement(ObjectFactory objectFactory, JavaToolchainResolverRegistry registry) {
            return objectFactory.newInstance(DefaultJvmToolchainManagement.class, registry);
        }

        @Provides