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

examples/Makefile

@@ -23,7 +23,7 @@ test:
 
 .PHONY: lint
 lint:
-	go run ../gnovm/cmd/gno lint $(OFFICIAL_PACKAGES)
+	go run ../gnovm/cmd/gno lint --verbose $(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 (

gno.land/cmd/gnoland/testdata/addpkg.txtar

@@ -3,7 +3,7 @@
 ## start a new node
 gnoland start
 
-## add bar.gno package located in $WORK directory as gno.land/r/foobar/bar
+## add bar package located in $WORK directory as gno.land/r/foobar/bar
 gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/foobar/bar -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
 
 ## execute Render

gno.land/cmd/gnoland/testdata/addpkg_invalid.txtar

@@ -0,0 +1,21 @@
+# test for add package; ensuring type checker catches invalid code.
+
+# start a new node
+gnoland start
+
+# add bar package located in $WORK directory as gno.land/r/foobar/bar
+! gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/foobar/bar -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+
+# compare render
+! stdout .+
+stderr 'as string value in return statement'
+stderr '"std" imported and not used'
+
+-- bar.gno --
+package bar
+
+import "std"
+
+func Render(path string) string {
+ 	return 89
+}

gno.land/pkg/gnoclient/client_txs.go

@@ -2,7 +2,6 @@ package gnoclient
 
 import (
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
-	"github.com/gnolang/gno/gnovm/pkg/transpiler"
 	"github.com/gnolang/gno/tm2/pkg/amino"
 	ctypes "github.com/gnolang/gno/tm2/pkg/bft/rpc/core/types"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
@@ -138,11 +137,6 @@ func (c *Client) Run(cfg BaseTxCfg, msgs ...MsgRun) (*ctypes.ResultBroadcastTxCo
 
 		caller := c.Signer.Info().GetAddress()
 
-		// Transpile and validate Gno syntax
-		if err = transpiler.TranspileAndCheckMempkg(msg.Package); err != nil {
-			return nil, err
-		}
-
 		msg.Package.Name = "main"
 		msg.Package.Path = ""
 

gno.land/pkg/gnoclient/integration_test.go

@@ -239,7 +239,6 @@ func TestRunSingle_Integration(t *testing.T) {
 
 	fileBody := `package main
 import (
-	"std"
 	"gno.land/p/demo/ufmt"
 	"gno.land/r/demo/tests"
 )
@@ -297,7 +296,6 @@ func TestRunMultiple_Integration(t *testing.T) {
 
 	fileBody1 := `package main
 import (
-	"std"
 	"gno.land/p/demo/ufmt"
 	"gno.land/r/demo/tests"
 )
@@ -311,7 +309,6 @@ func main() {
 
 	fileBody2 := `package main
 import (
-	"std"
 	"gno.land/p/demo/ufmt"
 	"gno.land/r/demo/deep/very/deep"
 )

gno.land/pkg/keyscli/addpkg.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
-	"github.com/gnolang/gno/gnovm/pkg/transpiler"
 	"github.com/gnolang/gno/tm2/pkg/amino"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
@@ -102,12 +101,6 @@ func execMakeAddPkg(cfg *MakeAddPkgCfg, args []string, io commands.IO) error {
 		panic(fmt.Sprintf("found an empty package %q", cfg.PkgPath))
 	}
 
-	// transpile and validate syntax
-	err = transpiler.TranspileAndCheckMempkg(memPkg)
-	if err != nil {
-		panic(err)
-	}
-
 	// parse gas wanted & fee.
 	gaswanted := cfg.RootCfg.GasWanted
 	gasfee, err := std.ParseCoin(cfg.RootCfg.GasFee)

gno.land/pkg/keyscli/run.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
-	"github.com/gnolang/gno/gnovm/pkg/transpiler"
 	"github.com/gnolang/gno/tm2/pkg/amino"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
@@ -109,11 +108,7 @@ func execMakeRun(cfg *MakeRunCfg, args []string, cmdio commands.IO) error {
 	if memPkg.IsEmpty() {
 		panic(fmt.Sprintf("found an empty package %q", memPkg.Path))
 	}
-	// transpile and validate syntax
-	err = transpiler.TranspileAndCheckMempkg(memPkg)
-	if err != nil {
-		panic(err)
-	}
+
 	memPkg.Name = "main"
 	// Set to empty; this will be automatically set by the VM keeper.
 	memPkg.Path = ""

gno.land/pkg/sdk/vm/builtins.go

@@ -16,7 +16,7 @@ func (vm *VMKeeper) initBuiltinPackagesAndTypes(store gno.Store) {
 	// NOTE: native functions/methods added here must be quick operations,
 	// or account for gas before operation.
 	// TODO: define criteria for inclusion, and solve gas calculations.
-	getPackage := func(pkgPath string) (pn *gno.PackageNode, pv *gno.PackageValue) {
+	getPackage := func(pkgPath string, newStore gno.Store) (pn *gno.PackageNode, pv *gno.PackageValue) {
 		// otherwise, built-in package value.
 		// first, load from filepath.
 		stdlibPath := filepath.Join(vm.stdlibsDir, pkgPath)
@@ -34,14 +34,13 @@ func (vm *VMKeeper) initBuiltinPackagesAndTypes(store gno.Store) {
 			PkgPath: "gno.land/r/stdlibs/" + pkgPath,
 			// PkgPath: pkgPath,
 			Output: os.Stdout,
-			Store:  store,
+			Store:  newStore,
 		})
 		defer m2.Release()
 		return m2.RunMemPackage(memPkg, true)
 	}
 	store.SetPackageGetter(getPackage)
 	store.SetNativeStore(stdlibs.NativeStore)
-	stdlibs.InjectNativeMappings(store)
 }
 
 // ----------------------------------------

gno.land/pkg/sdk/vm/errors.go

@@ -1,6 +1,11 @@
 package vm
 
-import "github.com/gnolang/gno/tm2/pkg/errors"
+import (
+	"strings"
+
+	"github.com/gnolang/gno/tm2/pkg/errors"
+	"go.uber.org/multierr"
+)
 
 // for convenience:
 type abciError struct{}
@@ -13,11 +18,21 @@ type (
 	InvalidPkgPathError struct{ abciError }
 	InvalidStmtError    struct{ abciError }
 	InvalidExprError    struct{ abciError }
+	TypeCheckError      struct {
+		abciError
+		Errors []string
+	}
 )
 
 func (e InvalidPkgPathError) Error() string { return "invalid package path" }
 func (e InvalidStmtError) Error() string    { return "invalid statement" }
 func (e InvalidExprError) Error() string    { return "invalid expression" }
+func (e TypeCheckError) Error() string {
+	var bld strings.Builder
+	bld.WriteString("invalid gno package; type check errors:\n")
+	bld.WriteString(strings.Join(e.Errors, "\n"))
+	return bld.String()
+}
 
 func ErrInvalidPkgPath(msg string) error {
 	return errors.Wrap(InvalidPkgPathError{}, msg)
@@ -30,3 +45,12 @@ func ErrInvalidStmt(msg string) error {
 func ErrInvalidExpr(msg string) error {
 	return errors.Wrap(InvalidExprError{}, msg)
 }
+
+func ErrTypeCheck(err error) error {
+	var tce TypeCheckError
+	errs := multierr.Errors(err)
+	for _, err := range errs {
+		tce.Errors = append(tce.Errors, err.Error())
+	}
+	return errors.NewWithData(tce).Stacktrace()
+}

gno.land/pkg/sdk/vm/keeper.go

@@ -160,6 +160,11 @@ func (vm *VMKeeper) AddPackage(ctx sdk.Context, msg MsgAddPackage) error {
 		return ErrInvalidPkgPath("reserved package name: " + pkgPath)
 	}
 
+	// Validate Gno syntax and type check.
+	if err := gno.TypeCheckMemPackage(memPkg, store); err != nil {
+		return ErrTypeCheck(err)
+	}
+
 	// Pay deposit from creator.
 	pkgAddr := gno.DerivePkgAddr(pkgPath)
 
@@ -317,6 +322,11 @@ func (vm *VMKeeper) Run(ctx sdk.Context, msg MsgRun) (res string, err error) {
 		return "", ErrInvalidPkgPath(err.Error())
 	}
 
+	// Validate Gno syntax and type check.
+	if err = gno.TypeCheckMemPackage(memPkg, store); err != nil {
+		return "", ErrTypeCheck(err)
+	}
+
 	// Send send-coins to pkg from caller.
 	err = vm.bank.SendCoins(ctx, caller, pkgAddr, send)
 	if err != nil {
@@ -565,6 +575,9 @@ func (vm *VMKeeper) QueryFile(ctx sdk.Context, filepath string) (res string, err
 		return memFile.Body, nil
 	} else {
 		memPkg := store.GetMemPackage(dirpath)
+		if memPkg == nil {
+			return "", fmt.Errorf("package %q is not available", dirpath) // TODO: XSS protection
+		}
 		for i, memfile := range memPkg.Files {
 			if i > 0 {
 				res += "\n"

gno.land/pkg/sdk/vm/keeper_test.go

@@ -31,8 +31,6 @@ func TestVMKeeperAddPackage(t *testing.T) {
 			Name: "test.gno",
 			Body: `package test
 
-import "std"
-
 func Echo() string {
 	return "hello world"
 }`,
@@ -413,8 +411,6 @@ func TestNumberOfArgsError(t *testing.T) {
 			Name: "test.gno",
 			Body: `package test
 
-import "std"
-
 func Echo(msg string) string {
 	return "echo:"+msg
 }`,

gno.land/pkg/sdk/vm/package.go

@@ -20,4 +20,5 @@ var Package = amino.RegisterPackage(amino.NewPackage(
 	InvalidPkgPathError{}, "InvalidPkgPathError",
 	InvalidStmtError{}, "InvalidStmtError",
 	InvalidExprError{}, "InvalidExprError",
+	TypeCheckError{}, "TypeCheckError",
 ))

gnovm/cmd/gno/lint.go

@@ -5,16 +5,19 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"go/scanner"
+	"go/types"
 	"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/pkg/gnomod"
 	"github.com/gnolang/gno/gnovm/tests"
 	"github.com/gnolang/gno/tm2/pkg/commands"
-	osm "github.com/gnolang/gno/tm2/pkg/os"
+	"go.uber.org/multierr"
 )
 
 type lintCfg struct {
@@ -75,36 +78,75 @@ func execLint(cfg *lintCfg, args []string, io commands.IO) error {
 
 	for _, pkgPath := range pkgPaths {
 		if verbose {
-			fmt.Fprintf(io.Err(), "Linting %q...\n", pkgPath)
+			fmt.Fprintf(io.Err(), "%s\n", 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) {
+		gmFile, err := gnomod.ParseAt(pkgPath)
+		if err != nil {
 			addIssue(lintIssue{
-				Code:       lintNoGnoMod,
+				Code:       lintGnoMod,
 				Confidence: 1,
 				Location:   pkgPath,
-				Msg:        "missing 'gno.mod' file",
+				Msg:        err.Error(),
 			})
 		}
 
 		// 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(pkgPath, pkgPath)
+
+			if gmFile == nil || !gmFile.Draft {
+				tcErr := gno.TypeCheckMemPackageTest(memPkg, testStore)
+				if tcErr != nil {
+					errs := multierr.Errors(tcErr)
+					for _, err := range errs {
+						switch err := err.(type) {
+						case types.Error:
+							addIssue(lintIssue{
+								Code:       lintTypeCheckError,
+								Msg:        err.Msg,
+								Confidence: 1,
+								Location:   err.Fset.Position(err.Pos).String(),
+							})
+						case scanner.ErrorList:
+							for _, scErr := range err {
+								addIssue(lintIssue{
+									Code:       lintParserError,
+									Msg:        scErr.Msg,
+									Confidence: 1,
+									Location:   scErr.Pos.String(),
+								})
+							}
+						case scanner.Error:
+							addIssue(lintIssue{
+								Code:       lintParserError,
+								Msg:        err.Msg,
+								Confidence: 1,
+								Location:   err.Pos.String(),
+							})
+						default:
+							fmt.Fprintf(os.Stderr, "unexpected error type: %T\n", err)
+						}
+					}
+				}
+			} else if verbose {
+				fmt.Fprintf(stderr, "%s: module is draft, skipping type check\n", pkgPath)
 			}
 
-			memPkg := gno.ReadMemPackage(targetPath, targetPath)
 			tm := tests.TestMachine(testStore, stdout, memPkg.Name)
 
 			// Check package
@@ -210,9 +252,11 @@ func catchRuntimeError(pkgPath string, addIssue func(issue lintIssue), action fu
 type lintCode int
 
 const (
-	lintUnknown  lintCode = 0
-	lintNoGnoMod lintCode = iota
+	lintUnknown lintCode = 0
+	lintGnoMod  lintCode = iota
 	lintGnoError
+	lintParserError
+	lintTypeCheckError
 
 	// TODO: add new linter codes here.
 )