// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test basic restrictions on type aliases.

package p

import (
	"reflect"
	. "reflect"
)

type T0 struct{}

// Valid type alias declarations.

type _ = T0
type _ = int
type _ = struct{}
type _ = reflect.Value
type _ = Value

type (
	A0 = T0
	A1 = int

	Alias8  = SliceFlag[[8]int]
	Alias9  = SliceFlag[[9]int]
	Alias10 = SliceFlag[[10]int]
	Alias11 = SliceFlag[[11]int]
	Alias12 = SliceFlag[[12]int]
	Alias13 = SliceFlag[[13]int]
	Alias14 = SliceFlag[[14]int]
	Alias15 = SliceFlag[[15]int]
	Alias16 = SliceFlag[[16]int]
	Alias17 = SliceFlag[[17]int]
	Alias18 = SliceFlag[[18]int]
	Alias19 = SliceFlag[[19]int]
	Alias20 = SliceFlag[[20]int]
)

[libraries]
alias1 = { module = "g:a" }
alias2 = { group = "g", name = "a", version = "" }

				{Name: "alias2", ExternalName: "concrete"},
			},
		},
		{
			name: "looping alias",
			input: []service{
				{Name: "alias1", ExternalName: "alias2"},
				{Name: "alias2", ExternalName: "alias1"},
			},
			output: []service{
				{Name: "alias1", ExternalName: "alias2"},
				{Name: "alias2", ExternalName: "alias1"},
			},
		},
	}
	for _, tt := range tests {

          /*function_aliases=*/
          {{"alias_1", "function_1"}, {"alias_2", "function_2"}},
          /*asset_file_defs=*/{});

  ASSERT_THAT(exported_model, IsOk());
  ASSERT_THAT(exported_model->function_aliases(), SizeIs(2));
  EXPECT_THAT(exported_model->function_aliases().at("alias_1"),
              StrEq("function_1"));
  EXPECT_THAT(exported_model->function_aliases().at("alias_2"),
              StrEq("function_2"));
}

    }

    void hasPlugin(String alias, String id, String version) {
        assert model.hasPlugin(alias)
        def plugin = model.getPlugin(alias)
        assert plugin != null : "Expected a plugin with alias '$alias' but it wasn't found"
        assert plugin.id == id
        assert plugin.version.requiredVersion == version
    }

// If a is not an instance of a generic alias, the result is nil.
func (a *Alias) TypeArgs() *TypeList { return a.targs }

// Rhs returns the type R on the right-hand side of an alias
// declaration "type A = R", which may be another alias.
func (a *Alias) Rhs() Type { return a.fromRHS }

// Unalias returns t if it is not an alias type;
// otherwise it follows t's alias chain until it

	actual  Type           // actual (aliased) type; never an alias
}

// NewAlias creates a new Alias type with the given type name and rhs.
// rhs must not be nil.
func NewAlias(obj *TypeName, rhs Type) *Alias {
	alias := (*Checker)(nil).newAlias(obj, rhs)
	// Ensure that alias.actual is set (#65455).
	alias.cleanup()
	return alias
}

// license that can be found in the LICENSE file.

package aliases

import (
	"go/token"
	"go/types"
)

// Package aliases defines backward compatible shims
// for the types.Alias type representation added in 1.22.
// This defines placeholders for x/tools until 1.26.

// NewAlias creates a new TypeName in Package pkg that
// is an alias for the type rhs.
//

package aliases

type (
	T0 [10]int
	T1 []byte
	T2 struct {
		x int
	}
	T3 interface {
		m() T2
	}
	T4 func(int, T0) chan T2
)

// basic aliases
type (
	Ai = int
	A0 = T0
	A1 = T1
	A2 = T2
	A3 = T3
	A4 = T4

	A10 = [10]int
	A11 = []byte
	A12 = struct {
		x int
	}
	A13 = interface {
		m() A2
	}
	A14 = func(int, A0) chan A2
)

// alias receiver types