String methodName = call.getMethodAsString();
        if (call.isImplicitThis() && methodName != null && methodName.equals(DOLLAR)) {
            visitInputMethod(call);
            return;
        }
        // visit the method call, because one of the args may be an input method call
        super.visitMethodCallExpression(call);
    }

         *
         * Because of it doing so, our decorated call site is removed from the dynamic invocation code path, and we lose the ability to track dynamic call entry points. <p>
         *
         * To fix that, we store the optimized call site that the Groovy runtime created (and we delegate to it in subsequent calls), and we put a reference to our
         * decorated call site back into the call site array.
         */

         * MetaClass.getMetaProperty(name) is very expensive when the property is not known.
         * Instead, we reach into the meta class to call a much more efficient lookup method.
         * Since we do this in a hot code path, we also reuse the argument array used for the
         * reflective call to save memory.
         */
        @Nullable
        protected MetaProperty lookupProperty(MetaClass metaClass, String name) {

     *
     * @param callable The callable to call
     * @param <T> Callable's return type
     * @return The value returned by {@link Callable#call()}
     */
    @Nullable
    public static <T> T uncheckedCall(Callable<T> callable) {
        try {
            return callable.call();
        } catch (Exception e) {
            throw throwAsUncheckedException(e);
        }

 * <strong>This type should only be extended and/or thrown by Gradle internal code.</strong>
 */
@Contextual
@HasInternalProtocol
public class ResolveException extends DefaultMultiCauseException {

    /**
     * Do not call this constructor.
     *
     * @deprecated This constructor will be removed in 9.0
     */
    @Deprecated
    public ResolveException(String message, Throwable cause) {
        super(message, cause);

    String getName();

    /**
     * This method or {@link #withInputStream(IoFunction)} ()} may or may not support being called more than
     * once per entry.  Use {@link #canReopen()} to determine if more than one call is supported.
     */
    byte[] getContent() throws IOException;

    /**
     * Declare an action to be run against this ZipEntry's content as a {@link InputStream}.

        extensionMapping.map("sourceSets", Callables.returning(new ArrayList<>()));
        extensionMapping.map("reportsDir", new Callable<File>() {
            @Override
            public File call() {
                return project.getExtensions().getByType(ReportingExtension.class).file(getReportName());
            }
        });
        withBasePlugin(new Action<Plugin>() {
            @Override

                switch (value.getMaximumNumberOfParameters()) {
                    case 0:
                        return value.call();
                    case 1:
                        return value.call(convention);
                    default:
                        return value.call(convention, conventionAwareObject);
                }
            }
        });
    }

    @Override

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)

            override fun invoke(receiver: Any): DependencyCollector = getterFunction.call(receiver) as DependencyCollector
        }

        data class Property(val property: KProperty<*>) : DependencyCollectorAccessor {
            override fun invoke(receiver: Any): DependencyCollector = property.call(receiver) as DependencyCollector
        }
    }

    private