Scope and Shadowing

Scope is the part of the program where a name can be used. In Go, scope follows braces. A pair of { } makes a block, and a name declared inside a block is visible from its declaration to the closing brace, then gone.

The levels

• Names declared outside every function are at package scope. Every file in the package sees them.
• A function's parameters and its body form a block.
• Every { } inside a function makes another block.
• if and for may declare a variable before their condition. That variable belongs to the statement, so it is visible in the condition and the body, and nowhere else. if runs a block only when its condition is true.

Shadowing

An inner block may declare a name that already exists outside it. That is legal. The inner declaration makes a second, separate variable, and the name now refers to the inner one until the block ends. The outer variable still exists and still holds its old value. This is called shadowing.

Sometimes that is exactly right: a short-lived value stays out of the rest of the function. Sometimes it is a bug, and the classic one is an error. You write if err := save(); err != nil inside a function that has its own err. The := declares a new err for the if only. The function's own err is never touched, so whatever checks it later sees nothing wrong.

What trips people up

Shadowing compiles cleanly, and the names look identical when you read the code.

package main

import "fmt"

func main() {
	message := "outer"

	// A bare pair of braces is a block. A name declared inside it is
	// gone at the closing brace.
	{
		message := "inner" // a second, separate variable with the same name
		fmt.Println(message)
	}

	// The outer message was never changed.
	fmt.Println(message)

	count := 0

	// The part before the semicolon declares doubled. It exists only
	// inside this if statement.
	if doubled := count + 2; doubled > 1 {
		fmt.Println("doubled:", doubled)
	}

	// fmt.Println(doubled) here would not compile: doubled is out of scope.
	fmt.Println("count:", count)
}

// Output:
// inner
// outer
// doubled: 2
// count: 0

package main

import (
	"errors"
	"fmt"
)

func save() error {
	return errors.New("disk full")
}

func main() {
	var err error

	// := declares a NEW err for this if only. The outer err is untouched.
	if err := save(); err != nil {
		fmt.Println("inside:", err)
	}
	fmt.Println("outer:", err)

	// The fix: assign to the existing err, then test it.
	err = save()
	if err != nil {
		fmt.Println("fixed:", err)
	}
}

// Output:
// inside: disk full
// outer: <nil>
// fixed: disk full

package report

import "sort"

// The parameter is called sort, so inside this function the name sort
// means a string, not the imported package.
func writeAll(lines []string, sort string) {
	// sort.Strings(lines)
	// compile error: sort.Strings undefined (type string has no field or method Strings)
	_ = sort
	_ = lines
}

# Build the shadow analyzer from the golang.org/x/tools module,
# then hand the binary to go vet.
go vet -vettool="$(go env GOPATH)/bin/shadow" ./...

# The default checks do not include it, so a plain run stays quiet:
go vet ./...