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

View as plain text