feat(gnovm/cmd): printing all the errors from goparser (#2011)

<!-- please provide a detailed description of the changes made in this
pull request. -->
This PR aims to print all the errors that are found by the go/parser
package.
Currently the `parser.ParseFile` function returns an `scanner.ErrorList`
object that only prints the first error and a count of the remaining
errors. #1933 everything is better explained here.

**For the changes this PR introduces**:
- Create **issueWithError** function. This function will wrap the lines
of code that processed an error (before this PR changes) in order to
convert it on an **lintIssue** structure. This existent code applies a
regex to localize the parse error more precisely.
- The PR changes the behavior of run, test, and lint commands. Not they
exit with a non-zero status code as soon as we found some error while
parsing the files. This in order to not having the whole stacktrace for
some parsing file error, improving visibility.
- Add a new case on `gnovm/cmd/gno/lint.go.catchRuntimeError` to handle
and print all errors of an error with type `scanner.ErrorList`
- remove some wrapping during panic calls. This was done by simplicity
some of the calls were doing `panic(errors.Wrap(err, "parsing file
"+mfile.Name))` here err has the type scanner.ErrorList but as we're
wrapping it it would be more complex and difficult to read on
**catchRuntimeError** to identify an error with the type ErrorList

**Results:** (Using issue example)
- lint:
```cmd
-- NOW
./.: missing 'gno.mod' file (code=1).
test.gno:6: expected ';', found example (code=2).
test.gno:7: expected '}', found 'EOF' (code=2).
exit status 1

---- BEFORE
./.: missing 'gno.mod' file (code=1).
test.gno:6: expected ';', found example (and 1 more errors) (code=2).
```
- run:
```cmd
-- NOW
test.gno:6: expected ';', found example (code=2).
test.gno:7: expected '}', found 'EOF' (code=2).
exit status 1

---- BEFORE
panic: test.gno:6:5: expected ';', found example (and 1 more errors)

goroutine 1 [running]:
github.com/gnolang/gno/gnovm/pkg/gnolang.MustReadFile(...)
        /Users/miguel/gnorigin/gnovm/pkg/gnolang/go2gno.go:49
main.parseFiles({0x140003b1720, 0x1, 0x1400031fb48?})
        /Users/miguel/gnorigin/gnovm/cmd/gno/run.go:132 +0x27c
main.parseFiles({0x140003b09a0, 0x1, 0x0?})
        /Users/miguel/gnorigin/gnovm/cmd/gno/run.go:121 +0x158
main.execRun(0x14000373230, {0x140003b09a0, 0x1, 0x1}, {0x100ca3e68, 0x140003b3bd0})
        /Users/miguel/gnorigin/gnovm/cmd/gno/run.go:89 +0x174
main.newRunCmd.func1({0x0?, 0x1400019c140?}, {0x140003b09a0?, 0x0?, 0x0?})
        /Users/miguel/gnorigin/gnovm/cmd/gno/run.go:35 +0x3c
github.com/gnolang/gno/tm2/pkg/commands.(*Command).Run(0x1400031fdc8?, {0x100c9af18?, 0x101249700?})
        /Users/miguel/gnorigin/tm2/pkg/commands/command.go:247 +0x17c
github.com/gnolang/gno/tm2/pkg/commands.(*Command).Run(0x140003ae2c0?, {0x100c9af18?, 0x101249700?})
        /Users/miguel/gnorigin/tm2/pkg/commands/command.go:251 +0x12c
github.com/gnolang/gno/tm2/pkg/commands.(*Command).ParseAndRun(0x140003ae6e0?, {0x100c9af18, 0x101249700}, {0x1400019c130?, 0x140003ae790?, 0x140003ae840?})
        /Users/miguel/gnorigin/tm2/pkg/commands/command.go:132 +0x4c
github.com/gnolang/gno/tm2/pkg/commands.(*Command).Execute(0x100ca3e68?, {0x100c9af18?, 0x101249700?}, {0x1400019c130?, 0x1011a5ef8?, 0x140000021a0?})
        /Users/miguel/gnorigin/tm2/pkg/commands/command.go:114 +0x28
main.main()
        /Users/miguel/gnorigin/gnovm/cmd/gno/main.go:13 +0x6c
```
<details><summary>Contributors' checklist...</summary>

- [ ] Added new tests, or not needed, or not feasible
- [ ] Provided an example (e.g. screenshot) to aid review or the PR is
self-explanatory
- [ ] Updated the official documentation or not needed
- [ ] No breaking changes were made, or a `BREAKING CHANGE: xxx` message
was included in the description
- [ ] Added references to related issues and PRs
- [ ] Provided any useful hints for running manual tests
- [ ] Added new benchmarks to [generated
graphs](https://gnoland.github.io/benchmarks), if any. More info
[here](https://github.com/gnolang/gno/blob/master/.benchmarks/README.md).
</details>

Author: Villaquiranm

gnovm/cmd/gno/lint.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"go/scanner"
+	"io"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -68,10 +70,6 @@ func execLint(cfg *lintCfg, args []string, io commands.IO) error {
 	}
 
 	hasError := false
-	addIssue := func(issue lintIssue) {
-		hasError = true
-		fmt.Fprint(io.Err(), issue.String()+"\n")
-	}
 
 	for _, pkgPath := range pkgPaths {
 		if verbose {
@@ -81,16 +79,18 @@ func execLint(cfg *lintCfg, args []string, io commands.IO) error {
 		// Check if 'gno.mod' exists
 		gnoModPath := filepath.Join(pkgPath, "gno.mod")
 		if !osm.FileExists(gnoModPath) {
-			addIssue(lintIssue{
+			hasError = true
+			issue := lintIssue{
 				Code:       lintNoGnoMod,
 				Confidence: 1,
 				Location:   pkgPath,
 				Msg:        "missing 'gno.mod' file",
-			})
+			}
+			fmt.Fprint(io.Err(), issue.String()+"\n")
 		}
 
 		// Handle runtime errors
-		catchRuntimeError(pkgPath, addIssue, func() {
+		hasError = catchRuntimeError(pkgPath, io.Err(), func() {
 			stdout, stdin, stderr := io.Out(), io.In(), io.Err()
 			testStore := tests.TestStore(
 				rootDir, "",
@@ -130,7 +130,7 @@ func execLint(cfg *lintCfg, args []string, io commands.IO) error {
 			}
 
 			tm.RunFiles(testfiles.Files...)
-		})
+		}) || hasError
 
 		// TODO: Add more checkers
 	}
@@ -164,47 +164,33 @@ func guessSourcePath(pkg, source string) string {
 // XXX: Ideally, error handling should encapsulate location details within a dedicated error type.
 var reParseRecover = regexp.MustCompile(`^([^:]+):(\d+)(?::\d+)?:? *(.*)$`)
 
-func catchRuntimeError(pkgPath string, addIssue func(issue lintIssue), action func()) {
+func catchRuntimeError(pkgPath string, stderr io.WriteCloser, action func()) (hasError bool) {
 	defer func() {
 		// Errors catched here mostly come from: gnovm/pkg/gnolang/preprocess.go
 		r := recover()
 		if r == nil {
 			return
 		}
-
-		var err error
+		hasError = true
 		switch verr := r.(type) {
 		case *gno.PreprocessError:
-			err = verr.Unwrap()
+			err := verr.Unwrap()
+			fmt.Fprint(stderr, issueFromError(pkgPath, err).String()+"\n")
+		case scanner.ErrorList:
+			for _, err := range verr {
+				fmt.Fprint(stderr, issueFromError(pkgPath, err).String()+"\n")
+			}
 		case error:
-			err = verr
+			fmt.Fprint(stderr, issueFromError(pkgPath, verr).String()+"\n")
 		case string:
-			err = errors.New(verr)
+			fmt.Fprint(stderr, issueFromError(pkgPath, errors.New(verr)).String()+"\n")
 		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 {
-			sourcepath := guessSourcePath(pkgPath, matches[1])
-			issue.Location = fmt.Sprintf("%s:%s", sourcepath, matches[2])
-			issue.Msg = strings.TrimSpace(matches[3])
-		} else {
-			issue.Location = fmt.Sprintf("%s:0", filepath.Clean(pkgPath))
-			issue.Msg = err.Error()
-		}
-
-		addIssue(issue)
 	}()
 
 	action()
+	return
 }
 
 type lintCode int
@@ -229,3 +215,23 @@ func (i lintIssue) String() string {
 	// TODO: consider crafting a doc URL based on Code.
 	return fmt.Sprintf("%s: %s (code=%d).", i.Location, i.Msg, i.Code)
 }
+
+func issueFromError(pkgPath string, err error) lintIssue {
+	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 {
+		sourcepath := guessSourcePath(pkgPath, matches[1])
+		issue.Location = fmt.Sprintf("%s:%s", sourcepath, matches[2])
+		issue.Msg = strings.TrimSpace(matches[3])
+	} else {
+		issue.Location = fmt.Sprintf("%s:0", filepath.Clean(pkgPath))
+		issue.Msg = err.Error()
+	}
+	return issue
+}

gnovm/cmd/gno/lint_test.go

@@ -16,6 +16,9 @@ func TestLintApp(t *testing.T) {
 		}, {
 			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/several-lint-errors/main.gno"},
+			stderrShouldContain: "../../tests/integ/several-lint-errors/main.gno:5: expected ';', found example (code=2).\n../../tests/integ/several-lint-errors/main.gno:6",
 		}, {
 			args:                []string{"lint", "--set-exit-status=0", "../../tests/integ/run_main/"},
 			stderrShouldContain: "./../../tests/integ/run_main: missing 'gno.mod' file (code=1).",

gnovm/cmd/gno/run.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"strings"
@@ -102,7 +103,7 @@ func execRun(cfg *runCfg, args []string, io commands.IO) error {
 	}
 
 	// read files
-	files, err := parseFiles(args)
+	files, err := parseFiles(args, stderr)
 	if err != nil {
 		return err
 	}
@@ -135,15 +136,16 @@ func execRun(cfg *runCfg, args []string, io commands.IO) error {
 	return nil
 }
 
-func parseFiles(fnames []string) ([]*gno.FileNode, error) {
+func parseFiles(fnames []string, stderr io.WriteCloser) ([]*gno.FileNode, error) {
 	files := make([]*gno.FileNode, 0, len(fnames))
+	var hasError bool
 	for _, fname := range fnames {
 		if s, err := os.Stat(fname); err == nil && s.IsDir() {
 			subFns, err := listNonTestFiles(fname)
 			if err != nil {
 				return nil, err
 			}
-			subFiles, err := parseFiles(subFns)
+			subFiles, err := parseFiles(subFns, stderr)
 			if err != nil {
 				return nil, err
 			}
@@ -154,7 +156,14 @@ func parseFiles(fnames []string) ([]*gno.FileNode, error) {
 			// in either case not a file we can parse.
 			return nil, err
 		}
-		files = append(files, gno.MustReadFile(fname))
+
+		hasError = catchRuntimeError(fname, stderr, func() {
+			files = append(files, gno.MustReadFile(fname))
+		})
+	}
+
+	if hasError {
+		os.Exit(1)
 	}
 	return files, nil
 }

gnovm/cmd/gno/test.go

@@ -325,7 +325,15 @@ func gnoTestPkg(
 		memPkg := gno.ReadMemPackage(pkgPath, gnoPkgPath)
 
 		// tfiles, ifiles := gno.ParseMemPackageTests(memPkg)
-		tfiles, ifiles := parseMemPackageTests(memPkg)
+		var tfiles, ifiles *gno.FileSet
+
+		hasError := catchRuntimeError(gnoPkgPath, stderr, func() {
+			tfiles, ifiles = parseMemPackageTests(memPkg)
+		})
+
+		if hasError {
+			os.Exit(1)
+		}
 		testPkgName := getPkgNameFromFileset(ifiles)
 
 		// run test files in pkg
@@ -639,7 +647,7 @@ func parseMemPackageTests(memPkg *std.MemPackage) (tset, itset *gno.FileSet) {
 		}
 		n, err := gno.ParseFile(mfile.Name, mfile.Body)
 		if err != nil {
-			panic(errors.Wrap(err, "parsing file "+mfile.Name))
+			panic(err)
 		}
 		if n == nil {
 			panic("should not happen")

gnovm/pkg/gnolang/nodes.go

@@ -1179,7 +1179,7 @@ func ParseMemPackage(memPkg *std.MemPackage) (fset *FileSet) {
 		}
 		n, err := ParseFile(mfile.Name, mfile.Body)
 		if err != nil {
-			panic(errors.Wrap(err, "parsing file "+mfile.Name))
+			panic(err)
 		}
 		if memPkg.Name != string(n.PkgName) {
 			panic(fmt.Sprintf(

gnovm/tests/integ/several-lint-errors/gno.mod

@@ -0,0 +1 @@
+module gno.land/tests/severalerrors

gnovm/tests/integ/several-lint-errors/main.gno

@@ -0,0 +1,6 @@
+package main
+
+func main() {
+	for {
+		_ example
+}