1 // Copyright 2023 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package types2 6 7 import ( 8 "cmd/compile/internal/syntax" 9 "fmt" 10 ) 11 12 // An Alias represents an alias type. 13 // Whether or not Alias types are created is controlled by the 14 // gotypesalias setting with the GODEBUG environment variable. 15 // For gotypesalias=1, alias declarations produce an Alias type. 16 // Otherwise, the alias information is only in the type name, 17 // which points directly to the actual (aliased) type. 18 type Alias struct { 19 obj *TypeName // corresponding declared alias object 20 orig *Alias // original, uninstantiated alias 21 tparams *TypeParamList // type parameters, or nil 22 targs *TypeList // type arguments, or nil 23 fromRHS Type // RHS of type alias declaration; may be an alias 24 actual Type // actual (aliased) type; never an alias 25 } 26 27 // NewAlias creates a new Alias type with the given type name and rhs. 28 // rhs must not be nil. 29 func NewAlias(obj *TypeName, rhs Type) *Alias { 30 alias := (*Checker)(nil).newAlias(obj, rhs) 31 // Ensure that alias.actual is set (#65455). 32 alias.cleanup() 33 return alias 34 } 35 36 // Obj returns the type name for the declaration defining the alias type a. 37 // For instantiated types, this is same as the type name of the origin type. 38 func (a *Alias) Obj() *TypeName { return a.orig.obj } 39 40 func (a *Alias) String() string { return TypeString(a, nil) } 41 42 // Underlying returns the [underlying type] of the alias type a, which is the 43 // underlying type of the aliased type. Underlying types are never Named, 44 // TypeParam, or Alias types. 45 // 46 // [underlying type]: https://go.dev/ref/spec#Underlying_types. 47 func (a *Alias) Underlying() Type { return unalias(a).Underlying() } 48 49 // Origin returns the generic Alias type of which a is an instance. 50 // If a is not an instance of a generic alias, Origin returns a. 51 func (a *Alias) Origin() *Alias { return a.orig } 52 53 // TypeParams returns the type parameters of the alias type a, or nil. 54 // A generic Alias and its instances have the same type parameters. 55 func (a *Alias) TypeParams() *TypeParamList { return a.tparams } 56 57 // SetTypeParams sets the type parameters of the alias type a. 58 // The alias a must not have type arguments. 59 func (a *Alias) SetTypeParams(tparams []*TypeParam) { 60 assert(a.targs == nil) 61 a.tparams = bindTParams(tparams) 62 } 63 64 // TypeArgs returns the type arguments used to instantiate the Alias type. 65 // If a is not an instance of a generic alias, the result is nil. 66 func (a *Alias) TypeArgs() *TypeList { return a.targs } 67 68 // Rhs returns the type R on the right-hand side of an alias 69 // declaration "type A = R", which may be another alias. 70 func (a *Alias) Rhs() Type { return a.fromRHS } 71 72 // Unalias returns t if it is not an alias type; 73 // otherwise it follows t's alias chain until it 74 // reaches a non-alias type which is then returned. 75 // Consequently, the result is never an alias type. 76 func Unalias(t Type) Type { 77 if a0, _ := t.(*Alias); a0 != nil { 78 return unalias(a0) 79 } 80 return t 81 } 82 83 func unalias(a0 *Alias) Type { 84 if a0.actual != nil { 85 return a0.actual 86 } 87 var t Type 88 for a := a0; a != nil; a, _ = t.(*Alias) { 89 t = a.fromRHS 90 } 91 if t == nil { 92 panic(fmt.Sprintf("non-terminated alias %s", a0.obj.name)) 93 } 94 95 // Memoize the type only if valid. 96 // In the presence of unfinished cyclic declarations, Unalias 97 // would otherwise latch the invalid value (#66704). 98 // TODO(adonovan): rethink, along with checker.typeDecl's use 99 // of Invalid to mark unfinished aliases. 100 if t != Typ[Invalid] { 101 a0.actual = t 102 } 103 104 return t 105 } 106 107 // asNamed returns t as *Named if that is t's 108 // actual type. It returns nil otherwise. 109 func asNamed(t Type) *Named { 110 n, _ := Unalias(t).(*Named) 111 return n 112 } 113 114 // newAlias creates a new Alias type with the given type name and rhs. 115 // rhs must not be nil. 116 func (check *Checker) newAlias(obj *TypeName, rhs Type) *Alias { 117 assert(rhs != nil) 118 a := new(Alias) 119 a.obj = obj 120 a.orig = a 121 a.fromRHS = rhs 122 if obj.typ == nil { 123 obj.typ = a 124 } 125 126 // Ensure that a.actual is set at the end of type checking. 127 if check != nil { 128 check.needsCleanup(a) 129 } 130 131 return a 132 } 133 134 // newAliasInstance creates a new alias instance for the given origin and type 135 // arguments, recording pos as the position of its synthetic object (for error 136 // reporting). 137 func (check *Checker) newAliasInstance(pos syntax.Pos, orig *Alias, targs []Type, expanding *Named, ctxt *Context) *Alias { 138 assert(len(targs) > 0) 139 obj := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil) 140 rhs := check.subst(pos, orig.fromRHS, makeSubstMap(orig.TypeParams().list(), targs), expanding, ctxt) 141 res := check.newAlias(obj, rhs) 142 res.orig = orig 143 res.tparams = orig.tparams 144 res.targs = newTypeList(targs) 145 return res 146 } 147 148 func (a *Alias) cleanup() { 149 // Ensure a.actual is set before types are published, 150 // so Unalias is a pure "getter", not a "setter". 151 actual := Unalias(a) 152 153 if actual == Typ[Invalid] { 154 // We don't set a.actual to Typ[Invalid] during type checking, 155 // as it may indicate that the RHS is not fully set up. 156 a.actual = actual 157 } 158 } 159