InstrumentationAnalysisTransform.class,
            spec -> {
                spec.getFrom().attribute(INSTRUMENTED_ATTRIBUTE, NOT_INSTRUMENTED.getValue());
                spec.getTo().attribute(INSTRUMENTED_ATTRIBUTE, ANALYZED_ARTIFACT.getValue());
                spec.parameters(params -> {
                    params.getBuildService().set(service);
                    params.getContextId().set(contextId);

                String value = options.option(config.getLongOption()).getValue();
                applyTo(value, settings, Origin.forCommandLine(config.getLongOption()));
            }
        }
    }

    private void applyTo(String value, T settings, Origin origin) {
        applyTo(getValue(value), settings, origin);
    }

    private E getValue(String value) {
        E enumValue = null;
        if (value != null) {

      V oldValue = forwardDelegate.putIfAbsent(e.getKey(), e.getValue());
      if (oldValue != null) {
        throw conflictException("key", e.getKey() + "=" + oldValue, entryArray[i]);
      }
      K oldKey = backwardDelegate.putIfAbsent(e.getValue(), e.getKey());
      if (oldKey != null) {
        throw conflictException("value", oldKey + "=" + e.getValue(), entryArray[i]);
      }
    }

  if (!padding) {
    return func_.emitWarning() << "'padding' attribute for " << kMaxUnpooling
                               << " is not set or not a string";
  }
  if (padding.getValue() != "VALID" && padding.getValue() != "SAME") {
    return func_.emitWarning()
           << "Padding for " << kMaxUnpooling << " must be 'SAME' or 'VALID'";
  }
  return success();
}

import org.gradle.kotlin.dsl.support.uncheckedCast

import kotlin.reflect.KProperty


/**
 * Provides efficient access to a property.
 */
interface PropertyDelegate {
    operator fun <T> getValue(receiver: Any?, property: KProperty<*>): T
}


/**
 * Provides efficient access to a mutable dynamic property.
 */
interface MutablePropertyDelegate : PropertyDelegate {

package org.gradle.tooling.internal.provider;

import java.io.Serializable;

public class WrapperPayload implements Serializable, PayloadInterface {
    PayloadInterface payload;

    public String getValue() {
        return payload.getValue();
    }

            .getValue());
    return init_func_op;
  }
  return nullptr;
}

// Returns ID for identifying a resource.
std::tuple<StringRef, StringRef, StringRef> GetResourceKey(Operation* op) {
  StringRef device;
  if (auto attr = op->getAttrOfType<StringAttr>("device")) {
    device = attr.getValue();
  }

  StringRef container;

                val lhsNode = ResolutionNode.Property(lhsPropertyWithResolvedReceiver)

                if (lhsNode in assignmentByNode && hasAssignmentInTheSameGeneration(assignmentByNode.getValue(lhsNode), generationId)) {
                    AssignmentAdditionResult.Reassignment(lhsPropertyWithResolvedReceiver)
                } else when (val rhsResult = resolveToObjectOrPropertyReference(rhsOrigin)) {

            allprojects {
                apply plugin: CustomPlugin
            }

            interface CustomParameter {
                void setValue(String str);
                String getValue();
            }

            class DefaultCustomModel implements Serializable {
                private final boolean builtWithParameter;
                private final String parameterValue;

        buildFile << """
            import ${Inject.name}

            abstract class UsesWorker extends DefaultTask {
                @Input
                abstract ${type} getValue()

                @Inject
                abstract WorkerExecutor getExecutor()

                @TaskAction
                def go() {
                    def flag = value