* <p>Allows default values for the properties of this object to be declared. Most implementations are generated at
 * run-time from existing classes, by a {@link org.gradle.api.internal.Instantiator} implementation.</p>
 *
 * <p>Each getter of an {@code IConventionAware} object should use the mappings to determine the value for the property,
 * when no value has been explicitly set for the property.</p>
 */
public interface IConventionAware {

    /**

        public Directory call() throws Exception {
            Method getter = GeneratedSubclasses.unpackType(compile).getMethod("getDestinationDir");
            if (getter.getDeclaringClass() == AbstractCompile.class) {
                // Subclass has not overridden the getter, so ignore
                return null;
            }

            // Subclass has overridden the getter, so call it

            if (recursiveCall) {

	includeMx bool,
) []*listener.Filter {
	idleTimeout := destinationRule.GetTrafficPolicy().GetConnectionPool().GetTcp().GetIdleTimeout()
	if idleTimeout == nil {
		idleTimeout = parseDuration(lb.node.Metadata.IdleTimeout)
	}
	tcpProxy := &tcp.TcpProxy{
		StatPrefix:                      statPrefix,

import org.gradle.api.Incubating;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to the getter for a property on a {@link RuleSource} to denote that the property defines the target for the rule source.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Incubating
public @interface RuleTarget {

import java.lang.annotation.Target;

/**
 * Indicates that a property of a managed model element is explicitly of an unmanaged type.
 * <p>
 * This annotation must be present on the <b>getter</b> of the property for the unmanaged type.
 * If the annotation is not present for a property that is not a managed type, a fatal error will occur.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)

                    if (accessor.getAccessorType() == PropertyAccessorType.SETTER) {
                        throw invalidProperty(extractionContext, property, "@Variant annotation is only allowed on getter methods");
                    }
                    Class<?> propertyType = property.getType().getRawClass();
                    if (!String.class.equals(propertyType) && !Named.class.isAssignableFrom(propertyType)) {

			authz.SetupLocal(&localAuthzServer, namespace.Future(&echo1NS)),
			deployment.SetupTwoNamespaces(&apps, deployment.Config{
				IncludeExtAuthz: true,
				Namespaces: []namespace.Getter{
					namespace.Future(&echo1NS),
					namespace.Future(&echo2NS),
				},
				ExternalNamespace: namespace.Future(&externalNS),
			})).
		Run()

    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KaSession.restoreSymbol")
    override fun restoreSymbol(analysisSession: KaSession): KaPropertyGetterSymbol? {
        return restorePropertySymbol(analysisSession)?.getter
    }
}

@KaAnalysisApiInternals
class KaPropertySetterSymbolPointer(
    propertySymbolPointer: KaSymbolPointer<KaPropertySymbol>,
) : KaPropertyAccessorSymbolPointer<KaPropertySetterSymbol>(propertySymbolPointer) {

    /**
     * Associates this property with the task that produces its value.
     */
    void attachProducer(ModelObject owner);

    /**
     * A simple getter that checks if this property has been finalized.
     *
     * @return {@code true} if this property has been finalized, {@code false} otherwise
     */
    boolean isFinalized();

import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target({ElementType.ANNOTATION_TYPE})
public @interface ReplacedAccessor {

    enum AccessorType {
        GETTER,
        SETTER
    }

    AccessorType value();

    /**
     * The name of the accessor, e.g. `getDestinationDir` or `setDestinationDir`
     */
    String name();

    /**