String propertyName = request.getInterceptedCallable().getCallableName();
            String setterName = "set" + TextUtil.capitalize(propertyName);
            scopeExpressions.add(CodeBlock.of("$1T.writesOfPropertiesNamed($2S)", INTERCEPTED_SCOPE_CLASS, propertyName));

@NonNullApi
public interface TypeAwareProblemBuilder extends InternalProblemSpec {
    TypeAwareProblemBuilder withAnnotationType(@Nullable Class<?> classWithAnnotationAttached);

    TypeAwareProblemBuilder forProperty(String propertyName);

    TypeAwareProblemBuilder parentProperty(@Nullable String parentProperty);

                'Use a URI or URL instance',
                'Use a TextResource instance',
            ]
            additionalData.asMap == [
                'typeName': 'org.gradle.api.DefaultTask',
                'propertyName': 'input',
            ]
        }

        where:
        method | targetType
        "dir"  | "directory"
        "file" | "file"
    }

        require(propertyAccess.receiver != null) { "Property access with explicit receiver expected" }

        val propertyName = propertyAccess.name

        expressionResolver.doResolveExpression(this, propertyAccess.receiver)?.let { receiverOrigin ->
            findDataProperty(getDataType(receiverOrigin), propertyName)?.let { property ->
                onProperty(ObjectOrigin.PropertyReference(receiverOrigin, property, propertyAccess))

        return getters.map { (name, getter) ->
            checkNotNull(getter)
            val nameAfterGet = name.substringAfter("get")
            val propertyName = nameAfterGet.replaceFirstChar { it.lowercase(Locale.getDefault()) }
            val type = propertyValueType(getter.returnType).toDataTypeRefOrError()

                with(it.find { it instanceof Map && it['propertyName'] == 'stableClasspath' }, Map) {
                    files.collect { new File(it as String) }.containsAll(expectedClasspath)
                }
            }
            with(outputFileProperties, List) {
                !empty
                with(it.find { it instanceof Map && it['propertyName'] == 'reports.enabledReports.html.outputLocation' }, Map) {

                                pluginId = in.nextString();
                                break;
                            }
                            case "propertyName": {
                                propertyName = in.nextString();
                                break;
                            }
                            case "parentPropertyName": {

            Optional.ofNullable(data.getPluginId()).ifPresent(pluginId -> builder.put("pluginId", pluginId));
            Optional.ofNullable(data.getPropertyName()).ifPresent(propertyName -> builder.put("propertyName", propertyName));
            Optional.ofNullable(data.getParentPropertyName()).ifPresent(parentPropertyName -> builder.put("parentPropertyName", parentPropertyName));

            }
        }

        private
        fun verifyTryGetProperty(propertyName: String) =
            inOrder(target, dynamicObject) {
                verify(target as DynamicObjectAware).asDynamicObject
                verify(dynamicObject).tryGetProperty(propertyName)
                verifyNoMoreInteractions()
            }

    }

    def "logs deprecated property message"() {
        when:
        DeprecationLogger.deprecateProperty(DeprecationLogger, "propertyName").withAdvice("Advice.").willBeRemovedInGradle9().undocumented().nagUser()

        then:
        expectMessage "The DeprecationLogger.propertyName property has been deprecated. This is scheduled to be removed in Gradle ${NEXT_GRADLE_VERSION}. Advice."
    }