Add external mutability improvements

runtime/account_test.go

@@ -1451,10 +1451,23 @@ func TestRuntimePublicKey(t *testing.T) {
 		}
 		addPublicKeyValidation(runtimeInterface, nil)
 
-		_, err := executeScript(script, runtimeInterface)
-		errs := checker.RequireCheckerErrors(t, err, 1)
+		value, err := executeScript(script, runtimeInterface)
+		require.NoError(t, err)
 
-		assert.IsType(t, &sema.ExternalMutationError{}, errs[0])
+		expected := cadence.Struct{
+			StructType: PublicKeyType,
+			Fields: []cadence.Value{
+				// Public key (bytes)
+				newBytesValue([]byte{1, 2}),
+
+				// Signature Algo
+				newSignAlgoValue(sema.SignatureAlgorithmECDSA_P256),
+			},
+		}
+
+		expected = cadence.ValueWithCachedTypeID(expected)
+
+		assert.Equal(t, expected, value)
 	})
 
 	t.Run("raw-key reference mutability", func(t *testing.T) {
@@ -1467,7 +1480,7 @@ func TestRuntimePublicKey(t *testing.T) {
                 signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
             )
 
-            var publickeyRef = &publicKey.publicKey as &[UInt8]
+            var publickeyRef = &publicKey.publicKey as auth(Mutate) &[UInt8]
             publickeyRef[0] = 3
 
             return publicKey
@@ -1885,9 +1898,7 @@ func TestAuthAccountContracts(t *testing.T) {
 				Location:  nextTransactionLocation(),
 			},
 		)
-		errs := checker.RequireCheckerErrors(t, err, 1)
-
-		assert.IsType(t, &sema.ExternalMutationError{}, errs[0])
+		require.NoError(t, err)
 	})
 
 	t.Run("update names through reference", func(t *testing.T) {
@@ -1898,7 +1909,7 @@ func TestAuthAccountContracts(t *testing.T) {
 		script := []byte(`
             transaction {
                 prepare(signer: AuthAccount) {
-                    var namesRef = &signer.contracts.names as &[String]
+                    var namesRef = &signer.contracts.names as auth(Mutate) &[String]
                     namesRef[0] = "baz"
 
                     assert(signer.contracts.names[0] == "foo")
@@ -2097,7 +2108,7 @@ func TestPublicAccountContracts(t *testing.T) {
 			},
 		}
 
-		_, err := rt.ExecuteScript(
+		result, err := rt.ExecuteScript(
 			Script{
 				Source: script,
 			},
@@ -2106,9 +2117,14 @@ func TestPublicAccountContracts(t *testing.T) {
 				Location:  common.ScriptLocation{},
 			},
 		)
-		errs := checker.RequireCheckerErrors(t, err, 1)
+		require.NoError(t, err)
+
+		require.IsType(t, cadence.Array{}, result)
+		array := result.(cadence.Array)
 
-		assert.IsType(t, &sema.ExternalMutationError{}, errs[0])
+		require.Len(t, array.Values, 2)
+		assert.Equal(t, cadence.String("foo"), array.Values[0])
+		assert.Equal(t, cadence.String("bar"), array.Values[1])
 	})
 
 	t.Run("append names", func(t *testing.T) {
@@ -2133,7 +2149,7 @@ func TestPublicAccountContracts(t *testing.T) {
 			},
 		}
 
-		_, err := rt.ExecuteScript(
+		result, err := rt.ExecuteScript(
 			Script{
 				Source: script,
 			},
@@ -2142,9 +2158,14 @@ func TestPublicAccountContracts(t *testing.T) {
 				Location:  common.ScriptLocation{},
 			},
 		)
-		errs := checker.RequireCheckerErrors(t, err, 1)
+		require.NoError(t, err)
+
+		require.IsType(t, cadence.Array{}, result)
+		array := result.(cadence.Array)
 
-		assert.IsType(t, &sema.ExternalMutationError{}, errs[0])
+		require.Len(t, array.Values, 2)
+		assert.Equal(t, cadence.String("foo"), array.Values[0])
+		assert.Equal(t, cadence.String("bar"), array.Values[1])
 	})
 }
 

runtime/attachments_test.go

@@ -171,10 +171,20 @@ func TestAccountAttachmentExportFailure(t *testing.T) {
 		import Test from 0x1
 		access(all) fun main(): &Test.A? { 
 			let r <- Test.makeRWithA()
-			let a = r[Test.A]
+			var a = r[Test.A]
+
+			// Life span of attachments (references) are validated statically.
+			// This indirection helps to trick the checker and causes to perform the validation at runtime,
+			// which is the intention of this test.
+			a = returnSameRef(a)
+
 			destroy r
 			return a
 		}
+
+		access(all) fun returnSameRef(_ ref: &Test.A?): &Test.A? {
+		    return ref
+		}
 	 `)
 
 	runtimeInterface1 := &testRuntimeInterface{

runtime/capabilitycontrollers_test.go

@@ -82,7 +82,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
                       /// > Our version of quicksort is not the fastest possible,
                       /// > but it's one of the simplest.
                       ///
-                      access(all) fun quickSort(_ items: &[AnyStruct], isLess: fun(Int, Int): Bool) {
+                      access(all) fun quickSort(_ items: auth(Mutate) &[AnyStruct], isLess: fun(Int, Int): Bool) {
 
                           fun quickSortPart(leftIndex: Int, rightIndex: Int) {
 
@@ -92,6 +92,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
                               let pivotIndex = (leftIndex + rightIndex) / 2
 
+                              items[pivotIndex] <-> items[leftIndex]
                               items[pivotIndex] <-> items[leftIndex]
 
                               var lastIndex = leftIndex
@@ -1195,7 +1196,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
                           assert(controllers1.length == 3)
 
                           Test.quickSort(
-                              &controllers1 as &[AnyStruct],
+                              &controllers1 as auth(Mutate) &[AnyStruct],
                               isLess: fun(i: Int, j: Int): Bool {
                                   let a = controllers1[i]
                                   let b = controllers1[j]
@@ -1293,7 +1294,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
                           assert(controllers1.length == 3)
 
                           Test.quickSort(
-                              &controllers1 as &[AnyStruct],
+                              &controllers1 as auth(Mutate) &[AnyStruct],
                               isLess: fun(i: Int, j: Int): Bool {
                                   let a = controllers1[i]
                                   let b = controllers1[j]
@@ -1644,7 +1645,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
                           assert(controllers.length == 3)
 
                           Test.quickSort(
-                              &controllers as &[AnyStruct],
+                              &controllers as auth(Mutate) &[AnyStruct],
                               isLess: fun(i: Int, j: Int): Bool {
                                   let a = controllers[i]
                                   let b = controllers[j]
@@ -1722,7 +1723,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
                           assert(controllers.length == 3)
 
                           Test.quickSort(
-                              &controllers as &[AnyStruct],
+                              &controllers as auth(Mutate) &[AnyStruct],
                               isLess: fun(i: Int, j: Int): Bool {
                                   let a = controllers[i]
                                   let b = controllers[j]
@@ -1977,7 +1978,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
                               let controllers1Before = signer.capabilities.storage.getControllers(forPath: storagePath1)
                               Test.quickSort(
-                                  &controllers1Before as &[AnyStruct],
+                                  &controllers1Before as auth(Mutate) &[AnyStruct],
                                   isLess: fun(i: Int, j: Int): Bool {
                                       let a = controllers1Before[i]
                                       let b = controllers1Before[j]
@@ -1991,7 +1992,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
                               let controllers2Before = signer.capabilities.storage.getControllers(forPath: storagePath2)
                               Test.quickSort(
-                                  &controllers2Before as &[AnyStruct],
+                                  &controllers2Before as auth(Mutate) &[AnyStruct],
                                   isLess: fun(i: Int, j: Int): Bool {
                                       let a = controllers2Before[i]
                                       let b = controllers2Before[j]
@@ -2015,7 +2016,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
                               let controllers1After = signer.capabilities.storage.getControllers(forPath: storagePath1)
                               Test.quickSort(
-                                  &controllers1After as &[AnyStruct],
+                                  &controllers1After as auth(Mutate) &[AnyStruct],
                                   isLess: fun(i: Int, j: Int): Bool {
                                       let a = controllers1After[i]
                                       let b = controllers1After[j]
@@ -2028,7 +2029,7 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
                               let controllers2After = signer.capabilities.storage.getControllers(forPath: storagePath2)
                               Test.quickSort(
-                                  &controllers2After as &[AnyStruct],
+                                  &controllers2After as auth(Mutate) &[AnyStruct],
                                   isLess: fun(i: Int, j: Int): Bool {
                                       let a = controllers2After[i]
                                       let b = controllers2After[j]

runtime/convertValues_test.go

@@ -1912,7 +1912,7 @@ func TestExportReferenceValue(t *testing.T) {
 	            var v:[AnyStruct] = []
 	            acct.save(v, to: /storage/x)
 
-                var ref = acct.borrow<&[AnyStruct]>(from: /storage/x)!
+                var ref = acct.borrow<auth(Insert) &[AnyStruct]>(from: /storage/x)!
 	            ref.append(ref)
 	            return ref
             }
@@ -1947,7 +1947,7 @@ func TestExportReferenceValue(t *testing.T) {
 	            var v:[AnyStruct] = []
 	            acct.save(v, to: /storage/x)
 
-                var ref1 = acct.borrow<&[AnyStruct]>(from: /storage/x)!
+                var ref1 = acct.borrow<auth(Insert) &[AnyStruct]>(from: /storage/x)!
                 var ref2 = acct.borrow<&[AnyStruct]>(from: /storage/x)!
 
 	            ref1.append(ref2)

runtime/interpreter/interpreter.go

@@ -4451,7 +4451,22 @@ var AuthAccountReferenceStaticType = ReferenceStaticType{
 }
 
 func (interpreter *Interpreter) getEntitlement(typeID common.TypeID) (*sema.EntitlementType, error) {
-	location, _, _ := common.DecodeTypeID(interpreter, string(typeID))
+	location, qualifiedIdentifier, err := common.DecodeTypeID(interpreter, string(typeID))
+	if err != nil {
+		return nil, err
+	}
+
+	if location == nil {
+		ty := sema.BuiltinEntitlements[qualifiedIdentifier]
+		if ty == nil {
+			return nil, TypeLoadingError{
+				TypeID: typeID,
+			}
+		}
+
+		return ty, nil
+	}
+
 	elaboration := interpreter.getElaboration(location)
 	if elaboration == nil {
 		return nil, TypeLoadingError{
@@ -4470,7 +4485,22 @@ func (interpreter *Interpreter) getEntitlement(typeID common.TypeID) (*sema.Enti
 }
 
 func (interpreter *Interpreter) getEntitlementMapType(typeID common.TypeID) (*sema.EntitlementMapType, error) {
-	location, _, _ := common.DecodeTypeID(interpreter, string(typeID))
+	location, qualifiedIdentifier, err := common.DecodeTypeID(interpreter, string(typeID))
+	if err != nil {
+		return nil, err
+	}
+
+	if location == nil {
+		ty := sema.BuiltinEntitlementMappings[qualifiedIdentifier]
+		if ty == nil {
+			return nil, TypeLoadingError{
+				TypeID: typeID,
+			}
+		}
+
+		return ty, nil
+	}
+
 	elaboration := interpreter.getElaboration(location)
 	if elaboration == nil {
 		return nil, TypeLoadingError{
@@ -4691,10 +4721,17 @@ func (interpreter *Interpreter) getAccessOfMember(self Value, identifier string)
 	return &member.Resolve(interpreter, identifier, ast.EmptyRange, func(err error) {}).Access
 }
 
-func (interpreter *Interpreter) mapMemberValueAuthorization(self Value, memberAccess *sema.Access, resultValue Value) Value {
+func (interpreter *Interpreter) mapMemberValueAuthorization(
+	self Value,
+	memberAccess *sema.Access,
+	resultValue Value,
+	resultingType sema.Type,
+) Value {
+
 	if memberAccess == nil {
 		return resultValue
 	}
+
 	if mappedAccess, isMappedAccess := (*memberAccess).(sema.EntitlementMapAccess); isMappedAccess {
 		var auth Authorization
 		switch selfValue := self.(type) {
@@ -4706,7 +4743,16 @@ func (interpreter *Interpreter) mapMemberValueAuthorization(self Value, memberAc
 			}
 			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, imageAccess)
 		default:
-			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, mappedAccess.Codomain())
+			var access sema.Access
+			if mappedAccess.Type == sema.IdentityMappingType {
+				access = sema.AllSupportedEntitlements(resultingType)
+			}
+
+			if access == nil {
+				access = mappedAccess.Codomain()
+			}
+
+			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, access)
 		}
 
 		switch refValue := resultValue.(type) {
@@ -4721,15 +4767,21 @@ func (interpreter *Interpreter) mapMemberValueAuthorization(self Value, memberAc
 	return resultValue
 }
 
-func (interpreter *Interpreter) getMemberWithAuthMapping(self Value, locationRange LocationRange, identifier string) Value {
+func (interpreter *Interpreter) getMemberWithAuthMapping(
+	self Value,
+	locationRange LocationRange,
+	identifier string,
+	memberAccessInfo sema.MemberAccessInfo,
+) Value {
+
 	result := interpreter.getMember(self, locationRange, identifier)
 	if result == nil {
 		return nil
 	}
 	// once we have obtained the member, if it was declared with entitlement-mapped access, we must compute the output of the map based
-	// on the runtime authorizations of the acccessing reference or composite
+	// on the runtime authorizations of the accessing reference or composite
 	memberAccess := interpreter.getAccessOfMember(self, identifier)
-	return interpreter.mapMemberValueAuthorization(self, memberAccess, result)
+	return interpreter.mapMemberValueAuthorization(self, memberAccess, result, memberAccessInfo.ResultingType)
 }
 
 // getMember gets the member value by the given identifier from the given Value depending on its type.