...
Run Format

Source file src/cmd/vet/copylock.go

Documentation: cmd/vet

     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  // This file contains the code to check that locks are not passed by value.
     6  
     7  package main
     8  
     9  import (
    10  	"bytes"
    11  	"fmt"
    12  	"go/ast"
    13  	"go/token"
    14  	"go/types"
    15  )
    16  
    17  func init() {
    18  	register("copylocks",
    19  		"check that locks are not passed by value",
    20  		checkCopyLocks,
    21  		funcDecl, rangeStmt, funcLit, callExpr, assignStmt, genDecl, compositeLit, returnStmt)
    22  }
    23  
    24  // checkCopyLocks checks whether node might
    25  // inadvertently copy a lock.
    26  func checkCopyLocks(f *File, node ast.Node) {
    27  	switch node := node.(type) {
    28  	case *ast.RangeStmt:
    29  		checkCopyLocksRange(f, node)
    30  	case *ast.FuncDecl:
    31  		checkCopyLocksFunc(f, node.Name.Name, node.Recv, node.Type)
    32  	case *ast.FuncLit:
    33  		checkCopyLocksFunc(f, "func", nil, node.Type)
    34  	case *ast.CallExpr:
    35  		checkCopyLocksCallExpr(f, node)
    36  	case *ast.AssignStmt:
    37  		checkCopyLocksAssign(f, node)
    38  	case *ast.GenDecl:
    39  		checkCopyLocksGenDecl(f, node)
    40  	case *ast.CompositeLit:
    41  		checkCopyLocksCompositeLit(f, node)
    42  	case *ast.ReturnStmt:
    43  		checkCopyLocksReturnStmt(f, node)
    44  	}
    45  }
    46  
    47  // checkCopyLocksAssign checks whether an assignment
    48  // copies a lock.
    49  func checkCopyLocksAssign(f *File, as *ast.AssignStmt) {
    50  	for i, x := range as.Rhs {
    51  		if path := lockPathRhs(f, x); path != nil {
    52  			f.Badf(x.Pos(), "assignment copies lock value to %v: %v", f.gofmt(as.Lhs[i]), path)
    53  		}
    54  	}
    55  }
    56  
    57  // checkCopyLocksGenDecl checks whether lock is copied
    58  // in variable declaration.
    59  func checkCopyLocksGenDecl(f *File, gd *ast.GenDecl) {
    60  	if gd.Tok != token.VAR {
    61  		return
    62  	}
    63  	for _, spec := range gd.Specs {
    64  		valueSpec := spec.(*ast.ValueSpec)
    65  		for i, x := range valueSpec.Values {
    66  			if path := lockPathRhs(f, x); path != nil {
    67  				f.Badf(x.Pos(), "variable declaration copies lock value to %v: %v", valueSpec.Names[i].Name, path)
    68  			}
    69  		}
    70  	}
    71  }
    72  
    73  // checkCopyLocksCompositeLit detects lock copy inside a composite literal
    74  func checkCopyLocksCompositeLit(f *File, cl *ast.CompositeLit) {
    75  	for _, x := range cl.Elts {
    76  		if node, ok := x.(*ast.KeyValueExpr); ok {
    77  			x = node.Value
    78  		}
    79  		if path := lockPathRhs(f, x); path != nil {
    80  			f.Badf(x.Pos(), "literal copies lock value from %v: %v", f.gofmt(x), path)
    81  		}
    82  	}
    83  }
    84  
    85  // checkCopyLocksReturnStmt detects lock copy in return statement
    86  func checkCopyLocksReturnStmt(f *File, rs *ast.ReturnStmt) {
    87  	for _, x := range rs.Results {
    88  		if path := lockPathRhs(f, x); path != nil {
    89  			f.Badf(x.Pos(), "return copies lock value: %v", path)
    90  		}
    91  	}
    92  }
    93  
    94  // checkCopyLocksCallExpr detects lock copy in the arguments to a function call
    95  func checkCopyLocksCallExpr(f *File, ce *ast.CallExpr) {
    96  	var id *ast.Ident
    97  	switch fun := ce.Fun.(type) {
    98  	case *ast.Ident:
    99  		id = fun
   100  	case *ast.SelectorExpr:
   101  		id = fun.Sel
   102  	}
   103  	if fun, ok := f.pkg.uses[id].(*types.Builtin); ok {
   104  		switch fun.Name() {
   105  		case "new", "len", "cap", "Sizeof":
   106  			return
   107  		}
   108  	}
   109  	for _, x := range ce.Args {
   110  		if path := lockPathRhs(f, x); path != nil {
   111  			f.Badf(x.Pos(), "call of %s copies lock value: %v", f.gofmt(ce.Fun), path)
   112  		}
   113  	}
   114  }
   115  
   116  // checkCopyLocksFunc checks whether a function might
   117  // inadvertently copy a lock, by checking whether
   118  // its receiver, parameters, or return values
   119  // are locks.
   120  func checkCopyLocksFunc(f *File, name string, recv *ast.FieldList, typ *ast.FuncType) {
   121  	if recv != nil && len(recv.List) > 0 {
   122  		expr := recv.List[0].Type
   123  		if path := lockPath(f.pkg.typesPkg, f.pkg.types[expr].Type); path != nil {
   124  			f.Badf(expr.Pos(), "%s passes lock by value: %v", name, path)
   125  		}
   126  	}
   127  
   128  	if typ.Params != nil {
   129  		for _, field := range typ.Params.List {
   130  			expr := field.Type
   131  			if path := lockPath(f.pkg.typesPkg, f.pkg.types[expr].Type); path != nil {
   132  				f.Badf(expr.Pos(), "%s passes lock by value: %v", name, path)
   133  			}
   134  		}
   135  	}
   136  
   137  	// Don't check typ.Results. If T has a Lock field it's OK to write
   138  	//     return T{}
   139  	// because that is returning the zero value. Leave result checking
   140  	// to the return statement.
   141  }
   142  
   143  // checkCopyLocksRange checks whether a range statement
   144  // might inadvertently copy a lock by checking whether
   145  // any of the range variables are locks.
   146  func checkCopyLocksRange(f *File, r *ast.RangeStmt) {
   147  	checkCopyLocksRangeVar(f, r.Tok, r.Key)
   148  	checkCopyLocksRangeVar(f, r.Tok, r.Value)
   149  }
   150  
   151  func checkCopyLocksRangeVar(f *File, rtok token.Token, e ast.Expr) {
   152  	if e == nil {
   153  		return
   154  	}
   155  	id, isId := e.(*ast.Ident)
   156  	if isId && id.Name == "_" {
   157  		return
   158  	}
   159  
   160  	var typ types.Type
   161  	if rtok == token.DEFINE {
   162  		if !isId {
   163  			return
   164  		}
   165  		obj := f.pkg.defs[id]
   166  		if obj == nil {
   167  			return
   168  		}
   169  		typ = obj.Type()
   170  	} else {
   171  		typ = f.pkg.types[e].Type
   172  	}
   173  
   174  	if typ == nil {
   175  		return
   176  	}
   177  	if path := lockPath(f.pkg.typesPkg, typ); path != nil {
   178  		f.Badf(e.Pos(), "range var %s copies lock: %v", f.gofmt(e), path)
   179  	}
   180  }
   181  
   182  type typePath []types.Type
   183  
   184  // String pretty-prints a typePath.
   185  func (path typePath) String() string {
   186  	n := len(path)
   187  	var buf bytes.Buffer
   188  	for i := range path {
   189  		if i > 0 {
   190  			fmt.Fprint(&buf, " contains ")
   191  		}
   192  		// The human-readable path is in reverse order, outermost to innermost.
   193  		fmt.Fprint(&buf, path[n-i-1].String())
   194  	}
   195  	return buf.String()
   196  }
   197  
   198  func lockPathRhs(f *File, x ast.Expr) typePath {
   199  	if _, ok := x.(*ast.CompositeLit); ok {
   200  		return nil
   201  	}
   202  	if _, ok := x.(*ast.CallExpr); ok {
   203  		// A call may return a zero value.
   204  		return nil
   205  	}
   206  	if star, ok := x.(*ast.StarExpr); ok {
   207  		if _, ok := star.X.(*ast.CallExpr); ok {
   208  			// A call may return a pointer to a zero value.
   209  			return nil
   210  		}
   211  	}
   212  	return lockPath(f.pkg.typesPkg, f.pkg.types[x].Type)
   213  }
   214  
   215  // lockPath returns a typePath describing the location of a lock value
   216  // contained in typ. If there is no contained lock, it returns nil.
   217  func lockPath(tpkg *types.Package, typ types.Type) typePath {
   218  	if typ == nil {
   219  		return nil
   220  	}
   221  
   222  	for {
   223  		atyp, ok := typ.Underlying().(*types.Array)
   224  		if !ok {
   225  			break
   226  		}
   227  		typ = atyp.Elem()
   228  	}
   229  
   230  	// We're only interested in the case in which the underlying
   231  	// type is a struct. (Interfaces and pointers are safe to copy.)
   232  	styp, ok := typ.Underlying().(*types.Struct)
   233  	if !ok {
   234  		return nil
   235  	}
   236  
   237  	// We're looking for cases in which a pointer to this type
   238  	// is a sync.Locker, but a value is not. This differentiates
   239  	// embedded interfaces from embedded values.
   240  	if types.Implements(types.NewPointer(typ), lockerType) && !types.Implements(typ, lockerType) {
   241  		return []types.Type{typ}
   242  	}
   243  
   244  	nfields := styp.NumFields()
   245  	for i := 0; i < nfields; i++ {
   246  		ftyp := styp.Field(i).Type()
   247  		subpath := lockPath(tpkg, ftyp)
   248  		if subpath != nil {
   249  			return append(subpath, typ)
   250  		}
   251  	}
   252  
   253  	return nil
   254  }
   255  
   256  var lockerType *types.Interface
   257  
   258  // Construct a sync.Locker interface type.
   259  func init() {
   260  	nullary := types.NewSignature(nil, nil, nil, false) // func()
   261  	methods := []*types.Func{
   262  		types.NewFunc(token.NoPos, nil, "Lock", nullary),
   263  		types.NewFunc(token.NoPos, nil, "Unlock", nullary),
   264  	}
   265  	lockerType = types.NewInterface(methods, nil).Complete()
   266  }
   267  

View as plain text