* limitations under the License.
 */

package org.gradle.internal.metaobject;

/**
 * An implementation of a Groovy MetaClass that is instrumented and might need to cancel some optimizations
 * in order to get the instrumentation to work properly.
 */
public interface InstrumentedMetaClass {
    /**

    @Override
    public Pair<RelativePath, ClassVisitor> apply(ClasspathEntryVisitor.Entry entry, ClassVisitor visitor, ClassData classData) throws IOException {
        return first.apply(entry, second.apply(entry, visitor, classData).right, classData);
    }

 * This is due to the contract of this public API that is stricter than what is expected in the Gradle internals.
 * <p>
 * For example, the implementation of such an API might add validations checking third-party
 * plugins or build scripts for compliance with some limitations imposed by Gradle. In the internal
 * code, one does not expect such limitations.
 * <p>

        return credentialsProviderFactory.provide(credentialsType, identity);
    }

    @Override
    public <A, B, R> Provider<R> zip(Provider<A> left, Provider<B> right, BiFunction<? super A, ? super B, ? extends R> combiner) {
        return left.zip(right, combiner);
    }

        val hasher = Hashing.newHasher()
        // This routine is used to snapshot results of File.list(), File.listFiles() and similar calls.
        // Technically, the relative order or entries is visible to the caller, so it might be considered when computing the hash.
        // However, the File.list spec leaves the order undefined, so no reasonable implementation should depend on it.

    def buildFinishedHandler = Mock(IntermediateResultHandler)
    def listener = new DefaultPhasedActionResultListener(projectsLoadedHandler, buildFinishedHandler)

    def "right handler is called"() {
        when:
        listener.onResult(new ProjectsLoadedResult<String>('result1'))
        listener.onResult(new BuildFinishedResult<String>('result2'))

        then:

        warn(
            """
                WARNING: Unsupported Kotlin plugin version.
                The `embedded-kotlin` and `kotlin-dsl` plugins rely on features of Kotlin `{}` that might work differently than in the requested version `{}`.
            """.trimIndent(),
            embeddedKotlinVersion,
            kotlinVersion
        )
    }
}


internal

            attach(unassignedProgressOperations.pop());
        }
    }

    // Declares that we are stopping showing updates from this ProgressOperation.
    // We might be completely done following this ProgressOperation, or
    // we might simply be waiting for its children to complete.
    private void unshow(ProgressOperation operation) {
        OperationIdentifier operationId = operation.getOperationId();

            Class.forName(superclass.name, true, superclass.classLoader)
            maybeInit(superclass)
        }
    }

    // TODO: What about the runtime decorations a serialized bean might have had at configuration time?
    private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =

        return cacheBuilderFactory.getRootDir();
    }

    /**
     * Is the build using an empty settings because a build definition is missing from the current directory?
     *
     * <p>There are two cases where this might be true: Gradle was invoked from a directory where there is no build script and no settings script in the directory hierarchy,