}
    }

    private static class DefaultValidationProblemGroup extends DefaultProblemGroup implements ValidationProblemGroup {

        private final ProblemGroup property = new DefaultProblemGroup("property-validation", "Gradle property validation", this);

        private final ProblemGroup type = new DefaultProblemGroup("type-validation", "Gradle type validation", this);

            }
            builder.append(rootType.get()).append("' ");
        }

        Object property = additionalData.map(TypeValidationData::getPropertyName).orElse(null);
        if (property != null) {
            if (typeRelevant) {
                builder.append("property '");
            } else {
                if (pluginId.isPresent()) {
                    builder.append("In plugin '")

                                        $property $modification
                                    }
                                }
                            }
                        }
                    }
                }
            }
        """

        and:
        succeeds ':test'

        then:
        skipped ':test'

        where:
        property                 | modification

        'validation:property-validation:unexpected-input-file-type' : 'Unexpected input file type',
        'validation:property-validation:unsupported-notation' : 'Property has unsupported value',
        'validation:property-validation:unknown-implementation' : 'Unknown property implementation',

    @Test
    fun `field of bean found in input property of task`() {

        val beanType = PropertyTraceTest::class.java
        val taskType = Task::class.java

        assertThat(
            PropertyTrace.Property(
                PropertyKind.Field,
                "f",
                PropertyTrace.Bean(
                    beanType,
                    PropertyTrace.Property(
                        PropertyKind.InputProperty,

import org.jetbrains.kotlin.analysis.api.base.KaConstantValue
import org.jetbrains.kotlin.psi.KtExpression

/**
 * Value representing some property or variable initializer
 */
public sealed class KaInitializerValue {
    /**
     * [com.intellij.psi.PsiElement] of initializer. May be null if property/variable came from non-source file.
     */
    public abstract val initializerPsi: KtExpression?
}

/**

 * that they don't leak the service: the lifetime of the property should be shorter or as long as the lifetime of the cached service.
 *
 * When caching a service inside another service, the property should also be [lazy] to avoid issues with cyclic service initialization and
 * excessive class loading on startup.
 *

 * limitations under the License.
 */

package gradlebuild.basics

import org.gradle.api.file.DirectoryProperty
import org.gradle.api.provider.Property


interface BuildEnvironmentExtension {
    val gitCommitId: Property<String>
    val gitBranch: Property<String>
    val repoRoot: DirectoryProperty

 *
 * <p>
 * The store considers property annotations to belong to {@linkplain AnnotationCategory categories}.
 * Each property can have at most one annotation per category.
 * Validation failures with a given type can be visited using {@link TypeAnnotationMetadata#visitValidationFailures(TypeValidationContext)}.
 * </p>
 *
 * <strong>Property annotation inheritance</strong>
 *
 * <p>

                append("Gradle runtime")
            }

            is Property -> {
                append(trace.kind)
                append(" ")
                quoted(trace.name)
                append(" of ")
            }

            is SystemProperty -> {
                append("system property ")
                quoted(trace.name)
                append(" set at ")
            }