Feat/version hint (#51)

Author: ascandone

Lexer.g4

@@ -2,7 +2,7 @@ lexer grammar Lexer;
 WS: [ \t\r\n]+ -> skip;
 NEWLINE: [\r\n]+;
 MULTILINE_COMMENT: '/*' (MULTILINE_COMMENT | .)*? '*/' -> skip;
-LINE_COMMENT: '//' .*? NEWLINE -> skip;
+LINE_COMMENT: '//' .*? NEWLINE -> channel(HIDDEN);
 
 VARS: 'vars';
 MAX: 'max';

internal/analysis/check.go

@@ -91,6 +91,7 @@ type Diagnostic struct {
 }
 
 type CheckResult struct {
+	version                parser.Version
 	nextDiagnosticId       int32
 	unboundedAccountInSend parser.ValueExpr
 	emptiedAccount         map[string]struct{}
@@ -141,6 +142,7 @@ func (r CheckResult) ResolveBuiltinFn(v *parser.FnCallIdentifier) FnCallResoluti
 
 func newCheckResult(program parser.Program) CheckResult {
 	return CheckResult{
+		version:          program.GetVersion(),
 		emptiedAccount:   make(map[string]struct{}),
 		declaredVars:     make(map[string]parser.VarDeclaration),
 		unusedVars:       make(map[string]parser.Range),
@@ -303,6 +305,8 @@ func (res *CheckResult) checkDuplicateVars(variableName parser.Variable, decl pa
 }
 
 func (res *CheckResult) checkFnCall(fnCall parser.FnCall) string {
+	res.checkOvedraftFunctionVersion(fnCall)
+
 	returnType := TypeAny
 
 	if resolution, ok := Builtins[fnCall.Caller.Name]; ok {
@@ -353,6 +357,8 @@ func (res *CheckResult) checkTypeOf(lit parser.ValueExpr, typeHint string) strin
 			return res.checkInfixOverload(lit, []string{TypeNumber, TypeMonetary})
 
 		case parser.InfixOperatorDiv:
+			res.checkInfixVersion(*lit)
+
 			res.checkExpression(lit.Left, TypeNumber)
 			res.checkExpression(lit.Right, TypeNumber)
 			return TypePortion
@@ -366,6 +372,8 @@ func (res *CheckResult) checkTypeOf(lit parser.ValueExpr, typeHint string) strin
 		}
 
 	case *parser.AccountInterpLiteral:
+		res.checkAccountInterpolationVersion(*lit)
+
 		for _, part := range lit.Parts {
 			if v, ok := part.(*parser.Variable); ok {
 				res.checkExpression(v, TypeAny)
@@ -477,6 +485,8 @@ func (res *CheckResult) checkSource(source parser.Source) {
 		}
 
 	case *parser.SourceOneof:
+		res.checkOneofVersion(source.Range)
+
 		for _, source := range source.Sources {
 			res.checkSource(source)
 		}
@@ -631,6 +641,8 @@ func (res *CheckResult) checkDestination(destination parser.Destination) {
 		res.checkKeptOrDestination(destination.Remaining)
 
 	case *parser.DestinationOneof:
+		res.checkOneofVersion(destination.Range)
+
 		for _, clause := range destination.Clauses {
 			res.checkExpression(clause.Cap, TypeMonetary)
 			res.checkKeptOrDestination(clause.To)

internal/analysis/check_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/formancehq/numscript/internal/analysis"
+	"github.com/formancehq/numscript/internal/flags"
 	"github.com/formancehq/numscript/internal/parser"
 
 	"github.com/stretchr/testify/assert"
@@ -671,3 +672,192 @@ send [EUR/2 *] (
 		d1.Range,
 	)
 }
+
+func TestDoNoCheckVersionWhenNotSpecified(t *testing.T) {
+	t.Parallel()
+
+	input := `
+vars {
+	number $n
+}
+
+send [EUR/2 100] (
+  	source = {
+			1/$n from @a
+			remaining from @b
+		}
+  	destination = @dest
+)
+`
+
+	require.Equal(t,
+		[]analysis.Diagnostic(nil),
+		checkSource(input),
+	)
+
+}
+
+func TestRequireVersionForInfixDiv(t *testing.T) {
+	t.Parallel()
+
+	input := `
+// @version machine
+
+vars {
+	number $n
+}
+
+send [EUR/2 100] (
+  	source = {
+			1/$n from @a
+			remaining from @b
+		}
+  	destination = @dest
+)
+`
+
+	require.Equal(t,
+		[]analysis.Diagnostic{
+			{
+				Range: parser.RangeOfIndexed(input, "1/$n", 0),
+				Kind: analysis.VersionMismatch{
+					GotVersion:      parser.VersionMachine{},
+					RequiredVersion: parser.NewVersionInterpreter(0, 0, 15),
+				},
+			},
+		},
+		checkSource(input),
+	)
+}
+
+func TestRequireVersionForInfixDivWhenVersionLt(t *testing.T) {
+	t.Parallel()
+
+	input := `
+// required version is 0.0.15
+// @version interpreter 0.0.1
+
+vars {
+	number $n
+}
+
+send [EUR/2 100] (
+  	source = {
+			1/$n from @a
+			remaining from @b
+		}
+  	destination = @dest
+)
+`
+
+	require.Equal(t,
+		[]analysis.Diagnostic{
+			{
+				Range: parser.RangeOfIndexed(input, "1/$n", 0),
+				Kind: analysis.VersionMismatch{
+					GotVersion:      parser.NewVersionInterpreter(0, 0, 1),
+					RequiredVersion: parser.NewVersionInterpreter(0, 0, 15),
+				},
+			},
+		},
+		checkSource(input),
+	)
+}
+
+func TestRequireFlagForOneofWhenMissing(t *testing.T) {
+	t.Parallel()
+
+	input := `
+// @version interpreter 0.0.15
+
+send [EUR/2 100] (
+  	source = oneof {
+			@a
+			@b
+		}
+  	destination = @dest
+)
+`
+
+	ds := checkSource(input)
+	require.Len(t, ds, 1)
+
+	require.Equal(t,
+		analysis.ExperimentalFeature{
+			Name: flags.ExperimentalOneofFeatureFlag,
+		},
+		ds[0].Kind,
+	)
+}
+
+func TestRequireFlagForOneofWhenGiven(t *testing.T) {
+	t.Parallel()
+
+	input := `
+// @version interpreter 0.0.15
+// @feature_flag experimental-oneof
+
+send [EUR/2 100] (
+  	source = oneof {
+			@a
+			@b
+		}
+  	destination = @dest
+)
+`
+
+	require.Empty(t, checkSource(input))
+}
+
+func TestRequireFlagForInterpolation(t *testing.T) {
+	t.Parallel()
+
+	input := `
+// @version interpreter 0.0.15
+vars {
+	number $id 
+}
+
+send [EUR/2 100] (
+  	source = @user:$id
+  	destination = @dest
+)
+`
+
+	require.Equal(t,
+		[]analysis.Diagnostic{
+			{
+				Range: parser.RangeOfIndexed(input, "@user:$id", 0),
+				Kind: analysis.ExperimentalFeature{
+					Name: flags.ExperimentalAccountInterpolationFlag,
+				},
+			},
+		},
+		checkSource(input),
+	)
+}
+
+func TestRequireFlagForFunctionOverdraft(t *testing.T) {
+	t.Parallel()
+
+	input := `
+// @version interpreter 0.0.15
+vars {
+	monetary $m = overdraft(@acc, USD/2)
+}
+
+send $m ( source = @world destination = @dest)
+`
+
+	require.Equal(t,
+		[]analysis.Diagnostic{
+			{
+				Range: parser.RangeOfIndexed(input, "overdraft(@acc, USD/2)", 0),
+				Kind: analysis.ExperimentalFeature{
+					Name: flags.ExperimentalOverdraftFunctionFeatureFlag,
+				},
+			},
+		},
+		checkSource(input),
+	)
+}

internal/analysis/diagnostic_kind.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 
 	"github.com/formancehq/numscript/internal/ansi"
+	"github.com/formancehq/numscript/internal/parser"
 	"github.com/formancehq/numscript/internal/utils"
 )
 
@@ -271,3 +272,28 @@ func (e UnboundedAccountIsNotLast) Message() string {
 func (UnboundedAccountIsNotLast) Severity() Severity {
 	return WarningSeverity
 }
+
+type VersionMismatch struct {
+	RequiredVersion parser.Version
+	GotVersion      parser.Version
+}
+
+func (e VersionMismatch) Message() string {
+	return fmt.Sprintf("Version mismatch. Required version '%s' (but got '%s' instead)", e.RequiredVersion.String(), e.GotVersion.String())
+}
+
+func (VersionMismatch) Severity() Severity {
+	return ErrorSeverity
+}
+
+type ExperimentalFeature struct {
+	Name string
+}
+
+func (e ExperimentalFeature) Message() string {
+	return fmt.Sprintf("This feature is experimental. Add this comment to your script:\n// @feature_flag %s", e.Name)
+}
+
+func (ExperimentalFeature) Severity() Severity {
+	return ErrorSeverity
+}