Static Analysis Tool for Go: Detecting Unused Variables

Static analysis is a powerful technique for identifying potential issues in code without actually running it. This challenge will guide you through building a basic static analysis tool in Go to detect unused variables within a given Go source file. Identifying unused variables is crucial for code clarity, maintainability, and reducing potential bugs.

Problem Description

Your task is to create a Go program that takes a Go source file as input and reports all variables that are declared but never used within their scope. The program should parse the Go code, identify variable declarations, track their usage, and then list the unused ones.

Key Requirements:

• Input: A path to a Go source file (.go).
• Parsing: Utilize Go's built-in go/parser and go/ast packages to parse the source code into an Abstract Syntax Tree (AST).
• Variable Detection: Identify all variable declarations (short variable declarations := and var declarations).
• Usage Tracking: For each declared variable, determine if it is ever read or assigned to after its declaration within its scope.
• Scope Awareness: Correctly handle variable scopes (e.g., function-level, block-level) to avoid false positives or negatives.
• Output: Print a list of unused variables, including their name, line number, and the file path.
• Error Handling: Gracefully handle cases where the input file cannot be parsed or doesn't exist.

Expected Behavior:

The program should accurately identify variables that are declared but not used. For instance, if a variable is declared and then immediately overwritten without being read, it should be considered unused. Variables declared within a scope that are used within that same scope but not outside it are considered used.

Edge Cases to Consider:

• Variables declared and immediately assigned to a new value without being read.
• Variables used only within loops or conditional statements.
• Global variables versus local variables.
• Variables declared with _ (blank identifier) should be ignored.
• Functions or methods that are declared but not called (though this is out of scope for this particular challenge focusing on variables).

Examples

Example 1:

Input File (main.go):

package main

func main() {
	var x int = 10
	y := 20
	z := 30
	println(y) // x is declared but not used
}

Output:

Unused variable 'x' found at line 4 in main.go

Explanation: x is declared but never read. y is read (by println). z is declared but not used and also shadowed by the y := 20 declaration. However, for simplicity in this challenge, we focus on the first occurrence and its direct usage. A more advanced tool would handle shadowing.

Example 2:

Input File (another.go):

package main

func greet(name string) {
	greeting := "Hello, " + name
	var message string
	message = greeting + "!"
	println(message)
}

func main() {
	greet("World")
}

Output:

Unused variable 'name' found at line 4 in another.go

Explanation: The name parameter is declared but not directly used within the greet function. It's used in the initialization of greeting, which is a form of usage. message is declared and then assigned and used.

Example 3:

Input File (complex.go):

package main

func process(data []int) {
	if len(data) > 0 {
		first := data[0]
		// Some processing here, first is used indirectly
	} else {
		var unusedVar int
		unusedVar = 100 // Assigned but not read
	}
	var anotherUnused int
}

Output:

Unused variable 'unusedVar' found at line 11 in complex.go
Unused variable 'anotherUnused' found at line 14 in complex.go

Explanation: first is declared within the if block. While its direct use isn't shown in this snippet, we assume it's used within the comment's "processing". unusedVar is declared and assigned in the else block but never read. anotherUnused is declared at the function level but never used.

Constraints

• The input will be a single Go source file (.go).
• The file path will be a valid string.
• The program should be reasonably efficient, processing typical Go files within a few seconds.
• Focus on top-level functions and their immediate inner scopes. Handling complex generic types or deeply nested anonymous functions might be out of scope for this initial challenge.
• Only report unused variables declared using var and :=.

Notes

• You will need to familiarize yourself with Go's go/parser, go/ast, and go/token packages.
• A good starting point is to use parser.ParseFile to get an ast.File.
• You'll likely want to implement an ast.Visitor to traverse the AST.
• Consider how to track variable declarations and their corresponding usages within different scopes. A map or similar data structure could be useful for this.
• Remember that Go's AST represents identifiers. You'll need to distinguish between declarations and uses of these identifiers.
• The go/token package provides position information (line numbers) for AST nodes.
• Be mindful of built-in functions (like println) and how their arguments are treated.