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