Save statement implementation (#17)

Numscript.g4

@@ -19,6 +19,7 @@ ALLOWING: 'allowing';
 UNBOUNDED: 'unbounded';
 OVERDRAFT: 'overdraft';
 KEPT: 'kept';
+SAVE: 'save';
 LPARENS: '(';
 RPARENS: ')';
 LBRACKET: '[';
@@ -100,4 +101,5 @@ sentValue: literal # sentLiteral | sentAllLit # sentAll;
 
 statement:
 	SEND sentValue LPARENS SOURCE EQ source DESTINATION EQ destination RPARENS	# sendStatement
+	| SAVE sentValue FROM literal												# saveStatement
 	| functionCall																# fnCallStatement;

internal/analysis/check.go

@@ -173,6 +173,10 @@ func (res *CheckResult) checkStatement(statement parser.Statement) {
 	res.emptiedAccount = make(map[string]struct{})
 
 	switch statement := statement.(type) {
+	case *parser.SaveStatement:
+		res.checkSentValue(statement.SentValue)
+		res.checkLiteral(statement.Literal, TypeAccount)
+
 	case *parser.SendStatement:
 		_, isSendAll := statement.SentValue.(*parser.SentValueAll)
 		res.unboundedSend = isSendAll

internal/analysis/check_test.go

@@ -85,6 +85,62 @@ func TestDuplicateVariable(t *testing.T) {
 	)
 }
 
+func TestUnboundVarInSaveAccount(t *testing.T) {
+	t.Parallel()
+
+	input := `save $unbound_mon from $unbound_acc`
+
+	program := parser.Parse(input).Value
+
+	diagnostics := analysis.CheckProgram(program).Diagnostics
+	require.Len(t, diagnostics, 2)
+
+	assert.Equal(t,
+		[]analysis.Diagnostic{
+			{
+				Kind:  &analysis.UnboundVariable{Name: "unbound_mon"},
+				Range: parser.RangeOfIndexed(input, "$unbound_mon", 0),
+			},
+			{
+				Kind:  &analysis.UnboundVariable{Name: "unbound_acc"},
+				Range: parser.RangeOfIndexed(input, "$unbound_acc", 0),
+			},
+		},
+		diagnostics,
+	)
+}
+
+func TestMismatchedTypeInSave(t *testing.T) {
+	t.Parallel()
+
+	input := `vars {
+	string $str
+	number $n
+}
+	
+save $str from $n
+`
+
+	program := parser.Parse(input).Value
+
+	diagnostics := analysis.CheckProgram(program).Diagnostics
+	require.Len(t, diagnostics, 2)
+
+	assert.Equal(t,
+		[]analysis.Diagnostic{
+			{
+				Kind:  &analysis.TypeMismatch{Expected: "monetary", Got: "string"},
+				Range: parser.RangeOfIndexed(input, "$str", 1),
+			},
+			{
+				Kind:  &analysis.TypeMismatch{Expected: "account", Got: "number"},
+				Range: parser.RangeOfIndexed(input, "$n", 1),
+			},
+		},
+		diagnostics,
+	)
+}
+
 func TestUnboundVarInSource(t *testing.T) {
 	t.Parallel()
 

internal/analysis/goto_definition_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/formancehq/numscript/internal/parser"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGotoDefinitionOnSendMonetaryVar(t *testing.T) {
@@ -23,7 +24,7 @@ send $amt (
 	checkResult := analysis.CheckProgram(program)
 
 	res := analysis.GotoDefinition(program, rng.Start, checkResult)
-	assert.NotNil(t, res)
+	require.NotNil(t, res)
 
 	assert.Equal(t, &analysis.GotoDefinitionResult{
 		Range: parser.RangeOfIndexed(input, "$amt", 0),

internal/analysis/hover.go

@@ -50,6 +50,12 @@ func HoverOn(program parser.Program, position parser.Position) Hover {
 				return hover
 			}
 
+		case *parser.SaveStatement:
+			hover := hoverOnSaveStatement(*statement, position)
+			if hover != nil {
+				return hover
+			}
+
 		case *parser.FnCall:
 			hover := hoverOnFnCall(*statement, position)
 			if hover != nil {
@@ -92,6 +98,24 @@ func hoverOnSentValue(sentValue parser.SentValue, position parser.Position) Hove
 	}
 }
 
+func hoverOnSaveStatement(saveStatement parser.SaveStatement, position parser.Position) Hover {
+	if !saveStatement.Range.Contains(position) {
+		return nil
+	}
+
+	hover := hoverOnSentValue(saveStatement.SentValue, position)
+	if hover != nil {
+		return hover
+	}
+
+	hover = hoverOnLiteral(saveStatement.Literal, position)
+	if hover != nil {
+		return hover
+	}
+
+	return nil
+}
+
 func hoverOnSendStatement(sendStatement parser.SendStatement, position parser.Position) Hover {
 	if !sendStatement.Range.Contains(position) {
 		return nil