// FILE: context.kt
import kotlin.reflect.KProperty

class Delegate(private var value: String) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        this.value = value
    }
}

fun test() {
    var x by Delegate("a")
    <caret_context>x
}


// MODULE: main

        writeableProperty(JavaTestSubject, "myProperty", String.class).setValue(myProperties, "otherValue")

        then:
        readableProperty(JavaTestSubject, String, "myProperty").getValue(myProperties) == "otherValue"
    }

    def "write property with multiple setters"() {
        when:
        writeableProperty(JavaTestSubject, "myProperty2", String.class).setValue(myProperties, "stringValue")

        then:

    def "can reference input using dollar method expression - #syntax"() {
        when:
        buildScript """
          @Managed
          interface Thing {
            String getValue(); void setValue(String str)
          }

          model {
            thing(Thing) {
                value = "foo"
            }
            tasks {
                def v = $syntax
                create("echo") {

    assertEquals("test", map.entrySet().iterator().next().getValue());
    assertThrows(
        UnsupportedOperationException.class, () -> map.entrySet().iterator().next().setValue(1));
  }

  public void testEntrySetToArrayMutationThrows() {
    map.putInstance(String.class, "test");
    @SuppressWarnings("unchecked") // Should get a CCE later if cast is wrong

      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

  @Override
  public Set<Entry<Class<? extends @NonNull B>, B>> entrySet() {

    }
    int oldCount = backingMap.getValue(entryIndex);
    long newCount = (long) oldCount + (long) occurrences;
    checkArgument(newCount <= Integer.MAX_VALUE, "too many occurrences: %s", newCount);
    backingMap.setValue(entryIndex, (int) newCount);
    size += occurrences;
    return oldCount;
  }

  @CanIgnoreReturnValue
  @Override
  public final int remove(@CheckForNull Object element, int occurrences) {

            classes[publicType] = generated
        }
        return generated
    }

    interface SomeType {
        Integer getValue()

        void setValue(Integer value)
    }

    interface SpecializedType extends SomeType {}

    interface SpecializedType2 extends SomeType {}

    static class SomeTypeImpl implements SomeType {
        SomeType target

      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

  @Override
  public Set<Entry<Class<? extends @NonNull B>, B>> entrySet() {

package org.gradle.internal.declarativedsl.mappingToJvm


fun interface DeclarativeRuntimePropertyGetter {
    fun getValue(receiver: Any): Any?
}


fun interface DeclarativeRuntimePropertySetter {
    fun setValue(receiver: Any, value: Any?)

    } finally {
      function = null;
    }

    /*
     * If set()/setValue() throws an Error, we let it propagate. Why? The most likely Error is a
     * StackOverflowError (from deep transform(..., directExecutor()) nesting), and calling
     * setException(stackOverflowError) would fail:
     *
     * - If the stack overflowed before set()/setValue() could even store the result in the output