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

View as plain text