if err != nil && s.RemoteKubeConfigFileOptional {
			if err != rest.ErrNotInCluster {
				klog.Warningf("failed to read in-cluster kubeconfig for delegated authentication: %v", err)
			}
			return nil, nil
		}
	}
	if err != nil {
		return nil, fmt.Errorf("failed to get delegated authentication kubeconfig: %v", err)
	}

	// set high qps/burst limits since this will effectively limit API server responsiveness

    }

    /**
     * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
     * Otherwise, returns `null`
     */
    override val callableId: CallableId? by cached {
        val fir = firSymbol.fir
        if (fir is FirSyntheticPropertyAccessor) {
            fir.delegate.symbol.callableId
        } else null
    }

 * implementations and replacing them with a "stub" that will throw an
 * {@link UnsupportedOperationException} if called at runtime. All members (including but
 * not limited to stripped and stubbed methods) are delegated to a {@link ClassWriter}
 * responsible for writing new API classes.
 */
public class MethodStubbingApiMemberAdapter extends ClassVisitor {

    private static final String UOE_METHOD = "$unsupportedOpEx";

import java.io.Writer;
import javax.annotation.CheckForNull;

/**
 * Writer that places all output on an {@link Appendable} target. If the target is {@link Flushable}
 * or {@link Closeable}, flush()es and close()s will also be delegated to the target.
 *
 * @author Alan Green
 * @author Sebastian Kanthak
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
class AppendableWriter extends Writer {

                value = "changed"
            }
        }

        then:
        container.asList() == [created]
        created.value == "changed"
    }

    def "register methods delegated to parent"() {
        given:
        def container = parent.containerWithType(CreatedSubType)
        container.register("createdOne")
        container.register("createdTwo") {
            it.value = "changed"

        fixture.assertStateStored {
            projectsConfigured(":", ":a", ":b")
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/28204")
    def "access to #description delegated property value is causing a violation"() {
        given:
        settingsFile << """
            include("a")
        """
        buildKotlinFile << """

            ?: throw IllegalStateException(
                "Element '$name' of type '${it::class.java.name}' from container '$this' cannot be cast to '${T::class.qualifiedName}'."
            )
    }


/**
 * Delegated property getter that locates extensions.
 */
inline operator fun <reified T : Any> ExtensionContainer.getValue(thisRef: Any?, property: KProperty<*>): T =
    getByName<T>(property.name)


/**

    /**
     * This is a performance optimization which avoids using BeanDynamicObject to wrap the Script object.
     * Using BeanDynamicObject would be wasteful, because most of the interesting properties and methods
     * are delegated to the script target. Doing this delegation explicitly avoids
     * us going through the methodMissing/propertyMissing protocol that BeanDynamicObject would use.
     */

}

// Validate validates RuntimeConfig with a list of registries.
// Usually this list only has one element, the apiserver registry of the process.
// But in the advanced (and usually not recommended) case of delegated apiservers there can be more.
// Validate will filter out the known groups of each registry.
// If anything is left over after that, an error is returned.

     * e.g,
     * ```
     * interface A { fun x() }
     * class B(a: A) : A by a
     * ```
     * the `B.foo` function will be generated by Kotlin compiler
     */
    DELEGATED,


    JAVA_SYNTHETIC_PROPERTY,

    /**
     * Declaration is backing field of some member property
     * A symbol kind of [KaBackingFieldSymbol]
     *
     * @see KaBackingFieldSymbol