neoneo-go/pkg/compiler/debug_test.go

package compiler

import (
	"encoding/json"
	"strings"
	"testing"

	"github.com/nspcc-dev/neo-go/internal/testserdes"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestCodeGen_DebugInfo(t *testing.T) {
	src := `package foo
	import "github.com/nspcc-dev/neo-go/pkg/interop"
	import "github.com/nspcc-dev/neo-go/pkg/interop/storage"
	import "github.com/nspcc-dev/neo-go/pkg/interop/native/ledger"
var staticVar int
func init() {
	a := 1
	_ = a
}
func init() {
	x := ""
	_ = x
	staticVar = 1
}
func Main(op string) bool {
	var s string
	_ = s
	res := MethodInt(op)
	_ = MethodString()
	_ = MethodByteArray()
	_ = MethodArray()
	_ = MethodStruct()
	_ = MethodConcat("a", "b", "c")
	_ = unexportedMethod()
	return res == 42
}

func MethodInt(a string) int {
	if a == "get42" {
		return 42
	}
	return 3
}
func MethodConcat(a, b string, c string) string{
	return a + b + c
}
func MethodString() string { return "" }
func MethodByteArray() []byte { return nil }
func MethodArray() []bool { return nil }
func MethodStruct() struct{} { return struct{}{} }
func unexportedMethod() int { return 1 }
func MethodParams(addr interop.Hash160, h interop.Hash256,
	sig interop.Signature, pub interop.PublicKey,
	inter interop.Interface,
	ctx storage.Context, tx ledger.Transaction) bool {
	return true
}
type MyStruct struct {}
func (ms MyStruct) MethodOnStruct() { }
func (ms *MyStruct) MethodOnPointerToStruct() { }
func _deploy(data interface{}, isUpdate bool) { x := 1; _ = x }
`

	ne, d, err := CompileWithOptions("foo.go", strings.NewReader(src), nil)
	require.NoError(t, err)
	require.NotNil(t, d)

	t.Run("return types", func(t *testing.T) {
		returnTypes := map[string]string{
			"MethodInt":    "Integer",
			"MethodConcat": "ByteString",
			"MethodString": "ByteString", "MethodByteArray": "ByteString",
			"MethodArray": "Array", "MethodStruct": "Struct",
			"Main":                    "Boolean",
			"unexportedMethod":        "Integer",
			"MethodOnStruct":          "Void",
			"MethodOnPointerToStruct": "Void",
			"MethodParams":            "Boolean",
			"_deploy":                 "Void",
			manifest.MethodInit:       "Void",
		}
		for i := range d.Methods {
			name := d.Methods[i].ID
			assert.Equal(t, returnTypes[name], d.Methods[i].ReturnType)
		}
	})

	t.Run("variables", func(t *testing.T) {
		vars := map[string][]string{
			"Main":                {"s,ByteString", "res,Integer"},
			manifest.MethodInit:   {"a,Integer", "x,ByteString"},
			manifest.MethodDeploy: {"x,Integer"},
		}
		for i := range d.Methods {
			v, ok := vars[d.Methods[i].ID]
			if ok {
				require.Equal(t, v, d.Methods[i].Variables)
			}
		}
	})

	t.Run("static variables", func(t *testing.T) {
		require.Equal(t, []string{"staticVar,Integer"}, d.StaticVariables)
	})

	t.Run("param types", func(t *testing.T) {
		paramTypes := map[string][]DebugParam{
			"_deploy": {
				{
					Name:   "data",
					Type:   "Any",
					TypeSC: smartcontract.AnyType,
				},
				{
					Name:   "isUpdate",
					Type:   "Boolean",
					TypeSC: smartcontract.BoolType,
				},
			},
			"MethodInt": {{
				Name:   "a",
				Type:   "ByteString",
				TypeSC: smartcontract.StringType,
			}},
			"MethodConcat": {
				{
					Name:   "a",
					Type:   "ByteString",
					TypeSC: smartcontract.StringType,
				},
				{
					Name:   "b",
					Type:   "ByteString",
					TypeSC: smartcontract.StringType,
				},
				{
					Name:   "c",
					Type:   "ByteString",
					TypeSC: smartcontract.StringType,
				},
			},
			"Main": {{
				Name:   "op",
				Type:   "ByteString",
				TypeSC: smartcontract.StringType,
			}},
		}
		for i := range d.Methods {
			v, ok := paramTypes[d.Methods[i].ID]
			if ok {
				require.Equal(t, v, d.Methods[i].Parameters)
			}
		}
	})

	// basic check that last instruction of every method is indeed RET
	for i := range d.Methods {
		index := d.Methods[i].Range.End
		require.True(t, int(index) < len(ne.Script))
		require.EqualValues(t, opcode.RET, ne.Script[index])
	}

	t.Run("convert to Manifest", func(t *testing.T) {
		p := manifest.NewPermission(manifest.PermissionWildcard)
		p.Methods.Add("randomMethod")

		actual, err := d.ConvertToManifest(&Options{
			Name:        "MyCTR",
			SafeMethods: []string{"methodInt", "methodString"},
			Permissions: []manifest.Permission{*p},
		})
		require.NoError(t, err)
		expected := &manifest.Manifest{
			Name: "MyCTR",
			ABI: manifest.ABI{
				Methods: []manifest.Method{
					{
						Name:       manifest.MethodInit,
						Parameters: []manifest.Parameter{},
						ReturnType: smartcontract.VoidType,
					},
					{
						Name: "_deploy",
						Parameters: []manifest.Parameter{
							manifest.NewParameter("data", smartcontract.AnyType),
							manifest.NewParameter("isUpdate", smartcontract.BoolType),
						},
						ReturnType: smartcontract.VoidType,
					},
					{
						Name: "main",
						Parameters: []manifest.Parameter{
							manifest.NewParameter("op", smartcontract.StringType),
						},
						ReturnType: smartcontract.BoolType,
					},
					{
						Name: "methodInt",
						Parameters: []manifest.Parameter{
							{
								Name: "a",
								Type: smartcontract.StringType,
							},
						},
						ReturnType: smartcontract.IntegerType,
						Safe:       true,
					},
					{
						Name:       "methodString",
						Parameters: []manifest.Parameter{},
						ReturnType: smartcontract.StringType,
						Safe:       true,
					},
					{
						Name:       "methodByteArray",
						Parameters: []manifest.Parameter{},
						ReturnType: smartcontract.ByteArrayType,
					},
					{
						Name:       "methodArray",
						Parameters: []manifest.Parameter{},
						ReturnType: smartcontract.ArrayType,
					},
					{
						Name:       "methodStruct",
						Parameters: []manifest.Parameter{},
						ReturnType: smartcontract.ArrayType,
					},
					{
						Name: "methodConcat",
						Parameters: []manifest.Parameter{
							{
								Name: "a",
								Type: smartcontract.StringType,
							},
							{
								Name: "b",
								Type: smartcontract.StringType,
							},
							{
								Name: "c",
								Type: smartcontract.StringType,
							},
						},
						ReturnType: smartcontract.StringType,
					},
					{
						Name: "methodParams",
						Parameters: []manifest.Parameter{
							manifest.NewParameter("addr", smartcontract.Hash160Type),
							manifest.NewParameter("h", smartcontract.Hash256Type),
							manifest.NewParameter("sig", smartcontract.SignatureType),
							manifest.NewParameter("pub", smartcontract.PublicKeyType),
							manifest.NewParameter("inter", smartcontract.InteropInterfaceType),
							manifest.NewParameter("ctx", smartcontract.InteropInterfaceType),
							manifest.NewParameter("tx", smartcontract.ArrayType),
						},
						ReturnType: smartcontract.BoolType,
					},
				},
				Events: []manifest.Event{},
			},
			Groups:      []manifest.Group{},
			Permissions: []manifest.Permission{*p},
			Trusts: manifest.WildPermissionDescs{
				Value: []manifest.PermissionDesc{},
			},
			Extra: json.RawMessage("null"),
		}
		require.Equal(t, len(expected.ABI.Methods), len(actual.ABI.Methods))
		for _, exp := range expected.ABI.Methods {
			md := actual.ABI.GetMethod(exp.Name, len(exp.Parameters))
			require.NotNil(t, md)
			require.Equal(t, exp.Name, md.Name)
			require.Equal(t, exp.Parameters, md.Parameters)
			require.Equal(t, exp.ReturnType, md.ReturnType)
			require.Equal(t, exp.Safe, md.Safe)
		}
		require.Equal(t, expected.ABI.Events, actual.ABI.Events)
		require.Equal(t, expected.Groups, actual.Groups)
		require.Equal(t, expected.Permissions, actual.Permissions)
		require.Equal(t, expected.Trusts, actual.Trusts)
		require.Equal(t, expected.Extra, actual.Extra)
	})
}

func TestSequencePoints(t *testing.T) {
	src := `package foo
	func Main(op string) bool {
		if op == "123" {
			return true
		}
		return false
	}`

	_, d, err := CompileWithOptions("foo.go", strings.NewReader(src), nil)
	require.NoError(t, err)
	require.NotNil(t, d)

	require.Equal(t, d.Documents, []string{"foo.go"})

	// Main func has 2 return on 4-th and 6-th lines.
	ps := d.Methods[0].SeqPoints
	require.Equal(t, 2, len(ps))
	require.Equal(t, 4, ps[0].StartLine)
	require.Equal(t, 6, ps[1].StartLine)
}

func TestDebugInfo_MarshalJSON(t *testing.T) {
	d := &DebugInfo{
		Documents: []string{"/path/to/file"},
		Methods: []MethodDebugInfo{
			{
				ID: "id1",
				Name: DebugMethodName{
					Namespace: "default",
					Name:      "method1",
				},
				Range: DebugRange{Start: 10, End: 20},
				Parameters: []DebugParam{
					{Name: "param1", Type: "Integer"},
					{Name: "ok", Type: "Boolean"},
				},
				ReturnType: "ByteString",
				Variables:  []string{},
				SeqPoints: []DebugSeqPoint{
					{
						Opcode:    123,
						Document:  1,
						StartLine: 2,
						StartCol:  3,
						EndLine:   4,
						EndCol:    5,
					},
				},
			},
		},
		Events: []EventDebugInfo{},
	}

	testserdes.MarshalUnmarshalJSON(t, d, new(DebugInfo))
}

func TestManifestOverload(t *testing.T) {
	src := `package foo
	func Main() int {
		return 1
	}
	func Add3() int {
		return Add3Aux(0)
	}
	func Add3Aux(a int) int {
		return a + 3
	}
	func Add3Aux2(b int) int {
		return b + 3
	}
	func Add4() int {
		return 4
	}`

	_, di, err := CompileWithOptions("foo.go", strings.NewReader(src), nil)
	require.NoError(t, err)

	m, err := di.ConvertToManifest(&Options{Overloads: map[string]string{"add3Aux": "add3"}})
	require.NoError(t, err)
	require.NoError(t, m.ABI.IsValid())
	require.NotNil(t, m.ABI.GetMethod("add3", 0))
	require.NotNil(t, m.ABI.GetMethod("add3", 1))
	require.Nil(t, m.ABI.GetMethod("add3Aux", 1))

	t.Run("missing method", func(t *testing.T) {
		_, err := di.ConvertToManifest(&Options{Overloads: map[string]string{"miss": "add3"}})
		require.Error(t, err)
	})
	t.Run("parameter conflict", func(t *testing.T) {
		_, err := di.ConvertToManifest(&Options{Overloads: map[string]string{"add4": "add3"}})
		require.Error(t, err)
	})
	t.Run("parameter conflict, overload", func(t *testing.T) {
		_, err := di.ConvertToManifest(&Options{Overloads: map[string]string{
			"add3Aux":  "add3",
			"add3Aux2": "add3",
		}})
		require.Error(t, err)
	})
	t.Run("missing target method", func(t *testing.T) {
		_, err := di.ConvertToManifest(&Options{Overloads: map[string]string{"add4": "add5"}})
		require.Error(t, err)
	})
}