Code Blocks and Identifier Scopes

Code Blocks

• the universe block contains all project source code.
• each package has a package block containing all source code, excluding the package import declarations in that package.
• each file has a file block containing all the source code, including the package import declarations, in that file.
• generally, a pair of braces {} encloses a local block. However, some local blocks aren't enclosed within {}, such blocks are called implicit local blocks. The local blocks enclosed in {} are called explicit local blocks. The {} in composite literals and type definitions don't form local blocks.

• An if, switch or for keyword is followed by two nested local blocks. One is implicit, the other is explicit. The explicit one is nested in the implicit one. If such a keyword is followed by a short variable declaration, then the variables are declared in the implicit block.
• An else keyword is followed by one explicit or implicit block, which is nested in the implicit block following its if counterpart keyword. If the else keyword is followed by another if keyword, then the code block following the else keyword can be implicit, otherwise, the code block must be explicit.
• An select keyword is followed by one explicit block.
• Each case and default keyword is followed by one implicit block, which is nested in the explicit block following its corresponding switch or select keyword.

• package blocks are nested in the universe block.
• file blocks are also directly nested in the universe block, instead of package blocks. (This explanation is different from the go/* standard packages.)
• each top-level local block is nested in both a package block and a file block. (This explanation is also different from the go/* standard packages.)
• a non-top local block must be nested in another local block.

Source Code Element Declaration Places

• package imports.
• defined types and type alias.
• named constants.
• variables.
• functions.
• labels.

• package imports can never be declared in package blocks and local blocks.
• functions can never be declared in local blocks. (Anonymous functions can be enclosed in local blocks but they are not declarations.)
• labels can only be declared in local blocks.

• if the innermost containing blocks of two code element declarations are the same one, then the names (identifiers) of the two code elements can't be identical.
• the name (identifier) of a package-level code element declared in a package must not be identical to any package import name declared in any source file in the package (a.k.a., a package import name in a package must not be identical to any package-level code element declared in the package). This rule might be relaxed later.
• if the innermost containing function body blocks of two label declarations are the same one, then the names (identifiers) of the two labels can't be identical.
• the references of a label must be within the innermost function body block containing the declaration of the label.
• some special portions in the implicit local blocks in all kinds of control flows have special requirements. Generally, no code elements are allowed to be directly declared in such implicit local blocks, except some short variable declarations.
  • Each if, switch or for keyword can be closely followed by a short variable declaration.
  • Each case keyword in a select control flow can be closely followed by a short variable declaration.

Scopes of Declared Source Code Elements

• The scope of a predeclared/built-in identifier is the universe block.
• The scope of the identifier of a package import is the file block containing the package import declaration.
• The scope of an identifier denoting a constant, type, variable, or function (but not method) declared at package level is the package block.
• The scope of an identifier denoting a method receiver, function parameter, or result variable is the corresponding function body (a local block).
• The scope of the identifier of a constant or a variable declared inside a function body begins at the end of the specification of the constant or variable (or the end of the declaration for a short declared variable) and ends at the end of the innermost containing block.
• The scope of the identifier of a type or a type alias declared inside a function body begins at the end of the identifier in the corresponding type specification and ends at the end of the innermost containing block.
• The scope of a label is the body of the innermost function body block containing the label declaration but excludes all the bodies of anonymous functions nested in the containing function.
• About the scopes of type parameters, please read the Go generics 101 book.

package main

func main() {
	// var v int = v   // error: v is undefined
	// const C int = C // error: C is undefined
	/*
	type T = struct {
		*T    // error: T uses <T>
		x []T // error: T uses <T>
	}
	*/

	// Following type definitions are all valid.
	type T struct {
		*T
		x []T
	}
	type A [5]*A
	type S []S
	type M map[int]M
	type F func(F) F
	type Ch chan Ch
	type P *P

	// ...
	var p P
	p = &p
	p = ***********************p
	***********************p = p

	var s = make(S, 3)
	s[0] = s
	s = s[0][0][0][0][0][0][0][0]

	var m = M{}
	m[1] = m
	m = m[1][1][1][1][1][1][1][1]
}

package main

// Here the two identifiers at each line are the
// same one. The right ones are both not the
// predeclared identifiers. Instead, they are
// same as respective left one. So the two
// lines both fail to compile.
/*
const iota = iota // error: constant definition loop
var true = true   // error: typechecking loop
*/

var a = b // can reference variables declared later
var b = 123

func main() {
	// The identifiers at the right side in the
	// next two lines are the predeclared ones.
	const iota = iota // ok
	var true = true   // ok
	_ = true

	// The following lines fail to compile, for
	// c references a later declared variable d.
	/*
	var c = d
	var d = 123
	_ = c
	*/
}

Identifier Shadowing

package main

import "fmt"

var p0, p1, p2, p3, p4, p5 *int
var x = 9999 // x#0

func main() {
	p0 = &x
	var x = 888  // x#1
	p1 = &x
	for x := 70; x < 77; x++ {  // x#2
		p2 = &x
		x := x - 70 //  // x#3
		p3 = &x
		if x := x - 3; x > 0 { // x#4
			p4 = &x
			x := -x // x#5
			p5 = &x
		}
	}

	// 9999 888 77 6 3 -3
	fmt.Println(*p0, *p1, *p2, *p3, *p4, *p5)
}

package main

import "fmt"

var f = func(b bool) {
	fmt.Print("Goat")
}

func main() {
	var f = func(b bool) {
		fmt.Print("Sheep")
		if b {
			fmt.Print(" ")
			f(!b) // The f is the package-level f.
		}
	}
	f(true) // The f is the local f.
}

func main() {
	var f func(b bool)
	f = func(b bool) {
		fmt.Print("Sheep")
		if b {
			fmt.Print(" ")
			f(!b) // The f is also the local f now.
		}
	}
	f(true)
}

package main

import "fmt"
import "strconv"

func parseInt(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		// Some new gophers may think err is an
		// already declared variable in the following
		// short variable declaration. However, both
		// b and err are new declared here actually.
		// The new declared err variable shadows the
		// err variable declared above.
		b, err := strconv.ParseBool(s)
		if err != nil {
			return 0, err
		}

		// If execution goes here, some new gophers
		// might expect a nil error will be returned.
		// But in fact, the outer non-nil error will
		// be returned instead, for the scope of the
		// inner err variable ends at the end of the
		// outer if-clause.
		if b {
			n = 1
		}
	}
	return n, err
}

func main() {
	fmt.Println(parseInt("TRUE"))
}

1 strconv.Atoi: parsing "TRUE": invalid syntax

package main

import (
	"fmt"
)

// Shadows the built-in function identifier "len".
const len = 3
// Shadows the built-in const identifier "true".
var true = 0
// Shadows the built-in variable identifier "nil".
type nil struct {}
// Shadows the built-in type identifier "int".
func int(){}

func main() {
	fmt.Println("a weird program")
	var output = fmt.Println

	// Shadows the package import "fmt".
	var fmt = [len]nil{{}, {}, {}}
	// Sorry, "len" is a constant.
	// var n = len(fmt)
	// Use the built-in cap function instead, :(
	var n = cap(fmt)

	// The "for" keyword is followed by one
	// implicit local code block and one explicit
	// local code block. The iteration variable
	// "true" shadows the package-level variable
	// "true" declared above.
	for true := 0; true < n; true++ {
		// Shadows the built-in const "false".
		var false = fmt[true]
		// The new declared "true" variable
		// shadows the iteration variable "true".
		var true = true+1
		// Sorry, "fmt" is an array, not a package.
		// fmt.Println(true, false)
		output(true, false)
	}
}

a weird program
1 {}
2 {}
3 {}