1 // Copyright 2013 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.
5 // This file implements type-checking of identifiers and type expressions.
13 "go/internal/typeparams"
18 // ident type-checks identifier e and initializes x with the value or type of e.
19 // If an error occurred, x.mode is set to invalid.
20 // For the meaning of def, see Checker.definedType, below.
21 // If wantType is set, the identifier e is expected to denote a type.
23 func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) {
27 // Note that we cannot use check.lookup here because the returned scope
28 // may be different from obj.Parent(). See also Scope.LookupParent doc.
29 scope, obj := check.scope.LookupParent(e.Name, check.pos)
33 check.error(e, _InvalidBlank, "cannot use _ as value or type")
35 check.errorf(e, _UndeclaredName, "undeclared name: %s", e.Name)
38 case universeAny, universeComparable:
39 if !check.allowVersion(check.pkg, 1, 18) {
40 check.errorf(e, _UndeclaredName, "undeclared name: %s (requires version go1.18 or later)", e.Name)
43 // If we allow "any" for general use, this if-statement can be removed (issue #33232).
44 if obj == universeAny {
45 check.error(e, _Todo, "cannot use any outside constraint position")
49 check.recordUse(e, obj)
51 // Type-check the object.
52 // Only call Checker.objDecl if the object doesn't have a type yet
53 // (in which case we must actually determine it) or the object is a
54 // TypeName and we also want a type (in which case we might detect
55 // a cycle which needs to be reported). Otherwise we can skip the
56 // call and avoid a possible cycle error in favor of the more
57 // informative "not a type/value" error that this function's caller
58 // will issue (see issue #25790).
60 if _, gotType := obj.(*TypeName); typ == nil || gotType && wantType {
61 check.objDecl(obj, def)
62 typ = obj.Type() // type must have been assigned by Checker.objDecl
66 // The object may have been dot-imported.
67 // If so, mark the respective package as used.
68 // (This code is only needed for dot-imports. Without them,
69 // we only have to mark variables, see *Var case below).
70 if pkgName := check.dotImportMap[dotImportKey{scope, obj.Name()}]; pkgName != nil {
74 switch obj := obj.(type) {
76 check.errorf(e, _InvalidPkgUse, "use of package %s not in selector", obj.name)
81 if typ == Typ[Invalid] {
84 if obj == universeIota {
85 if check.iota == nil {
86 check.errorf(e, _InvalidIota, "cannot use iota outside constant declaration")
100 // It's ok to mark non-local variables, but ignore variables
101 // from other packages to avoid potential race conditions with
102 // dot-imported variables.
103 if obj.pkg == check.pkg {
106 check.addDeclDep(obj)
107 if typ == Typ[Invalid] {
113 check.addDeclDep(obj)
130 // typ type-checks the type expression e and returns its type, or Typ[Invalid].
131 // The type must not be an (uninstantiated) generic type.
132 func (check *Checker) typ(e ast.Expr) Type {
133 return check.definedType(e, nil)
136 // varType type-checks the type expression e and returns its type, or Typ[Invalid].
137 // The type must not be an (uninstantiated) generic type and it must be ordinary
138 // (see ordinaryType).
139 func (check *Checker) varType(e ast.Expr) Type {
140 typ := check.definedType(e, nil)
141 check.ordinaryType(e, typ)
145 // ordinaryType reports an error if typ is an interface type containing
146 // type lists or is (or embeds) the predeclared type comparable.
147 func (check *Checker) ordinaryType(pos positioner, typ Type) {
148 // We don't want to call under() (via asInterface) or complete interfaces while we
149 // are in the middle of type-checking parameter declarations that might belong to
150 // interface methods. Delay this check to the end of type-checking.
152 if t := asInterface(typ); t != nil {
153 tset := computeInterfaceTypeSet(check, pos.Pos(), t) // TODO(gri) is this the correct position?
154 if !tset.IsMethodSet() {
156 check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
158 check.softErrorf(pos, _Todo, "interface contains type constraints")
165 // anyType type-checks the type expression e and returns its type, or Typ[Invalid].
166 // The type may be generic or instantiated.
167 func (check *Checker) anyType(e ast.Expr) Type {
168 typ := check.typInternal(e, nil)
170 check.recordTypeAndValue(e, typexpr, typ, nil)
174 // definedType is like typ but also accepts a type name def.
175 // If def != nil, e is the type specification for the defined type def, declared
176 // in a type declaration, and def.underlying will be set to the type of e before
177 // any components of e are type-checked.
179 func (check *Checker) definedType(e ast.Expr, def *Named) Type {
180 typ := check.typInternal(e, def)
183 check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
186 check.recordTypeAndValue(e, typexpr, typ, nil)
190 // genericType is like typ but the type must be an (uninstantiated) generic type.
191 func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
192 typ := check.typInternal(e, nil)
194 if typ != Typ[Invalid] && !isGeneric(typ) {
196 check.errorf(e, _Todo, "%s is not a generic type", typ)
200 // TODO(gri) what is the correct call below?
201 check.recordTypeAndValue(e, typexpr, typ, nil)
205 // goTypeName returns the Go type name for typ and
206 // removes any occurrences of "types." from that name.
207 func goTypeName(typ Type) string {
208 return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
211 // typInternal drives type checking of types.
212 // Must only be called by definedType or genericType.
214 func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
216 check.trace(e0.Pos(), "type %s", e0)
222 // Calling under() here may lead to endless instantiations.
223 // Test case: type T[P any] *T[P]
224 // TODO(gri) investigate if that's a bug or to be expected
225 // (see also analogous comment in Checker.instantiate).
226 under = safeUnderlying(T)
229 check.trace(e0.Pos(), "=> %s // %s", T, goTypeName(T))
231 check.trace(e0.Pos(), "=> %s (under = %s) // %s", T, under, goTypeName(T))
236 switch e := e0.(type) {
238 // ignore - error reported before
242 check.ident(&x, e, def, true)
247 def.setUnderlying(typ)
250 // ignore - error reported before
252 check.errorf(&x, _NotAType, "%s used as type", &x)
254 check.errorf(&x, _NotAType, "%s is not a type", &x)
257 case *ast.SelectorExpr:
259 check.selector(&x, e)
264 def.setUnderlying(typ)
267 // ignore - error reported before
269 check.errorf(&x, _NotAType, "%s used as type", &x)
271 check.errorf(&x, _NotAType, "%s is not a type", &x)
274 case *ast.IndexExpr, *ast.MultiIndexExpr:
275 ix := typeparams.UnpackIndexExpr(e)
276 // TODO(rfindley): type instantiation should require go1.18
277 return check.instantiatedType(ix.X, ix.Indices, def)
280 // Generic types must be instantiated before they can be used in any form.
281 // Consequently, generic types cannot be parenthesized.
282 return check.definedType(e.X, def)
287 def.setUnderlying(typ)
288 typ.len = check.arrayLength(e.Len)
289 typ.elem = check.varType(e.Elt)
294 def.setUnderlying(typ)
295 typ.elem = check.varType(e.Elt)
299 // dots are handled explicitly where they are legal
300 // (array composite literals and parameter lists)
301 check.error(e, _InvalidDotDotDot, "invalid use of '...'")
304 case *ast.StructType:
306 def.setUnderlying(typ)
307 check.structType(typ, e)
312 def.setUnderlying(typ)
313 typ.base = check.varType(e.X)
317 typ := new(Signature)
318 def.setUnderlying(typ)
319 check.funcType(typ, nil, e)
322 case *ast.InterfaceType:
323 typ := new(Interface)
324 def.setUnderlying(typ)
328 check.interfaceType(typ, e, def)
333 def.setUnderlying(typ)
335 typ.key = check.varType(e.Key)
336 typ.elem = check.varType(e.Value)
338 // spec: "The comparison operators == and != must be fully defined
339 // for operands of the key type; thus the key type must not be a
340 // function, map, or slice."
342 // Delay this check because it requires fully setup types;
343 // it is safe to continue in any case (was issue 6667).
345 if !Comparable(typ.key) {
347 if asTypeParam(typ.key) != nil {
348 why = " (missing comparable constraint)"
350 check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
358 def.setUnderlying(typ)
362 case ast.SEND | ast.RECV:
369 check.invalidAST(e, "unknown channel direction %d", e.Dir)
374 typ.elem = check.varType(e.Value)
378 check.errorf(e0, _NotAType, "%s is not a type", e0)
382 def.setUnderlying(typ)
386 func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named) Type {
387 gtyp := check.genericType(x, true)
388 if gtyp == Typ[Invalid] {
389 return gtyp // error already reported
391 base, _ := gtyp.(*Named)
393 panic(fmt.Sprintf("%v: cannot instantiate %v", x.Pos(), gtyp))
396 // evaluate arguments
397 targs := check.typeList(targsx)
399 def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
403 // determine argument positions
404 posList := make([]token.Pos, len(targs))
405 for i, arg := range targsx {
406 posList[i] = arg.Pos()
409 typ := check.instantiate(x.Pos(), base, targs, posList)
410 def.setUnderlying(typ)
412 // make sure we check instantiation works at least once
413 // and that the resulting type is valid
415 check.validType(typ, nil)
421 // arrayLength type-checks the array length expression e
422 // and returns the constant length >= 0, or a value < 0
423 // to indicate an error (and thus an unknown length).
424 func (check *Checker) arrayLength(e ast.Expr) int64 {
427 if x.mode != constant_ {
428 if x.mode != invalid {
429 check.errorf(&x, _InvalidArrayLen, "array length %s must be constant", &x)
433 if isUntyped(x.typ) || isInteger(x.typ) {
434 if val := constant.ToInt(x.val); val.Kind() == constant.Int {
435 if representableConst(val, check, Typ[Int], nil) {
436 if n, ok := constant.Int64Val(val); ok && n >= 0 {
439 check.errorf(&x, _InvalidArrayLen, "invalid array length %s", &x)
444 check.errorf(&x, _InvalidArrayLen, "array length %s must be integer", &x)
448 // typeList provides the list of types corresponding to the incoming expression list.
449 // If an error occurred, the result is nil, but all list elements were type-checked.
450 func (check *Checker) typeList(list []ast.Expr) []Type {
451 res := make([]Type, len(list)) // res != nil even if len(list) == 0
452 for i, x := range list {
453 t := check.varType(x)
454 if t == Typ[Invalid] {