labels.go

Documentation: go/types

     1  // Copyright 2013 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  package types
     6  
     7  import (
     8  	"go/ast"
     9  	"go/token"
    10  )
    11  
    12  // labels checks correct label use in body.
    13  func (check *Checker) labels(body *ast.BlockStmt) {
    14  	// set of all labels in this body
    15  	all := NewScope(nil, body.Pos(), body.End(), "label")
    16  
    17  	fwdJumps := check.blockBranches(all, nil, nil, body.List)
    18  
    19  	// If there are any forward jumps left, no label was found for
    20  	// the corresponding goto statements. Either those labels were
    21  	// never defined, or they are inside blocks and not reachable
    22  	// for the respective gotos.
    23  	for _, jmp := range fwdJumps {
    24  		var msg string
    25  		var code errorCode
    26  		name := jmp.Label.Name
    27  		if alt := all.Lookup(name); alt != nil {
    28  			msg = "goto %s jumps into block"
    29  			alt.(*Label).used = true // avoid another error
    30  			code = _JumpIntoBlock
    31  		} else {
    32  			msg = "label %s not declared"
    33  			code = _UndeclaredLabel
    34  		}
    35  		check.errorf(jmp.Label, code, msg, name)
    36  	}
    37  
    38  	// spec: "It is illegal to define a label that is never used."
    39  	for _, obj := range all.elems {
    40  		if lbl := obj.(*Label); !lbl.used {
    41  			check.softErrorf(lbl, _UnusedLabel, "label %s declared but not used", lbl.name)
    42  		}
    43  	}
    44  }
    45  
    46  // A block tracks label declarations in a block and its enclosing blocks.
    47  type block struct {
    48  	parent *block                      // enclosing block
    49  	lstmt  *ast.LabeledStmt            // labeled statement to which this block belongs, or nil
    50  	labels map[string]*ast.LabeledStmt // allocated lazily
    51  }
    52  
    53  // insert records a new label declaration for the current block.
    54  // The label must not have been declared before in any block.
    55  func (b *block) insert(s *ast.LabeledStmt) {
    56  	name := s.Label.Name
    57  	if debug {
    58  		assert(b.gotoTarget(name) == nil)
    59  	}
    60  	labels := b.labels
    61  	if labels == nil {
    62  		labels = make(map[string]*ast.LabeledStmt)
    63  		b.labels = labels
    64  	}
    65  	labels[name] = s
    66  }
    67  
    68  // gotoTarget returns the labeled statement in the current
    69  // or an enclosing block with the given label name, or nil.
    70  func (b *block) gotoTarget(name string) *ast.LabeledStmt {
    71  	for s := b; s != nil; s = s.parent {
    72  		if t := s.labels[name]; t != nil {
    73  			return t
    74  		}
    75  	}
    76  	return nil
    77  }
    78  
    79  // enclosingTarget returns the innermost enclosing labeled
    80  // statement with the given label name, or nil.
    81  func (b *block) enclosingTarget(name string) *ast.LabeledStmt {
    82  	for s := b; s != nil; s = s.parent {
    83  		if t := s.lstmt; t != nil && t.Label.Name == name {
    84  			return t
    85  		}
    86  	}
    87  	return nil
    88  }
    89  
    90  // blockBranches processes a block's statement list and returns the set of outgoing forward jumps.
    91  // all is the scope of all declared labels, parent the set of labels declared in the immediately
    92  // enclosing block, and lstmt is the labeled statement this block is associated with (or nil).
    93  func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *ast.LabeledStmt, list []ast.Stmt) []*ast.BranchStmt {
    94  	b := &block{parent: parent, lstmt: lstmt}
    95  
    96  	var (
    97  		varDeclPos         token.Pos
    98  		fwdJumps, badJumps []*ast.BranchStmt
    99  	)
   100  
   101  	// All forward jumps jumping over a variable declaration are possibly
   102  	// invalid (they may still jump out of the block and be ok).
   103  	// recordVarDecl records them for the given position.
   104  	recordVarDecl := func(pos token.Pos) {
   105  		varDeclPos = pos
   106  		badJumps = append(badJumps[:0], fwdJumps...) // copy fwdJumps to badJumps
   107  	}
   108  
   109  	jumpsOverVarDecl := func(jmp *ast.BranchStmt) bool {
   110  		if varDeclPos.IsValid() {
   111  			for _, bad := range badJumps {
   112  				if jmp == bad {
   113  					return true
   114  				}
   115  			}
   116  		}
   117  		return false
   118  	}
   119  
   120  	blockBranches := func(lstmt *ast.LabeledStmt, list []ast.Stmt) {
   121  		// Unresolved forward jumps inside the nested block
   122  		// become forward jumps in the current block.
   123  		fwdJumps = append(fwdJumps, check.blockBranches(all, b, lstmt, list)...)
   124  	}
   125  
   126  	var stmtBranches func(ast.Stmt)
   127  	stmtBranches = func(s ast.Stmt) {
   128  		switch s := s.(type) {
   129  		case *ast.DeclStmt:
   130  			if d, _ := s.Decl.(*ast.GenDecl); d != nil && d.Tok == token.VAR {
   131  				recordVarDecl(d.Pos())
   132  			}
   133  
   134  		case *ast.LabeledStmt:
   135  			// declare non-blank label
   136  			if name := s.Label.Name; name != "_" {
   137  				lbl := NewLabel(s.Label.Pos(), check.pkg, name)
   138  				if alt := all.Insert(lbl); alt != nil {
   139  					check.softErrorf(lbl, _DuplicateLabel, "label %s already declared", name)
   140  					check.reportAltDecl(alt)
   141  					// ok to continue
   142  				} else {
   143  					b.insert(s)
   144  					check.recordDef(s.Label, lbl)
   145  				}
   146  				// resolve matching forward jumps and remove them from fwdJumps
   147  				i := 0
   148  				for _, jmp := range fwdJumps {
   149  					if jmp.Label.Name == name {
   150  						// match
   151  						lbl.used = true
   152  						check.recordUse(jmp.Label, lbl)
   153  						if jumpsOverVarDecl(jmp) {
   154  							check.softErrorf(
   155  								jmp.Label,
   156  								_JumpOverDecl,
   157  								"goto %s jumps over variable declaration at line %d",
   158  								name,
   159  								check.fset.Position(varDeclPos).Line,
   160  							)
   161  							// ok to continue
   162  						}
   163  					} else {
   164  						// no match - record new forward jump
   165  						fwdJumps[i] = jmp
   166  						i++
   167  					}
   168  				}
   169  				fwdJumps = fwdJumps[:i]
   170  				lstmt = s
   171  			}
   172  			stmtBranches(s.Stmt)
   173  
   174  		case *ast.BranchStmt:
   175  			if s.Label == nil {
   176  				return // checked in 1st pass (check.stmt)
   177  			}
   178  
   179  			// determine and validate target
   180  			name := s.Label.Name
   181  			switch s.Tok {
   182  			case token.BREAK:
   183  				// spec: "If there is a label, it must be that of an enclosing
   184  				// "for", "switch", or "select" statement, and that is the one
   185  				// whose execution terminates."
   186  				valid := false
   187  				if t := b.enclosingTarget(name); t != nil {
   188  					switch t.Stmt.(type) {
   189  					case *ast.SwitchStmt, *ast.TypeSwitchStmt, *ast.SelectStmt, *ast.ForStmt, *ast.RangeStmt:
   190  						valid = true
   191  					}
   192  				}
   193  				if !valid {
   194  					check.errorf(s.Label, _MisplacedLabel, "invalid break label %s", name)
   195  					return
   196  				}
   197  
   198  			case token.CONTINUE:
   199  				// spec: "If there is a label, it must be that of an enclosing
   200  				// "for" statement, and that is the one whose execution advances."
   201  				valid := false
   202  				if t := b.enclosingTarget(name); t != nil {
   203  					switch t.Stmt.(type) {
   204  					case *ast.ForStmt, *ast.RangeStmt:
   205  						valid = true
   206  					}
   207  				}
   208  				if !valid {
   209  					check.errorf(s.Label, _MisplacedLabel, "invalid continue label %s", name)
   210  					return
   211  				}
   212  
   213  			case token.GOTO:
   214  				if b.gotoTarget(name) == nil {
   215  					// label may be declared later - add branch to forward jumps
   216  					fwdJumps = append(fwdJumps, s)
   217  					return
   218  				}
   219  
   220  			default:
   221  				check.invalidAST(s, "branch statement: %s %s", s.Tok, name)
   222  				return
   223  			}
   224  
   225  			// record label use
   226  			obj := all.Lookup(name)
   227  			obj.(*Label).used = true
   228  			check.recordUse(s.Label, obj)
   229  
   230  		case *ast.AssignStmt:
   231  			if s.Tok == token.DEFINE {
   232  				recordVarDecl(s.Pos())
   233  			}
   234  
   235  		case *ast.BlockStmt:
   236  			blockBranches(lstmt, s.List)
   237  
   238  		case *ast.IfStmt:
   239  			stmtBranches(s.Body)
   240  			if s.Else != nil {
   241  				stmtBranches(s.Else)
   242  			}
   243  
   244  		case *ast.CaseClause:
   245  			blockBranches(nil, s.Body)
   246  
   247  		case *ast.SwitchStmt:
   248  			stmtBranches(s.Body)
   249  
   250  		case *ast.TypeSwitchStmt:
   251  			stmtBranches(s.Body)
   252  
   253  		case *ast.CommClause:
   254  			blockBranches(nil, s.Body)
   255  
   256  		case *ast.SelectStmt:
   257  			stmtBranches(s.Body)
   258  
   259  		case *ast.ForStmt:
   260  			stmtBranches(s.Body)
   261  
   262  		case *ast.RangeStmt:
   263  			stmtBranches(s.Body)
   264  		}
   265  	}
   266  
   267  	for _, s := range list {
   268  		stmtBranches(s)
   269  	}
   270  
   271  	return fwdJumps
   272  }
   273
View as plain text