expr.go

     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 types2
     8  
     9  import (
    10  	"cmd/compile/internal/syntax"
    11  	"fmt"
    12  	"go/constant"
    13  	"go/token"
    14  	. "internal/types/errors"
    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 *syntax.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[syntax.Operator]func(Type) bool
    60  
    61  var unaryOpPredicates opPredicates
    62  
    63  func init() {
    64  	// Setting unaryOpPredicates in init avoids declaration cycles.
    65  	unaryOpPredicates = opPredicates{
    66  		syntax.Add: allNumeric,
    67  		syntax.Sub: allNumeric,
    68  		syntax.Xor: allInteger,
    69  		syntax.Not: allBoolean,
    70  	}
    71  }
    72  
    73  func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
    74  	if pred := m[op]; pred != nil {
    75  		if !pred(x.typ()) {
    76  			check.errorf(x, UndefinedOp, invalidOp+"operator %s not defined on %s", op, x)
    77  			return false
    78  		}
    79  	} else {
    80  		check.errorf(x, InvalidSyntaxTree, "unknown operator %s", op)
    81  		return false
    82  	}
    83  	return true
    84  }
    85  
    86  // opPos returns the position of the operator if x is an operation;
    87  // otherwise it returns the start position of x.
    88  func opPos(x syntax.Expr) syntax.Pos {
    89  	switch op := x.(type) {
    90  	case nil:
    91  		return nopos // don't crash
    92  	case *syntax.Operation:
    93  		return op.Pos()
    94  	default:
    95  		return syntax.StartPos(x)
    96  	}
    97  }
    98  
    99  // opName returns the name of the operation if x is an operation
   100  // that might overflow; otherwise it returns the empty string.
   101  func opName(x syntax.Expr) string {
   102  	if e, _ := x.(*syntax.Operation); e != nil {
   103  		op := int(e.Op)
   104  		if e.Y == nil {
   105  			if op < len(op2str1) {
   106  				return op2str1[op]
   107  			}
   108  		} else {
   109  			if op < len(op2str2) {
   110  				return op2str2[op]
   111  			}
   112  		}
   113  	}
   114  	return ""
   115  }
   116  
   117  var op2str1 = [...]string{
   118  	syntax.Xor: "bitwise complement",
   119  }
   120  
   121  // This is only used for operations that may cause overflow.
   122  var op2str2 = [...]string{
   123  	syntax.Add: "addition",
   124  	syntax.Sub: "subtraction",
   125  	syntax.Xor: "bitwise XOR",
   126  	syntax.Mul: "multiplication",
   127  	syntax.Shl: "shift",
   128  }
   129  
   130  func (check *Checker) unary(x *operand, e *syntax.Operation) {
   131  	check.expr(nil, x, e.X)
   132  	if !x.isValid() {
   133  		return
   134  	}
   135  
   136  	op := e.Op
   137  	switch op {
   138  	case syntax.And:
   139  		// spec: "As an exception to the addressability
   140  		// requirement x may also be a composite literal."
   141  		if _, ok := syntax.Unparen(e.X).(*syntax.CompositeLit); !ok && x.mode() != variable {
   142  			check.errorf(x, UnaddressableOperand, invalidOp+"cannot take address of %s", x)
   143  			x.invalidate()
   144  			return
   145  		}
   146  		x.mode_ = value
   147  		x.typ_ = &Pointer{base: x.typ()}
   148  		return
   149  
   150  	case syntax.Recv:
   151  		// We cannot receive a value with an incomplete type; make sure it's complete.
   152  		if elem := check.chanElem(x, x, true); elem != nil && check.isComplete(elem) {
   153  			x.mode_ = commaok
   154  			x.typ_ = elem
   155  			check.hasCallOrRecv = true
   156  			return
   157  		}
   158  		x.invalidate()
   159  		return
   160  
   161  	case syntax.Tilde:
   162  		// Provide a better error position and message than what check.op below would do.
   163  		if !allInteger(x.typ()) {
   164  			check.error(e, UndefinedOp, "cannot use ~ outside of interface or type constraint")
   165  			x.invalidate()
   166  			return
   167  		}
   168  		check.error(e, UndefinedOp, "cannot use ~ outside of interface or type constraint (use ^ for bitwise complement)")
   169  		op = syntax.Xor
   170  	}
   171  
   172  	if !check.op(unaryOpPredicates, x, op) {
   173  		x.invalidate()
   174  		return
   175  	}
   176  
   177  	if x.mode() == constant_ {
   178  		if x.val.Kind() == constant.Unknown {
   179  			// nothing to do (and don't cause an error below in the overflow check)
   180  			return
   181  		}
   182  		var prec uint
   183  		if isUnsigned(x.typ()) {
   184  			prec = uint(check.conf.sizeof(x.typ()) * 8)
   185  		}
   186  		x.val = constant.UnaryOp(op2tok[op], x.val, prec)
   187  		x.expr = e
   188  		check.overflow(x, opPos(x.expr))
   189  		return
   190  	}
   191  
   192  	x.mode_ = value
   193  	// x.typ remains unchanged
   194  }
   195  
   196  // chanElem returns the channel element type of x for a receive from x (recv == true)
   197  // or send to x (recv == false) operation. If the operation is not valid, chanElem
   198  // reports an error and returns nil.
   199  func (check *Checker) chanElem(pos poser, x *operand, recv bool) Type {
   200  	u, err := commonUnder(x.typ(), func(t, u Type) *typeError {
   201  		if u == nil {
   202  			return typeErrorf("no specific channel type")
   203  		}
   204  		ch, _ := u.(*Chan)
   205  		if ch == nil {
   206  			return typeErrorf("non-channel %s", t)
   207  		}
   208  		if recv && ch.dir == SendOnly {
   209  			return typeErrorf("send-only channel %s", t)
   210  		}
   211  		if !recv && ch.dir == RecvOnly {
   212  			return typeErrorf("receive-only channel %s", t)
   213  		}
   214  		return nil
   215  	})
   216  
   217  	if u != nil {
   218  		return u.(*Chan).elem
   219  	}
   220  
   221  	cause := err.format(check)
   222  	if recv {
   223  		if isTypeParam(x.typ()) {
   224  			check.errorf(pos, InvalidReceive, invalidOp+"cannot receive from %s: %s", x, cause)
   225  		} else {
   226  			// In this case, only the non-channel and send-only channel error are possible.
   227  			check.errorf(pos, InvalidReceive, invalidOp+"cannot receive from %s %s", cause, x)
   228  		}
   229  	} else {
   230  		if isTypeParam(x.typ()) {
   231  			check.errorf(pos, InvalidSend, invalidOp+"cannot send to %s: %s", x, cause)
   232  		} else {
   233  			// In this case, only the non-channel and receive-only channel error are possible.
   234  			check.errorf(pos, InvalidSend, invalidOp+"cannot send to %s %s", cause, x)
   235  		}
   236  	}
   237  	return nil
   238  }
   239  
   240  func isShift(op syntax.Operator) bool {
   241  	return op == syntax.Shl || op == syntax.Shr
   242  }
   243  
   244  func isComparison(op syntax.Operator) bool {
   245  	// Note: tokens are not ordered well to make this much easier
   246  	switch op {
   247  	case syntax.Eql, syntax.Neq, syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq:
   248  		return true
   249  	}
   250  	return false
   251  }
   252  
   253  // updateExprType updates the type of x to typ and invokes itself
   254  // recursively for the operands of x, depending on expression kind.
   255  // If typ is still an untyped and not the final type, updateExprType
   256  // only updates the recorded untyped type for x and possibly its
   257  // operands. Otherwise (i.e., typ is not an untyped type anymore,
   258  // or it is the final type for x), the type and value are recorded.
   259  // Also, if x is a constant, it must be representable as a value of typ,
   260  // and if x is the (formerly untyped) lhs operand of a non-constant
   261  // shift, it must be an integer value.
   262  func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
   263  	old, found := check.untyped[x]
   264  	if !found {
   265  		return // nothing to do
   266  	}
   267  
   268  	// update operands of x if necessary
   269  	switch x := x.(type) {
   270  	case *syntax.BadExpr,
   271  		*syntax.FuncLit,
   272  		*syntax.CompositeLit,
   273  		*syntax.IndexExpr,
   274  		*syntax.SliceExpr,
   275  		*syntax.AssertExpr,
   276  		*syntax.ListExpr,
   277  		//*syntax.StarExpr,
   278  		*syntax.KeyValueExpr,
   279  		*syntax.ArrayType,
   280  		*syntax.StructType,
   281  		*syntax.FuncType,
   282  		*syntax.InterfaceType,
   283  		*syntax.MapType,
   284  		*syntax.ChanType:
   285  		// These expression are never untyped - nothing to do.
   286  		// The respective sub-expressions got their final types
   287  		// upon assignment or use.
   288  		if debug {
   289  			check.dump("%v: found old type(%s): %s (new: %s)", atPos(x), x, old.typ, typ)
   290  			panic("unreachable")
   291  		}
   292  		return
   293  
   294  	case *syntax.CallExpr:
   295  		// Resulting in an untyped constant (e.g., built-in complex).
   296  		// The respective calls take care of calling updateExprType
   297  		// for the arguments if necessary.
   298  
   299  	case *syntax.Name, *syntax.BasicLit, *syntax.SelectorExpr:
   300  		// An identifier denoting a constant, a constant literal,
   301  		// or a qualified identifier (imported untyped constant).
   302  		// No operands to take care of.
   303  
   304  	case *syntax.ParenExpr:
   305  		check.updateExprType(x.X, typ, final)
   306  
   307  	// case *syntax.UnaryExpr:
   308  	// 	// If x is a constant, the operands were constants.
   309  	// 	// The operands don't need to be updated since they
   310  	// 	// never get "materialized" into a typed value. If
   311  	// 	// left in the untyped map, they will be processed
   312  	// 	// at the end of the type check.
   313  	// 	if old.val != nil {
   314  	// 		break
   315  	// 	}
   316  	// 	check.updateExprType(x.X, typ, final)
   317  
   318  	case *syntax.Operation:
   319  		if x.Y == nil {
   320  			// unary expression
   321  			if x.Op == syntax.Mul {
   322  				// see commented out code for StarExpr above
   323  				// TODO(gri) needs cleanup
   324  				if debug {
   325  					panic("unimplemented")
   326  				}
   327  				return
   328  			}
   329  			// If x is a constant, the operands were constants.
   330  			// The operands don't need to be updated since they
   331  			// never get "materialized" into a typed value. If
   332  			// left in the untyped map, they will be processed
   333  			// at the end of the type check.
   334  			if old.val != nil {
   335  				break
   336  			}
   337  			check.updateExprType(x.X, typ, final)
   338  			break
   339  		}
   340  
   341  		// binary expression
   342  		if old.val != nil {
   343  			break // see comment for unary expressions
   344  		}
   345  		if isComparison(x.Op) {
   346  			// The result type is independent of operand types
   347  			// and the operand types must have final types.
   348  		} else if isShift(x.Op) {
   349  			// The result type depends only on lhs operand.
   350  			// The rhs type was updated when checking the shift.
   351  			check.updateExprType(x.X, typ, final)
   352  		} else {
   353  			// The operand types match the result type.
   354  			check.updateExprType(x.X, typ, final)
   355  			check.updateExprType(x.Y, typ, final)
   356  		}
   357  
   358  	default:
   359  		panic("unreachable")
   360  	}
   361  
   362  	// If the new type is not final and still untyped, just
   363  	// update the recorded type.
   364  	if !final && isUntyped(typ) {
   365  		old.typ = typ.Underlying().(*Basic)
   366  		check.untyped[x] = old
   367  		return
   368  	}
   369  
   370  	// Otherwise we have the final (typed or untyped type).
   371  	// Remove it from the map of yet untyped expressions.
   372  	delete(check.untyped, x)
   373  
   374  	if old.isLhs {
   375  		// If x is the lhs of a shift, its final type must be integer.
   376  		// We already know from the shift check that it is representable
   377  		// as an integer if it is a constant.
   378  		if !allInteger(typ) {
   379  			check.errorf(x, InvalidShiftOperand, invalidOp+"shifted operand %s (type %s) must be integer", x, typ)
   380  			return
   381  		}
   382  		// Even if we have an integer, if the value is a constant we
   383  		// still must check that it is representable as the specific
   384  		// int type requested (was go.dev/issue/22969). Fall through here.
   385  	}
   386  	if old.val != nil {
   387  		// If x is a constant, it must be representable as a value of typ.
   388  		c := operand{old.mode, x, old.typ, old.val, 0}
   389  		check.convertUntyped(&c, typ)
   390  		if !c.isValid() {
   391  			return
   392  		}
   393  	}
   394  
   395  	// Everything's fine, record final type and value for x.
   396  	check.recordTypeAndValue(x, old.mode, typ, old.val)
   397  }
   398  
   399  // updateExprVal updates the value of x to val.
   400  func (check *Checker) updateExprVal(x syntax.Expr, val constant.Value) {
   401  	if info, ok := check.untyped[x]; ok {
   402  		info.val = val
   403  		check.untyped[x] = info
   404  	}
   405  }
   406  
   407  // implicitTypeAndValue returns the implicit type of x when used in a context
   408  // where the target type is expected. If no such implicit conversion is
   409  // possible, it returns a nil Type and non-zero error code.
   410  //
   411  // If x is a constant operand, the returned constant.Value will be the
   412  // representation of x in this context.
   413  func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, constant.Value, Code) {
   414  	if !x.isValid() || isTyped(x.typ()) || !isValid(target) {
   415  		return x.typ(), nil, 0
   416  	}
   417  	// x is untyped
   418  
   419  	if isUntyped(target) {
   420  		// both x and target are untyped
   421  		if m := maxType(x.typ(), target); m != nil {
   422  			return m, nil, 0
   423  		}
   424  		return nil, nil, InvalidUntypedConversion
   425  	}
   426  
   427  	if x.isNil() {
   428  		assert(isUntyped(x.typ()))
   429  		if hasNil(target) {
   430  			return target, nil, 0
   431  		}
   432  		return nil, nil, InvalidUntypedConversion
   433  	}
   434  
   435  	switch u := target.Underlying().(type) {
   436  	case *Basic:
   437  		if x.mode() == constant_ {
   438  			v, code := check.representation(x, u)
   439  			if code != 0 {
   440  				return nil, nil, code
   441  			}
   442  			return target, v, code
   443  		}
   444  		// Non-constant untyped values may appear as the
   445  		// result of comparisons (untyped bool), intermediate
   446  		// (delayed-checked) rhs operands of shifts, and as
   447  		// the value nil.
   448  		switch x.typ().(*Basic).kind {
   449  		case UntypedBool:
   450  			if !isBoolean(target) {
   451  				return nil, nil, InvalidUntypedConversion
   452  			}
   453  		case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
   454  			if !isNumeric(target) {
   455  				return nil, nil, InvalidUntypedConversion
   456  			}
   457  		case UntypedString:
   458  			// Non-constant untyped string values are not permitted by the spec and
   459  			// should not occur during normal typechecking passes, but this path is
   460  			// reachable via the AssignableTo API.
   461  			if !isString(target) {
   462  				return nil, nil, InvalidUntypedConversion
   463  			}
   464  		default:
   465  			return nil, nil, InvalidUntypedConversion
   466  		}
   467  	case *Interface:
   468  		if isTypeParam(target) {
   469  			if !underIs(target, func(u Type) bool {
   470  				if u == nil {
   471  					return false
   472  				}
   473  				t, _, _ := check.implicitTypeAndValue(x, u)
   474  				return t != nil
   475  			}) {
   476  				return nil, nil, InvalidUntypedConversion
   477  			}
   478  			break
   479  		}
   480  		// Update operand types to the default type rather than the target
   481  		// (interface) type: values must have concrete dynamic types.
   482  		// Untyped nil was handled upfront.
   483  		if !u.Empty() {
   484  			return nil, nil, InvalidUntypedConversion // cannot assign untyped values to non-empty interfaces
   485  		}
   486  		return Default(x.typ()), nil, 0 // default type for nil is nil
   487  	default:
   488  		return nil, nil, InvalidUntypedConversion
   489  	}
   490  	return target, nil, 0
   491  }
   492  
   493  // If switchCase is true, the operator op is ignored.
   494  func (check *Checker) comparison(x, y *operand, op syntax.Operator, switchCase bool) {
   495  	// Avoid spurious errors if any of the operands has an invalid type (go.dev/issue/54405).
   496  	if !isValid(x.typ()) || !isValid(y.typ()) {
   497  		x.invalidate()
   498  		return
   499  	}
   500  
   501  	if switchCase {
   502  		op = syntax.Eql
   503  	}
   504  
   505  	errOp := x  // operand for which error is reported, if any
   506  	cause := "" // specific error cause, if any
   507  
   508  	// spec: "In any comparison, the first operand must be assignable
   509  	// to the type of the second operand, or vice versa."
   510  	code := MismatchedTypes
   511  	ok, _ := x.assignableTo(check, y.typ(), nil)
   512  	if !ok {
   513  		ok, _ = y.assignableTo(check, x.typ(), nil)
   514  	}
   515  	if !ok {
   516  		// Report the error on the 2nd operand since we only
   517  		// know after seeing the 2nd operand whether we have
   518  		// a type mismatch.
   519  		errOp = y
   520  		cause = check.sprintf("mismatched types %s and %s", x.typ(), y.typ())
   521  		goto Error
   522  	}
   523  
   524  	// check if comparison is defined for operands
   525  	code = UndefinedOp
   526  	switch op {
   527  	case syntax.Eql, syntax.Neq:
   528  		// spec: "The equality operators == and != apply to operands that are comparable."
   529  		switch {
   530  		case x.isNil() || y.isNil():
   531  			// Comparison against nil requires that the other operand type has nil.
   532  			typ := x.typ()
   533  			if x.isNil() {
   534  				typ = y.typ()
   535  			}
   536  			if !hasNil(typ) {
   537  				// This case should only be possible for "nil == nil".
   538  				// Report the error on the 2nd operand since we only
   539  				// know after seeing the 2nd operand whether we have
   540  				// an invalid comparison.
   541  				errOp = y
   542  				goto Error
   543  			}
   544  
   545  		case !Comparable(x.typ()):
   546  			errOp = x
   547  			cause = check.incomparableCause(x.typ())
   548  			goto Error
   549  
   550  		case !Comparable(y.typ()):
   551  			errOp = y
   552  			cause = check.incomparableCause(y.typ())
   553  			goto Error
   554  		}
   555  
   556  	case syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq:
   557  		// spec: The ordering operators <, <=, >, and >= apply to operands that are ordered."
   558  		switch {
   559  		case !allOrdered(x.typ()):
   560  			errOp = x
   561  			goto Error
   562  		case !allOrdered(y.typ()):
   563  			errOp = y
   564  			goto Error
   565  		}
   566  
   567  	default:
   568  		panic("unreachable")
   569  	}
   570  
   571  	// comparison is ok
   572  	if x.mode() == constant_ && y.mode() == constant_ {
   573  		x.val = constant.MakeBool(constant.Compare(x.val, op2tok[op], y.val))
   574  		// The operands are never materialized; no need to update
   575  		// their types.
   576  	} else {
   577  		x.mode_ = value
   578  		// The operands have now their final types, which at run-
   579  		// time will be materialized. Update the expression trees.
   580  		// If the current types are untyped, the materialized type
   581  		// is the respective default type.
   582  		check.updateExprType(x.expr, Default(x.typ()), true)
   583  		check.updateExprType(y.expr, Default(y.typ()), true)
   584  	}
   585  
   586  	// spec: "Comparison operators compare two operands and yield
   587  	//        an untyped boolean value."
   588  	x.typ_ = Typ[UntypedBool]
   589  	return
   590  
   591  Error:
   592  	// We have an offending operand errOp and possibly an error cause.
   593  	if cause == "" {
   594  		if isTypeParam(x.typ()) || isTypeParam(y.typ()) {
   595  			// TODO(gri) should report the specific type causing the problem, if any
   596  			if !isTypeParam(x.typ()) {
   597  				errOp = y
   598  			}
   599  			cause = check.sprintf("type parameter %s cannot use operator %s", errOp.typ(), op)
   600  		} else {
   601  			// catch-all: neither x nor y is a type parameter
   602  			what := compositeKind(errOp.typ())
   603  			if what == "" {
   604  				what = check.sprintf("%s", errOp.typ())
   605  			}
   606  			cause = check.sprintf("operator %s not defined on %s", op, what)
   607  		}
   608  	}
   609  	if switchCase {
   610  		check.errorf(x, code, "invalid case %s in switch on %s (%s)", x.expr, y.expr, cause) // error position always at 1st operand
   611  	} else {
   612  		check.errorf(errOp, code, invalidOp+"%s %s %s (%s)", x.expr, op, y.expr, cause)
   613  	}
   614  	x.invalidate()
   615  }
   616  
   617  // incomparableCause returns a more specific cause why typ is not comparable.
   618  // If there is no more specific cause, the result is "".
   619  func (check *Checker) incomparableCause(typ Type) string {
   620  	switch typ.Underlying().(type) {
   621  	case *Slice, *Signature, *Map:
   622  		return compositeKind(typ) + " can only be compared to nil"
   623  	}
   624  	// see if we can extract a more specific error
   625  	return comparableType(typ, true, nil).format(check)
   626  }
   627  
   628  // If e != nil, it must be the shift expression; it may be nil for non-constant shifts.
   629  func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
   630  	// TODO(gri) This function seems overly complex. Revisit.
   631  
   632  	var xval constant.Value
   633  	if x.mode() == constant_ {
   634  		xval = constant.ToInt(x.val)
   635  	}
   636  
   637  	if allInteger(x.typ()) || isUntyped(x.typ()) && xval != nil && xval.Kind() == constant.Int {
   638  		// The lhs is of integer type or an untyped constant representable
   639  		// as an integer. Nothing to do.
   640  	} else {
   641  		// shift has no chance
   642  		check.errorf(x, InvalidShiftOperand, invalidOp+"shifted operand %s must be integer", x)
   643  		x.invalidate()
   644  		return
   645  	}
   646  
   647  	// spec: "The right operand in a shift expression must have integer type
   648  	// or be an untyped constant representable by a value of type uint."
   649  
   650  	// Check that constants are representable by uint, but do not convert them
   651  	// (see also go.dev/issue/47243).
   652  	var yval constant.Value
   653  	if y.mode() == constant_ {
   654  		// Provide a good error message for negative shift counts.
   655  		yval = constant.ToInt(y.val) // consider -1, 1.0, but not -1.1
   656  		if yval.Kind() == constant.Int && constant.Sign(yval) < 0 {
   657  			check.errorf(y, InvalidShiftCount, invalidOp+"negative shift count %s", y)
   658  			x.invalidate()
   659  			return
   660  		}
   661  
   662  		if isUntyped(y.typ()) {
   663  			// Caution: Check for representability here, rather than in the switch
   664  			// below, because isInteger includes untyped integers (was bug go.dev/issue/43697).
   665  			check.representable(y, Typ[Uint])
   666  			if !y.isValid() {
   667  				x.invalidate()
   668  				return
   669  			}
   670  		}
   671  	} else {
   672  		// Check that RHS is otherwise at least of integer type.
   673  		switch {
   674  		case allInteger(y.typ()):
   675  			if !allUnsigned(y.typ()) && !check.verifyVersionf(y, go1_13, invalidOp+"signed shift count %s", y) {
   676  				x.invalidate()
   677  				return
   678  			}
   679  		case isUntyped(y.typ()):
   680  			// This is incorrect, but preserves pre-existing behavior.
   681  			// See also go.dev/issue/47410.
   682  			check.convertUntyped(y, Typ[Uint])
   683  			if !y.isValid() {
   684  				x.invalidate()
   685  				return
   686  			}
   687  		default:
   688  			check.errorf(y, InvalidShiftCount, invalidOp+"shift count %s must be integer", y)
   689  			x.invalidate()
   690  			return
   691  		}
   692  	}
   693  
   694  	if x.mode() == constant_ {
   695  		if y.mode() == constant_ {
   696  			// if either x or y has an unknown value, the result is unknown
   697  			if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
   698  				x.val = constant.MakeUnknown()
   699  				// ensure the correct type - see comment below
   700  				if !isInteger(x.typ()) {
   701  					x.typ_ = Typ[UntypedInt]
   702  				}
   703  				return
   704  			}
   705  			// rhs must be within reasonable bounds in constant shifts
   706  			const shiftBound = 1023 - 1 + 52 // so we can express smallestFloat64 (see go.dev/issue/44057)
   707  			s, ok := constant.Uint64Val(yval)
   708  			if !ok || s > shiftBound {
   709  				check.errorf(y, InvalidShiftCount, invalidOp+"invalid shift count %s", y)
   710  				x.invalidate()
   711  				return
   712  			}
   713  			// The lhs is representable as an integer but may not be an integer
   714  			// (e.g., 2.0, an untyped float) - this can only happen for untyped
   715  			// non-integer numeric constants. Correct the type so that the shift
   716  			// result is of integer type.
   717  			if !isInteger(x.typ()) {
   718  				x.typ_ = Typ[UntypedInt]
   719  			}
   720  			// x is a constant so xval != nil and it must be of Int kind.
   721  			x.val = constant.Shift(xval, op2tok[op], uint(s))
   722  			x.expr = e
   723  			check.overflow(x, opPos(x.expr))
   724  			return
   725  		}
   726  
   727  		// non-constant shift with constant lhs
   728  		if isUntyped(x.typ()) {
   729  			// spec: "If the left operand of a non-constant shift
   730  			// expression is an untyped constant, the type of the
   731  			// constant is what it would be if the shift expression
   732  			// were replaced by its left operand alone.".
   733  			//
   734  			// Delay operand checking until we know the final type
   735  			// by marking the lhs expression as lhs shift operand.
   736  			//
   737  			// Usually (in correct programs), the lhs expression
   738  			// is in the untyped map. However, it is possible to
   739  			// create incorrect programs where the same expression
   740  			// is evaluated twice (via a declaration cycle) such
   741  			// that the lhs expression type is determined in the
   742  			// first round and thus deleted from the map, and then
   743  			// not found in the second round (double insertion of
   744  			// the same expr node still just leads to one entry for
   745  			// that node, and it can only be deleted once).
   746  			// Be cautious and check for presence of entry.
   747  			// Example: var e, f = int(1<<""[f]) // go.dev/issue/11347
   748  			if info, found := check.untyped[x.expr]; found {
   749  				info.isLhs = true
   750  				check.untyped[x.expr] = info
   751  			}
   752  			// keep x's type
   753  			x.mode_ = value
   754  			return
   755  		}
   756  	}
   757  
   758  	// non-constant shift - lhs must be an integer
   759  	if !allInteger(x.typ()) {
   760  		check.errorf(x, InvalidShiftOperand, invalidOp+"shifted operand %s must be integer", x)
   761  		x.invalidate()
   762  		return
   763  	}
   764  
   765  	x.mode_ = value
   766  }
   767  
   768  var binaryOpPredicates opPredicates
   769  
   770  func init() {
   771  	// Setting binaryOpPredicates in init avoids declaration cycles.
   772  	binaryOpPredicates = opPredicates{
   773  		syntax.Add: allNumericOrString,
   774  		syntax.Sub: allNumeric,
   775  		syntax.Mul: allNumeric,
   776  		syntax.Div: allNumeric,
   777  		syntax.Rem: allInteger,
   778  
   779  		syntax.And:    allInteger,
   780  		syntax.Or:     allInteger,
   781  		syntax.Xor:    allInteger,
   782  		syntax.AndNot: allInteger,
   783  
   784  		syntax.AndAnd: allBoolean,
   785  		syntax.OrOr:   allBoolean,
   786  	}
   787  }
   788  
   789  // If e != nil, it must be the binary expression; it may be nil for non-constant expressions
   790  // (when invoked for an assignment operation where the binary expression is implicit).
   791  func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op syntax.Operator) {
   792  	var y operand
   793  
   794  	check.expr(nil, x, lhs)
   795  	check.expr(nil, &y, rhs)
   796  
   797  	if !x.isValid() {
   798  		return
   799  	}
   800  	if !y.isValid() {
   801  		x.invalidate()
   802  		x.expr = y.expr
   803  		return
   804  	}
   805  
   806  	if isShift(op) {
   807  		check.shift(x, &y, e, op)
   808  		return
   809  	}
   810  
   811  	check.matchTypes(x, &y)
   812  	if !x.isValid() {
   813  		return
   814  	}
   815  
   816  	if isComparison(op) {
   817  		check.comparison(x, &y, op, false)
   818  		return
   819  	}
   820  
   821  	if !Identical(x.typ(), y.typ()) {
   822  		// only report an error if we have valid types
   823  		// (otherwise we had an error reported elsewhere already)
   824  		if isValid(x.typ()) && isValid(y.typ()) {
   825  			if e != nil {
   826  				check.errorf(x, MismatchedTypes, invalidOp+"%s (mismatched types %s and %s)", e, x.typ(), y.typ())
   827  			} else {
   828  				check.errorf(x, MismatchedTypes, invalidOp+"%s %s= %s (mismatched types %s and %s)", lhs, op, rhs, x.typ(), y.typ())
   829  			}
   830  		}
   831  		x.invalidate()
   832  		return
   833  	}
   834  
   835  	if !check.op(binaryOpPredicates, x, op) {
   836  		x.invalidate()
   837  		return
   838  	}
   839  
   840  	if op == syntax.Div || op == syntax.Rem {
   841  		// check for zero divisor
   842  		if (x.mode() == constant_ || allInteger(x.typ())) && y.mode() == constant_ && constant.Sign(y.val) == 0 {
   843  			check.error(&y, DivByZero, invalidOp+"division by zero")
   844  			x.invalidate()
   845  			return
   846  		}
   847  
   848  		// check for divisor underflow in complex division (see go.dev/issue/20227)
   849  		if x.mode() == constant_ && y.mode() == constant_ && isComplex(x.typ()) {
   850  			re, im := constant.Real(y.val), constant.Imag(y.val)
   851  			re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im)
   852  			if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 {
   853  				check.error(&y, DivByZero, invalidOp+"division by zero")
   854  				x.invalidate()
   855  				return
   856  			}
   857  		}
   858  	}
   859  
   860  	if x.mode() == constant_ && y.mode() == constant_ {
   861  		// if either x or y has an unknown value, the result is unknown
   862  		if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
   863  			x.val = constant.MakeUnknown()
   864  			// x.typ is unchanged
   865  			return
   866  		}
   867  		// force integer division for integer operands
   868  		tok := op2tok[op]
   869  		if op == syntax.Div && isInteger(x.typ()) {
   870  			tok = token.QUO_ASSIGN
   871  		}
   872  		x.val = constant.BinaryOp(x.val, tok, y.val)
   873  		x.expr = e
   874  		check.overflow(x, opPos(x.expr))
   875  		return
   876  	}
   877  
   878  	x.mode_ = value
   879  	// x.typ is unchanged
   880  }
   881  
   882  // matchTypes attempts to convert any untyped types x and y such that they match.
   883  // If an error occurs, x.mode is set to invalid.
   884  func (check *Checker) matchTypes(x, y *operand) {
   885  	// mayConvert reports whether the operands x and y may
   886  	// possibly have matching types after converting one
   887  	// untyped operand to the type of the other.
   888  	// If mayConvert returns true, we try to convert the
   889  	// operands to each other's types, and if that fails
   890  	// we report a conversion failure.
   891  	// If mayConvert returns false, we continue without an
   892  	// attempt at conversion, and if the operand types are
   893  	// not compatible, we report a type mismatch error.
   894  	mayConvert := func(x, y *operand) bool {
   895  		// If both operands are typed, there's no need for an implicit conversion.
   896  		if isTyped(x.typ()) && isTyped(y.typ()) {
   897  			return false
   898  		}
   899  		// A numeric type can only convert to another numeric type.
   900  		if allNumeric(x.typ()) != allNumeric(y.typ()) {
   901  			return false
   902  		}
   903  		// An untyped operand may convert to its default type when paired with an empty interface
   904  		// TODO(gri) This should only matter for comparisons (the only binary operation that is
   905  		//           valid with interfaces), but in that case the assignability check should take
   906  		//           care of the conversion. Verify and possibly eliminate this extra test.
   907  		if isNonTypeParamInterface(x.typ()) || isNonTypeParamInterface(y.typ()) {
   908  			return true
   909  		}
   910  		// A boolean type can only convert to another boolean type.
   911  		if allBoolean(x.typ()) != allBoolean(y.typ()) {
   912  			return false
   913  		}
   914  		// A string type can only convert to another string type.
   915  		if allString(x.typ()) != allString(y.typ()) {
   916  			return false
   917  		}
   918  		// Untyped nil can only convert to a type that has a nil.
   919  		if x.isNil() {
   920  			return hasNil(y.typ())
   921  		}
   922  		if y.isNil() {
   923  			return hasNil(x.typ())
   924  		}
   925  		// An untyped operand cannot convert to a pointer.
   926  		// TODO(gri) generalize to type parameters
   927  		if isPointer(x.typ()) || isPointer(y.typ()) {
   928  			return false
   929  		}
   930  		return true
   931  	}
   932  
   933  	if mayConvert(x, y) {
   934  		check.convertUntyped(x, y.typ())
   935  		if !x.isValid() {
   936  			return
   937  		}
   938  		check.convertUntyped(y, x.typ())
   939  		if !y.isValid() {
   940  			x.invalidate()
   941  			return
   942  		}
   943  	}
   944  }
   945  
   946  // exprKind describes the kind of an expression; the kind
   947  // determines if an expression is valid in 'statement context'.
   948  type exprKind int
   949  
   950  const (
   951  	conversion exprKind = iota
   952  	expression
   953  	statement
   954  )
   955  
   956  // target represent the (signature) type and description of the LHS
   957  // variable of an assignment, or of a function result variable.
   958  type target struct {
   959  	sig  *Signature
   960  	desc string
   961  }
   962  
   963  // newTarget creates a new target for the given type and description.
   964  // The result is nil if typ is not a signature.
   965  func newTarget(typ Type, desc string) *target {
   966  	if typ != nil {
   967  		if sig, _ := typ.Underlying().(*Signature); sig != nil {
   968  			return &target{sig, desc}
   969  		}
   970  	}
   971  	return nil
   972  }
   973  
   974  // rawExpr typechecks expression e and initializes x with the expression
   975  // value or type. If an error occurred, x.mode is set to invalid.
   976  // If a non-nil target T is given and e is a generic function,
   977  // T is used to infer the type arguments for e.
   978  // If hint != nil, it is the type of a composite literal element.
   979  // If allowGeneric is set, the operand type may be an uninstantiated
   980  // parameterized type or function value.
   981  func (check *Checker) rawExpr(T *target, x *operand, e syntax.Expr, hint Type, allowGeneric bool) exprKind {
   982  	if check.conf.Trace {
   983  		check.trace(e.Pos(), "-- expr %s", e)
   984  		check.indent++
   985  		defer func() {
   986  			check.indent--
   987  			check.trace(e.Pos(), "=> %s", x)
   988  		}()
   989  	}
   990  
   991  	kind := check.exprInternal(T, x, e, hint)
   992  
   993  	if !allowGeneric {
   994  		check.nonGeneric(T, x)
   995  	}
   996  
   997  	check.record(x)
   998  
   999  	return kind
  1000  }
  1001  
  1002  // If x is a generic type, or a generic function whose type arguments cannot be inferred
  1003  // from a non-nil target T, nonGeneric reports an error and invalidates x.mode and x.typ.
  1004  // Otherwise it leaves x alone.
  1005  func (check *Checker) nonGeneric(T *target, x *operand) {
  1006  	if !x.isValid() || x.mode() == novalue {
  1007  		return
  1008  	}
  1009  	var what string
  1010  	switch t := x.typ().(type) {
  1011  	case *Alias, *Named:
  1012  		if isGeneric(t) {
  1013  			what = "type"
  1014  		}
  1015  	case *Signature:
  1016  		if t.tparams != nil {
  1017  			if enableReverseTypeInference && T != nil {
  1018  				check.funcInst(T, x.Pos(), x, nil, true)
  1019  				return
  1020  			}
  1021  			what = "function"
  1022  		}
  1023  	}
  1024  	if what != "" {
  1025  		check.errorf(x.expr, WrongTypeArgCount, "cannot use generic %s %s without instantiation", what, x.expr)
  1026  		x.invalidate()
  1027  		x.typ_ = Typ[Invalid]
  1028  	}
  1029  }
  1030  
  1031  // exprInternal contains the core of type checking of expressions.
  1032  // Must only be called by rawExpr.
  1033  // (See rawExpr for an explanation of the parameters.)
  1034  func (check *Checker) exprInternal(T *target, x *operand, e syntax.Expr, hint Type) exprKind {
  1035  	// make sure x has a valid state in case of bailout
  1036  	// (was go.dev/issue/5770)
  1037  	x.invalidate()
  1038  	x.typ_ = Typ[Invalid]
  1039  
  1040  	switch e := e.(type) {
  1041  	case nil:
  1042  		panic("unreachable")
  1043  
  1044  	case *syntax.BadExpr:
  1045  		goto Error // error was reported before
  1046  
  1047  	case *syntax.Name:
  1048  		check.ident(x, e, false)
  1049  
  1050  	case *syntax.DotsType:
  1051  		// dots are handled explicitly where they are valid
  1052  		check.error(e, InvalidSyntaxTree, "invalid use of ...")
  1053  		goto Error
  1054  
  1055  	case *syntax.BasicLit:
  1056  		if e.Bad {
  1057  			goto Error // error reported during parsing
  1058  		}
  1059  		check.basicLit(x, e)
  1060  		if !x.isValid() {
  1061  			goto Error
  1062  		}
  1063  
  1064  	case *syntax.FuncLit:
  1065  		check.funcLit(x, e)
  1066  		if !x.isValid() {
  1067  			goto Error
  1068  		}
  1069  
  1070  	case *syntax.CompositeLit:
  1071  		check.compositeLit(x, e, hint)
  1072  		if !x.isValid() {
  1073  			goto Error
  1074  		}
  1075  
  1076  	case *syntax.ParenExpr:
  1077  		// type inference doesn't go past parentheses (target type T = nil)
  1078  		kind := check.rawExpr(nil, x, e.X, nil, false)
  1079  		x.expr = e
  1080  		return kind
  1081  
  1082  	case *syntax.SelectorExpr:
  1083  		check.selector(x, e, false)
  1084  
  1085  	case *syntax.IndexExpr:
  1086  		if check.indexExpr(x, e) {
  1087  			if !enableReverseTypeInference {
  1088  				T = nil
  1089  			}
  1090  			check.funcInst(T, e.Pos(), x, e, true)
  1091  		}
  1092  		if !x.isValid() {
  1093  			goto Error
  1094  		}
  1095  
  1096  	case *syntax.SliceExpr:
  1097  		check.sliceExpr(x, e)
  1098  		if !x.isValid() {
  1099  			goto Error
  1100  		}
  1101  
  1102  	case *syntax.AssertExpr:
  1103  		check.expr(nil, x, e.X)
  1104  		if !x.isValid() {
  1105  			goto Error
  1106  		}
  1107  		// x.(type) expressions are encoded via TypeSwitchGuards
  1108  		if e.Type == nil {
  1109  			check.error(e, InvalidSyntaxTree, "invalid use of AssertExpr")
  1110  			goto Error
  1111  		}
  1112  		if isTypeParam(x.typ()) {
  1113  			check.errorf(x, InvalidAssert, invalidOp+"cannot use type assertion on type parameter value %s", x)
  1114  			goto Error
  1115  		}
  1116  		if _, ok := x.typ().Underlying().(*Interface); !ok {
  1117  			check.errorf(x, InvalidAssert, invalidOp+"%s is not an interface", x)
  1118  			goto Error
  1119  		}
  1120  		T := check.varType(e.Type)
  1121  		if !isValid(T) {
  1122  			goto Error
  1123  		}
  1124  		// We cannot assert to an incomplete type; make sure it's complete.
  1125  		if !check.isComplete(T) {
  1126  			goto Error
  1127  		}
  1128  		check.typeAssertion(e, x, T, false)
  1129  		x.mode_ = commaok
  1130  		x.typ_ = T
  1131  
  1132  	case *syntax.TypeSwitchGuard:
  1133  		// x.(type) expressions are handled explicitly in type switches
  1134  		check.error(e, InvalidSyntaxTree, "use of .(type) outside type switch")
  1135  		check.use(e.X)
  1136  		goto Error
  1137  
  1138  	case *syntax.CallExpr:
  1139  		return check.callExpr(x, e)
  1140  
  1141  	case *syntax.ListExpr:
  1142  		// catch-all for unexpected expression lists
  1143  		check.error(e, InvalidSyntaxTree, "unexpected list of expressions")
  1144  		goto Error
  1145  
  1146  	// case *syntax.UnaryExpr:
  1147  	// 	check.expr(x, e.X)
  1148  	// 	if x.mode == invalid {
  1149  	// 		goto Error
  1150  	// 	}
  1151  	// 	check.unary(x, e, e.Op)
  1152  	// 	if x.mode == invalid {
  1153  	// 		goto Error
  1154  	// 	}
  1155  	// 	if e.Op == token.ARROW {
  1156  	// 		x.expr = e
  1157  	// 		return statement // receive operations may appear in statement context
  1158  	// 	}
  1159  
  1160  	// case *syntax.BinaryExpr:
  1161  	// 	check.binary(x, e, e.X, e.Y, e.Op)
  1162  	// 	if x.mode == invalid {
  1163  	// 		goto Error
  1164  	// 	}
  1165  
  1166  	case *syntax.Operation:
  1167  		if e.Y == nil {
  1168  			// unary expression
  1169  			if e.Op == syntax.Mul {
  1170  				// pointer indirection
  1171  				check.exprOrType(x, e.X, false)
  1172  				switch x.mode() {
  1173  				case invalid:
  1174  					goto Error
  1175  				case typexpr:
  1176  					check.validVarType(e.X, x.typ())
  1177  					x.typ_ = &Pointer{base: x.typ()}
  1178  				default:
  1179  					var base Type
  1180  					if !underIs(x.typ(), func(u Type) bool {
  1181  						p, _ := u.(*Pointer)
  1182  						if p == nil {
  1183  							check.errorf(x, InvalidIndirection, invalidOp+"cannot indirect %s", x)
  1184  							return false
  1185  						}
  1186  						if base != nil && !Identical(p.base, base) {
  1187  							check.errorf(x, InvalidIndirection, invalidOp+"pointers of %s must have identical base types", x)
  1188  							return false
  1189  						}
  1190  						base = p.base
  1191  						return true
  1192  					}) {
  1193  						goto Error
  1194  					}
  1195  					// We cannot dereference a pointer with an incomplete base type; make sure it's complete.
  1196  					if !check.isComplete(base) {
  1197  						goto Error
  1198  					}
  1199  					x.mode_ = variable
  1200  					x.typ_ = base
  1201  				}
  1202  				break
  1203  			}
  1204  
  1205  			check.unary(x, e)
  1206  			if !x.isValid() {
  1207  				goto Error
  1208  			}
  1209  			if e.Op == syntax.Recv {
  1210  				x.expr = e
  1211  				return statement // receive operations may appear in statement context
  1212  			}
  1213  			break
  1214  		}
  1215  
  1216  		// binary expression
  1217  		check.binary(x, e, e.X, e.Y, e.Op)
  1218  		if !x.isValid() {
  1219  			goto Error
  1220  		}
  1221  
  1222  	case *syntax.KeyValueExpr:
  1223  		// key:value expressions are handled in composite literals
  1224  		check.error(e, InvalidSyntaxTree, "no key:value expected")
  1225  		goto Error
  1226  
  1227  	case *syntax.ArrayType, *syntax.SliceType, *syntax.StructType, *syntax.FuncType,
  1228  		*syntax.InterfaceType, *syntax.MapType, *syntax.ChanType:
  1229  		x.mode_ = typexpr
  1230  		x.typ_ = check.typ(e)
  1231  		// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
  1232  		// even though check.typ has already called it. This is fine as both
  1233  		// times the same expression and type are recorded. It is also not a
  1234  		// performance issue because we only reach here for composite literal
  1235  		// types, which are comparatively rare.
  1236  
  1237  	default:
  1238  		panic(fmt.Sprintf("%s: unknown expression type %T", atPos(e), e))
  1239  	}
  1240  
  1241  	// everything went well
  1242  	x.expr = e
  1243  	return expression
  1244  
  1245  Error:
  1246  	x.invalidate()
  1247  	x.expr = e
  1248  	return statement // avoid follow-up errors
  1249  }
  1250  
  1251  // keyVal maps a complex, float, integer, string or boolean constant value
  1252  // to the corresponding complex128, float64, int64, uint64, string, or bool
  1253  // Go value if possible; otherwise it returns x.
  1254  // A complex constant that can be represented as a float (such as 1.2 + 0i)
  1255  // is returned as a floating point value; if a floating point value can be
  1256  // represented as an integer (such as 1.0) it is returned as an integer value.
  1257  // This ensures that constants of different kind but equal value (such as
  1258  // 1.0 + 0i, 1.0, 1) result in the same value.
  1259  func keyVal(x constant.Value) any {
  1260  	switch x.Kind() {
  1261  	case constant.Complex:
  1262  		f := constant.ToFloat(x)
  1263  		if f.Kind() != constant.Float {
  1264  			r, _ := constant.Float64Val(constant.Real(x))
  1265  			i, _ := constant.Float64Val(constant.Imag(x))
  1266  			return complex(r, i)
  1267  		}
  1268  		x = f
  1269  		fallthrough
  1270  	case constant.Float:
  1271  		i := constant.ToInt(x)
  1272  		if i.Kind() != constant.Int {
  1273  			v, _ := constant.Float64Val(x)
  1274  			return v
  1275  		}
  1276  		x = i
  1277  		fallthrough
  1278  	case constant.Int:
  1279  		if v, ok := constant.Int64Val(x); ok {
  1280  			return v
  1281  		}
  1282  		if v, ok := constant.Uint64Val(x); ok {
  1283  			return v
  1284  		}
  1285  	case constant.String:
  1286  		return constant.StringVal(x)
  1287  	case constant.Bool:
  1288  		return constant.BoolVal(x)
  1289  	}
  1290  	return x
  1291  }
  1292  
  1293  // typeAssertion checks x.(T). The type of x must be an interface.
  1294  func (check *Checker) typeAssertion(e syntax.Expr, x *operand, T Type, typeSwitch bool) {
  1295  	var cause string
  1296  	if check.assertableTo(x.typ(), T, &cause) {
  1297  		return // success
  1298  	}
  1299  
  1300  	if typeSwitch {
  1301  		check.errorf(e, ImpossibleAssert, "impossible type switch case: %s\n\t%s cannot have dynamic type %s %s", e, x, T, cause)
  1302  		return
  1303  	}
  1304  
  1305  	check.errorf(e, ImpossibleAssert, "impossible type assertion: %s\n\t%s does not implement %s %s", e, T, x.typ(), cause)
  1306  }
  1307  
  1308  // expr typechecks expression e and initializes x with the expression value.
  1309  // If a non-nil target T is given and e is a generic function or
  1310  // a function call, T is used to infer the type arguments for e.
  1311  // The result must be a single value.
  1312  // If an error occurred, x.mode is set to invalid.
  1313  func (check *Checker) expr(T *target, x *operand, e syntax.Expr) {
  1314  	check.rawExpr(T, x, e, nil, false)
  1315  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1316  	check.singleValue(x)
  1317  }
  1318  
  1319  // genericExpr is like expr but the result may also be generic.
  1320  func (check *Checker) genericExpr(x *operand, e syntax.Expr) {
  1321  	check.rawExpr(nil, x, e, nil, true)
  1322  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1323  	check.singleValue(x)
  1324  }
  1325  
  1326  // multiExpr typechecks e and returns its value (or values) in list.
  1327  // If allowCommaOk is set and e is a map index, comma-ok, or comma-err
  1328  // expression, the result is a two-element list containing the value
  1329  // of e, and an untyped bool value or an error value, respectively.
  1330  // If an error occurred, list[0] is not valid.
  1331  func (check *Checker) multiExpr(e syntax.Expr, allowCommaOk bool) (list []*operand, commaOk bool) {
  1332  	var x operand
  1333  	check.rawExpr(nil, &x, e, nil, false)
  1334  	check.exclude(&x, 1<<novalue|1<<builtin|1<<typexpr)
  1335  
  1336  	if t, ok := x.typ().(*Tuple); ok && x.isValid() {
  1337  		// multiple values
  1338  		list = make([]*operand, t.Len())
  1339  		for i, v := range t.vars {
  1340  			list[i] = &operand{mode_: value, expr: e, typ_: v.typ}
  1341  		}
  1342  		return
  1343  	}
  1344  
  1345  	// exactly one (possibly invalid or comma-ok) value
  1346  	list = []*operand{&x}
  1347  	if allowCommaOk && (x.mode() == mapindex || x.mode() == commaok || x.mode() == commaerr) {
  1348  		x2 := &operand{mode_: value, expr: e, typ_: Typ[UntypedBool]}
  1349  		if x.mode() == commaerr {
  1350  			x2.typ_ = universeError
  1351  		}
  1352  		list = append(list, x2)
  1353  		commaOk = true
  1354  	}
  1355  
  1356  	return
  1357  }
  1358  
  1359  // exprWithHint typechecks expression e and initializes x with the expression value;
  1360  // hint is the type of a composite literal element.
  1361  // If an error occurred, x.mode is set to invalid.
  1362  func (check *Checker) exprWithHint(x *operand, e syntax.Expr, hint Type) {
  1363  	assert(hint != nil)
  1364  	check.rawExpr(nil, x, e, hint, false)
  1365  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1366  	check.singleValue(x)
  1367  }
  1368  
  1369  // exprOrType typechecks expression or type e and initializes x with the expression value or type.
  1370  // If allowGeneric is set, the operand type may be an uninstantiated parameterized type or function
  1371  // value.
  1372  // If an error occurred, x.mode is set to invalid.
  1373  func (check *Checker) exprOrType(x *operand, e syntax.Expr, allowGeneric bool) {
  1374  	check.rawExpr(nil, x, e, nil, allowGeneric)
  1375  	check.exclude(x, 1<<novalue)
  1376  	check.singleValue(x)
  1377  }
  1378  
  1379  // exclude reports an error if x.mode is in modeset and sets x.mode to invalid.
  1380  // The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr.
  1381  func (check *Checker) exclude(x *operand, modeset uint) {
  1382  	if modeset&(1<<x.mode()) != 0 {
  1383  		var msg string
  1384  		var code Code
  1385  		switch x.mode() {
  1386  		case novalue:
  1387  			if modeset&(1<<typexpr) != 0 {
  1388  				msg = "%s used as value"
  1389  			} else {
  1390  				msg = "%s used as value or type"
  1391  			}
  1392  			code = TooManyValues
  1393  		case builtin:
  1394  			msg = "%s must be called"
  1395  			code = UncalledBuiltin
  1396  		case typexpr:
  1397  			msg = "%s is not an expression"
  1398  			code = NotAnExpr
  1399  		default:
  1400  			panic("unreachable")
  1401  		}
  1402  		check.errorf(x, code, msg, x)
  1403  		x.invalidate()
  1404  	}
  1405  }
  1406  
  1407  // singleValue reports an error if x describes a tuple and sets x.mode to invalid.
  1408  func (check *Checker) singleValue(x *operand) {
  1409  	if x.mode() == value {
  1410  		// tuple types are never named - no need for underlying type below
  1411  		if t, ok := x.typ().(*Tuple); ok {
  1412  			assert(t.Len() != 1)
  1413  			check.errorf(x, TooManyValues, "multiple-value %s in single-value context", x)
  1414  			x.invalidate()
  1415  		}
  1416  	}
  1417  }
  1418  
  1419  // op2tok translates syntax.Operators into token.Tokens.
  1420  var op2tok = [...]token.Token{
  1421  	syntax.Def:  token.ILLEGAL,
  1422  	syntax.Not:  token.NOT,
  1423  	syntax.Recv: token.ILLEGAL,
  1424  
  1425  	syntax.OrOr:   token.LOR,
  1426  	syntax.AndAnd: token.LAND,
  1427  
  1428  	syntax.Eql: token.EQL,
  1429  	syntax.Neq: token.NEQ,
  1430  	syntax.Lss: token.LSS,
  1431  	syntax.Leq: token.LEQ,
  1432  	syntax.Gtr: token.GTR,
  1433  	syntax.Geq: token.GEQ,
  1434  
  1435  	syntax.Add: token.ADD,
  1436  	syntax.Sub: token.SUB,
  1437  	syntax.Or:  token.OR,
  1438  	syntax.Xor: token.XOR,
  1439  
  1440  	syntax.Mul:    token.MUL,
  1441  	syntax.Div:    token.QUO,
  1442  	syntax.Rem:    token.REM,
  1443  	syntax.And:    token.AND,
  1444  	syntax.AndNot: token.AND_NOT,
  1445  	syntax.Shl:    token.SHL,
  1446  	syntax.Shr:    token.SHR,
  1447  }
  1448
View as plain text