Source file src/go/types/expr.go

Documentation: go/types

     1  // Copyright 2012 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  // This file implements typechecking of expressions.
     6  
     7  package types
     8  
     9  import (
    10  	"fmt"
    11  	"go/ast"
    12  	"go/constant"
    13  	"go/internal/typeparams"
    14  	"go/token"
    15  	"math"
    16  )
    17  
    18  /*
    19  Basic algorithm:
    20  
    21  Expressions are checked recursively, top down. Expression checker functions
    22  are generally of the form:
    23  
    24    func f(x *operand, e *ast.Expr, ...)
    25  
    26  where e is the expression to be checked, and x is the result of the check.
    27  The check performed by f may fail in which case x.mode == invalid, and
    28  related error messages will have been issued by f.
    29  
    30  If a hint argument is present, it is the composite literal element type
    31  of an outer composite literal; it is used to type-check composite literal
    32  elements that have no explicit type specification in the source
    33  (e.g.: []T{{...}, {...}}, the hint is the type T in this case).
    34  
    35  All expressions are checked via rawExpr, which dispatches according
    36  to expression kind. Upon returning, rawExpr is recording the types and
    37  constant values for all expressions that have an untyped type (those types
    38  may change on the way up in the expression tree). Usually these are constants,
    39  but the results of comparisons or non-constant shifts of untyped constants
    40  may also be untyped, but not constant.
    41  
    42  Untyped expressions may eventually become fully typed (i.e., not untyped),
    43  typically when the value is assigned to a variable, or is used otherwise.
    44  The updateExprType method is used to record this final type and update
    45  the recorded types: the type-checked expression tree is again traversed down,
    46  and the new type is propagated as needed. Untyped constant expression values
    47  that become fully typed must now be representable by the full type (constant
    48  sub-expression trees are left alone except for their roots). This mechanism
    49  ensures that a client sees the actual (run-time) type an untyped value would
    50  have. It also permits type-checking of lhs shift operands "as if the shift
    51  were not present": when updateExprType visits an untyped lhs shift operand
    52  and assigns it it's final type, that type must be an integer type, and a
    53  constant lhs must be representable as an integer.
    54  
    55  When an expression gets its final type, either on the way out from rawExpr,
    56  on the way down in updateExprType, or at the end of the type checker run,
    57  the type (and constant value, if any) is recorded via Info.Types, if present.
    58  */
    59  
    60  type opPredicates map[token.Token]func(Type) bool
    61  
    62  var unaryOpPredicates opPredicates
    63  
    64  func init() {
    65  	// Setting unaryOpPredicates in init avoids declaration cycles.
    66  	unaryOpPredicates = opPredicates{
    67  		token.ADD: isNumeric,
    68  		token.SUB: isNumeric,
    69  		token.XOR: isInteger,
    70  		token.NOT: isBoolean,
    71  	}
    72  }
    73  
    74  func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
    75  	if pred := m[op]; pred != nil {
    76  		if !pred(x.typ) {
    77  			check.invalidOp(x, _UndefinedOp, "operator %s not defined for %s", op, x)
    78  			return false
    79  		}
    80  	} else {
    81  		check.invalidAST(x, "unknown operator %s", op)
    82  		return false
    83  	}
    84  	return true
    85  }
    86  
    87  // overflow checks that the constant x is representable by its type.
    88  // For untyped constants, it checks that the value doesn't become
    89  // arbitrarily large.
    90  func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) {
    91  	assert(x.mode == constant_)
    92  
    93  	if x.val.Kind() == constant.Unknown {
    94  		// TODO(gri) We should report exactly what went wrong. At the
    95  		//           moment we don't have the (go/constant) API for that.
    96  		//           See also TODO in go/constant/value.go.
    97  		check.errorf(atPos(opPos), _InvalidConstVal, "constant result is not representable")
    98  		return
    99  	}
   100  
   101  	// Typed constants must be representable in
   102  	// their type after each constant operation.
   103  	if isTyped(x.typ) {
   104  		check.representable(x, asBasic(x.typ))
   105  		return
   106  	}
   107  
   108  	// Untyped integer values must not grow arbitrarily.
   109  	const prec = 512 // 512 is the constant precision
   110  	if x.val.Kind() == constant.Int && constant.BitLen(x.val) > prec {
   111  		check.errorf(atPos(opPos), _InvalidConstVal, "constant %s overflow", opName(x.expr))
   112  		x.val = constant.MakeUnknown()
   113  	}
   114  }
   115  
   116  // opName returns the name of an operation, or the empty string.
   117  // For now, only operations that might overflow are handled.
   118  // TODO(gri) Expand this to a general mechanism giving names to
   119  //           nodes?
   120  func opName(e ast.Expr) string {
   121  	switch e := e.(type) {
   122  	case *ast.BinaryExpr:
   123  		if int(e.Op) < len(op2str2) {
   124  			return op2str2[e.Op]
   125  		}
   126  	case *ast.UnaryExpr:
   127  		if int(e.Op) < len(op2str1) {
   128  			return op2str1[e.Op]
   129  		}
   130  	}
   131  	return ""
   132  }
   133  
   134  var op2str1 = [...]string{
   135  	token.XOR: "bitwise complement",
   136  }
   137  
   138  // This is only used for operations that may cause overflow.
   139  var op2str2 = [...]string{
   140  	token.ADD: "addition",
   141  	token.SUB: "subtraction",
   142  	token.XOR: "bitwise XOR",
   143  	token.MUL: "multiplication",
   144  	token.SHL: "shift",
   145  }
   146  
   147  // The unary expression e may be nil. It's passed in for better error messages only.
   148  func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
   149  	check.expr(x, e.X)
   150  	if x.mode == invalid {
   151  		return
   152  	}
   153  	switch e.Op {
   154  	case token.AND:
   155  		// spec: "As an exception to the addressability
   156  		// requirement x may also be a composite literal."
   157  		if _, ok := unparen(e.X).(*ast.CompositeLit); !ok && x.mode != variable {
   158  			check.invalidOp(x, _UnaddressableOperand, "cannot take address of %s", x)
   159  			x.mode = invalid
   160  			return
   161  		}
   162  		x.mode = value
   163  		x.typ = &Pointer{base: x.typ}
   164  		return
   165  
   166  	case token.ARROW:
   167  		typ := asChan(x.typ)
   168  		if typ == nil {
   169  			check.invalidOp(x, _InvalidReceive, "cannot receive from non-channel %s", x)
   170  			x.mode = invalid
   171  			return
   172  		}
   173  		if typ.dir == SendOnly {
   174  			check.invalidOp(x, _InvalidReceive, "cannot receive from send-only channel %s", x)
   175  			x.mode = invalid
   176  			return
   177  		}
   178  		x.mode = commaok
   179  		x.typ = typ.elem
   180  		check.hasCallOrRecv = true
   181  		return
   182  	}
   183  
   184  	if !check.op(unaryOpPredicates, x, e.Op) {
   185  		x.mode = invalid
   186  		return
   187  	}
   188  
   189  	if x.mode == constant_ {
   190  		if x.val.Kind() == constant.Unknown {
   191  			// nothing to do (and don't cause an error below in the overflow check)
   192  			return
   193  		}
   194  		var prec uint
   195  		if isUnsigned(x.typ) {
   196  			prec = uint(check.conf.sizeof(x.typ) * 8)
   197  		}
   198  		x.val = constant.UnaryOp(e.Op, x.val, prec)
   199  		x.expr = e
   200  		check.overflow(x, e.Op, x.Pos())
   201  		return
   202  	}
   203  
   204  	x.mode = value
   205  	// x.typ remains unchanged
   206  }
   207  
   208  func isShift(op token.Token) bool {
   209  	return op == token.SHL || op == token.SHR
   210  }
   211  
   212  func isComparison(op token.Token) bool {
   213  	// Note: tokens are not ordered well to make this much easier
   214  	switch op {
   215  	case token.EQL, token.NEQ, token.LSS, token.LEQ, token.GTR, token.GEQ:
   216  		return true
   217  	}
   218  	return false
   219  }
   220  
   221  func fitsFloat32(x constant.Value) bool {
   222  	f32, _ := constant.Float32Val(x)
   223  	f := float64(f32)
   224  	return !math.IsInf(f, 0)
   225  }
   226  
   227  func roundFloat32(x constant.Value) constant.Value {
   228  	f32, _ := constant.Float32Val(x)
   229  	f := float64(f32)
   230  	if !math.IsInf(f, 0) {
   231  		return constant.MakeFloat64(f)
   232  	}
   233  	return nil
   234  }
   235  
   236  func fitsFloat64(x constant.Value) bool {
   237  	f, _ := constant.Float64Val(x)
   238  	return !math.IsInf(f, 0)
   239  }
   240  
   241  func roundFloat64(x constant.Value) constant.Value {
   242  	f, _ := constant.Float64Val(x)
   243  	if !math.IsInf(f, 0) {
   244  		return constant.MakeFloat64(f)
   245  	}
   246  	return nil
   247  }
   248  
   249  // representableConst reports whether x can be represented as
   250  // value of the given basic type and for the configuration
   251  // provided (only needed for int/uint sizes).
   252  //
   253  // If rounded != nil, *rounded is set to the rounded value of x for
   254  // representable floating-point and complex values, and to an Int
   255  // value for integer values; it is left alone otherwise.
   256  // It is ok to provide the addressof the first argument for rounded.
   257  //
   258  // The check parameter may be nil if representableConst is invoked
   259  // (indirectly) through an exported API call (AssignableTo, ConvertibleTo)
   260  // because we don't need the Checker's config for those calls.
   261  func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *constant.Value) bool {
   262  	if x.Kind() == constant.Unknown {
   263  		return true // avoid follow-up errors
   264  	}
   265  
   266  	var conf *Config
   267  	if check != nil {
   268  		conf = check.conf
   269  	}
   270  
   271  	switch {
   272  	case isInteger(typ):
   273  		x := constant.ToInt(x)
   274  		if x.Kind() != constant.Int {
   275  			return false
   276  		}
   277  		if rounded != nil {
   278  			*rounded = x
   279  		}
   280  		if x, ok := constant.Int64Val(x); ok {
   281  			switch typ.kind {
   282  			case Int:
   283  				var s = uint(conf.sizeof(typ)) * 8
   284  				return int64(-1)<<(s-1) <= x && x <= int64(1)<<(s-1)-1
   285  			case Int8:
   286  				const s = 8
   287  				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
   288  			case Int16:
   289  				const s = 16
   290  				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
   291  			case Int32:
   292  				const s = 32
   293  				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
   294  			case Int64, UntypedInt:
   295  				return true
   296  			case Uint, Uintptr:
   297  				if s := uint(conf.sizeof(typ)) * 8; s < 64 {
   298  					return 0 <= x && x <= int64(1)<<s-1
   299  				}
   300  				return 0 <= x
   301  			case Uint8:
   302  				const s = 8
   303  				return 0 <= x && x <= 1<<s-1
   304  			case Uint16:
   305  				const s = 16
   306  				return 0 <= x && x <= 1<<s-1
   307  			case Uint32:
   308  				const s = 32
   309  				return 0 <= x && x <= 1<<s-1
   310  			case Uint64:
   311  				return 0 <= x
   312  			default:
   313  				unreachable()
   314  			}
   315  		}
   316  		// x does not fit into int64
   317  		switch n := constant.BitLen(x); typ.kind {
   318  		case Uint, Uintptr:
   319  			var s = uint(conf.sizeof(typ)) * 8
   320  			return constant.Sign(x) >= 0 && n <= int(s)
   321  		case Uint64:
   322  			return constant.Sign(x) >= 0 && n <= 64
   323  		case UntypedInt:
   324  			return true
   325  		}
   326  
   327  	case isFloat(typ):
   328  		x := constant.ToFloat(x)
   329  		if x.Kind() != constant.Float {
   330  			return false
   331  		}
   332  		switch typ.kind {
   333  		case Float32:
   334  			if rounded == nil {
   335  				return fitsFloat32(x)
   336  			}
   337  			r := roundFloat32(x)
   338  			if r != nil {
   339  				*rounded = r
   340  				return true
   341  			}
   342  		case Float64:
   343  			if rounded == nil {
   344  				return fitsFloat64(x)
   345  			}
   346  			r := roundFloat64(x)
   347  			if r != nil {
   348  				*rounded = r
   349  				return true
   350  			}
   351  		case UntypedFloat:
   352  			return true
   353  		default:
   354  			unreachable()
   355  		}
   356  
   357  	case isComplex(typ):
   358  		x := constant.ToComplex(x)
   359  		if x.Kind() != constant.Complex {
   360  			return false
   361  		}
   362  		switch typ.kind {
   363  		case Complex64:
   364  			if rounded == nil {
   365  				return fitsFloat32(constant.Real(x)) && fitsFloat32(constant.Imag(x))
   366  			}
   367  			re := roundFloat32(constant.Real(x))
   368  			im := roundFloat32(constant.Imag(x))
   369  			if re != nil && im != nil {
   370  				*rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
   371  				return true
   372  			}
   373  		case Complex128:
   374  			if rounded == nil {
   375  				return fitsFloat64(constant.Real(x)) && fitsFloat64(constant.Imag(x))
   376  			}
   377  			re := roundFloat64(constant.Real(x))
   378  			im := roundFloat64(constant.Imag(x))
   379  			if re != nil && im != nil {
   380  				*rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
   381  				return true
   382  			}
   383  		case UntypedComplex:
   384  			return true
   385  		default:
   386  			unreachable()
   387  		}
   388  
   389  	case isString(typ):
   390  		return x.Kind() == constant.String
   391  
   392  	case isBoolean(typ):
   393  		return x.Kind() == constant.Bool
   394  	}
   395  
   396  	return false
   397  }
   398  
   399  // representable checks that a constant operand is representable in the given
   400  // basic type.
   401  func (check *Checker) representable(x *operand, typ *Basic) {
   402  	v, code := check.representation(x, typ)
   403  	if code != 0 {
   404  		check.invalidConversion(code, x, typ)
   405  		x.mode = invalid
   406  		return
   407  	}
   408  	assert(v != nil)
   409  	x.val = v
   410  }
   411  
   412  // representation returns the representation of the constant operand x as the
   413  // basic type typ.
   414  //
   415  // If no such representation is possible, it returns a non-zero error code.
   416  func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, errorCode) {
   417  	assert(x.mode == constant_)
   418  	v := x.val
   419  	if !representableConst(x.val, check, typ, &v) {
   420  		if isNumeric(x.typ) && isNumeric(typ) {
   421  			// numeric conversion : error msg
   422  			//
   423  			// integer -> integer : overflows
   424  			// integer -> float   : overflows (actually not possible)
   425  			// float   -> integer : truncated
   426  			// float   -> float   : overflows
   427  			//
   428  			if !isInteger(x.typ) && isInteger(typ) {
   429  				return nil, _TruncatedFloat
   430  			} else {
   431  				return nil, _NumericOverflow
   432  			}
   433  		}
   434  		return nil, _InvalidConstVal
   435  	}
   436  	return v, 0
   437  }
   438  
   439  func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) {
   440  	msg := "cannot convert %s to %s"
   441  	switch code {
   442  	case _TruncatedFloat:
   443  		msg = "%s truncated to %s"
   444  	case _NumericOverflow:
   445  		msg = "%s overflows %s"
   446  	}
   447  	check.errorf(x, code, msg, x, target)
   448  }
   449  
   450  // updateExprType updates the type of x to typ and invokes itself
   451  // recursively for the operands of x, depending on expression kind.
   452  // If typ is still an untyped and not the final type, updateExprType
   453  // only updates the recorded untyped type for x and possibly its
   454  // operands. Otherwise (i.e., typ is not an untyped type anymore,
   455  // or it is the final type for x), the type and value are recorded.
   456  // Also, if x is a constant, it must be representable as a value of typ,
   457  // and if x is the (formerly untyped) lhs operand of a non-constant
   458  // shift, it must be an integer value.
   459  //
   460  func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) {
   461  	old, found := check.untyped[x]
   462  	if !found {
   463  		return // nothing to do
   464  	}
   465  
   466  	// update operands of x if necessary
   467  	switch x := x.(type) {
   468  	case *ast.BadExpr,
   469  		*ast.FuncLit,
   470  		*ast.CompositeLit,
   471  		*ast.IndexExpr,
   472  		*ast.SliceExpr,
   473  		*ast.TypeAssertExpr,
   474  		*ast.StarExpr,
   475  		*ast.KeyValueExpr,
   476  		*ast.ArrayType,
   477  		*ast.StructType,
   478  		*ast.FuncType,
   479  		*ast.InterfaceType,
   480  		*ast.MapType,
   481  		*ast.ChanType:
   482  		// These expression are never untyped - nothing to do.
   483  		// The respective sub-expressions got their final types
   484  		// upon assignment or use.
   485  		if debug {
   486  			check.dump("%v: found old type(%s): %s (new: %s)", x.Pos(), x, old.typ, typ)
   487  			unreachable()
   488  		}
   489  		return
   490  
   491  	case *ast.CallExpr:
   492  		// Resulting in an untyped constant (e.g., built-in complex).
   493  		// The respective calls take care of calling updateExprType
   494  		// for the arguments if necessary.
   495  
   496  	case *ast.Ident, *ast.BasicLit, *ast.SelectorExpr:
   497  		// An identifier denoting a constant, a constant literal,
   498  		// or a qualified identifier (imported untyped constant).
   499  		// No operands to take care of.
   500  
   501  	case *ast.ParenExpr:
   502  		check.updateExprType(x.X, typ, final)
   503  
   504  	case *ast.UnaryExpr:
   505  		// If x is a constant, the operands were constants.
   506  		// The operands don't need to be updated since they
   507  		// never get "materialized" into a typed value. If
   508  		// left in the untyped map, they will be processed
   509  		// at the end of the type check.
   510  		if old.val != nil {
   511  			break
   512  		}
   513  		check.updateExprType(x.X, typ, final)
   514  
   515  	case *ast.BinaryExpr:
   516  		if old.val != nil {
   517  			break // see comment for unary expressions
   518  		}
   519  		if isComparison(x.Op) {
   520  			// The result type is independent of operand types
   521  			// and the operand types must have final types.
   522  		} else if isShift(x.Op) {
   523  			// The result type depends only on lhs operand.
   524  			// The rhs type was updated when checking the shift.
   525  			check.updateExprType(x.X, typ, final)
   526  		} else {
   527  			// The operand types match the result type.
   528  			check.updateExprType(x.X, typ, final)
   529  			check.updateExprType(x.Y, typ, final)
   530  		}
   531  
   532  	default:
   533  		unreachable()
   534  	}
   535  
   536  	// If the new type is not final and still untyped, just
   537  	// update the recorded type.
   538  	if !final && isUntyped(typ) {
   539  		old.typ = asBasic(typ)
   540  		check.untyped[x] = old
   541  		return
   542  	}
   543  
   544  	// Otherwise we have the final (typed or untyped type).
   545  	// Remove it from the map of yet untyped expressions.
   546  	delete(check.untyped, x)
   547  
   548  	if old.isLhs {
   549  		// If x is the lhs of a shift, its final type must be integer.
   550  		// We already know from the shift check that it is representable
   551  		// as an integer if it is a constant.
   552  		if !isInteger(typ) {
   553  			check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ)
   554  			return
   555  		}
   556  		// Even if we have an integer, if the value is a constant we
   557  		// still must check that it is representable as the specific
   558  		// int type requested (was issue #22969). Fall through here.
   559  	}
   560  	if old.val != nil {
   561  		// If x is a constant, it must be representable as a value of typ.
   562  		c := operand{old.mode, x, old.typ, old.val, 0}
   563  		check.convertUntyped(&c, typ)
   564  		if c.mode == invalid {
   565  			return
   566  		}
   567  	}
   568  
   569  	// Everything's fine, record final type and value for x.
   570  	check.recordTypeAndValue(x, old.mode, typ, old.val)
   571  }
   572  
   573  // updateExprVal updates the value of x to val.
   574  func (check *Checker) updateExprVal(x ast.Expr, val constant.Value) {
   575  	if info, ok := check.untyped[x]; ok {
   576  		info.val = val
   577  		check.untyped[x] = info
   578  	}
   579  }
   580  
   581  // convertUntyped attempts to set the type of an untyped value to the target type.
   582  func (check *Checker) convertUntyped(x *operand, target Type) {
   583  	newType, val, code := check.implicitTypeAndValue(x, target)
   584  	if code != 0 {
   585  		check.invalidConversion(code, x, target.Underlying())
   586  		x.mode = invalid
   587  		return
   588  	}
   589  	if val != nil {
   590  		x.val = val
   591  		check.updateExprVal(x.expr, val)
   592  	}
   593  	if newType != x.typ {
   594  		x.typ = newType
   595  		check.updateExprType(x.expr, newType, false)
   596  	}
   597  }
   598  
   599  // implicitTypeAndValue returns the implicit type of x when used in a context
   600  // where the target type is expected. If no such implicit conversion is
   601  // possible, it returns a nil Type and non-zero error code.
   602  //
   603  // If x is a constant operand, the returned constant.Value will be the
   604  // representation of x in this context.
   605  func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, errorCode) {
   606  	target = expand(target)
   607  	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
   608  		return x.typ, nil, 0
   609  	}
   610  
   611  	if isUntyped(target) {
   612  		// both x and target are untyped
   613  		xkind := x.typ.(*Basic).kind
   614  		tkind := target.(*Basic).kind
   615  		if isNumeric(x.typ) && isNumeric(target) {
   616  			if xkind < tkind {
   617  				return target, nil, 0
   618  			}
   619  		} else if xkind != tkind {
   620  			return nil, nil, _InvalidUntypedConversion
   621  		}
   622  		return x.typ, nil, 0
   623  	}
   624  
   625  	switch t := optype(target).(type) {
   626  	case *Basic:
   627  		if x.mode == constant_ {
   628  			v, code := check.representation(x, t)
   629  			if code != 0 {
   630  				return nil, nil, code
   631  			}
   632  			return target, v, code
   633  		}
   634  		// Non-constant untyped values may appear as the
   635  		// result of comparisons (untyped bool), intermediate
   636  		// (delayed-checked) rhs operands of shifts, and as
   637  		// the value nil.
   638  		switch x.typ.(*Basic).kind {
   639  		case UntypedBool:
   640  			if !isBoolean(target) {
   641  				return nil, nil, _InvalidUntypedConversion
   642  			}
   643  		case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
   644  			if !isNumeric(target) {
   645  				return nil, nil, _InvalidUntypedConversion
   646  			}
   647  		case UntypedString:
   648  			// Non-constant untyped string values are not permitted by the spec and
   649  			// should not occur during normal typechecking passes, but this path is
   650  			// reachable via the AssignableTo API.
   651  			if !isString(target) {
   652  				return nil, nil, _InvalidUntypedConversion
   653  			}
   654  		case UntypedNil:
   655  			// Unsafe.Pointer is a basic type that includes nil.
   656  			if !hasNil(target) {
   657  				return nil, nil, _InvalidUntypedConversion
   658  			}
   659  			// Preserve the type of nil as UntypedNil: see #13061.
   660  			return Typ[UntypedNil], nil, 0
   661  		default:
   662  			return nil, nil, _InvalidUntypedConversion
   663  		}
   664  	case *_Sum:
   665  		ok := t.is(func(t Type) bool {
   666  			target, _, _ := check.implicitTypeAndValue(x, t)
   667  			return target != nil
   668  		})
   669  		if !ok {
   670  			return nil, nil, _InvalidUntypedConversion
   671  		}
   672  		// keep nil untyped (was bug #39755)
   673  		if x.isNil() {
   674  			return Typ[UntypedNil], nil, 0
   675  		}
   676  	case *Interface:
   677  		// Values must have concrete dynamic types. If the value is nil,
   678  		// keep it untyped (this is important for tools such as go vet which
   679  		// need the dynamic type for argument checking of say, print
   680  		// functions)
   681  		if x.isNil() {
   682  			return Typ[UntypedNil], nil, 0
   683  		}
   684  		// cannot assign untyped values to non-empty interfaces
   685  		check.completeInterface(token.NoPos, t)
   686  		if !t.Empty() {
   687  			return nil, nil, _InvalidUntypedConversion
   688  		}
   689  		return Default(x.typ), nil, 0
   690  	case *Pointer, *Signature, *Slice, *Map, *Chan:
   691  		if !x.isNil() {
   692  			return nil, nil, _InvalidUntypedConversion
   693  		}
   694  		// Keep nil untyped - see comment for interfaces, above.
   695  		return Typ[UntypedNil], nil, 0
   696  	default:
   697  		return nil, nil, _InvalidUntypedConversion
   698  	}
   699  	return target, nil, 0
   700  }
   701  
   702  func (check *Checker) comparison(x, y *operand, op token.Token) {
   703  	// spec: "In any comparison, the first operand must be assignable
   704  	// to the type of the second operand, or vice versa."
   705  	err := ""
   706  	var code errorCode
   707  	xok, _ := x.assignableTo(check, y.typ, nil)
   708  	yok, _ := y.assignableTo(check, x.typ, nil)
   709  	if xok || yok {
   710  		defined := false
   711  		switch op {
   712  		case token.EQL, token.NEQ:
   713  			// spec: "The equality operators == and != apply to operands that are comparable."
   714  			defined = Comparable(x.typ) && Comparable(y.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ)
   715  		case token.LSS, token.LEQ, token.GTR, token.GEQ:
   716  			// spec: The ordering operators <, <=, >, and >= apply to operands that are ordered."
   717  			defined = isOrdered(x.typ) && isOrdered(y.typ)
   718  		default:
   719  			unreachable()
   720  		}
   721  		if !defined {
   722  			typ := x.typ
   723  			if x.isNil() {
   724  				typ = y.typ
   725  			}
   726  			err = check.sprintf("operator %s not defined for %s", op, typ)
   727  			code = _UndefinedOp
   728  		}
   729  	} else {
   730  		err = check.sprintf("mismatched types %s and %s", x.typ, y.typ)
   731  		code = _MismatchedTypes
   732  	}
   733  
   734  	if err != "" {
   735  		check.errorf(x, code, "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
   736  		x.mode = invalid
   737  		return
   738  	}
   739  
   740  	if x.mode == constant_ && y.mode == constant_ {
   741  		x.val = constant.MakeBool(constant.Compare(x.val, op, y.val))
   742  		// The operands are never materialized; no need to update
   743  		// their types.
   744  	} else {
   745  		x.mode = value
   746  		// The operands have now their final types, which at run-
   747  		// time will be materialized. Update the expression trees.
   748  		// If the current types are untyped, the materialized type
   749  		// is the respective default type.
   750  		check.updateExprType(x.expr, Default(x.typ), true)
   751  		check.updateExprType(y.expr, Default(y.typ), true)
   752  	}
   753  
   754  	// spec: "Comparison operators compare two operands and yield
   755  	//        an untyped boolean value."
   756  	x.typ = Typ[UntypedBool]
   757  }
   758  
   759  // If e != nil, it must be the shift expression; it may be nil for non-constant shifts.
   760  func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) {
   761  	// TODO(gri) This function seems overly complex. Revisit.
   762  
   763  	var xval constant.Value
   764  	if x.mode == constant_ {
   765  		xval = constant.ToInt(x.val)
   766  	}
   767  
   768  	if isInteger(x.typ) || isUntyped(x.typ) && xval != nil && xval.Kind() == constant.Int {
   769  		// The lhs is of integer type or an untyped constant representable
   770  		// as an integer. Nothing to do.
   771  	} else {
   772  		// shift has no chance
   773  		check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s must be integer", x)
   774  		x.mode = invalid
   775  		return
   776  	}
   777  
   778  	// spec: "The right operand in a shift expression must have integer type
   779  	// or be an untyped constant representable by a value of type uint."
   780  
   781  	// Check that constants are representable by uint, but do not convert them
   782  	// (see also issue #47243).
   783  	if y.mode == constant_ {
   784  		// Provide a good error message for negative shift counts.
   785  		yval := constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
   786  		if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
   787  			check.invalidOp(y, _InvalidShiftCount, "negative shift count %s", y)
   788  			x.mode = invalid
   789  			return
   790  		}
   791  
   792  		if isUntyped(y.typ) {
   793  			// Caution: Check for representability here, rather than in the switch
   794  			// below, because isInteger includes untyped integers (was bug #43697).
   795  			check.representable(y, Typ[Uint])
   796  			if y.mode == invalid {
   797  				x.mode = invalid
   798  				return
   799  			}
   800  		}
   801  	}
   802  
   803  	// Check that RHS is otherwise at least of integer type.
   804  	switch {
   805  	case isInteger(y.typ):
   806  		if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) {
   807  			check.invalidOp(y, _InvalidShiftCount, "signed shift count %s requires go1.13 or later", y)
   808  			x.mode = invalid
   809  			return
   810  		}
   811  	case isUntyped(y.typ):
   812  		// This is incorrect, but preserves pre-existing behavior.
   813  		// See also bug #47410.
   814  		check.convertUntyped(y, Typ[Uint])
   815  		if y.mode == invalid {
   816  			x.mode = invalid
   817  			return
   818  		}
   819  	default:
   820  		check.invalidOp(y, _InvalidShiftCount, "shift count %s must be integer", y)
   821  		x.mode = invalid
   822  		return
   823  	}
   824  
   825  	if x.mode == constant_ {
   826  		if y.mode == constant_ {
   827  			// if either x or y has an unknown value, the result is unknown
   828  			if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
   829  				x.val = constant.MakeUnknown()
   830  				// ensure the correct type - see comment below
   831  				if !isInteger(x.typ) {
   832  					x.typ = Typ[UntypedInt]
   833  				}
   834  				return
   835  			}
   836  			// rhs must be within reasonable bounds in constant shifts
   837  			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see issue #44057)
   838  			s, ok := constant.Uint64Val(y.val)
   839  			if !ok || s > shiftBound {
   840  				check.invalidOp(y, _InvalidShiftCount, "invalid shift count %s", y)
   841  				x.mode = invalid
   842  				return
   843  			}
   844  			// The lhs is representable as an integer but may not be an integer
   845  			// (e.g., 2.0, an untyped float) - this can only happen for untyped
   846  			// non-integer numeric constants. Correct the type so that the shift
   847  			// result is of integer type.
   848  			if !isInteger(x.typ) {
   849  				x.typ = Typ[UntypedInt]
   850  			}
   851  			// x is a constant so xval != nil and it must be of Int kind.
   852  			x.val = constant.Shift(xval, op, uint(s))
   853  			x.expr = e
   854  			opPos := x.Pos()
   855  			if b, _ := e.(*ast.BinaryExpr); b != nil {
   856  				opPos = b.OpPos
   857  			}
   858  			check.overflow(x, op, opPos)
   859  			return
   860  		}
   861  
   862  		// non-constant shift with constant lhs
   863  		if isUntyped(x.typ) {
   864  			// spec: "If the left operand of a non-constant shift
   865  			// expression is an untyped constant, the type of the
   866  			// constant is what it would be if the shift expression
   867  			// were replaced by its left operand alone.".
   868  			//
   869  			// Delay operand checking until we know the final type
   870  			// by marking the lhs expression as lhs shift operand.
   871  			//
   872  			// Usually (in correct programs), the lhs expression
   873  			// is in the untyped map. However, it is possible to
   874  			// create incorrect programs where the same expression
   875  			// is evaluated twice (via a declaration cycle) such
   876  			// that the lhs expression type is determined in the
   877  			// first round and thus deleted from the map, and then
   878  			// not found in the second round (double insertion of
   879  			// the same expr node still just leads to one entry for
   880  			// that node, and it can only be deleted once).
   881  			// Be cautious and check for presence of entry.
   882  			// Example: var e, f = int(1<<""[f]) // issue 11347
   883  			if info, found := check.untyped[x.expr]; found {
   884  				info.isLhs = true
   885  				check.untyped[x.expr] = info
   886  			}
   887  			// keep x's type
   888  			x.mode = value
   889  			return
   890  		}
   891  	}
   892  
   893  	// non-constant shift - lhs must be an integer
   894  	if !isInteger(x.typ) {
   895  		check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s must be integer", x)
   896  		x.mode = invalid
   897  		return
   898  	}
   899  
   900  	x.mode = value
   901  }
   902  
   903  var binaryOpPredicates opPredicates
   904  
   905  func init() {
   906  	// Setting binaryOpPredicates in init avoids declaration cycles.
   907  	binaryOpPredicates = opPredicates{
   908  		token.ADD: isNumericOrString,
   909  		token.SUB: isNumeric,
   910  		token.MUL: isNumeric,
   911  		token.QUO: isNumeric,
   912  		token.REM: isInteger,
   913  
   914  		token.AND:     isInteger,
   915  		token.OR:      isInteger,
   916  		token.XOR:     isInteger,
   917  		token.AND_NOT: isInteger,
   918  
   919  		token.LAND: isBoolean,
   920  		token.LOR:  isBoolean,
   921  	}
   922  }
   923  
   924  // If e != nil, it must be the binary expression; it may be nil for non-constant expressions
   925  // (when invoked for an assignment operation where the binary expression is implicit).
   926  func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token.Token, opPos token.Pos) {
   927  	var y operand
   928  
   929  	check.expr(x, lhs)
   930  	check.expr(&y, rhs)
   931  
   932  	if x.mode == invalid {
   933  		return
   934  	}
   935  	if y.mode == invalid {
   936  		x.mode = invalid
   937  		x.expr = y.expr
   938  		return
   939  	}
   940  
   941  	if isShift(op) {
   942  		check.shift(x, &y, e, op)
   943  		return
   944  	}
   945  
   946  	check.convertUntyped(x, y.typ)
   947  	if x.mode == invalid {
   948  		return
   949  	}
   950  	check.convertUntyped(&y, x.typ)
   951  	if y.mode == invalid {
   952  		x.mode = invalid
   953  		return
   954  	}
   955  
   956  	if isComparison(op) {
   957  		check.comparison(x, &y, op)
   958  		return
   959  	}
   960  
   961  	if !check.identical(x.typ, y.typ) {
   962  		// only report an error if we have valid types
   963  		// (otherwise we had an error reported elsewhere already)
   964  		if x.typ != Typ[Invalid] && y.typ != Typ[Invalid] {
   965  			var posn positioner = x
   966  			if e != nil {
   967  				posn = e
   968  			}
   969  			check.invalidOp(posn, _MismatchedTypes, "mismatched types %s and %s", x.typ, y.typ)
   970  		}
   971  		x.mode = invalid
   972  		return
   973  	}
   974  
   975  	if !check.op(binaryOpPredicates, x, op) {
   976  		x.mode = invalid
   977  		return
   978  	}
   979  
   980  	if op == token.QUO || op == token.REM {
   981  		// check for zero divisor
   982  		if (x.mode == constant_ || isInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 {
   983  			check.invalidOp(&y, _DivByZero, "division by zero")
   984  			x.mode = invalid
   985  			return
   986  		}
   987  
   988  		// check for divisor underflow in complex division (see issue 20227)
   989  		if x.mode == constant_ && y.mode == constant_ && isComplex(x.typ) {
   990  			re, im := constant.Real(y.val), constant.Imag(y.val)
   991  			re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im)
   992  			if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 {
   993  				check.invalidOp(&y, _DivByZero, "division by zero")
   994  				x.mode = invalid
   995  				return
   996  			}
   997  		}
   998  	}
   999  
  1000  	if x.mode == constant_ && y.mode == constant_ {
  1001  		// if either x or y has an unknown value, the result is unknown
  1002  		if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
  1003  			x.val = constant.MakeUnknown()
  1004  			// x.typ is unchanged
  1005  			return
  1006  		}
  1007  		// force integer division of integer operands
  1008  		if op == token.QUO && isInteger(x.typ) {
  1009  			op = token.QUO_ASSIGN
  1010  		}
  1011  		x.val = constant.BinaryOp(x.val, op, y.val)
  1012  		x.expr = e
  1013  		check.overflow(x, op, opPos)
  1014  		return
  1015  	}
  1016  
  1017  	x.mode = value
  1018  	// x.typ is unchanged
  1019  }
  1020  
  1021  // exprKind describes the kind of an expression; the kind
  1022  // determines if an expression is valid in 'statement context'.
  1023  type exprKind int
  1024  
  1025  const (
  1026  	conversion exprKind = iota
  1027  	expression
  1028  	statement
  1029  )
  1030  
  1031  // rawExpr typechecks expression e and initializes x with the expression
  1032  // value or type. If an error occurred, x.mode is set to invalid.
  1033  // If hint != nil, it is the type of a composite literal element.
  1034  //
  1035  func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type) exprKind {
  1036  	if trace {
  1037  		check.trace(e.Pos(), "expr %s", e)
  1038  		check.indent++
  1039  		defer func() {
  1040  			check.indent--
  1041  			check.trace(e.Pos(), "=> %s", x)
  1042  		}()
  1043  	}
  1044  
  1045  	kind := check.exprInternal(x, e, hint)
  1046  	check.record(x)
  1047  
  1048  	return kind
  1049  }
  1050  
  1051  // exprInternal contains the core of type checking of expressions.
  1052  // Must only be called by rawExpr.
  1053  //
  1054  func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
  1055  	// make sure x has a valid state in case of bailout
  1056  	// (was issue 5770)
  1057  	x.mode = invalid
  1058  	x.typ = Typ[Invalid]
  1059  
  1060  	switch e := e.(type) {
  1061  	case *ast.BadExpr:
  1062  		goto Error // error was reported before
  1063  
  1064  	case *ast.Ident:
  1065  		check.ident(x, e, nil, false)
  1066  
  1067  	case *ast.Ellipsis:
  1068  		// ellipses are handled explicitly where they are legal
  1069  		// (array composite literals and parameter lists)
  1070  		check.error(e, _BadDotDotDotSyntax, "invalid use of '...'")
  1071  		goto Error
  1072  
  1073  	case *ast.BasicLit:
  1074  		switch e.Kind {
  1075  		case token.INT, token.FLOAT, token.IMAG:
  1076  			check.langCompat(e)
  1077  			// The max. mantissa precision for untyped numeric values
  1078  			// is 512 bits, or 4048 bits for each of the two integer
  1079  			// parts of a fraction for floating-point numbers that are
  1080  			// represented accurately in the go/constant package.
  1081  			// Constant literals that are longer than this many bits
  1082  			// are not meaningful; and excessively long constants may
  1083  			// consume a lot of space and time for a useless conversion.
  1084  			// Cap constant length with a generous upper limit that also
  1085  			// allows for separators between all digits.
  1086  			const limit = 10000
  1087  			if len(e.Value) > limit {
  1088  				check.errorf(e, _InvalidConstVal, "excessively long constant: %s... (%d chars)", e.Value[:10], len(e.Value))
  1089  				goto Error
  1090  			}
  1091  		}
  1092  		x.setConst(e.Kind, e.Value)
  1093  		if x.mode == invalid {
  1094  			// The parser already establishes syntactic correctness.
  1095  			// If we reach here it's because of number under-/overflow.
  1096  			// TODO(gri) setConst (and in turn the go/constant package)
  1097  			// should return an error describing the issue.
  1098  			check.errorf(e, _InvalidConstVal, "malformed constant: %s", e.Value)
  1099  			goto Error
  1100  		}
  1101  
  1102  	case *ast.FuncLit:
  1103  		if sig, ok := check.typ(e.Type).(*Signature); ok {
  1104  			if !check.conf.IgnoreFuncBodies && e.Body != nil {
  1105  				// Anonymous functions are considered part of the
  1106  				// init expression/func declaration which contains
  1107  				// them: use existing package-level declaration info.
  1108  				decl := check.decl // capture for use in closure below
  1109  				iota := check.iota // capture for use in closure below (#22345)
  1110  				// Don't type-check right away because the function may
  1111  				// be part of a type definition to which the function
  1112  				// body refers. Instead, type-check as soon as possible,
  1113  				// but before the enclosing scope contents changes (#22992).
  1114  				check.later(func() {
  1115  					check.funcBody(decl, "<function literal>", sig, e.Body, iota)
  1116  				})
  1117  			}
  1118  			x.mode = value
  1119  			x.typ = sig
  1120  		} else {
  1121  			check.invalidAST(e, "invalid function literal %s", e)
  1122  			goto Error
  1123  		}
  1124  
  1125  	case *ast.CompositeLit:
  1126  		var typ, base Type
  1127  
  1128  		switch {
  1129  		case e.Type != nil:
  1130  			// composite literal type present - use it
  1131  			// [...]T array types may only appear with composite literals.
  1132  			// Check for them here so we don't have to handle ... in general.
  1133  			if atyp, _ := e.Type.(*ast.ArrayType); atyp != nil && atyp.Len != nil {
  1134  				if ellip, _ := atyp.Len.(*ast.Ellipsis); ellip != nil && ellip.Elt == nil {
  1135  					// We have an "open" [...]T array type.
  1136  					// Create a new ArrayType with unknown length (-1)
  1137  					// and finish setting it up after analyzing the literal.
  1138  					typ = &Array{len: -1, elem: check.varType(atyp.Elt)}
  1139  					base = typ
  1140  					break
  1141  				}
  1142  			}
  1143  			typ = check.typ(e.Type)
  1144  			base = typ
  1145  
  1146  		case hint != nil:
  1147  			// no composite literal type present - use hint (element type of enclosing type)
  1148  			typ = hint
  1149  			base, _ = deref(under(typ)) // *T implies &T{}
  1150  
  1151  		default:
  1152  			// TODO(gri) provide better error messages depending on context
  1153  			check.error(e, _UntypedLit, "missing type in composite literal")
  1154  			goto Error
  1155  		}
  1156  
  1157  		switch utyp := optype(base).(type) {
  1158  		case *Struct:
  1159  			if len(e.Elts) == 0 {
  1160  				break
  1161  			}
  1162  			fields := utyp.fields
  1163  			if _, ok := e.Elts[0].(*ast.KeyValueExpr); ok {
  1164  				// all elements must have keys
  1165  				visited := make([]bool, len(fields))
  1166  				for _, e := range e.Elts {
  1167  					kv, _ := e.(*ast.KeyValueExpr)
  1168  					if kv == nil {
  1169  						check.error(e, _MixedStructLit, "mixture of field:value and value elements in struct literal")
  1170  						continue
  1171  					}
  1172  					key, _ := kv.Key.(*ast.Ident)
  1173  					// do all possible checks early (before exiting due to errors)
  1174  					// so we don't drop information on the floor
  1175  					check.expr(x, kv.Value)
  1176  					if key == nil {
  1177  						check.errorf(kv, _InvalidLitField, "invalid field name %s in struct literal", kv.Key)
  1178  						continue
  1179  					}
  1180  					i := fieldIndex(utyp.fields, check.pkg, key.Name)
  1181  					if i < 0 {
  1182  						check.errorf(kv, _MissingLitField, "unknown field %s in struct literal", key.Name)
  1183  						continue
  1184  					}
  1185  					fld := fields[i]
  1186  					check.recordUse(key, fld)
  1187  					etyp := fld.typ
  1188  					check.assignment(x, etyp, "struct literal")
  1189  					// 0 <= i < len(fields)
  1190  					if visited[i] {
  1191  						check.errorf(kv, _DuplicateLitField, "duplicate field name %s in struct literal", key.Name)
  1192  						continue
  1193  					}
  1194  					visited[i] = true
  1195  				}
  1196  			} else {
  1197  				// no element must have a key
  1198  				for i, e := range e.Elts {
  1199  					if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
  1200  						check.error(kv, _MixedStructLit, "mixture of field:value and value elements in struct literal")
  1201  						continue
  1202  					}
  1203  					check.expr(x, e)
  1204  					if i >= len(fields) {
  1205  						check.error(x, _InvalidStructLit, "too many values in struct literal")
  1206  						break // cannot continue
  1207  					}
  1208  					// i < len(fields)
  1209  					fld := fields[i]
  1210  					if !fld.Exported() && fld.pkg != check.pkg {
  1211  						check.errorf(x,
  1212  							_UnexportedLitField,
  1213  							"implicit assignment to unexported field %s in %s literal", fld.name, typ)
  1214  						continue
  1215  					}
  1216  					etyp := fld.typ
  1217  					check.assignment(x, etyp, "struct literal")
  1218  				}
  1219  				if len(e.Elts) < len(fields) {
  1220  					check.error(inNode(e, e.Rbrace), _InvalidStructLit, "too few values in struct literal")
  1221  					// ok to continue
  1222  				}
  1223  			}
  1224  
  1225  		case *Array:
  1226  			// Prevent crash if the array referred to is not yet set up. Was issue #18643.
  1227  			// This is a stop-gap solution. Should use Checker.objPath to report entire
  1228  			// path starting with earliest declaration in the source. TODO(gri) fix this.
  1229  			if utyp.elem == nil {
  1230  				check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration")
  1231  				goto Error
  1232  			}
  1233  			n := check.indexedElts(e.Elts, utyp.elem, utyp.len)
  1234  			// If we have an array of unknown length (usually [...]T arrays, but also
  1235  			// arrays [n]T where n is invalid) set the length now that we know it and
  1236  			// record the type for the array (usually done by check.typ which is not
  1237  			// called for [...]T). We handle [...]T arrays and arrays with invalid
  1238  			// length the same here because it makes sense to "guess" the length for
  1239  			// the latter if we have a composite literal; e.g. for [n]int{1, 2, 3}
  1240  			// where n is invalid for some reason, it seems fair to assume it should
  1241  			// be 3 (see also Checked.arrayLength and issue #27346).
  1242  			if utyp.len < 0 {
  1243  				utyp.len = n
  1244  				// e.Type is missing if we have a composite literal element
  1245  				// that is itself a composite literal with omitted type. In
  1246  				// that case there is nothing to record (there is no type in
  1247  				// the source at that point).
  1248  				if e.Type != nil {
  1249  					check.recordTypeAndValue(e.Type, typexpr, utyp, nil)
  1250  				}
  1251  			}
  1252  
  1253  		case *Slice:
  1254  			// Prevent crash if the slice referred to is not yet set up.
  1255  			// See analogous comment for *Array.
  1256  			if utyp.elem == nil {
  1257  				check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration")
  1258  				goto Error
  1259  			}
  1260  			check.indexedElts(e.Elts, utyp.elem, -1)
  1261  
  1262  		case *Map:
  1263  			// Prevent crash if the map referred to is not yet set up.
  1264  			// See analogous comment for *Array.
  1265  			if utyp.key == nil || utyp.elem == nil {
  1266  				check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration")
  1267  				goto Error
  1268  			}
  1269  			visited := make(map[interface{}][]Type, len(e.Elts))
  1270  			for _, e := range e.Elts {
  1271  				kv, _ := e.(*ast.KeyValueExpr)
  1272  				if kv == nil {
  1273  					check.error(e, _MissingLitKey, "missing key in map literal")
  1274  					continue
  1275  				}
  1276  				check.exprWithHint(x, kv.Key, utyp.key)
  1277  				check.assignment(x, utyp.key, "map literal")
  1278  				if x.mode == invalid {
  1279  					continue
  1280  				}
  1281  				if x.mode == constant_ {
  1282  					duplicate := false
  1283  					// if the key is of interface type, the type is also significant when checking for duplicates
  1284  					xkey := keyVal(x.val)
  1285  					if asInterface(utyp.key) != nil {
  1286  						for _, vtyp := range visited[xkey] {
  1287  							if check.identical(vtyp, x.typ) {
  1288  								duplicate = true
  1289  								break
  1290  							}
  1291  						}
  1292  						visited[xkey] = append(visited[xkey], x.typ)
  1293  					} else {
  1294  						_, duplicate = visited[xkey]
  1295  						visited[xkey] = nil
  1296  					}
  1297  					if duplicate {
  1298  						check.errorf(x, _DuplicateLitKey, "duplicate key %s in map literal", x.val)
  1299  						continue
  1300  					}
  1301  				}
  1302  				check.exprWithHint(x, kv.Value, utyp.elem)
  1303  				check.assignment(x, utyp.elem, "map literal")
  1304  			}
  1305  
  1306  		default:
  1307  			// when "using" all elements unpack KeyValueExpr
  1308  			// explicitly because check.use doesn't accept them
  1309  			for _, e := range e.Elts {
  1310  				if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
  1311  					// Ideally, we should also "use" kv.Key but we can't know
  1312  					// if it's an externally defined struct key or not. Going
  1313  					// forward anyway can lead to other errors. Give up instead.
  1314  					e = kv.Value
  1315  				}
  1316  				check.use(e)
  1317  			}
  1318  			// if utyp is invalid, an error was reported before
  1319  			if utyp != Typ[Invalid] {
  1320  				check.errorf(e, _InvalidLit, "invalid composite literal type %s", typ)
  1321  				goto Error
  1322  			}
  1323  		}
  1324  
  1325  		x.mode = value
  1326  		x.typ = typ
  1327  
  1328  	case *ast.ParenExpr:
  1329  		kind := check.rawExpr(x, e.X, nil)
  1330  		x.expr = e
  1331  		return kind
  1332  
  1333  	case *ast.SelectorExpr:
  1334  		check.selector(x, e)
  1335  
  1336  	case *ast.IndexExpr:
  1337  		if check.indexExpr(x, e) {
  1338  			check.funcInst(x, e)
  1339  		}
  1340  		if x.mode == invalid {
  1341  			goto Error
  1342  		}
  1343  
  1344  	case *ast.SliceExpr:
  1345  		check.sliceExpr(x, e)
  1346  		if x.mode == invalid {
  1347  			goto Error
  1348  		}
  1349  
  1350  	case *ast.TypeAssertExpr:
  1351  		check.expr(x, e.X)
  1352  		if x.mode == invalid {
  1353  			goto Error
  1354  		}
  1355  		xtyp, _ := under(x.typ).(*Interface)
  1356  		if xtyp == nil {
  1357  			check.invalidOp(x, _InvalidAssert, "%s is not an interface", x)
  1358  			goto Error
  1359  		}
  1360  		check.ordinaryType(x, xtyp)
  1361  		// x.(type) expressions are handled explicitly in type switches
  1362  		if e.Type == nil {
  1363  			// Don't use invalidAST because this can occur in the AST produced by
  1364  			// go/parser.
  1365  			check.error(e, _BadTypeKeyword, "use of .(type) outside type switch")
  1366  			goto Error
  1367  		}
  1368  		T := check.varType(e.Type)
  1369  		if T == Typ[Invalid] {
  1370  			goto Error
  1371  		}
  1372  		check.typeAssertion(x, x, xtyp, T)
  1373  		x.mode = commaok
  1374  		x.typ = T
  1375  
  1376  	case *ast.CallExpr:
  1377  		return check.callExpr(x, e)
  1378  
  1379  	case *ast.StarExpr:
  1380  		check.exprOrType(x, e.X)
  1381  		switch x.mode {
  1382  		case invalid:
  1383  			goto Error
  1384  		case typexpr:
  1385  			x.typ = &Pointer{base: x.typ}
  1386  		default:
  1387  			if typ := asPointer(x.typ); typ != nil {
  1388  				x.mode = variable
  1389  				x.typ = typ.base
  1390  			} else {
  1391  				check.invalidOp(x, _InvalidIndirection, "cannot indirect %s", x)
  1392  				goto Error
  1393  			}
  1394  		}
  1395  
  1396  	case *ast.UnaryExpr:
  1397  		check.unary(x, e)
  1398  		if x.mode == invalid {
  1399  			goto Error
  1400  		}
  1401  		if e.Op == token.ARROW {
  1402  			x.expr = e
  1403  			return statement // receive operations may appear in statement context
  1404  		}
  1405  
  1406  	case *ast.BinaryExpr:
  1407  		check.binary(x, e, e.X, e.Y, e.Op, e.OpPos)
  1408  		if x.mode == invalid {
  1409  			goto Error
  1410  		}
  1411  
  1412  	case *ast.KeyValueExpr:
  1413  		// key:value expressions are handled in composite literals
  1414  		check.invalidAST(e, "no key:value expected")
  1415  		goto Error
  1416  
  1417  	case *ast.ArrayType, *ast.StructType, *ast.FuncType,
  1418  		*ast.InterfaceType, *ast.MapType, *ast.ChanType:
  1419  		x.mode = typexpr
  1420  		x.typ = check.typ(e)
  1421  		// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
  1422  		// even though check.typ has already called it. This is fine as both
  1423  		// times the same expression and type are recorded. It is also not a
  1424  		// performance issue because we only reach here for composite literal
  1425  		// types, which are comparatively rare.
  1426  
  1427  	default:
  1428  		if typeparams.IsListExpr(e) {
  1429  			// catch-all for unexpected expression lists
  1430  			check.errorf(e, _Todo, "unexpected list of expressions")
  1431  		} else {
  1432  			panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
  1433  		}
  1434  	}
  1435  
  1436  	// everything went well
  1437  	x.expr = e
  1438  	return expression
  1439  
  1440  Error:
  1441  	x.mode = invalid
  1442  	x.expr = e
  1443  	return statement // avoid follow-up errors
  1444  }
  1445  
  1446  func keyVal(x constant.Value) interface{} {
  1447  	switch x.Kind() {
  1448  	case constant.Bool:
  1449  		return constant.BoolVal(x)
  1450  	case constant.String:
  1451  		return constant.StringVal(x)
  1452  	case constant.Int:
  1453  		if v, ok := constant.Int64Val(x); ok {
  1454  			return v
  1455  		}
  1456  		if v, ok := constant.Uint64Val(x); ok {
  1457  			return v
  1458  		}
  1459  	case constant.Float:
  1460  		v, _ := constant.Float64Val(x)
  1461  		return v
  1462  	case constant.Complex:
  1463  		r, _ := constant.Float64Val(constant.Real(x))
  1464  		i, _ := constant.Float64Val(constant.Imag(x))
  1465  		return complex(r, i)
  1466  	}
  1467  	return x
  1468  }
  1469  
  1470  // typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
  1471  func (check *Checker) typeAssertion(at positioner, x *operand, xtyp *Interface, T Type) {
  1472  	method, wrongType := check.assertableTo(xtyp, T)
  1473  	if method == nil {
  1474  		return
  1475  	}
  1476  	var msg string
  1477  	if wrongType != nil {
  1478  		if check.identical(method.typ, wrongType.typ) {
  1479  			msg = fmt.Sprintf("missing method %s (%s has pointer receiver)", method.name, method.name)
  1480  		} else {
  1481  			msg = fmt.Sprintf("wrong type for method %s (have %s, want %s)", method.name, wrongType.typ, method.typ)
  1482  		}
  1483  	} else {
  1484  		msg = "missing method " + method.name
  1485  	}
  1486  	check.errorf(at, _ImpossibleAssert, "%s cannot have dynamic type %s (%s)", x, T, msg)
  1487  }
  1488  
  1489  // expr typechecks expression e and initializes x with the expression value.
  1490  // The result must be a single value.
  1491  // If an error occurred, x.mode is set to invalid.
  1492  //
  1493  func (check *Checker) expr(x *operand, e ast.Expr) {
  1494  	check.rawExpr(x, e, nil)
  1495  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1496  	check.singleValue(x)
  1497  }
  1498  
  1499  // multiExpr is like expr but the result may also be a multi-value.
  1500  func (check *Checker) multiExpr(x *operand, e ast.Expr) {
  1501  	check.rawExpr(x, e, nil)
  1502  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1503  }
  1504  
  1505  // exprWithHint typechecks expression e and initializes x with the expression value;
  1506  // hint is the type of a composite literal element.
  1507  // If an error occurred, x.mode is set to invalid.
  1508  //
  1509  func (check *Checker) exprWithHint(x *operand, e ast.Expr, hint Type) {
  1510  	assert(hint != nil)
  1511  	check.rawExpr(x, e, hint)
  1512  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1513  	check.singleValue(x)
  1514  }
  1515  
  1516  // exprOrType typechecks expression or type e and initializes x with the expression value or type.
  1517  // If an error occurred, x.mode is set to invalid.
  1518  //
  1519  func (check *Checker) exprOrType(x *operand, e ast.Expr) {
  1520  	check.rawExpr(x, e, nil)
  1521  	check.exclude(x, 1<<novalue)
  1522  	check.singleValue(x)
  1523  }
  1524  
  1525  // exclude reports an error if x.mode is in modeset and sets x.mode to invalid.
  1526  // The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr.
  1527  func (check *Checker) exclude(x *operand, modeset uint) {
  1528  	if modeset&(1<<x.mode) != 0 {
  1529  		var msg string
  1530  		var code errorCode
  1531  		switch x.mode {
  1532  		case novalue:
  1533  			if modeset&(1<<typexpr) != 0 {
  1534  				msg = "%s used as value"
  1535  			} else {
  1536  				msg = "%s used as value or type"
  1537  			}
  1538  			code = _TooManyValues
  1539  		case builtin:
  1540  			msg = "%s must be called"
  1541  			code = _UncalledBuiltin
  1542  		case typexpr:
  1543  			msg = "%s is not an expression"
  1544  			code = _NotAnExpr
  1545  		default:
  1546  			unreachable()
  1547  		}
  1548  		check.errorf(x, code, msg, x)
  1549  		x.mode = invalid
  1550  	}
  1551  }
  1552  
  1553  // singleValue reports an error if x describes a tuple and sets x.mode to invalid.
  1554  func (check *Checker) singleValue(x *operand) {
  1555  	if x.mode == value {
  1556  		// tuple types are never named - no need for underlying type below
  1557  		if t, ok := x.typ.(*Tuple); ok {
  1558  			assert(t.Len() != 1)
  1559  			check.errorf(x, _TooManyValues, "%d-valued %s where single value is expected", t.Len(), x)
  1560  			x.mode = invalid
  1561  		}
  1562  	}
  1563  }
  1564  

View as plain text