*x = 1;
}

void setintptr(intptr x) {
	*x = 1;
}

void setvoidptr(void *x) {
	*(int*)x = 1;
}

typedef struct Struct Struct;
struct Struct {
	int *P;
};

void setstruct(Struct s) {
	*s.P = 1;
}

// issue 11925
// Structs with zero-length trailing fields are now padded by the Go compiler.

struct a11925 {
	int i;
	char a[0];
	char b[0];
};

	typemap.Set[TestInterface[string]](tm, TestStruct{Field: "interface"})

	assert.Equal(t, typemap.Get[int](tm), ptr.Of(1))
	assert.Equal(t, typemap.Get[int32](tm), ptr.Of(int32(2)))
	assert.Equal(t, typemap.Get[string](tm), ptr.Of("string"))
	assert.Equal(t, typemap.Get[*TestStruct](tm), ptr.Of(&TestStruct{Field: "pointer"}))
	assert.Equal(t, typemap.Get[TestInterface[string]](tm), ptr.Of(TestInterface[string](TestStruct{Field: "interface"})))

	if fieldsHasShape(allParams) {
		t.SetHasShape(true)
	}

	return t
}

// NewStruct returns a new struct with the given fields.
func NewStruct(fields []*Field) *Type {
	t := newType(TSTRUCT)
	t.setFields(fields)
	if fieldsHasShape(fields) {
		t.SetHasShape(true)
	}
	for _, f := range fields {
		if f.Type.NotInHeap() {
			t.SetNotInHeap(true)
			break
		}
	}

				return c
			},
			protocmp.Transform(),
		},
		// Random struct pointer
		{
			&TestStruct{Name: "foobar"},
			func(c Spec) Spec {
				c.(*TestStruct).Name = "bar"
				return c
			},
			nil,
		},
		// Random struct
		{
			TestStruct{Name: "foobar"},
			func(c Spec) Spec {
				x := c.(TestStruct)
				x.Name = "bar"
				return x
			},
			nil,
		},
		// Slice
		{

	testHandle[testStringStruct](t, testStringStruct{"x"})
	testHandle[testStringStructArrayStruct](t, testStringStructArrayStruct{
		s: [2]testStringStruct{testStringStruct{"y"}, testStringStruct{"z"}},
	})
	testHandle[testStruct](t, testStruct{0.5, "184"})
}

func testHandle[T comparable](t *testing.T, value T) {
	name := reflect.TypeFor[T]().Name()
	t.Run(fmt.Sprintf("%s/%#v", name, value), func(t *testing.T) {
		t.Parallel()

    override val analysisSession: KaFirSession,
) : KaDestructuringDeclarationSymbol(), KaFirSymbol<FirVariableSymbol<*>> {

    init {
        require(firSymbol.name == SpecialNames.DESTRUCT)
    }

    override val psi: KtDestructuringDeclaration
        get() = withValidityAssertion {
            when (val psi = firSymbol.fir.psi) {
                is KtDestructuringDeclaration -> psi

	testCloneSeq[testStringArray](t, cSeq(0, 2*goarch.PtrSize, 4*goarch.PtrSize))
	testCloneSeq[testStringStruct](t, cSeq(0))
	testCloneSeq[testStringStructArrayStruct](t, cSeq(0, 2*goarch.PtrSize))
	testCloneSeq[testStruct](t, cSeq(8))
}

func cSeq(stringOffsets ...uintptr) cloneSeq {
	return cloneSeq{stringOffsets: stringOffsets}
}

func testCloneSeq[T any](t *testing.T, want cloneSeq) {
	typName := reflect.TypeFor[T]().Name()

	tags   []string // field tags; nil if there are no tags
}

// NewStruct returns a new struct with the given fields and corresponding field tags.
// If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be
// only as long as required to hold the tag with the largest index i. Consequently,
// if no field has a tag, tags may be nil.
func NewStruct(fields []*Var, tags []string) *Struct {
	var fset objset

        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaDestructuringDeclarationSymbol>(this)?.let { return it }
        throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(SpecialNames.DESTRUCT.asString())
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        return other is KaFe10PsiDestructuringDeclarationSymbol && other.psi == this.psi
    }

	tags   []string // field tags; nil if there are no tags
}

// NewStruct returns a new struct with the given fields and corresponding field tags.
// If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be
// only as long as required to hold the tag with the largest index i. Consequently,
// if no field has a tag, tags may be nil.
func NewStruct(fields []*Var, tags []string) *Struct {
	var fset objset