Limited string templates: \(identifier)

runtime/ast/elementtype.go

@@ -85,4 +85,5 @@ const (
  ElementTypeForceExpression
  ElementTypePathExpression
  ElementTypeAttachExpression
+ ElementTypeStringTemplateExpression
 )

runtime/ast/expression.go

@@ -220,6 +220,73 @@ func (*StringExpression) precedence() precedence {
  return precedenceLiteral
 }
 
+// StringTemplateExpression
+
+type StringTemplateExpression struct {
+ Values []string
+ Expressions []Expression
+ Range
+}
+
+var _ Expression = &StringTemplateExpression{}
+
+func NewStringTemplateExpression(
+ gauge common.MemoryGauge,
+ values []string,
+ exprs []Expression,
+ exprRange Range,
+) *StringTemplateExpression {
+ common.UseMemory(gauge, common.NewStringTemplateExpressionMemoryUsage(len(values)+len(exprs)))
+ return &StringTemplateExpression{
+ Values: values,
+ Expressions: exprs,
+ Range: exprRange,
+ }
+}
+
+var _ Element = &StringExpression{}
+var _ Expression = &StringExpression{}
+
+func (*StringTemplateExpression) ElementType() ElementType {
+ return ElementTypeStringTemplateExpression
+}
+
+func (*StringTemplateExpression) isExpression() {}
+
+func (*StringTemplateExpression) isIfStatementTest() {}
+
+func (*StringTemplateExpression) Walk(_ func(Element)) {
+ // NO-OP
+}
+
+func (e *StringTemplateExpression) String() string {
+ return Prettier(e)
+}
+
+func (e *StringTemplateExpression) Doc() prettier.Doc {
+ if len(e.Expressions) == 0 {
+ return prettier.Text(e.Values[0])
+ }
+
+ // TODO: must reproduce expressions as literals
+ panic("not implemented")
+}
+
+func (e *StringTemplateExpression) MarshalJSON() ([]byte, error) {
+ type Alias StringTemplateExpression
+ return json.Marshal(&struct {
+ *Alias
+ Type string
+ }{
+ Type: "StringTemplateExpression",
+ Alias: (*Alias)(e),
+ })
+}
+
+func (*StringTemplateExpression) precedence() precedence {
+ return precedenceLiteral
+}
+
 // IntegerExpression
 
 type IntegerExpression struct {

runtime/ast/expression_extractor.go

@@ -48,6 +48,10 @@ type StringExtractor interface {
  ExtractString(extractor *ExpressionExtractor, expression *StringExpression) ExpressionExtraction
 }
 
+type StringTemplateExtractor interface {
+ ExtractStringTemplate(extractor *ExpressionExtractor, expression *StringTemplateExpression) ExpressionExtraction
+}
+
 type ArrayExtractor interface {
  ExtractArray(extractor *ExpressionExtractor, expression *ArrayExpression) ExpressionExtraction
 }
@@ -117,31 +121,32 @@ type AttachExtractor interface {
 }
 
 type ExpressionExtractor struct {
- IndexExtractor IndexExtractor
- ForceExtractor ForceExtractor
- BoolExtractor BoolExtractor
- NilExtractor NilExtractor
- IntExtractor IntExtractor
- FixedPointExtractor FixedPointExtractor
- StringExtractor StringExtractor
- ArrayExtractor ArrayExtractor
- DictionaryExtractor DictionaryExtractor
- IdentifierExtractor IdentifierExtractor
- AttachExtractor AttachExtractor
- MemoryGauge common.MemoryGauge
- VoidExtractor VoidExtractor
- UnaryExtractor UnaryExtractor
- ConditionalExtractor ConditionalExtractor
- InvocationExtractor InvocationExtractor
- BinaryExtractor BinaryExtractor
- FunctionExtractor FunctionExtractor
- CastingExtractor CastingExtractor
- CreateExtractor CreateExtractor
- DestroyExtractor DestroyExtractor
- ReferenceExtractor ReferenceExtractor
- MemberExtractor MemberExtractor
- PathExtractor PathExtractor
- nextIdentifier int
+ IndexExtractor IndexExtractor
+ ForceExtractor ForceExtractor
+ BoolExtractor BoolExtractor
+ NilExtractor NilExtractor
+ IntExtractor IntExtractor
+ FixedPointExtractor FixedPointExtractor
+ StringExtractor StringExtractor
+ StringTemplateExtractor StringTemplateExtractor
+ ArrayExtractor ArrayExtractor
+ DictionaryExtractor DictionaryExtractor
+ IdentifierExtractor IdentifierExtractor
+ AttachExtractor AttachExtractor
+ MemoryGauge common.MemoryGauge
+ VoidExtractor VoidExtractor
+ UnaryExtractor UnaryExtractor
+ ConditionalExtractor ConditionalExtractor
+ InvocationExtractor InvocationExtractor
+ BinaryExtractor BinaryExtractor
+ FunctionExtractor FunctionExtractor
+ CastingExtractor CastingExtractor
+ CreateExtractor CreateExtractor
+ DestroyExtractor DestroyExtractor
+ ReferenceExtractor ReferenceExtractor
+ MemberExtractor MemberExtractor
+ PathExtractor PathExtractor
+ nextIdentifier int
 }
 
 var _ ExpressionVisitor[ExpressionExtraction] = &ExpressionExtractor{}
@@ -271,6 +276,35 @@ func (extractor *ExpressionExtractor) ExtractString(expression *StringExpression
  return rewriteExpressionAsIs(expression)
 }
 
+func (extractor *ExpressionExtractor) VisitStringTemplateExpression(expression *StringTemplateExpression) ExpressionExtraction {
+
+ // delegate to child extractor, if any,
+ // or call default implementation
+
+ if extractor.StringTemplateExtractor != nil {
+ return extractor.StringTemplateExtractor.ExtractStringTemplate(extractor, expression)
+ }
+ return extractor.ExtractStringTemplate(expression)
+}
+
+func (extractor *ExpressionExtractor) ExtractStringTemplate(expression *StringTemplateExpression) ExpressionExtraction {
+
+ // copy the expression
+ newExpression := *expression
+
+ // rewrite all value expressions
+
+ rewrittenExpressions, extractedExpressions :=
+ extractor.VisitExpressions(expression.Expressions)
+
+ newExpression.Expressions = rewrittenExpressions
+
+ return ExpressionExtraction{
+ RewrittenExpression: &newExpression,
+ ExtractedExpressions: extractedExpressions,
+ }
+}
+
 func (extractor *ExpressionExtractor) VisitArrayExpression(expression *ArrayExpression) ExpressionExtraction {
 
  // delegate to child extractor, if any,

runtime/ast/precedence.go

@@ -83,6 +83,7 @@ const (
  // - BoolExpression
  // - NilExpression
  // - StringExpression
+ // - StringTemplateExpression
  // - IntegerExpression
  // - FixedPointExpression
  // - ArrayExpression

runtime/ast/string_template_test.go

@@ -0,0 +1,47 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/turbolent/prettier"
+)
+
+func TestStringTemplate_Doc(t *testing.T) {
+
+ t.Parallel()
+
+ stmt := &StringTemplateExpression{
+ Values: []string{
+ "abc",
+ },
+ Expressions: []Expression{},
+ Range: Range{
+ StartPos: Position{Offset: 4, Line: 2, Column: 3},
+ EndPos: Position{Offset: 11, Line: 2, Column: 10},
+ },
+ }
+
+ assert.Equal(t,
+ prettier.Text("abc"),
+ stmt.Doc(),
+ )
+}

runtime/ast/visitor.go

@@ -183,6 +183,7 @@ type ExpressionVisitor[T any] interface {
  VisitNilExpression(*NilExpression) T
  VisitBoolExpression(*BoolExpression) T
  VisitStringExpression(*StringExpression) T
+ VisitStringTemplateExpression(*StringTemplateExpression) T
  VisitIntegerExpression(*IntegerExpression) T
  VisitFixedPointExpression(*FixedPointExpression) T
  VisitDictionaryExpression(*DictionaryExpression) T
@@ -219,6 +220,9 @@ func AcceptExpression[T any](expression Expression, visitor ExpressionVisitor[T]
  case ElementTypeStringExpression:
  return visitor.VisitStringExpression(expression.(*StringExpression))
 
+ case ElementTypeStringTemplateExpression:
+ return visitor.VisitStringTemplateExpression(expression.(*StringTemplateExpression))
+
  case ElementTypeIntegerExpression:
  return visitor.VisitIntegerExpression(expression.(*IntegerExpression))
 

runtime/common/memorykind.go

@@ -204,6 +204,7 @@ const (
  MemoryKindIntegerExpression
  MemoryKindFixedPointExpression
  MemoryKindArrayExpression
+ MemoryKindStringTemplateExpression
  MemoryKindDictionaryExpression
  MemoryKindIdentifierExpression
  MemoryKindInvocationExpression