+++ /dev/null
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package shadow defines an Analyzer that checks for shadowed variables.
-package shadow
-
-import (
- "go/ast"
- "go/token"
- "go/types"
-
- "golang.org/x/tools/go/analysis"
- "golang.org/x/tools/go/analysis/passes/inspect"
- "golang.org/x/tools/go/ast/inspector"
-)
-
-// NOTE: Experimental. Not part of the vet suite.
-
-const Doc = `check for possible unintended shadowing of variables
-
-This analyzer check for shadowed variables.
-A shadowed variable is a variable declared in an inner scope
-with the same name and type as a variable in an outer scope,
-and where the outer variable is mentioned after the inner one
-is declared.
-
-(This definition can be refined; the module generates too many
-false positives and is not yet enabled by default.)
-
-For example:
-
- func BadRead(f *os.File, buf []byte) error {
- var err error
- for {
- n, err := f.Read(buf) // shadows the function variable 'err'
- if err != nil {
- break // causes return of wrong value
- }
- foo(buf)
- }
- return err
- }
-`
-
-var Analyzer = &analysis.Analyzer{
- Name: "shadow",
- Doc: Doc,
- Requires: []*analysis.Analyzer{inspect.Analyzer},
- Run: run,
-}
-
-// flags
-var strict = false
-
-func init() {
- Analyzer.Flags.BoolVar(&strict, "strict", strict, "whether to be strict about shadowing; can be noisy")
-}
-
-func run(pass *analysis.Pass) (interface{}, error) {
- inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
-
- spans := make(map[types.Object]span)
- for id, obj := range pass.TypesInfo.Defs {
- // Ignore identifiers that don't denote objects
- // (package names, symbolic variables such as t
- // in t := x.(type) of type switch headers).
- if obj != nil {
- growSpan(spans, obj, id.Pos(), id.End())
- }
- }
- for id, obj := range pass.TypesInfo.Uses {
- growSpan(spans, obj, id.Pos(), id.End())
- }
- for node, obj := range pass.TypesInfo.Implicits {
- // A type switch with a short variable declaration
- // such as t := x.(type) doesn't declare the symbolic
- // variable (t in the example) at the switch header;
- // instead a new variable t (with specific type) is
- // declared implicitly for each case. Such variables
- // are found in the types.Info.Implicits (not Defs)
- // map. Add them here, assuming they are declared at
- // the type cases' colon ":".
- if cc, ok := node.(*ast.CaseClause); ok {
- growSpan(spans, obj, cc.Colon, cc.Colon)
- }
- }
-
- nodeFilter := []ast.Node{
- (*ast.AssignStmt)(nil),
- (*ast.GenDecl)(nil),
- }
- inspect.Preorder(nodeFilter, func(n ast.Node) {
- switch n := n.(type) {
- case *ast.AssignStmt:
- checkShadowAssignment(pass, spans, n)
- case *ast.GenDecl:
- checkShadowDecl(pass, spans, n)
- }
- })
- return nil, nil
-}
-
-// A span stores the minimum range of byte positions in the file in which a
-// given variable (types.Object) is mentioned. It is lexically defined: it spans
-// from the beginning of its first mention to the end of its last mention.
-// A variable is considered shadowed (if strict is off) only if the
-// shadowing variable is declared within the span of the shadowed variable.
-// In other words, if a variable is shadowed but not used after the shadowed
-// variable is declared, it is inconsequential and not worth complaining about.
-// This simple check dramatically reduces the nuisance rate for the shadowing
-// check, at least until something cleverer comes along.
-//
-// One wrinkle: A "naked return" is a silent use of a variable that the Span
-// will not capture, but the compilers catch naked returns of shadowed
-// variables so we don't need to.
-//
-// Cases this gets wrong (TODO):
-// - If a for loop's continuation statement mentions a variable redeclared in
-// the block, we should complain about it but don't.
-// - A variable declared inside a function literal can falsely be identified
-// as shadowing a variable in the outer function.
-//
-type span struct {
- min token.Pos
- max token.Pos
-}
-
-// contains reports whether the position is inside the span.
-func (s span) contains(pos token.Pos) bool {
- return s.min <= pos && pos < s.max
-}
-
-// growSpan expands the span for the object to contain the source range [pos, end).
-func growSpan(spans map[types.Object]span, obj types.Object, pos, end token.Pos) {
- if strict {
- return // No need
- }
- s, ok := spans[obj]
- if ok {
- if s.min > pos {
- s.min = pos
- }
- if s.max < end {
- s.max = end
- }
- } else {
- s = span{pos, end}
- }
- spans[obj] = s
-}
-
-// checkShadowAssignment checks for shadowing in a short variable declaration.
-func checkShadowAssignment(pass *analysis.Pass, spans map[types.Object]span, a *ast.AssignStmt) {
- if a.Tok != token.DEFINE {
- return
- }
- if idiomaticShortRedecl(pass, a) {
- return
- }
- for _, expr := range a.Lhs {
- ident, ok := expr.(*ast.Ident)
- if !ok {
- pass.ReportRangef(expr, "invalid AST: short variable declaration of non-identifier")
- return
- }
- checkShadowing(pass, spans, ident)
- }
-}
-
-// idiomaticShortRedecl reports whether this short declaration can be ignored for
-// the purposes of shadowing, that is, that any redeclarations it contains are deliberate.
-func idiomaticShortRedecl(pass *analysis.Pass, a *ast.AssignStmt) bool {
- // Don't complain about deliberate redeclarations of the form
- // i := i
- // Such constructs are idiomatic in range loops to create a new variable
- // for each iteration. Another example is
- // switch n := n.(type)
- if len(a.Rhs) != len(a.Lhs) {
- return false
- }
- // We know it's an assignment, so the LHS must be all identifiers. (We check anyway.)
- for i, expr := range a.Lhs {
- lhs, ok := expr.(*ast.Ident)
- if !ok {
- pass.ReportRangef(expr, "invalid AST: short variable declaration of non-identifier")
- return true // Don't do any more processing.
- }
- switch rhs := a.Rhs[i].(type) {
- case *ast.Ident:
- if lhs.Name != rhs.Name {
- return false
- }
- case *ast.TypeAssertExpr:
- if id, ok := rhs.X.(*ast.Ident); ok {
- if lhs.Name != id.Name {
- return false
- }
- }
- default:
- return false
- }
- }
- return true
-}
-
-// idiomaticRedecl reports whether this declaration spec can be ignored for
-// the purposes of shadowing, that is, that any redeclarations it contains are deliberate.
-func idiomaticRedecl(d *ast.ValueSpec) bool {
- // Don't complain about deliberate redeclarations of the form
- // var i, j = i, j
- // Don't ignore redeclarations of the form
- // var i = 3
- if len(d.Names) != len(d.Values) {
- return false
- }
- for i, lhs := range d.Names {
- rhs, ok := d.Values[i].(*ast.Ident)
- if !ok || lhs.Name != rhs.Name {
- return false
- }
- }
- return true
-}
-
-// checkShadowDecl checks for shadowing in a general variable declaration.
-func checkShadowDecl(pass *analysis.Pass, spans map[types.Object]span, d *ast.GenDecl) {
- if d.Tok != token.VAR {
- return
- }
- for _, spec := range d.Specs {
- valueSpec, ok := spec.(*ast.ValueSpec)
- if !ok {
- pass.ReportRangef(spec, "invalid AST: var GenDecl not ValueSpec")
- return
- }
- // Don't complain about deliberate redeclarations of the form
- // var i = i
- if idiomaticRedecl(valueSpec) {
- return
- }
- for _, ident := range valueSpec.Names {
- checkShadowing(pass, spans, ident)
- }
- }
-}
-
-// checkShadowing checks whether the identifier shadows an identifier in an outer scope.
-func checkShadowing(pass *analysis.Pass, spans map[types.Object]span, ident *ast.Ident) {
- if ident.Name == "_" {
- // Can't shadow the blank identifier.
- return
- }
- obj := pass.TypesInfo.Defs[ident]
- if obj == nil {
- return
- }
- // obj.Parent.Parent is the surrounding scope. If we can find another declaration
- // starting from there, we have a shadowed identifier.
- _, shadowed := obj.Parent().Parent().LookupParent(obj.Name(), obj.Pos())
- if shadowed == nil {
- return
- }
- // Don't complain if it's shadowing a universe-declared identifier; that's fine.
- if shadowed.Parent() == types.Universe {
- return
- }
- if strict {
- // The shadowed identifier must appear before this one to be an instance of shadowing.
- if shadowed.Pos() > ident.Pos() {
- return
- }
- } else {
- // Don't complain if the span of validity of the shadowed identifier doesn't include
- // the shadowing identifier.
- span, ok := spans[shadowed]
- if !ok {
- pass.ReportRangef(ident, "internal error: no range for %q", ident.Name)
- return
- }
- if !span.contains(ident.Pos()) {
- return
- }
- }
- // Don't complain if the types differ: that implies the programmer really wants two different things.
- if types.Identical(obj.Type(), shadowed.Type()) {
- line := pass.Fset.Position(shadowed.Pos()).Line
- pass.ReportRangef(ident, "declaration of %q shadows declaration at line %d", obj.Name(), line)
- }
-}
projects / dotfiles / .git / blobdiff