BLOCK type=kotlin.Int origin=null
            TYPE_OP type=<root>.FooImpl origin=CAST typeOperand=<root>.FooImpl
              GET_VAR 'p0: <root>.Foo declared in <root>.CodeFragment.run' type=<root>.Foo origin=null
            CALL 'public final fun <get-n> (): kotlin.Int declared in <root>.FooImpl' type=kotlin.Int origin=GET_PROPERTY
              $this: TYPE_OP type=<root>.FooImpl origin=IMPLICIT_CAST typeOperand=<root>.FooImpl

}

// ConvertToType implements ref.Val.ConvertToType.
func (d CIDR) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case CIDRType:
		return d
	case types.TypeType:
		return CIDRType
	case types.StringType:
		return types.String(d.Prefix.String())
	}
	return types.NewErr("type conversion error from '%s' to '%s'", CIDRType, typeVal)
}

// Equal implements ref.Val.Equal.
func (d CIDR) Equal(other ref.Val) ref.Val {

    private final Map<String, VersionEntry> versions = new TreeMap<>();
    private final Map<String, LibraryEntry> libraries = new TreeMap<>();
    private final Map<String, PluginEntry> plugins = new TreeMap<>();

    private final boolean fullyQualifiedAliases;

    public VersionCatalogDependencyRegistry(boolean fullyQualifiedAliases) {

from typing import TypeVar

from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from typing_extensions import Annotated

app = FastAPI()

T = TypeVar("T")

Dep = Annotated[T, Depends()]


class A:
    pass


class B:
    pass


@app.get("/a")
async def a(dep: Dep[A]):
    return {"cls": dep.__class__.__name__}


@app.get("/b")
async def b(dep: Dep[B]):

from typing import AsyncGenerator, ContextManager, TypeVar

import anyio
from anyio import CapacityLimiter
from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
from starlette.concurrency import (  # noqa
    run_until_first_complete as run_until_first_complete,
)

_T = TypeVar("_T")


@asynccontextmanager

import org.gradle.internal.SystemProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

@NonNullApi
public class DefaultSslContextFactory implements SslContextFactory {
    private static final Set<String> SSL_SYSTEM_PROPERTIES = ImmutableSet.of(
        "ssl.TrustManagerFactory.algorithm",

 */
val propertiesCodec: Codec<Properties> = mapCodec { Properties() }


val treeMapCodec: Codec<TreeMap<Any?, Any?>> = codec(
    {
        write(it.comparator())
        writeMap(it)
    },
    {
        @Suppress("unchecked_cast")
        val comparator = read() as Comparator<Any?>?
        readMapInto { TreeMap(comparator) }
    }
)

        byte typeTag = decoder.readByte();
        String name = decoder.readString();
        List<URL> classpath = new ArrayList<>();
        int classpathSize = decoder.readInt();
        for (int i=0; i<classpathSize; i++) {
            classpath.add(new URL(decoder.readString()));
        }

        switch(typeTag) {
            case VISITABLE_URL_CLASSLOADER_SPEC:

import org.gradle.api.logging.Logger;
import org.gradle.internal.logging.text.TreeFormatter;

import javax.annotation.concurrent.NotThreadSafe;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

@NotThreadSafe
public class PublicationWarningsCollector {

    private final Logger logger;
    private final String unsupportedFeature;
    private final String incompatibleFeature;

var providerLookupClusterFailures = monitoring.NewSum(
	"provider_lookup_cluster_failures",
	"Number of times a cluster lookup failed",
)

func IncLookupClusterFailures(provider string) {
	providerLookupClusterFailures.With(typeTag.Value(provider)).Increment()