Merge branch 'master' of https://github.com/onflow/cadence into supun…

…/vm-cadence-1.0

.github/workflows/compatibility-check-template.yml

@@ -108,6 +108,7 @@ jobs:
           path: |
             ./tmp/output-old.txt
             ./tmp/output-new.txt
+            ./tmp/contracts.csv
 
       # Check Diff
 

.github/workflows/get-contracts.yml

@@ -0,0 +1,52 @@
+name: Get contracts
+
+on:
+  workflow_call:
+    inputs:
+      chain:
+        required: true
+        type: string
+    secrets:
+      FLOWDIVER_API_KEY:
+        required: true
+
+env:
+  GO_VERSION: '1.22'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.run_id }}-${{ inputs.chain }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v4
+        with:
+          go-version: ${{ env.GO_VERSION }}
+          cache: true
+
+      - name: Make output dirs
+        run: |
+          mkdir tmp
+
+      # Get contracts
+
+      - name: Download contracts
+        env:
+          FLOWDIVER_API_KEY: ${{ secrets.FLOWDIVER_API_KEY }}
+        working-directory: ./tools/get-contracts
+        run: |
+          go run . --chain=${{ inputs.chain }} --apiKey="$FLOWDIVER_API_KEY" > ../../tmp/contracts.csv
+
+      # Upload
+
+      - name: Upload
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ inputs.chain }}-contracts
+          path: |
+            ./tmp/contracts.csv

Makefile

@@ -64,7 +64,7 @@ ci:
 	# test all packages
 	go test -coverprofile=coverage.txt -covermode=atomic -parallel 8 -race -coverpkg $(COVERPKGS) ./...
 	# run interpreter smoke tests. results from run above are reused, so no tests runs are duplicated
-	go test -count=5 ./tests/interpreter/... -runSmokeTests=true -validateAtree=false
+	go test -count=5 ./interpreter/... -runSmokeTests=true -validateAtree=false
 	# remove coverage of empty functions from report
 	sed -i -e 's/^.* 0 0$$//' coverage.txt
 

ast/elementtype.go

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

ast/expression.go

@@ -220,6 +220,81 @@ func (*StringExpression) precedence() precedence {
 	return precedenceLiteral
 }
 
+// StringTemplateExpression
+
+type StringTemplateExpression struct {
+	// Values and Expressions are assumed to be interleaved, V[0] + E[0] + V[1] + ... + E[n-1] + V[n]
+	// this is enforced in the parser e.g. "a\(b)c" will be parsed as follows
+	// Values: 			[]string{"a","c"}
+	// Expressions:		[]Expression{b}
+	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)))
+	if len(values) != len(exprs)+1 {
+		// assert string template alternating structure
+		panic(errors.NewUnreachableError())
+	}
+	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 (e *StringTemplateExpression) Walk(walkChild func(Element)) {
+	walkExpressions(walkChild, e.Expressions)
+}
+
+func (e *StringTemplateExpression) String() string {
+	return Prettier(e)
+}
+
+func (e *StringTemplateExpression) Doc() prettier.Doc {
+	if len(e.Expressions) == 0 {
+		return prettier.Text(QuoteString(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 {
@@ -1416,7 +1491,7 @@ func FunctionDocument(
 	}
 
 	// NOTE: not all functions have a parameter list,
-	// e.g. the `destroy` special function
+	// e.g. the `init` (initializer, special function)
 	if parameterList != nil {
 
 		signatureDoc = append(

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,

ast/precedence.go

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

ast/string_template_test.go

@@ -0,0 +1,48 @@
+/*
+ * 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(),
+	)
+}

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))
 

bbq/compiler/compiler.go

@@ -972,6 +972,11 @@ func (c *Compiler) VisitStringExpression(expression *ast.StringExpression) (_ st
 	return
 }
 
+func (c *Compiler) VisitStringTemplateExpression(_ *ast.StringTemplateExpression) (_ struct{}) {
+	// TODO
+	panic(errors.NewUnreachableError())
+}
+
 func (c *Compiler) VisitCastingExpression(expression *ast.CastingExpression) (_ struct{}) {
 	c.compileExpression(expression.Expression)
 

bbq/vm/config.go

@@ -24,7 +24,7 @@ import (
 	"github.com/onflow/cadence/interpreter"
 	"github.com/onflow/cadence/sema"
 	"github.com/onflow/cadence/stdlib"
-	"github.com/onflow/cadence/tests/utils"
+	"github.com/onflow/cadence/test_utils/common_utils"
 )
 
 type Config struct {
@@ -68,7 +68,7 @@ func (c *Config) interpreter() *interpreter.Interpreter {
 	if c.inter == nil {
 		inter, err := interpreter.NewInterpreter(
 			nil,
-			utils.TestLocation,
+			common_utils.TestLocation,
 			&interpreter.Config{
 				Storage:               c.Storage,
 				ImportLocationHandler: nil,