import org.gradle.util.internal.TextUtil;

import static org.gradle.api.problems.Severity.ERROR;
import static org.gradle.internal.deprecation.Documentation.userManual;

/**
 * A handler for properties discovered without a valid annotation.
 */
public interface MissingPropertyAnnotationHandler {
    void handleMissingPropertyAnnotation(TypeValidationContext context, PropertyAnnotationMetadata annotationMetadata, String displayName);

     * that the output is generated in a stable order rather than in an order based on the order that implementations
     * are discovered.
     */
    String getId();

    /**
     * Notifies the build user of whatever problems have been collected. May report problems to the console, or generate a report

        registry.register(barRegistration)
        def foo = registry.atStateOrLater(fooReference.path, ModelNode.State.Discovered)

        then:
        !foo.promise.canBeViewedAs(ModelType.of(String))
        foo.promise.canBeViewedAs(ModelType.of(List))

        registry.realize(fooReference.path, fooReference.type).is(fooList)

  // Value: Information we know about that Value.
  // Note that these Value's are in general in different functions.
  DenseMap<Value, ResourceInfo> resource_infos_;
  // The set of regions we already discovered.
  DenseSet<Region*> discovered_;
  // Identifiers about mutable variables.
  // All variables are identified by (device, container, shared_name).
  DenseSet<std::tuple<llvm::StringRef, llvm::StringRef, llvm::StringRef>>

/**
 * A hard-coded sequence of model actions that can be applied to a model element.
 *
 * <p>This is pretty much a placeholder for something more descriptive.
 */
public enum ModelActionRole {
    Discover(ModelNode.State.Discovered, false), // Defines all projections for the node
    Create(ModelNode.State.Created, false), // Initializes the node
    Defaults(ModelNode.State.DefaultsApplied, true), // Allows a mutation to setup default values for an element

 * One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *
 * The default implementation will look for a {@code .mvn} child directory
 * or a {@code pom.xml} containing the {@code root="true"} attribute.
 *
 * @see DefaultRootLocator
 */

        then:
        NoSuchMethodException e = thrown()
        e.message == /Could not find method unknown() on JavaMethodTestSubjectSubclass./
    }

    def "default methods are discovered"() {
        expect:
        JavaMethod.of(JavaMethodTestSubjectSubclass, String, "defaultMethod").invoke(new JavaMethodTestSubjectSubclass()) == "parent-interface"
    }

        output.contains 'Output: outputFiles$2 [output2.txt]'
    }

    @ToBeFixedForConfigurationCache(because = "task references another task")
    def "nested properties are discovered"() {
        buildFile << classesForNestedProperties()
        buildFile << """
            task test(type: TaskWithNestedObjectProperty) {
                input = "someString"

        collection.visitDependencies(Stub(TaskDependencyResolveContext))

        then:
        registry.state("tasks.redundant") == ModelNode.State.Discovered
    }

    def "realize is idempotent"() {
        given:
        ModelRegistryHelper registry = new ModelRegistryHelper()
        ModelPath path = ModelPath.path("tasks")

 * One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *
 * The default implementation will look for a {@code .mvn} child directory
 * or a {@code pom.xml} containing the {@code root="true"} attribute.
 */
public interface RootLocator {