feat(gnovm): Test Coverage Support

gnovm/pkg/coverage/analyze.go

@@ -0,0 +1,108 @@
+package coverage
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+)
+
+// detectExecutableLines analyzes the given source code content and returns a map
+// of line numbers to boolean values indicating whether each line is executable.
+func DetectExecutableLines(content string) (map[int]bool, error) {
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, "", content, parser.ParseComments)
+	if err != nil {
+		return nil, err
+	}
+
+	executableLines := make(map[int]bool)
+
+	ast.Inspect(node, func(n ast.Node) bool {
+		if n == nil {
+			return true
+		}
+
+		if isExecutableLine(n) {
+			line := fset.Position(n.Pos()).Line
+			executableLines[line] = true
+		}
+
+		return true
+	})
+
+	return executableLines, nil
+}
+
+// countCodeLines counts the number of executable lines in the given source code content.
+func CountCodeLines(content string) int {
+	lines, err := DetectExecutableLines(content)
+	if err != nil {
+		return 0
+	}
+
+	return len(lines)
+}
+
+// isExecutableLine determines whether a given AST node represents an
+// executable line of code for the purpose of code coverage measurement.
+//
+// It returns true for statement nodes that typically contain executable code,
+// such as assignments, expressions, return statements, and control flow statements.
+//
+// It returns false for nodes that represent non-executable lines, such as
+// declarations, blocks, and function definitions.
+func isExecutableLine(node ast.Node) bool {
+	switch n := node.(type) {
+	case *ast.AssignStmt, *ast.ExprStmt, *ast.ReturnStmt, *ast.BranchStmt,
+		*ast.IncDecStmt, *ast.GoStmt, *ast.DeferStmt, *ast.SendStmt:
+		return true
+	case *ast.IfStmt, *ast.ForStmt, *ast.RangeStmt, *ast.SwitchStmt,
+		*ast.TypeSwitchStmt, *ast.SelectStmt:
+		return true
+	case *ast.CaseClause:
+		// Even if a `case` condition (e.g., `case 1:`) in a `switch` statement is executed,
+		// the condition itself is not included in the coverage; coverage only recorded for the
+		// code block inside the corresponding `case` clause.
+		return false
+	case *ast.LabeledStmt:
+		return isExecutableLine(n.Stmt)
+	case *ast.FuncDecl:
+		return false
+	case *ast.BlockStmt:
+		return false
+	case *ast.DeclStmt:
+		// check inner declarations in the DeclStmt (e.g. `var a, b = 1, 2`)
+		// if there is a value initialization, then the line is executable
+		genDecl, ok := n.Decl.(*ast.GenDecl)
+		if ok && (genDecl.Tok == token.VAR || genDecl.Tok == token.CONST) {
+			for _, spec := range genDecl.Specs {
+				valueSpec, ok := spec.(*ast.ValueSpec)
+				if ok && len(valueSpec.Values) > 0 {
+					return true
+				}
+			}
+		}
+		return false
+	case *ast.ImportSpec, *ast.TypeSpec, *ast.ValueSpec:
+		return false
+	case *ast.InterfaceType:
+		return false
+	case *ast.GenDecl:
+		switch n.Tok {
+		case token.VAR, token.CONST:
+			for _, spec := range n.Specs {
+				valueSpec, ok := spec.(*ast.ValueSpec)
+				if ok && len(valueSpec.Values) > 0 {
+					return true
+				}
+			}
+			return false
+		case token.TYPE, token.IMPORT:
+			return false
+		default:
+			return true
+		}
+	default:
+		return false
+	}
+}

gnovm/pkg/coverage/analyze_test.go

@@ -0,0 +1,90 @@
+package coverage
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDetectExecutableLines(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name    string
+		content string
+		want    map[int]bool
+		wantErr bool
+	}{
+		{
+			name: "Simple function",
+			content: `
+package main
+
+func main() {
+	x := 5
+	if x > 3 {
+		println("Greater")
+	}
+}`,
+			want: map[int]bool{
+				5: true, // x := 5
+				6: true, // if x > 3
+				7: true, // println("Greater")
+			},
+			wantErr: false,
+		},
+		{
+			name: "Function with loop",
+			content: `
+package main
+
+func loopFunction() {
+	for i := 0; i < 5; i++ {
+		if i%2 == 0 {
+			continue
+		}
+		println(i)
+	}
+}`,
+			want: map[int]bool{
+				5: true, // for i := 0; i < 5; i++
+				6: true, // if i%2 == 0
+				7: true, // continue
+				9: true, // println(i)
+			},
+			wantErr: false,
+		},
+		{
+			name: "Only declarations",
+			content: `
+package main
+
+import "fmt"
+
+var x int
+
+type MyStruct struct {
+	field int
+}`,
+			want:    map[int]bool{},
+			wantErr: false,
+		},
+		{
+			name: "Invalid gno code",
+			content: `
+This is not valid Go code
+It should result in an error`,
+			want:    nil,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got, err := DetectExecutableLines(tt.content)
+			assert.Equal(t, tt.wantErr, err != nil)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

gnovm/pkg/coverage/coverage.go

@@ -0,0 +1,170 @@
+package coverage
+
+import (
+	"io"
+	"path/filepath"
+)
+
+// Collector defines the interface for collecting coverage data
+type Collector interface {
+	RecordHit(loc FileLocation)
+	SetExecutableLines(filePath string, lines map[int]bool)
+	AddFile(filePath string, totalLines int)
+}
+
+// Coverage implements the Collector interface and manages coverage data
+type Coverage struct {
+	enabled     bool
+	rootDir     string
+	currentPath string
+	currentFile string
+	files       fileCoverageMap
+	pathCache   pathCache
+}
+
+// FileCoverage stores coverage information for a single file
+type FileCoverage struct {
+	totalLines      int
+	hitLines        map[int]int
+	executableLines map[int]bool
+}
+
+type (
+	fileCoverageMap map[string]FileCoverage
+	pathCache       map[string]string
+)
+
+func (m fileCoverageMap) get(path string) (FileCoverage, bool) {
+	fc, ok := m[path]
+	return fc, ok
+}
+
+func (m fileCoverageMap) set(path string, fc FileCoverage) {
+	m[path] = fc
+}
+
+// NewFileCoverage creates a new FileCoverage instance
+func NewFileCoverage() FileCoverage {
+	return FileCoverage{
+		totalLines:      0,
+		hitLines:        make(map[int]int),
+		executableLines: make(map[int]bool),
+	}
+}
+
+// New creates a new Coverage instance
+func New(rootDir string) *Coverage {
+	return &Coverage{
+		rootDir:   rootDir,
+		files:     make(fileCoverageMap),
+		pathCache: make(pathCache),
+	}
+}
+
+// Configuration methods
+func (c *Coverage) Enabled() bool              { return c.enabled }
+func (c *Coverage) Enable()                    { c.enabled = true }
+func (c *Coverage) Disable()                   { c.enabled = false }
+func (c *Coverage) SetCurrentPath(path string) { c.currentPath = path }
+func (c *Coverage) CurrentPath() string        { return c.currentPath }
+func (c *Coverage) SetCurrentFile(file string) { c.currentFile = file }
+func (c *Coverage) CurrentFile() string        { return c.currentFile }
+
+// RecordHit implements Collector.RecordHit
+func (c *Coverage) RecordHit(loc FileLocation) {
+	if !c.enabled { return }
+
+	path := filepath.Join(loc.PkgPath, loc.File)
+	cov := c.getOrCreateFileCoverage(path)
+
+	if cov.executableLines[loc.Line] {
+		cov.hitLines[loc.Line]++
+		c.files.set(path, cov)
+	}
+}
+
+// SetExecutableLines implements Collector.SetExecutableLines
+func (c *Coverage) SetExecutableLines(filePath string, executableLines map[int]bool) {
+	cov, exists := c.files.get(filePath)
+	if !exists {
+		cov = NewFileCoverage()
+	}
+
+	cov.executableLines = executableLines
+	c.files.set(filePath, cov)
+}
+
+// AddFile implements Collector.AddFile
+func (c *Coverage) AddFile(filePath string, totalLines int) {
+	if IsTestFile(filePath) || !isValidFile(c.currentPath, filePath) {
+		return
+	}
+
+	cov, exists := c.files.get(filePath)
+	if !exists {
+		cov = NewFileCoverage()
+	}
+
+	cov.totalLines = totalLines
+	c.files.set(filePath, cov)
+}
+
+// Report generates a coverage report using the given options
+func (c *Coverage) Report(opts ReportOpts, w io.Writer) error {
+	reporter := NewReporter(c, opts)
+	if opts.pattern != "" {
+		return reporter.WriteFileDetail(w, opts.pattern, opts.showHits)
+	}
+	return reporter.Write(w)
+}
+
+// FileLocation represents a specific location in source code
+type FileLocation struct {
+	PkgPath string
+	File    string
+	Line    int
+	Column  int
+}
+
+// Helper methods
+func (c *Coverage) getOrCreateFileCoverage(filePath string) FileCoverage {
+	cov, exists := c.files.get(filePath)
+	if !exists {
+		cov = NewFileCoverage()
+	}
+	return cov
+}
+
+// GetStats returns coverage statistics for a file
+func (c *Coverage) GetStats(filePath string) (hits, total int, ok bool) {
+	cov, exists := c.files.get(filePath)
+	if !exists {
+		return 0, 0, false
+	}
+	return len(cov.hitLines), cov.totalLines, true
+}
+
+// GetFileHits returns the hit counts for a file (primarily for testing)
+func (c *Coverage) GetFileHits(filePath string) map[int]int {
+	if cov, exists := c.files.get(filePath); exists {
+		return cov.hitLines
+	}
+	return nil
+}
+
+// GetExecutableLines returns the executable lines for a file (primarily for testing)
+func (c *Coverage) GetExecutableLines(filePath string) map[int]bool {
+	if cov, exists := c.files.get(filePath); exists {
+		return cov.executableLines
+	}
+	return nil
+}
+
+// GetFiles returns a list of all tracked files
+func (c *Coverage) GetFiles() []string {
+	files := make([]string, 0, len(c.files))
+	for file := range c.files {
+		files = append(files, file)
+	}
+	return files
+}