Produce a better error message when failing to reference type-erased references

runtime/interpreter/errors.go

@@ -414,6 +414,30 @@
 	)
 }
 
+// InvalidMemberReferenceError
+type InvalidMemberReferenceError struct {
+	ExpectedType sema.Type
+	ActualType   sema.Type
+	LocationRange
+}
+
+var _ errors.UserError = InvalidMemberReferenceError{}
+
+func (InvalidMemberReferenceError) IsUserError() {}
+
+func (e InvalidMemberReferenceError) Error() string {
+	expected, actual := sema.ErrorMessageExpectedActualTypes(
+		e.ExpectedType,
+		e.ActualType,
+	)
+
+	return fmt.Sprintf(
+		"cannot create reference: expected `%s`, got `%s`",
+		expected,
+		actual,
+	)
+}
+
 // InvalidPathDomainError
 type InvalidPathDomainError struct {
 	LocationRange

runtime/interpreter/interpreter_expression.go

@@ -275,6 +275,18 @@ func (interpreter *Interpreter) getReferenceValue(value Value, resultType sema.T
 	case NilValue, ReferenceValue:
 		// Reference to a nil, should return a nil.
 		// If the value is already a reference then return the same reference.
+		// However, we need to make sure that this reference is actually a subtype of the resultType,
+		// since the checker may not be aware that we are "short-circuiting" in this case
+
+		staticType := value.StaticType(interpreter)
+		if !interpreter.IsSubTypeOfSemaType(staticType, resultType) {
+			panic(InvalidMemberReferenceError{
+				ExpectedType:  resultType,
+				ActualType:    interpreter.MustConvertStaticToSemaType(staticType),
+				LocationRange: locationRange,
+			})
+		}
+
 		return value
 	case *SomeValue:
 		innerValue := interpreter.getReferenceValue(value.value, resultType, locationRange)
@@ -1030,13 +1042,15 @@ func (interpreter *Interpreter) maybeGetReference(
 	memberValue Value,
 ) Value {
 	indexExpressionTypes := interpreter.Program.Elaboration.IndexExpressionTypes(expression)
+
 	if indexExpressionTypes.ReturnReference {
 		expectedType := indexExpressionTypes.ResultType
 
 		locationRange := LocationRange{
 			Location:    interpreter.Location,
 			HasPosition: expression,
 		}
+
 		// Get a reference to the value
 		memberValue = interpreter.getReferenceValue(memberValue, expectedType, locationRange)
 	}

runtime/tests/interpreter/member_test.go

@@ -1149,3 +1149,52 @@ func TestInterpretMemberAccess(t *testing.T) {
 		}
 	})
 }
+
+func TestInterpretNestedReferenceMemberAccess(t *testing.T) {
+
+	t.Parallel()
+
+	t.Run("indexing", func(t *testing.T) {
+		t.Parallel()
+
+		inter := parseCheckAndInterpret(t, `
+            resource R {}
+
+            fun test() {
+                let r <- create R()
+                let arrayRef = &[&r as &R] as &[AnyStruct]
+                let ref: &AnyStruct = arrayRef[0]  // <--- run-time error here
+                destroy r
+            }
+        `)
+
+		_, err := inter.Invoke("test")
+		require.ErrorAs(t, err, &interpreter.InvalidMemberReferenceError{})
+	})
+
+	t.Run("field", func(t *testing.T) {
+		t.Parallel()
+
+		inter := parseCheckAndInterpret(t, `
+            resource R {}
+
+            struct Container {
+                let value: AnyStruct
+
+                init(value: AnyStruct) {
+                    self.value = value
+                }
+            }
+
+            fun test() {
+                let r <- create R()
+                let containerRef = &Container(value: &r as &R) as &Container
+                let ref: &AnyStruct = containerRef.value  // <--- run-time error here
+                destroy r
+            }        
+        `)
+
+		_, err := inter.Invoke("test")
+		require.ErrorAs(t, err, &interpreter.InvalidMemberReferenceError{})
+	})
+}