Add more tests for expressions in string templates.

parser/expression_test.go

@@ -34,6 +34,7 @@ import (
 	"github.com/onflow/cadence/common"
 	"github.com/onflow/cadence/errors"
 	"github.com/onflow/cadence/parser/lexer"
+	"github.com/onflow/cadence/runtime/tests/utils"
 	. "github.com/onflow/cadence/test_utils/common_utils"
 )
 
@@ -6287,7 +6288,7 @@ func TestParseStringTemplate(t *testing.T) {
 		require.NoError(t, err)
 	})
 
-	t.Run("invalid, unbalanced paren", func(t *testing.T) {
+	t.Run("invalid, missing paren", func(t *testing.T) {
 
 		t.Parallel()
 
@@ -6314,6 +6315,33 @@ func TestParseStringTemplate(t *testing.T) {
 		)
 	})
 
+	t.Run("invalid, nested expression paren", func(t *testing.T) {
+
+		t.Parallel()
+
+		_, errs := testParseExpression(`
+			"\((2+2)/2()"
+		`)
+
+		var err error
+		if len(errs) > 0 {
+			err = Error{
+				Errors: errs,
+			}
+		}
+
+		require.Error(t, err)
+		utils.AssertEqualWithDiff(t,
+			[]error{
+				&SyntaxError{
+					Message: "expected token ')'",
+					Pos:     ast.Position{Offset: 16, Line: 2, Column: 15},
+				},
+			},
+			errs,
+		)
+	})
+
 	t.Run("invalid, nested templates", func(t *testing.T) {
 
 		t.Parallel()
@@ -6478,6 +6506,45 @@ func TestParseStringTemplate(t *testing.T) {
 
 		AssertEqualWithDiff(t, expected, actual)
 	})
+
+	t.Run("valid, extra closing paren", func(t *testing.T) {
+
+		t.Parallel()
+
+		actual, errs := testParseExpression(`
+			"\(a))"
+		`)
+
+		var err error
+		if len(errs) > 0 {
+			err = Error{
+				Errors: errs,
+			}
+		}
+
+		require.NoError(t, err)
+
+		expected := &ast.StringTemplateExpression{
+			Values: []string{
+				"",
+				")",
+			},
+			Expressions: []ast.Expression{
+				&ast.IdentifierExpression{
+					Identifier: ast.Identifier{
+						Identifier: "a",
+						Pos:        ast.Position{Offset: 7, Line: 2, Column: 6},
+					},
+				},
+			},
+			Range: ast.Range{
+				StartPos: ast.Position{Offset: 4, Line: 2, Column: 3},
+				EndPos:   ast.Position{Offset: 10, Line: 2, Column: 9},
+			},
+		}
+
+		utils.AssertEqualWithDiff(t, expected, actual)
+	})
 }
 
 func TestParseNilCoalescing(t *testing.T) {

sema/string_test.go

@@ -743,6 +743,27 @@ func TestCheckStringTemplate(t *testing.T) {
 		assert.IsType(t, &sema.TypeMismatchWithDescriptionError{}, errs[0])
 	})
 
+	t.Run("invalid, struct with tostring", func(t *testing.T) {
+
+		t.Parallel()
+
+		_, err := ParseAndCheck(t, `
+			access(all)
+			struct SomeStruct {
+				access(all)
+				view fun toString(): String {
+					return "SomeStruct"
+				}
+			}
+			let a = SomeStruct()
+			let x: String = "\(a)" 
+		`)
+
+		errs := RequireCheckerErrors(t, err, 1)
+
+		assert.IsType(t, &sema.TypeMismatchWithDescriptionError{}, errs[0])
+	})
+
 	t.Run("invalid, array", func(t *testing.T) {
 		t.Parallel()
 
@@ -788,4 +809,18 @@ func TestCheckStringTemplate(t *testing.T) {
 
 		assert.IsType(t, &sema.TypeMismatchWithDescriptionError{}, errs[0])
 	})
+
+	t.Run("invalid, expression type", func(t *testing.T) {
+
+		t.Parallel()
+
+		_, err := ParseAndCheck(t, `
+			let y: Int = 0
+			let x: String = "\(y > 0 ? "String" : true)"
+		`)
+
+		errs := RequireCheckerErrors(t, err, 1)
+
+		assert.IsType(t, &sema.TypeMismatchWithDescriptionError{}, errs[0])
+	})
 }