}

    def "variant annotation on setter raises error"() {
        buildFile << """
        @Managed
        interface SampleBinary extends BinarySpec {
            String getVariantProp()
            @Variant
            void setVariantProp(String variant)

        when:
        impl.otherValue {
            value = "12"
        }

        then:
        1 * prop.setValue("12")
        0 * state._
    }

    def "mixes in converting setter for managed property with scalar type"() {
        def state = Mock(ModelElementState)

        given:
        def proxyClass = generate(SomeType)
        def impl = proxyClass.newInstance(state, typeConverter)

                )

            return kotlinType.toKtType(analysisContext)
        }

        // Manually handle custom setter parameter
        if (declaration is KtParameter) {
            val parameterList = declaration.parent as? KtParameterList
            if (parameterList?.parameters?.singleOrNull() == declaration) {

  feed->mutable_id()->set_node_name("feed0");
  feed->set_name("myfeed");
  feed = config.add_feed();
  feed->mutable_id()->set_node_name("feed1");
  tf2xla::Fetch* fetch = config.add_fetch();
  fetch->mutable_id()->set_node_name("fetch0");
  fetch->set_name("myfetch");
  tf2xla::Variable* variable = config.add_variable();
  variable->set_node_name("myvar_readonly");
  variable->mutable_shape()->add_dim()->set_size(1);

        if (readOnly) {
            ArchiveFileSet archiveFileSet = archiveTask instanceof Zip ? new ZipFileSet() : archiveTask.createTarFileSet()
            archiveFileSet.setDir(file)
            archiveFileSet.setFileMode("0444")
            archiveFileSet.setDirMode("0555")
            archiveTask.add(archiveFileSet)
        } else {
            archiveTask.setBasedir(file)
        }

	return v.Cap()
}

func setlen(x *[]int, n int) { // ERROR "x does not escape"
	v := reflect.ValueOf(x).Elem()
	v.SetLen(n)
}

func setcap(x *[]int, n int) { // ERROR "x does not escape"
	v := reflect.ValueOf(x).Elem()
	v.SetCap(n)
}

// Unfortunate: x doesn't need to escape to heap, just to result.
func slice1(x []byte) []byte { // ERROR "leaking param: x$"

		c.kubeconfig,
	}, args...)

	var out bytes.Buffer
	var err bytes.Buffer

	start := time.Now()

	invokeMutex.Lock()
	rootCmd := cmd.GetRootCmd(cmdArgs)
	rootCmd.SetOut(&out)
	rootCmd.SetErr(&err)
	// istioctl will overwrite logs which we don't want.
	// It happens to do this via PersistentPreRunE, which we can disable.

                            }
                        } else {
                            // Coerce the value to the type accepted by the property setter and invoke the setter directly
                            Class setterType = metaBeanProperty.getSetter().getParameterTypes()[0].getTheClass();
                            value = propertySetTransformer.transformValue(setterType, value);

        val previousErr = System.err
        try {
            System.setOut(outCapture)
            System.setErr(errCapture)
            block()
        } finally {
            System.out.flush()
            System.setOut(previousOut)
            outCapture.stop()
            System.err.flush()
            System.setErr(previousErr)
            errCapture.stop()
        }
    } catch (error: Throwable) {

        return super.visit(visitor);
    }

    @Override
    public PatternSet getPatterns() {
        return patternSet;
    }

    @Override
    public DefaultConfigurableFileTree setDir(Object dir) {
        from(dir);
        return this;
    }

    @Override
    public File getDir() {
        if (dir == null) {