)

// Standard constants for all storage class
const (
	// Reduced redundancy storage class
	RRS = "REDUCED_REDUNDANCY"
	// Standard storage class
	STANDARD = "STANDARD"
)

// Standard constats for config info storage class
const (
	ClassStandard = "standard"
	ClassRRS      = "rrs"
	Optimize      = "optimize"
	InlineBlock   = "inline_block"

	// Reduced redundancy storage class environment variable

                    subject.collectionOfClasses(listOf(Number::class, Int::class))

                    subject.methodParameterizedClass(type = Int::class)
                    subject.covariantMethodParameterizedClass(type = Int::class)
                    subject.methodParameterizedCovariantClass(type = Int::class)
                    subject.methodParameterizedContravariantClass(type = Int::class)

 * based on the static type of the provider.
 */
class RegisteringDomainObjectDelegateProviderWithType<T, U : Any>
private constructor(
    internal val delegateProvider: T,
    internal val type: KClass<U>
) {
    companion object {
        fun <T, U : Any> of(delegateProvider: T, type: KClass<U>) =
            RegisteringDomainObjectDelegateProviderWithType(delegateProvider, type)
    }

        withBuildScript("""
            plugins { id("my-plugin") }

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }
            the<MyExtension>().some("kotlin.reified.get")
            the(MyExtension::class).some("kotlin.kclass.get")
            configure<MyExtension> { some("kotlin.configure") }
            my.some("accessor.get")

    private fun getFrontendIndependentKClassOf(value: Any): KClass<*> {
        fun KClass<*>.isFrontendIndependent(): Boolean {
            if (this == Any::class) return false
            val qualifiedName = qualifiedName ?: return false
            return symbolImplementationPackageNames.none { qualifiedName.startsWith("$it.") }
        }

        val valueClass = value::class

  @JvmName("reifiedTag")
  inline fun <reified T : Any> tag(): T? = tag(T::class)

  /** Returns the tag attached with [type] as a key, or null if no tag is attached with that key. */
  fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags[type])

  /**
   * Returns the tag attached with `Object.class` as a key, or null if no tag is attached with
   * that key.
   *

            taskAssertion("cabin", Copy::class),
            taskAssertion("castle", Task::class, equalTo("null!")),
            taskAssertion("valley", Copy::class, equalTo("null!")),
            taskAssertion("hill", Copy::class, equalTo("null!")),
            taskAssertion("bat"),
            taskAssertion("pipistrelle", Copy::class, equalTo("nullABC")),
            taskAssertion("yate"),
            taskAssertion("quartern", Copy::class),

  // effectively a "weak reference" to intern'd class value.
  // types are compared by comparing pointer values here.
  // Handle* class_;  // effectively a "weak reference" to intern'd class value.

  /// The Integer handle.
  friend class Integer;
  /// The Float handle.
  friend class Float;
  /// The String handle.
  friend class String;
  /// The Object handle.
  friend class Object;
  /// The List handle.

        source "class A { static final int x = 1; }",
            "class B { static final int x = A.x + 1; }",
            "class C { static final int x = B.x + 1; }",
            "class D { static final int x = C.x + 1; }",
            "class E { }"
        outputs.snapshot { run language.compileTaskName }

        when:

        """
            package org.gradle.ruleusing;
            public class Class2 extends Class1 { }
        """
    }

    private static classReferencingIntermediate() {
        """
        package org.gradle.ruleusing;
        public class Class1 {
            private org.gradle.intermediate.IntermediateClass mClass = null;
        }
       """
    }