feat: improve gno linter with basic errors support

gnovm/cmd/gno/lint.go

@@ -2,12 +2,17 @@
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
+	"strings"
 
 	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
+	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
+	"github.com/gnolang/gno/gnovm/tests"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 	osm "github.com/gnolang/gno/tm2/pkg/os"
 )
@@ -71,7 +76,7 @@
 			fmt.Fprintf(io.Err(), "Linting %q...\n", pkgPath)
 		}
 
-		// 'gno.mod' exists?
+		// Check if 'gno.mod' exists
 		gnoModPath := filepath.Join(pkgPath, "gno.mod")
 		if !osm.FileExists(gnoModPath) {
 			addIssue(lintIssue{
@@ -82,20 +87,110 @@
 			})
 		}
 
-		// TODO: add more checkers
+		// Handle runtime errors
+		catchRuntimeError(pkgPath, addIssue, func() {
+			stdout, stdin, stderr := io.Out(), io.In(), io.Err()
+			testStore := tests.TestStore(
+				rootDir, "",
+				stdin, stdout, stderr,
+				tests.ImportModeStdlibsOnly,
+			)
+
+			targetPath := pkgPath
+			info, err := os.Stat(pkgPath)
+			if err == nil && !info.IsDir() {
+				targetPath = filepath.Dir(pkgPath)
+			}
+
+			memPkg := gno.ReadMemPackage(targetPath, targetPath)
+			tm := tests.TestMachine(testStore, stdout, memPkg.Name)
+
+			// Check package
+			tm.RunMemPackage(memPkg, true)
+
+			// Check test files
+			testfiles := &gno.FileSet{}
+			for _, mfile := range memPkg.Files {
+				if !strings.HasSuffix(mfile.Name, ".gno") {
+					continue // Skip non-GNO files
+				}
+
+				n, _ := gno.ParseFile(mfile.Name, mfile.Body)
+				if n == nil {
+					continue // Skip empty files
+				}
+
+				// XXX: package ending with `_test` is not supported yet
+				if strings.HasSuffix(mfile.Name, "_test.gno") && !strings.HasSuffix(string(n.PkgName), "_test") {
+					// Keep only test files
+					testfiles.AddFiles(n)
+				}
+			}
+
+			tm.RunFiles(testfiles.Files...)
+		})
+
+		// TODO: Add more checkers
 	}
 
 	if hasError && cfg.setExitStatus != 0 {
 		os.Exit(cfg.setExitStatus)
 	}
+
 	return nil
 }
 
+var reParseRecover = regexp.MustCompile(`^(.+):(\d+): ?(.*)$`)
+
+func catchRuntimeError(pkgPath string, addIssue func(issue lintIssue), action func()) {
+	defer func() {
+		// Errors catched here mostly come from: gnovm/pkg/gnolang/preprocess.go
+		r := recover()
+		if r == nil {
+			return
+		}
+
+		var err error
+		switch verr := r.(type) {
+		case *gno.PreprocessError:
+			err = verr.Unwrap()
+		case error:
+			err = verr
+		case string:
+			err = errors.New(verr)
+		default:
+			panic(r)
+		}
+
+		var issue lintIssue
+		issue.Confidence = 1
+		issue.Code = lintGnoError
+
+		parsedError := strings.TrimSpace(err.Error())
+		parsedError = strings.TrimPrefix(parsedError, pkgPath+"/")
+
+		matches := reParseRecover.FindStringSubmatch(parsedError)
+		if len(matches) == 4 {
+			issue.Location = fmt.Sprintf("%s:%s", matches[1], matches[2])
+			issue.Msg = strings.TrimSpace(matches[3])
+		} else {
+			issue.Location = fmt.Sprintf("%s:0", parsedError)
+			issue.Msg = err.Error()
+		}
+
+		addIssue(issue)
+	}()
+
+	action()
+}
+
 type lintCode int
 
 const (
 	lintUnknown  lintCode = 0
 	lintNoGnoMod lintCode = iota
+	lintGnoError
+
 	// TODO: add new linter codes here.
 )
 

gnovm/cmd/gno/lint_test.go

@@ -10,6 +10,12 @@ func TestLintApp(t *testing.T) {
 		}, {
 			args:                []string{"lint", "--set-exit-status=0", "../../tests/integ/run-main/"},
 			stderrShouldContain: "./../../tests/integ/run-main: missing 'gno.mod' file (code=1).",
+		}, {
+			args:                []string{"lint", "--set-exit-status=0", "../../tests/integ/undefined-variable-test/undefined_variables_test.gno"},
+			stderrShouldContain: "undefined_variables_test.gno:6: name toto not declared (code=2)",
+		}, {
+			args:                []string{"lint", "--set-exit-status=0", "../../tests/integ/package-not-declared/main.gno"},
+			stderrShouldContain: "main.gno:4: name fmt not declared (code=2).",
 		}, {
 			args:                []string{"lint", "--set-exit-status=0", "../../tests/integ/run-main/"},
 			stderrShouldContain: "./../../tests/integ/run-main: missing 'gno.mod' file (code=1).",
@@ -20,6 +26,7 @@ func TestLintApp(t *testing.T) {
 			args: []string{"lint", "--set-exit-status=0", "../../tests/integ/invalid-module-name/"},
 			// TODO: raise an error because gno.mod is invalid
 		},
+
 		// TODO: 'gno mod' is valid?
 		// TODO: is gno source valid?
 		// TODO: are dependencies valid?

gnovm/cmd/gno/run_test.go

@@ -63,6 +63,10 @@ func TestRunApp(t *testing.T) {
 			args:                []string{"run", "-expr", "WithArg(-255)", "../../tests/integ/run-package"},
 			stdoutShouldContain: "out of range!",
 		},
+		{
+			args:                 []string{"run", "../../tests/integ/undefined-variable-test/undefined_variables_test.gno"},
+			recoverShouldContain: "--- preprocess stack ---", // should contain preprocess debug stack trace
+		},
 		// TODO: a test file
 		// TODO: args
 		// TODO: nativeLibs VS stdlibs

gnovm/cmd/gno/test_test.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"os"
+	"strconv"
 	"testing"
 
 	"github.com/gnolang/gno/gnovm/pkg/integration"
@@ -9,8 +11,10 @@ import (
 )
 
 func Test_ScriptsTest(t *testing.T) {
+	updateScripts, _ := strconv.ParseBool(os.Getenv("UPDATE_SCRIPTS"))
 	p := testscript.Params{
-		Dir: "testdata/gno_test",
+		UpdateScripts: updateScripts,
+		Dir:           "testdata/gno_test",
 	}
 
 	if coverdir, ok := integration.ResolveCoverageDir(); ok {

gnovm/cmd/gno/testdata/gno_test/lint_bad_import.txtar

@@ -0,0 +1,19 @@
+# testing gno lint command: bad import error
+
+! gno lint ./bad_file.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- bad_file.gno --
+package main
+
+import "python"
+
+func main() {
+	fmt.Println("Hello", 42)
+}
+
+-- stdout.golden --
+-- stderr.golden --
+./bad_file.gno:1: unknown import path python (code=2).

gnovm/cmd/gno/testdata/gno_test/lint_file_error.txtar

@@ -0,0 +1,20 @@
+# gno lint: test file error
+
+! gno lint ./i_have_error_test.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- i_have_error_test.gno --
+package main
+
+import "fmt"
+
+func TestIHaveSomeError() {
+	i := undefined_variable
+	fmt.Println("Hello", 42)
+}
+
+-- stdout.golden --
+-- stderr.golden --
+./i_have_error_test.gno:6: name undefined_variable not declared (code=2).

gnovm/cmd/gno/testdata/gno_test/lint_file_error_txtar

@@ -0,0 +1,20 @@
+# gno lint: test file error
+
+! gno lint ./i_have_error_test.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- i_have_error_test.gno --
+package main
+
+import "fmt"
+
+func TestIHaveSomeError() {
+	i := undefined_variable
+	fmt.Println("Hello", 42)
+}
+
+-- stdout.golden --
+-- stderr.golden --
+i_have_error_test.gno:6: name undefined_variable not declared (code=2).

gnovm/cmd/gno/testdata/gno_test/lint_no_error.txtar

@@ -0,0 +1,18 @@
+# testing simple gno lint command with any error
+
+gno lint ./good_file.gno 
+
+cmp stdout stdout.golden
+cmp stdout stderr.golden
+
+-- good_file.gno --
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello", 42)
+}
+
+-- stdout.golden --
+-- stderr.golden --

gnovm/cmd/gno/testdata/gno_test/lint_no_gnomod.txtar

@@ -0,0 +1,19 @@
+# gno lint: no gnomod
+
+! gno lint .
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- good_file.gno --
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello", 42)
+}
+
+-- stdout.golden --
+-- stderr.golden --
+./.: missing 'gno.mod' file (code=1).

gnovm/cmd/gno/testdata/gno_test/lint_not_declared.txtar

@@ -0,0 +1,20 @@
+# testing gno lint command: not declared error
+
+! gno lint ./bad_file.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- bad_file.gno --
+package main
+
+import "fmt"
+
+func main() {
+  hello.Foo()
+	fmt.Println("Hello", 42)
+}
+
+-- stdout.golden --
+-- stderr.golden --
+./bad_file.gno:6: name hello not declared (code=2).

gnovm/pkg/gnolang/debug.go

@@ -4,6 +4,7 @@
 	"fmt"
 	"net/http"
 	"os"
+	"strings"
 	"time"
 
 	// Ignore pprof import, as the server does not
@@ -76,6 +77,40 @@
 	}
 }
 
+// PreprocessError wraps a processing error along with its associated
+// preprocessing stack for enhanced error reporting.
+type PreprocessError struct {
+	err   error
+	stack []BlockNode
+}
+
+// Unwrap returns the encapsulated error message.
+func (p *PreprocessError) Unwrap() error {
+	return p.err
+}
+
+// Stack produces a string representation of the preprocessing stack
+// trace that was associated with the error occurrence.
+func (p *PreprocessError) Stack() string {
+	var stacktrace strings.Builder
+	for i := len(p.stack) - 1; i >= 0; i-- {
+		sbn := p.stack[i]
+		fmt.Fprintf(&stacktrace, "stack %d: %s\n", i, sbn.String())
+	}
+	return stacktrace.String()
+}
+
+// Error consolidates and returns the full error message, including
+// the actual error followed by its associated preprocessing stack.
+func (p *PreprocessError) Error() string {
+	var err strings.Builder
+	fmt.Fprintf(&err, "%s:\n", p.Unwrap())
+	fmt.Fprintln(&err, "--- preprocess stack ---")
+	fmt.Fprint(&err, p.Stack())
+	fmt.Fprintf(&err, "------------------------")
+	return err.String()
+}
+
 // ----------------------------------------
 // Exposed errors accessors
 // File tests may access debug errors.

gnovm/pkg/gnolang/preprocess.go

@@ -154,24 +154,27 @@
 
 		defer func() {
 			if r := recover(); r != nil {
-				fmt.Println("--- preprocess stack ---")
-				for i := len(stack) - 1; i >= 0; i-- {
-					sbn := stack[i]
-					fmt.Printf("stack %d: %s\n", i, sbn.String())
-				}
-				fmt.Println("------------------------")
 				// before re-throwing the error, append location information to message.
 				loc := last.GetLocation()
 				if nline := n.GetLine(); nline > 0 {
 					loc.Line = nline
 				}
-				if rerr, ok := r.(error); ok {
+
+				var err error
+				rerr, ok := r.(error)
+				if ok {
 					// NOTE: gotuna/gorilla expects error exceptions.
-					panic(errors.Wrap(rerr, loc.String()))
+					err = errors.Wrap(rerr, loc.String())
 				} else {
 					// NOTE: gotuna/gorilla expects error exceptions.
-					panic(errors.New(fmt.Sprintf("%s: %v", loc.String(), r)))
+					err = errors.New(fmt.Sprintf("%s: %v", loc.String(), r))
 				}
+
+				// Re-throw the error after wrapping it with the preprocessing stack information.
+				panic(&PreprocessError{
+					err:   err,
+					stack: stack,
+				})
 			}
 		}()
 		if debug {