abstract int getNumber()
        abstract void setNumber(int value)
    }

    def "rule class can have abstract getter and setter"() {
        expect:
        extract(AbstractPropertyRules).empty
    }

    def "can create instance of rule class with abstract getter and setter"() {
        when:
        def schema = extractor.extract(AbstractPropertyRules)
        def instance = schema.factory.create()

        file("merge.txt").text == "one,two"
    }

    @Issue("https://github.com/gradle/gradle/issues/12832")
    def "can use += convenience in Groovy DSL to add elements to file collection when property has legacy setter"() {
        taskTypeLogsInputFileCollectionContent()
        buildFile << """
            class LegacyTask extends ShowFilesTask {
                void setInFiles(def c) {
                    inFiles.from = c

            strict(methodShouldNotBeAnnotatedMessage { type(TypeWithAnnotatedNonGetterMethods.canonicalName).kind('setter').method('setSomething').annotation('Large').includeLink() }),

            }
        })

        then:
        publication.artifacts == [mavenArtifact] as Set
        publication.publishableArtifacts.files.files == [pomFile, artifactFile] as Set
    }

    def "can use setter to replace existing artifacts set"() {
        given:
        def publication = createPublication()
        def mavenArtifact1 = Mock(MavenArtifact)
        def mavenArtifact2 = Mock(MavenArtifact)

        when:

  // going via GetMarkForCompilationPassFlags() to avoid infinite recursion. The
  // latter will try to setup and parse flags, which would bring us back to this
  // setter.
  if (absl::SimpleAtoi(value, &opt_level)) {
    mark_for_compilation_flags->xla_auto_jit_flag
        .optimization_level_single_gpu = opt_level;
    mark_for_compilation_flags->xla_auto_jit_flag.optimization_level_general =

// A Value can be changed only if it is addressable and was not
// obtained by the use of unexported struct fields.
// If CanSet returns false, calling Set or any type-specific
// setter (e.g., SetBool, SetInt) will panic.
func (v Value) CanSet() bool {
	return v.flag&(flagAddr|flagRO) == flagAddr
}

// Elem returns the value that the interface v contains
// or that the pointer v points to.

        then:
        properties*.name == ["name"]
        properties*.type == [ModelType.of(String)]
    }

    interface SetterOnlyUnmanaged {
        void setName(String name);
    }

    def "setter only unmanaged"() {
        when:
        def schema = extract(SetterOnlyUnmanaged)

        then:
        assert schema instanceof UnmanagedImplStructSchema
        schema.getProperty("name") == null
    }

    // Copy params from this page's URL.
    const params = url.searchParams;
    for (const p of new URLSearchParams(window.location.search)) {
      params.set(p[0], p[1]);
    }

    // Give the params to the setter to modify.
    paramSetter(params);

    elem.href = url.toString();
  }

  function handleTopClick(e) {
    // Walk back until we find TR and then get the Name column (index 5)
    let elem = e.target;

- [`KT-64825`](https://youtrack.jetbrains.com/issue/KT-64825) Analysis API. Cannot compute containing PSI for unknown source kind 'org.jetbrains.kotlin.KtFakeSourceElementKind$DefaultAccessor' exception on getContainingSymbol call for default setter parameter
- [`KT-64080`](https://youtrack.jetbrains.com/issue/KT-64080) K2: Analysis API: On-air resolve does not trigger resolution of delegated super call arguments

        """

        when:
        run "consumer"
        then:
        executedAndNotSkipped(":producer", ":consumer")
    }

    @Issue("https://github.com/gradle/gradle/issues/13623")
    def "setter for #fieldModifier property with different type doesn't cause drop of task dependency"() {
        buildFile """
            abstract class Producer extends DefaultTask {