Merge pull request #2592 from onflow/sainati/entitlement-conversion-c…

…rash

Fix crash on entitlement mappings with empty outputs

runtime/interpreter/interpreter.go

@@ -448,7 +448,7 @@ func (interpreter *Interpreter) InvokeExternally(
 
 	var self *MemberAccessibleValue
 	var base *EphemeralReferenceValue
-	var boundAuth *EntitlementSetAuthorization
+	var boundAuth Authorization
 	if boundFunc, ok := functionValue.(BoundFunctionValue); ok {
 		self = boundFunc.Self
 		base = boundFunc.Base
@@ -1713,7 +1713,7 @@ func (interpreter *Interpreter) substituteMappedEntitlements(ty sema.Type) sema.
 				return sema.NewReferenceType(
 					interpreter,
 					refType.Type,
-					interpreter.MustConvertStaticAuthorizationToSemaAccess(*interpreter.SharedState.currentEntitlementMappedValue),
+					interpreter.MustConvertStaticAuthorizationToSemaAccess(interpreter.SharedState.currentEntitlementMappedValue),
 				)
 			}
 		}
@@ -4900,17 +4900,17 @@ func (interpreter *Interpreter) mapMemberValueAuthorization(self Value, memberAc
 		return resultValue
 	}
 	if mappedAccess, isMappedAccess := (*memberAccess).(sema.EntitlementMapAccess); isMappedAccess {
-		var auth EntitlementSetAuthorization
+		var auth Authorization
 		switch selfValue := self.(type) {
 		case AuthorizedValue:
 			selfAccess := interpreter.MustConvertStaticAuthorizationToSemaAccess(selfValue.GetAuthorization())
 			imageAccess, err := mappedAccess.Image(selfAccess, func() ast.Range { return ast.EmptyRange })
 			if err != nil {
 				panic(err)
 			}
-			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, imageAccess).(EntitlementSetAuthorization)
+			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, imageAccess)
 		default:
-			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, mappedAccess.Codomain()).(EntitlementSetAuthorization)
+			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, mappedAccess.Codomain())
 		}
 
 		switch refValue := resultValue.(type) {
@@ -4919,7 +4919,7 @@ func (interpreter *Interpreter) mapMemberValueAuthorization(self Value, memberAc
 		case *StorageReferenceValue:
 			return NewStorageReferenceValue(interpreter, auth, refValue.TargetStorageAddress, refValue.TargetPath, refValue.BorrowedType)
 		case BoundFunctionValue:
-			return NewBoundFunctionValue(interpreter, refValue.Function, refValue.Self, refValue.Base, &auth)
+			return NewBoundFunctionValue(interpreter, refValue.Function, refValue.Self, refValue.Base, auth)
 		}
 	}
 	return resultValue

runtime/interpreter/interpreter_expression.go

@@ -1148,7 +1148,7 @@ func (interpreter *Interpreter) VisitReferenceExpression(referenceExpression *as
 		// if we are currently interpretering a function that was declared with mapped entitlement access, any appearances
 		// of that mapped access in the body of the function should be replaced with the computed output of the map
 		if _, isMapped := typ.Authorization.(sema.EntitlementMapAccess); isMapped && interpreter.SharedState.currentEntitlementMappedValue != nil {
-			auth = *interpreter.SharedState.currentEntitlementMappedValue
+			auth = interpreter.SharedState.currentEntitlementMappedValue
 		} else {
 			auth = ConvertSemaAccesstoStaticAuthorization(interpreter, typ.Authorization)
 		}

runtime/interpreter/invocation.go

@@ -28,7 +28,7 @@ type Invocation struct {
 	LocationRange      LocationRange
 	Self               *MemberAccessibleValue
 	Base               *EphemeralReferenceValue
-	BoundAuthorization *EntitlementSetAuthorization
+	BoundAuthorization Authorization
 	TypeParameterTypes *sema.TypeParameterTypeOrderedMap
 	Interpreter        *Interpreter
 	Arguments          []Value
@@ -39,7 +39,7 @@ func NewInvocation(
 	interpreter *Interpreter,
 	self *MemberAccessibleValue,
 	base *EphemeralReferenceValue,
-	boundAuth *EntitlementSetAuthorization,
+	boundAuth Authorization,
 	arguments []Value,
 	argumentTypes []sema.Type,
 	typeParameterTypes *sema.TypeParameterTypeOrderedMap,

runtime/interpreter/sharedstate.go

@@ -43,7 +43,7 @@ type SharedState struct {
 	storageMutatedDuringIteration               bool
 	CapabilityControllerIterations              map[AddressPath]int
 	MutationDuringCapabilityControllerIteration bool
-	currentEntitlementMappedValue               *EntitlementSetAuthorization
+	currentEntitlementMappedValue               Authorization
 }
 
 func NewSharedState(config *Config) *SharedState {

runtime/interpreter/value_function.go

@@ -325,7 +325,7 @@ type BoundFunctionValue struct {
 	Function           FunctionValue
 	Base               *EphemeralReferenceValue
 	Self               *MemberAccessibleValue
-	BoundAuthorization *EntitlementSetAuthorization
+	BoundAuthorization Authorization
 }
 
 var _ Value = BoundFunctionValue{}
@@ -336,7 +336,7 @@ func NewBoundFunctionValue(
 	function FunctionValue,
 	self *MemberAccessibleValue,
 	base *EphemeralReferenceValue,
-	boundAuth *EntitlementSetAuthorization,
+	boundAuth Authorization,
 ) BoundFunctionValue {
 
 	common.UseMemory(interpreter, common.BoundFunctionValueMemoryUsage)

runtime/tests/interpreter/entitlements_test.go

@@ -2380,6 +2380,44 @@ func TestInterpretEntitledAttachments(t *testing.T) {
 			).Equal(value.(*interpreter.EphemeralReferenceValue).Authorization),
 		)
 	})
+
+	t.Run("empty output", func(t *testing.T) {
+
+		t.Parallel()
+
+		inter := parseCheckAndInterpret(t, `
+			entitlement A
+			entitlement B
+
+			entitlement mapping M {
+			    A -> B
+			}
+
+			struct S {
+				access(M) fun foo(): auth(M) &AnyStruct {
+					let a: AnyStruct = "hello"
+					return &a as auth(M) &AnyStruct
+				}
+			}
+
+			fun test(): &AnyStruct {
+				let s = S()
+				let ref = &s as &S
+
+				// Must return an unauthorized ref
+				return ref.foo()
+			}
+		`)
+
+		value, err := inter.Invoke("test")
+		require.NoError(t, err)
+
+		require.Equal(
+			t,
+			interpreter.UnauthorizedAccess,
+			value.(*interpreter.EphemeralReferenceValue).Authorization,
+		)
+	})
 }
 
 func TestInterpretEntitledReferenceCollections(t *testing.T) {