Source file src/go/types/stmt.go

Documentation: go/types

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // This file implements typechecking of statements.
     6  
     7  package types
     8  
     9  import (
    10  	"go/ast"
    11  	"go/constant"
    12  	"go/token"
    13  	"sort"
    14  )
    15  
    16  func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt, iota constant.Value) {
    17  	if check.conf.IgnoreFuncBodies {
    18  		panic("internal error: function body not ignored")
    19  	}
    20  
    21  	if trace {
    22  		check.trace(body.Pos(), "--- %s: %s", name, sig)
    23  		defer func() {
    24  			check.trace(body.End(), "--- <end>")
    25  		}()
    26  	}
    27  
    28  	// set function scope extent
    29  	sig.scope.pos = body.Pos()
    30  	sig.scope.end = body.End()
    31  
    32  	// save/restore current context and setup function context
    33  	// (and use 0 indentation at function start)
    34  	defer func(ctxt context, indent int) {
    35  		check.context = ctxt
    36  		check.indent = indent
    37  	}(check.context, check.indent)
    38  	check.context = context{
    39  		decl:  decl,
    40  		scope: sig.scope,
    41  		iota:  iota,
    42  		sig:   sig,
    43  	}
    44  	check.indent = 0
    45  
    46  	check.stmtList(0, body.List)
    47  
    48  	if check.hasLabel {
    49  		check.labels(body)
    50  	}
    51  
    52  	if sig.results.Len() > 0 && !check.isTerminating(body, "") {
    53  		check.error(atPos(body.Rbrace), _MissingReturn, "missing return")
    54  	}
    55  
    56  	// TODO(gri) Should we make it an error to declare generic functions
    57  	//           where the type parameters are not used?
    58  	// 12/19/2018: Probably not - it can make sense to have an API with
    59  	//           all functions uniformly sharing the same type parameters.
    60  
    61  	// spec: "Implementation restriction: A compiler may make it illegal to
    62  	// declare a variable inside a function body if the variable is never used."
    63  	check.usage(sig.scope)
    64  }
    65  
    66  func (check *Checker) usage(scope *Scope) {
    67  	var unused []*Var
    68  	for _, elem := range scope.elems {
    69  		if v, _ := elem.(*Var); v != nil && !v.used {
    70  			unused = append(unused, v)
    71  		}
    72  	}
    73  	sort.Slice(unused, func(i, j int) bool {
    74  		return unused[i].pos < unused[j].pos
    75  	})
    76  	for _, v := range unused {
    77  		check.softErrorf(v, _UnusedVar, "%s declared but not used", v.name)
    78  	}
    79  
    80  	for _, scope := range scope.children {
    81  		// Don't go inside function literal scopes a second time;
    82  		// they are handled explicitly by funcBody.
    83  		if !scope.isFunc {
    84  			check.usage(scope)
    85  		}
    86  	}
    87  }
    88  
    89  // stmtContext is a bitset describing which
    90  // control-flow statements are permissible,
    91  // and provides additional context information
    92  // for better error messages.
    93  type stmtContext uint
    94  
    95  const (
    96  	// permissible control-flow statements
    97  	breakOk stmtContext = 1 << iota
    98  	continueOk
    99  	fallthroughOk
   100  
   101  	// additional context information
   102  	finalSwitchCase
   103  )
   104  
   105  func (check *Checker) simpleStmt(s ast.Stmt) {
   106  	if s != nil {
   107  		check.stmt(0, s)
   108  	}
   109  }
   110  
   111  func trimTrailingEmptyStmts(list []ast.Stmt) []ast.Stmt {
   112  	for i := len(list); i > 0; i-- {
   113  		if _, ok := list[i-1].(*ast.EmptyStmt); !ok {
   114  			return list[:i]
   115  		}
   116  	}
   117  	return nil
   118  }
   119  
   120  func (check *Checker) stmtList(ctxt stmtContext, list []ast.Stmt) {
   121  	ok := ctxt&fallthroughOk != 0
   122  	inner := ctxt &^ fallthroughOk
   123  	list = trimTrailingEmptyStmts(list) // trailing empty statements are "invisible" to fallthrough analysis
   124  	for i, s := range list {
   125  		inner := inner
   126  		if ok && i+1 == len(list) {
   127  			inner |= fallthroughOk
   128  		}
   129  		check.stmt(inner, s)
   130  	}
   131  }
   132  
   133  func (check *Checker) multipleDefaults(list []ast.Stmt) {
   134  	var first ast.Stmt
   135  	for _, s := range list {
   136  		var d ast.Stmt
   137  		switch c := s.(type) {
   138  		case *ast.CaseClause:
   139  			if len(c.List) == 0 {
   140  				d = s
   141  			}
   142  		case *ast.CommClause:
   143  			if c.Comm == nil {
   144  				d = s
   145  			}
   146  		default:
   147  			check.invalidAST(s, "case/communication clause expected")
   148  		}
   149  		if d != nil {
   150  			if first != nil {
   151  				check.errorf(d, _DuplicateDefault, "multiple defaults (first at %s)", check.fset.Position(first.Pos()))
   152  			} else {
   153  				first = d
   154  			}
   155  		}
   156  	}
   157  }
   158  
   159  func (check *Checker) openScope(node ast.Node, comment string) {
   160  	scope := NewScope(check.scope, node.Pos(), node.End(), comment)
   161  	check.recordScope(node, scope)
   162  	check.scope = scope
   163  }
   164  
   165  func (check *Checker) closeScope() {
   166  	check.scope = check.scope.Parent()
   167  }
   168  
   169  func assignOp(op token.Token) token.Token {
   170  	// token_test.go verifies the token ordering this function relies on
   171  	if token.ADD_ASSIGN <= op && op <= token.AND_NOT_ASSIGN {
   172  		return op + (token.ADD - token.ADD_ASSIGN)
   173  	}
   174  	return token.ILLEGAL
   175  }
   176  
   177  func (check *Checker) suspendedCall(keyword string, call *ast.CallExpr) {
   178  	var x operand
   179  	var msg string
   180  	var code errorCode
   181  	switch check.rawExpr(&x, call, nil) {
   182  	case conversion:
   183  		msg = "requires function call, not conversion"
   184  		code = _InvalidDefer
   185  		if keyword == "go" {
   186  			code = _InvalidGo
   187  		}
   188  	case expression:
   189  		msg = "discards result of"
   190  		code = _UnusedResults
   191  	case statement:
   192  		return
   193  	default:
   194  		unreachable()
   195  	}
   196  	check.errorf(&x, code, "%s %s %s", keyword, msg, &x)
   197  }
   198  
   199  // goVal returns the Go value for val, or nil.
   200  func goVal(val constant.Value) interface{} {
   201  	// val should exist, but be conservative and check
   202  	if val == nil {
   203  		return nil
   204  	}
   205  	// Match implementation restriction of other compilers.
   206  	// gc only checks duplicates for integer, floating-point
   207  	// and string values, so only create Go values for these
   208  	// types.
   209  	switch val.Kind() {
   210  	case constant.Int:
   211  		if x, ok := constant.Int64Val(val); ok {
   212  			return x
   213  		}
   214  		if x, ok := constant.Uint64Val(val); ok {
   215  			return x
   216  		}
   217  	case constant.Float:
   218  		if x, ok := constant.Float64Val(val); ok {
   219  			return x
   220  		}
   221  	case constant.String:
   222  		return constant.StringVal(val)
   223  	}
   224  	return nil
   225  }
   226  
   227  // A valueMap maps a case value (of a basic Go type) to a list of positions
   228  // where the same case value appeared, together with the corresponding case
   229  // types.
   230  // Since two case values may have the same "underlying" value but different
   231  // types we need to also check the value's types (e.g., byte(1) vs myByte(1))
   232  // when the switch expression is of interface type.
   233  type (
   234  	valueMap  map[interface{}][]valueType // underlying Go value -> valueType
   235  	valueType struct {
   236  		pos token.Pos
   237  		typ Type
   238  	}
   239  )
   240  
   241  func (check *Checker) caseValues(x *operand, values []ast.Expr, seen valueMap) {
   242  L:
   243  	for _, e := range values {
   244  		var v operand
   245  		check.expr(&v, e)
   246  		if x.mode == invalid || v.mode == invalid {
   247  			continue L
   248  		}
   249  		check.convertUntyped(&v, x.typ)
   250  		if v.mode == invalid {
   251  			continue L
   252  		}
   253  		// Order matters: By comparing v against x, error positions are at the case values.
   254  		res := v // keep original v unchanged
   255  		check.comparison(&res, x, token.EQL)
   256  		if res.mode == invalid {
   257  			continue L
   258  		}
   259  		if v.mode != constant_ {
   260  			continue L // we're done
   261  		}
   262  		// look for duplicate values
   263  		if val := goVal(v.val); val != nil {
   264  			// look for duplicate types for a given value
   265  			// (quadratic algorithm, but these lists tend to be very short)
   266  			for _, vt := range seen[val] {
   267  				if check.identical(v.typ, vt.typ) {
   268  					check.errorf(&v, _DuplicateCase, "duplicate case %s in expression switch", &v)
   269  					check.error(atPos(vt.pos), _DuplicateCase, "\tprevious case") // secondary error, \t indented
   270  					continue L
   271  				}
   272  			}
   273  			seen[val] = append(seen[val], valueType{v.Pos(), v.typ})
   274  		}
   275  	}
   276  }
   277  
   278  func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []ast.Expr, seen map[Type]ast.Expr) (T Type) {
   279  L:
   280  	for _, e := range types {
   281  		T = check.typeOrNil(e)
   282  		if T == Typ[Invalid] {
   283  			continue L
   284  		}
   285  		if T != nil {
   286  			check.ordinaryType(e, T)
   287  		}
   288  		// look for duplicate types
   289  		// (quadratic algorithm, but type switches tend to be reasonably small)
   290  		for t, other := range seen {
   291  			if T == nil && t == nil || T != nil && t != nil && check.identical(T, t) {
   292  				// talk about "case" rather than "type" because of nil case
   293  				Ts := "nil"
   294  				if T != nil {
   295  					Ts = T.String()
   296  				}
   297  				check.errorf(e, _DuplicateCase, "duplicate case %s in type switch", Ts)
   298  				check.error(other, _DuplicateCase, "\tprevious case") // secondary error, \t indented
   299  				continue L
   300  			}
   301  		}
   302  		seen[T] = e
   303  		if T != nil {
   304  			check.typeAssertion(e, x, xtyp, T)
   305  		}
   306  	}
   307  	return
   308  }
   309  
   310  // stmt typechecks statement s.
   311  func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
   312  	// statements must end with the same top scope as they started with
   313  	if debug {
   314  		defer func(scope *Scope) {
   315  			// don't check if code is panicking
   316  			if p := recover(); p != nil {
   317  				panic(p)
   318  			}
   319  			assert(scope == check.scope)
   320  		}(check.scope)
   321  	}
   322  
   323  	// process collected function literals before scope changes
   324  	defer check.processDelayed(len(check.delayed))
   325  
   326  	inner := ctxt &^ (fallthroughOk | finalSwitchCase)
   327  	switch s := s.(type) {
   328  	case *ast.BadStmt, *ast.EmptyStmt:
   329  		// ignore
   330  
   331  	case *ast.DeclStmt:
   332  		check.declStmt(s.Decl)
   333  
   334  	case *ast.LabeledStmt:
   335  		check.hasLabel = true
   336  		check.stmt(ctxt, s.Stmt)
   337  
   338  	case *ast.ExprStmt:
   339  		// spec: "With the exception of specific built-in functions,
   340  		// function and method calls and receive operations can appear
   341  		// in statement context. Such statements may be parenthesized."
   342  		var x operand
   343  		kind := check.rawExpr(&x, s.X, nil)
   344  		var msg string
   345  		var code errorCode
   346  		switch x.mode {
   347  		default:
   348  			if kind == statement {
   349  				return
   350  			}
   351  			msg = "is not used"
   352  			code = _UnusedExpr
   353  		case builtin:
   354  			msg = "must be called"
   355  			code = _UncalledBuiltin
   356  		case typexpr:
   357  			msg = "is not an expression"
   358  			code = _NotAnExpr
   359  		}
   360  		check.errorf(&x, code, "%s %s", &x, msg)
   361  
   362  	case *ast.SendStmt:
   363  		var ch, x operand
   364  		check.expr(&ch, s.Chan)
   365  		check.expr(&x, s.Value)
   366  		if ch.mode == invalid || x.mode == invalid {
   367  			return
   368  		}
   369  
   370  		tch := asChan(ch.typ)
   371  		if tch == nil {
   372  			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to non-chan type %s", ch.typ)
   373  			return
   374  		}
   375  
   376  		if tch.dir == RecvOnly {
   377  			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to receive-only type %s", tch)
   378  			return
   379  		}
   380  
   381  		check.assignment(&x, tch.elem, "send")
   382  
   383  	case *ast.IncDecStmt:
   384  		var op token.Token
   385  		switch s.Tok {
   386  		case token.INC:
   387  			op = token.ADD
   388  		case token.DEC:
   389  			op = token.SUB
   390  		default:
   391  			check.invalidAST(inNode(s, s.TokPos), "unknown inc/dec operation %s", s.Tok)
   392  			return
   393  		}
   394  
   395  		var x operand
   396  		check.expr(&x, s.X)
   397  		if x.mode == invalid {
   398  			return
   399  		}
   400  		if !isNumeric(x.typ) {
   401  			check.invalidOp(s.X, _NonNumericIncDec, "%s%s (non-numeric type %s)", s.X, s.Tok, x.typ)
   402  			return
   403  		}
   404  
   405  		Y := &ast.BasicLit{ValuePos: s.X.Pos(), Kind: token.INT, Value: "1"} // use x's position
   406  		check.binary(&x, nil, s.X, Y, op, s.TokPos)
   407  		if x.mode == invalid {
   408  			return
   409  		}
   410  		check.assignVar(s.X, &x)
   411  
   412  	case *ast.AssignStmt:
   413  		switch s.Tok {
   414  		case token.ASSIGN, token.DEFINE:
   415  			if len(s.Lhs) == 0 {
   416  				check.invalidAST(s, "missing lhs in assignment")
   417  				return
   418  			}
   419  			if s.Tok == token.DEFINE {
   420  				check.shortVarDecl(inNode(s, s.TokPos), s.Lhs, s.Rhs)
   421  			} else {
   422  				// regular assignment
   423  				check.assignVars(s.Lhs, s.Rhs)
   424  			}
   425  
   426  		default:
   427  			// assignment operations
   428  			if len(s.Lhs) != 1 || len(s.Rhs) != 1 {
   429  				check.errorf(inNode(s, s.TokPos), _MultiValAssignOp, "assignment operation %s requires single-valued expressions", s.Tok)
   430  				return
   431  			}
   432  			op := assignOp(s.Tok)
   433  			if op == token.ILLEGAL {
   434  				check.invalidAST(atPos(s.TokPos), "unknown assignment operation %s", s.Tok)
   435  				return
   436  			}
   437  			var x operand
   438  			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op, s.TokPos)
   439  			if x.mode == invalid {
   440  				return
   441  			}
   442  			check.assignVar(s.Lhs[0], &x)
   443  		}
   444  
   445  	case *ast.GoStmt:
   446  		check.suspendedCall("go", s.Call)
   447  
   448  	case *ast.DeferStmt:
   449  		check.suspendedCall("defer", s.Call)
   450  
   451  	case *ast.ReturnStmt:
   452  		res := check.sig.results
   453  		if res.Len() > 0 {
   454  			// function returns results
   455  			// (if one, say the first, result parameter is named, all of them are named)
   456  			if len(s.Results) == 0 && res.vars[0].name != "" {
   457  				// spec: "Implementation restriction: A compiler may disallow an empty expression
   458  				// list in a "return" statement if a different entity (constant, type, or variable)
   459  				// with the same name as a result parameter is in scope at the place of the return."
   460  				for _, obj := range res.vars {
   461  					if alt := check.lookup(obj.name); alt != nil && alt != obj {
   462  						check.errorf(s, _OutOfScopeResult, "result parameter %s not in scope at return", obj.name)
   463  						check.errorf(alt, _OutOfScopeResult, "\tinner declaration of %s", obj)
   464  						// ok to continue
   465  					}
   466  				}
   467  			} else {
   468  				// return has results or result parameters are unnamed
   469  				check.initVars(res.vars, s.Results, s.Return)
   470  			}
   471  		} else if len(s.Results) > 0 {
   472  			check.error(s.Results[0], _WrongResultCount, "no result values expected")
   473  			check.use(s.Results...)
   474  		}
   475  
   476  	case *ast.BranchStmt:
   477  		if s.Label != nil {
   478  			check.hasLabel = true
   479  			return // checked in 2nd pass (check.labels)
   480  		}
   481  		switch s.Tok {
   482  		case token.BREAK:
   483  			if ctxt&breakOk == 0 {
   484  				check.error(s, _MisplacedBreak, "break not in for, switch, or select statement")
   485  			}
   486  		case token.CONTINUE:
   487  			if ctxt&continueOk == 0 {
   488  				check.error(s, _MisplacedContinue, "continue not in for statement")
   489  			}
   490  		case token.FALLTHROUGH:
   491  			if ctxt&fallthroughOk == 0 {
   492  				msg := "fallthrough statement out of place"
   493  				code := _MisplacedFallthrough
   494  				if ctxt&finalSwitchCase != 0 {
   495  					msg = "cannot fallthrough final case in switch"
   496  				}
   497  				check.error(s, code, msg)
   498  			}
   499  		default:
   500  			check.invalidAST(s, "branch statement: %s", s.Tok)
   501  		}
   502  
   503  	case *ast.BlockStmt:
   504  		check.openScope(s, "block")
   505  		defer check.closeScope()
   506  
   507  		check.stmtList(inner, s.List)
   508  
   509  	case *ast.IfStmt:
   510  		check.openScope(s, "if")
   511  		defer check.closeScope()
   512  
   513  		check.simpleStmt(s.Init)
   514  		var x operand
   515  		check.expr(&x, s.Cond)
   516  		if x.mode != invalid && !isBoolean(x.typ) {
   517  			check.error(s.Cond, _InvalidCond, "non-boolean condition in if statement")
   518  		}
   519  		check.stmt(inner, s.Body)
   520  		// The parser produces a correct AST but if it was modified
   521  		// elsewhere the else branch may be invalid. Check again.
   522  		switch s.Else.(type) {
   523  		case nil, *ast.BadStmt:
   524  			// valid or error already reported
   525  		case *ast.IfStmt, *ast.BlockStmt:
   526  			check.stmt(inner, s.Else)
   527  		default:
   528  			check.invalidAST(s.Else, "invalid else branch in if statement")
   529  		}
   530  
   531  	case *ast.SwitchStmt:
   532  		inner |= breakOk
   533  		check.openScope(s, "switch")
   534  		defer check.closeScope()
   535  
   536  		check.simpleStmt(s.Init)
   537  		var x operand
   538  		if s.Tag != nil {
   539  			check.expr(&x, s.Tag)
   540  			// By checking assignment of x to an invisible temporary
   541  			// (as a compiler would), we get all the relevant checks.
   542  			check.assignment(&x, nil, "switch expression")
   543  			if x.mode != invalid && !Comparable(x.typ) && !hasNil(x.typ) {
   544  				check.errorf(&x, _InvalidExprSwitch, "cannot switch on %s (%s is not comparable)", &x, x.typ)
   545  				x.mode = invalid
   546  			}
   547  		} else {
   548  			// spec: "A missing switch expression is
   549  			// equivalent to the boolean value true."
   550  			x.mode = constant_
   551  			x.typ = Typ[Bool]
   552  			x.val = constant.MakeBool(true)
   553  			x.expr = &ast.Ident{NamePos: s.Body.Lbrace, Name: "true"}
   554  		}
   555  
   556  		check.multipleDefaults(s.Body.List)
   557  
   558  		seen := make(valueMap) // map of seen case values to positions and types
   559  		for i, c := range s.Body.List {
   560  			clause, _ := c.(*ast.CaseClause)
   561  			if clause == nil {
   562  				check.invalidAST(c, "incorrect expression switch case")
   563  				continue
   564  			}
   565  			check.caseValues(&x, clause.List, seen)
   566  			check.openScope(clause, "case")
   567  			inner := inner
   568  			if i+1 < len(s.Body.List) {
   569  				inner |= fallthroughOk
   570  			} else {
   571  				inner |= finalSwitchCase
   572  			}
   573  			check.stmtList(inner, clause.Body)
   574  			check.closeScope()
   575  		}
   576  
   577  	case *ast.TypeSwitchStmt:
   578  		inner |= breakOk
   579  		check.openScope(s, "type switch")
   580  		defer check.closeScope()
   581  
   582  		check.simpleStmt(s.Init)
   583  
   584  		// A type switch guard must be of the form:
   585  		//
   586  		//     TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
   587  		//
   588  		// The parser is checking syntactic correctness;
   589  		// remaining syntactic errors are considered AST errors here.
   590  		// TODO(gri) better factoring of error handling (invalid ASTs)
   591  		//
   592  		var lhs *ast.Ident // lhs identifier or nil
   593  		var rhs ast.Expr
   594  		switch guard := s.Assign.(type) {
   595  		case *ast.ExprStmt:
   596  			rhs = guard.X
   597  		case *ast.AssignStmt:
   598  			if len(guard.Lhs) != 1 || guard.Tok != token.DEFINE || len(guard.Rhs) != 1 {
   599  				check.invalidAST(s, "incorrect form of type switch guard")
   600  				return
   601  			}
   602  
   603  			lhs, _ = guard.Lhs[0].(*ast.Ident)
   604  			if lhs == nil {
   605  				check.invalidAST(s, "incorrect form of type switch guard")
   606  				return
   607  			}
   608  
   609  			if lhs.Name == "_" {
   610  				// _ := x.(type) is an invalid short variable declaration
   611  				check.softErrorf(lhs, _NoNewVar, "no new variable on left side of :=")
   612  				lhs = nil // avoid declared but not used error below
   613  			} else {
   614  				check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
   615  			}
   616  
   617  			rhs = guard.Rhs[0]
   618  
   619  		default:
   620  			check.invalidAST(s, "incorrect form of type switch guard")
   621  			return
   622  		}
   623  
   624  		// rhs must be of the form: expr.(type) and expr must be an ordinary interface
   625  		expr, _ := rhs.(*ast.TypeAssertExpr)
   626  		if expr == nil || expr.Type != nil {
   627  			check.invalidAST(s, "incorrect form of type switch guard")
   628  			return
   629  		}
   630  		var x operand
   631  		check.expr(&x, expr.X)
   632  		if x.mode == invalid {
   633  			return
   634  		}
   635  		xtyp, _ := under(x.typ).(*Interface)
   636  		if xtyp == nil {
   637  			check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x)
   638  			return
   639  		}
   640  		check.ordinaryType(&x, xtyp)
   641  
   642  		check.multipleDefaults(s.Body.List)
   643  
   644  		var lhsVars []*Var              // list of implicitly declared lhs variables
   645  		seen := make(map[Type]ast.Expr) // map of seen types to positions
   646  		for _, s := range s.Body.List {
   647  			clause, _ := s.(*ast.CaseClause)
   648  			if clause == nil {
   649  				check.invalidAST(s, "incorrect type switch case")
   650  				continue
   651  			}
   652  			// Check each type in this type switch case.
   653  			T := check.caseTypes(&x, xtyp, clause.List, seen)
   654  			check.openScope(clause, "case")
   655  			// If lhs exists, declare a corresponding variable in the case-local scope.
   656  			if lhs != nil {
   657  				// spec: "The TypeSwitchGuard may include a short variable declaration.
   658  				// When that form is used, the variable is declared at the beginning of
   659  				// the implicit block in each clause. In clauses with a case listing
   660  				// exactly one type, the variable has that type; otherwise, the variable
   661  				// has the type of the expression in the TypeSwitchGuard."
   662  				if len(clause.List) != 1 || T == nil {
   663  					T = x.typ
   664  				}
   665  				obj := NewVar(lhs.Pos(), check.pkg, lhs.Name, T)
   666  				scopePos := clause.Pos() + token.Pos(len("default")) // for default clause (len(List) == 0)
   667  				if n := len(clause.List); n > 0 {
   668  					scopePos = clause.List[n-1].End()
   669  				}
   670  				check.declare(check.scope, nil, obj, scopePos)
   671  				check.recordImplicit(clause, obj)
   672  				// For the "declared but not used" error, all lhs variables act as
   673  				// one; i.e., if any one of them is 'used', all of them are 'used'.
   674  				// Collect them for later analysis.
   675  				lhsVars = append(lhsVars, obj)
   676  			}
   677  			check.stmtList(inner, clause.Body)
   678  			check.closeScope()
   679  		}
   680  
   681  		// If lhs exists, we must have at least one lhs variable that was used.
   682  		if lhs != nil {
   683  			var used bool
   684  			for _, v := range lhsVars {
   685  				if v.used {
   686  					used = true
   687  				}
   688  				v.used = true // avoid usage error when checking entire function
   689  			}
   690  			if !used {
   691  				check.softErrorf(lhs, _UnusedVar, "%s declared but not used", lhs.Name)
   692  			}
   693  		}
   694  
   695  	case *ast.SelectStmt:
   696  		inner |= breakOk
   697  
   698  		check.multipleDefaults(s.Body.List)
   699  
   700  		for _, s := range s.Body.List {
   701  			clause, _ := s.(*ast.CommClause)
   702  			if clause == nil {
   703  				continue // error reported before
   704  			}
   705  
   706  			// clause.Comm must be a SendStmt, RecvStmt, or default case
   707  			valid := false
   708  			var rhs ast.Expr // rhs of RecvStmt, or nil
   709  			switch s := clause.Comm.(type) {
   710  			case nil, *ast.SendStmt:
   711  				valid = true
   712  			case *ast.AssignStmt:
   713  				if len(s.Rhs) == 1 {
   714  					rhs = s.Rhs[0]
   715  				}
   716  			case *ast.ExprStmt:
   717  				rhs = s.X
   718  			}
   719  
   720  			// if present, rhs must be a receive operation
   721  			if rhs != nil {
   722  				if x, _ := unparen(rhs).(*ast.UnaryExpr); x != nil && x.Op == token.ARROW {
   723  					valid = true
   724  				}
   725  			}
   726  
   727  			if !valid {
   728  				check.error(clause.Comm, _InvalidSelectCase, "select case must be send or receive (possibly with assignment)")
   729  				continue
   730  			}
   731  
   732  			check.openScope(s, "case")
   733  			if clause.Comm != nil {
   734  				check.stmt(inner, clause.Comm)
   735  			}
   736  			check.stmtList(inner, clause.Body)
   737  			check.closeScope()
   738  		}
   739  
   740  	case *ast.ForStmt:
   741  		inner |= breakOk | continueOk
   742  		check.openScope(s, "for")
   743  		defer check.closeScope()
   744  
   745  		check.simpleStmt(s.Init)
   746  		if s.Cond != nil {
   747  			var x operand
   748  			check.expr(&x, s.Cond)
   749  			if x.mode != invalid && !isBoolean(x.typ) {
   750  				check.error(s.Cond, _InvalidCond, "non-boolean condition in for statement")
   751  			}
   752  		}
   753  		check.simpleStmt(s.Post)
   754  		// spec: "The init statement may be a short variable
   755  		// declaration, but the post statement must not."
   756  		if s, _ := s.Post.(*ast.AssignStmt); s != nil && s.Tok == token.DEFINE {
   757  			check.softErrorf(s, _InvalidPostDecl, "cannot declare in post statement")
   758  			// Don't call useLHS here because we want to use the lhs in
   759  			// this erroneous statement so that we don't get errors about
   760  			// these lhs variables being declared but not used.
   761  			check.use(s.Lhs...) // avoid follow-up errors
   762  		}
   763  		check.stmt(inner, s.Body)
   764  
   765  	case *ast.RangeStmt:
   766  		inner |= breakOk | continueOk
   767  		check.openScope(s, "for")
   768  		defer check.closeScope()
   769  
   770  		// check expression to iterate over
   771  		var x operand
   772  		check.expr(&x, s.X)
   773  
   774  		// determine key/value types
   775  		var key, val Type
   776  		if x.mode != invalid {
   777  			typ := optype(x.typ)
   778  			if _, ok := typ.(*Chan); ok && s.Value != nil {
   779  				// TODO(gri) this also needs to happen for channels in generic variables
   780  				check.softErrorf(atPos(s.Value.Pos()), _InvalidIterVar, "range over %s permits only one iteration variable", &x)
   781  				// ok to continue
   782  			}
   783  			var msg string
   784  			key, val, msg = rangeKeyVal(typ, isVarName(s.Key), isVarName(s.Value))
   785  			if key == nil || msg != "" {
   786  				if msg != "" {
   787  					// TODO(rFindley) should this be parenthesized, to be consistent with other qualifiers?
   788  					msg = ": " + msg
   789  				}
   790  				check.softErrorf(&x, _InvalidRangeExpr, "cannot range over %s%s", &x, msg)
   791  				// ok to continue
   792  			}
   793  		}
   794  
   795  		// check assignment to/declaration of iteration variables
   796  		// (irregular assignment, cannot easily map to existing assignment checks)
   797  
   798  		// lhs expressions and initialization value (rhs) types
   799  		lhs := [2]ast.Expr{s.Key, s.Value}
   800  		rhs := [2]Type{key, val} // key, val may be nil
   801  
   802  		if s.Tok == token.DEFINE {
   803  			// short variable declaration; variable scope starts after the range clause
   804  			// (the for loop opens a new scope, so variables on the lhs never redeclare
   805  			// previously declared variables)
   806  			var vars []*Var
   807  			for i, lhs := range lhs {
   808  				if lhs == nil {
   809  					continue
   810  				}
   811  
   812  				// determine lhs variable
   813  				var obj *Var
   814  				if ident, _ := lhs.(*ast.Ident); ident != nil {
   815  					// declare new variable
   816  					name := ident.Name
   817  					obj = NewVar(ident.Pos(), check.pkg, name, nil)
   818  					check.recordDef(ident, obj)
   819  					// _ variables don't count as new variables
   820  					if name != "_" {
   821  						vars = append(vars, obj)
   822  					}
   823  				} else {
   824  					check.invalidAST(lhs, "cannot declare %s", lhs)
   825  					obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
   826  				}
   827  
   828  				// initialize lhs variable
   829  				if typ := rhs[i]; typ != nil {
   830  					x.mode = value
   831  					x.expr = lhs // we don't have a better rhs expression to use here
   832  					x.typ = typ
   833  					check.initVar(obj, &x, "range clause")
   834  				} else {
   835  					obj.typ = Typ[Invalid]
   836  					obj.used = true // don't complain about unused variable
   837  				}
   838  			}
   839  
   840  			// declare variables
   841  			if len(vars) > 0 {
   842  				scopePos := s.X.End()
   843  				for _, obj := range vars {
   844  					// spec: "The scope of a constant or variable identifier declared inside
   845  					// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
   846  					// for short variable declarations) and ends at the end of the innermost
   847  					// containing block."
   848  					check.declare(check.scope, nil /* recordDef already called */, obj, scopePos)
   849  				}
   850  			} else {
   851  				check.error(inNode(s, s.TokPos), _NoNewVar, "no new variables on left side of :=")
   852  			}
   853  		} else {
   854  			// ordinary assignment
   855  			for i, lhs := range lhs {
   856  				if lhs == nil {
   857  					continue
   858  				}
   859  				if typ := rhs[i]; typ != nil {
   860  					x.mode = value
   861  					x.expr = lhs // we don't have a better rhs expression to use here
   862  					x.typ = typ
   863  					check.assignVar(lhs, &x)
   864  				}
   865  			}
   866  		}
   867  
   868  		check.stmt(inner, s.Body)
   869  
   870  	default:
   871  		check.invalidAST(s, "invalid statement")
   872  	}
   873  }
   874  
   875  // isVarName reports whether x is a non-nil, non-blank (_) expression.
   876  func isVarName(x ast.Expr) bool {
   877  	if x == nil {
   878  		return false
   879  	}
   880  	ident, _ := unparen(x).(*ast.Ident)
   881  	return ident == nil || ident.Name != "_"
   882  }
   883  
   884  // rangeKeyVal returns the key and value type produced by a range clause
   885  // over an expression of type typ, and possibly an error message. If the
   886  // range clause is not permitted the returned key is nil or msg is not
   887  // empty (in that case we still may have a non-nil key type which can be
   888  // used to reduce the chance for follow-on errors).
   889  // The wantKey, wantVal, and hasVal flags indicate which of the iteration
   890  // variables are used or present; this matters if we range over a generic
   891  // type where not all keys or values are of the same type.
   892  func rangeKeyVal(typ Type, wantKey, wantVal bool) (Type, Type, string) {
   893  	switch typ := typ.(type) {
   894  	case *Basic:
   895  		if isString(typ) {
   896  			return Typ[Int], universeRune, "" // use 'rune' name
   897  		}
   898  	case *Array:
   899  		return Typ[Int], typ.elem, ""
   900  	case *Slice:
   901  		return Typ[Int], typ.elem, ""
   902  	case *Pointer:
   903  		if typ := asArray(typ.base); typ != nil {
   904  			return Typ[Int], typ.elem, ""
   905  		}
   906  	case *Map:
   907  		return typ.key, typ.elem, ""
   908  	case *Chan:
   909  		var msg string
   910  		if typ.dir == SendOnly {
   911  			msg = "send-only channel"
   912  		}
   913  		return typ.elem, Typ[Invalid], msg
   914  	case *_Sum:
   915  		first := true
   916  		var key, val Type
   917  		var msg string
   918  		typ.is(func(t Type) bool {
   919  			k, v, m := rangeKeyVal(under(t), wantKey, wantVal)
   920  			if k == nil || m != "" {
   921  				key, val, msg = k, v, m
   922  				return false
   923  			}
   924  			if first {
   925  				key, val, msg = k, v, m
   926  				first = false
   927  				return true
   928  			}
   929  			if wantKey && !Identical(key, k) {
   930  				key, val, msg = nil, nil, "all possible values must have the same key type"
   931  				return false
   932  			}
   933  			if wantVal && !Identical(val, v) {
   934  				key, val, msg = nil, nil, "all possible values must have the same element type"
   935  				return false
   936  			}
   937  			return true
   938  		})
   939  		return key, val, msg
   940  	}
   941  	return nil, nil, ""
   942  }
   943  

View as plain text