private final String propertyName;
    private final Method getter;
    private final TypeToken<?> declaredType;
    private final ImmutableMap<AnnotationCategory, Annotation> annotationsByCategory;
    private final ImmutableMap<Class<? extends Annotation>, Annotation> annotationsByType;

    private final String propertyName;
    private Map<PropertyAccessorType, PropertyAccessorExtractionContext> accessors;

    public ModelPropertyExtractionContext(String propertyName) {
        this.propertyName = propertyName;
        this.accessors = Maps.newEnumMap(PropertyAccessorType.class);
    }

    public String getPropertyName() {
        return propertyName;
    }

    public boolean isReadable() {

                    continue;
                }

                ModelType<?> propertyType = determineManagedPropertyType(extractionContext, propertyName, accessorBindings);
                ModelSchema<?> propertySchema = schemaStore.getSchema(propertyType);

    private
    fun getterName(propertyName: String) = "get" + capitalize(propertyName)

    private
    fun setterName(propertyName: String) = "set" + capitalize(propertyName)

    private
    fun capitalize(propertyName: String) = propertyName.replaceFirstChar {
        if (it.isLowerCase()) it.uppercaseChar() else it
    }
}

        private final List<ReplacedAccessor> replacedAccessors;

        public UpgradedProperty(String containingType, String propertyName, String methodName, String methodDescriptor, List<ReplacedAccessor> replacedAccessors) {
            this.containingType = containingType;
            this.propertyName = propertyName;
            this.methodName = methodName;
            this.methodDescriptor = methodDescriptor;

     * requirements.
     *
     * @param validationContext the validation context
     * @param propertyName the name of the property
     * @param beanType the type of the bean
     */
    public static void validateBeanType(
        TypeValidationContext validationContext,
        String propertyName,
        Class<?> beanType
    ) {
        getUnsupportedReason(beanType).ifPresent(reason ->

            // And being empty archives is not reflected in the fingerprint.
            return hasEmptyFingerprints(sourceFileProperties, propertyName -> !propertiesRequiringIsEmptyCheck.contains(propertyName))
                && hasEmptyInputFileCollections(work, propertiesRequiringIsEmptyCheck::contains);
        }
    }

public interface PropertyVisitor {
    default void visitInputFileProperty(String propertyName, boolean optional, InputBehavior behavior, DirectorySensitivity directorySensitivity, LineEndingSensitivity lineEndingSensitivity, @Nullable FileNormalizer fileNormalizer, PropertyValue value, InputFilePropertyType filePropertyType) {}

    default void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {}

    @Nullable
    @Override
    public String obtain() {
        @Nullable String propertyName = propertyNameOrNull();
        if (propertyName == null) {
            return null;
        }
        return System.getProperty(propertyName);
    }

    @Override
    public String getDisplayName() {
        return String.format("system property '%s'", propertyNameOrNull());

            if (targetMetadata.hasProperty(null, propertyName) == null) {
                if (propertyName == "class") {
                    return javaClass
                }
                throw MissingPropertyException(propertyName)
            }
            scriptReferenced()
        }

        override fun setProperty(propertyName: String, newValue: Any?) {