Port fixes of v0.42.8-patch.4

runtime/interpreter/errors.go

@@ -340,19 +340,6 @@ func (e DestroyedResourceError) Error() string {
 	return "resource was destroyed and cannot be used anymore"
 }
 
-// ForceAssignmentToNonNilResourceError
-type ForceAssignmentToNonNilResourceError struct {
-	LocationRange
-}
-
-var _ errors.UserError = ForceAssignmentToNonNilResourceError{}
-
-func (ForceAssignmentToNonNilResourceError) IsUserError() {}
-
-func (e ForceAssignmentToNonNilResourceError) Error() string {
-	return "force assignment to non-nil resource-typed value"
-}
-
 // ForceNilError
 type ForceNilError struct {
 	LocationRange
@@ -1107,3 +1094,16 @@ func (ResourceReferenceDereferenceError) IsInternalError() {}
 func (e ResourceReferenceDereferenceError) Error() string {
 	return "internal error: resource-references cannot be dereferenced"
 }
+
+// ResourceLossError
+type ResourceLossError struct {
+	LocationRange
+}
+
+var _ errors.UserError = ResourceLossError{}
+
+func (ResourceLossError) IsUserError() {}
+
+func (e ResourceLossError) Error() string {
+	return "resource loss: attempting to assign to non-nil resource-typed value"
+}

runtime/interpreter/interpreter.go

@@ -925,27 +925,15 @@
 		HasPosition: position,
 	}
 
-	// If the assignment is a forced move,
-	// ensure that the target is nil,
-	// otherwise panic
+	// Evaluate the value, and assign it using the setter function
 
-	if transferOperation == ast.TransferOperationMoveForced {
-
-		// If the force-move assignment is used for the initialization of a field,
-		// then there is no prior value for the field, so allow missing
-
-		const allowMissing = true
-
-		target := targetGetterSetter.get(allowMissing)
-
-		if _, ok := target.(NilValue); !ok && target != nil {
-			panic(ForceAssignmentToNonNilResourceError{
-				LocationRange: locationRange,
-			})
-		}
-	}
-
-	// Finally, evaluate the value, and assign it using the setter function
+	// Here it is too early to check whether the existing value is a
+	// valid non-nil resource (i.e: causing a resource loss), because
+	// evaluating the `valueExpression` could change things, and
+	// a `nil`/invalid resource at this point could be valid after
+	// the evaluation of `valueExpression`.
+	// Therefore, delay the checking of resource loss as much as possible,
+	// and check it at the 'setter', at the point where the value is assigned.
 
 	value := interpreter.evalExpression(valueExpression)
 
@@ -2162,46 +2150,64 @@
 		}
 
 	case *sema.ReferenceType:
-		if !valueType.Equal(unwrappedTargetType) {
-			// transferring a reference at runtime does not change its entitlements; this is so that an upcast reference
-			// can later be downcast back to its original entitlement set
-
-			// check defensively that we never create a runtime mapped entitlement value
-			if _, isMappedAuth := unwrappedTargetType.Authorization.(*sema.EntitlementMapAccess); isMappedAuth {
-				panic(UnexpectedMappedEntitlementError{
-					Type:          unwrappedTargetType,
-					LocationRange: locationRange,
-				})
-			}
-
-			switch ref := value.(type) {
-			case *EphemeralReferenceValue:
+		targetAuthorization := ConvertSemaAccessToStaticAuthorization(interpreter, unwrappedTargetType.Authorization)
+		switch ref := value.(type) {
+		case *EphemeralReferenceValue:
+			if interpreter.shouldConvertReference(ref, valueType, unwrappedTargetType, targetAuthorization) {
+				checkMappedEntitlements(unwrappedTargetType, locationRange)
 				return NewEphemeralReferenceValue(
 					interpreter,
-					ConvertSemaAccessToStaticAuthorization(interpreter, unwrappedTargetType.Authorization),
+					targetAuthorization,
 					ref.Value,
 					unwrappedTargetType.Type,
 					locationRange,
 				)
+			}
 
-			case *StorageReferenceValue:
+		case *StorageReferenceValue:
+			if interpreter.shouldConvertReference(ref, valueType, unwrappedTargetType, targetAuthorization) {
+				checkMappedEntitlements(unwrappedTargetType, locationRange)
 				return NewStorageReferenceValue(
 					interpreter,
-					ConvertSemaAccessToStaticAuthorization(interpreter, unwrappedTargetType.Authorization),
+					targetAuthorization,
 					ref.TargetStorageAddress,
 					ref.TargetPath,
 					unwrappedTargetType.Type,
 				)
-
-			default:
-				panic(errors.NewUnexpectedError("unsupported reference value: %T", ref))
 			}
+
+		default:
+			panic(errors.NewUnexpectedError("unsupported reference value: %T", ref))
 		}
 	}
 
 	return value
 }
 
+func (interpreter *Interpreter) shouldConvertReference(
+	ref ReferenceValue,
+	valueType sema.Type,
+	unwrappedTargetType *sema.ReferenceType,
+	targetAuthorization Authorization,
+) bool {
+	if !valueType.Equal(unwrappedTargetType) {
+		return true
+	}
+
+	return !ref.BorrowType().Equal(unwrappedTargetType.Type) ||
+		!ref.GetAuthorization().Equal(targetAuthorization)
+}
+
+func checkMappedEntitlements(unwrappedTargetType *sema.ReferenceType, locationRange LocationRange) {
+	// check defensively that we never create a runtime mapped entitlement value
+	if _, isMappedAuth := unwrappedTargetType.Authorization.(*sema.EntitlementMapAccess); isMappedAuth {
+		panic(UnexpectedMappedEntitlementError{
+			Type:          unwrappedTargetType,
+			LocationRange: locationRange,
+		})
+	}
+}
+
 // BoxOptional boxes a value in optionals, if necessary
 func (interpreter *Interpreter) BoxOptional(
 	locationRange LocationRange,
@@ -5526,3 +5532,31 @@
 
 	f()
 }
+
+func (interpreter *Interpreter) checkResourceLoss(value Value, locationRange LocationRange) {
+	if !value.IsResourceKinded(interpreter) {
+		return
+	}
+
+	var resourceKindedValue ResourceKindedValue
+
+	switch existingValue := value.(type) {
+	case *CompositeValue:
+		// A dedicated error is thrown when setting duplicate attachments.
+		// So don't throw an error here.
+		if existingValue.Kind == common.CompositeKindAttachment {
+			return
+		}
+		resourceKindedValue = existingValue
+	case ResourceKindedValue:
+		resourceKindedValue = existingValue
+	default:
+		panic(errors.NewUnreachableError())
+	}
+
+	if !resourceKindedValue.isInvalidatedResource(interpreter) {
+		panic(ResourceLossError{
+			LocationRange: locationRange,
+		})
+	}
+}