src: track cppgc wrappers with CppgcWrapperList in Environment

[joyeecheung]

This allows us to perform cleanups of cppgc wrappers that rely on a living Environment during Environment shutdown. Otherwise the cleanup may happen during object destruction, which can be triggered by GC after Enivronment shutdown, leading to invalid access to Environment.

The general pattern for this type of non-trivial destruction is designed to be:

class MyWrap final : CPPGC_MIXIN(MyWrap) {
 public:
  ~MyWrap() { this->Clean(); }
  void CleanEnvResource(Environment* env) override {
     // Do cleanup that relies on a living Environemnt. This would be
     // called by CppgcMixin::Clean() first during Environment shutdown,
     // while the Environment is still alive. If the destructor calls
     // Clean() again later during garbage collection that happens after
     // Environment shutdown, CleanEnvResource() would be skipped, preventing
     // invalid access to the Environment.
  }
}

In addition, this allows us to trace external memory held by the wrappers in the heap snapshots if we add synthethic edges between the wrappers and other nodes in the embdder graph callback, or to perform snapshot serialization for them.

[nodejs-github-bot]

CI: https://ci.nodejs.org/job/node-test-pull-request/64424/

[codecov]

Codecov Report

Attention: Patch coverage is 91.66667% with 1 line in your changes missing coverage. Please review.

Project coverage is 89.06%. Comparing base (7c3aa9f) to head (37e7bac).
Report is 20 commits behind head on main.

Files with missing lines	Patch %	Lines
src/cppgc_helpers.h	88.88%	0 Missing and 1 partial ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main   #56534      +/-   ##
==========================================
- Coverage   89.12%   89.06%   -0.07%     
==========================================
  Files         662      662              
  Lines      191556   191670     +114     
  Branches    36860    36813      -47     
==========================================
- Hits       170732   170705      -27     
- Misses      13690    13808     +118     
- Partials     7134     7157      +23     

Files with missing lines	Coverage Δ
src/env.cc	85.51% <100.00%> (-0.16%)	⬇️
src/env.h	98.21% <100.00%> (+0.06%)	⬆️
src/cppgc_helpers.h	87.09% <88.88%> (+0.73%)	⬆️

... and 54 files with indirect coverage changes

[legendecas]

Assumptions should not be made about the order and the timing of their execution. There is no guarantee on the order in which the destructors are invoked. That's why destructors must not access any other on-heap objects (which might have already been destructed). If some destructor unavoidably needs to access other on-heap objects, it will have to be converted to a pre-finalizer. The pre-finalizer is allowed to access other on-heap objects.
https://github.com/v8/v8/tree/main/include/cppgc#sweeping-phase

This example should depend on CPPGC_USING_PRE_FINALIZER as it may access other heap objects.

[joyeecheung]

Updated to mention CPPGC_USING_PRE_FINALIZER, though I noticed two things:

1. ContextifyContext does not even need to have special cleanup and can just have a default destructor - when the destructors are invoked, the context is already going away as it would've been holding the ContextifyContext alive. So there's no need to set the internal pointers of the context; On the other hand since the context is already going away, the per-environment context list would now contain empty global handles to that context, and the context tracking code is already able to deal with empty handles, so it matters little to purge it from the list in the destructor (we could also do the housekeeping in the constructor, in TrackContext() instead, to make sure there aren't too many empty handles lying around).
2. It seems the use of CPPGC_USING_PRE_FINALIZER would crash the construction of ContextifyContext, which I have not gotten to the bottom of yet.