// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that StructuralType() calculates the correct value of structural type for
// unusual cases.

package types

import (
	"cmd/internal/src"
	"testing"
)

type test struct {
	typ            *Type
	structuralType *Type
}

func TestStructuralType(t *testing.T) {
	// These are the few constants that need to be initialized in order to use
	// the types package without using the typecheck package by calling
	// typecheck.InitUniverse() (the normal way to initialize the types package).
	PtrSize = 8
	RegSize = 8
	MaxWidth = 1 << 50

	// type intType = int
	intType := newType(TINT)
	// type structf = struct { f int }
	structf := NewStruct(nil, []*Field{
		NewField(src.NoXPos, LocalPkg.Lookup("f"), intType),
	})

	// type Sf structf
	Sf := newType(TFORW)
	Sf.sym = LocalPkg.Lookup("Sf")
	Sf.SetUnderlying(structf)

	// type A int
	A := newType(TFORW)
	A.sym = LocalPkg.Lookup("A")
	A.SetUnderlying(intType)

	// type B int
	B := newType(TFORW)
	B.sym = LocalPkg.Lookup("B")
	B.SetUnderlying(intType)

	emptyInterface := NewInterface(BuiltinPkg, []*Field{}, false)
	any := newType(TFORW)
	any.sym = LocalPkg.Lookup("any")
	any.SetUnderlying(emptyInterface)

	// The tests marked NONE have no structural type; all the others have a
	// structural type of structf - "struct { f int }"
	tests := []*test{
		{
			// interface { struct { f int } }
			embed(structf),
			structf,
		},
		{
			// interface { struct { f int }; any }
			embed(structf, any),
			structf,
		},
		{
			// interface { Sf }
			embed(Sf),
			structf,
		},
		{
			// interface { any | Sf }
			embed(any, Sf),
			structf,
		},
		{
			// interface { struct { f int }; Sf } - NONE
			embed(structf, Sf),
			nil,
		},
		{
			// interface { struct { f int } | ~struct { f int } }
			embed(NewUnion([]*Type{structf, structf}, []bool{false, true})),
			structf,
		},
		{
			// interface { ~struct { f int } ; Sf }
			embed(NewUnion([]*Type{structf}, []bool{true}), Sf),
			structf,
		},
		{
			// interface { struct { f int } ; Sf } - NONE
			embed(NewUnion([]*Type{structf}, []bool{false}), Sf),
			nil,
		},
		{
			// interface { Sf | A; B | Sf}
			embed(NewUnion([]*Type{Sf, A}, []bool{false, false}),
				NewUnion([]*Type{B, Sf}, []bool{false, false})),
			structf,
		},
		{
			// interface { Sf | A; A | Sf } - NONE
			embed(NewUnion([]*Type{Sf, A}, []bool{false, false}),
				NewUnion([]*Type{A, Sf}, []bool{false, false})),
			nil,
		},
		{
			// interface { Sf | any } - NONE
			embed(NewUnion([]*Type{Sf, any}, []bool{false, false})),
			nil,
		},
		{
			// interface { Sf | any; Sf }
			embed(NewUnion([]*Type{Sf, any}, []bool{false, false}), Sf),
			structf,
		},
	}
	for _, tst := range tests {
		if got, want := tst.typ.StructuralType(), tst.structuralType; got != want {
			t.Errorf("StructuralType(%v) = %v, wanted %v",
				tst.typ, got, want)
		}
	}
}

func embed(types ...*Type) *Type {
	fields := make([]*Field, len(types))
	for i, t := range types {
		fields[i] = NewField(src.NoXPos, nil, t)
	}
	return NewInterface(LocalPkg, fields, false)
}