fix(script): drop AST after script execution (boa-dev#4876)

## Context

This PR extends the idea introduced in boa-dev#4855.

PR boa-dev#4855 fixed a memory retention issue for **modules**, where the
parsed AST and source text were kept in memory even after module
initialization.

This PR applies the same idea to **scripts**, ensuring that the parsed
AST is released once script execution has completed.

# Summary

This PR prevents scripts from keeping their parsed AST after
compilation.

Right now `Script::Inner` stores the full AST in the `source` field:

```rust
struct Inner {
    realm: Realm,
    source: boa_ast::Script,
    source_text: SourceText,
    codeblock: GcRefCell<Option<Gc<CodeBlock>>>,
}
```

The AST is only needed while generating bytecode in
`Script::codeblock()`.
After compilation it is not used anymore, but it still stays in
`Script::Inner`.

Function objects created from the script keep a reference to the script
(`OrdinaryFunction::script_or_module`). Because of this, the script can
stay alive for a long time, which also keeps the whole AST in memory.


# Steps to Reproduce

In a long-running program (for example a REPL or server), repeatedly run
scripts that define functions:

```rust
let script = Script::parse(Source::from_bytes(src), None, &mut context)?;
script.evaluate(&mut context)?;
```

If those functions are stored on the global object, they keep the script
alive.
Since the script holds the AST, memory usage keeps growing as more
scripts run.


# Impact

This mostly affects long-running programs that embed Boa.

Every script that defines functions can keep its AST in memory forever.
AST structures are usually much bigger than the source code, so memory
usage can grow over time.

Modules already drop their AST after linking, but scripts did not.


# Fix

`Script::Inner::source` is changed to:

```rust
source: RefCell<Option<boa_ast::Script>>
```

The AST is used during compilation and then removed once the `CodeBlock`
is created:

```rust
*self.inner.source.borrow_mut() = None;
```


# Result

After this change, the AST is dropped once compilation finishes.

Scripts now behave consistently with modules after the change introduced
in boa-dev#4855.

**The AST is only required during parsing and compilation. Once the
script finishes execution and the result is consumed, it can be safely
released to reduce memory usage in long-running runtimes.**

---------

Signed-off-by: ashnaaseth2325-oss <ashnaaseth2325@gmail.com>
Co-authored-by: José Julián Espina <julian.espina@canonical.com>
Co-authored-by: José Julián Espina <jedel0124@gmail.com>

Author: ashnaaseth2325-oss

core/engine/src/script.rs

@@ -8,7 +8,10 @@
 //! [spec]: https://tc39.es/ecma262/#sec-scripts
 //! [script]: https://tc39.es/ecma262/#sec-script-records
 
-use std::path::{Path, PathBuf};
+use std::{
+    cell::RefCell,
+    path::{Path, PathBuf},
+};
 
 use rustc_hash::FxHashMap;
 
@@ -37,19 +40,22 @@ impl std::fmt::Debug for Script {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Script")
             .field("realm", &self.inner.realm.addr())
-            .field("code", &self.inner.source)
+            .field("phase", &self.inner.phase.borrow())
             .field("loaded_modules", &self.inner.loaded_modules)
             .finish()
     }
 }
-
+#[derive(Debug, Finalize)]
+enum ScriptPhase {
+    Ast(boa_ast::Script),
+    Codeblock(Gc<CodeBlock>),
+}
 #[derive(Trace, Finalize)]
 struct Inner {
     realm: Realm,
     #[unsafe_ignore_trace]
-    source: boa_ast::Script,
+    phase: RefCell<ScriptPhase>,
     source_text: SourceText,
-    codeblock: GcRefCell<Option<Gc<CodeBlock>>>,
     loaded_modules: GcRefCell<FxHashMap<JsString, Module>>,
     host_defined: HostDefined,
     path: Option<PathBuf>,
@@ -102,9 +108,8 @@ impl Script {
         Ok(Self {
             inner: Gc::new(Inner {
                 realm: realm.unwrap_or_else(|| context.realm().clone()),
-                source: code,
+                phase: RefCell::new(ScriptPhase::Ast(code)),
                 source_text,
-                codeblock: GcRefCell::default(),
                 loaded_modules: GcRefCell::default(),
                 host_defined: HostDefined::default(),
                 path,
@@ -116,48 +121,50 @@ impl Script {
     ///
     /// This is a no-op if this has been called previously.
     pub fn codeblock(&self, context: &mut Context) -> JsResult<Gc<CodeBlock>> {
-        let mut codeblock = self.inner.codeblock.borrow_mut();
-
-        if let Some(codeblock) = &*codeblock {
-            return Ok(codeblock.clone());
-        }
-
-        let mut annex_b_function_names = Vec::new();
-
-        global_declaration_instantiation_context(
-            &mut annex_b_function_names,
-            &self.inner.source,
-            self.inner.realm.scope(),
-            context,
-        )?;
-
-        let spanned_source_text = SpannedSourceText::new_source_only(self.get_source());
-        let mut compiler = ByteCompiler::new(
-            js_string!("<main>"),
-            self.inner.source.strict(),
-            false,
-            self.inner.realm.scope().clone(),
-            self.inner.realm.scope().clone(),
-            false,
-            false,
-            context.interner_mut(),
-            false,
-            spanned_source_text,
-            self.path().map(Path::to_owned).into(),
-        );
-
-        #[cfg(feature = "annex-b")]
-        {
-            compiler.annex_b_function_names = annex_b_function_names;
-        }
-
-        // TODO: move to `Script::evaluate` to make this operation infallible.
-        compiler.global_declaration_instantiation(&self.inner.source);
-        compiler.compile_statement_list(self.inner.source.statements(), true, false);
-
-        let cb = Gc::new(compiler.finish());
-
-        *codeblock = Some(cb.clone());
+        let cb = {
+            let phase = self.inner.phase.borrow();
+            let source = match &*phase {
+                ScriptPhase::Codeblock(codeblock) => return Ok(codeblock.clone()),
+                ScriptPhase::Ast(source) => source,
+            };
+
+            let mut annex_b_function_names = Vec::new();
+
+            global_declaration_instantiation_context(
+                &mut annex_b_function_names,
+                source,
+                self.inner.realm.scope(),
+                context,
+            )?;
+
+            let spanned_source_text = SpannedSourceText::new_source_only(self.get_source());
+
+            let mut compiler = ByteCompiler::new(
+                js_string!("<main>"),
+                source.strict(),
+                false,
+                self.inner.realm.scope().clone(),
+                self.inner.realm.scope().clone(),
+                false,
+                false,
+                context.interner_mut(),
+                false,
+                spanned_source_text,
+                self.path().map(Path::to_owned).into(),
+            );
+
+            #[cfg(feature = "annex-b")]
+            {
+                compiler.annex_b_function_names = annex_b_function_names;
+            }
+
+            compiler.global_declaration_instantiation(source);
+            compiler.compile_statement_list(source.statements(), true, false);
+
+            Gc::new(compiler.finish())
+        };
+
+        *self.inner.phase.borrow_mut() = ScriptPhase::Codeblock(cb.clone());
 
         Ok(cb)
     }
@@ -173,6 +180,7 @@ impl Script {
         let record = context.run();
 
         context.vm.pop_frame();
+
         record.consume()
     }
 
@@ -205,6 +213,7 @@ impl Script {
         let record = context.run_async_with_budget(budget).await;
 
         context.vm.pop_frame();
+
         record.consume()
     }