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 u, _ := commonUnder(typ, nil); u != nil {
   968  			if sig, _ := u.(*Signature); sig != nil {
   969  				return &target{sig, desc}
   970  			}
   971  		}
   972  	}
   973  	return nil
   974  }
   975  
   976  // rawExpr typechecks expression e and initializes x with the expression
   977  // value or type. If an error occurred, x.mode is set to invalid.
   978  // If a non-nil target T is given and e is a generic function,
   979  // T is used to infer the type arguments for e.
   980  // If hint != nil, it is the type of a composite literal element.
   981  // If allowGeneric is set, the operand type may be an uninstantiated
   982  // parameterized type or function value.
   983  func (check *Checker) rawExpr(T *target, x *operand, e syntax.Expr, hint Type, allowGeneric bool) exprKind {
   984  	if check.conf.Trace {
   985  		check.trace(e.Pos(), "-- expr %s", e)
   986  		check.indent++
   987  		defer func() {
   988  			check.indent--
   989  			check.trace(e.Pos(), "=> %s", x)
   990  		}()
   991  	}
   992  
   993  	kind := check.exprInternal(T, x, e, hint)
   994  
   995  	if !allowGeneric {
   996  		check.nonGeneric(T, x)
   997  	}
   998  
   999  	check.record(x)
  1000  
  1001  	return kind
  1002  }
  1003  
  1004  // If x is a generic type, or a generic function whose type arguments cannot be inferred
  1005  // from a non-nil target T, nonGeneric reports an error and invalidates x.mode and x.typ.
  1006  // Otherwise it leaves x alone.
  1007  func (check *Checker) nonGeneric(T *target, x *operand) {
  1008  	if !x.isValid() || x.mode() == novalue {
  1009  		return
  1010  	}
  1011  	var what string
  1012  	switch t := x.typ().(type) {
  1013  	case *Alias, *Named:
  1014  		if isGeneric(t) {
  1015  			what = "type"
  1016  		}
  1017  	case *Signature:
  1018  		if t.tparams != nil {
  1019  			if enableReverseTypeInference && T != nil {
  1020  				check.funcInst(T, x.Pos(), x, nil, true)
  1021  				return
  1022  			}
  1023  			what = "function"
  1024  		}
  1025  	}
  1026  	if what != "" {
  1027  		check.errorf(x.expr, WrongTypeArgCount, "cannot use generic %s %s without instantiation", what, x.expr)
  1028  		x.invalidate()
  1029  		x.typ_ = Typ[Invalid]
  1030  	}
  1031  }
  1032  
  1033  // exprInternal contains the core of type checking of expressions.
  1034  // Must only be called by rawExpr.
  1035  // (See rawExpr for an explanation of the parameters.)
  1036  func (check *Checker) exprInternal(T *target, x *operand, e syntax.Expr, hint Type) exprKind {
  1037  	// make sure x has a valid state in case of bailout
  1038  	// (was go.dev/issue/5770)
  1039  	x.invalidate()
  1040  	x.typ_ = Typ[Invalid]
  1041  
  1042  	switch e := e.(type) {
  1043  	case nil:
  1044  		panic("unreachable")
  1045  
  1046  	case *syntax.BadExpr:
  1047  		goto Error // error was reported before
  1048  
  1049  	case *syntax.Name:
  1050  		check.ident(x, e, false)
  1051  
  1052  	case *syntax.DotsType:
  1053  		// dots are handled explicitly where they are valid
  1054  		check.error(e, InvalidSyntaxTree, "invalid use of ...")
  1055  		goto Error
  1056  
  1057  	case *syntax.BasicLit:
  1058  		if e.Bad {
  1059  			goto Error // error reported during parsing
  1060  		}
  1061  		check.basicLit(x, e)
  1062  		if !x.isValid() {
  1063  			goto Error
  1064  		}
  1065  
  1066  	case *syntax.FuncLit:
  1067  		check.funcLit(x, e)
  1068  		if !x.isValid() {
  1069  			goto Error
  1070  		}
  1071  
  1072  	case *syntax.CompositeLit:
  1073  		check.compositeLit(x, e, hint)
  1074  		if !x.isValid() {
  1075  			goto Error
  1076  		}
  1077  
  1078  	case *syntax.ParenExpr:
  1079  		// type inference doesn't go past parentheses (target type T = nil)
  1080  		kind := check.rawExpr(nil, x, e.X, nil, false)
  1081  		x.expr = e
  1082  		return kind
  1083  
  1084  	case *syntax.SelectorExpr:
  1085  		check.selector(x, e, false)
  1086  
  1087  	case *syntax.IndexExpr:
  1088  		if check.indexExpr(x, e) {
  1089  			if !enableReverseTypeInference {
  1090  				T = nil
  1091  			}
  1092  			check.funcInst(T, e.Pos(), x, e, true)
  1093  		}
  1094  		if !x.isValid() {
  1095  			goto Error
  1096  		}
  1097  
  1098  	case *syntax.SliceExpr:
  1099  		check.sliceExpr(x, e)
  1100  		if !x.isValid() {
  1101  			goto Error
  1102  		}
  1103  
  1104  	case *syntax.AssertExpr:
  1105  		check.expr(nil, x, e.X)
  1106  		if !x.isValid() {
  1107  			goto Error
  1108  		}
  1109  		// x.(type) expressions are encoded via TypeSwitchGuards
  1110  		if e.Type == nil {
  1111  			check.error(e, InvalidSyntaxTree, "invalid use of AssertExpr")
  1112  			goto Error
  1113  		}
  1114  		if isTypeParam(x.typ()) {
  1115  			check.errorf(x, InvalidAssert, invalidOp+"cannot use type assertion on type parameter value %s", x)
  1116  			goto Error
  1117  		}
  1118  		if _, ok := x.typ().Underlying().(*Interface); !ok {
  1119  			check.errorf(x, InvalidAssert, invalidOp+"%s is not an interface", x)
  1120  			goto Error
  1121  		}
  1122  		T := check.varType(e.Type)
  1123  		if !isValid(T) {
  1124  			goto Error
  1125  		}
  1126  		// We cannot assert to an incomplete type; make sure it's complete.
  1127  		if !check.isComplete(T) {
  1128  			goto Error
  1129  		}
  1130  		check.typeAssertion(e, x, T, false)
  1131  		x.mode_ = commaok
  1132  		x.typ_ = T
  1133  
  1134  	case *syntax.TypeSwitchGuard:
  1135  		// x.(type) expressions are handled explicitly in type switches
  1136  		check.error(e, InvalidSyntaxTree, "use of .(type) outside type switch")
  1137  		check.use(e.X)
  1138  		goto Error
  1139  
  1140  	case *syntax.CallExpr:
  1141  		return check.callExpr(x, e)
  1142  
  1143  	case *syntax.ListExpr:
  1144  		// catch-all for unexpected expression lists
  1145  		check.error(e, InvalidSyntaxTree, "unexpected list of expressions")
  1146  		goto Error
  1147  
  1148  	// case *syntax.UnaryExpr:
  1149  	// 	check.expr(x, e.X)
  1150  	// 	if x.mode == invalid {
  1151  	// 		goto Error
  1152  	// 	}
  1153  	// 	check.unary(x, e, e.Op)
  1154  	// 	if x.mode == invalid {
  1155  	// 		goto Error
  1156  	// 	}
  1157  	// 	if e.Op == token.ARROW {
  1158  	// 		x.expr = e
  1159  	// 		return statement // receive operations may appear in statement context
  1160  	// 	}
  1161  
  1162  	// case *syntax.BinaryExpr:
  1163  	// 	check.binary(x, e, e.X, e.Y, e.Op)
  1164  	// 	if x.mode == invalid {
  1165  	// 		goto Error
  1166  	// 	}
  1167  
  1168  	case *syntax.Operation:
  1169  		if e.Y == nil {
  1170  			// unary expression
  1171  			if e.Op == syntax.Mul {
  1172  				// pointer indirection
  1173  				check.exprOrType(x, e.X, false)
  1174  				switch x.mode() {
  1175  				case invalid:
  1176  					goto Error
  1177  				case typexpr:
  1178  					check.validVarType(e.X, x.typ())
  1179  					x.typ_ = &Pointer{base: x.typ()}
  1180  				default:
  1181  					var base Type
  1182  					if !underIs(x.typ(), func(u Type) bool {
  1183  						p, _ := u.(*Pointer)
  1184  						if p == nil {
  1185  							check.errorf(x, InvalidIndirection, invalidOp+"cannot indirect %s", x)
  1186  							return false
  1187  						}
  1188  						if base != nil && !Identical(p.base, base) {
  1189  							check.errorf(x, InvalidIndirection, invalidOp+"pointers of %s must have identical base types", x)
  1190  							return false
  1191  						}
  1192  						base = p.base
  1193  						return true
  1194  					}) {
  1195  						goto Error
  1196  					}
  1197  					// We cannot dereference a pointer with an incomplete base type; make sure it's complete.
  1198  					if !check.isComplete(base) {
  1199  						goto Error
  1200  					}
  1201  					x.mode_ = variable
  1202  					x.typ_ = base
  1203  				}
  1204  				break
  1205  			}
  1206  
  1207  			check.unary(x, e)
  1208  			if !x.isValid() {
  1209  				goto Error
  1210  			}
  1211  			if e.Op == syntax.Recv {
  1212  				x.expr = e
  1213  				return statement // receive operations may appear in statement context
  1214  			}
  1215  			break
  1216  		}
  1217  
  1218  		// binary expression
  1219  		check.binary(x, e, e.X, e.Y, e.Op)
  1220  		if !x.isValid() {
  1221  			goto Error
  1222  		}
  1223  
  1224  	case *syntax.KeyValueExpr:
  1225  		// key:value expressions are handled in composite literals
  1226  		check.error(e, InvalidSyntaxTree, "no key:value expected")
  1227  		goto Error
  1228  
  1229  	case *syntax.ArrayType, *syntax.SliceType, *syntax.StructType, *syntax.FuncType,
  1230  		*syntax.InterfaceType, *syntax.MapType, *syntax.ChanType:
  1231  		x.mode_ = typexpr
  1232  		x.typ_ = check.typ(e)
  1233  		// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
  1234  		// even though check.typ has already called it. This is fine as both
  1235  		// times the same expression and type are recorded. It is also not a
  1236  		// performance issue because we only reach here for composite literal
  1237  		// types, which are comparatively rare.
  1238  
  1239  	default:
  1240  		panic(fmt.Sprintf("%s: unknown expression type %T", atPos(e), e))
  1241  	}
  1242  
  1243  	// everything went well
  1244  	x.expr = e
  1245  	return expression
  1246  
  1247  Error:
  1248  	x.invalidate()
  1249  	x.expr = e
  1250  	return statement // avoid follow-up errors
  1251  }
  1252  
  1253  // keyVal maps a complex, float, integer, string or boolean constant value
  1254  // to the corresponding complex128, float64, int64, uint64, string, or bool
  1255  // Go value if possible; otherwise it returns x.
  1256  // A complex constant that can be represented as a float (such as 1.2 + 0i)
  1257  // is returned as a floating point value; if a floating point value can be
  1258  // represented as an integer (such as 1.0) it is returned as an integer value.
  1259  // This ensures that constants of different kind but equal value (such as
  1260  // 1.0 + 0i, 1.0, 1) result in the same value.
  1261  func keyVal(x constant.Value) any {
  1262  	switch x.Kind() {
  1263  	case constant.Complex:
  1264  		f := constant.ToFloat(x)
  1265  		if f.Kind() != constant.Float {
  1266  			r, _ := constant.Float64Val(constant.Real(x))
  1267  			i, _ := constant.Float64Val(constant.Imag(x))
  1268  			return complex(r, i)
  1269  		}
  1270  		x = f
  1271  		fallthrough
  1272  	case constant.Float:
  1273  		i := constant.ToInt(x)
  1274  		if i.Kind() != constant.Int {
  1275  			v, _ := constant.Float64Val(x)
  1276  			return v
  1277  		}
  1278  		x = i
  1279  		fallthrough
  1280  	case constant.Int:
  1281  		if v, ok := constant.Int64Val(x); ok {
  1282  			return v
  1283  		}
  1284  		if v, ok := constant.Uint64Val(x); ok {
  1285  			return v
  1286  		}
  1287  	case constant.String:
  1288  		return constant.StringVal(x)
  1289  	case constant.Bool:
  1290  		return constant.BoolVal(x)
  1291  	}
  1292  	return x
  1293  }
  1294  
  1295  // typeAssertion checks x.(T). The type of x must be an interface.
  1296  func (check *Checker) typeAssertion(e syntax.Expr, x *operand, T Type, typeSwitch bool) {
  1297  	var cause string
  1298  	if check.assertableTo(x.typ(), T, &cause) {
  1299  		return // success
  1300  	}
  1301  
  1302  	if typeSwitch {
  1303  		check.errorf(e, ImpossibleAssert, "impossible type switch case: %s\n\t%s cannot have dynamic type %s %s", e, x, T, cause)
  1304  		return
  1305  	}
  1306  
  1307  	check.errorf(e, ImpossibleAssert, "impossible type assertion: %s\n\t%s does not implement %s %s", e, T, x.typ(), cause)
  1308  }
  1309  
  1310  // expr typechecks expression e and initializes x with the expression value.
  1311  // If a non-nil target T is given and e is a generic function or
  1312  // a function call, T is used to infer the type arguments for e.
  1313  // The result must be a single value.
  1314  // If an error occurred, x.mode is set to invalid.
  1315  func (check *Checker) expr(T *target, x *operand, e syntax.Expr) {
  1316  	check.rawExpr(T, x, e, nil, false)
  1317  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1318  	check.singleValue(x)
  1319  }
  1320  
  1321  // genericExpr is like expr but the result may also be generic.
  1322  func (check *Checker) genericExpr(x *operand, e syntax.Expr, hint Type) {
  1323  	check.rawExpr(nil, x, e, hint, true)
  1324  	check.exclude(x, 1<<novalue|1<<builtin|1<<typexpr)
  1325  	check.singleValue(x)
  1326  }
  1327  
  1328  // multiExpr typechecks e and returns its value (or values) in list.
  1329  // If allowCommaOk is set and e is a map index, comma-ok, or comma-err
  1330  // expression, the result is a two-element list containing the value
  1331  // of e, and an untyped bool value or an error value, respectively.
  1332  // If an error occurred, list[0] is not valid.
  1333  func (check *Checker) multiExpr(e syntax.Expr, allowCommaOk bool) (list []*operand, commaOk bool) {
  1334  	var x operand
  1335  	check.rawExpr(nil, &x, e, nil, false)
  1336  	check.exclude(&x, 1<<novalue|1<<builtin|1<<typexpr)
  1337  
  1338  	if t, ok := x.typ().(*Tuple); ok && x.isValid() {
  1339  		// multiple values
  1340  		list = make([]*operand, t.Len())
  1341  		for i, v := range t.vars {
  1342  			list[i] = &operand{mode_: value, expr: e, typ_: v.typ}
  1343  		}
  1344  		return
  1345  	}
  1346  
  1347  	// exactly one (possibly invalid or comma-ok) value
  1348  	list = []*operand{&x}
  1349  	if allowCommaOk && (x.mode() == mapindex || x.mode() == commaok || x.mode() == commaerr) {
  1350  		x2 := &operand{mode_: value, expr: e, typ_: Typ[UntypedBool]}
  1351  		if x.mode() == commaerr {
  1352  			x2.typ_ = universeError
  1353  		}
  1354  		list = append(list, x2)
  1355  		commaOk = true
  1356  	}
  1357  
  1358  	return
  1359  }
  1360  
  1361  // exprOrType typechecks expression or type e and initializes x with the expression value or type.
  1362  // If allowGeneric is set, the operand type may be an uninstantiated parameterized type or function
  1363  // value.
  1364  // If an error occurred, x.mode is set to invalid.
  1365  func (check *Checker) exprOrType(x *operand, e syntax.Expr, allowGeneric bool) {
  1366  	check.rawExpr(nil, x, e, nil, allowGeneric)
  1367  	check.exclude(x, 1<<novalue)
  1368  	check.singleValue(x)
  1369  }
  1370  
  1371  // exclude reports an error if x.mode is in modeset and sets x.mode to invalid.
  1372  // The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr.
  1373  func (check *Checker) exclude(x *operand, modeset uint) {
  1374  	if modeset&(1<<x.mode()) != 0 {
  1375  		var msg string
  1376  		var code Code
  1377  		switch x.mode() {
  1378  		case novalue:
  1379  			if modeset&(1<<typexpr) != 0 {
  1380  				msg = "%s used as value"
  1381  			} else {
  1382  				msg = "%s used as value or type"
  1383  			}
  1384  			code = TooManyValues
  1385  		case builtin:
  1386  			msg = "%s must be called"
  1387  			code = UncalledBuiltin
  1388  		case typexpr:
  1389  			msg = "%s is not an expression"
  1390  			code = NotAnExpr
  1391  		default:
  1392  			panic("unreachable")
  1393  		}
  1394  		check.errorf(x, code, msg, x)
  1395  		x.invalidate()
  1396  	}
  1397  }
  1398  
  1399  // singleValue reports an error if x describes a tuple and sets x.mode to invalid.
  1400  func (check *Checker) singleValue(x *operand) {
  1401  	if x.mode() == value {
  1402  		// tuple types are never named - no need for underlying type below
  1403  		if t, ok := x.typ().(*Tuple); ok {
  1404  			assert(t.Len() != 1)
  1405  			check.errorf(x, TooManyValues, "multiple-value %s in single-value context", x)
  1406  			x.invalidate()
  1407  		}
  1408  	}
  1409  }
  1410  
  1411  // op2tok translates syntax.Operators into token.Tokens.
  1412  var op2tok = [...]token.Token{
  1413  	syntax.Def:  token.ILLEGAL,
  1414  	syntax.Not:  token.NOT,
  1415  	syntax.Recv: token.ILLEGAL,
  1416  
  1417  	syntax.OrOr:   token.LOR,
  1418  	syntax.AndAnd: token.LAND,
  1419  
  1420  	syntax.Eql: token.EQL,
  1421  	syntax.Neq: token.NEQ,
  1422  	syntax.Lss: token.LSS,
  1423  	syntax.Leq: token.LEQ,
  1424  	syntax.Gtr: token.GTR,
  1425  	syntax.Geq: token.GEQ,
  1426  
  1427  	syntax.Add: token.ADD,
  1428  	syntax.Sub: token.SUB,
  1429  	syntax.Or:  token.OR,
  1430  	syntax.Xor: token.XOR,
  1431  
  1432  	syntax.Mul:    token.MUL,
  1433  	syntax.Div:    token.QUO,
  1434  	syntax.Rem:    token.REM,
  1435  	syntax.And:    token.AND,
  1436  	syntax.AndNot: token.AND_NOT,
  1437  	syntax.Shl:    token.SHL,
  1438  	syntax.Shr:    token.SHR,
  1439  }
  1440
View as plain text