unused

Documentation

Overview

Package unused contains code for finding unused code.

Index

• Variables
• func Run(pass *analysis.Pass) (interface{}, error)
• type Node
  • func Graph(fset *token.FileSet, files []*ast.File, pkg *types.Package, info *types.Info, ...) []Node
• type NodeID
• type Object
• type ObjectPath
• type Options
• type Result
• type SerializedGraph
  • func (g *SerializedGraph) Dot() string
  • func (g *SerializedGraph) Merge(nodes []Node)
  • func (g *SerializedGraph) Results() Result

Variables

var Analyzer = &lint.Analyzer{
	Doc: &lint.Documentation{
		Title: "Unused code",
	},
	Analyzer: &analysis.Analyzer{
		Name:       "U1000",
		Doc:        "Unused code",
		Run:        Run,
		Requires:   []*analysis.Analyzer{generated.Analyzer, directives.Analyzer},
		ResultType: reflect.TypeOf(Result{}),
	},
}

var Debug io.Writer

var DefaultOptions = Options{
	FieldWritesAreUses:     true,
	PostStatementsAreReads: false,
	ExportedIsUsed:         true,
	ExportedFieldsAreUsed:  true,
	ParametersAreUsed:      true,
	LocalVariablesAreUsed:  true,
	GeneratedIsUsed:        true,
}

Functions

func Run

func Run(pass *analysis.Pass) (interface{}, error)

Types

type Node

type Node struct {
	ID  NodeID
	Obj Object

	// using slices instead of maps here helps make merging of graphs simpler and more efficient, because we can rewrite
	// IDs in place instead of having to build new maps.
	Uses []NodeID
	Owns []NodeID
}

func Graph

func Graph(fset *token.FileSet,
	files []*ast.File,
	pkg *types.Package,
	info *types.Info,
	directives []lint.Directive,
	generated map[string]generated.Generator,
	opts Options,
) []Node

type NodeID

type NodeID uint64

OPT(dh): 32 bits would be plenty, but the Node struct would end up with padding, anyway.

type Object

type Object struct {
	Name      string
	ShortName string
	// OPT(dh): use an enum for the kind
	Kind            string
	Path            ObjectPath
	Position        token.Position
	DisplayPosition token.Position
}

type ObjectPath

type ObjectPath struct {
	PkgPath string
	ObjPath objectpath.Path
}

type Options

type Options struct {
	FieldWritesAreUses     bool
	PostStatementsAreReads bool
	ExportedIsUsed         bool
	ExportedFieldsAreUsed  bool
	ParametersAreUsed      bool
	LocalVariablesAreUsed  bool
	GeneratedIsUsed        bool
}

type Result

type Result struct {
	Used   []Object
	Unused []Object
	Quiet  []Object
}

TODO(dh): should we return a map instead of two slices?

type SerializedGraph

type SerializedGraph struct {
	// contains filtered or unexported fields
}

func (*SerializedGraph) Dot

func (g *SerializedGraph) Dot() string

Dot formats a graph in Graphviz dot format.

func (*SerializedGraph) Merge

func (g *SerializedGraph) Merge(nodes []Node)

func (*SerializedGraph) Results

func (g *SerializedGraph) Results() Result