[Compiler] Emit default destroyed events when resources are destroyed

[SupunS]

Work towards #3993

Description

There are a few important points/behaviours that needed to be upheld by the implementation:

• The default values of event-parameters are closure variables.
• Event must be constructed before the enclosing resource is destroyed, but the actual emitting must happen after the resource is destroyed.
• Default destroyed events can be inherited.

Implementation Approach

• Generate a synthetic constructor for each ResourceDestroyed event, that assigns the parameters to fields.

  func init(a: T1, b: T2, ...) {
      self.a = a
      self.b = b
  }

• For each resource that contains a ResourceDestroyed event, generate a getter-function, that return an array of events.

  resource R: I {
  
      var field: Int
  
      event ResourceDestroyed(a: T1 = v, b: T2 = self.field)
  
      func $ResourceDestroyed(): [AnyStruct] {
          return [
              R.ResourceDestroyed(a: v, b: self.field),    // event defined in the same type
              I.ResourceDestroyed(...),                    // inherited events
          ]
      }
  }

  This makes it seamless to capture the closure variables, that are used in argument default values.
• During the resource destruction, call the $ResourceDestroyed() to get the event-values. Then once the resource is destroyed, emit the retrieved event-values (this part is already available in the value-implementation).

Alternatives Considered

• Directly emit the event inside the generated $ResourceDestroyed function, rather than returning the event-values.

  resource R: I {
  
      event ResourceDestroyed(a: T1 = v1, b: T2 = v2)
  
      func $ResourceDestroyed() {
          emit R.ResourceDestroyed(a: v1, b: v2),    // event defined in the same type
          emit I.ResourceDestroyed(...),             // inherited events
      }
  }

  The problem is this will both construct and emit the event before the resource is destroyed.

• Return the event's fields only by the $ResourceDestroyed function, rather than constructing an event value.

  • The problem is, to emit the event, it also needs the event's type. So we not only need to return the fields but also event type as a runtime type.
  • The returned value is an array-of-arrays, which is not an improvement from array-of-composites.

---

• 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

[github-actions]

Cadence Benchstat comparison

This branch with compared with the base branch onflow:feature/compiler commit c99075e
The command for i in {1..N}; do go test ./... -run=XXX -bench=. -benchmem -shuffle=on; done was used.
Bench tests were run a total of 7 times on each branch.

Collapsed results for better readability

[turbolent]

Great work! It makes sense to compile to a method, so self and fields are available 👍

In the examples, what do = v, = v1, and = v2 refer to?

[SupunS]

v, v1, v2 all are any arbitrary value / expression (expressions that are supported by the default destroy event). In the example I mostly wanted to show that the default-value expression will be available/moved as-is inside the generated method.

[turbolent]

Great work! 👏