get() = withValidityAssertion {
            val fir = firSymbol.fir as FirSyntheticProperty
            return fir.setter?.delegate?.let { builder.functionLikeBuilder.buildFunctionSymbol(it.symbol) }
        }

    override val setter: KaPropertySetterSymbol?
        get() = withValidityAssertion {

                        }
                    }
                    fir.setter?.let { setter ->
                        methods.singleOrNull { it.name.startsWith("set") }?.let {
                            bindings.put(METHOD_FOR_FIR_FUNCTION, setter, Method(it.name, getAsmMethodSignatureWithCorrection(it)))
                        }
                    }

        then:
        IllegalArgumentException e = thrown()
        e.message == "There's an extension registered with name 'foo'. You should not reassign it via a property setter."
    }

    def "can register extensions using dynamic property setter"() {
        when:
        container.foo = extension

        then:
        container.findByName('foo') == extension
    }

        testCase                                    | convention
        "id has convention set twice"               | setId("convention") + setId("again")
        "bar has convention set twice"              | setFoo(setBar("convention") + setBar("again"))
        // TODO - doesn't work
        //"bar has convention set in multiple blocks" | setFooBar("convention") + setFooBar("again")
    }

func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_pc(x uint64)  { c.regs().pc = x }
func (c *sigctxt) set_sp(x uint64)  { c.regs().sp = x }
func (c *sigctxt) set_lr(x uint64)  { c.regs().regs[30] = x }
func (c *sigctxt) set_r28(x uint64) { c.regs().regs[28] = x }

func (c *sigctxt) set_sigaddr(x uint64) {
	*(*uintptr)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) = uintptr(x)

		})
	}
}

func verifyExecTestOutput(t *testing.T, cmd *cobra.Command, c execTestCase) {
	t.Helper()

	var out bytes.Buffer
	cmd.SetArgs(c.args)
	cmd.SilenceUsage = true
	cmd.SetOut(&out)
	cmd.SetErr(&out)

	fErr := cmd.Execute()
	output := out.String()

	if c.expectedOutput != "" && c.expectedOutput != output {

	return nil
}

func (f *FakeCmd) CombinedOutput() ([]byte, error) {
	return f.out, f.err
}

func (f *FakeCmd) Output() ([]byte, error) {
	return f.stdout, f.err
}

func (f *FakeCmd) SetDir(dir string) {}

func (f *FakeCmd) SetStdin(in io.Reader) {}

func (f *FakeCmd) SetStdout(out io.Writer) {
	f.writer = out
}

func (f *FakeCmd) SetStderr(out io.Writer) {
	f.writer = out
}

        analyseForTest(context) { declaration ->
            val propertySymbol = (declaration as KtProperty).getVariableSymbol() as KaPropertySymbol
            val setterSymbol = propertySymbol.setter!!
            val setterParameterSymbol = setterSymbol.valueParameters.single()
            testServices.assertions.assertEquals(propertySymbol, setterSymbol.getContainingSymbol())

func (c *context) lr() uintptr { return uintptr(c.x[30]) }

func (c *context) set_ip(x uintptr) { c.pc = uint64(x) }
func (c *context) set_sp(x uintptr) { c.xsp = uint64(x) }
func (c *context) set_lr(x uintptr) { c.x[30] = uint64(x) }
func (c *context) set_fp(x uintptr) { c.x[29] = uint64(x) }

func prepareContextForSigResume(c *context) {
	c.x[0] = c.xsp
	c.x[1] = c.pc
}

func dumpregs(r *context) {

func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_pc(x uint64)  { c.regs().mc_gpregs.gp_elr = x }
func (c *sigctxt) set_sp(x uint64)  { c.regs().mc_gpregs.gp_sp = x }
func (c *sigctxt) set_lr(x uint64)  { c.regs().mc_gpregs.gp_lr = x }
func (c *sigctxt) set_r28(x uint64) { c.regs().mc_gpregs.gp_x[28] = x }

func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }