Feat/experimental interpolation syntax

Lexer.g4

@@ -0,0 +1,57 @@
+lexer grammar Lexer;
+WS: [ \t\r\n]+ -> skip;
+NEWLINE: [\r\n]+;
+MULTILINE_COMMENT: '/*' (MULTILINE_COMMENT | .)*? '*/' -> skip;
+LINE_COMMENT: '//' .*? NEWLINE -> skip;
+
+VARS: 'vars';
+MAX: 'max';
+SOURCE: 'source';
+DESTINATION: 'destination';
+SEND: 'send';
+FROM: 'from';
+UP: 'up';
+TO: 'to';
+REMAINING: 'remaining';
+ALLOWING: 'allowing';
+UNBOUNDED: 'unbounded';
+OVERDRAFT: 'overdraft';
+KEPT: 'kept';
+SAVE: 'save';
+LPARENS: '(';
+RPARENS: ')';
+LBRACKET: '[';
+RBRACKET: ']';
+LBRACE: '{';
+RBRACE: '}';
+COMMA: ',';
+EQ: '=';
+STAR: '*';
+PLUS: '+';
+MINUS: '-';
+
+RATIO_PORTION_LITERAL: [0-9]+ [ ]? '/' [ ]? [0-9]+;
+PERCENTAGE_PORTION_LITERAL: [0-9]+ ('.' [0-9]+)? '%';
+
+STRING: '"' ('\\"' | ~[\r\n"])* '"';
+
+IDENTIFIER: [a-z]+ [a-z_]*;
+NUMBER: MINUS? [0-9]+ ('_' [0-9]+)*;
+// VARIABLE_NAME: '$' [a-z_]+ [a-z0-9_]*;
+
+ASSET: [A-Z/0-9]+;
+
+ACCOUNT_START: '@' -> pushMode(ACCOUNT_MODE);
+COLON: ':' -> pushMode(ACCOUNT_MODE);
+// fragment ACCOUNT_FRAGMENT_PART: [a-zA-Z0-9_-]+ | VARIABLE_NAME; ACCOUNT: '@' [a-zA-Z0-9_-]+ (':'
+// ACCOUNT_FRAGMENT_PART)*;
+
+fragment VARIABLE_NAME_FRAMGMENT: '$' [a-z_]+ [a-z0-9_]*;
+
+mode ACCOUNT_MODE;
+
+ACCOUNT_TEXT: [a-zA-Z0-9_-]+ -> popMode;
+VARIABLE_NAME_ACC: VARIABLE_NAME_FRAMGMENT -> popMode;
+
+mode DEFAULT_MODE;
+VARIABLE_NAME_DEFAULT: VARIABLE_NAME_FRAMGMENT;

Numscript.g4

@@ -1,46 +1,9 @@
 grammar Numscript;
 
 // Tokens
-WS: [ \t\r\n]+ -> skip;
-NEWLINE: [\r\n]+;
-MULTILINE_COMMENT: '/*' (MULTILINE_COMMENT | .)*? '*/' -> skip;
-LINE_COMMENT: '//' .*? NEWLINE -> skip;
-
-VARS: 'vars';
-MAX: 'max';
-SOURCE: 'source';
-DESTINATION: 'destination';
-SEND: 'send';
-FROM: 'from';
-UP: 'up';
-TO: 'to';
-REMAINING: 'remaining';
-ALLOWING: 'allowing';
-UNBOUNDED: 'unbounded';
-OVERDRAFT: 'overdraft';
-KEPT: 'kept';
-SAVE: 'save';
-LPARENS: '(';
-RPARENS: ')';
-LBRACKET: '[';
-RBRACKET: ']';
-LBRACE: '{';
-RBRACE: '}';
-COMMA: ',';
-EQ: '=';
-STAR: '*';
-MINUS: '-';
-
-RATIO_PORTION_LITERAL: [0-9]+ [ ]? '/' [ ]? [0-9]+;
-PERCENTAGE_PORTION_LITERAL: [0-9]+ ('.' [0-9]+)? '%';
-
-STRING: '"' ('\\"' | ~[\r\n"])* '"';
-
-IDENTIFIER: [a-z]+ [a-z_]*;
-NUMBER: MINUS? [0-9]+ ('_' [0-9]+)*;
-VARIABLE_NAME: '$' [a-z_]+ [a-z0-9_]*;
-ACCOUNT: '@' [a-zA-Z0-9_-]+ (':' [a-zA-Z0-9_-]+)*;
-ASSET: [A-Z/0-9]+;
+options {
+	tokenVocab = 'Lexer';
+}
 
 monetaryLit:
 	LBRACKET (asset = valueExpr) (amt = valueExpr) RBRACKET;
@@ -49,33 +12,37 @@ portion:
 	RATIO_PORTION_LITERAL			# ratio
 	| PERCENTAGE_PORTION_LITERAL	# percentage;
 
+accountLiteralPart:
+	ACCOUNT_TEXT		# accountTextPart
+	| VARIABLE_NAME_ACC	# accountVarPart;
+
 valueExpr:
-	VARIABLE_NAME											# variableExpr
-	| ASSET													# assetLiteral
-	| STRING												# stringLiteral
-	| ACCOUNT												# accountLiteral
-	| NUMBER												# numberLiteral
-	| monetaryLit											# monetaryLiteral
-	| portion												# portionLiteral
-	| left = valueExpr op = ('+' | '-') right = valueExpr	# infixExpr;
+	VARIABLE_NAME_DEFAULT											# variableExpr
+	| ASSET															# assetLiteral
+	| STRING														# stringLiteral
+	| ACCOUNT_START accountLiteralPart (COLON accountLiteralPart)*	# accountLiteral
+	| NUMBER														# numberLiteral
+	| monetaryLit													# monetaryLiteral
+	| portion														# portionLiteral
+	| left = valueExpr op = (PLUS | MINUS) right = valueExpr		# infixExpr;
 
 functionCallArgs: valueExpr ( COMMA valueExpr)*;
 functionCall:
 	fnName = (OVERDRAFT | IDENTIFIER) LPARENS functionCallArgs? RPARENS;
 
 varOrigin: EQ functionCall;
 varDeclaration:
-	type_ = IDENTIFIER name = VARIABLE_NAME varOrigin?;
+	type_ = IDENTIFIER name = VARIABLE_NAME_DEFAULT varOrigin?;
 varsDeclaration: VARS LBRACE varDeclaration* RBRACE;
 
 program: varsDeclaration? statement* EOF;
 
 sentAllLit: LBRACKET (asset = valueExpr) STAR RBRACKET;
 
 allotment:
-	portion			# portionedAllotment
-	| VARIABLE_NAME	# portionVariable
-	| REMAINING		# remainingAllotment;
+	portion					# portionedAllotment
+	| VARIABLE_NAME_DEFAULT	# portionVariable
+	| REMAINING				# remainingAllotment;
 
 source:
 	address = valueExpr ALLOWING UNBOUNDED OVERDRAFT						# srcAccountUnboundedOverdraft

generate-parser.sh

@@ -1 +1,2 @@
-antlr4 -Dlanguage=Go Numscript.g4 -o internal/parser/antlr
+antlr4 -Dlanguage=Go Lexer.g4 Numscript.g4 -o internal/parser/antlrParser -package antlrParser
+mv internal/parser/antlrParser/_lexer.go internal/parser/antlrParser/lexer.go

internal/analysis/check.go

@@ -358,7 +358,12 @@ func (res *CheckResult) checkExpression(lit parser.ValueExpr, requiredType strin
 		res.assertHasType(lit, requiredType, TypeMonetary)
 		res.checkExpression(lit.Asset, TypeAsset)
 		res.checkExpression(lit.Amount, TypeNumber)
-	case *parser.AccountLiteral:
+	case *parser.AccountInterpLiteral:
+		for _, part := range lit.Parts {
+			if v, ok := part.(*parser.Variable); ok {
+				res.checkExpression(v, TypeAny)
+			}
+		}
 		res.assertHasType(lit, requiredType, TypeAccount)
 	case *parser.RatioLiteral:
 		res.assertHasType(lit, requiredType, TypePortion)
@@ -413,7 +418,7 @@ func (res *CheckResult) checkSource(source parser.Source) {
 	switch source := source.(type) {
 	case *parser.SourceAccount:
 		res.checkExpression(source.ValueExpr, TypeAccount)
-		if account, ok := source.ValueExpr.(*parser.AccountLiteral); ok {
+		if account, ok := source.ValueExpr.(*parser.AccountInterpLiteral); ok {
 			if account.IsWorld() && res.unboundedSend {
 				res.Diagnostics = append(res.Diagnostics, Diagnostic{
 					Range: source.GetRange(),
@@ -423,18 +428,18 @@ func (res *CheckResult) checkSource(source parser.Source) {
 				res.unboundedAccountInSend = account
 			}
 
-			if _, emptied := res.emptiedAccount[account.Name]; emptied && !account.IsWorld() {
+			if _, emptied := res.emptiedAccount[account.String()]; emptied && !account.IsWorld() {
 				res.Diagnostics = append(res.Diagnostics, Diagnostic{
-					Kind:  &EmptiedAccount{Name: account.Name},
+					Kind:  &EmptiedAccount{Name: account.String()},
 					Range: account.Range,
 				})
 			}
 
-			res.emptiedAccount[account.Name] = struct{}{}
+			res.emptiedAccount[account.String()] = struct{}{}
 		}
 
 	case *parser.SourceOverdraft:
-		if accountLiteral, ok := source.Address.(*parser.AccountLiteral); ok && accountLiteral.IsWorld() {
+		if accountLiteral, ok := source.Address.(*parser.AccountInterpLiteral); ok && accountLiteral.IsWorld() {
 			res.Diagnostics = append(res.Diagnostics, Diagnostic{
 				Range: accountLiteral.Range,
 				Kind:  &InvalidWorldOverdraft{},

internal/analysis/check_test.go

@@ -344,6 +344,56 @@ send [EUR/2 $n] (
 	)
 }
 
+func TestNoUnusedOnStringInterp(t *testing.T) {
+	t.Parallel()
+
+	input := `vars { number $id }
+
+send [EUR/2 *] (
+  	source = @user:$id:pending
+  	destination = @dest
+)`
+
+	program := parser.Parse(input).Value
+
+	diagnostics := analysis.CheckProgram(program).Diagnostics
+	require.Empty(t, diagnostics)
+
+}
+
+func TestWrongTypeInsideAccountInterp(t *testing.T) {
+	t.Skip("TODO formalize a better type system to model this easy")
+
+	t.Parallel()
+
+	input := `vars { monetary $m }
+
+send [EUR/2 *] (
+  	source = @user:$m
+  	destination = @dest
+)`
+
+	program := parser.Parse(input).Value
+
+	diagnostics := analysis.CheckProgram(program).Diagnostics
+
+	require.Len(t, diagnostics, 1, "diagnostics=%#v\n", diagnostics)
+
+	d1 := diagnostics[0]
+	assert.Equal(t,
+		&analysis.TypeMismatch{
+			Expected: "number|account|string",
+			Got:      "monetary",
+		},
+		d1.Kind,
+	)
+
+	assert.Equal(t,
+		parser.RangeOfIndexed(input, "$n", 1),
+		d1.Range,
+	)
+}
+
 func TestWrongTypeForCap(t *testing.T) {
 	t.Parallel()
 

internal/analysis/hover.go

@@ -145,6 +145,17 @@ func hoverOnExpression(lit parser.ValueExpr, position parser.Position) Hover {
 	}
 
 	switch lit := lit.(type) {
+	case *parser.AccountInterpLiteral:
+		for _, part := range lit.Parts {
+			if v, ok := part.(*parser.Variable); ok {
+
+				hover := hoverOnExpression(v, position)
+				if hover != nil {
+					return hover
+				}
+			}
+		}
+
 	case *parser.Variable:
 		return &VariableHover{
 			Range: lit.Range,

internal/analysis/hover_test.go

@@ -181,6 +181,33 @@ send [C 10] (
 	require.NotNil(t, resolved)
 }
 
+func TestHoverOnStringInterp(t *testing.T) {
+	input := `vars { number $id }
+
+send [ASSET *] (
+	source = @world
+	destination = @user:$id
+)
+`
+
+	rng := parser.RangeOfIndexed(input, "$id", 1)
+
+	program := parser.Parse(input).Value
+	hover := analysis.HoverOn(program, rng.Start)
+	require.NotNil(t, hover)
+
+	variableHover, ok := hover.(*analysis.VariableHover)
+	require.True(t, ok, "Expected VariableHover")
+
+	require.Equal(t, rng, variableHover.Range)
+
+	checkResult := analysis.CheckProgram(program)
+	require.NotNil(t, variableHover.Node)
+
+	resolved := checkResult.ResolveVar(variableHover.Node)
+	require.NotNil(t, resolved)
+}
+
 func TestHoverOnDestinationInorderRemaining(t *testing.T) {
 	input := `vars { account $dest }
 

internal/interpreter/evaluate_expr.go

@@ -2,6 +2,7 @@
 
 import (
 	"math/big"
+	"strings"
 
 	"github.com/formancehq/numscript/internal/parser"
 	"github.com/formancehq/numscript/internal/utils"
@@ -11,8 +12,28 @@
 	switch expr := expr.(type) {
 	case *parser.AssetLiteral:
 		return Asset(expr.Asset), nil
-	case *parser.AccountLiteral:
-		return AccountAddress(expr.Name), nil
+	case *parser.AccountInterpLiteral:
+		var parts []string
+		for _, part := range expr.Parts {
+			switch part := part.(type) {
+			case parser.AccountTextPart:
+				parts = append(parts, part.Name)
+			case *parser.Variable:
+				value, err := st.evaluateExpr(part)
+				if err != nil {
+					return nil, err
+				}
+				strValue, err := castToString(value, expr.Range)
+				if err != nil {
+					return nil, err
+				}
+				parts = append(parts, strValue)
+			}
+		}
+		name := strings.Join(parts, ":")
+		// TODO validate valid names
+		return AccountAddress(name), nil
+
 	case *parser.StringLiteral:
 		return String(expr.String), nil
 	case *parser.RatioLiteral:
@@ -124,3 +145,18 @@
 
 	return (*leftValue).evalSub(st, right)
 }
+
+func castToString(v Value, rng parser.Range) (string, InterpreterError) {
+	switch v := v.(type) {
+	case AccountAddress:
+		return v.String(), nil
+	case String:
+		return v.String(), nil
+	case MonetaryInt:
+		return v.String(), nil
+
+	default:
+		// No asset nor ratio can be implicitly cast to string
+		return "", CannotCastToString{Value: v, Range: rng}
+	}
+}

internal/interpreter/interpreter_error.go

@@ -193,3 +193,12 @@
 func (e ExperimentalFeature) Error() string {
 	return fmt.Sprintf("this feature is experimental. You need the '%s' feature flag to enable it", e.FlagName)
 }
+
+type CannotCastToString struct {
+	parser.Range
+	Value Value
+}
+
+func (e CannotCastToString) Error() string {
+	return fmt.Sprintf("Cannot cast this value to string: %s", e.Value)
+}