fun AnalysisSchema.reflect(code: String): ObjectReflection {
    val resolution = resolve(code)
    val trace = assignmentTrace(resolution)
    val context = ReflectionContext(SchemaTypeRefContext(this), resolution, trace)
    val topLevel = org.gradle.internal.declarativedsl.objectGraph.reflect(resolution.topLevelReceiver, context)

    return topLevel
}

import java.io.File;
import java.util.List;

public interface ModuleArtifactCache {
    /**
     * Adds a resolution to the index.
     *
     * The incoming file is expected to be in the persistent local. This method will not move/copy the file there. <p>
     *  @param key The key to cache this resolution under in the index. Cannot be null.
     * @param artifactFile The artifact file in the persistent file store. Cannot be null

    @JvmStatic
    fun main(args: Array<String>) {
        val resolution = schema.resolve(
            """
            val myD = newD("shared")

            val c1 = c(1)
            c1.d = myD
            str = c1.d.id
            """.trimIndent()
        )
        printResolutionResults(resolution)
        printResolvedAssignments(resolution)
    }

object EmptyBlocksTest {
    @Test
    fun `empty configuring block leads to object access`() {
        val resolution = schema.resolve(
            """
            configuring { }
            """.trimIndent()
        )

        val result = runtimeInstanceFromResult(schema, resolution, kotlinFunctionAsConfigureLambda, RuntimeCustomAccessors.none, ::TopLevel)

        assertTrue { result.configuredLazy.isInitialized() }

    /**
     * Discard any configuration state that is not required after graph resolution has been attempted.
     */
    void maybeDiscardStateRequiredForGraphResolution();

    /**
     * Sets whether or not any configuration resolution is final and the state required for resolution can be
     * discarded.  Setting this to true implies that the configuration may be re-resolved again in the future.
     *

        val resolution = schema.resolve(
            """
            val m = my1()

            my {
                my = m
            }

            my {
                val m = my2()
                my = m
            }
            """.trimIndent()
        )

        val rhsOrigins = resolution.assignments.map { it.rhs as ObjectOrigin.FromLocalValue }

/**
 * Provides an indexed view into cached artifacts and a record of resolution attempts, successful or not.
 *
 * Maintains references to the location of files in the persistent local. Does not deal with moving files into the local.
 *
 * @param <K> The type of the key to the index
 */
public interface CachedExternalResourceIndex<K> {

    /**
     * Adds a resolution to the index.
     *

import kotlin.test.Test
import kotlin.test.assertEquals


object OriginReplacementTest {
    @Test
    fun `replaces configured object access and function call receiver`() {
        with(resolution("configuring { property = value() }")) {
            val assignment = assignments.single()
            val lhs = replaceInnerReceiverWithTopLevel(assignment.lhs.receiverObject)

import org.eclipse.aether.resolution.ArtifactDescriptorException;
import org.eclipse.aether.resolution.ArtifactDescriptorPolicy;
import org.eclipse.aether.resolution.ArtifactDescriptorPolicyRequest;
import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
import org.eclipse.aether.resolution.ArtifactDescriptorResult;
import org.eclipse.aether.resolution.ArtifactRequest;

 */

package org.gradle.internal.component.resolution.failure.describer;

import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.internal.component.resolution.failure.exception.AbstractResolutionFailureException;
import org.gradle.internal.component.resolution.failure.type.ResolutionFailure;

import java.util.Optional;

/**