// not to be confused with the universe any
	anyType{},

	// comparable
	types.Universe.Lookup("comparable").Type(),

	// "any" has special handling: see usage of predeclared.
}

type anyType struct{}

func (t anyType) Underlying() types.Type { return t }
func (t anyType) String() string         { return "any" }

// See cmd/compile/internal/noder.derivedInfo.

    override val unit: KaType by cachedBuiltin(builtinTypes.unitType)
    override val nothing: KaType by cachedBuiltin(builtinTypes.nothingType)
    override val any: KaType by cachedBuiltin(builtinTypes.anyType)

    override val throwable: KaType by cachedBuiltin(builtinTypes.throwableType)
    override val nullableAny: KaType by cachedBuiltin(builtinTypes.nullableAnyType)

	}
	return v, nil
}

func buildTestEnv() (*cel.Env, *apiservercel.DeclType, error) {
	variablesType := apiservercel.NewMapType(apiservercel.StringType, apiservercel.AnyType, 0)
	variablesType.Fields = make(map[string]*apiservercel.DeclField)
	envSet, err := environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), true).Extend(
		environment.VersionedOptions{

		return apiservercel.NewListType(apiservercel.StringType, -1)
	case reflect.TypeOf(map[string]authenticationv1.ExtraValue{}):
		return apiservercel.NewMapType(apiservercel.StringType, apiservercel.AnyType, -1)
	default:
		t.Fatalf("unsupported type %v", nativeType)
	}
	return nil

	name       string
	expression string
}

func (t *testVariable) GetExpression() string {
	return t.expression
}

func (t *testVariable) ReturnTypes() []*cel.Type {
	return []*cel.Type{cel.AnyType}
}

func (t *testVariable) GetName() string {
	return t.name
}

func TestCompositedPolicies(t *testing.T) {
	cases := []struct {
		name                  string