}

  @Test
  @TestMetadata("any.kt")
  public void testAny() {
    runTest("analysis/analysis-api/testData/types/builtins/any.kt");
  }

  @Test
  @TestMetadata("anyWithoutBuiltins.kt")
  public void testAnyWithoutBuiltins() {
    runTest("analysis/analysis-api/testData/types/builtins/anyWithoutBuiltins.kt");
  }

     *     such as `Int = UnresolvedClass`.
     *  2. It forces the user to handle error types explicitly, which reduces the risk of false positives.
     *  3. It is consistent with most of the behavior of the Kotlin compiler.
     */
    STRICT,

    /**
     * Error types are equal to and subtypes of all types.
     *

	switch typeVal {
	case FormatType:
		return d
	case types.TypeType:
		return FormatType
	default:
		return types.NewErr("type conversion error from '%s' to '%s'", FormatType, typeVal)
	}
}

func (d *Format) Equal(other ref.Val) ref.Val {
	otherDur, ok := other.(*Format)
	if !ok {
		return types.MaybeNoSuchOverloadErr(other)
	}
	return types.Bool(d.Name == otherDur.Name)
}

func (d *Format) Type() ref.Type {

import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContext
import org.jetbrains.kotlin.types.checker.NewTypeVariableConstructor
import org.jetbrains.kotlin.types.error.ErrorTypeConstructor
import org.jetbrains.kotlin.types.error.ErrorTypeKind
import org.jetbrains.kotlin.types.error.ErrorUtils
import org.jetbrains.kotlin.types.model.KotlinTypeMarker

func (in *ControllerRevision) APILifecycleIntroduced() (major, minor int) {
	return 1, 9
}

// APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison.
// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go.

// nil on success, or the first conflicting method on failure.
func assertableTo(free *typeparams.Free, v, t types.Type) *types.Func {
	if t == nil || v == nil {
		// not assertable to, but there is no missing method
		return nil
	}
	// ensure that v and t are interfaces
	V, _ := v.Underlying().(*types.Interface)
	T, _ := t.Underlying().(*types.Interface)
	if V == nil || T == nil {
		return nil
	}

		m.Aggregated.Scanner = &metrics
	}
	if types.Contains(madmin.MetricsOS) {
		metrics := globalOSMetrics.report()
		m.Aggregated.OS = &metrics
	}
	if types.Contains(madmin.MetricsBatchJobs) {
		m.Aggregated.BatchJobs = globalBatchJobsMetrics.report(opts.jobID)
	}
	if types.Contains(madmin.MetricsSiteResync) {
		m.Aggregated.SiteResync = globalSiteResyncMetrics.report(opts.depID)
	}
	if types.Contains(madmin.MetricNet) {

package versions

import (
	"go/ast"
	"go/types"
)

// FileVersion returns a file's Go version.
// The reported version is an unknown Future version if a
// version cannot be determined.
func FileVersion(info *types.Info, file *ast.File) string {
	// In tools built with Go >= 1.22, the Go version of a file
	// follow a cascades of sources:
	// 1) types.Info.FileVersion, which follows the cascade:

	Tp, _ := T.(*TypeParam)

	// "V and T have identical underlying types if tags are ignored
	// and V and T are not type parameters"
	if IdenticalIgnoreTags(Vu, Tu) && Vp == nil && Tp == nil {
		return true
	}

	// "V and T are unnamed pointer types and their pointer base types
	// have identical underlying types if tags are ignored
	// and their pointer base types are not type parameters"
	if V, ok := V.(*Pointer); ok {

	if l == nil {
		return nil
	}
	return l.tparams
}

// TypeList holds a list of types.
type TypeList struct{ types []Type }

// newTypeList returns a new TypeList with the types in list.
func newTypeList(list []Type) *TypeList {
	if len(list) == 0 {
		return nil
	}
	return &TypeList{list}
}

// Len returns the number of types in the list.
// It is safe to call on a nil receiver.