Add support for resource-kinded fields in transaction roles

runtime/ast/transaction_declaration.go

@@ -198,10 +198,10 @@ func (d *TransactionDeclaration) String() string {
 // TransactionRoleDeclaration
 
 type TransactionRoleDeclaration struct {
-	Identifier Identifier
 	Prepare    *SpecialFunctionDeclaration
 	DocString  string
 	Fields     []*FieldDeclaration
+	Identifier Identifier
 	Range
 }
 

runtime/interpreter/errors.go

@@ -239,10 +239,10 @@ func (e RedeclarationError) Error() string {
 // DereferenceError
 
 type DereferenceError struct {
-	Cause        string
+	LocationRange
 	ExpectedType sema.Type
 	ActualType   sema.Type
-	LocationRange
+	Cause        string
 }
 
 var _ errors.UserError = DereferenceError{}

runtime/sema/check_composite_declaration.go

@@ -171,17 +171,22 @@ func (checker *Checker) visitCompositeDeclaration(declaration *ast.CompositeDecl
 
 	// NOTE: check destructors after initializer and functions
 
-	checker.withSelfResourceInvalidationAllowed(func() {
-		checker.checkDestructors(
-			declaration.Members.Destructors(),
-			declaration.Members.FieldsByIdentifier(),
-			compositeType.Members,
-			compositeType,
-			declaration.DeclarationKind(),
-			declaration.DeclarationDocString(),
-			kind,
-		)
-	})
+	checker.withResourceFieldInvalidationAllowed(
+		func(expression *ast.MemberExpression) *Member {
+			return checker.accessedSelfMember(expression)
+		},
+		func() {
+			checker.checkDestructors(
+				declaration.Members.Destructors(),
+				declaration.Members.FieldsByIdentifier(),
+				compositeType.Members,
+				compositeType,
+				declaration.DeclarationKind(),
+				declaration.DeclarationDocString(),
+				kind,
+			)
+		},
+	)
 
 	// NOTE: visit interfaces first
 	// DON'T use `nestedDeclarations`, because of non-deterministic order

runtime/sema/check_member_expression.go

@@ -110,6 +110,24 @@ func (checker *Checker) visitMember(expression *ast.MemberExpression) (accessedT
 				IsOptional:   isOptional,
 			},
 		)
+
+		// If the access is to a member which may be invalidated,
+		// its use must be recorded/checked, so that it isn't used after it was invalidated
+
+		resourceFieldInvalidationAllowed := checker.resourceFieldInvalidationAllowed
+		if resourceFieldInvalidationAllowed != nil {
+			member := resourceFieldInvalidationAllowed(expression)
+			if member != nil && member.TypeAnnotation.Type.IsResourceType() {
+
+				// NOTE: Preventing the capturing of the resource field is already implicitly handled:
+				// By definition, the resource field can only be nested in a resource,
+				// so `self` is a resource, and the capture of it is checked separately
+
+				res := Resource{Member: member}
+
+				checker.checkResourceUseAfterInvalidation(res, expression.Identifier)
+			}
+		}
 	}()
 
 	accessedExpression := expression.Expression
@@ -133,22 +151,6 @@ func (checker *Checker) visitMember(expression *ast.MemberExpression) (accessedT
 		return accessedType, member, isOptional
 	}
 
-	// If the access is to a member of `self` and a resource,
-	// its use must be recorded/checked, so that it isn't used after it was invalidated
-
-	accessedSelfMember := checker.accessedSelfMember(expression)
-	if accessedSelfMember != nil &&
-		accessedSelfMember.TypeAnnotation.Type.IsResourceType() {
-
-		// NOTE: Preventing the capturing of the resource field is already implicitly handled:
-		// By definition, the resource field can only be nested in a resource,
-		// so `self` is a resource, and the capture of it is checked separately
-
-		res := Resource{Member: accessedSelfMember}
-
-		checker.checkResourceUseAfterInvalidation(res, expression.Identifier)
-	}
-
 	identifier := expression.Identifier.Identifier
 	identifierStartPosition := expression.Identifier.StartPosition()
 	identifierEndPosition := expression.Identifier.EndPosition(checker.memoryGauge)

runtime/sema/check_transaction_declaration.go

@@ -83,13 +83,30 @@ func (checker *Checker) VisitTransactionDeclaration(declaration *ast.Transaction
 		declaration.PostConditions,
 		VoidType,
 		func() {
-			checker.withSelfResourceInvalidationAllowed(func() {
-				checker.visitTransactionExecuteFunction(declaration.Execute, transactionType)
-			})
+			checker.withResourceFieldInvalidationAllowed(
+				func(expression *ast.MemberExpression) *Member {
+					// In addition to the behaviour in composite destructors,
+					// where a self member may be invalidated,
+					// also allow invalidation of role members
+					memberInfo, _ := checker.Elaboration.MemberExpressionMemberInfo(expression)
+					if _, ok := memberInfo.AccessedType.(*TransactionRoleType); ok {
+						return memberInfo.Member
+					}
+
+					return checker.accessedSelfMember(expression)
+				},
+				func() {
+					checker.visitTransactionExecuteFunction(declaration.Execute, transactionType)
+				},
+			)
 		},
 	)
 
-	checker.checkResourceFieldsInvalidated(transactionType, transactionType.Members)
+	checker.checkResourceFieldsInvalidated(transactionType, members)
+
+	transactionType.Roles.Foreach(func(_ string, roleTye *TransactionRoleType) {
+		checker.checkResourceFieldsInvalidated(roleTye, roleTye.Members)
+	})
 
 	return
 }

runtime/sema/checker.go

@@ -91,28 +91,28 @@ type ContractValueHandlerFunc func(
 
 type Checker struct {
 	// memoryGauge is used for metering memory usage
-	memoryGauge             common.MemoryGauge
-	Location                common.Location
-	expectedType            Type
-	resources               *Resources
-	valueActivations        *VariableActivations
-	currentMemberExpression *ast.MemberExpression
-	typeActivations         *VariableActivations
-	containerTypes          map[Type]struct{}
-	Program                 *ast.Program
-	PositionInfo            *PositionInfo
-	Config                  *Config
-	Elaboration             *Elaboration
+	memoryGauge  common.MemoryGauge
+	Location     common.Location
+	expectedType Type
+	Config       *Config
 	// initialized lazily. use beforeExtractor()
-	_beforeExtractor                   *BeforeExtractor
-	errors                             []error
-	functionActivations                *FunctionActivations
-	inCondition                        bool
-	allowSelfResourceFieldInvalidation bool
-	inAssignment                       bool
-	inInvocation                       bool
-	inCreate                           bool
-	isChecked                          bool
+	_beforeExtractor                 *BeforeExtractor
+	currentMemberExpression          *ast.MemberExpression
+	typeActivations                  *VariableActivations
+	containerTypes                   map[Type]struct{}
+	Program                          *ast.Program
+	PositionInfo                     *PositionInfo
+	resources                        *Resources
+	Elaboration                      *Elaboration
+	valueActivations                 *VariableActivations
+	resourceFieldInvalidationAllowed func(*ast.MemberExpression) *Member
+	functionActivations              *FunctionActivations
+	errors                           []error
+	inCondition                      bool
+	inAssignment                     bool
+	inInvocation                     bool
+	inCreate                         bool
+	isChecked                        bool
 }
 
 var _ ast.DeclarationVisitor[struct{}] = &Checker{}
@@ -1355,9 +1355,10 @@ func (checker *Checker) recordResourceInvalidation(
 		return nil
 	}
 
-	reportInvalidNestedMove := func() {
+	reportInvalidNestedMove := func(identifier *ast.Identifier) {
 		checker.report(
 			&InvalidNestedResourceMoveError{
+				Identifier: identifier,
 				Range: ast.NewRangeFromPositioned(
 					checker.memoryGauge,
 					expression,
@@ -1366,32 +1367,13 @@ func (checker *Checker) recordResourceInvalidation(
 		)
 	}
 
-	accessedSelfMember := checker.accessedSelfMember(expression)
-
-	switch expression.(type) {
-	case *ast.MemberExpression:
-
-		if accessedSelfMember == nil ||
-			!checker.allowSelfResourceFieldInvalidation {
-
-			reportInvalidNestedMove()
-			return nil
+	getRecordedResourceInvalidation := func(res Resource) *recordedResourceInvalidation {
+		invalidation := ResourceInvalidation{
+			Kind:     invalidationKind,
+			StartPos: expression.StartPosition(),
+			EndPos:   expression.EndPosition(checker.memoryGauge),
 		}
 
-	case *ast.IndexExpression:
-		reportInvalidNestedMove()
-		return nil
-	}
-
-	invalidation := ResourceInvalidation{
-		Kind:     invalidationKind,
-		StartPos: expression.StartPosition(),
-		EndPos:   expression.EndPosition(checker.memoryGauge),
-	}
-
-	if checker.allowSelfResourceFieldInvalidation && accessedSelfMember != nil {
-		res := Resource{Member: accessedSelfMember}
-
 		checker.maybeAddResourceInvalidation(res, invalidation)
 
 		return &recordedResourceInvalidation{
@@ -1400,37 +1382,51 @@ func (checker *Checker) recordResourceInvalidation(
 		}
 	}
 
-	identifierExpression, ok := expression.(*ast.IdentifierExpression)
-	if !ok {
-		return nil
-	}
+	switch expression := expression.(type) {
+	case *ast.IdentifierExpression:
+		variable := checker.findAndCheckValueVariable(expression, false)
+		if variable == nil {
+			return nil
+		}
 
-	variable := checker.findAndCheckValueVariable(identifierExpression, false)
-	if variable == nil {
-		return nil
-	}
+		if invalidationKind != ResourceInvalidationKindMoveTemporary &&
+			variable.DeclarationKind == common.DeclarationKindSelf {
 
-	if invalidationKind != ResourceInvalidationKindMoveTemporary &&
-		variable.DeclarationKind == common.DeclarationKindSelf {
+			checker.report(
+				&InvalidSelfInvalidationError{
+					InvalidationKind: invalidationKind,
+					Range: ast.NewRangeFromPositioned(
+						checker.memoryGauge,
+						expression,
+					),
+				},
+			)
+		}
 
-		checker.report(
-			&InvalidSelfInvalidationError{
-				InvalidationKind: invalidationKind,
-				Range: ast.NewRangeFromPositioned(
-					checker.memoryGauge,
-					expression,
-				),
-			},
-		)
-	}
+		return getRecordedResourceInvalidation(Resource{
+			Variable: variable,
+		})
+
+	case *ast.MemberExpression:
+		resourceFieldInvalidationAllowed := checker.resourceFieldInvalidationAllowed
+		if resourceFieldInvalidationAllowed != nil {
+			member := resourceFieldInvalidationAllowed(expression)
+			if member != nil {
+				return getRecordedResourceInvalidation(Resource{
+					Member: member,
+				})
+			}
+		}
 
-	res := Resource{Variable: variable}
+		reportInvalidNestedMove(&expression.Identifier)
+		return nil
 
-	checker.maybeAddResourceInvalidation(res, invalidation)
+	case *ast.IndexExpression:
+		reportInvalidNestedMove(nil)
+		return nil
 
-	return &recordedResourceInvalidation{
-		resource:     res,
-		invalidation: invalidation,
+	default:
+		return nil
 	}
 }
 
@@ -1798,11 +1794,14 @@ func (checker *Checker) isWriteableAccess(access ast.Access) bool {
 	}
 }
 
-func (checker *Checker) withSelfResourceInvalidationAllowed(f func()) {
-	allowSelfResourceFieldInvalidation := checker.allowSelfResourceFieldInvalidation
-	checker.allowSelfResourceFieldInvalidation = true
+func (checker *Checker) withResourceFieldInvalidationAllowed(
+	invalidationAllowed func(*ast.MemberExpression) *Member,
+	f func(),
+) {
+	oldInvalidationAllowed := checker.resourceFieldInvalidationAllowed
+	checker.resourceFieldInvalidationAllowed = invalidationAllowed
 	defer func() {
-		checker.allowSelfResourceFieldInvalidation = allowSelfResourceFieldInvalidation
+		checker.resourceFieldInvalidationAllowed = oldInvalidationAllowed
 	}()
 
 	f()

runtime/sema/errors.go

@@ -1860,6 +1860,7 @@ func (e *MissingResourceAnnotationError) Error() string {
 // InvalidNestedResourceMoveError
 
 type InvalidNestedResourceMoveError struct {
+	Identifier *ast.Identifier
 	ast.Range
 }
 
@@ -1871,6 +1872,11 @@ func (*InvalidNestedResourceMoveError) isSemanticError() {}
 func (*InvalidNestedResourceMoveError) IsUserError() {}
 
 func (e *InvalidNestedResourceMoveError) Error() string {
+	identifier := e.Identifier
+	if identifier != nil {
+		return fmt.Sprintf("cannot move nested resource-kinded field `%s`", identifier.Identifier)
+	}
+
 	return "cannot move nested resource"
 }
 
@@ -2903,7 +2909,6 @@ func (e *ReadOnlyTargetAssignmentError) Error() string {
 }
 
 // MissingPrepareForFieldError
-//
 type MissingPrepareForFieldError struct {
 	FirstFieldName string
 	FirstFieldPos  ast.Position

runtime/sema/resources.go

@@ -57,7 +57,7 @@ import (
 
 */
 
-// A Resource is a variable or a member
+// A Resource is a variable OR a member
 type Resource struct {
 	Variable *Variable
 	Member   *Member

runtime/sema/type.go

@@ -5649,10 +5649,10 @@ func IsNilType(ty Type) bool {
 
 type TransactionType struct {
 	Members           *StringMemberOrderedMap
+	Roles             *orderedmap.OrderedMap[string, *TransactionRoleType]
 	Fields            []string
 	PrepareParameters []Parameter
 	Parameters        []Parameter
-	Roles             *orderedmap.OrderedMap[string, *TransactionRoleType]
 }
 
 var _ Type = &TransactionType{}