The new [ChaCha8.Read] method implements the [io.Reader] interface....

     */
    fun isEnabledForCurrentThread(): Boolean = inputTrackingDisabledCounterForThread == 0

    /**
     * Disables input tracking for the current thread. Multiple calls to this method "stack", so if
     * this method was called twice then [restoreForCurrentThread] should also be called twice to
     * enable input tracking back.
     */
    fun disableForCurrentThread() {
        ++inputTrackingDisabledCounterForThread

 */
@Incubating
public interface IsolatedProject {

    /**
     * <p>Returns the name of this project. The project's name is not necessarily unique within a project hierarchy. You
     * should use the {@link #getPath()} method for a unique identifier for the project.
     * If the root project is unnamed and is located on a file system root it will have a randomly-generated name
     * </p>
     *

The patterns used by [ServeMux] now allow one or more spaces or tabs after the method name.

 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *
 * <p>To use an existing supplier instance (say, named {@code supplier}) in a context where the
 * <i>other type</i> of supplier is expected, use the method reference {@code supplier::get}. A

package org.gradle.internal.cc.impl

class ConfigurationCacheJavaSerializationIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "restores task fields whose value is Serializable and has writeReplace method"() {
        buildFile << """
            class Placeholder implements Serializable {
                String value

                private Object readResolve() {

import org.gradle.test.fixtures.file.TestFile

class UnrelatedMethodInstrumentationInDynamicGroovyIntegrationTest extends AbstractProcessInstrumentationIntegrationTest implements DynamicGroovyPluginMixin {
    def "calling an unrelated method is allowed in groovy build script #indyStatus"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        generateClassesWithClashingMethods()

        withPluginCode("""

    /**
     * Returns the name for this variant, which is unique for the variants of its owning component.
     *
     * In general, this method should be avoided. The internal engine should not need to know the name of a node and
     * should instead identify nodes based on their integer node ID. This method should only be used for
     * diagnostics/reporting and for implementing existing public API methods that require this field.
     */

     * <p>
     * Given the type used, this method returns the simple version even for versions lower than 5.
     *
     * @return the version number
     * @see #toString()
     */
    int asInt();

    /**
     * Return this version as a String, "14" for Java 14.
     * <p>
     * This method will return {@code 1.<version>} when the version is lower than 5.
     *
     * @since 6.8

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type I interface{ M() }

type _ interface {
	I
	I // ERROR "duplicate method M"