return __modifiedProperties.getPropertyNames();
    }

    public void mymodifyProperty(String propertyName) {
        registerModifiedProperty(propertyName);
    }

    public void mymodifyPropertyCancel(String propertyName) {
        __modifiedProperties.remove(propertyName);
    }

    public void clearModifiedInfo() {
        __modifiedProperties.clear();
    }

    override fun property(receiver: DynamicObject, propertyName: String): Any? =
        withDynamicCall(receiver) {
            receiver.getProperty(propertyName)
        }

    override fun findProperty(receiver: DynamicObject, propertyName: String): Any? =
        withDynamicCall(receiver) {
            val dynamicInvokeResult: DynamicInvokeResult = receiver.tryGetProperty(propertyName)

    public PropertyDescImpl(final String propertyName, final Class<?> propertyType, final Method readMethod, final Method writeMethod,
            final Field field, final BeanDesc beanDesc) {
        assertArgumentNotEmpty("propertyName", propertyName);
        assertArgumentNotNull("propertyType", propertyType);
        assertArgumentNotNull("beanDesc", beanDesc);

        this.propertyName = propertyName;
        this.propertyType = propertyType;

        return new NamedMemberScope(CallType.GET_PROPERTY, propertyName);
    }

    /**
     * The returned scope includes writes of all properties named {@code propertyName}.
     * This scope doesn't include calls to the setter method corresponding to this property,
     * use additional explicit {@link #methodsNamed(String)} scope to intercept that.
     *

    public UnmanagedPropertyMissingSetterException(String propertyName) {
        super(getMessage(propertyName));
    }

    private static String getMessage(String propertyName) {
        return String.format(
            "unmanaged property '%s' cannot be read only, unmanaged properties must have setters",
            propertyName);
    }

    private final String propertyName;
    private final PropertyValue value;
    private final boolean optional;
    private final ValidationAction validationAction;

    public AbstractValidatingProperty(String propertyName, PropertyValue value, boolean optional, ValidationAction validationAction) {
        this.propertyName = propertyName;
        this.value = value;
        this.optional = optional;

        });

        beforeExecutionState.getInputProperties().forEach((propertyName, valueSnapshot) -> {
            if (logger.isWarnEnabled()) {
                logger.warn("Appending input value fingerprint for '{}' to build cache key: {}",
                    propertyName, Hashing.hashHashable(valueSnapshot));
            }
            cacheKeyHasher.putString(propertyName);
            valueSnapshot.appendToHasher(cacheKeyHasher);
        });

public class OverlappingOutputs {
    private final String propertyName;
    private final String overlappedFilePath;

    public OverlappingOutputs(String propertyName, String overlappedFilePath) {
        this.propertyName = propertyName;
        this.overlappedFilePath = overlappedFilePath;
    }

    public String getPropertyName() {
        return propertyName;
    }

    public String getOverlappedFilePath() {

}


private
fun fragmentsForConfiguration(accessor: Accessor.ForConfiguration): Fragments = accessor.run {

    val name = config.target
    val propertyName = name.original
    val className = "${propertyName.uppercaseFirstChar()}ConfigurationAccessorsKt"
    val (functionFlags, deprecationBlock) =

            return null;
        }

        private Accessors(JavaClass owningClass, String propertyName, Set<JavaMethod> getters, Set<JavaMethod> setters) {
            this.getters = getters;
            this.setters = setters;
            this.owningClass = owningClass;
            this.propertyName = propertyName;
        }

        public boolean nullableIsSymmetric() {