Introduce dereference on the Reference type

[darkdrag00nv2]

Closes #2803

Description

---

• Targeted PR against master branch
• Linked to Github issue with discussion and accepted design OR link to spec that describes this work
• Code follows the standards mentioned here
• Updated relevant documentation
• Re-reviewed Files changed in the Github PR explorer
• Added appropriate labels

[darkdrag00nv2]

I can see that there are two types of reference values - EphemeralReferenceValue and StorageReferenceValue.

Should this function be implemented on both or just EphemeralReferenceValue?

[darkdrag00nv2]

The implementation of dereference on EphemeralReferenceValue looks straightforward. Is this correct or am I missing something?

[bluesign]

shouldn't this create new Value (copy of the value somehow ) ? something like Transfer etc.

[bluesign]

I was thinking more like:

let x: &[Int] = &[1]
x.dereference().append(2)

PS: if we make a copy also we can support non-primitives like structs

[turbolent]

Yeah, this needs a Transfer to the stack, i.e.

.Transfer(
	interpreter,
	locationRange,
	atree.Address{},
	false,
	nil,
	nil,
)

[turbolent]

Great point @bluesign to test by operating on the returned value directly, my example above, let ints2 = ref.dereference() was adding a copy 👍

[turbolent]

@darkdrag00nv2 yeah, dereferencing needs to be implemented for both EphemeralReferenceValue and StorageReferenceValue.

Dereferencing should be supported at the type level for references in general (&T), for all primitive types (e.g. Int -> &Int), or containers of primitive types (e.g. [Int] -> &[Int]). At the value level there are two different kinds of values that both represent values of reference types. Basically, let v: &T might either hold be a EphemeralReferenceValue or a StorageReferenceValue at run-time.

[darkdrag00nv2]

@turbolent You've mentioned primitive types and containers of primitive types.

Could we not define it for all subtypes of AnyStruct? Basically ignoring all resource types. Do you see any complications/extra-work to support them, say for Struct?

[bluesign]

Could we not define it for all subtypes of AnyStruct? Basically ignoring all resource types. Do you see any complications/extra-work to support them, say for Struct?

Only edge case I see is attachments ( Contracts are covered by transfer ), attachments would allow detaching and attaching to new struct. ( which we don't allow currently )

struct T{
  access(all) var tag : Int
  init(_ tag:Int){
     self.tag = tag
  }
}
						
attachment X for AnyStruct{

}

fun main(): AnyStruct {
   var t1 = T(1)
   var t2 = T(2)
   var res = attach X() to t1

   var ff = res[X]!.dereference
   var newAttached = attach ff() to t2
   return newAttached
}

[SupunS]

Not sure why this got closed. This should now be opened against the master (#2971)

[dsainati1]

Same, it seems as though it was closed automatically when feature/stable-cadence was merged into master. I can't re-open it for some reason though.