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
149 // while we are in the middle of type-checking parameter declarations that
150 // might belong to interface methods. Delay this check to the end of
153 if t := asInterface(typ); t != nil {
154 tset := computeTypeSet(check, pos.Pos(), t) // TODO(gri) is this the correct position?
155 if tset.types != nil {
156 check.softErrorf(pos, _Todo, "interface contains type constraints (%s)", tset.types)
159 if tset.IsComparable() {
160 check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
166 // anyType type-checks the type expression e and returns its type, or Typ[Invalid].
167 // The type may be generic or instantiated.
168 func (check *Checker) anyType(e ast.Expr) Type {
169 typ := check.typInternal(e, nil)
171 check.recordTypeAndValue(e, typexpr, typ, nil)
175 // definedType is like typ but also accepts a type name def.
176 // If def != nil, e is the type specification for the defined type def, declared
177 // in a type declaration, and def.underlying will be set to the type of e before
178 // any components of e are type-checked.
180 func (check *Checker) definedType(e ast.Expr, def *Named) Type {
181 typ := check.typInternal(e, def)
184 check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
187 check.recordTypeAndValue(e, typexpr, typ, nil)
191 // genericType is like typ but the type must be an (uninstantiated) generic type.
192 func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
193 typ := check.typInternal(e, nil)
195 if typ != Typ[Invalid] && !isGeneric(typ) {
197 check.errorf(e, _Todo, "%s is not a generic type", typ)
201 // TODO(gri) what is the correct call below?
202 check.recordTypeAndValue(e, typexpr, typ, nil)
206 // goTypeName returns the Go type name for typ and
207 // removes any occurrences of "types." from that name.
208 func goTypeName(typ Type) string {
209 return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
212 // typInternal drives type checking of types.
213 // Must only be called by definedType or genericType.
215 func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
217 check.trace(e0.Pos(), "type %s", e0)
223 // Calling under() here may lead to endless instantiations.
224 // Test case: type T[P any] *T[P]
225 // TODO(gri) investigate if that's a bug or to be expected
226 // (see also analogous comment in Checker.instantiate).
227 under = T.Underlying()
230 check.trace(e0.Pos(), "=> %s // %s", T, goTypeName(T))
232 check.trace(e0.Pos(), "=> %s (under = %s) // %s", T, under, goTypeName(T))
237 switch e := e0.(type) {
239 // ignore - error reported before
243 check.ident(&x, e, def, true)
248 def.setUnderlying(typ)
251 // ignore - error reported before
253 check.errorf(&x, _NotAType, "%s used as type", &x)
255 check.errorf(&x, _NotAType, "%s is not a type", &x)
258 case *ast.SelectorExpr:
260 check.selector(&x, e)
265 def.setUnderlying(typ)
268 // ignore - error reported before
270 check.errorf(&x, _NotAType, "%s used as type", &x)
272 check.errorf(&x, _NotAType, "%s is not a type", &x)
275 case *ast.IndexExpr, *ast.MultiIndexExpr:
276 ix := typeparams.UnpackIndexExpr(e)
277 // TODO(rfindley): type instantiation should require go1.18
278 return check.instantiatedType(ix.X, ix.Indices, def)
281 // Generic types must be instantiated before they can be used in any form.
282 // Consequently, generic types cannot be parenthesized.
283 return check.definedType(e.X, def)
288 def.setUnderlying(typ)
289 typ.len = check.arrayLength(e.Len)
290 typ.elem = check.varType(e.Elt)
295 def.setUnderlying(typ)
296 typ.elem = check.varType(e.Elt)
300 // dots are handled explicitly where they are legal
301 // (array composite literals and parameter lists)
302 check.error(e, _InvalidDotDotDot, "invalid use of '...'")
305 case *ast.StructType:
307 def.setUnderlying(typ)
308 check.structType(typ, e)
313 def.setUnderlying(typ)
314 typ.base = check.varType(e.X)
318 typ := new(Signature)
319 def.setUnderlying(typ)
320 check.funcType(typ, nil, e)
323 case *ast.InterfaceType:
324 typ := new(Interface)
325 def.setUnderlying(typ)
329 check.interfaceType(typ, e, def)
334 def.setUnderlying(typ)
336 typ.key = check.varType(e.Key)
337 typ.elem = check.varType(e.Value)
339 // spec: "The comparison operators == and != must be fully defined
340 // for operands of the key type; thus the key type must not be a
341 // function, map, or slice."
343 // Delay this check because it requires fully setup types;
344 // it is safe to continue in any case (was issue 6667).
346 if !Comparable(typ.key) {
348 if asTypeParam(typ.key) != nil {
349 why = " (missing comparable constraint)"
351 check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
359 def.setUnderlying(typ)
363 case ast.SEND | ast.RECV:
370 check.invalidAST(e, "unknown channel direction %d", e.Dir)
375 typ.elem = check.varType(e.Value)
379 check.errorf(e0, _NotAType, "%s is not a type", e0)
383 def.setUnderlying(typ)
387 // typeOrNil type-checks the type expression (or nil value) e
388 // and returns the type of e, or nil. If e is a type, it must
389 // not be an (uninstantiated) generic type.
390 // If e is neither a type nor nil, typeOrNil returns Typ[Invalid].
391 // TODO(gri) should we also disallow non-var types?
392 func (check *Checker) typeOrNil(e ast.Expr) Type {
394 check.rawExpr(&x, e, nil)
397 // ignore - error reported before
399 check.errorf(&x, _NotAType, "%s used as type", &x)
401 check.instantiatedOperand(&x)
409 check.errorf(&x, _NotAType, "%s is not a type", &x)
414 func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named) Type {
415 base := check.genericType(x, true)
416 if base == Typ[Invalid] {
417 return base // error already reported
420 // evaluate arguments
421 targs := check.typeList(targsx)
423 def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
427 // determine argument positions
428 posList := make([]token.Pos, len(targs))
429 for i, arg := range targsx {
430 posList[i] = arg.Pos()
433 typ := check.InstantiateLazy(x.Pos(), base, targs, posList, true)
434 def.setUnderlying(typ)
436 // make sure we check instantiation works at least once
437 // and that the resulting type is valid
440 check.validType(t, nil)
446 // arrayLength type-checks the array length expression e
447 // and returns the constant length >= 0, or a value < 0
448 // to indicate an error (and thus an unknown length).
449 func (check *Checker) arrayLength(e ast.Expr) int64 {
452 if x.mode != constant_ {
453 if x.mode != invalid {
454 check.errorf(&x, _InvalidArrayLen, "array length %s must be constant", &x)
458 if isUntyped(x.typ) || isInteger(x.typ) {
459 if val := constant.ToInt(x.val); val.Kind() == constant.Int {
460 if representableConst(val, check, Typ[Int], nil) {
461 if n, ok := constant.Int64Val(val); ok && n >= 0 {
464 check.errorf(&x, _InvalidArrayLen, "invalid array length %s", &x)
469 check.errorf(&x, _InvalidArrayLen, "array length %s must be integer", &x)
473 // typeList provides the list of types corresponding to the incoming expression list.
474 // If an error occurred, the result is nil, but all list elements were type-checked.
475 func (check *Checker) typeList(list []ast.Expr) []Type {
476 res := make([]Type, len(list)) // res != nil even if len(list) == 0
477 for i, x := range list {
478 t := check.varType(x)
479 if t == Typ[Invalid] {