...
Run Format

Source file src/cmd/cover/cover.go

Documentation: cmd/cover

  // 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 main
  
  import (
  	"bytes"
  	"flag"
  	"fmt"
  	"go/ast"
  	"go/parser"
  	"go/printer"
  	"go/token"
  	"io"
  	"io/ioutil"
  	"log"
  	"os"
  	"path/filepath"
  	"sort"
  	"strconv"
  	"strings"
  )
  
  const usageMessage = "" +
  	`Usage of 'go tool cover':
  Given a coverage profile produced by 'go test':
  	go test -coverprofile=c.out
  
  Open a web browser displaying annotated source code:
  	go tool cover -html=c.out
  
  Write out an HTML file instead of launching a web browser:
  	go tool cover -html=c.out -o coverage.html
  
  Display coverage percentages to stdout for each function:
  	go tool cover -func=c.out
  
  Finally, to generate modified source code with coverage annotations
  (what go test -cover does):
  	go tool cover -mode=set -var=CoverageVariableName program.go
  `
  
  func usage() {
  	fmt.Fprintln(os.Stderr, usageMessage)
  	fmt.Fprintln(os.Stderr, "Flags:")
  	flag.PrintDefaults()
  	fmt.Fprintln(os.Stderr, "\n  Only one of -html, -func, or -mode may be set.")
  	os.Exit(2)
  }
  
  var (
  	mode    = flag.String("mode", "", "coverage mode: set, count, atomic")
  	varVar  = flag.String("var", "GoCover", "name of coverage variable to generate")
  	output  = flag.String("o", "", "file for output; default: stdout")
  	htmlOut = flag.String("html", "", "generate HTML representation of coverage profile")
  	funcOut = flag.String("func", "", "output coverage profile information for each function")
  )
  
  var profile string // The profile to read; the value of -html or -func
  
  var counterStmt func(*File, ast.Expr) ast.Stmt
  
  const (
  	atomicPackagePath = "sync/atomic"
  	atomicPackageName = "_cover_atomic_"
  )
  
  func main() {
  	flag.Usage = usage
  	flag.Parse()
  
  	// Usage information when no arguments.
  	if flag.NFlag() == 0 && flag.NArg() == 0 {
  		flag.Usage()
  	}
  
  	err := parseFlags()
  	if err != nil {
  		fmt.Fprintln(os.Stderr, err)
  		fmt.Fprintln(os.Stderr, `For usage information, run "go tool cover -help"`)
  		os.Exit(2)
  	}
  
  	// Generate coverage-annotated source.
  	if *mode != "" {
  		annotate(flag.Arg(0))
  		return
  	}
  
  	// Output HTML or function coverage information.
  	if *htmlOut != "" {
  		err = htmlOutput(profile, *output)
  	} else {
  		err = funcOutput(profile, *output)
  	}
  
  	if err != nil {
  		fmt.Fprintf(os.Stderr, "cover: %v\n", err)
  		os.Exit(2)
  	}
  }
  
  // parseFlags sets the profile and counterStmt globals and performs validations.
  func parseFlags() error {
  	profile = *htmlOut
  	if *funcOut != "" {
  		if profile != "" {
  			return fmt.Errorf("too many options")
  		}
  		profile = *funcOut
  	}
  
  	// Must either display a profile or rewrite Go source.
  	if (profile == "") == (*mode == "") {
  		return fmt.Errorf("too many options")
  	}
  
  	if *mode != "" {
  		switch *mode {
  		case "set":
  			counterStmt = setCounterStmt
  		case "count":
  			counterStmt = incCounterStmt
  		case "atomic":
  			counterStmt = atomicCounterStmt
  		default:
  			return fmt.Errorf("unknown -mode %v", *mode)
  		}
  
  		if flag.NArg() == 0 {
  			return fmt.Errorf("missing source file")
  		} else if flag.NArg() == 1 {
  			return nil
  		}
  	} else if flag.NArg() == 0 {
  		return nil
  	}
  	return fmt.Errorf("too many arguments")
  }
  
  // Block represents the information about a basic block to be recorded in the analysis.
  // Note: Our definition of basic block is based on control structures; we don't break
  // apart && and ||. We could but it doesn't seem important enough to bother.
  type Block struct {
  	startByte token.Pos
  	endByte   token.Pos
  	numStmt   int
  }
  
  // File is a wrapper for the state of a file used in the parser.
  // The basic parse tree walker is a method of this type.
  type File struct {
  	fset       *token.FileSet
  	name       string // Name of file.
  	astFile    *ast.File
  	blocks     []Block
  	atomicPkg  string                // Package name for "sync/atomic" in this file.
  	directives map[*ast.Comment]bool // Map of compiler directives to whether it's processed in ast.Visitor or not.
  }
  
  // Visit implements the ast.Visitor interface.
  func (f *File) Visit(node ast.Node) ast.Visitor {
  	switch n := node.(type) {
  	case *ast.BlockStmt:
  		// If it's a switch or select, the body is a list of case clauses; don't tag the block itself.
  		if len(n.List) > 0 {
  			switch n.List[0].(type) {
  			case *ast.CaseClause: // switch
  				for _, n := range n.List {
  					clause := n.(*ast.CaseClause)
  					clause.Body = f.addCounters(clause.Colon+1, clause.End(), clause.Body, false)
  				}
  				return f
  			case *ast.CommClause: // select
  				for _, n := range n.List {
  					clause := n.(*ast.CommClause)
  					clause.Body = f.addCounters(clause.Colon+1, clause.End(), clause.Body, false)
  				}
  				return f
  			}
  		}
  		n.List = f.addCounters(n.Lbrace, n.Rbrace+1, n.List, true) // +1 to step past closing brace.
  	case *ast.IfStmt:
  		if n.Init != nil {
  			ast.Walk(f, n.Init)
  		}
  		ast.Walk(f, n.Cond)
  		ast.Walk(f, n.Body)
  		if n.Else == nil {
  			return nil
  		}
  		// The elses are special, because if we have
  		//	if x {
  		//	} else if y {
  		//	}
  		// we want to cover the "if y". To do this, we need a place to drop the counter,
  		// so we add a hidden block:
  		//	if x {
  		//	} else {
  		//		if y {
  		//		}
  		//	}
  		switch stmt := n.Else.(type) {
  		case *ast.IfStmt:
  			block := &ast.BlockStmt{
  				Lbrace: n.Body.End(), // Start at end of the "if" block so the covered part looks like it starts at the "else".
  				List:   []ast.Stmt{stmt},
  				Rbrace: stmt.End(),
  			}
  			n.Else = block
  		case *ast.BlockStmt:
  			stmt.Lbrace = n.Body.End() // Start at end of the "if" block so the covered part looks like it starts at the "else".
  		default:
  			panic("unexpected node type in if")
  		}
  		ast.Walk(f, n.Else)
  		return nil
  	case *ast.SelectStmt:
  		// Don't annotate an empty select - creates a syntax error.
  		if n.Body == nil || len(n.Body.List) == 0 {
  			return nil
  		}
  	case *ast.SwitchStmt:
  		// Don't annotate an empty switch - creates a syntax error.
  		if n.Body == nil || len(n.Body.List) == 0 {
  			if n.Init != nil {
  				ast.Walk(f, n.Init)
  			}
  			if n.Tag != nil {
  				ast.Walk(f, n.Tag)
  			}
  			return nil
  		}
  	case *ast.TypeSwitchStmt:
  		// Don't annotate an empty type switch - creates a syntax error.
  		if n.Body == nil || len(n.Body.List) == 0 {
  			if n.Init != nil {
  				ast.Walk(f, n.Init)
  			}
  			ast.Walk(f, n.Assign)
  			return nil
  		}
  	case *ast.CommentGroup:
  		var list []*ast.Comment
  		// Drop all but the //go: comments, some of which are semantically important.
  		// We drop all others because they can appear in places that cause our counters
  		// to appear in syntactically incorrect places. //go: appears at the beginning of
  		// the line and is syntactically safe.
  		for _, c := range n.List {
  			if f.isDirective(c) {
  				list = append(list, c)
  
  				// Mark compiler directive as handled.
  				f.directives[c] = true
  			}
  		}
  		n.List = list
  	}
  	return f
  }
  
  // unquote returns the unquoted string.
  func unquote(s string) string {
  	t, err := strconv.Unquote(s)
  	if err != nil {
  		log.Fatalf("cover: improperly quoted string %q\n", s)
  	}
  	return t
  }
  
  // addImport adds an import for the specified path, if one does not already exist, and returns
  // the local package name.
  func (f *File) addImport(path string) string {
  	// Does the package already import it?
  	for _, s := range f.astFile.Imports {
  		if unquote(s.Path.Value) == path {
  			if s.Name != nil {
  				return s.Name.Name
  			}
  			return filepath.Base(path)
  		}
  	}
  	newImport := &ast.ImportSpec{
  		Name: ast.NewIdent(atomicPackageName),
  		Path: &ast.BasicLit{
  			Kind:  token.STRING,
  			Value: fmt.Sprintf("%q", path),
  		},
  	}
  	impDecl := &ast.GenDecl{
  		Tok: token.IMPORT,
  		Specs: []ast.Spec{
  			newImport,
  		},
  	}
  	// Make the new import the first Decl in the file.
  	astFile := f.astFile
  	astFile.Decls = append(astFile.Decls, nil)
  	copy(astFile.Decls[1:], astFile.Decls[0:])
  	astFile.Decls[0] = impDecl
  	astFile.Imports = append(astFile.Imports, newImport)
  
  	// Now refer to the package, just in case it ends up unused.
  	// That is, append to the end of the file the declaration
  	//	var _ = _cover_atomic_.AddUint32
  	reference := &ast.GenDecl{
  		Tok: token.VAR,
  		Specs: []ast.Spec{
  			&ast.ValueSpec{
  				Names: []*ast.Ident{
  					ast.NewIdent("_"),
  				},
  				Values: []ast.Expr{
  					&ast.SelectorExpr{
  						X:   ast.NewIdent(atomicPackageName),
  						Sel: ast.NewIdent("AddUint32"),
  					},
  				},
  			},
  		},
  	}
  	astFile.Decls = append(astFile.Decls, reference)
  	return atomicPackageName
  }
  
  var slashslash = []byte("//")
  
  // initialComments returns the prefix of content containing only
  // whitespace and line comments. Any +build directives must appear
  // within this region. This approach is more reliable than using
  // go/printer to print a modified AST containing comments.
  //
  func initialComments(content []byte) []byte {
  	// Derived from go/build.Context.shouldBuild.
  	end := 0
  	p := content
  	for len(p) > 0 {
  		line := p
  		if i := bytes.IndexByte(line, '\n'); i >= 0 {
  			line, p = line[:i], p[i+1:]
  		} else {
  			p = p[len(p):]
  		}
  		line = bytes.TrimSpace(line)
  		if len(line) == 0 { // Blank line.
  			end = len(content) - len(p)
  			continue
  		}
  		if !bytes.HasPrefix(line, slashslash) { // Not comment line.
  			break
  		}
  	}
  	return content[:end]
  }
  
  func annotate(name string) {
  	fset := token.NewFileSet()
  	content, err := ioutil.ReadFile(name)
  	if err != nil {
  		log.Fatalf("cover: %s: %s", name, err)
  	}
  	parsedFile, err := parser.ParseFile(fset, name, content, parser.ParseComments)
  	if err != nil {
  		log.Fatalf("cover: %s: %s", name, err)
  	}
  
  	file := &File{
  		fset:       fset,
  		name:       name,
  		astFile:    parsedFile,
  		directives: map[*ast.Comment]bool{},
  	}
  	if *mode == "atomic" {
  		file.atomicPkg = file.addImport(atomicPackagePath)
  	}
  
  	for _, cg := range parsedFile.Comments {
  		for _, c := range cg.List {
  			if file.isDirective(c) {
  				file.directives[c] = false
  			}
  		}
  	}
  	// Remove comments. Or else they interfere with new AST.
  	parsedFile.Comments = nil
  
  	ast.Walk(file, file.astFile)
  	fd := os.Stdout
  	if *output != "" {
  		var err error
  		fd, err = os.Create(*output)
  		if err != nil {
  			log.Fatalf("cover: %s", err)
  		}
  	}
  	fd.Write(initialComments(content)) // Retain '// +build' directives.
  
  	// Retain compiler directives that are not processed in ast.Visitor.
  	// Some compiler directives like "go:linkname" and "go:cgo_"
  	// can be not attached to anything in the tree and hence will not be printed by printer.
  	// So, we have to explicitly print them here.
  	for cd, handled := range file.directives {
  		if !handled {
  			fmt.Fprintln(fd, cd.Text)
  		}
  	}
  
  	file.print(fd)
  	// After printing the source tree, add some declarations for the counters etc.
  	// We could do this by adding to the tree, but it's easier just to print the text.
  	file.addVariables(fd)
  }
  
  func (f *File) print(w io.Writer) {
  	printer.Fprint(w, f.fset, f.astFile)
  }
  
  // isDirective reports whether a comment is a compiler directive.
  func (f *File) isDirective(c *ast.Comment) bool {
  	return strings.HasPrefix(c.Text, "//go:") && f.fset.Position(c.Slash).Column == 1
  }
  
  // intLiteral returns an ast.BasicLit representing the integer value.
  func (f *File) intLiteral(i int) *ast.BasicLit {
  	node := &ast.BasicLit{
  		Kind:  token.INT,
  		Value: fmt.Sprint(i),
  	}
  	return node
  }
  
  // index returns an ast.BasicLit representing the number of counters present.
  func (f *File) index() *ast.BasicLit {
  	return f.intLiteral(len(f.blocks))
  }
  
  // setCounterStmt returns the expression: __count[23] = 1.
  func setCounterStmt(f *File, counter ast.Expr) ast.Stmt {
  	return &ast.AssignStmt{
  		Lhs: []ast.Expr{counter},
  		Tok: token.ASSIGN,
  		Rhs: []ast.Expr{f.intLiteral(1)},
  	}
  }
  
  // incCounterStmt returns the expression: __count[23]++.
  func incCounterStmt(f *File, counter ast.Expr) ast.Stmt {
  	return &ast.IncDecStmt{
  		X:   counter,
  		Tok: token.INC,
  	}
  }
  
  // atomicCounterStmt returns the expression: atomic.AddUint32(&__count[23], 1)
  func atomicCounterStmt(f *File, counter ast.Expr) ast.Stmt {
  	return &ast.ExprStmt{
  		X: &ast.CallExpr{
  			Fun: &ast.SelectorExpr{
  				X:   ast.NewIdent(f.atomicPkg),
  				Sel: ast.NewIdent("AddUint32"),
  			},
  			Args: []ast.Expr{&ast.UnaryExpr{
  				Op: token.AND,
  				X:  counter,
  			},
  				f.intLiteral(1),
  			},
  		},
  	}
  }
  
  // newCounter creates a new counter expression of the appropriate form.
  func (f *File) newCounter(start, end token.Pos, numStmt int) ast.Stmt {
  	counter := &ast.IndexExpr{
  		X: &ast.SelectorExpr{
  			X:   ast.NewIdent(*varVar),
  			Sel: ast.NewIdent("Count"),
  		},
  		Index: f.index(),
  	}
  	stmt := counterStmt(f, counter)
  	f.blocks = append(f.blocks, Block{start, end, numStmt})
  	return stmt
  }
  
  // addCounters takes a list of statements and adds counters to the beginning of
  // each basic block at the top level of that list. For instance, given
  //
  //	S1
  //	if cond {
  //		S2
  // 	}
  //	S3
  //
  // counters will be added before S1 and before S3. The block containing S2
  // will be visited in a separate call.
  // TODO: Nested simple blocks get unnecessary (but correct) counters
  func (f *File) addCounters(pos, blockEnd token.Pos, list []ast.Stmt, extendToClosingBrace bool) []ast.Stmt {
  	// Special case: make sure we add a counter to an empty block. Can't do this below
  	// or we will add a counter to an empty statement list after, say, a return statement.
  	if len(list) == 0 {
  		return []ast.Stmt{f.newCounter(pos, blockEnd, 0)}
  	}
  	// We have a block (statement list), but it may have several basic blocks due to the
  	// appearance of statements that affect the flow of control.
  	var newList []ast.Stmt
  	for {
  		// Find first statement that affects flow of control (break, continue, if, etc.).
  		// It will be the last statement of this basic block.
  		var last int
  		end := blockEnd
  		for last = 0; last < len(list); last++ {
  			stmt := list[last]
  			end = f.statementBoundary(stmt)
  			if f.endsBasicSourceBlock(stmt) {
  				// If it is a labeled statement, we need to place a counter between
  				// the label and its statement because it may be the target of a goto
  				// and thus start a basic block. That is, given
  				//	foo: stmt
  				// we need to create
  				//	foo: ; stmt
  				// and mark the label as a block-terminating statement.
  				// The result will then be
  				//	foo: COUNTER[n]++; stmt
  				// However, we can't do this if the labeled statement is already
  				// a control statement, such as a labeled for.
  				if label, isLabel := stmt.(*ast.LabeledStmt); isLabel && !f.isControl(label.Stmt) {
  					newLabel := *label
  					newLabel.Stmt = &ast.EmptyStmt{
  						Semicolon: label.Stmt.Pos(),
  						Implicit:  true,
  					}
  					end = label.Pos() // Previous block ends before the label.
  					list[last] = &newLabel
  					// Open a gap and drop in the old statement, now without a label.
  					list = append(list, nil)
  					copy(list[last+1:], list[last:])
  					list[last+1] = label.Stmt
  				}
  				last++
  				extendToClosingBrace = false // Block is broken up now.
  				break
  			}
  		}
  		if extendToClosingBrace {
  			end = blockEnd
  		}
  		if pos != end { // Can have no source to cover if e.g. blocks abut.
  			newList = append(newList, f.newCounter(pos, end, last))
  		}
  		newList = append(newList, list[0:last]...)
  		list = list[last:]
  		if len(list) == 0 {
  			break
  		}
  		pos = list[0].Pos()
  	}
  	return newList
  }
  
  // hasFuncLiteral reports the existence and position of the first func literal
  // in the node, if any. If a func literal appears, it usually marks the termination
  // of a basic block because the function body is itself a block.
  // Therefore we draw a line at the start of the body of the first function literal we find.
  // TODO: what if there's more than one? Probably doesn't matter much.
  func hasFuncLiteral(n ast.Node) (bool, token.Pos) {
  	if n == nil {
  		return false, 0
  	}
  	var literal funcLitFinder
  	ast.Walk(&literal, n)
  	return literal.found(), token.Pos(literal)
  }
  
  // statementBoundary finds the location in s that terminates the current basic
  // block in the source.
  func (f *File) statementBoundary(s ast.Stmt) token.Pos {
  	// Control flow statements are easy.
  	switch s := s.(type) {
  	case *ast.BlockStmt:
  		// Treat blocks like basic blocks to avoid overlapping counters.
  		return s.Lbrace
  	case *ast.IfStmt:
  		found, pos := hasFuncLiteral(s.Init)
  		if found {
  			return pos
  		}
  		found, pos = hasFuncLiteral(s.Cond)
  		if found {
  			return pos
  		}
  		return s.Body.Lbrace
  	case *ast.ForStmt:
  		found, pos := hasFuncLiteral(s.Init)
  		if found {
  			return pos
  		}
  		found, pos = hasFuncLiteral(s.Cond)
  		if found {
  			return pos
  		}
  		found, pos = hasFuncLiteral(s.Post)
  		if found {
  			return pos
  		}
  		return s.Body.Lbrace
  	case *ast.LabeledStmt:
  		return f.statementBoundary(s.Stmt)
  	case *ast.RangeStmt:
  		found, pos := hasFuncLiteral(s.X)
  		if found {
  			return pos
  		}
  		return s.Body.Lbrace
  	case *ast.SwitchStmt:
  		found, pos := hasFuncLiteral(s.Init)
  		if found {
  			return pos
  		}
  		found, pos = hasFuncLiteral(s.Tag)
  		if found {
  			return pos
  		}
  		return s.Body.Lbrace
  	case *ast.SelectStmt:
  		return s.Body.Lbrace
  	case *ast.TypeSwitchStmt:
  		found, pos := hasFuncLiteral(s.Init)
  		if found {
  			return pos
  		}
  		return s.Body.Lbrace
  	}
  	// If not a control flow statement, it is a declaration, expression, call, etc. and it may have a function literal.
  	// If it does, that's tricky because we want to exclude the body of the function from this block.
  	// Draw a line at the start of the body of the first function literal we find.
  	// TODO: what if there's more than one? Probably doesn't matter much.
  	found, pos := hasFuncLiteral(s)
  	if found {
  		return pos
  	}
  	return s.End()
  }
  
  // endsBasicSourceBlock reports whether s changes the flow of control: break, if, etc.,
  // or if it's just problematic, for instance contains a function literal, which will complicate
  // accounting due to the block-within-an expression.
  func (f *File) endsBasicSourceBlock(s ast.Stmt) bool {
  	switch s := s.(type) {
  	case *ast.BlockStmt:
  		// Treat blocks like basic blocks to avoid overlapping counters.
  		return true
  	case *ast.BranchStmt:
  		return true
  	case *ast.ForStmt:
  		return true
  	case *ast.IfStmt:
  		return true
  	case *ast.LabeledStmt:
  		return true // A goto may branch here, starting a new basic block.
  	case *ast.RangeStmt:
  		return true
  	case *ast.SwitchStmt:
  		return true
  	case *ast.SelectStmt:
  		return true
  	case *ast.TypeSwitchStmt:
  		return true
  	case *ast.ExprStmt:
  		// Calls to panic change the flow.
  		// We really should verify that "panic" is the predefined function,
  		// but without type checking we can't and the likelihood of it being
  		// an actual problem is vanishingly small.
  		if call, ok := s.X.(*ast.CallExpr); ok {
  			if ident, ok := call.Fun.(*ast.Ident); ok && ident.Name == "panic" && len(call.Args) == 1 {
  				return true
  			}
  		}
  	}
  	found, _ := hasFuncLiteral(s)
  	return found
  }
  
  // isControl reports whether s is a control statement that, if labeled, cannot be
  // separated from its label.
  func (f *File) isControl(s ast.Stmt) bool {
  	switch s.(type) {
  	case *ast.ForStmt, *ast.RangeStmt, *ast.SwitchStmt, *ast.SelectStmt, *ast.TypeSwitchStmt:
  		return true
  	}
  	return false
  }
  
  // funcLitFinder implements the ast.Visitor pattern to find the location of any
  // function literal in a subtree.
  type funcLitFinder token.Pos
  
  func (f *funcLitFinder) Visit(node ast.Node) (w ast.Visitor) {
  	if f.found() {
  		return nil // Prune search.
  	}
  	switch n := node.(type) {
  	case *ast.FuncLit:
  		*f = funcLitFinder(n.Body.Lbrace)
  		return nil // Prune search.
  	}
  	return f
  }
  
  func (f *funcLitFinder) found() bool {
  	return token.Pos(*f) != token.NoPos
  }
  
  // Sort interface for []block1; used for self-check in addVariables.
  
  type block1 struct {
  	Block
  	index int
  }
  
  type blockSlice []block1
  
  func (b blockSlice) Len() int           { return len(b) }
  func (b blockSlice) Less(i, j int) bool { return b[i].startByte < b[j].startByte }
  func (b blockSlice) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
  
  // offset translates a token position into a 0-indexed byte offset.
  func (f *File) offset(pos token.Pos) int {
  	return f.fset.Position(pos).Offset
  }
  
  // addVariables adds to the end of the file the declarations to set up the counter and position variables.
  func (f *File) addVariables(w io.Writer) {
  	// Self-check: Verify that the instrumented basic blocks are disjoint.
  	t := make([]block1, len(f.blocks))
  	for i := range f.blocks {
  		t[i].Block = f.blocks[i]
  		t[i].index = i
  	}
  	sort.Sort(blockSlice(t))
  	for i := 1; i < len(t); i++ {
  		if t[i-1].endByte > t[i].startByte {
  			fmt.Fprintf(os.Stderr, "cover: internal error: block %d overlaps block %d\n", t[i-1].index, t[i].index)
  			// Note: error message is in byte positions, not token positions.
  			fmt.Fprintf(os.Stderr, "\t%s:#%d,#%d %s:#%d,#%d\n",
  				f.name, f.offset(t[i-1].startByte), f.offset(t[i-1].endByte),
  				f.name, f.offset(t[i].startByte), f.offset(t[i].endByte))
  		}
  	}
  
  	// Declare the coverage struct as a package-level variable.
  	fmt.Fprintf(w, "\nvar %s = struct {\n", *varVar)
  	fmt.Fprintf(w, "\tCount     [%d]uint32\n", len(f.blocks))
  	fmt.Fprintf(w, "\tPos       [3 * %d]uint32\n", len(f.blocks))
  	fmt.Fprintf(w, "\tNumStmt   [%d]uint16\n", len(f.blocks))
  	fmt.Fprintf(w, "} {\n")
  
  	// Initialize the position array field.
  	fmt.Fprintf(w, "\tPos: [3 * %d]uint32{\n", len(f.blocks))
  
  	// A nice long list of positions. Each position is encoded as follows to reduce size:
  	// - 32-bit starting line number
  	// - 32-bit ending line number
  	// - (16 bit ending column number << 16) | (16-bit starting column number).
  	for i, block := range f.blocks {
  		start := f.fset.Position(block.startByte)
  		end := f.fset.Position(block.endByte)
  		fmt.Fprintf(w, "\t\t%d, %d, %#x, // [%d]\n", start.Line, end.Line, (end.Column&0xFFFF)<<16|(start.Column&0xFFFF), i)
  	}
  
  	// Close the position array.
  	fmt.Fprintf(w, "\t},\n")
  
  	// Initialize the position array field.
  	fmt.Fprintf(w, "\tNumStmt: [%d]uint16{\n", len(f.blocks))
  
  	// A nice long list of statements-per-block, so we can give a conventional
  	// valuation of "percent covered". To save space, it's a 16-bit number, so we
  	// clamp it if it overflows - won't matter in practice.
  	for i, block := range f.blocks {
  		n := block.numStmt
  		if n > 1<<16-1 {
  			n = 1<<16 - 1
  		}
  		fmt.Fprintf(w, "\t\t%d, // %d\n", n, i)
  	}
  
  	// Close the statements-per-block array.
  	fmt.Fprintf(w, "\t},\n")
  
  	// Close the struct initialization.
  	fmt.Fprintf(w, "}\n")
  }
  

View as plain text