Change member access semantics

runtime/attachments_test.go

@@ -170,10 +170,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/interpreter/interpreter_expression.go

@@ -144,7 +144,10 @@ func (interpreter *Interpreter) valueIndexExpressionGetterSetter(indexExpression
 			if isNestedResourceMove {
 				return target.RemoveKey(interpreter, locationRange, transferredIndexingValue)
 			} else {
-				return target.GetKey(interpreter, locationRange, transferredIndexingValue)
+				value := target.GetKey(interpreter, locationRange, transferredIndexingValue)
+
+				// If the indexing value is a reference, then return a reference for the resulting value.
+				return interpreter.maybeGetReference(indexExpression, value)
 			}
 		},
 		set: func(value Value) {
@@ -169,6 +172,12 @@ func (interpreter *Interpreter) memberExpressionGetterSetter(memberExpression *a
 
 	isNestedResourceMove := interpreter.Program.Elaboration.IsNestedResourceMoveExpression(memberExpression)
 
+	memberInfo, ok := interpreter.Program.Elaboration.MemberExpressionMemberInfo(memberExpression)
+	if !ok {
+		panic(errors.NewUnreachableError())
+	}
+	memberType := memberInfo.Member.TypeAnnotation.Type
+
 	return getterSetter{
 		target: target,
 		get: func(allowMissing bool) Value {
@@ -212,6 +221,13 @@ func (interpreter *Interpreter) memberExpressionGetterSetter(memberExpression *a
 				}
 			}
 
+			// Return a reference, if the member is accessed via a reference.
+			// This is pre-computed at the checker.
+			if memberInfo.ReturnReference {
+				// Get a reference to the value
+				resultValue = interpreter.getReferenceValue(resultValue, memberType)
+			}
+
 			return resultValue
 		},
 		set: func(value Value) {
@@ -222,6 +238,41 @@ func (interpreter *Interpreter) memberExpressionGetterSetter(memberExpression *a
 	}
 }
 
+// getReferenceValue Returns a reference to a given value.
+// Reference to an optional should return an optional reference.
+// This has to be done recursively for nested optionals.
+// e.g.1: Given type T, this method returns &T.
+// e.g.2: Given T?, this returns (&T)?
+func (interpreter *Interpreter) getReferenceValue(value Value, semaType sema.Type) Value {
+	switch value.(type) {
+	case NilValue, ReferenceValue:
+		// Reference to a nil, should return a nil.
+		// If the value is already a reference then return the same reference.
+		return value
+	}
+
+	optionalType, ok := semaType.(*sema.OptionalType)
+	if ok {
+		semaType = optionalType.Type
+
+		// Because the boxing happens further down the code, it is possible
+		// to have a concrete value (non-some) for a place where optional is expected.
+		// Therefore, always unwrap the type, but only unwrap if the value is `SomeValue`.
+		//
+		// However, checker guarantees that the wise-versa doesn't happen.
+		// i.e: There will never be a `SomeValue`, with type being a non-optional.
+
+		if optionalValue, ok := value.(*SomeValue); ok {
+			value = optionalValue.value
+		}
+		innerValue := interpreter.getReferenceValue(value, semaType)
+		return NewSomeValueNonCopying(interpreter, innerValue)
+	}
+
+	interpreter.maybeTrackReferencedResourceKindedValue(value)
+	return NewEphemeralReferenceValue(interpreter, UnauthorizedAccess, value, semaType)
+}
+
 func (interpreter *Interpreter) checkMemberAccess(
 	memberExpression *ast.MemberExpression,
 	target Value,
@@ -860,10 +911,28 @@ func (interpreter *Interpreter) VisitIndexExpression(expression *ast.IndexExpres
 			Location:    interpreter.Location,
 			HasPosition: expression,
 		}
-		return typedResult.GetKey(interpreter, locationRange, indexingValue)
+		value := typedResult.GetKey(interpreter, locationRange, indexingValue)
+
+		// If the indexing value is a reference, then return a reference for the resulting value.
+		return interpreter.maybeGetReference(expression, value)
 	}
 }
 
+func (interpreter *Interpreter) maybeGetReference(
+	expression *ast.IndexExpression,
+	memberValue Value,
+) Value {
+	indexExpressionTypes := interpreter.Program.Elaboration.IndexExpressionTypes(expression)
+	if indexExpressionTypes.ReturnReference {
+		elementType := indexExpressionTypes.IndexedType.ElementType(false)
+
+		// Get a reference to the value
+		memberValue = interpreter.getReferenceValue(memberValue, elementType)
+	}
+
+	return memberValue
+}
+
 func (interpreter *Interpreter) VisitConditionalExpression(expression *ast.ConditionalExpression) Value {
 	value, ok := interpreter.evalExpression(expression.Test).(BoolValue)
 	if !ok {

runtime/missingmember_test.go

@@ -3542,18 +3542,18 @@ access(all) contract AuctionDutch {
 		access(all) let currentPrice: UFix64
 		access(all) let totalItems: Int
 		access(all) let acceptedBids: Int
-		access(all) let tickStatus: {UFix64:TickStatus}
-		access(all) let metadata: {String:String}
-
-		init(status:String, currentPrice: UFix64, totalItems: Int, acceptedBids:Int,  startTime: UFix64, tickStatus: {UFix64:TickStatus}, metadata: {String:String}){
-			self.status=status
-			self.currentPrice=currentPrice
-			self.totalItems=totalItems
-			self.acceptedBids=acceptedBids
-			self.startTime=startTime
-			self.currentTime= 42.0 // Clock.time()
-			self.tickStatus=tickStatus
-			self.metadata=metadata
+		access(all) let tickStatus: &{UFix64:TickStatus}
+		access(all) let metadata: &{String:String}
+
+		init(status:String, currentPrice: UFix64, totalItems: Int, acceptedBids:Int,  startTime: UFix64, tickStatus: &{UFix64:TickStatus}, metadata: &{String:String}){
+			self.status = status
+			self.currentPrice = currentPrice
+			self.totalItems = totalItems
+			self.acceptedBids = acceptedBids
+			self.startTime = startTime
+			self.currentTime = 42.0 // Clock.time()
+			self.tickStatus = tickStatus
+			self.metadata = metadata
 		}
 	}
 
@@ -3573,7 +3573,7 @@ access(all) contract AuctionDutch {
 		}
 
 		access(all) fun getStatus(_ id: UInt64) : AuctionDutchStatus{
-			let item= self.getAuction(id)
+			let item = self.getAuction(id)
 			let currentTime= 42.0 // Clock.time()
 
 			var status="Ongoing"
@@ -3586,13 +3586,15 @@ access(all) contract AuctionDutch {
 			}
 
 
-			return AuctionDutchStatus(status: status,
-			currentPrice: currentPrice,
-			totalItems: item.numberOfItems,
-			acceptedBids: item.winningBids.length,
-			startTime: item.startAt(),
-			tickStatus: item.auctionStatus,
-			metadata:item.metadata)
+			return AuctionDutchStatus(
+			    status: status,
+			    currentPrice: currentPrice,
+			    totalItems: item.numberOfItems,
+			    acceptedBids: item.winningBids.length,
+			    startTime: item.startAt(),
+			    tickStatus: item.auctionStatus,
+			    metadata:item.metadata,
+            )
 		}
 
 		access(all) fun getBids(_ id:UInt64) : Bids {

runtime/resource_duplicate_test.go

@@ -168,7 +168,12 @@ func TestRuntimeResourceDuplicationUsingDestructorIteration(t *testing.T) {
 			},
 		)
 
-		require.ErrorAs(t, err, &interpreter.ContainerMutatedDuringIterationError{})
+		var checkerErr *sema.CheckerError
+		require.ErrorAs(t, err, &checkerErr)
+
+		errs := checker.RequireCheckerErrors(t, checkerErr, 2)
+		assert.IsType(t, &sema.TypeMismatchError{}, errs[0])
+		assert.IsType(t, &sema.TypeMismatchError{}, errs[1])
 	})
 
 	t.Run("simplified", func(t *testing.T) {
@@ -268,10 +273,11 @@ func TestRuntimeResourceDuplicationUsingDestructorIteration(t *testing.T) {
 		var checkerErr *sema.CheckerError
 		require.ErrorAs(t, err, &checkerErr)
 
-		errs := checker.RequireCheckerErrors(t, checkerErr, 1)
-
-		assert.IsType(t, &sema.InvalidatedResourceReferenceError{}, errs[0])
+		errs := checker.RequireCheckerErrors(t, checkerErr, 3)
 
+		assert.IsType(t, &sema.TypeMismatchError{}, errs[0])
+		assert.IsType(t, &sema.TypeMismatchError{}, errs[1])
+		assert.IsType(t, &sema.InvalidatedResourceReferenceError{}, errs[2])
 	})
 
 	t.Run("forEachKey", func(t *testing.T) {
@@ -355,7 +361,8 @@ func TestRuntimeResourceDuplicationUsingDestructorIteration(t *testing.T) {
 			},
 		)
 
-		require.ErrorAs(t, err, &interpreter.ContainerMutatedDuringIterationError{})
+		errs := checker.RequireCheckerErrors(t, err, 1)
+		assert.IsType(t, &sema.TypeMismatchError{}, errs[0])
 	})
 
 	t.Run("array", func(t *testing.T) {

runtime/resourcedictionary_test.go

@@ -252,11 +252,12 @@ func TestRuntimeResourceDictionaryValues(t *testing.T) {
      transaction {
 
          prepare(signer: AuthAccount) {
-             let c = signer.borrow<&Test.C>(from: /storage/c)!
+             let c <- signer.load<@Test.C>(from: /storage/c)!
              log(c.rs["b"]?.value)
 			 destroy c.remove("b")
 			 c.forceInsert("b", <- Test.createR(4))
              log(c.rs["b"]?.value)
+             signer.save(<-c, to: /storage/c)
          }
      }
    `)
@@ -292,10 +293,11 @@ func TestRuntimeResourceDictionaryValues(t *testing.T) {
      transaction {
 
          prepare(signer: AuthAccount) {
-             let c = signer.borrow<&Test.C>(from: /storage/c)!
+             let c <- signer.load<@Test.C>(from: /storage/c)!
              log(c.rs["b"]?.value)
 			 destroy c.remove("b")
              log(c.rs["b"]?.value)
+             signer.save(<-c, to: /storage/c)
          }
      }
    `)

runtime/sema/account_capability_controller.cdc

@@ -1,4 +1,4 @@
-access(all) struct AccountCapabilityController {
+access(all) struct AccountCapabilityController: MemberAccessible {
 
     /// An arbitrary "tag" for the controller.
     /// For example, it could be used to describe the purpose of the capability.

runtime/sema/anyresource_type.go

@@ -30,6 +30,7 @@ var AnyResourceType = &SimpleType{
 	Equatable:  false,
 	Comparable: false,
 	// The actual returnability of a value is checked at run-time
-	Exportable: true,
-	Importable: false,
+	Exportable:       true,
+	Importable:       false,
+	MemberAccessible: true,
 }

runtime/sema/anystruct_type.go

@@ -31,7 +31,8 @@ var AnyStructType = &SimpleType{
 	Comparable: false,
 	Exportable: true,
 	// The actual importability is checked at runtime
-	Importable: true,
+	Importable:       true,
+	MemberAccessible: true,
 }
 
 var AnyStructTypeAnnotation = NewTypeAnnotation(AnyStructType)

runtime/sema/authaccount.cdc

@@ -1,5 +1,5 @@
 
-access(all) struct AuthAccount {
+access(all) struct AuthAccount: MemberAccessible {
 
     /// The address of the account.
     access(all) let address: Address

runtime/sema/block.cdc

@@ -1,5 +1,5 @@
 
-access(all) struct Block {
+access(all) struct Block: MemberAccessible {
 
     /// The height of the block.
     ///

runtime/sema/check_expression.go

@@ -316,11 +316,24 @@ func (checker *Checker) visitIndexExpression(
 
 		checker.checkUnusedExpressionResourceLoss(elementType, targetExpression)
 
+		// If the element,
+		//   1) is accessed via a reference, and
+		//   2) is container-typed,
+		// then the element type should also be a reference.
+		returnReference := false
+		if !isAssignment && shouldReturnReference(valueIndexedType, elementType) {
+			elementType = checker.getReferenceType(elementType)
+
+			// Store the result in elaboration, so the interpreter can re-use this.
+			returnReference = true
+		}
+
 		checker.Elaboration.SetIndexExpressionTypes(
 			indexExpression,
 			IndexExpressionTypes{
-				IndexedType:  valueIndexedType,
-				IndexingType: indexingType,
+				IndexedType:     valueIndexedType,
+				IndexingType:    indexingType,
+				ReturnReference: returnReference,
 			},
 		)