feat(gnolint): add lint checks for Render

gnovm/cmd/gno/testdata/lint/render_multiple_cardinality_errors.txtar

@@ -0,0 +1,22 @@
+# testing gno tool lint command: Render function with multiple cardinality errors (too many parameters and returns)
+
+! gno tool lint ./multiple_cardinality_errors.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- multiple_cardinality_errors.gno --
+package main
+
+// multiple cardinality errors: too many parameters and return values
+func Render(path string, extra string) (string, error) {
+	return "Hello World " + path, nil 
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+multiple_cardinality_errors.gno:4: Render function should have exactly one parameter, found: 2 parameters, expected: func Render(string) string (code=5)
+multiple_cardinality_errors.gno:4: Render function should return exactly one string value, found: 2 returns, expected: func Render(string) string (code=5)

gnovm/cmd/gno/testdata/lint/render_multiple_type_errors.txtar

@@ -0,0 +1,22 @@
+# testing gno tool lint command: Render function with multiple type errors (wrong parameter and return types)
+
+! gno tool lint ./multiple_type_errors.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- multiple_type_errors.gno --
+package main
+
+// multiple type errors: wrong parameter type and wrong return type
+func Render(path int) int {
+	return path
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+multiple_type_errors.gno:4: Render function parameter should be of type string, found: int type, expected: func Render(string) string (code=5)
+multiple_type_errors.gno:4: Render function should return a single string, found: int type: expected func Render(string) string (code=5)

gnovm/cmd/gno/testdata/lint/render_no_param.txtar

@@ -0,0 +1,21 @@
+# testing gno tool lint command: Render function with no parameter
+
+! gno tool lint ./no_param.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- no_param.gno --
+package test
+
+// no parameter
+func Render() string {
+	return "Hello World"
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+no_param.gno:4: Render function should have exactly one parameter, found: 0 parameters, expected: func Render(string) string (code=5)

gnovm/cmd/gno/testdata/lint/render_too_many_params.txtar

@@ -0,0 +1,21 @@
+# testing gno tool lint command: Render function with too many parameters
+
+! gno tool lint ./too_many_params.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- too_many_params.gno --
+package main
+
+// too many parameters
+func Render(path string, extra string) string {
+	return "Hello World " + path + extra
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+too_many_params.gno:4: Render function should have exactly one parameter, found: 2 parameters, expected: func Render(string) string (code=5)

gnovm/cmd/gno/testdata/lint/render_too_many_returns.txtar

@@ -0,0 +1,21 @@
+# testing gno tool lint command: Render function with too many return values
+
+! gno tool lint ./too_many_returns.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- too_many_returns.gno --
+package main
+
+// too many return values
+func Render(path string) (string, error) {
+	return "Hello World " + path, nil
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+too_many_returns.gno:4: Render function should return exactly one string value, found: 2 returns, expected: func Render(string) string (code=5)

gnovm/cmd/gno/testdata/lint/render_valid.txtar

@@ -0,0 +1,26 @@
+# testing gno tool lint command: valid Render function signature
+
+gno tool lint ./valid_render.gno
+
+cmp stdout stdout.golden
+cmp stdout stderr.golden
+
+-- valid_render.gno --
+package test
+
+type Test struct{}
+// valid as well since it contains a receiver
+func (t *Test) Render(n int) int {
+    return n
+}
+
+// valid Render
+func Render(path string) string {
+	return "Hello World"
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --

gnovm/cmd/gno/testdata/lint/render_wrong_param_type.txtar

@@ -0,0 +1,23 @@
+# testing gno tool lint command: all invalid Render function signature cases
+
+! gno tool lint ./wrong_param_type.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- wrong_param_type.gno --
+package test
+
+import "fmt"
+
+// wrong parameter type (int vs string)
+func Render(path int) string {
+	return "Hello World" + fmt.Sprint(path)
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+wrong_param_type.gno:6: Render function parameter should be of type string, found: int type, expected: func Render(string) string (code=5)

gnovm/cmd/gno/testdata/lint/render_wrong_return_type.txtar

@@ -0,0 +1,21 @@
+# testing gno tool lint command: Render function with wrong return type
+
+! gno tool lint ./wrong_return_type.gno
+
+cmp stdout stdout.golden
+cmp stderr stderr.golden
+
+-- wrong_return_type.gno --
+package main
+
+// wrong return type (int vs string)
+func Render(path string) int {
+	return 42
+}
+
+-- gno.mod --
+module gno.land/p/test
+
+-- stdout.golden --
+-- stderr.golden --
+wrong_return_type.gno:4: Render function should return a single string, found: int type: expected func Render(string) string (code=5)

gnovm/cmd/gno/tool_lint.go

@@ -60,6 +60,7 @@
 	lintGnoError
 	lintParserError
 	lintTypeCheckError
+	lintRenderFuncSignature
 
 	// TODO: add new linter codes here.
 )
@@ -171,6 +172,11 @@
 		if hasRuntimeErr {
 			hasError = true
 		}
+
+		// ensure Render function signature matches what's expected
+		if renderErr := lintRenderSignature(io, memPkg); renderErr {
+			hasError = true
+		}
 	}
 
 	if hasError {
@@ -317,3 +323,99 @@
 	}
 	return issue
 }
+
+// lintRenderSignature checks if a Render function in the package has the
+// expected signature: func Render(string) string
+// Methods are ignored (e.g., func (t *Type) Render()).
+func lintRenderSignature(io commands.IO, memPkg *gnovm.MemPackage) bool {
+	var (
+		hasError   bool
+		exp        = "func Render(string) string"
+		stringType = "string"
+
+		errParameterCount = func(count int) string {
+			return fmt.Sprintf("Render function should have exactly one parameter, found: %d parameters, expected: %s", count, exp)
+		}
+		errParameterType = func(t string) string {
+			return fmt.Sprintf("Render function parameter should be of type string, found: %s type, expected: %s", t, exp)
+		}
+		errReturnCount = func(count int) string {
+			return fmt.Sprintf("Render function should return exactly one string value, found: %d returns, expected: %s", count, exp)
+		}
+		errReturnType = func(t string) string {
+			return fmt.Sprintf("Render function should return a single string, found: %s type: expected %s", t, exp)
+		}
+		errPrintln = func(errMsg, file string, line int) {
+			hasError = true
+			io.ErrPrintln(lintIssue{
+				Code:       lintRenderFuncSignature,
+				Msg:        errMsg,
+				Confidence: 1,
+				Location:   fmt.Sprintf("%s:%d", file, line),
+			})
+		}
+	)
+
+	for _, file := range memPkg.Files {
+		if !strings.HasSuffix(file.Name, ".gno") {
+			continue
+		}
+
+		fn, err := gno.ParseFile(file.Name, file.Body)
+		// if we can't parse the file for whatever reason, there is no point in
+		// attempting a lint check on the Render func
+		if err != nil {
+			continue
+		}
+
+		for _, decl := range fn.Decls {
+			// ignore non-function declarations
+			funcDecl, ok := decl.(*gno.FuncDecl)
+			if !ok {
+				continue
+			}
+
+			// ignore non-Render functions
+			if funcDecl.NameExpr.Name.String() != "Render" {
+				continue
+			}
+
+			// ignore methods
+			if funcDecl.IsMethod {
+				continue
+			}
+
+			// ensure we have a single string parameter
+			n := len(funcDecl.Type.Params)
+			switch n {
+			case 1:
+				param := funcDecl.Type.Params[0]
+				paramType, ok := param.Type.(*gno.NameExpr)
+				if !ok || paramType.Name.String() != stringType {
+					msg := errParameterType(paramType.Name.String())
+					errPrintln(msg, file.Name, funcDecl.GetLine())
+				}
+			default:
+				msg := errParameterCount(n)
+				errPrintln(msg, file.Name, funcDecl.GetLine())
+			}
+
+			// ensure return type is a single string
+			n = len(funcDecl.Type.Results)
+			switch n {
+			case 1:
+				ret := funcDecl.Type.Results[0]
+				retType, ok := ret.Type.(*gno.NameExpr)
+				if !ok || retType.Name.String() != stringType {
+					msg := errReturnType(retType.Name.String())
+					errPrintln(msg, file.Name, funcDecl.GetLine())
+				}
+			default:
+				msg := errReturnCount(n)
+				errPrintln(msg, file.Name, funcDecl.GetLine())
+			}
+		}
+	}
+
+	return hasError
+}

gnovm/pkg/gnolang/nodes.go

@@ -112,6 +112,8 @@ const (
 
 type Name string
 
+func (n Name) String() string { return string(n) }
+
 // ----------------------------------------
 // Location
 // Acts as an identifier for nodes.