feat(pkg/cosmosanalysis): support discovery of modules defined in a variable (#2820)

* feat: change module discovery to resolve modules from a variable

* feat: change module discovery to resolve modules from a pkg variable

The changeset resolves the modules defined in a variable within the same
package but in a different file.

* feat: change module discovery to resolve modules from a other pkg variable

* feat: discover app modules created using a function call

* refactor: simplify module discovery

* chore: update changelog

* chore: minor code improvements and documentation

* fix: cosmosanalysis to work when proto Go import is missing version

Some apps define the Go import path in the proto files without the
version suffix while the Go module uses a version suffix. This change
allows the custom module discovery to work in such case.

* refactor: improve discovery for different custom module layouts

Changeset modifies the module discovery to search inside custom module
folders for the RPC services implementation.

* fix: remove default from typescript client generate output flag

* refactor: improve module discovery to work with versioned Go modules

The change allows discovery for blockchain apps that are versioned. It
also handles the cases where custom app modules are imported using a Go
import that might or might not contain the version suffix.

* feat: add `cosmos_proto` to protoc includes

The protp package is required to generate code for other blockchains
like Gaia, otherwise generation would fail because the proto option
`cosmos_proto.scalar` won't be available while generating the typescript
code for some cosmos SDK modules. Cosmos SDK removed the `cosmos_proto`
from its third party proto includes in changeset
cosmos/cosmos-sdk@0cb7fd0

* feat: add error support to `NewBasicManager` call discovery

* review: add comment to basic manager discovery

Co-authored-by: Thomas Bruyelle <thomas.bruyelle@gmail.com>

* chore: fix syntax

* fix CL

* test: registered modules for osmosis

* test: add test for standard module discovery cases

This case discover registered modules registered as NewBasicManager
function arguments.

* test: add test for module discovery with API routes

* tests: add tests for `cosmosanalysis` module helper functions

* tests: add discovery test for versioned apps

Blockchain apps are versioned when the import path in the `go.mod` file
contains a version suffix.

* test: registered modules for current spn, gaia and juno

Co-authored-by: Thomas Bruyelle <thomas.bruyelle@gmail.com>
Co-authored-by: Thomas Bruyelle <thomas.bruyelle@tendermint.com>
Co-authored-by: Alex Johnson <alex@shmeeload.xyz>

Author: 3 people

changelog.md

@@ -4,6 +4,7 @@
 
 ### Changes
 
+- Updated `pkg/cosmosanalysis` to discover the list of app modules when defined in variables.
 - Switch to broadcast mode sync in `cosmosclient`
 - Updated `nodetime`: `ts-proto` to `v1.123.0`, `protobufjs` to `v7.1.1`, `swagger-typescript-api` to `v9.2.0`
 - Switched codegen client to use `axios` instead of `fetch`

ignite/cmd/generate_typescript_client.go

@@ -3,7 +3,6 @@ package ignitecmd
 import (
 	"github.com/spf13/cobra"
 
-	"github.com/ignite/cli/ignite/chainconfig"
 	"github.com/ignite/cli/ignite/pkg/cliui"
 	"github.com/ignite/cli/ignite/services/chain"
 )
@@ -16,7 +15,7 @@ func NewGenerateTSClient() *cobra.Command {
 	}
 
 	c.Flags().AddFlagSet(flagSetProto3rdParty(""))
-	c.Flags().StringP(flagOutput, "o", chainconfig.DefaultTSClientPath, "typescript client output path")
+	c.Flags().StringP(flagOutput, "o", "", "typescript client output path")
 
 	return c
 }

ignite/pkg/cosmosanalysis/app/app.go

@@ -1,11 +1,14 @@
 package app
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"go/ast"
+	"go/format"
 	"go/parser"
 	"go/token"
+	"path/filepath"
 
 	"github.com/ignite/cli/ignite/pkg/cosmosanalysis"
 	"github.com/ignite/cli/ignite/pkg/goanalysis"
@@ -77,7 +80,7 @@ func CheckKeeper(path, keeperName string) error {
 // 1. Mapping out all the imports and named imports
 // 2. Looking for the call to module.NewBasicManager and finds the modules registered there
 // 3. Looking for the implementation of RegisterAPIRoutes and find the modules that call their RegisterGRPCGatewayRoutes
-func FindRegisteredModules(chainRoot string) ([]string, error) {
+func FindRegisteredModules(chainRoot string) (modules []string, err error) {
 	appFilePath, err := cosmosanalysis.FindAppFilePath(chainRoot)
 	if err != nil {
 		return nil, err
@@ -99,24 +102,45 @@ func FindRegisteredModules(chainRoot string) ([]string, error) {
 		return nil, err
 	}
 
-	var basicModules []string
+	// The directory where the app file is located.
+	// This is required to resolve references within the app package.
+	appDir := filepath.Dir(appFilePath)
+
 	ast.Inspect(f, func(n ast.Node) bool {
-		if pkgsReg := findBasicManagerRegistrations(n, basicManagerModule); pkgsReg != nil {
-			for _, rp := range pkgsReg {
-				importModule := packages[rp]
-				basicModules = append(basicModules, importModule)
+		// Stop traversing the child nodes when there is an error
+		if err != nil {
+			return false
+		}
+
+		var pkgs []string
+
+		pkgs, err = findBasicManagerRegistrations(n, basicManagerModule, appDir, packages)
+		if err != nil {
+			return false
+		}
+
+		if pkgs != nil {
+			for _, p := range pkgs {
+				importModule := packages[p]
+				if importModule == "" {
+					// When the package is not defined in the same file use the package name as import
+					importModule = p
+				}
+
+				modules = append(modules, importModule)
 			}
 
 			return false
 		}
 
-		if pkgsReg := findRegisterAPIRoutersRegistrations(n); pkgsReg != nil {
-			for _, rp := range pkgsReg {
-				importModule := packages[rp]
+		if pkgs = findRegisterAPIRoutersRegistrations(n); pkgs != nil {
+			for _, p := range pkgs {
+				importModule := packages[p]
 				if importModule == "" {
 					continue
 				}
-				basicModules = append(basicModules, importModule)
+
+				modules = append(modules, importModule)
 			}
 
 			return false
@@ -125,56 +149,87 @@ func FindRegisteredModules(chainRoot string) ([]string, error) {
 		return true
 	})
 
-	return basicModules, nil
+	return modules, err
+}
+
+func exprToString(n ast.Expr) (string, error) {
+	buf := bytes.Buffer{}
+	fset := token.NewFileSet()
+
+	// Convert the expression node to Go
+	if err := format.Node(&buf, fset, n); err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
+func newExprError(msg string, n ast.Expr) error {
+	s, err := exprToString(n)
+	if err != nil {
+		return fmt.Errorf("%s: %w", msg, err)
+	}
+
+	return fmt.Errorf("%s: %s", msg, s)
 }
 
-func findBasicManagerRegistrations(n ast.Node, basicManagerModule string) []string {
+func findBasicManagerRegistrations(n ast.Node, basicManagerModule, pkgDir string, pkgs map[string]string) (packages []string, err error) {
 	callExprType, ok := n.(*ast.CallExpr)
 	if !ok {
-		return nil
+		return
 	}
 
 	selectorExprType, ok := callExprType.Fun.(*ast.SelectorExpr)
 	if !ok {
-		return nil
+		return
 	}
 
 	identExprType, ok := selectorExprType.X.(*ast.Ident)
 	if !ok || identExprType.Name != basicManagerModule || selectorExprType.Sel.Name != "NewBasicManager" {
-		return nil
+		return
 	}
 
-	packagesRegistered := make([]string, len(callExprType.Args))
-	for i, arg := range callExprType.Args {
-		argAsCompositeLitType, ok := arg.(*ast.CompositeLit)
-		if ok {
-			compositeTypeSelectorExpr, ok := argAsCompositeLitType.Type.(*ast.SelectorExpr)
-			if !ok {
-				continue
+	// Node "n" defines the call to NewBasicManager, let's loop on its args to discover modules
+	for _, arg := range callExprType.Args {
+		switch v := arg.(type) {
+		case *ast.CompositeLit:
+			// The arg is an app module
+			p := parsePkgNameFromCompositeLit(v)
+			if p == "" {
+				return nil, newExprError("unexpected basic app module reference", arg)
 			}
 
-			compositeTypeX, ok := compositeTypeSelectorExpr.X.(*ast.Ident)
-			if ok {
-				packagesRegistered[i] = compositeTypeX.Name
-				continue
+			packages = append(packages, p)
+		case *ast.CallExpr:
+			// The arg is a function call that returns the app module
+			p := parsePkgNameFromCall(v)
+			if p == "" {
+				return nil, newExprError("unexpected basic app module function format", arg)
 			}
-		}
 
-		argAsCallType, ok := arg.(*ast.CallExpr)
-		if ok {
-			argAsFunctionType, ok := argAsCallType.Fun.(*ast.SelectorExpr)
-			if !ok {
-				continue
+			packages = append(packages, p)
+		case *ast.Ident:
+			// The list of modules are defined in a local variable
+			p := parseAppModulesFromIdent(v, pkgDir)
+			if len(p) == 0 {
+				return nil, newExprError("unsupported basic app modules variable format", arg)
 			}
 
-			argX, ok := argAsFunctionType.X.(*ast.Ident)
-			if ok {
-				packagesRegistered[i] = argX.Name
+			packages = append(packages, p...)
+		case *ast.SelectorExpr:
+			// The list of modules is defined in a variable of a different package
+			p := parseAppModulesFromSelectorExpr(v, pkgDir, pkgs)
+			if len(p) == 0 {
+				return nil, newExprError("unsupported basic app modules variable reference", arg)
 			}
+
+			packages = append(packages, p...)
+		default:
+			return nil, newExprError("unsupported NewBasicManager() argument format", arg)
 		}
 	}
 
-	return packagesRegistered
+	return packages, nil
 }
 
 func findBasicManagerModule(pkgs map[string]string) (string, error) {