feat(cmd/gno): perform type checking when calling linter

examples/Makefile

@@ -44,7 +44,7 @@ test:
 
 .PHONY: lint
 lint:
-	go run ../gnovm/cmd/gno lint $(OFFICIAL_PACKAGES)
+	go run ../gnovm/cmd/gno lint -v $(OFFICIAL_PACKAGES)
 
 .PHONY: test.sync
 test.sync:

examples/gno.land/r/demo/art/gnoface/gno.mod

@@ -1,3 +1,5 @@
+// Draft
+
 module gno.land/r/demo/art/gnoface
 
 require (

gnovm/cmd/gno/lint.go

@@ -6,6 +6,7 @@
 	"flag"
 	"fmt"
 	"go/scanner"
+	"go/types"
 	"io"
 	"os"
 	"path/filepath"
@@ -14,9 +15,11 @@
 
 	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
+	"github.com/gnolang/gno/gnovm/pkg/gnomod"
 	"github.com/gnolang/gno/gnovm/tests"
 	"github.com/gnolang/gno/tm2/pkg/commands"
-	osm "github.com/gnolang/gno/tm2/pkg/os"
+	"github.com/gnolang/gno/tm2/pkg/std"
+	"go.uber.org/multierr"
 )
 
 type lintCfg struct {
@@ -49,6 +52,31 @@
 	fs.StringVar(&c.rootDir, "root-dir", rootdir, "clone location of github.com/gnolang/gno (gno tries to guess it)")
 }
 
+type lintCode int
+
+const (
+	lintUnknown lintCode = iota
+	lintGnoMod
+	lintGnoError
+	lintParserError
+	lintTypeCheckError
+
+	// TODO: add new linter codes here.
+)
+
+type lintIssue struct {
+	Code       lintCode
+	Msg        string
+	Confidence float64 // 1 is 100%
+	Location   string  // file:line, or equivalent
+	// TODO: consider writing fix suggestions
+}
+
+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 execLint(cfg *lintCfg, args []string, io commands.IO) error {
 	if len(args) < 1 {
 		return flag.ErrHelp
@@ -71,66 +99,62 @@
 
 	for _, pkgPath := range pkgPaths {
 		if verbose {
-			fmt.Fprintf(io.Err(), "Linting %q...\n", pkgPath)
+			io.ErrPrintln(pkgPath)
+		}
+
+		info, err := os.Stat(pkgPath)
+		if err == nil && !info.IsDir() {
+			pkgPath = filepath.Dir(pkgPath)
 		}
 
 		// Check if 'gno.mod' exists
-		gnoModPath := filepath.Join(pkgPath, "gno.mod")
-		if !osm.FileExists(gnoModPath) {
-			hasError = true
+		gmFile, err := gnomod.ParseAt(pkgPath)
+		if err != nil {
 			issue := lintIssue{
-				Code:       lintNoGnoMod,
+				Code:       lintGnoMod,
 				Confidence: 1,
 				Location:   pkgPath,
-				Msg:        "missing 'gno.mod' file",
+				Msg:        err.Error(),
 			}
-			fmt.Fprint(io.Err(), issue.String()+"\n")
+			io.ErrPrintln(issue)
+			hasError = true
 		}
 
 		// Handle runtime errors
 		hasError = catchRuntimeError(pkgPath, io.Err(), 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(pkgPath, pkgPath)
+
+			// Run type checking
+			if gmFile == nil || !gmFile.Draft {
+				foundErr, err := lintTypeCheck(io, memPkg, testStore)
+				if err != nil {
+					io.ErrPrintln(err)
+					hasError = true
+				} else {
+					hasError = foundErr || hasError
+				}
+			} else if verbose {
+				io.ErrPrintfln("%s: module is draft, skipping type check\n", 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
-				}
+			testFiles := lintTestFiles(memPkg)
 
-				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...)
+			tm.RunFiles(testFiles.Files...)
 		}) || hasError
-
-		// TODO: Add more checkers
 	}
 
 	if hasError {
@@ -140,6 +164,67 @@
 	return nil
 }
 
+func lintTypeCheck(io commands.IO, memPkg *std.MemPackage, testStore gno.Store) (errorsFound bool, err error) {
+	tcErr := gno.TypeCheckMemPackageTest(memPkg, testStore)
+	if tcErr == nil {
+		return false, nil
+	}
+
+	errs := multierr.Errors(tcErr)
+	for _, err := range errs {
+		switch err := err.(type) {
+		case types.Error:
+			io.ErrPrintln(lintIssue{
+				Code:       lintTypeCheckError,
+				Msg:        err.Msg,
+				Confidence: 1,
+				Location:   err.Fset.Position(err.Pos).String(),
+			})
+		case scanner.ErrorList:
+			for _, scErr := range err {
+				io.ErrPrintln(lintIssue{
+					Code:       lintParserError,
+					Msg:        scErr.Msg,
+					Confidence: 1,
+					Location:   scErr.Pos.String(),
+				})
+			}
+		case scanner.Error:
+			io.ErrPrintln(lintIssue{
+				Code:       lintParserError,
+				Msg:        err.Msg,
+				Confidence: 1,
+				Location:   err.Pos.String(),
+			})
+		default:
+			//nolint
+			return false, fmt.Errorf("unexpected error type: %T", err)
+		}
+	}
+	return true, nil
+}
+
+func lintTestFiles(memPkg *std.MemPackage) *gno.FileSet {
+	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)
+		}
+	}
+	return testfiles
+}
+
 func guessSourcePath(pkg, source string) string {
 	if info, err := os.Stat(pkg); !os.IsNotExist(err) && !info.IsDir() {
 		pkg = filepath.Dir(pkg)
@@ -191,29 +276,6 @@
 	return
 }
 
-type lintCode int
-
-const (
-	lintUnknown  lintCode = 0
-	lintNoGnoMod lintCode = iota
-	lintGnoError
-
-	// TODO: add new linter codes here.
-)
-
-type lintIssue struct {
-	Code       lintCode
-	Msg        string
-	Confidence float64 // 1 is 100%
-	Location   string  // file:line, or equivalent
-	// TODO: consider writing fix suggestions
-}
-
-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

gnovm/cmd/gno/lint_test.go

@@ -9,7 +9,7 @@ func TestLintApp(t *testing.T) {
 			errShouldBe: "flag: help requested",
 		}, {
 			args:                []string{"lint", "../../tests/integ/run_main/"},
-			stderrShouldContain: "./../../tests/integ/run_main: missing 'gno.mod' file (code=1).",
+			stderrShouldContain: "./../../tests/integ/run_main: gno.mod file not found in current or any parent directory (code=1).",
 			errShouldBe:         "exit code: 1",
 		}, {
 			args:                []string{"lint", "../../tests/integ/undefined_variable_test/undefined_variables_test.gno"},
@@ -23,23 +23,25 @@ func TestLintApp(t *testing.T) {
 			args:                []string{"lint", "../../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",
 			errShouldBe:         "exit code: 1",
-		}, {
-			args:                []string{"lint", "../../tests/integ/run_main/"},
-			stderrShouldContain: "./../../tests/integ/run_main: missing 'gno.mod' file (code=1).",
-			errShouldBe:         "exit code: 1",
 		}, {
 			args: []string{"lint", "../../tests/integ/minimalist_gnomod/"},
 			// TODO: raise an error because there is a gno.mod, but no .gno files
 		}, {
 			args: []string{"lint", "../../tests/integ/invalid_module_name/"},
 			// TODO: raise an error because gno.mod is invalid
+		}, {
+			args:                []string{"lint", "../../tests/integ/invalid_gno_file/"},
+			stderrShouldContain: "../../tests/integ/invalid_gno_file/invalid.gno:1: expected 'package', found packag (code=2).",
+			errShouldBe:         "exit code: 1",
+		}, {
+			args:                []string{"lint", "../../tests/integ/typecheck_missing_return/"},
+			stderrShouldContain: "../../tests/integ/typecheck_missing_return/main.gno:5:1: missing return (code=4).",
+			errShouldBe:         "exit code: 1",
 		},
 
 		// TODO: 'gno mod' is valid?
-		// TODO: is gno source valid?
 		// TODO: are dependencies valid?
 		// TODO: is gno source using unsafe/discouraged features?
-		// TODO: consider making `gno transpile; go lint *gen.go`
 		// TODO: check for imports of native libs from non _test.gno files
 	}
 	testMainCaseRun(t, tc)

gnovm/cmd/gno/scripts_test.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"testing"
+
+	"github.com/gnolang/gno/gnovm/pkg/integration"
+	"github.com/rogpeppe/go-internal/testscript"
+	"github.com/stretchr/testify/require"
+)
+
+func TestScript(t *testing.T) {
+	updateScripts, _ := strconv.ParseBool(os.Getenv("UPDATE_SCRIPTS"))
+	dirs, err := os.ReadDir("testdata")
+	require.NoError(t, err)
+	for _, dir := range dirs {
+		t.Run(dir.Name(), func(t *testing.T) {
+			p := testscript.Params{
+				UpdateScripts: updateScripts,
+				Dir:           filepath.Join("testdata", dir.Name()),
+			}
+
+			if coverdir, ok := integration.ResolveCoverageDir(); ok {
+				err := integration.SetupTestscriptsCoverage(&p, coverdir)
+				require.NoError(t, err)
+			}
+
+			err := integration.SetupGno(&p, t.TempDir())
+			require.NoError(t, err)
+
+			testscript.Run(t, p)
+		})
+	}
+}