Add v0.42 parser package under old_parser

runtime/ast/access.go

@@ -215,6 +215,7 @@
 	AccessContract
 	AccessAccount
 	AccessAll
+	AccessPubSettableLegacy // Deprecated
 )
 
 func PrimitiveAccessCount() int {
@@ -253,6 +254,8 @@
 		return "access(account)"
 	case AccessContract:
 		return "access(contract)"
+	case AccessPubSettableLegacy:
+		return "pub(set)"
 	}
 
 	panic(errors.NewUnreachableError())
@@ -270,6 +273,8 @@
 		return "account"
 	case AccessContract:
 		return "contract"
+	case AccessPubSettableLegacy:
+		return "legacy public settable"
 	}
 
 	panic(errors.NewUnreachableError())

runtime/ast/type.go

@@ -537,9 +537,10 @@ func (t *FunctionType) CheckEqual(other Type, checker TypeEqualityChecker) error
 
 // ReferenceType
 type ReferenceType struct {
-	Type          Type          `json:"ReferencedType"`
-	StartPos      Position      `json:"-"`
-	Authorization Authorization `json:"Authorization"`
+	Type             Type     `json:"ReferencedType"`
+	StartPos         Position `json:"-"`
+	LegacyAuthorized bool
+	Authorization    Authorization `json:"Authorization"`
 }
 
 var _ Type = &ReferenceType{}
@@ -634,7 +635,8 @@ func (t *ReferenceType) CheckEqual(other Type, checker TypeEqualityChecker) erro
 // IntersectionType
 
 type IntersectionType struct {
-	Types []*NominalType
+	LegacyRestrictedType Type // Deprecated
+	Types                []*NominalType
 	Range
 }
 

runtime/ast/type_test.go

@@ -1205,6 +1205,7 @@ func TestReferenceType_MarshalJSON(t *testing.T) {
 		`
         {
             "Type": "ReferenceType",
+			"LegacyAuthorized": false,
             "Authorization": {
 				 "ConjunctiveElements": [
 					{ 
@@ -1347,6 +1348,7 @@ func TestIntersectionType_MarshalJSON(t *testing.T) {
 		`
         {
             "Type": "IntersectionType",
+			"LegacyRestrictedType": null,
             "Types": [
                 {
                     "Type": "NominalType",

runtime/common/declarationkind.go

@@ -44,6 +44,7 @@
 	DeclarationKindEvent
 	DeclarationKindField
 	DeclarationKindInitializer
+	DeclarationKindDestructorLegacy
 	DeclarationKindStructureInterface
 	DeclarationKindResourceInterface
 	DeclarationKindContractInterface
@@ -116,6 +117,8 @@
 		return "field"
 	case DeclarationKindInitializer:
 		return "initializer"
+	case DeclarationKindDestructorLegacy:
+		return "legacy destructor"
 	case DeclarationKindAttachment:
 		return "attachment"
 	case DeclarationKindStructureInterface:
@@ -173,6 +176,8 @@
 		return "event"
 	case DeclarationKindInitializer:
 		return "init"
+	case DeclarationKindDestructorLegacy: // Deprecated
+		return "destroy"
 	case DeclarationKindAttachment:
 		return "attachment"
 	case DeclarationKindStructureInterface:

runtime/old_parser/benchmark_test.go

@@ -0,0 +1,230 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Dapper Labs, Inc.
+ *
+ * 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 old_parser
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/onflow/cadence/runtime/common"
+)
+
+func BenchmarkParseDeploy(b *testing.B) {
+
+	b.Run("byte array", func(b *testing.B) {
+
+		var builder strings.Builder
+		for i := 0; i < 15000; i++ {
+			if i > 0 {
+				builder.WriteString(", ")
+			}
+			builder.WriteString(strconv.Itoa(rand.Intn(math.MaxUint8)))
+		}
+
+		transaction := []byte(fmt.Sprintf(`
+              transaction {
+                execute {
+                  AuthAccount(publicKeys: [], code: [%s])
+                }
+              }
+            `,
+			builder.String(),
+		))
+
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			_, err := ParseProgram(nil, transaction, Config{})
+			if err != nil {
+				b.FailNow()
+			}
+		}
+	})
+
+	b.Run("decode hex", func(b *testing.B) {
+
+		var builder strings.Builder
+		for i := 0; i < 15000; i++ {
+			builder.WriteString(fmt.Sprintf("%02x", i))
+		}
+
+		transaction := []byte(fmt.Sprintf(`
+              transaction {
+                execute {
+                  AuthAccount(publicKeys: [], code: "%s".decodeHex())
+                }
+              }
+            `,
+			builder.String(),
+		))
+
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			_, err := ParseProgram(nil, transaction, Config{})
+			if err != nil {
+				b.FailNow()
+			}
+		}
+	})
+}
+
+const fungibleTokenContract = `
+pub contract FungibleToken {
+
+    pub resource interface Provider {
+        pub fun withdraw(amount: Int): @Vault {
+            pre {
+                amount > 0:
+                    "Withdrawal amount must be positive"
+            }
+            post {
+                result.balance == amount:
+                    "Incorrect amount returned"
+            }
+        }
+    }
+
+    pub resource interface Receiver {
+        pub balance: Int
+
+        init(balance: Int) {
+            pre {
+                balance >= 0:
+                    "Initial balance must be non-negative"
+            }
+            post {
+                self.balance == balance:
+                    "Balance must be initialized to the initial balance"
+            }
+        }
+
+        pub fun deposit(from: @Receiver) {
+            pre {
+                from.balance > 0:
+                    "Deposit balance needs to be positive!"
+            }
+            post {
+                self.balance == before(self.balance) + before(from.balance):
+                    "Incorrect amount removed"
+            }
+        }
+    }
+
+    pub resource Vault: Provider, Receiver {
+
+        pub var balance: Int
+
+        init(balance: Int) {
+            self.balance = balance
+        }
+
+        pub fun withdraw(amount: Int): @Vault {
+            self.balance = self.balance - amount
+            return <-create Vault(balance: amount)
+        }
+
+        // transfer combines withdraw and deposit into one function call
+        pub fun transfer(to: &Receiver, amount: Int) {
+            pre {
+                amount <= self.balance:
+                    "Insufficient funds"
+            }
+            post {
+                self.balance == before(self.balance) - amount:
+                    "Incorrect amount removed"
+            }
+            to.deposit(from: <-self.withdraw(amount: amount))
+        }
+
+        pub fun deposit(from: @Receiver) {
+            self.balance = self.balance + from.balance
+            destroy from
+        }
+
+        pub fun createEmptyVault(): @Vault {
+            return <-create Vault(balance: 0)
+        }
+    }
+
+    pub fun createEmptyVault(): @Vault {
+        return <-create Vault(balance: 0)
+    }
+
+    pub resource VaultMinter {
+        pub fun mintTokens(amount: Int, recipient: &Receiver) {
+            recipient.deposit(from: <-create Vault(balance: amount))
+        }
+    }
+
+    init() {
+        let oldVault <- self.account.storage[Vault] <- create Vault(balance: 30)
+        destroy oldVault
+
+        let oldMinter <- self.account.storage[VaultMinter] <- create VaultMinter()
+        destroy oldMinter
+    }
+}
+`
+
+type testMemoryGauge struct {
+	meter map[common.MemoryKind]uint64
+}
+
+func (g *testMemoryGauge) MeterMemory(usage common.MemoryUsage) error {
+	g.meter[usage.Kind] += usage.Amount
+	return nil
+}
+
+func BenchmarkParseFungibleToken(b *testing.B) {
+
+	code := []byte(fungibleTokenContract)
+
+	b.Run("Without memory metering", func(b *testing.B) {
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			_, err := ParseProgram(nil, code, Config{})
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+
+	b.Run("With memory metering", func(b *testing.B) {
+		meter := &testMemoryGauge{
+			meter: make(map[common.MemoryKind]uint64),
+		}
+
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			_, err := ParseProgram(meter, code, Config{})
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}