diff --git a/Cargo.lock b/Cargo.lock
index c20e3a35ad9..51d726ea262 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -112,6 +112,7 @@ dependencies = [
 name = "boa_interner"
 version = "0.13.0"
 dependencies = [
+ "gc",
  "serde",
  "string-interner",
 ]
@@ -1273,9 +1274,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.75"
+version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c059c05b48c5c0067d4b4b2b4f0732dd65feb52daf7e0ea09cd87e7dadc1af79"
+checksum = "edde269018d33d7146dd074e5f7da6fef9b0a957507454c867caa0852c560a9a"
 dependencies = [
  "itoa 1.0.1",
  "ryu",
diff --git a/boa/Cargo.toml b/boa/Cargo.toml
index 0d485a506aa..686311fbf71 100644
--- a/boa/Cargo.toml
+++ b/boa/Cargo.toml
@@ -23,7 +23,7 @@ boa_unicode = { path = "../boa_unicode", version = "0.13.0" }
 boa_interner = { path = "../boa_interner", version = "0.13.0" }
 gc = { version = "0.4.1", features = ["derive"] }
 serde = { version = "1.0.134", features = ["derive", "rc"] }
-serde_json = "1.0.75"
+serde_json = "1.0.76"
 rand = "0.8.4"
 num-traits = "0.2.14"
 regress = "0.4.1"
diff --git a/boa/benches/full.rs b/boa/benches/full.rs
index efa7c25a159..197094c5c72 100644
--- a/boa/benches/full.rs
+++ b/boa/benches/full.rs
@@ -1,7 +1,6 @@
 //! Benchmarks of the whole execution engine in Boa.
 
-use boa::{realm::Realm, syntax::Parser, Context};
-use boa_interner::Interner;
+use boa::{realm::Realm, Context};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 #[cfg(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"))]
@@ -21,9 +20,9 @@ macro_rules! full_benchmarks {
             $(
                 {
                     static CODE: &str = include_str!(concat!("bench_scripts/", stringify!($name), ".js"));
-                    let mut interner = Interner::new();
+                    let mut context = Context::default();
                     c.bench_function(concat!($id, " (Parser)"), move |b| {
-                        b.iter(|| Parser::new(black_box(CODE.as_bytes()), false).parse_all(&mut interner))
+                        b.iter(|| context.parse(black_box(CODE)))
                     });
                 }
             )*
@@ -32,11 +31,11 @@ macro_rules! full_benchmarks {
             $(
                 {
                     static CODE: &str = include_str!(concat!("bench_scripts/", stringify!($name), ".js"));
-                    let mut interner = Interner::new();
-                    let statement_list = Parser::new(CODE.as_bytes(), false).parse_all( &mut interner).expect("parsing failed");
+                    let mut context = Context::default();
+                    let statement_list = context.parse(CODE).expect("parsing failed");
                     c.bench_function(concat!($id, " (Compiler)"), move |b| {
                         b.iter(|| {
-                            Context::compile(black_box(&statement_list));
+                            context.compile(black_box(&statement_list))
                         })
                     });
                 }
@@ -46,13 +45,12 @@ macro_rules! full_benchmarks {
             $(
                 {
                     static CODE: &str = include_str!(concat!("bench_scripts/", stringify!($name), ".js"));
-                    let mut interner = Interner::new();
-                    let statement_list = Parser::new(CODE.as_bytes(), false).parse_all(&mut interner).expect("parsing failed");
-                    let mut context = Context::new(interner);
-                    let code_block = Context::compile(&statement_list);
+                    let mut context = Context::default();
+                    let statement_list = context.parse(CODE).expect("parsing failed");
+                    let code_block = context.compile(&statement_list);
                     c.bench_function(concat!($id, " (Execution)"), move |b| {
                         b.iter(|| {
-                            context.execute(black_box(code_block.clone())).unwrap();
+                            context.execute(black_box(code_block.clone())).unwrap()
                         })
                     });
                 }
diff --git a/boa/src/builtins/array/tests.rs b/boa/src/builtins/array/tests.rs
index 9d4d683ba0a..2374fb13635 100644
--- a/boa/src/builtins/array/tests.rs
+++ b/boa/src/builtins/array/tests.rs
@@ -117,7 +117,6 @@ fn of() {
     assert_eq!(context.eval("a.length").unwrap(), JsValue::new(3));
 }
 
-#[ignore]
 #[test]
 fn concat() {
     let mut context = Context::default();
diff --git a/boa/src/builtins/console/mod.rs b/boa/src/builtins/console/mod.rs
index 861fef63506..cb569baa1cd 100644
--- a/boa/src/builtins/console/mod.rs
+++ b/boa/src/builtins/console/mod.rs
@@ -304,7 +304,12 @@ impl Console {
         let mut prev_frame = context.vm.frame.as_ref();
 
         while let Some(frame) = prev_frame {
-            stack_trace.push(frame.code.name.to_string());
+            stack_trace.push(
+                context
+                    .interner()
+                    .resolve_expect(frame.code.name)
+                    .to_owned(),
+            );
             prev_frame = frame.prev.as_ref();
         }
 
diff --git a/boa/src/builtins/dataview/mod.rs b/boa/src/builtins/dataview/mod.rs
index 37207e6494f..e57d77efa43 100644
--- a/boa/src/builtins/dataview/mod.rs
+++ b/boa/src/builtins/dataview/mod.rs
@@ -1,6 +1,7 @@
 use crate::{
     builtins::{array_buffer::SharedMemoryOrder, typed_array::TypedArrayName, BuiltIn, JsArgs},
     context::StandardObjects,
+    gc::{Finalize, Trace},
     object::{
         internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
         JsObject, ObjectData,
@@ -10,7 +11,6 @@ use crate::{
     value::JsValue,
     Context, JsResult,
 };
-use gc::{Finalize, Trace};
 
 #[derive(Debug, Clone, Trace, Finalize)]
 pub struct DataView {
diff --git a/boa/src/builtins/function/arguments.rs b/boa/src/builtins/function/arguments.rs
index 7ef1e56c768..c74b63303ad 100644
--- a/boa/src/builtins/function/arguments.rs
+++ b/boa/src/builtins/function/arguments.rs
@@ -1,14 +1,13 @@
 use crate::{
     builtins::Array,
     environment::lexical_environment::Environment,
+    gc::{Finalize, Trace},
     object::{FunctionBuilder, JsObject, ObjectData},
     property::PropertyDescriptor,
     symbol::{self, WellKnownSymbols},
     syntax::ast::node::FormalParameter,
     Context, JsValue,
 };
-
-use gc::{Finalize, Trace};
 use rustc_hash::FxHashSet;
 
 #[derive(Debug, Clone, Trace, Finalize)]
@@ -171,9 +170,9 @@ impl Arguments {
         // a. Let name be parameterNames[index].
 
         for (index, parameter_name_vec) in formals.iter().map(|fp| fp.names()).enumerate().rev() {
-            for parameter_name in parameter_name_vec.iter().cloned() {
+            for parameter_name in parameter_name_vec.iter().copied() {
                 // b. If name is not an element of mappedNames, then
-                if !mapped_names.contains(parameter_name) {
+                if !mapped_names.contains(&parameter_name) {
                     // i. Add name as an element of the list mappedNames.
                     mapped_names.insert(parameter_name);
                     // ii. If index < len, then
@@ -189,7 +188,7 @@ impl Arguments {
                                 // 1. Let getterClosure be a new Abstract Closure with no parameters that captures
                                 // name and env and performs the following steps when called:
                                 |_, _, captures, context| {
-                                    captures.0.get_binding_value(&captures.1, false, context)
+                                    captures.0.get_binding_value(captures.1, false, context)
                                 },
                                 (env.clone(), parameter_name.to_owned()),
                             )
@@ -212,7 +211,7 @@ impl Arguments {
                                     // a. Return env.SetMutableBinding(name, value, false).
                                     captures
                                         .0
-                                        .set_mutable_binding(&captures.1, value, false, context)
+                                        .set_mutable_binding(captures.1, value, false, context)
                                         .map(|_| JsValue::Undefined)
                                     // Ok(JsValue::Undefined)
                                 },
diff --git a/boa/src/builtins/function/mod.rs b/boa/src/builtins/function/mod.rs
index ebc110bd460..255dbf14ffa 100644
--- a/boa/src/builtins/function/mod.rs
+++ b/boa/src/builtins/function/mod.rs
@@ -11,39 +11,29 @@
 //! [spec]: https://tc39.es/ecma262/#sec-function-objects
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function
 
-use std::{
-    any::Any,
-    borrow::Cow,
-    fmt,
-    ops::{Deref, DerefMut},
-};
-
-use dyn_clone::DynClone;
-use gc::{Gc, GcCell};
-
+use super::JsArgs;
 use crate::{
     builtins::BuiltIn,
     context::StandardObjects,
     environment::lexical_environment::Environment,
-    gc::{Finalize, Trace},
-    object::JsObject,
-    object::{internal_methods::get_prototype_from_constructor, NativeObject, ObjectData},
-    property::Attribute,
-    property::PropertyDescriptor,
-    BoaProfiler, Context, JsResult, JsValue,
-};
-use crate::{object::Object, symbol::WellKnownSymbols};
-use crate::{
-    object::{ConstructorBuilder, FunctionBuilder},
-    property::PropertyKey,
-    JsString,
-};
-use crate::{
-    object::{Ref, RefMut},
+    gc::{self, Finalize, Gc, Trace},
+    object::{
+        internal_methods::get_prototype_from_constructor, JsObject, NativeObject, Object,
+        ObjectData,
+    },
+    object::{ConstructorBuilder, FunctionBuilder, Ref, RefMut},
+    property::{Attribute, PropertyDescriptor, PropertyKey},
+    symbol::WellKnownSymbols,
     value::IntegerOrInfinity,
+    BoaProfiler, Context, JsResult, JsString, JsValue,
+};
+use dyn_clone::DynClone;
+use std::{
+    any::Any,
+    borrow::Cow,
+    fmt,
+    ops::{Deref, DerefMut},
 };
-
-use super::JsArgs;
 
 pub(crate) mod arguments;
 #[cfg(test)]
@@ -136,7 +126,7 @@ impl ConstructorKind {
 /// with `Any::downcast_ref` and `Any::downcast_mut` to recover the original
 /// type.
 #[derive(Clone, Debug, Trace, Finalize)]
-pub struct Captures(Gc<GcCell<Box<dyn NativeObject>>>);
+pub struct Captures(Gc<gc::Cell<Box<dyn NativeObject>>>);
 
 impl Captures {
     /// Creates a new capture context.
@@ -144,7 +134,7 @@ impl Captures {
     where
         T: NativeObject,
     {
-        Self(Gc::new(GcCell::new(Box::new(captures))))
+        Self(Gc::new(gc::Cell::new(Box::new(captures))))
     }
 
     /// Casts `Captures` to `Any`
@@ -152,7 +142,7 @@ impl Captures {
     /// # Panics
     ///
     /// Panics if it's already borrowed as `&mut Any`
-    pub fn as_any(&self) -> gc::GcCellRef<'_, dyn Any> {
+    pub fn as_any(&self) -> gc::Ref<'_, dyn Any> {
         Ref::map(self.0.borrow(), |data| data.deref().as_any())
     }
 
@@ -161,7 +151,7 @@ impl Captures {
     /// # Panics
     ///
     /// Panics if it's already borrowed as `&mut Any`
-    pub fn as_mut_any(&self) -> gc::GcCellRefMut<'_, Box<dyn NativeObject>, dyn Any> {
+    pub fn as_mut_any(&self) -> gc::RefMut<'_, Box<dyn NativeObject>, dyn Any> {
         RefMut::map(self.0.borrow_mut(), |data| data.deref_mut().as_mut_any())
     }
 }
diff --git a/boa/src/builtins/map/map_iterator.rs b/boa/src/builtins/map/map_iterator.rs
index 340ff75a292..b7cbb1ab63e 100644
--- a/boa/src/builtins/map/map_iterator.rs
+++ b/boa/src/builtins/map/map_iterator.rs
@@ -1,13 +1,13 @@
+use super::ordered_map::MapLock;
 use crate::{
     builtins::{function::make_builtin_fn, iterable::create_iter_result_object, Array, JsValue},
+    gc::{Finalize, Trace},
     object::{JsObject, ObjectData},
     property::{PropertyDescriptor, PropertyNameKind},
     symbol::WellKnownSymbols,
     BoaProfiler, Context, JsResult,
 };
-use gc::{Finalize, Trace};
 
-use super::ordered_map::MapLock;
 /// The Map Iterator object represents an iteration over a map. It implements the iterator protocol.
 ///
 /// More information:
diff --git a/boa/src/builtins/set/set_iterator.rs b/boa/src/builtins/set/set_iterator.rs
index 3720423143d..c82ac608ca3 100644
--- a/boa/src/builtins/set/set_iterator.rs
+++ b/boa/src/builtins/set/set_iterator.rs
@@ -1,13 +1,11 @@
 use crate::{
-    builtins::Array,
-    builtins::JsValue,
-    builtins::{function::make_builtin_fn, iterable::create_iter_result_object},
+    builtins::{function::make_builtin_fn, iterable::create_iter_result_object, Array, JsValue},
+    gc::{Finalize, Trace},
     object::{JsObject, ObjectData},
     property::{PropertyDescriptor, PropertyNameKind},
     symbol::WellKnownSymbols,
     BoaProfiler, Context, JsResult,
 };
-use gc::{Finalize, Trace};
 
 /// The Set Iterator object represents an iteration over a set. It implements the iterator protocol.
 ///
diff --git a/boa/src/bytecompiler.rs b/boa/src/bytecompiler.rs
index 1aa6e62dfe7..67e299ecc64 100644
--- a/boa/src/bytecompiler.rs
+++ b/boa/src/bytecompiler.rs
@@ -1,7 +1,6 @@
-use gc::Gc;
-
 use crate::{
     builtins::function::ThisMode,
+    gc::Gc,
     syntax::ast::{
         node::{
             declaration::{BindingPatternTypeArray, BindingPatternTypeObject, DeclarationPattern},
@@ -16,7 +15,9 @@ use crate::{
     vm::{CodeBlock, Opcode},
     JsBigInt, JsString, JsValue,
 };
-use std::{collections::HashMap, mem::size_of};
+use boa_interner::{Interner, Sym};
+use rustc_hash::FxHashMap;
+use std::mem::size_of;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 enum Literal {
@@ -32,7 +33,7 @@ struct Label {
 
 #[derive(Debug, Clone)]
 struct JumpControlInfo {
-    label: Option<Box<str>>,
+    label: Option<Sym>,
     start_address: u32,
     kind: JumpControlInfoKind,
     breaks: Vec<Label>,
@@ -56,24 +57,26 @@ enum Access<'a> {
 }
 
 #[derive(Debug)]
-pub struct ByteCompiler {
+pub struct ByteCompiler<'b> {
     code_block: CodeBlock,
-    literals_map: HashMap<Literal, u32>,
-    names_map: HashMap<JsString, u32>,
+    literals_map: FxHashMap<Literal, u32>,
+    names_map: FxHashMap<JsString, u32>,
     jump_info: Vec<JumpControlInfo>,
+    interner: &'b Interner,
 }
 
-impl ByteCompiler {
+impl<'b> ByteCompiler<'b> {
     /// Represents a placeholder address that will be patched later.
     const DUMMY_ADDRESS: u32 = u32::MAX;
 
     #[inline]
-    pub fn new(name: JsString, strict: bool) -> Self {
+    pub fn new(name: Sym, strict: bool, interner: &'b Interner) -> Self {
         Self {
             code_block: CodeBlock::new(name, 0, strict, false),
-            literals_map: HashMap::new(),
-            names_map: HashMap::new(),
+            literals_map: FxHashMap::default(),
+            names_map: FxHashMap::default(),
             jump_info: Vec::new(),
+            interner,
         }
     }
 
@@ -235,7 +238,7 @@ impl ByteCompiler {
     }
 
     #[inline]
-    fn push_loop_control_info(&mut self, label: Option<Box<str>>, start_address: u32) {
+    fn push_loop_control_info(&mut self, label: Option<Sym>, start_address: u32) {
         self.jump_info.push(JumpControlInfo {
             label,
             start_address,
@@ -247,11 +250,7 @@ impl ByteCompiler {
     }
 
     #[inline]
-    fn push_loop_control_info_for_of_in_loop(
-        &mut self,
-        label: Option<Box<str>>,
-        start_address: u32,
-    ) {
+    fn push_loop_control_info_for_of_in_loop(&mut self, label: Option<Sym>, start_address: u32) {
         self.jump_info.push(JumpControlInfo {
             label,
             start_address,
@@ -274,7 +273,7 @@ impl ByteCompiler {
     }
 
     #[inline]
-    fn push_switch_control_info(&mut self, label: Option<Box<str>>, start_address: u32) {
+    fn push_switch_control_info(&mut self, label: Option<Sym>, start_address: u32) {
         self.jump_info.push(JumpControlInfo {
             label,
             start_address,
@@ -354,7 +353,7 @@ impl ByteCompiler {
     fn compile_access<'a>(&mut self, node: &'a Node) -> Access<'a> {
         match node {
             Node::Identifier(name) => {
-                let index = self.get_or_insert_name(name.as_ref());
+                let index = self.get_or_insert_name(self.interner.resolve_expect(name.sym()));
                 Access::Variable { index }
             }
             Node::GetConstField(node) => Access::ByName { node },
@@ -371,7 +370,7 @@ impl ByteCompiler {
                 self.emit(Opcode::GetName, &[name]);
             }
             Access::ByName { node } => {
-                let index = self.get_or_insert_name(node.field());
+                let index = self.get_or_insert_name(self.interner.resolve_expect(node.field()));
                 self.compile_expr(node.obj(), true);
                 self.emit(Opcode::GetPropertyByName, &[index]);
             }
@@ -406,7 +405,7 @@ impl ByteCompiler {
             }
             Access::ByName { node } => {
                 self.compile_expr(node.obj(), true);
-                let index = self.get_or_insert_name(node.field());
+                let index = self.get_or_insert_name(self.interner.resolve_expect(node.field()));
                 self.emit(Opcode::SetPropertyByName, &[index]);
             }
             Access::ByValue { node } => {
@@ -435,7 +434,9 @@ impl ByteCompiler {
         match expr {
             Node::Const(c) => {
                 match c {
-                    Const::String(v) => self.emit_push_literal(Literal::String(v.as_ref().into())),
+                    Const::String(v) => self.emit_push_literal(Literal::String(
+                        self.interner.resolve_expect(*v).into(),
+                    )),
                     Const::Int(v) => self.emit_push_integer(*v),
                     Const::Num(v) => self.emit_push_rational(*v),
                     Const::BigInt(v) => self.emit_push_literal(Literal::BigInt(v.clone())),
@@ -487,7 +488,9 @@ impl ByteCompiler {
                     }
                     UnaryOp::Delete => match unary.target() {
                         Node::GetConstField(ref get_const_field) => {
-                            let index = self.get_or_insert_name(get_const_field.field());
+                            let index = self.get_or_insert_name(
+                                self.interner.resolve_expect(get_const_field.field()),
+                            );
                             self.compile_expr(get_const_field.obj(), true);
                             self.emit(Opcode::DeletePropertyByName, &[index]);
                             None
@@ -515,7 +518,9 @@ impl ByteCompiler {
                     UnaryOp::TypeOf => {
                         match &unary.target() {
                             Node::Identifier(identifier) => {
-                                let index = self.get_or_insert_name(identifier.as_ref());
+                                let index = self.get_or_insert_name(
+                                    self.interner.resolve_expect(identifier.sym()),
+                                );
                                 self.emit(Opcode::GetNameOrUndefined, &[index]);
                             }
                             expr => self.compile_expr(expr, true),
@@ -680,6 +685,7 @@ impl ByteCompiler {
                             PropertyName::Literal(name) => {
                                 self.compile_stmt(node, true);
                                 self.emit_opcode(Opcode::Swap);
+                                let name = self.interner.resolve_expect(*name);
                                 let index = self.get_or_insert_name(name);
                                 self.emit(Opcode::DefineOwnPropertyByName, &[index]);
                             }
@@ -695,6 +701,7 @@ impl ByteCompiler {
                                     PropertyName::Literal(name) => {
                                         self.compile_stmt(&func.clone().into(), true);
                                         self.emit_opcode(Opcode::Swap);
+                                        let name = self.interner.resolve_expect(*name);
                                         let index = self.get_or_insert_name(name);
                                         self.emit(Opcode::SetPropertyGetterByName, &[index]);
                                     }
@@ -708,6 +715,7 @@ impl ByteCompiler {
                                     PropertyName::Literal(name) => {
                                         self.compile_stmt(&func.clone().into(), true);
                                         self.emit_opcode(Opcode::Swap);
+                                        let name = self.interner.resolve_expect(*name);
                                         let index = self.get_or_insert_name(name);
                                         self.emit(Opcode::SetPropertySetterByName, &[index]);
                                     }
@@ -721,6 +729,7 @@ impl ByteCompiler {
                                     PropertyName::Literal(name) => {
                                         self.compile_stmt(&func.clone().into(), true);
                                         self.emit_opcode(Opcode::Swap);
+                                        let name = self.interner.resolve_expect(*name);
                                         let index = self.get_or_insert_name(name);
                                         self.emit(Opcode::DefineOwnPropertyByName, &[index]);
                                     }
@@ -736,6 +745,7 @@ impl ByteCompiler {
                                         PropertyName::Literal(name) => {
                                             self.emit_opcode(Opcode::PushUndefined);
                                             self.emit_opcode(Opcode::Swap);
+                                            let name = self.interner.resolve_expect(*name);
                                             let index = self.get_or_insert_name(name);
                                             self.emit(Opcode::DefineOwnPropertyByName, &[index]);
                                         }
@@ -752,6 +762,7 @@ impl ByteCompiler {
                                         PropertyName::Literal(name) => {
                                             self.emit_opcode(Opcode::PushUndefined);
                                             self.emit_opcode(Opcode::Swap);
+                                            let name = self.interner.resolve_expect(*name);
                                             let index = self.get_or_insert_name(name);
                                             self.emit(Opcode::DefineOwnPropertyByName, &[index])
                                         }
@@ -768,6 +779,7 @@ impl ByteCompiler {
                                         PropertyName::Literal(name) => {
                                             self.emit_opcode(Opcode::PushUndefined);
                                             self.emit_opcode(Opcode::Swap);
+                                            let name = self.interner.resolve_expect(*name);
                                             let index = self.get_or_insert_name(name);
                                             self.emit(Opcode::DefineOwnPropertyByName, &[index])
                                         }
@@ -794,7 +806,7 @@ impl ByteCompiler {
                 }
             }
             Node::Identifier(name) => {
-                let index = self.get_or_insert_name(name.as_ref());
+                let index = self.get_or_insert_name(self.interner.resolve_expect(name.sym()));
                 let access = Access::Variable { index };
                 self.access_get(access, use_expr);
             }
@@ -858,9 +870,9 @@ impl ByteCompiler {
             Node::TemplateLit(template_literal) => {
                 for element in template_literal.elements() {
                     match element {
-                        TemplateElement::String(s) => {
-                            self.emit_push_literal(Literal::String(s.as_ref().into()))
-                        }
+                        TemplateElement::String(s) => self.emit_push_literal(Literal::String(
+                            self.interner.resolve_expect(*s).into(),
+                        )),
                         TemplateElement::Expr(expr) => {
                             self.compile_expr(expr, true);
                         }
@@ -901,7 +913,8 @@ impl ByteCompiler {
                     Node::GetConstField(field) => {
                         self.compile_expr(field.obj(), true);
                         self.emit(Opcode::Dup, &[]);
-                        let index = self.get_or_insert_name(field.field());
+                        let index =
+                            self.get_or_insert_name(self.interner.resolve_expect(field.field()));
                         self.emit(Opcode::GetPropertyByName, &[index]);
                     }
                     Node::GetField(field) => {
@@ -921,7 +934,9 @@ impl ByteCompiler {
                 self.emit_opcode(Opcode::PushNewArray);
                 for cooked in template.cookeds() {
                     if let Some(cooked) = cooked {
-                        self.emit_push_literal(Literal::String(cooked.as_ref().into()));
+                        self.emit_push_literal(Literal::String(
+                            self.interner.resolve_expect(*cooked).into(),
+                        ));
                     } else {
                         self.emit_opcode(Opcode::PushUndefined);
                     }
@@ -931,7 +946,9 @@ impl ByteCompiler {
 
                 self.emit_opcode(Opcode::PushNewArray);
                 for raw in template.raws() {
-                    self.emit_push_literal(Literal::String(raw.as_ref().into()));
+                    self.emit_push_literal(Literal::String(
+                        self.interner.resolve_expect(*raw).into(),
+                    ));
                     self.emit_opcode(Opcode::PushValueToArray);
                 }
 
@@ -956,11 +973,12 @@ impl ByteCompiler {
                 for decl in list.as_ref() {
                     match decl {
                         Declaration::Identifier { ident, .. } => {
-                            if ident.as_ref() == "arguments" {
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            if ident == "arguments" {
                                 self.code_block.lexical_name_argument = true;
                             }
 
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let index = self.get_or_insert_name(ident);
 
                             if let Some(expr) = decl.init() {
                                 self.compile_expr(expr, true);
@@ -970,7 +988,7 @@ impl ByteCompiler {
                             }
                         }
                         Declaration::Pattern(pattern) => {
-                            if pattern.idents().contains(&"arguments") {
+                            if pattern.idents().contains(&Sym::ARGUMENTS) {
                                 self.code_block.lexical_name_argument = true;
                             }
 
@@ -989,11 +1007,12 @@ impl ByteCompiler {
                 for decl in list.as_ref() {
                     match decl {
                         Declaration::Identifier { ident, .. } => {
-                            if ident.as_ref() == "arguments" {
+                            if ident.sym() == Sym::ARGUMENTS {
                                 self.code_block.lexical_name_argument = true;
                             }
 
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let index =
+                                self.get_or_insert_name(self.interner.resolve_expect(ident.sym()));
 
                             if let Some(expr) = decl.init() {
                                 self.compile_expr(expr, true);
@@ -1003,7 +1022,7 @@ impl ByteCompiler {
                             }
                         }
                         Declaration::Pattern(pattern) => {
-                            if pattern.idents().contains(&"arguments") {
+                            if pattern.idents().contains(&Sym::ARGUMENTS) {
                                 self.code_block.lexical_name_argument = true;
                             }
 
@@ -1022,11 +1041,12 @@ impl ByteCompiler {
                 for decl in list.as_ref() {
                     match decl {
                         Declaration::Identifier { ident, .. } => {
-                            if ident.as_ref() == "arguments" {
+                            if ident.sym() == Sym::ARGUMENTS {
                                 self.code_block.lexical_name_argument = true;
                             }
 
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let index =
+                                self.get_or_insert_name(self.interner.resolve_expect(ident.sym()));
                             let init = decl
                                 .init()
                                 .expect("const declaration must have initializer");
@@ -1034,7 +1054,7 @@ impl ByteCompiler {
                             self.emit(Opcode::DefInitConst, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
-                            if pattern.idents().contains(&"arguments") {
+                            if pattern.idents().contains(&Sym::ARGUMENTS) {
                                 self.code_block.lexical_name_argument = true;
                             }
 
@@ -1077,7 +1097,7 @@ impl ByteCompiler {
                 let initial_jump = self.jump();
 
                 let start_address = self.next_opcode_location();
-                self.push_loop_control_info(for_loop.label().map(Into::into), start_address);
+                self.push_loop_control_info(for_loop.label(), start_address);
 
                 if let Some(final_expr) = for_loop.final_expr() {
                     self.compile_expr(final_expr, false);
@@ -1106,22 +1126,21 @@ impl ByteCompiler {
                 let early_exit = self.jump_with_custom_opcode(Opcode::ForInLoopInitIterator);
 
                 let start_address = self.next_opcode_location();
-                self.push_loop_control_info_for_of_in_loop(
-                    for_in_loop.label().map(Into::into),
-                    start_address,
-                );
+                self.push_loop_control_info_for_of_in_loop(for_in_loop.label(), start_address);
 
                 self.emit_opcode(Opcode::PushDeclarativeEnvironment);
                 let exit = self.jump_with_custom_opcode(Opcode::ForInLoopNext);
 
                 match for_in_loop.init() {
                     IterableLoopInitializer::Identifier(ref ident) => {
-                        let index = self.get_or_insert_name(ident.as_ref());
+                        let ident = self.interner.resolve_expect(ident.sym());
+                        let index = self.get_or_insert_name(ident);
                         self.emit(Opcode::SetName, &[index]);
                     }
                     IterableLoopInitializer::Var(declaration) => match declaration {
                         Declaration::Identifier { ident, .. } => {
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::DefInitVar, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
@@ -1130,7 +1149,8 @@ impl ByteCompiler {
                     },
                     IterableLoopInitializer::Let(declaration) => match declaration {
                         Declaration::Identifier { ident, .. } => {
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::DefInitLet, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
@@ -1139,7 +1159,8 @@ impl ByteCompiler {
                     },
                     IterableLoopInitializer::Const(declaration) => match declaration {
                         Declaration::Identifier { ident, .. } => {
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::DefInitConst, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
@@ -1165,22 +1186,21 @@ impl ByteCompiler {
                 self.emit_opcode(Opcode::InitIterator);
 
                 let start_address = self.next_opcode_location();
-                self.push_loop_control_info_for_of_in_loop(
-                    for_of_loop.label().map(Into::into),
-                    start_address,
-                );
+                self.push_loop_control_info_for_of_in_loop(for_of_loop.label(), start_address);
 
                 self.emit_opcode(Opcode::PushDeclarativeEnvironment);
                 let exit = self.jump_with_custom_opcode(Opcode::ForInLoopNext);
 
                 match for_of_loop.init() {
                     IterableLoopInitializer::Identifier(ref ident) => {
-                        let index = self.get_or_insert_name(ident.as_ref());
+                        let ident = self.interner.resolve_expect(ident.sym());
+                        let index = self.get_or_insert_name(ident);
                         self.emit(Opcode::SetName, &[index]);
                     }
                     IterableLoopInitializer::Var(declaration) => match declaration {
                         Declaration::Identifier { ident, .. } => {
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::DefInitVar, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
@@ -1189,7 +1209,8 @@ impl ByteCompiler {
                     },
                     IterableLoopInitializer::Let(declaration) => match declaration {
                         Declaration::Identifier { ident, .. } => {
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::DefInitLet, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
@@ -1198,7 +1219,8 @@ impl ByteCompiler {
                     },
                     IterableLoopInitializer::Const(declaration) => match declaration {
                         Declaration::Identifier { ident, .. } => {
-                            let index = self.get_or_insert_name(ident.as_ref());
+                            let ident = self.interner.resolve_expect(ident.sym());
+                            let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::DefInitConst, &[index]);
                         }
                         Declaration::Pattern(pattern) => {
@@ -1219,7 +1241,7 @@ impl ByteCompiler {
             }
             Node::WhileLoop(while_) => {
                 let start_address = self.next_opcode_location();
-                self.push_loop_control_info(while_.label().map(Into::into), start_address);
+                self.push_loop_control_info(while_.label(), start_address);
 
                 self.compile_expr(while_.cond(), true);
                 let exit = self.jump_if_false();
@@ -1233,7 +1255,7 @@ impl ByteCompiler {
                 let initial_label = self.jump();
 
                 let start_address = self.next_opcode_location();
-                self.push_loop_control_info(do_while.label().map(Into::into), start_address);
+                self.push_loop_control_info(do_while.label(), start_address);
 
                 let condition_label_address = self.next_opcode_location();
                 self.compile_expr(do_while.cond(), true);
@@ -1271,7 +1293,7 @@ impl ByteCompiler {
                         let mut emit_for_of_in_exit = 0;
                         let mut address_info = None;
                         for info in items {
-                            if info.label.as_deref() == node.label() {
+                            if info.label == node.label() {
                                 address_info = Some(info);
                                 break;
                             }
@@ -1306,7 +1328,7 @@ impl ByteCompiler {
                     self.jump_info.last_mut().unwrap().breaks.push(label);
                 } else {
                     for info in self.jump_info.iter_mut().rev() {
-                        if info.label.as_deref() == node.label() {
+                        if info.label == node.label() {
                             info.breaks.push(label);
                             break;
                         }
@@ -1385,7 +1407,8 @@ impl ByteCompiler {
                     if let Some(decl) = catch.parameter() {
                         match decl {
                             Declaration::Identifier { ident, .. } => {
-                                let index = self.get_or_insert_name(ident.as_ref());
+                                let ident = self.interner.resolve_expect(ident.sym());
+                                let index = self.get_or_insert_name(ident);
                                 self.emit(Opcode::DefInitLet, &[index]);
                             }
                             Declaration::Pattern(pattern) => {
@@ -1477,7 +1500,7 @@ impl ByteCompiler {
 
         let strict = body.strict() || self.code_block.strict;
         let length = parameters.len() as u32;
-        let mut code = CodeBlock::new(name.unwrap_or("").into(), length, strict, true);
+        let mut code = CodeBlock::new(name.unwrap_or(Sym::EMPTY_STRING), length, strict, true);
 
         if let FunctionKind::Arrow = kind {
             code.constructor = false;
@@ -1486,9 +1509,10 @@ impl ByteCompiler {
 
         let mut compiler = ByteCompiler {
             code_block: code,
-            literals_map: HashMap::new(),
-            names_map: HashMap::new(),
+            literals_map: FxHashMap::default(),
+            names_map: FxHashMap::default(),
             jump_info: Vec::new(),
+            interner: self.interner,
         };
 
         let mut has_rest_parameter = false;
@@ -1503,7 +1527,8 @@ impl ByteCompiler {
 
             match parameter.declaration() {
                 Declaration::Identifier { ident, .. } => {
-                    let index = compiler.get_or_insert_name(ident.as_ref());
+                    let ident = self.interner.resolve_expect(ident.sym());
+                    let index = compiler.get_or_insert_name(ident);
                     if let Some(init) = parameter.declaration().init() {
                         let skip = compiler.jump_with_custom_opcode(Opcode::JumpIfNotUndefined);
                         compiler.compile_expr(init, true);
@@ -1544,7 +1569,7 @@ impl ByteCompiler {
 
         match kind {
             FunctionKind::Declaration => {
-                let index = self.get_or_insert_name(name.unwrap());
+                let index = self.get_or_insert_name(self.interner.resolve_expect(name.unwrap()));
                 self.emit(Opcode::DefInitVar, &[index]);
             }
             FunctionKind::Expression | FunctionKind::Arrow => {
@@ -1572,7 +1597,7 @@ impl ByteCompiler {
             Node::GetConstField(field) => {
                 self.compile_expr(field.obj(), true);
                 self.emit(Opcode::Dup, &[]);
-                let index = self.get_or_insert_name(field.field());
+                let index = self.get_or_insert_name(self.interner.resolve_expect(field.field()));
                 self.emit(Opcode::GetPropertyByName, &[index]);
             }
             Node::GetField(field) => {
@@ -1646,7 +1671,8 @@ impl ByteCompiler {
                             default_init,
                         } => {
                             self.emit_opcode(Opcode::Dup);
-                            let index = self.get_or_insert_name(property_name);
+                            let index = self
+                                .get_or_insert_name(self.interner.resolve_expect(*property_name));
                             self.emit(Opcode::GetPropertyByName, &[index]);
 
                             if let Some(init) = default_init {
@@ -1655,6 +1681,7 @@ impl ByteCompiler {
                                 self.patch_jump(skip);
                             }
 
+                            let ident = self.interner.resolve_expect(*ident);
                             let index = self.get_or_insert_name(ident);
                             self.emit(def, &[index]);
                         }
@@ -1667,11 +1694,14 @@ impl ByteCompiler {
                             self.emit_opcode(Opcode::PushEmptyObject);
 
                             for key in excluded_keys {
-                                self.emit_push_literal(Literal::String(key.as_ref().into()));
+                                self.emit_push_literal(Literal::String(
+                                    self.interner.resolve_expect(*key).into(),
+                                ));
                             }
 
                             self.emit(Opcode::CopyDataProperties, &[excluded_keys.len() as u32]);
 
+                            let ident = self.interner.resolve_expect(*ident);
                             let index = self.get_or_insert_name(ident);
                             self.emit(def, &[index]);
                         }
@@ -1681,6 +1711,7 @@ impl ByteCompiler {
                             default_init,
                         } => {
                             self.emit_opcode(Opcode::Dup);
+                            let ident = self.interner.resolve_expect(*ident);
                             let index = self.get_or_insert_name(ident);
                             self.emit(Opcode::GetPropertyByName, &[index]);
 
@@ -1739,6 +1770,7 @@ impl ByteCompiler {
                                 self.patch_jump(skip);
                             }
 
+                            let ident = self.interner.resolve_expect(*ident);
                             let index = self.get_or_insert_name(ident);
                             self.emit(def, &[index]);
                         }
@@ -1751,6 +1783,7 @@ impl ByteCompiler {
                         SingleNameRest { ident } => {
                             self.emit_opcode(Opcode::IteratorToArray);
 
+                            let ident = self.interner.resolve_expect(*ident);
                             let index = self.get_or_insert_name(ident);
                             self.emit(def, &[index]);
                             self.emit_opcode(Opcode::PushTrue);
diff --git a/boa/src/context.rs b/boa/src/context.rs
index 6c2585778f3..61ddcf4efd6 100644
--- a/boa/src/context.rs
+++ b/boa/src/context.rs
@@ -1,5 +1,7 @@
 //! Javascript context.
 
+use boa_interner::Sym;
+
 use crate::{
     builtins::{
         self, function::NativeFunctionSignature, intrinsics::IntrinsicObjects,
@@ -7,14 +9,14 @@ use crate::{
     },
     bytecompiler::ByteCompiler,
     class::{Class, ClassBuilder},
+    gc::Gc,
     object::{FunctionBuilder, JsObject, ObjectData},
     property::{Attribute, PropertyDescriptor, PropertyKey},
     realm::Realm,
     syntax::{ast::node::StatementList, parser::ParseError, Parser},
     vm::{CallFrame, CodeBlock, FinallyReturn, Vm},
-    BoaProfiler, Interner, JsResult, JsString, JsValue,
+    BoaProfiler, Interner, JsResult, JsValue,
 };
-use gc::Gc;
 
 #[cfg(feature = "console")]
 use crate::builtins::console::Console;
@@ -390,7 +392,7 @@ impl Default for Context {
     fn default() -> Self {
         let mut context = Self {
             realm: Realm::create(),
-            interner: Interner::new(),
+            interner: Interner::default(),
             #[cfg(feature = "console")]
             console: Console::default(),
             iterator_prototypes: IteratorPrototypes::default(),
@@ -895,7 +897,7 @@ impl Context {
             Err(e) => return self.throw_syntax_error(e),
         };
 
-        let code_block = Context::compile(&statement_list);
+        let code_block = self.compile(&statement_list);
         let result = self.execute(code_block);
 
         // The main_timer needs to be dropped before the BoaProfiler is.
@@ -907,9 +909,9 @@ impl Context {
 
     /// Compile the AST into a `CodeBlock` ready to be executed by the VM.
     #[inline]
-    pub fn compile(statement_list: &StatementList) -> Gc<CodeBlock> {
+    pub fn compile(&mut self, statement_list: &StatementList) -> Gc<CodeBlock> {
         let _ = BoaProfiler::global().start_event("Compilation", "Main");
-        let mut compiler = ByteCompiler::new(JsString::new("<main>"), statement_list.strict());
+        let mut compiler = ByteCompiler::new(Sym::MAIN, statement_list.strict(), &self.interner);
         compiler.compile_statement_list(statement_list, true);
         Gc::new(compiler.finish())
     }
diff --git a/boa/src/environment/declarative_environment_record.rs b/boa/src/environment/declarative_environment_record.rs
index 16714f8c2b1..7b7589a79c6 100644
--- a/boa/src/environment/declarative_environment_record.rs
+++ b/boa/src/environment/declarative_environment_record.rs
@@ -10,11 +10,11 @@ use crate::{
         environment_record_trait::EnvironmentRecordTrait,
         lexical_environment::{Environment, EnvironmentType},
     },
-    gc::{Finalize, Trace},
+    gc::{self, Finalize, Gc, Trace},
     object::JsObject,
     BoaProfiler, Context, JsResult, JsValue,
 };
-use gc::{Gc, GcCell};
+use boa_interner::Sym;
 use rustc_hash::FxHashMap;
 
 /// Declarative Bindings have a few properties for book keeping purposes, such as mutability (const vs let).
@@ -34,7 +34,7 @@ pub struct DeclarativeEnvironmentRecordBinding {
 /// declarations contained within its scope.
 #[derive(Debug, Trace, Finalize, Clone)]
 pub struct DeclarativeEnvironmentRecord {
-    pub env_rec: GcCell<FxHashMap<Box<str>, DeclarativeEnvironmentRecordBinding>>,
+    pub env_rec: gc::Cell<FxHashMap<Sym, DeclarativeEnvironmentRecordBinding>>,
     pub outer_env: Option<Environment>,
 }
 
@@ -42,7 +42,7 @@ impl DeclarativeEnvironmentRecord {
     pub fn new(env: Option<Environment>) -> DeclarativeEnvironmentRecord {
         let _timer = BoaProfiler::global().start_event("new_declarative_environment", "env");
         DeclarativeEnvironmentRecord {
-            env_rec: GcCell::new(FxHashMap::default()),
+            env_rec: gc::Cell::new(FxHashMap::default()),
             outer_env: env,
         }
     }
@@ -55,10 +55,10 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-declarative-environment-records-hasbinding-n
-    fn has_binding(&self, name: &str, _context: &mut Context) -> JsResult<bool> {
+    fn has_binding(&self, name: Sym, _context: &mut Context) -> JsResult<bool> {
         // 1. If envRec has a binding for the name that is the value of N, return true.
         // 2. Return false.
-        Ok(self.env_rec.borrow().contains_key(name))
+        Ok(self.env_rec.borrow().contains_key(&name))
     }
 
     /// `9.1.1.1.2 CreateMutableBinding ( N, D )`
@@ -69,24 +69,24 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-declarative-environment-records-createmutablebinding-n-d
     fn create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         allow_name_reuse: bool,
-        _context: &mut Context,
+        context: &mut Context,
     ) -> JsResult<()> {
         // 1. Assert: envRec does not already have a binding for N.
         if !allow_name_reuse {
             assert!(
-                !self.env_rec.borrow().contains_key(name),
+                !self.env_rec.borrow().contains_key(&name),
                 "Identifier {} has already been declared",
-                name
+                context.interner().resolve_expect(name)
             );
         }
 
         // 2. Create a mutable binding in envRec for N and record that it is uninitialized.
         //    If D is true, record that the newly created binding may be deleted by a subsequent DeleteBinding call.
         self.env_rec.borrow_mut().insert(
-            name.into(),
+            name,
             DeclarativeEnvironmentRecordBinding {
                 value: None,
                 can_delete: deletion,
@@ -107,21 +107,21 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-declarative-environment-records-createimmutablebinding-n-s
     fn create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
-        _context: &mut Context,
+        context: &mut Context,
     ) -> JsResult<()> {
         // 1. Assert: envRec does not already have a binding for N.
         assert!(
-            !self.env_rec.borrow().contains_key(name),
+            !self.env_rec.borrow().contains_key(&name),
             "Identifier {} has already been declared",
-            name
+            context.interner().resolve_expect(name)
         );
 
         // 2. Create an immutable binding in envRec for N and record that it is uninitialized.
         //    If S is true, record that the newly created binding is a strict binding.
         self.env_rec.borrow_mut().insert(
-            name.into(),
+            name,
             DeclarativeEnvironmentRecordBinding {
                 value: None,
                 can_delete: true,
@@ -140,13 +140,8 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-declarative-environment-records-initializebinding-n-v
-    fn initialize_binding(
-        &self,
-        name: &str,
-        value: JsValue,
-        _context: &mut Context,
-    ) -> JsResult<()> {
-        if let Some(ref mut record) = self.env_rec.borrow_mut().get_mut(name) {
+    fn initialize_binding(&self, name: Sym, value: JsValue, context: &mut Context) -> JsResult<()> {
+        if let Some(ref mut record) = self.env_rec.borrow_mut().get_mut(&name) {
             if record.value.is_none() {
                 // 2. Set the bound value for N in envRec to V.
                 // 3. Record that the binding for N in envRec has been initialized.
@@ -158,7 +153,10 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
         }
 
         // 1. Assert: envRec must have an uninitialized binding for N.
-        panic!("record must have binding for {}", name);
+        panic!(
+            "record must have binding for {}",
+            context.interner().resolve_expect(name)
+        );
     }
 
     /// `9.1.1.1.5 SetMutableBinding ( N, V, S )`
@@ -170,16 +168,19 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     #[allow(clippy::else_if_without_else)]
     fn set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         mut strict: bool,
         context: &mut Context,
     ) -> JsResult<()> {
         // 1. If envRec does not have a binding for N, then
-        if self.env_rec.borrow().get(name).is_none() {
+        if self.env_rec.borrow().get(&name).is_none() {
             // a. If S is true, throw a ReferenceError exception.
             if strict {
-                return context.throw_reference_error(format!("{} not found", name));
+                return context.throw_reference_error(format!(
+                    "{} not found",
+                    context.interner().resolve_expect(name)
+                ));
             }
 
             // b. Perform envRec.CreateMutableBinding(N, true).
@@ -193,7 +194,7 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
 
         let (binding_strict, binding_value_is_none, binding_mutable) = {
             let env_rec = self.env_rec.borrow();
-            let binding = env_rec.get(name).unwrap();
+            let binding = env_rec.get(&name).unwrap();
             (binding.strict, binding.value.is_none(), binding.mutable)
         };
 
@@ -204,18 +205,23 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
 
         // 3. If the binding for N in envRec has not yet been initialized, throw a ReferenceError exception.
         if binding_value_is_none {
-            return context.throw_reference_error(format!("{} has not been initialized", name));
+            return context.throw_reference_error(format!(
+                "{} has not been initialized",
+                context.interner().resolve_expect(name)
+            ));
         // 4. Else if the binding for N in envRec is a mutable binding, change its bound value to V.
         } else if binding_mutable {
             let mut env_rec = self.env_rec.borrow_mut();
-            let binding = env_rec.get_mut(name).unwrap();
+            let binding = env_rec.get_mut(&name).unwrap();
             binding.value = Some(value);
         // 5. Else,
         // a. Assert: This is an attempt to change the value of an immutable binding.
         // b. If S is true, throw a TypeError exception.
         } else if strict {
-            return context
-                .throw_type_error(format!("Cannot mutate an immutable binding {}", name));
+            return context.throw_type_error(format!(
+                "Cannot mutate an immutable binding {}",
+                context.interner().resolve_expect(name)
+            ));
         }
 
         // 6. Return NormalCompletion(empty).
@@ -230,21 +236,27 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-declarative-environment-records-getbindingvalue-n-s
     fn get_binding_value(
         &self,
-        name: &str,
+        name: Sym,
         _strict: bool,
         context: &mut Context,
     ) -> JsResult<JsValue> {
         // 1. Assert: envRec has a binding for N.
         // 2. If the binding for N in envRec is an uninitialized binding, throw a ReferenceError exception.
         // 3. Return the value currently bound to N in envRec.
-        if let Some(binding) = self.env_rec.borrow().get(name) {
+        if let Some(binding) = self.env_rec.borrow().get(&name) {
             if let Some(ref val) = binding.value {
                 Ok(val.clone())
             } else {
-                context.throw_reference_error(format!("{} is an uninitialized binding", name))
+                context.throw_reference_error(format!(
+                    "{} is an uninitialized binding",
+                    context.interner().resolve_expect(name)
+                ))
             }
         } else {
-            panic!("Cannot get binding value for {}", name);
+            panic!(
+                "Cannot get binding value for {}",
+                context.interner().resolve_expect(name)
+            );
         }
     }
 
@@ -254,21 +266,24 @@ impl EnvironmentRecordTrait for DeclarativeEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-declarative-environment-records-deletebinding-n
-    fn delete_binding(&self, name: &str, _context: &mut Context) -> JsResult<bool> {
+    fn delete_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Assert: envRec has a binding for the name that is the value of N.
         // 2. If the binding for N in envRec cannot be deleted, return false.
         // 3. Remove the binding for N from envRec.
         // 4. Return true.
-        match self.env_rec.borrow().get(name) {
+        match self.env_rec.borrow().get(&name) {
             Some(binding) => {
                 if binding.can_delete {
-                    self.env_rec.borrow_mut().remove(name);
+                    self.env_rec.borrow_mut().remove(&name);
                     Ok(true)
                 } else {
                     Ok(false)
                 }
             }
-            None => panic!("env_rec has no binding for {}", name),
+            None => panic!(
+                "env_rec has no binding for {}",
+                context.interner().resolve_expect(name)
+            ),
         }
     }
 
diff --git a/boa/src/environment/environment_record_trait.rs b/boa/src/environment/environment_record_trait.rs
index 7a05e63fc2b..24de3fe82cc 100644
--- a/boa/src/environment/environment_record_trait.rs
+++ b/boa/src/environment/environment_record_trait.rs
@@ -9,12 +9,14 @@
 //! There are 5 Environment record kinds. They all have methods in common, these are implemented as a the `EnvironmentRecordTrait`
 //!
 
-use crate::{environment::lexical_environment::VariableScope, object::JsObject};
 use crate::{
+    environment::lexical_environment::VariableScope,
     environment::lexical_environment::{Environment, EnvironmentType},
     gc::{Finalize, Trace},
+    object::JsObject,
     Context, JsResult, JsValue,
 };
+use boa_interner::Sym;
 use std::fmt::Debug;
 
 /// <https://tc39.es/ecma262/#sec-environment-records>
@@ -24,7 +26,7 @@ use std::fmt::Debug;
 pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// Determine if an Environment Record has a binding for the String value N.
     /// Return true if it does and false if it does not.
-    fn has_binding(&self, name: &str, context: &mut Context) -> JsResult<bool>;
+    fn has_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool>;
 
     /// Create a new but uninitialized mutable binding in an Environment Record. The String value N is the text of the bound name.
     /// If the Boolean argument deletion is true the binding may be subsequently deleted.
@@ -35,7 +37,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// paraments with the same name.
     fn create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         allow_name_reuse: bool,
         context: &mut Context,
@@ -47,7 +49,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// regardless of the strict mode setting of operations that reference that binding.
     fn create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<()>;
@@ -55,8 +57,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// Set the value of an already existing but uninitialized binding in an Environment Record.
     /// The String value N is the text of the bound name.
     /// V is the value for the binding and is a value of any ECMAScript language type.
-    fn initialize_binding(&self, name: &str, value: JsValue, context: &mut Context)
-        -> JsResult<()>;
+    fn initialize_binding(&self, name: Sym, value: JsValue, context: &mut Context) -> JsResult<()>;
 
     /// Set the value of an already existing mutable binding in an Environment Record.
     /// The String value `name` is the text of the bound name.
@@ -64,7 +65,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// If `strict` is true and the binding cannot be set throw a TypeError exception.
     fn set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
         context: &mut Context,
@@ -76,7 +77,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// otherwise require strict mode reference semantics.
     fn get_binding_value(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<JsValue>;
@@ -85,7 +86,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// The String value name is the text of the bound name.
     /// If a binding for name exists, remove the binding and return true.
     /// If the binding exists but cannot be removed return false. If the binding does not exist return true.
-    fn delete_binding(&self, name: &str, context: &mut Context) -> JsResult<bool>;
+    fn delete_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool>;
 
     /// Determine if an Environment Record establishes a this binding.
     /// Return true if it does and false if it does not.
@@ -129,7 +130,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// Create mutable binding while handling outer environments
     fn recursive_create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         scope: VariableScope,
         context: &mut Context,
@@ -146,7 +147,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// Create immutable binding while handling outer environments
     fn recursive_create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         scope: VariableScope,
         context: &mut Context,
@@ -163,7 +164,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// Set mutable binding while handling outer environments
     fn recursive_set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
         context: &mut Context,
@@ -180,7 +181,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     /// Initialize binding while handling outer environments
     fn recursive_initialize_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         context: &mut Context,
     ) -> JsResult<()> {
@@ -194,7 +195,7 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     }
 
     /// Check if a binding exists in current or any outer environment
-    fn recursive_has_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn recursive_has_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         Ok(self.has_binding(name, context)?
             || match self.get_outer_environment_ref() {
                 Some(outer) => outer.recursive_has_binding(name, context)?,
@@ -203,13 +204,16 @@ pub trait EnvironmentRecordTrait: Debug + Trace + Finalize {
     }
 
     /// Retrieve binding from current or any outer environment
-    fn recursive_get_binding_value(&self, name: &str, context: &mut Context) -> JsResult<JsValue> {
+    fn recursive_get_binding_value(&self, name: Sym, context: &mut Context) -> JsResult<JsValue> {
         if self.has_binding(name, context)? {
             self.get_binding_value(name, false, context)
         } else {
             match self.get_outer_environment_ref() {
                 Some(outer) => outer.recursive_get_binding_value(name, context),
-                None => context.throw_reference_error(format!("{} is not defined", name)),
+                None => context.throw_reference_error(format!(
+                    "{} is not defined",
+                    context.interner().resolve_expect(name)
+                )),
             }
         }
     }
diff --git a/boa/src/environment/function_environment_record.rs b/boa/src/environment/function_environment_record.rs
index 2d7262e6605..c7a2c2ed995 100644
--- a/boa/src/environment/function_environment_record.rs
+++ b/boa/src/environment/function_environment_record.rs
@@ -8,18 +8,17 @@
 //! from within the function.
 //! More info: <https://tc39.es/ecma262/#sec-function-environment-records>
 
-use gc::Gc;
-
 use crate::{
     environment::{
         declarative_environment_record::DeclarativeEnvironmentRecord,
         environment_record_trait::EnvironmentRecordTrait,
         lexical_environment::{Environment, EnvironmentType, VariableScope},
     },
-    gc::{empty_trace, Finalize, Trace},
+    gc::{empty_trace, Finalize, Gc, Trace},
     object::{JsObject, JsPrototype},
     Context, JsResult, JsValue,
 };
+use boa_interner::Sym;
 
 /// Different binding status for `this`.
 /// Usually set on a function environment record
@@ -136,13 +135,13 @@ impl FunctionEnvironmentRecord {
 }
 
 impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
-    fn has_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn has_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         self.declarative_record.has_binding(name, context)
     }
 
     fn create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         allow_name_reuse: bool,
         context: &mut Context,
@@ -153,7 +152,7 @@ impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
 
     fn create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<()> {
@@ -161,19 +160,14 @@ impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
             .create_immutable_binding(name, strict, context)
     }
 
-    fn initialize_binding(
-        &self,
-        name: &str,
-        value: JsValue,
-        context: &mut Context,
-    ) -> JsResult<()> {
+    fn initialize_binding(&self, name: Sym, value: JsValue, context: &mut Context) -> JsResult<()> {
         self.declarative_record
             .initialize_binding(name, value, context)
     }
 
     fn set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
         context: &mut Context,
@@ -184,7 +178,7 @@ impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
 
     fn get_binding_value(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<JsValue> {
@@ -192,7 +186,7 @@ impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
             .get_binding_value(name, strict, context)
     }
 
-    fn delete_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn delete_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         self.declarative_record.delete_binding(name, context)
     }
 
@@ -262,7 +256,7 @@ impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
 
     fn recursive_create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         _scope: VariableScope,
         context: &mut Context,
@@ -272,7 +266,7 @@ impl EnvironmentRecordTrait for FunctionEnvironmentRecord {
 
     fn recursive_create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         _scope: VariableScope,
         context: &mut Context,
diff --git a/boa/src/environment/global_environment_record.rs b/boa/src/environment/global_environment_record.rs
index 5c21ecc7a5d..41fa693d0ce 100644
--- a/boa/src/environment/global_environment_record.rs
+++ b/boa/src/environment/global_environment_record.rs
@@ -14,12 +14,12 @@ use crate::{
         lexical_environment::{Environment, EnvironmentType, VariableScope},
         object_environment_record::ObjectEnvironmentRecord,
     },
-    gc::{Finalize, Trace},
+    gc::{self, Finalize, Gc, Trace},
     object::JsObject,
     property::PropertyDescriptor,
     Context, JsResult, JsValue,
 };
-use gc::{Gc, GcCell};
+use boa_interner::Sym;
 use rustc_hash::FxHashSet;
 
 #[derive(Debug, Trace, Finalize, Clone)]
@@ -27,7 +27,7 @@ pub struct GlobalEnvironmentRecord {
     pub object_record: ObjectEnvironmentRecord,
     pub global_this_binding: JsObject,
     pub declarative_record: DeclarativeEnvironmentRecord,
-    pub var_names: GcCell<FxHashSet<Box<str>>>,
+    pub var_names: gc::Cell<FxHashSet<Sym>>,
 }
 
 impl GlobalEnvironmentRecord {
@@ -49,7 +49,7 @@ impl GlobalEnvironmentRecord {
             object_record: obj_rec,
             global_this_binding: this_value,
             declarative_record: dcl_rec,
-            var_names: GcCell::new(FxHashSet::default()),
+            var_names: gc::Cell::new(FxHashSet::default()),
         }
     }
 
@@ -59,11 +59,11 @@ impl GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-hasvardeclaration
-    pub fn has_var_declaration(&self, name: &str) -> bool {
+    pub fn has_var_declaration(&self, name: Sym) -> bool {
         // 1. Let varDeclaredNames be envRec.[[VarNames]].
         // 2. If varDeclaredNames contains N, return true.
         // 3. Return false.
-        self.var_names.borrow().contains(name)
+        self.var_names.borrow().contains(&name)
     }
 
     /// `9.1.1.4.13 HasLexicalDeclaration ( N )`
@@ -72,7 +72,7 @@ impl GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-haslexicaldeclaration
-    pub fn has_lexical_declaration(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    pub fn has_lexical_declaration(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let DclRec be envRec.[[DeclarativeRecord]].
         // 2. Return DclRec.HasBinding(N).
         self.declarative_record.has_binding(name, context)
@@ -86,7 +86,7 @@ impl GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-hasrestrictedglobalproperty
     pub fn has_restricted_global_property(
         &self,
-        name: &str,
+        name: Sym,
         context: &mut Context,
     ) -> JsResult<bool> {
         // 1. Let ObjRec be envRec.[[ObjectRecord]].
@@ -94,7 +94,8 @@ impl GlobalEnvironmentRecord {
         let global_object = &self.object_record.bindings;
 
         // 3. Let existingProp be ? globalObject.[[GetOwnProperty]](N).
-        let existing_prop = global_object.__get_own_property__(&name.into(), context)?;
+        let existing_prop = global_object
+            .__get_own_property__(&context.interner().resolve_expect(name).into(), context)?;
 
         if let Some(existing_prop) = existing_prop {
             // 5. If existingProp.[[Configurable]] is true, return false.
@@ -112,13 +113,14 @@ impl GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-candeclareglobalvar
-    pub fn can_declare_global_var(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    pub fn can_declare_global_var(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let ObjRec be envRec.[[ObjectRecord]].
         // 2. Let globalObject be ObjRec.[[BindingObject]].
         let global_object = &self.object_record.bindings;
 
         // 3. Let hasProperty be ? HasOwnProperty(globalObject, N).
-        let has_property = global_object.has_own_property(name, context)?;
+        let key = context.interner().resolve_expect(name).to_owned();
+        let has_property = global_object.has_own_property(key, context)?;
 
         // 4. If hasProperty is true, return true.
         if has_property {
@@ -135,13 +137,14 @@ impl GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-candeclareglobalfunction
-    pub fn can_declare_global_function(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    pub fn can_declare_global_function(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let ObjRec be envRec.[[ObjectRecord]].
         // 2. Let globalObject be ObjRec.[[BindingObject]].
         let global_object = &self.object_record.bindings;
 
         // 3. Let existingProp be ? globalObject.[[GetOwnProperty]](N).
-        let existing_prop = global_object.__get_own_property__(&name.into(), context)?;
+        let existing_prop = global_object
+            .__get_own_property__(&context.interner().resolve_expect(name).into(), context)?;
 
         if let Some(existing_prop) = existing_prop {
             // 5. If existingProp.[[Configurable]] is true, return true.
@@ -175,7 +178,7 @@ impl GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-createglobalvarbinding
     pub fn create_global_var_binding(
         &mut self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         context: &mut Context,
     ) -> JsResult<()> {
@@ -184,7 +187,8 @@ impl GlobalEnvironmentRecord {
         let global_object = &self.object_record.bindings;
 
         // 3. Let hasProperty be ? HasOwnProperty(globalObject, N).
-        let has_property = global_object.has_own_property(name, context)?;
+        let has_property = global_object
+            .has_own_property(context.interner().resolve_expect(name).to_owned(), context)?;
         // 4. Let extensible be ? IsExtensible(globalObject).
         let extensible = global_object.is_extensible(context)?;
 
@@ -201,9 +205,9 @@ impl GlobalEnvironmentRecord {
         // 6. Let varDeclaredNames be envRec.[[VarNames]].
         let mut var_declared_names = self.var_names.borrow_mut();
         // 7. If varDeclaredNames does not contain N, then
-        if !var_declared_names.contains(name) {
+        if !var_declared_names.contains(&name) {
             // a. Append N to varDeclaredNames.
-            var_declared_names.insert(name.into());
+            var_declared_names.insert(name);
         }
 
         // 8. Return NormalCompletion(empty).
@@ -218,7 +222,7 @@ impl GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-createglobalfunctionbinding
     pub fn create_global_function_binding(
         &mut self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         deletion: bool,
         context: &mut Context,
@@ -228,7 +232,8 @@ impl GlobalEnvironmentRecord {
         let global_object = &self.object_record.bindings;
 
         // 3. Let existingProp be ? globalObject.[[GetOwnProperty]](N).
-        let existing_prop = global_object.__get_own_property__(&name.into(), context)?;
+        let existing_prop = global_object
+            .__get_own_property__(&context.interner().resolve_expect(name).into(), context)?;
 
         // 4. If existingProp is undefined or existingProp.[[Configurable]] is true, then
         let desc = if existing_prop
@@ -248,16 +253,18 @@ impl GlobalEnvironmentRecord {
             PropertyDescriptor::builder().value(value.clone()).build()
         };
 
+        let name_str = context.interner().resolve_expect(name).to_owned();
+
         // 6. Perform ? DefinePropertyOrThrow(globalObject, N, desc).
-        global_object.define_property_or_throw(name, desc, context)?;
+        global_object.define_property_or_throw(name_str.as_str(), desc, context)?;
         // 7. Perform ? Set(globalObject, N, V, false).
-        global_object.set(name, value, false, context)?;
+        global_object.set(name_str, value, false, context)?;
 
         // 8. Let varDeclaredNames be envRec.[[VarNames]].
         // 9. If varDeclaredNames does not contain N, then
-        if !self.var_names.borrow().contains(name) {
+        if !self.var_names.borrow().contains(&name) {
             // a. Append N to varDeclaredNames.
-            self.var_names.borrow_mut().insert(name.into());
+            self.var_names.borrow_mut().insert(name);
         }
 
         // 10. Return NormalCompletion(empty).
@@ -272,7 +279,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-hasbinding-n
-    fn has_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn has_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let DclRec be envRec.[[DeclarativeRecord]].
         // 2. If DclRec.HasBinding(N) is true, return true.
         if self.declarative_record.has_binding(name, context)? {
@@ -292,7 +299,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-createmutablebinding-n-d
     fn create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         allow_name_reuse: bool,
         context: &mut Context,
@@ -300,7 +307,10 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
         // 1. Let DclRec be envRec.[[DeclarativeRecord]].
         // 2. If DclRec.HasBinding(N) is true, throw a TypeError exception.
         if !allow_name_reuse && self.declarative_record.has_binding(name, context)? {
-            return context.throw_type_error(format!("Binding already exists for {}", name));
+            return context.throw_type_error(format!(
+                "Binding already exists for {}",
+                context.interner().resolve_expect(name)
+            ));
         }
 
         // 3. Return DclRec.CreateMutableBinding(N, D).
@@ -316,14 +326,17 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-createimmutablebinding-n-s
     fn create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<()> {
         // 1. Let DclRec be envRec.[[DeclarativeRecord]].
         // 2. If DclRec.HasBinding(N) is true, throw a TypeError exception.
         if self.declarative_record.has_binding(name, context)? {
-            return context.throw_type_error(format!("Binding already exists for {}", name));
+            return context.throw_type_error(format!(
+                "Binding already exists for {}",
+                context.interner().resolve_expect(name)
+            ));
         }
 
         // 3. Return DclRec.CreateImmutableBinding(N, S).
@@ -337,12 +350,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-initializebinding-n-v
-    fn initialize_binding(
-        &self,
-        name: &str,
-        value: JsValue,
-        context: &mut Context,
-    ) -> JsResult<()> {
+    fn initialize_binding(&self, name: Sym, value: JsValue, context: &mut Context) -> JsResult<()> {
         // 1. Let DclRec be envRec.[[DeclarativeRecord]].
         // 2. If DclRec.HasBinding(N) is true, then
         if self.declarative_record.has_binding(name, context)? {
@@ -371,7 +379,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-setmutablebinding-n-v-s
     fn set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
         context: &mut Context,
@@ -399,7 +407,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-getbindingvalue-n-s
     fn get_binding_value(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<JsValue> {
@@ -423,7 +431,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-global-environment-records-deletebinding-n
-    fn delete_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn delete_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let DclRec be envRec.[[DeclarativeRecord]].
         // 2. If DclRec.HasBinding(N) is true, then
         if self.declarative_record.has_binding(name, context)? {
@@ -437,7 +445,9 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
 
         // 5. Let existingProp be ? HasOwnProperty(globalObject, N).
         // 6. If existingProp is true, then
-        if global_object.has_own_property(name, context)? {
+        if global_object
+            .has_own_property(context.interner().resolve_expect(name).to_owned(), context)?
+        {
             // a. Let status be ? ObjRec.DeleteBinding(N).
             let status = self.object_record.delete_binding(name, context)?;
 
@@ -445,7 +455,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
             if status {
                 // i. Let varNames be envRec.[[VarNames]].
                 // ii. If N is an element of varNames, remove that element from the varNames.
-                self.var_names.borrow_mut().remove(name);
+                self.var_names.borrow_mut().remove(&name);
             }
 
             // c. Return status.
@@ -519,7 +529,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
 
     fn recursive_create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         _scope: VariableScope,
         context: &mut Context,
@@ -529,7 +539,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
 
     fn recursive_create_immutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         _scope: VariableScope,
         context: &mut Context,
@@ -539,7 +549,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
 
     fn recursive_set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
         context: &mut Context,
@@ -549,7 +559,7 @@ impl EnvironmentRecordTrait for GlobalEnvironmentRecord {
 
     fn recursive_initialize_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         context: &mut Context,
     ) -> JsResult<()> {
diff --git a/boa/src/environment/lexical_environment.rs b/boa/src/environment/lexical_environment.rs
index 8f7361be1b0..f282dfac349 100644
--- a/boa/src/environment/lexical_environment.rs
+++ b/boa/src/environment/lexical_environment.rs
@@ -7,10 +7,10 @@
 
 use super::global_environment_record::GlobalEnvironmentRecord;
 use crate::{
-    environment::environment_record_trait::EnvironmentRecordTrait, object::JsObject, BoaProfiler,
-    Context, JsResult, JsValue,
+    environment::environment_record_trait::EnvironmentRecordTrait, gc::Gc, object::JsObject,
+    BoaProfiler, Context, JsResult, JsValue,
 };
-use gc::Gc;
+use boa_interner::Sym;
 use std::{collections::VecDeque, error, fmt};
 
 /// Environments are wrapped in a Box and then in a GC wrapper
@@ -100,7 +100,7 @@ impl Context {
 
     pub(crate) fn create_mutable_binding(
         &mut self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         scope: VariableScope,
     ) -> JsResult<()> {
@@ -110,7 +110,7 @@ impl Context {
 
     pub(crate) fn create_immutable_binding(
         &mut self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         scope: VariableScope,
     ) -> JsResult<()> {
@@ -120,7 +120,7 @@ impl Context {
 
     pub(crate) fn set_mutable_binding(
         &mut self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
     ) -> JsResult<()> {
@@ -128,7 +128,7 @@ impl Context {
             .recursive_set_mutable_binding(name, value, strict, self)
     }
 
-    pub(crate) fn initialize_binding(&mut self, name: &str, value: JsValue) -> JsResult<()> {
+    pub(crate) fn initialize_binding(&mut self, name: Sym, value: JsValue) -> JsResult<()> {
         let _timer =
             BoaProfiler::global().start_event("LexicalEnvironment::initialize_binding", "env");
         self.get_current_environment()
@@ -148,13 +148,13 @@ impl Context {
             .clone()
     }
 
-    pub(crate) fn has_binding(&mut self, name: &str) -> JsResult<bool> {
+    pub(crate) fn has_binding(&mut self, name: Sym) -> JsResult<bool> {
         let _timer = BoaProfiler::global().start_event("LexicalEnvironment::has_binding", "env");
         self.get_current_environment()
             .recursive_has_binding(name, self)
     }
 
-    pub(crate) fn get_binding_value(&mut self, name: &str) -> JsResult<JsValue> {
+    pub(crate) fn get_binding_value(&mut self, name: Sym) -> JsResult<JsValue> {
         let _timer =
             BoaProfiler::global().start_event("LexicalEnvironment::get_binding_value", "env");
         self.get_current_environment()
diff --git a/boa/src/environment/object_environment_record.rs b/boa/src/environment/object_environment_record.rs
index d39cb624414..55a85251bdb 100644
--- a/boa/src/environment/object_environment_record.rs
+++ b/boa/src/environment/object_environment_record.rs
@@ -6,19 +6,18 @@
 //! Property keys that are not strings in the form of an `IdentifierName` are not included in the set of bound identifiers.
 //! More info:  [Object Records](https://tc39.es/ecma262/#sec-object-environment-records)
 
-use gc::Gc;
-
 use crate::{
     environment::{
         environment_record_trait::EnvironmentRecordTrait,
         lexical_environment::{Environment, EnvironmentType},
     },
-    gc::{Finalize, Trace},
+    gc::{Finalize, Gc, Trace},
     object::JsObject,
     property::PropertyDescriptor,
     symbol::WellKnownSymbols,
     Context, JsResult, JsValue,
 };
+use boa_interner::Sym;
 
 #[derive(Debug, Trace, Finalize, Clone)]
 pub struct ObjectEnvironmentRecord {
@@ -49,11 +48,14 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-hasbinding-n
-    fn has_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn has_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let bindingObject be envRec.[[BindingObject]].
         // 2. Let foundBinding be ? HasProperty(bindingObject, N).
         // 3. If foundBinding is false, return false.
-        if !self.bindings.has_property(name, context)? {
+        if !self
+            .bindings
+            .has_property(context.interner().resolve_expect(name).to_owned(), context)?
+        {
             return Ok(false);
         }
 
@@ -71,7 +73,10 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
         {
             // a. Let blocked be ! ToBoolean(? Get(unscopables, N)).
             // b. If blocked is true, return false.
-            if unscopables.get(name, context)?.to_boolean() {
+            if unscopables
+                .get(context.interner().resolve_expect(name).to_owned(), context)?
+                .to_boolean()
+            {
                 return Ok(false);
             }
         }
@@ -88,7 +93,7 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-createmutablebinding-n-d
     fn create_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         deletion: bool,
         _allow_name_reuse: bool,
         context: &mut Context,
@@ -96,7 +101,7 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
         // 1. Let bindingObject be envRec.[[BindingObject]].
         // 2. Return ? DefinePropertyOrThrow(bindingObject, N, PropertyDescriptor { [[Value]]: undefined, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: D }).
         self.bindings.define_property_or_throw(
-            name,
+            context.interner().resolve_expect(name).to_owned(),
             PropertyDescriptor::builder()
                 .value(JsValue::undefined())
                 .writable(true)
@@ -115,7 +120,7 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-createimmutablebinding-n-s
     fn create_immutable_binding(
         &self,
-        _name: &str,
+        _name: Sym,
         _strict: bool,
         _context: &mut Context,
     ) -> JsResult<()> {
@@ -128,12 +133,7 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-initializebinding-n-v
-    fn initialize_binding(
-        &self,
-        name: &str,
-        value: JsValue,
-        context: &mut Context,
-    ) -> JsResult<()> {
+    fn initialize_binding(&self, name: Sym, value: JsValue, context: &mut Context) -> JsResult<()> {
         // 1. Return ? envRec.SetMutableBinding(N, V, false).
         self.set_mutable_binding(name, value, false, context)
     }
@@ -146,14 +146,16 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-setmutablebinding-n-v-s
     fn set_mutable_binding(
         &self,
-        name: &str,
+        name: Sym,
         value: JsValue,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<()> {
         // 1. Let bindingObject be envRec.[[BindingObject]].
         // 2. Let stillExists be ? HasProperty(bindingObject, N).
-        let still_exists = self.bindings.has_property(name, context)?;
+        let still_exists = self
+            .bindings
+            .has_property(context.interner().resolve_expect(name).to_owned(), context)?;
 
         // 3. If stillExists is false and S is true, throw a ReferenceError exception.
         if !still_exists && strict {
@@ -161,7 +163,12 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
         }
 
         // 4. Return ? Set(bindingObject, N, V, S).
-        self.bindings.set(name, value, strict, context)?;
+        self.bindings.set(
+            context.interner().resolve_expect(name).to_owned(),
+            value,
+            strict,
+            context,
+        )?;
         Ok(())
     }
 
@@ -173,24 +180,31 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-getbindingvalue-n-s
     fn get_binding_value(
         &self,
-        name: &str,
+        name: Sym,
         strict: bool,
         context: &mut Context,
     ) -> JsResult<JsValue> {
         // 1. Let bindingObject be envRec.[[BindingObject]].
         // 2. Let value be ? HasProperty(bindingObject, N).
         // 3. If value is false, then
-        if !self.bindings.__has_property__(&name.into(), context)? {
+        if !self
+            .bindings
+            .__has_property__(&context.interner().resolve_expect(name).into(), context)?
+        {
             // a. If S is false, return the value undefined; otherwise throw a ReferenceError exception.
             if !strict {
                 return Ok(JsValue::undefined());
             } else {
-                return context.throw_reference_error(format!("{} has no binding", name));
+                return context.throw_reference_error(format!(
+                    "{} has no binding",
+                    context.interner().resolve_expect(name)
+                ));
             }
         }
 
         // 4. Return ? Get(bindingObject, N).
-        self.bindings.get(name, context)
+        self.bindings
+            .get(context.interner().resolve_expect(name).to_owned(), context)
     }
 
     /// `9.1.1.2.7 DeleteBinding ( N )`
@@ -199,10 +213,11 @@ impl EnvironmentRecordTrait for ObjectEnvironmentRecord {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-object-environment-records-deletebinding-n
-    fn delete_binding(&self, name: &str, context: &mut Context) -> JsResult<bool> {
+    fn delete_binding(&self, name: Sym, context: &mut Context) -> JsResult<bool> {
         // 1. Let bindingObject be envRec.[[BindingObject]].
         // 2. Return ? bindingObject.[[Delete]](N).
-        self.bindings.__delete__(&name.into(), context)
+        self.bindings
+            .__delete__(&context.interner().resolve_expect(name).into(), context)
     }
 
     /// `9.1.1.2.8 HasThisBinding ( )`
diff --git a/boa/src/gc.rs b/boa/src/gc.rs
index 7cf585edaac..5fbd0255f71 100644
--- a/boa/src/gc.rs
+++ b/boa/src/gc.rs
@@ -5,6 +5,6 @@
 #![allow(clippy::unsafe_removed_from_name)]
 
 pub use gc::{
-    custom_trace, force_collect, unsafe_empty_trace as empty_trace, Finalize, GcCellRef as Ref,
-    GcCellRefMut as RefMut, Trace,
+    custom_trace, force_collect, unsafe_empty_trace as empty_trace, Finalize, Gc, GcCell as Cell,
+    GcCellRef as Ref, GcCellRefMut as RefMut, Trace,
 };
diff --git a/boa/src/object/jsobject.rs b/boa/src/object/jsobject.rs
index d87c783e63d..31d5e860e7a 100644
--- a/boa/src/object/jsobject.rs
+++ b/boa/src/object/jsobject.rs
@@ -4,12 +4,12 @@
 
 use super::{JsPrototype, NativeObject, Object};
 use crate::{
+    gc::{self, Finalize, Gc, Trace},
     object::{ObjectData, ObjectKind},
     property::{PropertyDescriptor, PropertyKey},
     value::PreferredType,
     Context, JsResult, JsValue,
 };
-use gc::{Finalize, Gc, GcCell, GcCellRef, GcCellRefMut, Trace};
 use std::{
     cell::RefCell,
     collections::HashMap,
@@ -19,20 +19,20 @@ use std::{
 };
 
 /// A wrapper type for an immutably borrowed type T.
-pub type Ref<'a, T> = GcCellRef<'a, T>;
+pub type Ref<'a, T> = gc::Ref<'a, T>;
 
 /// A wrapper type for a mutably borrowed type T.
-pub type RefMut<'a, T, U> = GcCellRefMut<'a, T, U>;
+pub type RefMut<'a, T, U> = gc::RefMut<'a, T, U>;
 
 /// Garbage collected `Object`.
 #[derive(Trace, Finalize, Clone, Default)]
-pub struct JsObject(Gc<GcCell<Object>>);
+pub struct JsObject(Gc<gc::Cell<Object>>);
 
 impl JsObject {
     /// Create a new `JsObject` from an internal `Object`.
     #[inline]
     fn from_object(object: Object) -> Self {
-        Self(Gc::new(GcCell::new(object)))
+        Self(Gc::new(gc::Cell::new(object)))
     }
 
     /// Create a new empty `JsObject`, with `prototype` set to `JsValue::Null`
@@ -650,9 +650,9 @@ Cannot both specify accessors and a value or writable attribute",
     }
 }
 
-impl AsRef<GcCell<Object>> for JsObject {
+impl AsRef<gc::Cell<Object>> for JsObject {
     #[inline]
-    fn as_ref(&self) -> &GcCell<Object> {
+    fn as_ref(&self) -> &gc::Cell<Object> {
         &*self.0
     }
 }
diff --git a/boa/src/property/mod.rs b/boa/src/property/mod.rs
index 0cbb1f3df7d..c591ac01770 100644
--- a/boa/src/property/mod.rs
+++ b/boa/src/property/mod.rs
@@ -15,14 +15,13 @@
 //! [section]: https://tc39.es/ecma262/#sec-property-attributes
 
 use crate::{
-    gc::{Finalize, Trace},
+    gc::{empty_trace, Finalize, Trace},
     JsString, JsSymbol, JsValue,
 };
 use std::{convert::TryFrom, fmt};
 
 mod attribute;
 pub use attribute::Attribute;
-use gc::unsafe_empty_trace;
 
 /// This represents a JavaScript Property AKA The Property Descriptor.
 ///
@@ -672,5 +671,5 @@ pub(crate) enum PropertyNameKind {
 }
 
 unsafe impl Trace for PropertyNameKind {
-    unsafe_empty_trace!();
+    empty_trace!();
 }
diff --git a/boa/src/realm.rs b/boa/src/realm.rs
index 303a93364d7..97f97facdc1 100644
--- a/boa/src/realm.rs
+++ b/boa/src/realm.rs
@@ -8,10 +8,10 @@ use crate::{
     environment::{
         global_environment_record::GlobalEnvironmentRecord, lexical_environment::LexicalEnvironment,
     },
+    gc::Gc,
     object::{JsObject, ObjectData},
     BoaProfiler,
 };
-use gc::Gc;
 
 /// Representation of a Realm.
 ///
diff --git a/boa/src/syntax/ast/constant.rs b/boa/src/syntax/ast/constant.rs
index 6fb6a9939b4..b657b854a2b 100644
--- a/boa/src/syntax/ast/constant.rs
+++ b/boa/src/syntax/ast/constant.rs
@@ -11,7 +11,7 @@ use crate::{
     gc::{Finalize, Trace},
     JsBigInt,
 };
-use std::fmt::{Display, Formatter, Result};
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -42,7 +42,7 @@ pub enum Const {
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-terms-and-definitions-string-value
     /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#String_literals
-    String(Box<str>),
+    String(Sym),
 
     /// A floating-point number literal.
     ///
@@ -115,27 +115,9 @@ pub enum Const {
     Undefined,
 }
 
-impl From<&str> for Const {
-    fn from(s: &str) -> Self {
-        Self::String(s.to_owned().into_boxed_str())
-    }
-}
-
-impl From<&String> for Const {
-    fn from(s: &String) -> Self {
-        Self::String(s.clone().into_boxed_str())
-    }
-}
-
-impl From<Box<str>> for Const {
-    fn from(s: Box<str>) -> Self {
-        Self::String(s)
-    }
-}
-
-impl From<String> for Const {
-    fn from(s: String) -> Self {
-        Self::String(s.into_boxed_str())
+impl From<Sym> for Const {
+    fn from(string: Sym) -> Self {
+        Self::String(string)
     }
 }
 
@@ -163,16 +145,18 @@ impl From<bool> for Const {
     }
 }
 
-impl Display for Const {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+impl ToInternedString for Const {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         match *self {
-            Self::String(ref st) => write!(f, "\"{}\"", st),
-            Self::Num(num) => write!(f, "{}", num),
-            Self::Int(num) => write!(f, "{}", num),
-            Self::BigInt(ref num) => write!(f, "{}", num),
-            Self::Bool(v) => write!(f, "{}", v),
-            Self::Null => write!(f, "null"),
-            Self::Undefined => write!(f, "undefined"),
+            Self::String(st) => {
+                format!("\"{}\"", interner.resolve_expect(st))
+            }
+            Self::Num(num) => num.to_string(),
+            Self::Int(num) => num.to_string(),
+            Self::BigInt(ref num) => num.to_string(),
+            Self::Bool(v) => v.to_string(),
+            Self::Null => "null".to_owned(),
+            Self::Undefined => "undefined".to_owned(),
         }
     }
 }
diff --git a/boa/src/syntax/ast/keyword.rs b/boa/src/syntax/ast/keyword.rs
index 597a355ad0c..af7b6c086a9 100644
--- a/boa/src/syntax/ast/keyword.rs
+++ b/boa/src/syntax/ast/keyword.rs
@@ -8,6 +8,7 @@
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords
 
 use crate::syntax::ast::op::{BinOp, CompOp};
+use boa_interner::{Interner, Sym};
 use std::{convert::TryInto, error, fmt, str::FromStr};
 
 #[cfg(feature = "deser")]
@@ -536,6 +537,11 @@ impl Keyword {
             Self::Yield => "yield",
         }
     }
+
+    /// Converts the keyword to a symbol in the given interner.
+    pub fn to_sym(self, interner: &mut Interner) -> Sym {
+        interner.get_or_intern_static(self.as_str())
+    }
 }
 
 impl TryInto<BinOp> for Keyword {
diff --git a/boa/src/syntax/ast/node/array/mod.rs b/boa/src/syntax/ast/node/array/mod.rs
index 34d3d883505..1745e3fd267 100644
--- a/boa/src/syntax/ast/node/array/mod.rs
+++ b/boa/src/syntax/ast/node/array/mod.rs
@@ -2,7 +2,7 @@
 
 use super::{join_nodes, Node};
 use crate::gc::{Finalize, Trace};
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -48,11 +48,9 @@ where
     }
 }
 
-impl fmt::Display for ArrayDecl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("[")?;
-        join_nodes(f, &self.arr)?;
-        f.write_str("]")
+impl ToInternedString for ArrayDecl {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("[{}]", join_nodes(interner, &self.arr))
     }
 }
 
diff --git a/boa/src/syntax/ast/node/await_expr/mod.rs b/boa/src/syntax/ast/node/await_expr/mod.rs
index e2755483e61..0527ec0d407 100644
--- a/boa/src/syntax/ast/node/await_expr/mod.rs
+++ b/boa/src/syntax/ast/node/await_expr/mod.rs
@@ -1,8 +1,8 @@
 //! Await expression node.
 
 use super::Node;
-use gc::{Finalize, Trace};
-use std::fmt;
+use crate::gc::{Finalize, Trace};
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -34,10 +34,9 @@ where
     }
 }
 
-impl fmt::Display for AwaitExpr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "await ")?;
-        self.expr.display(f, 0)
+impl ToInternedString for AwaitExpr {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("await {}", self.expr.to_indented_string(interner, 0))
     }
 }
 
diff --git a/boa/src/syntax/ast/node/block/mod.rs b/boa/src/syntax/ast/node/block/mod.rs
index b5be4073c2e..498a0e13cd8 100644
--- a/boa/src/syntax/ast/node/block/mod.rs
+++ b/boa/src/syntax/ast/node/block/mod.rs
@@ -2,8 +2,9 @@
 
 use super::{Node, StatementList};
 use crate::gc::{Finalize, Trace};
-use std::{collections::HashSet, fmt};
+use boa_interner::{Interner, Sym, ToInternedString};
 
+use rustc_hash::FxHashSet;
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
 
@@ -39,19 +40,22 @@ impl Block {
         self.statements.items()
     }
 
-    pub(crate) fn lexically_declared_names(&self) -> HashSet<&str> {
-        self.statements.lexically_declared_names()
+    pub(crate) fn lexically_declared_names(&self, interner: &Interner) -> FxHashSet<Sym> {
+        self.statements.lexically_declared_names(interner)
     }
 
-    pub(crate) fn var_declared_named(&self) -> HashSet<&str> {
+    pub(crate) fn var_declared_named(&self) -> FxHashSet<Sym> {
         self.statements.var_declared_names()
     }
 
     /// Implements the display formatting with indentation.
-    pub(super) fn display(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
-        writeln!(f, "{{")?;
-        self.statements.display(f, indentation + 1)?;
-        write!(f, "{}}}", "    ".repeat(indentation))
+    pub(super) fn to_indented_string(&self, interner: &Interner, indentation: usize) -> String {
+        format!(
+            "{{\n{}{}}}",
+            self.statements
+                .to_indented_string(interner, indentation + 1),
+            "    ".repeat(indentation)
+        )
     }
 }
 
@@ -66,9 +70,9 @@ where
     }
 }
 
-impl fmt::Display for Block {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for Block {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/call/mod.rs b/boa/src/syntax/ast/node/call/mod.rs
index 3b40ea1d3aa..914648688a5 100644
--- a/boa/src/syntax/ast/node/call/mod.rs
+++ b/boa/src/syntax/ast/node/call/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, Node},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -55,11 +55,13 @@ impl Call {
     }
 }
 
-impl fmt::Display for Call {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}(", self.expr)?;
-        join_nodes(f, &self.args)?;
-        f.write_str(")")
+impl ToInternedString for Call {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
+            "{}({})",
+            self.expr.to_interned_string(interner),
+            join_nodes(interner, &self.args)
+        )
     }
 }
 
diff --git a/boa/src/syntax/ast/node/conditional/conditional_op/mod.rs b/boa/src/syntax/ast/node/conditional/conditional_op/mod.rs
index 14ad10372e0..3670fc80e40 100644
--- a/boa/src/syntax/ast/node/conditional/conditional_op/mod.rs
+++ b/boa/src/syntax/ast/node/conditional/conditional_op/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -57,14 +57,13 @@ impl ConditionalOp {
     }
 }
 
-impl fmt::Display for ConditionalOp {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
+impl ToInternedString for ConditionalOp {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
             "{} ? {} : {}",
-            self.cond(),
-            self.if_true(),
-            self.if_false()
+            self.cond().to_interned_string(interner),
+            self.if_true().to_interned_string(interner),
+            self.if_false().to_interned_string(interner)
         )
     }
 }
diff --git a/boa/src/syntax/ast/node/conditional/if_node/mod.rs b/boa/src/syntax/ast/node/conditional/if_node/mod.rs
index 955e2ce1b96..cab16100d2d 100644
--- a/boa/src/syntax/ast/node/conditional/if_node/mod.rs
+++ b/boa/src/syntax/ast/node/conditional/if_node/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -59,26 +59,31 @@ impl If {
         }
     }
 
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indent: usize,
-    ) -> fmt::Result {
-        write!(f, "if ({}) ", self.cond())?;
+    ) -> String {
+        let mut buf = format!("if ({}) ", self.cond().to_interned_string(interner));
         match self.else_node() {
             Some(else_e) => {
-                self.body().display(f, indent)?;
-                f.write_str(" else ")?;
-                else_e.display(f, indent)
+                buf.push_str(&format!(
+                    "{} else {}",
+                    self.body().to_indented_string(interner, indent),
+                    else_e.to_indented_string(interner, indent)
+                ));
+            }
+            None => {
+                buf.push_str(&self.body().to_indented_string(interner, indent));
             }
-            None => self.body().display(f, indent),
         }
+        buf
     }
 }
 
-impl fmt::Display for If {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for If {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/declaration/arrow_function_decl/mod.rs b/boa/src/syntax/ast/node/declaration/arrow_function_decl/mod.rs
index 775558cb2cf..fed5c4c7a68 100644
--- a/boa/src/syntax/ast/node/declaration/arrow_function_decl/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/arrow_function_decl/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -51,26 +51,28 @@ impl ArrowFunctionDecl {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        write!(f, "(")?;
-        join_nodes(f, &self.params)?;
+    ) -> String {
+        let mut buf = format!("({}", join_nodes(interner, &self.params));
         if self.body().items().is_empty() {
-            f.write_str(") => {}")
+            buf.push_str(") => {}");
         } else {
-            f.write_str(") => {\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
+            buf.push_str(&format!(
+                ") => {{\n{}{}}}",
+                self.body.to_indented_string(interner, indentation + 1),
+                "    ".repeat(indentation)
+            ));
         }
+        buf
     }
 }
 
-impl fmt::Display for ArrowFunctionDecl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for ArrowFunctionDecl {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/declaration/async_function_decl/mod.rs b/boa/src/syntax/ast/node/declaration/async_function_decl/mod.rs
index e23b3c8e98c..681f08b6b9d 100644
--- a/boa/src/syntax/ast/node/declaration/async_function_decl/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/async_function_decl/mod.rs
@@ -1,8 +1,10 @@
 //! Async Function Declaration.
 
-use crate::syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList};
-use gc::{Finalize, Trace};
-use std::fmt;
+use crate::{
+    gc::{Finalize, Trace},
+    syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
+};
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -18,29 +20,28 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct AsyncFunctionDecl {
-    name: Box<str>,
+    name: Sym,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
 
 impl AsyncFunctionDecl {
     /// Creates a new async function declaration.
-    pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
+    pub(in crate::syntax) fn new<P, B>(name: Sym, parameters: P, body: B) -> Self
     where
-        N: Into<Box<str>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
         Self {
-            name: name.into(),
+            name,
             parameters: parameters.into(),
             body: body.into(),
         }
     }
 
     /// Gets the name of the async function declaration.
-    pub fn name(&self) -> &str {
-        &self.name
+    pub fn name(&self) -> Sym {
+        self.name
     }
 
     /// Gets the list of parameters of the async function declaration.
@@ -54,20 +55,27 @@ impl AsyncFunctionDecl {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        write!(f, "async function {}(", self.name())?;
-        join_nodes(f, &self.parameters)?;
+    ) -> String {
+        let mut buf = format!(
+            "async function {}({}",
+            interner.resolve_expect(self.name),
+            join_nodes(interner, &self.parameters)
+        );
+
         if self.body().is_empty() {
-            f.write_str(") {}")
+            buf.push_str(") {}");
         } else {
-            f.write_str(") {\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
+            buf.push_str(&format!(
+                ") {{\n{}{}}}",
+                self.body.to_indented_string(interner, indentation + 1),
+                "    ".repeat(indentation)
+            ));
         }
+        buf
     }
 }
 
@@ -77,8 +85,8 @@ impl From<AsyncFunctionDecl> for Node {
     }
 }
 
-impl fmt::Display for AsyncFunctionDecl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for AsyncFunctionDecl {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
diff --git a/boa/src/syntax/ast/node/declaration/async_function_expr/mod.rs b/boa/src/syntax/ast/node/declaration/async_function_expr/mod.rs
index 9ca95185169..a74b9552d36 100644
--- a/boa/src/syntax/ast/node/declaration/async_function_expr/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/async_function_expr/mod.rs
@@ -1,8 +1,10 @@
 //! Async Function Expression.
 
-use crate::syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList};
-use gc::{Finalize, Trace};
-use std::fmt;
+use crate::{
+    gc::{Finalize, Trace},
+    syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
+};
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -19,7 +21,7 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct AsyncFunctionExpr {
-    name: Option<Box<str>>,
+    name: Option<Sym>,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
@@ -28,7 +30,7 @@ impl AsyncFunctionExpr {
     /// Creates a new function expression
     pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
     where
-        N: Into<Option<Box<str>>>,
+        N: Into<Option<Sym>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
@@ -40,8 +42,8 @@ impl AsyncFunctionExpr {
     }
 
     /// Gets the name of the function declaration.
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_ref().map(Box::as_ref)
+    pub fn name(&self) -> Option<Sym> {
+        self.name
     }
 
     /// Gets the list of parameters of the function declaration.
@@ -55,30 +57,32 @@ impl AsyncFunctionExpr {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        f.write_str("async function")?;
-        if let Some(ref name) = self.name {
-            write!(f, " {}", name)?;
+    ) -> String {
+        let mut buf = "async function".to_owned();
+        if let Some(name) = self.name {
+            buf.push_str(&format!(" {}", interner.resolve_expect(name)));
         }
-        f.write_str("(")?;
-        join_nodes(f, &self.parameters)?;
+        buf.push_str(&format!("({}", join_nodes(interner, &self.parameters)));
         if self.body().is_empty() {
-            f.write_str(") {}")
+            buf.push_str(") {}");
         } else {
-            f.write_str(") {\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
+            buf.push_str(&format!(
+                ") {{\n{}{}}}",
+                self.body.to_indented_string(interner, indentation + 1),
+                "    ".repeat(indentation)
+            ));
         }
+        buf
     }
 }
 
-impl fmt::Display for AsyncFunctionExpr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for AsyncFunctionExpr {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/declaration/async_generator_decl/mod.rs b/boa/src/syntax/ast/node/declaration/async_generator_decl/mod.rs
index e49456a3212..6ab7f9ab918 100644
--- a/boa/src/syntax/ast/node/declaration/async_generator_decl/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/async_generator_decl/mod.rs
@@ -1,8 +1,10 @@
 //! Async Generator Declaration
 
-use crate::syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList};
-use gc::{Finalize, Trace};
-use std::fmt;
+use crate::{
+    gc::{Finalize, Trace},
+    syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
+};
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -16,29 +18,28 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct AsyncGeneratorDecl {
-    name: Box<str>,
+    name: Sym,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
 
 impl AsyncGeneratorDecl {
     /// Creates a new async generator declaration.
-    pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
+    pub(in crate::syntax) fn new<P, B>(name: Sym, parameters: P, body: B) -> Self
     where
-        N: Into<Box<str>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
         Self {
-            name: name.into(),
+            name,
             parameters: parameters.into(),
             body: body.into(),
         }
     }
 
     /// Gets the name of the async function declaration.
-    pub fn name(&self) -> &str {
-        &self.name
+    pub fn name(&self) -> Sym {
+        self.name
     }
 
     /// Gets the list of parameters of the async function declaration.
@@ -52,20 +53,26 @@ impl AsyncGeneratorDecl {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        write!(f, "async function* {}(", self.name())?;
-        join_nodes(f, &self.parameters)?;
+    ) -> String {
+        let mut buf = format!(
+            "async function* {}({}",
+            interner.resolve_expect(self.name),
+            join_nodes(interner, &self.parameters)
+        );
         if self.body().is_empty() {
-            f.write_str(") {}")
+            buf.push_str(") {}");
         } else {
-            f.write_str(") {\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
+            buf.push_str(&format!(
+                ") {{\n{}{}}}",
+                self.body.to_indented_string(interner, indentation + 1),
+                "    ".repeat(indentation)
+            ));
         }
+        buf
     }
 }
 
@@ -75,8 +82,8 @@ impl From<AsyncGeneratorDecl> for Node {
     }
 }
 
-impl fmt::Display for AsyncGeneratorDecl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for AsyncGeneratorDecl {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
diff --git a/boa/src/syntax/ast/node/declaration/async_generator_expr/mod.rs b/boa/src/syntax/ast/node/declaration/async_generator_expr/mod.rs
index e7825d899ce..c2812218076 100644
--- a/boa/src/syntax/ast/node/declaration/async_generator_expr/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/async_generator_expr/mod.rs
@@ -4,11 +4,13 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
 
+use super::block_to_string;
+
 /// The `async function*` keyword can be used to define a generator function inside an expression.
 ///
 /// More information:
@@ -18,7 +20,7 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct AsyncGeneratorExpr {
-    name: Option<Box<str>>,
+    name: Option<Sym>,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
@@ -27,7 +29,7 @@ impl AsyncGeneratorExpr {
     /// Creates a new async generator expression
     pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
     where
-        N: Into<Option<Box<str>>>,
+        N: Into<Option<Sym>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
@@ -39,8 +41,8 @@ impl AsyncGeneratorExpr {
     }
 
     /// Gets the name of the async generator expression
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_ref().map(Box::as_ref)
+    pub fn name(&self) -> Option<Sym> {
+        self.name
     }
 
     /// Gets the list of parameters of the async generator expression
@@ -53,39 +55,28 @@ impl AsyncGeneratorExpr {
         &self.body
     }
 
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        f.write_str("async function*")?;
-        if let Some(ref name) = self.name {
-            write!(f, " {}", name)?;
+    ) -> String {
+        let mut buf = "async function*".to_owned();
+        if let Some(name) = self.name {
+            buf.push_str(&format!(" {}", interner.resolve_expect(name)));
         }
-        f.write_str("(")?;
-        join_nodes(f, &self.parameters)?;
-        f.write_str(") ")?;
-        self.display_block(f, indentation)
-    }
+        buf.push_str(&format!(
+            "({}) {}",
+            join_nodes(interner, &self.parameters),
+            block_to_string(&self.body, interner, indentation)
+        ));
 
-    pub(in crate::syntax::ast::node) fn display_block(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        indentation: usize,
-    ) -> fmt::Result {
-        if self.body().items().is_empty() {
-            f.write_str("{}")
-        } else {
-            f.write_str("{\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
-        }
+        buf
     }
 }
 
-impl fmt::Display for AsyncGeneratorExpr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for AsyncGeneratorExpr {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/declaration/function_decl/mod.rs b/boa/src/syntax/ast/node/declaration/function_decl/mod.rs
index 952ae8cb486..be55fe5937c 100644
--- a/boa/src/syntax/ast/node/declaration/function_decl/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/function_decl/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -28,29 +28,28 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct FunctionDecl {
-    name: Box<str>,
+    name: Sym,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
 
 impl FunctionDecl {
     /// Creates a new function declaration.
-    pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
+    pub(in crate::syntax) fn new<P, B>(name: Sym, parameters: P, body: B) -> Self
     where
-        N: Into<Box<str>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
         Self {
-            name: name.into(),
+            name,
             parameters: parameters.into(),
             body: body.into(),
         }
     }
 
     /// Gets the name of the function declaration.
-    pub fn name(&self) -> &str {
-        &self.name
+    pub fn name(&self) -> Sym {
+        self.name
     }
 
     /// Gets the list of parameters of the function declaration.
@@ -64,20 +63,27 @@ impl FunctionDecl {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        write!(f, "function {}(", self.name)?;
-        join_nodes(f, &self.parameters)?;
+    ) -> String {
+        let mut buf = format!(
+            "function {}({}",
+            interner.resolve_expect(self.name),
+            join_nodes(interner, &self.parameters)
+        );
         if self.body().items().is_empty() {
-            f.write_str(") {}")
+            buf.push_str(") {}");
         } else {
-            f.write_str(") {\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
+            buf.push_str(&format!(
+                ") {{\n{}{}}}",
+                self.body.to_indented_string(interner, indentation + 1),
+                "    ".repeat(indentation)
+            ));
         }
+
+        buf
     }
 }
 
@@ -87,8 +93,8 @@ impl From<FunctionDecl> for Node {
     }
 }
 
-impl fmt::Display for FunctionDecl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for FunctionDecl {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
diff --git a/boa/src/syntax/ast/node/declaration/function_expr/mod.rs b/boa/src/syntax/ast/node/declaration/function_expr/mod.rs
index eaeb2056e68..2a9e3fc01a3 100644
--- a/boa/src/syntax/ast/node/declaration/function_expr/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/function_expr/mod.rs
@@ -2,11 +2,13 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
 
+use super::block_to_string;
+
 /// The `function` expression defines a function with the specified parameters.
 ///
 /// A function created with a function expression is a `Function` object and has all the
@@ -26,7 +28,7 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct FunctionExpr {
-    name: Option<Box<str>>,
+    name: Option<Sym>,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
@@ -35,7 +37,7 @@ impl FunctionExpr {
     /// Creates a new function expression
     pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
     where
-        N: Into<Option<Box<str>>>,
+        N: Into<Option<Sym>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
@@ -47,8 +49,8 @@ impl FunctionExpr {
     }
 
     /// Gets the name of the function declaration.
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_ref().map(Box::as_ref)
+    pub fn name(&self) -> Option<Sym> {
+        self.name
     }
 
     /// Gets the list of parameters of the function declaration.
@@ -62,41 +64,28 @@ impl FunctionExpr {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        f.write_str("function")?;
-        if let Some(ref name) = self.name {
-            write!(f, " {}", name)?;
+    ) -> String {
+        let mut buf = "function".to_owned();
+        if let Some(name) = self.name {
+            buf.push_str(&format!(" {}", interner.resolve_expect(name)));
         }
-        f.write_str("(")?;
-        join_nodes(f, &self.parameters)?;
-        f.write_str(") ")?;
-        self.display_block(f, indentation)
-    }
+        buf.push_str(&format!(
+            "({}) {}",
+            join_nodes(interner, &self.parameters),
+            block_to_string(&self.body, interner, indentation)
+        ));
 
-    /// Displays the function's body. This includes the curly braces at the start and end.
-    /// This will not indent the first brace, but will indent the last brace.
-    pub(in crate::syntax::ast::node) fn display_block(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        indentation: usize,
-    ) -> fmt::Result {
-        if self.body().items().is_empty() {
-            f.write_str("{}")
-        } else {
-            f.write_str("{\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
-        }
+        buf
     }
 }
 
-impl fmt::Display for FunctionExpr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for FunctionExpr {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/declaration/generator_decl/mod.rs b/boa/src/syntax/ast/node/declaration/generator_decl/mod.rs
index ef4fe8bc2b7..0b69f6ada44 100644
--- a/boa/src/syntax/ast/node/declaration/generator_decl/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/generator_decl/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -19,29 +19,28 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct GeneratorDecl {
-    name: Box<str>,
+    name: Sym,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
 
 impl GeneratorDecl {
     /// Creates a new generator declaration.
-    pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
+    pub(in crate::syntax) fn new<P, B>(name: Sym, parameters: P, body: B) -> Self
     where
-        N: Into<Box<str>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
         Self {
-            name: name.into(),
+            name,
             parameters: parameters.into(),
             body: body.into(),
         }
     }
 
     /// Gets the name of the generator declaration.
-    pub fn name(&self) -> &str {
-        &self.name
+    pub fn name(&self) -> Sym {
+        self.name
     }
 
     /// Gets the list of parameters of the generator declaration.
@@ -55,20 +54,27 @@ impl GeneratorDecl {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        write!(f, "function* {}(", self.name)?;
-        join_nodes(f, &self.parameters)?;
+    ) -> String {
+        let mut buf = format!(
+            "function* {}({}",
+            interner.resolve_expect(self.name),
+            join_nodes(interner, &self.parameters)
+        );
         if self.body().is_empty() {
-            f.write_str(") {}")
+            buf.push_str(") {}");
         } else {
-            f.write_str(") {\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
+            buf.push_str(&format!(
+                ") {{\n{}{}}}",
+                self.body.to_indented_string(interner, indentation + 1),
+                "    ".repeat(indentation)
+            ));
         }
+
+        buf
     }
 }
 
@@ -78,8 +84,8 @@ impl From<GeneratorDecl> for Node {
     }
 }
 
-impl fmt::Display for GeneratorDecl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for GeneratorDecl {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
diff --git a/boa/src/syntax/ast/node/declaration/generator_expr/mod.rs b/boa/src/syntax/ast/node/declaration/generator_expr/mod.rs
index 1f555801d29..42a2b0224dd 100644
--- a/boa/src/syntax/ast/node/declaration/generator_expr/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/generator_expr/mod.rs
@@ -2,11 +2,13 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, FormalParameter, Node, StatementList},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
 
+use super::block_to_string;
+
 /// The `function*` keyword can be used to define a generator function inside an expression.
 ///
 /// More information:
@@ -18,7 +20,7 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct GeneratorExpr {
-    name: Option<Box<str>>,
+    name: Option<Sym>,
     parameters: Box<[FormalParameter]>,
     body: StatementList,
 }
@@ -27,7 +29,7 @@ impl GeneratorExpr {
     /// Creates a new generator expression
     pub(in crate::syntax) fn new<N, P, B>(name: N, parameters: P, body: B) -> Self
     where
-        N: Into<Option<Box<str>>>,
+        N: Into<Option<Sym>>,
         P: Into<Box<[FormalParameter]>>,
         B: Into<StatementList>,
     {
@@ -39,8 +41,8 @@ impl GeneratorExpr {
     }
 
     /// Gets the name of the generator declaration.
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_ref().map(Box::as_ref)
+    pub fn name(&self) -> Option<Sym> {
+        self.name
     }
 
     /// Gets the list of parameters of the generator declaration.
@@ -53,42 +55,29 @@ impl GeneratorExpr {
         &self.body
     }
 
-    /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    /// Converts the generator expresion node to a string with indentation.
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        f.write_str("function*")?;
-        if let Some(ref name) = self.name {
-            write!(f, " {}", name)?;
+    ) -> String {
+        let mut buf = "function*".to_owned();
+        if let Some(name) = self.name {
+            buf.push_str(&format!(" {}", interner.resolve_expect(name)));
         }
-        f.write_str("(")?;
-        join_nodes(f, &self.parameters)?;
-        f.write_str(") ")?;
-        self.display_block(f, indentation)
-    }
+        buf.push_str(&format!(
+            "({}) {}",
+            join_nodes(interner, &self.parameters),
+            block_to_string(&self.body, interner, indentation)
+        ));
 
-    /// Displays the generator's body. This includes the curly braces at the start and end.
-    /// This will not indent the first brace, but will indent the last brace.
-    pub(in crate::syntax::ast::node) fn display_block(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        indentation: usize,
-    ) -> fmt::Result {
-        if self.body().items().is_empty() {
-            f.write_str("{}")
-        } else {
-            f.write_str("{\n")?;
-            self.body.display(f, indentation + 1)?;
-            write!(f, "{}}}", "    ".repeat(indentation))
-        }
+        buf
     }
 }
 
-impl fmt::Display for GeneratorExpr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for GeneratorExpr {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/declaration/mod.rs b/boa/src/syntax/ast/node/declaration/mod.rs
index 73350fd4efa..2d4aca44c2d 100644
--- a/boa/src/syntax/ast/node/declaration/mod.rs
+++ b/boa/src/syntax/ast/node/declaration/mod.rs
@@ -3,7 +3,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{join_nodes, Identifier, Node},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -25,6 +25,8 @@ pub use self::{
     function_expr::FunctionExpr,
 };
 
+use super::StatementList;
+
 #[cfg(test)]
 mod tests;
 
@@ -100,18 +102,21 @@ impl AsRef<[Declaration]> for DeclarationList {
     }
 }
 
-impl fmt::Display for DeclarationList {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for DeclarationList {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         if !self.as_ref().is_empty() {
             use DeclarationList::*;
-            match &self {
-                Let(_) => write!(f, "let ")?,
-                Const(_) => write!(f, "const ")?,
-                Var(_) => write!(f, "var ")?,
-            }
-            join_nodes(f, self.as_ref())
+            format!(
+                "{} {}",
+                match &self {
+                    Let(_) => "let",
+                    Const(_) => "const",
+                    Var(_) => "var",
+                },
+                join_nodes(interner, self.as_ref())
+            )
         } else {
-            Ok(())
+            String::new()
         }
     }
 }
@@ -155,20 +160,18 @@ pub enum Declaration {
     Pattern(DeclarationPattern),
 }
 
-impl fmt::Display for Declaration {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for Declaration {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         match &self {
             Self::Identifier { ident, init } => {
-                fmt::Display::fmt(&ident, f)?;
+                let mut buf = ident.to_interned_string(interner);
                 if let Some(ref init) = &init {
-                    write!(f, " = {}", init)?;
+                    buf.push_str(&format!(" = {}", init.to_interned_string(interner)));
                 }
+                buf
             }
-            Self::Pattern(pattern) => {
-                fmt::Display::fmt(&pattern, f)?;
-            }
+            Self::Pattern(pattern) => pattern.to_interned_string(interner),
         }
-        Ok(())
     }
 }
 
@@ -241,17 +244,12 @@ pub enum DeclarationPattern {
     Array(DeclarationPatternArray),
 }
 
-impl fmt::Display for DeclarationPattern {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for DeclarationPattern {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         match &self {
-            DeclarationPattern::Object(o) => {
-                fmt::Display::fmt(o, f)?;
-            }
-            DeclarationPattern::Array(a) => {
-                fmt::Display::fmt(a, f)?;
-            }
+            DeclarationPattern::Object(o) => o.to_interned_string(interner),
+            DeclarationPattern::Array(a) => a.to_interned_string(interner),
         }
-        Ok(())
     }
 }
 
@@ -260,7 +258,7 @@ impl DeclarationPattern {
     ///
     /// A single binding pattern may declare 0 to n identifiers.
     #[inline]
-    pub fn idents(&self) -> Vec<&str> {
+    pub fn idents(&self) -> Vec<Sym> {
         match &self {
             DeclarationPattern::Object(pattern) => pattern.idents(),
             DeclarationPattern::Array(pattern) => pattern.idents(),
@@ -292,21 +290,24 @@ pub struct DeclarationPatternObject {
     init: Option<Node>,
 }
 
-impl fmt::Display for DeclarationPatternObject {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt("{", f)?;
+impl ToInternedString for DeclarationPatternObject {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let mut buf = "{".to_owned();
         for (i, binding) in self.bindings.iter().enumerate() {
-            if i == self.bindings.len() - 1 {
-                write!(f, "{} ", binding)?;
+            let binding = binding.to_interned_string(interner);
+            let str = if i == self.bindings.len() - 1 {
+                format!("{} ", binding)
             } else {
-                write!(f, "{},", binding)?;
-            }
+                format!("{},", binding)
+            };
+
+            buf.push_str(&str);
         }
-        fmt::Display::fmt("}", f)?;
+        buf.push('}');
         if let Some(ref init) = self.init {
-            write!(f, " = {}", init)?;
+            buf.push_str(&format!(" = {}", init.to_interned_string(interner)));
         }
-        Ok(())
+        buf
     }
 }
 
@@ -334,7 +335,7 @@ impl DeclarationPatternObject {
 
     /// Gets the list of identifiers declared by the object binding pattern.
     #[inline]
-    pub(crate) fn idents(&self) -> Vec<&str> {
+    pub(crate) fn idents(&self) -> Vec<Sym> {
         let mut idents = Vec::new();
 
         for binding in &self.bindings {
@@ -347,13 +348,13 @@ impl DeclarationPatternObject {
                     property_name: _,
                     default_init: _,
                 } => {
-                    idents.push(ident.as_ref());
+                    idents.push(*ident);
                 }
                 RestProperty {
                     ident: property_name,
                     excluded_keys: _,
                 } => {
-                    idents.push(property_name.as_ref());
+                    idents.push(*property_name);
                 }
                 BindingPattern {
                     ident: _,
@@ -386,24 +387,26 @@ pub struct DeclarationPatternArray {
     init: Option<Node>,
 }
 
-impl fmt::Display for DeclarationPatternArray {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt("[", f)?;
+impl ToInternedString for DeclarationPatternArray {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let mut buf = "[".to_owned();
         for (i, binding) in self.bindings.iter().enumerate() {
             if i == self.bindings.len() - 1 {
                 match binding {
-                    BindingPatternTypeArray::Elision => write!(f, "{}, ", binding)?,
-                    _ => write!(f, "{} ", binding)?,
+                    BindingPatternTypeArray::Elision => {
+                        buf.push_str(&format!("{}, ", binding.to_interned_string(interner)))
+                    }
+                    _ => buf.push_str(&format!("{} ", binding.to_interned_string(interner))),
                 }
             } else {
-                write!(f, "{},", binding)?;
+                buf.push_str(&format!("{},", binding.to_interned_string(interner)));
             }
         }
-        fmt::Display::fmt("]", f)?;
+        buf.push(']');
         if let Some(ref init) = self.init {
-            write!(f, " = {}", init)?;
+            buf.push_str(&format!(" = {}", init.to_interned_string(interner)));
         }
-        Ok(())
+        buf
     }
 }
 
@@ -431,7 +434,7 @@ impl DeclarationPatternArray {
 
     /// Gets the list of identifiers declared by the array binding pattern.
     #[inline]
-    pub(crate) fn idents(&self) -> Vec<&str> {
+    pub(crate) fn idents(&self) -> Vec<Sym> {
         let mut idents = Vec::new();
 
         for binding in &self.bindings {
@@ -444,13 +447,13 @@ impl DeclarationPatternArray {
                     ident,
                     default_init: _,
                 } => {
-                    idents.push(ident.as_ref());
+                    idents.push(*ident);
                 }
                 BindingPattern { pattern } | BindingPatternRest { pattern } => {
                     let mut i = pattern.idents();
                     idents.append(&mut i)
                 }
-                SingleNameRest { ident } => idents.push(ident),
+                SingleNameRest { ident } => idents.push(*ident),
             }
         }
 
@@ -482,8 +485,8 @@ pub enum BindingPatternTypeObject {
     /// [spec1]: https://tc39.es/ecma262/#prod-SingleNameBinding
     /// [spec2]: https://tc39.es/ecma262/#prod-BindingProperty
     SingleName {
-        ident: Box<str>,
-        property_name: Box<str>,
+        ident: Sym,
+        property_name: Sym,
         default_init: Option<Node>,
     },
 
@@ -496,10 +499,7 @@ pub enum BindingPatternTypeObject {
     ///  - [ECMAScript reference: 14.3.3 Destructuring Binding Patterns - BindingRestProperty][spec1]
     ///
     /// [spec1]: https://tc39.es/ecma262/#prod-BindingRestProperty
-    RestProperty {
-        ident: Box<str>,
-        excluded_keys: Vec<Box<str>>,
-    },
+    RestProperty { ident: Sym, excluded_keys: Vec<Sym> },
 
     /// BindingPattern represents a `BindingProperty` with a `BindingPattern` as the `BindingElement`.
     ///
@@ -511,48 +511,57 @@ pub enum BindingPatternTypeObject {
     ///
     /// [spec1]: https://tc39.es/ecma262/#prod-BindingProperty
     BindingPattern {
-        ident: Box<str>,
+        ident: Sym,
         pattern: DeclarationPattern,
         default_init: Option<Node>,
     },
 }
 
-impl fmt::Display for BindingPatternTypeObject {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self {
-            BindingPatternTypeObject::Empty => {}
+impl ToInternedString for BindingPatternTypeObject {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        match self {
+            BindingPatternTypeObject::Empty => String::new(),
             BindingPatternTypeObject::SingleName {
                 ident,
                 property_name,
                 default_init,
             } => {
-                if ident == property_name {
-                    write!(f, " {}", ident)?;
+                let mut buf = if ident == property_name {
+                    format!(" {}", interner.resolve_expect(*ident))
                 } else {
-                    write!(f, " {} : {}", property_name, ident)?;
-                }
+                    format!(
+                        " {} : {}",
+                        interner.resolve_expect(*property_name),
+                        interner.resolve_expect(*ident)
+                    )
+                };
                 if let Some(ref init) = default_init {
-                    write!(f, " = {}", init)?;
+                    buf.push_str(&format!(" = {}", init.to_interned_string(interner)));
                 }
+                buf
             }
             BindingPatternTypeObject::RestProperty {
                 ident: property_name,
                 excluded_keys: _,
             } => {
-                write!(f, " ... {}", property_name)?;
+                format!(" ... {}", interner.resolve_expect(*property_name))
             }
             BindingPatternTypeObject::BindingPattern {
                 ident: property_name,
                 pattern,
                 default_init,
             } => {
-                write!(f, " {} : {}", property_name, pattern)?;
+                let mut buf = format!(
+                    " {} : {}",
+                    interner.resolve_expect(*property_name),
+                    pattern.to_interned_string(interner)
+                );
                 if let Some(ref init) = default_init {
-                    write!(f, " = {}", init)?;
+                    buf.push_str(&format!(" = {}", init.to_interned_string(interner)));
                 }
+                buf
             }
         }
-        Ok(())
     }
 }
 
@@ -594,7 +603,7 @@ pub enum BindingPatternTypeArray {
     ///
     /// [spec1]: https://tc39.es/ecma262/#prod-SingleNameBinding
     SingleName {
-        ident: Box<str>,
+        ident: Sym,
         default_init: Option<Node>,
     },
 
@@ -614,7 +623,7 @@ pub enum BindingPatternTypeArray {
     ///  - [ECMAScript reference: 14.3.3 Destructuring Binding Patterns - BindingRestElement][spec1]
     ///
     /// [spec1]: https://tc39.es/ecma262/#prod-BindingRestElement
-    SingleNameRest { ident: Box<str> },
+    SingleNameRest { ident: Sym },
 
     /// SingleNameRest represents a `BindingPattern` in a `BindingRestElement` of an array binding pattern.
     ///
@@ -625,32 +634,50 @@ pub enum BindingPatternTypeArray {
     BindingPatternRest { pattern: DeclarationPattern },
 }
 
-impl fmt::Display for BindingPatternTypeArray {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self {
-            BindingPatternTypeArray::Empty => {}
-            BindingPatternTypeArray::Elision => {
-                fmt::Display::fmt(" ", f)?;
-            }
+impl ToInternedString for BindingPatternTypeArray {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        match self {
+            BindingPatternTypeArray::Empty => String::new(),
+            BindingPatternTypeArray::Elision => " ".to_owned(),
             BindingPatternTypeArray::SingleName {
                 ident,
                 default_init,
             } => {
-                write!(f, " {}", ident)?;
+                let mut buf = format!(" {}", interner.resolve_expect(*ident));
                 if let Some(ref init) = default_init {
-                    write!(f, " = {}", init)?;
+                    buf.push_str(&format!(" = {}", init.to_interned_string(interner)));
                 }
+                buf
             }
             BindingPatternTypeArray::BindingPattern { pattern } => {
-                write!(f, " {}", pattern)?;
+                format!(" {}", pattern.to_interned_string(interner))
             }
             BindingPatternTypeArray::SingleNameRest { ident } => {
-                write!(f, " ... {}", ident)?;
+                format!(" ... {}", interner.resolve_expect(*ident))
             }
             BindingPatternTypeArray::BindingPatternRest { pattern } => {
-                write!(f, " ... {}", pattern)?;
+                format!(" ... {}", pattern.to_interned_string(interner))
             }
         }
-        Ok(())
+    }
+}
+
+/// Displays the body of a block or statement list.
+///
+/// This includes the curly braces at the start and end. This will not indent the first brace,
+/// but will indent the last brace.
+pub(in crate::syntax::ast::node) fn block_to_string(
+    body: &StatementList,
+    interner: &Interner,
+    indentation: usize,
+) -> String {
+    if body.items().is_empty() {
+        "{}".to_owned()
+    } else {
+        format!(
+            "{{\n{}{}}}",
+            body.to_indented_string(interner, indentation + 1),
+            "    ".repeat(indentation)
+        )
     }
 }
diff --git a/boa/src/syntax/ast/node/field/get_const_field/mod.rs b/boa/src/syntax/ast/node/field/get_const_field/mod.rs
index 54e44a0252d..d5b56e34b95 100644
--- a/boa/src/syntax/ast/node/field/get_const_field/mod.rs
+++ b/boa/src/syntax/ast/node/field/get_const_field/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -32,19 +32,18 @@ use serde::{Deserialize, Serialize};
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct GetConstField {
     obj: Box<Node>,
-    field: Box<str>,
+    field: Sym,
 }
 
 impl GetConstField {
     /// Creates a `GetConstField` AST node.
-    pub fn new<V, L>(value: V, label: L) -> Self
+    pub fn new<V>(value: V, field: Sym) -> Self
     where
         V: Into<Node>,
-        L: Into<Box<str>>,
     {
         Self {
             obj: Box::new(value.into()),
-            field: label.into(),
+            field,
         }
     }
 
@@ -54,14 +53,18 @@ impl GetConstField {
     }
 
     /// Gets the name of the field to retrieve.
-    pub fn field(&self) -> &str {
-        &self.field
+    pub fn field(&self) -> Sym {
+        self.field
     }
 }
 
-impl fmt::Display for GetConstField {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}.{}", self.obj(), self.field())
+impl ToInternedString for GetConstField {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
+            "{}.{}",
+            self.obj.to_interned_string(interner),
+            interner.resolve_expect(self.field)
+        )
     }
 }
 
diff --git a/boa/src/syntax/ast/node/field/get_field/mod.rs b/boa/src/syntax/ast/node/field/get_field/mod.rs
index 8ce069378c2..7534ebb4909 100644
--- a/boa/src/syntax/ast/node/field/get_field/mod.rs
+++ b/boa/src/syntax/ast/node/field/get_field/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -58,9 +58,13 @@ impl GetField {
     }
 }
 
-impl fmt::Display for GetField {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}[{}]", self.obj(), self.field())
+impl ToInternedString for GetField {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
+            "{}[{}]",
+            self.obj.to_interned_string(interner),
+            self.field.to_interned_string(interner)
+        )
     }
 }
 
diff --git a/boa/src/syntax/ast/node/identifier/mod.rs b/boa/src/syntax/ast/node/identifier/mod.rs
index 37cd58a26e4..0d9e2b7b212 100644
--- a/boa/src/syntax/ast/node/identifier/mod.rs
+++ b/boa/src/syntax/ast/node/identifier/mod.rs
@@ -1,10 +1,10 @@
 //! Local identifier node.
 
 use crate::{
-    gc::{Finalize, Trace},
+    gc::{empty_trace, Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -26,29 +26,36 @@ use serde::{Deserialize, Serialize};
 /// [mdn]: https://developer.mozilla.org/en-US/docs/Glossary/Identifier
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "deser", serde(transparent))]
-#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
+#[derive(Debug, Clone, Copy, Finalize, PartialEq)]
 pub struct Identifier {
-    ident: Box<str>,
+    ident: Sym,
 }
 
-impl fmt::Display for Identifier {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.ident, f)
+impl Identifier {
+    /// Creates a new identifier AST node.
+    pub fn new(ident: Sym) -> Self {
+        Self { ident }
+    }
+
+    /// Retrieves the identifier's string symbol in the interner.
+    pub fn sym(self) -> Sym {
+        self.ident
     }
 }
 
-impl AsRef<str> for Identifier {
-    fn as_ref(&self) -> &str {
-        &self.ident
+impl ToInternedString for Identifier {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        interner.resolve_expect(self.ident).to_owned()
     }
 }
 
-impl<T> From<T> for Identifier
-where
-    T: Into<Box<str>>,
-{
-    fn from(stm: T) -> Self {
-        Self { ident: stm.into() }
+unsafe impl Trace for Identifier {
+    empty_trace!();
+}
+
+impl From<Sym> for Identifier {
+    fn from(sym: Sym) -> Self {
+        Self { ident: sym }
     }
 }
 
diff --git a/boa/src/syntax/ast/node/break_node/mod.rs b/boa/src/syntax/ast/node/iteration/break_node/mod.rs
similarity index 66%
rename from boa/src/syntax/ast/node/break_node/mod.rs
rename to boa/src/syntax/ast/node/iteration/break_node/mod.rs
index ade6c36be16..2789649899c 100644
--- a/boa/src/syntax/ast/node/break_node/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/break_node/mod.rs
@@ -1,6 +1,8 @@
-use super::Node;
-use crate::gc::{Finalize, Trace};
-use std::fmt;
+use crate::{
+    gc::{empty_trace, Finalize, Trace},
+    syntax::ast::Node,
+};
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -23,36 +25,38 @@ mod tests;
 /// [spec]: https://tc39.es/ecma262/#prod-BreakStatement
 /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/break
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
+#[derive(Debug, Clone, Copy, Finalize, PartialEq)]
 pub struct Break {
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl Break {
     /// Creates a `Break` AST node.
-    pub fn new<OL, L>(label: OL) -> Self
+    pub fn new<L>(label: L) -> Self
     where
-        L: Into<Box<str>>,
-        OL: Into<Option<L>>,
+        L: Into<Option<Sym>>,
     {
         Self {
-            label: label.into().map(L::into),
+            label: label.into(),
         }
     }
 
     /// Gets the label of the break statement, if any.
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 }
 
-impl fmt::Display for Break {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
+unsafe impl Trace for Break {
+    empty_trace!();
+}
+
+impl ToInternedString for Break {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
             "break{}",
-            if self.label().is_some() {
-                format!(" {}", self.label().as_ref().unwrap())
+            if let Some(label) = self.label {
+                format!(" {}", interner.resolve_expect(label))
             } else {
                 String::new()
             }
diff --git a/boa/src/syntax/ast/node/break_node/tests.rs b/boa/src/syntax/ast/node/iteration/break_node/tests.rs
similarity index 89%
rename from boa/src/syntax/ast/node/break_node/tests.rs
rename to boa/src/syntax/ast/node/iteration/break_node/tests.rs
index 80e7ddfd795..ac9335d95f5 100644
--- a/boa/src/syntax/ast/node/break_node/tests.rs
+++ b/boa/src/syntax/ast/node/iteration/break_node/tests.rs
@@ -1,3 +1,5 @@
+use crate::syntax::ast::node::test_formatting;
+
 #[test]
 fn fmt() {
     // Blocks do not store their label, so we cannot test with
@@ -14,7 +16,7 @@ fn fmt() {
     //     skipped_call();
     // }
     // ```
-    super::super::test_formatting(
+    test_formatting(
         r#"
         {
             while (true) {
diff --git a/boa/src/syntax/ast/node/iteration/continue_node/mod.rs b/boa/src/syntax/ast/node/iteration/continue_node/mod.rs
index 013f6358158..ff33ad2dcd6 100644
--- a/boa/src/syntax/ast/node/iteration/continue_node/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/continue_node/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -23,33 +23,32 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct Continue {
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl Continue {
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
-    }
-
     /// Creates a `Continue` AST node.
-    pub fn new<OL, L>(label: OL) -> Self
+    pub fn new<L>(label: L) -> Self
     where
-        L: Into<Box<str>>,
-        OL: Into<Option<L>>,
+        L: Into<Option<Sym>>,
     {
         Self {
-            label: label.into().map(L::into),
+            label: label.into(),
         }
     }
+
+    pub fn label(&self) -> Option<Sym> {
+        self.label
+    }
 }
 
-impl fmt::Display for Continue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "continue")?;
-        if let Some(label) = self.label() {
-            write!(f, " {}", label)?;
+impl ToInternedString for Continue {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let mut buf = "continue".to_owned();
+        if let Some(label) = self.label {
+            buf.push_str(&format!(" {}", interner.resolve_expect(label)));
         }
-        Ok(())
+        buf
     }
 }
 
diff --git a/boa/src/syntax/ast/node/iteration/do_while_loop/mod.rs b/boa/src/syntax/ast/node/iteration/do_while_loop/mod.rs
index d324a04f38e..de20c10d6e1 100644
--- a/boa/src/syntax/ast/node/iteration/do_while_loop/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/do_while_loop/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -24,7 +24,7 @@ use serde::{Deserialize, Serialize};
 pub struct DoWhileLoop {
     body: Box<Node>,
     cond: Box<Node>,
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl DoWhileLoop {
@@ -36,11 +36,11 @@ impl DoWhileLoop {
         &self.cond
     }
 
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 
-    pub fn set_label(&mut self, label: Box<str>) {
+    pub fn set_label(&mut self, label: Sym) {
         self.label = Some(label);
     }
 
@@ -57,23 +57,30 @@ impl DoWhileLoop {
         }
     }
 
-    pub(in crate::syntax::ast::node) fn display(
+    /// Converts the "do while" loop to a string with the given indentation.
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        if let Some(ref label) = self.label {
-            write!(f, "{}: ", label)?;
-        }
-        write!(f, "do ")?;
-        self.body().display(f, indentation)?;
-        write!(f, " while ({})", self.cond())
+    ) -> String {
+        let mut buf = if let Some(label) = self.label {
+            format!("{}: ", interner.resolve_expect(label))
+        } else {
+            String::new()
+        };
+        buf.push_str(&format!(
+            "do {} while ({})",
+            self.body().to_indented_string(interner, indentation),
+            self.cond().to_interned_string(interner)
+        ));
+
+        buf
     }
 }
 
-impl fmt::Display for DoWhileLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for DoWhileLoop {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/iteration/for_in_loop/mod.rs b/boa/src/syntax/ast/node/iteration/for_in_loop/mod.rs
index f8beefbb621..a3f7b71464d 100644
--- a/boa/src/syntax/ast/node/iteration/for_in_loop/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/for_in_loop/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{iteration::IterableLoopInitializer, Node},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -13,7 +13,7 @@ pub struct ForInLoop {
     init: Box<IterableLoopInitializer>,
     expr: Box<Node>,
     body: Box<Node>,
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl ForInLoop {
@@ -42,26 +42,39 @@ impl ForInLoop {
         &self.body
     }
 
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 
-    pub fn set_label(&mut self, label: Box<str>) {
+    pub fn set_label(&mut self, label: Sym) {
         self.label = Some(label);
     }
 
-    pub fn display(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
-        if let Some(ref label) = self.label {
-            write!(f, "{}: ", label)?;
-        }
-        write!(f, "for ({} in {}) ", self.init, self.expr)?;
-        self.body().display(f, indentation)
+    /// Converts the "for in" loop to a string with the given indentation.
+    pub(in crate::syntax::ast::node) fn to_indented_string(
+        &self,
+        interner: &Interner,
+        indentation: usize,
+    ) -> String {
+        let mut buf = if let Some(label) = self.label {
+            format!("{}: ", interner.resolve_expect(label))
+        } else {
+            String::new()
+        };
+        buf.push_str(&format!(
+            "for ({} in {}) ",
+            self.init.to_interned_string(interner),
+            self.expr.to_interned_string(interner)
+        ));
+        buf.push_str(&self.body().to_indented_string(interner, indentation));
+
+        buf
     }
 }
 
-impl fmt::Display for ForInLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for ForInLoop {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/iteration/for_loop/mod.rs b/boa/src/syntax/ast/node/iteration/for_loop/mod.rs
index c608e1ac2db..8faf7058e84 100644
--- a/boa/src/syntax/ast/node/iteration/for_loop/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/for_loop/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -23,7 +23,7 @@ use serde::{Deserialize, Serialize};
 pub struct ForLoop {
     #[cfg_attr(feature = "deser", serde(flatten))]
     inner: Box<InnerForLoop>,
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl ForLoop {
@@ -61,42 +61,49 @@ impl ForLoop {
         self.inner.body()
     }
 
-    pub(in crate::syntax::ast::node) fn display(
+    /// Converts the for loop to a string with the given indentation.
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        if let Some(ref label) = self.label {
-            write!(f, "{}: ", label)?;
-        }
-        f.write_str("for (")?;
+    ) -> String {
+        let mut buf = if let Some(label) = self.label {
+            format!("{}: ", interner.resolve_expect(label))
+        } else {
+            String::new()
+        };
+        buf.push_str("for (");
         if let Some(init) = self.init() {
-            fmt::Display::fmt(init, f)?;
+            buf.push_str(&init.to_interned_string(interner));
         }
-        f.write_str("; ")?;
+        buf.push_str("; ");
         if let Some(condition) = self.condition() {
-            fmt::Display::fmt(condition, f)?;
+            buf.push_str(&condition.to_interned_string(interner));
         }
-        f.write_str("; ")?;
+        buf.push_str("; ");
         if let Some(final_expr) = self.final_expr() {
-            fmt::Display::fmt(final_expr, f)?;
+            buf.push_str(&final_expr.to_interned_string(interner));
         }
-        write!(f, ") ")?;
-        self.inner.body().display(f, indentation)
+        buf.push_str(&format!(
+            ") {}",
+            self.inner.body().to_indented_string(interner, indentation)
+        ));
+
+        buf
     }
 
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 
-    pub fn set_label(&mut self, label: Box<str>) {
+    pub fn set_label(&mut self, label: Sym) {
         self.label = Some(label);
     }
 }
 
-impl fmt::Display for ForLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for ForLoop {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/iteration/for_of_loop/mod.rs b/boa/src/syntax/ast/node/iteration/for_of_loop/mod.rs
index 6b4a954102b..63970eecbdb 100644
--- a/boa/src/syntax/ast/node/iteration/for_of_loop/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/for_of_loop/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{iteration::IterableLoopInitializer, Node},
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -13,10 +13,11 @@ pub struct ForOfLoop {
     init: Box<IterableLoopInitializer>,
     iterable: Box<Node>,
     body: Box<Node>,
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl ForOfLoop {
+    /// Creates a new "for of" loop AST node.
     pub fn new<I, B>(init: IterableLoopInitializer, iterable: I, body: B) -> Self
     where
         I: Into<Node>,
@@ -42,26 +43,39 @@ impl ForOfLoop {
         &self.body
     }
 
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 
-    pub fn set_label(&mut self, label: Box<str>) {
+    pub fn set_label(&mut self, label: Sym) {
         self.label = Some(label);
     }
 
-    pub fn display(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
-        if let Some(ref label) = self.label {
-            write!(f, "{}: ", label)?;
-        }
-        write!(f, "for ({} of {}) ", self.init, self.iterable)?;
-        self.body().display(f, indentation)
+    /// Converts the "for of" loop to a string with the given indentation.
+    pub(in crate::syntax::ast::node) fn to_indented_string(
+        &self,
+        interner: &Interner,
+        indentation: usize,
+    ) -> String {
+        let mut buf = if let Some(label) = self.label {
+            format!("{}: ", interner.resolve_expect(label))
+        } else {
+            String::new()
+        };
+        buf.push_str(&format!(
+            "for ({} of {}) {}",
+            self.init.to_interned_string(interner),
+            self.iterable.to_interned_string(interner),
+            self.body().to_indented_string(interner, indentation)
+        ));
+
+        buf
     }
 }
 
-impl fmt::Display for ForOfLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for ForOfLoop {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/iteration/mod.rs b/boa/src/syntax/ast/node/iteration/mod.rs
index 7d5dc77644a..b2bb3d26899 100644
--- a/boa/src/syntax/ast/node/iteration/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/mod.rs
@@ -1,14 +1,14 @@
 //! Iteration nodes
 
 pub use self::{
-    continue_node::Continue, do_while_loop::DoWhileLoop, for_in_loop::ForInLoop, for_loop::ForLoop,
-    for_of_loop::ForOfLoop, while_loop::WhileLoop,
+    break_node::Break, continue_node::Continue, do_while_loop::DoWhileLoop, for_in_loop::ForInLoop,
+    for_loop::ForLoop, for_of_loop::ForOfLoop, while_loop::WhileLoop,
 };
 use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{declaration::Declaration, identifier::Identifier},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -25,17 +25,26 @@ pub enum IterableLoopInitializer {
     Const(Declaration),
 }
 
-impl fmt::Display for IterableLoopInitializer {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for IterableLoopInitializer {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         match self {
-            IterableLoopInitializer::Identifier(identifier) => write!(f, "{}", identifier),
-            IterableLoopInitializer::Var(declaration) => write!(f, "var {}", declaration),
-            IterableLoopInitializer::Let(declaration) => write!(f, "let {}", declaration),
-            IterableLoopInitializer::Const(declaration) => write!(f, "const {}", declaration),
+            IterableLoopInitializer::Identifier(identifier) => {
+                identifier.to_interned_string(interner)
+            }
+            IterableLoopInitializer::Var(declaration) => {
+                format!("var {}", declaration.to_interned_string(interner))
+            }
+            IterableLoopInitializer::Let(declaration) => {
+                format!("let {}", declaration.to_interned_string(interner))
+            }
+            IterableLoopInitializer::Const(declaration) => {
+                format!("const {}", declaration.to_interned_string(interner))
+            }
         }
     }
 }
 
+pub mod break_node;
 pub mod continue_node;
 pub mod do_while_loop;
 pub mod for_in_loop;
diff --git a/boa/src/syntax/ast/node/iteration/while_loop/mod.rs b/boa/src/syntax/ast/node/iteration/while_loop/mod.rs
index 5a47fcaa750..eba779c4f26 100644
--- a/boa/src/syntax/ast/node/iteration/while_loop/mod.rs
+++ b/boa/src/syntax/ast/node/iteration/while_loop/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -23,7 +23,7 @@ use serde::{Deserialize, Serialize};
 pub struct WhileLoop {
     cond: Box<Node>,
     body: Box<Node>,
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl WhileLoop {
@@ -35,11 +35,11 @@ impl WhileLoop {
         &self.body
     }
 
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 
-    pub fn set_label(&mut self, label: Box<str>) {
+    pub fn set_label(&mut self, label: Sym) {
         self.label = Some(label);
     }
 
@@ -56,22 +56,30 @@ impl WhileLoop {
         }
     }
 
-    pub(in crate::syntax::ast::node) fn display(
+    /// Converts the while loop to a string with the given indentation.
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        if let Some(ref label) = self.label {
-            write!(f, "{}: ", label)?;
-        }
-        write!(f, "while ({}) ", self.cond())?;
-        self.body().display(f, indentation)
+    ) -> String {
+        let mut buf = if let Some(label) = self.label {
+            format!("{}: ", interner.resolve_expect(label))
+        } else {
+            String::new()
+        };
+        buf.push_str(&format!(
+            "while ({}) {}",
+            self.cond().to_interned_string(interner),
+            self.body().to_indented_string(interner, indentation)
+        ));
+
+        buf
     }
 }
 
-impl fmt::Display for WhileLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for WhileLoop {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/mod.rs b/boa/src/syntax/ast/node/mod.rs
index 02139145ccb..821bdbb4279 100644
--- a/boa/src/syntax/ast/node/mod.rs
+++ b/boa/src/syntax/ast/node/mod.rs
@@ -3,7 +3,6 @@
 pub mod array;
 pub mod await_expr;
 pub mod block;
-pub mod break_node;
 pub mod call;
 pub mod conditional;
 pub mod declaration;
@@ -26,7 +25,6 @@ pub use self::{
     array::ArrayDecl,
     await_expr::AwaitExpr,
     block::Block,
-    break_node::Break,
     call::Call,
     conditional::{ConditionalOp, If},
     declaration::{
@@ -37,7 +35,7 @@ pub use self::{
     },
     field::{GetConstField, GetField},
     identifier::Identifier,
-    iteration::{Continue, DoWhileLoop, ForInLoop, ForLoop, ForOfLoop, WhileLoop},
+    iteration::{Break, Continue, DoWhileLoop, ForInLoop, ForLoop, ForOfLoop, WhileLoop},
     new::New,
     object::Object,
     operator::{Assign, BinOp, UnaryOp},
@@ -52,10 +50,8 @@ pub use self::{
 };
 use super::Const;
 use crate::gc::{empty_trace, Finalize, Trace};
-use std::{
-    cmp::Ordering,
-    fmt::{self, Display},
-};
+use boa_interner::{Interner, Sym, ToInternedString};
+use std::cmp::Ordering;
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -226,12 +222,6 @@ pub enum Node {
     GeneratorExpr(GeneratorExpr),
 }
 
-impl Display for Node {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
-    }
-}
-
 impl From<Const> for Node {
     fn from(c: Const) -> Self {
         Self::Const(c)
@@ -255,8 +245,8 @@ impl Node {
         Self::This
     }
 
-    /// Displays the value of the node with the given indentation. For example, an indent
-    /// level of 2 would produce this:
+    /// Creates a string of the value of the node with the given indentation. For example, an
+    /// indent level of 2 would produce this:
     ///
     /// ```js
     ///         function hello() {
@@ -265,81 +255,95 @@ impl Node {
     ///         hello();
     ///         a = 2;
     /// ```
-    fn display(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
-        let indent = "    ".repeat(indentation);
-        match *self {
-            Self::Block(_) => {}
-            _ => write!(f, "{}", indent)?,
-        }
-        self.display_no_indent(f, indentation)
+    fn to_indented_string(&self, interner: &Interner, indentation: usize) -> String {
+        let mut buf = match *self {
+            Self::Block(_) => String::new(),
+            _ => "    ".repeat(indentation),
+        };
+
+        buf.push_str(&self.to_no_indent_string(interner, indentation));
+
+        buf
     }
 
-    /// Implements the display formatting with indentation. This will not prefix the value with
-    /// any indentation. If you want to prefix this with proper indents, use [`display`](Self::display).
-    fn display_no_indent(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
+    /// Implements the display formatting with indentation.
+    ///
+    /// This will not prefix the value with any indentation. If you want to prefix this with proper
+    /// indents, use [`to_indented_string()`](Self::to_indented_string).
+    fn to_no_indent_string(&self, interner: &Interner, indentation: usize) -> String {
         match *self {
-            Self::Call(ref expr) => Display::fmt(expr, f),
-            Self::Const(ref c) => write!(f, "{}", c),
-            Self::ConditionalOp(ref cond_op) => Display::fmt(cond_op, f),
-            Self::ForLoop(ref for_loop) => for_loop.display(f, indentation),
-            Self::ForOfLoop(ref for_of) => for_of.display(f, indentation),
-            Self::ForInLoop(ref for_in) => for_in.display(f, indentation),
-            Self::This => write!(f, "this"),
-            Self::Try(ref try_catch) => try_catch.display(f, indentation),
-            Self::Break(ref break_smt) => Display::fmt(break_smt, f),
-            Self::Continue(ref cont) => Display::fmt(cont, f),
-            Self::Spread(ref spread) => Display::fmt(spread, f),
-            Self::Block(ref block) => block.display(f, indentation),
-            Self::Identifier(ref s) => Display::fmt(s, f),
-            Self::New(ref expr) => Display::fmt(expr, f),
-            Self::GetConstField(ref get_const_field) => Display::fmt(get_const_field, f),
-            Self::GetField(ref get_field) => Display::fmt(get_field, f),
-            Self::WhileLoop(ref while_loop) => while_loop.display(f, indentation),
-            Self::DoWhileLoop(ref do_while) => do_while.display(f, indentation),
-            Self::If(ref if_smt) => if_smt.display(f, indentation),
-            Self::Switch(ref switch) => switch.display(f, indentation),
-            Self::Object(ref obj) => obj.display(f, indentation),
-            Self::ArrayDecl(ref arr) => Display::fmt(arr, f),
-            Self::VarDeclList(ref list) => Display::fmt(list, f),
-            Self::FunctionDecl(ref decl) => decl.display(f, indentation),
-            Self::FunctionExpr(ref expr) => expr.display(f, indentation),
-            Self::ArrowFunctionDecl(ref decl) => decl.display(f, indentation),
-            Self::BinOp(ref op) => Display::fmt(op, f),
-            Self::UnaryOp(ref op) => Display::fmt(op, f),
-            Self::Return(ref ret) => Display::fmt(ret, f),
-            Self::TaggedTemplate(ref template) => Display::fmt(template, f),
-            Self::TemplateLit(ref template) => Display::fmt(template, f),
-            Self::Throw(ref throw) => Display::fmt(throw, f),
-            Self::Assign(ref op) => Display::fmt(op, f),
-            Self::LetDeclList(ref decl) => Display::fmt(decl, f),
-            Self::ConstDeclList(ref decl) => Display::fmt(decl, f),
-            Self::AsyncFunctionDecl(ref decl) => decl.display(f, indentation),
-            Self::AsyncFunctionExpr(ref expr) => expr.display(f, indentation),
-            Self::AwaitExpr(ref expr) => Display::fmt(expr, f),
-            Self::Empty => write!(f, ";"),
-            Self::Yield(ref y) => Display::fmt(y, f),
-            Self::GeneratorDecl(ref decl) => Display::fmt(decl, f),
-            Self::GeneratorExpr(ref expr) => expr.display(f, indentation),
-            Self::AsyncGeneratorExpr(ref expr) => expr.display(f, indentation),
-            Self::AsyncGeneratorDecl(ref decl) => decl.display(f, indentation),
+            Self::Call(ref expr) => expr.to_interned_string(interner),
+            Self::Const(ref c) => c.to_interned_string(interner),
+            Self::ConditionalOp(ref cond_op) => cond_op.to_interned_string(interner),
+            Self::ForLoop(ref for_loop) => for_loop.to_indented_string(interner, indentation),
+            Self::ForOfLoop(ref for_of) => for_of.to_indented_string(interner, indentation),
+            Self::ForInLoop(ref for_in) => for_in.to_indented_string(interner, indentation),
+            Self::This => "this".to_owned(),
+            Self::Try(ref try_catch) => try_catch.to_indented_string(interner, indentation),
+            Self::Break(ref break_smt) => break_smt.to_interned_string(interner),
+            Self::Continue(ref cont) => cont.to_interned_string(interner),
+            Self::Spread(ref spread) => spread.to_interned_string(interner),
+            Self::Block(ref block) => block.to_indented_string(interner, indentation),
+            Self::Identifier(ref ident) => ident.to_interned_string(interner),
+            Self::New(ref expr) => expr.to_interned_string(interner),
+            Self::GetConstField(ref get_const_field) => {
+                get_const_field.to_interned_string(interner)
+            }
+            Self::GetField(ref get_field) => get_field.to_interned_string(interner),
+            Self::WhileLoop(ref while_loop) => while_loop.to_indented_string(interner, indentation),
+            Self::DoWhileLoop(ref do_while) => do_while.to_indented_string(interner, indentation),
+            Self::If(ref if_smt) => if_smt.to_indented_string(interner, indentation),
+            Self::Switch(ref switch) => switch.to_indented_string(interner, indentation),
+            Self::Object(ref obj) => obj.to_indented_string(interner, indentation),
+            Self::ArrayDecl(ref arr) => arr.to_interned_string(interner),
+            Self::VarDeclList(ref list) => list.to_interned_string(interner),
+            Self::FunctionDecl(ref decl) => decl.to_indented_string(interner, indentation),
+            Self::FunctionExpr(ref expr) => expr.to_indented_string(interner, indentation),
+            Self::ArrowFunctionDecl(ref decl) => decl.to_indented_string(interner, indentation),
+            Self::BinOp(ref op) => op.to_interned_string(interner),
+            Self::UnaryOp(ref op) => op.to_interned_string(interner),
+            Self::Return(ref ret) => ret.to_interned_string(interner),
+            Self::TaggedTemplate(ref template) => template.to_interned_string(interner),
+            Self::TemplateLit(ref template) => template.to_interned_string(interner),
+            Self::Throw(ref throw) => throw.to_interned_string(interner),
+            Self::Assign(ref op) => op.to_interned_string(interner),
+            Self::LetDeclList(ref decl) => decl.to_interned_string(interner),
+            Self::ConstDeclList(ref decl) => decl.to_interned_string(interner),
+            Self::AsyncFunctionDecl(ref decl) => decl.to_indented_string(interner, indentation),
+            Self::AsyncFunctionExpr(ref expr) => expr.to_indented_string(interner, indentation),
+            Self::AwaitExpr(ref expr) => expr.to_interned_string(interner),
+            Self::Empty => ";".to_owned(),
+            Self::Yield(ref y) => y.to_interned_string(interner),
+            Self::GeneratorDecl(ref decl) => decl.to_interned_string(interner),
+            Self::GeneratorExpr(ref expr) => expr.to_indented_string(interner, indentation),
+            Self::AsyncGeneratorExpr(ref expr) => expr.to_indented_string(interner, indentation),
+            Self::AsyncGeneratorDecl(ref decl) => decl.to_indented_string(interner, indentation),
         }
     }
 }
 
+impl ToInternedString for Node {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
+    }
+}
+
 /// Utility to join multiple Nodes into a single string.
-fn join_nodes<N>(f: &mut fmt::Formatter<'_>, nodes: &[N]) -> fmt::Result
+fn join_nodes<N>(interner: &Interner, nodes: &[N]) -> String
 where
-    N: Display,
+    N: ToInternedString,
 {
     let mut first = true;
+    let mut buf = String::new();
     for e in nodes {
-        if !first {
-            f.write_str(", ")?;
+        if first {
+            first = false;
+        } else {
+            buf.push_str(", ");
         }
-        first = false;
-        Display::fmt(e, f)?;
+        buf.push_str(&e.to_interned_string(interner))
     }
-    Ok(())
+    buf
 }
 
 /// "Formal parameter" is a fancy way of saying "function parameter".
@@ -377,9 +381,9 @@ impl FormalParameter {
     }
 
     /// Gets the name of the formal parameter.
-    pub fn names(&self) -> Vec<&str> {
+    pub fn names(&self) -> Vec<Sym> {
         match &self.declaration {
-            Declaration::Identifier { ident, .. } => vec![ident.as_ref()],
+            Declaration::Identifier { ident, .. } => vec![ident.sym()],
             Declaration::Pattern(pattern) => match pattern {
                 DeclarationPattern::Object(object_pattern) => object_pattern.idents(),
 
@@ -408,13 +412,15 @@ impl FormalParameter {
     }
 }
 
-impl Display for FormalParameter {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.is_rest_param {
-            write!(f, "...")?;
-        }
-        write!(f, "{}", self.declaration)?;
-        Ok(())
+impl ToInternedString for FormalParameter {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let mut buf = if self.is_rest_param {
+            "...".to_owned()
+        } else {
+            String::new()
+        };
+        buf.push_str(&self.declaration.to_interned_string(interner));
+        buf
     }
 }
 
@@ -618,7 +624,7 @@ pub enum PropertyName {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#prod-LiteralPropertyName
-    Literal(Box<str>),
+    Literal(Sym),
     /// A `Computed` property name is an expression that gets evaluated and converted into a property name.
     ///
     /// More information:
@@ -628,21 +634,18 @@ pub enum PropertyName {
     Computed(Node),
 }
 
-impl Display for PropertyName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for PropertyName {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         match self {
-            PropertyName::Literal(key) => write!(f, "{}", key),
-            PropertyName::Computed(key) => write!(f, "{}", key),
+            PropertyName::Literal(key) => interner.resolve_expect(*key).to_owned(),
+            PropertyName::Computed(key) => key.to_interned_string(interner),
         }
     }
 }
 
-impl<T> From<T> for PropertyName
-where
-    T: Into<Box<str>>,
-{
-    fn from(name: T) -> Self {
-        Self::Literal(name.into())
+impl From<Sym> for PropertyName {
+    fn from(name: Sym) -> Self {
+        Self::Literal(name)
     }
 }
 
@@ -667,7 +670,7 @@ unsafe impl Trace for PropertyName {
 /// level.
 #[cfg(test)]
 fn test_formatting(source: &'static str) {
-    use crate::{syntax::Parser, Interner};
+    use crate::syntax::Parser;
 
     // Remove preceding newline.
     let source = &source[1..];
@@ -682,13 +685,11 @@ fn test_formatting(source: &'static str) {
         .map(|l| &l[characters_to_remove..]) // Remove preceding whitespace from each line
         .collect::<Vec<&'static str>>()
         .join("\n");
-    let mut interner = Interner::new();
-    let result = format!(
-        "{}",
-        Parser::new(scenario.as_bytes(), false)
-            .parse_all(&mut interner)
-            .expect("parsing failed")
-    );
+    let mut interner = Interner::default();
+    let result = Parser::new(scenario.as_bytes(), false)
+        .parse_all(&mut interner)
+        .expect("parsing failed")
+        .to_interned_string(&interner);
     if scenario != result {
         eprint!("========= Expected:\n{}", scenario);
         eprint!("========= Got:\n{}", result);
diff --git a/boa/src/syntax/ast/node/new/mod.rs b/boa/src/syntax/ast/node/new/mod.rs
index 000f11eb31f..1a523dd967a 100644
--- a/boa/src/syntax/ast/node/new/mod.rs
+++ b/boa/src/syntax/ast/node/new/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{Call, Node},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -54,9 +54,9 @@ impl From<Call> for New {
     }
 }
 
-impl fmt::Display for New {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "new {}", self.call)
+impl ToInternedString for New {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("new {}", self.call.to_interned_string(interner))
     }
 }
 
diff --git a/boa/src/syntax/ast/node/object/mod.rs b/boa/src/syntax/ast/node/object/mod.rs
index 3024e4f0be0..eae1e07a2b7 100644
--- a/boa/src/syntax/ast/node/object/mod.rs
+++ b/boa/src/syntax/ast/node/object/mod.rs
@@ -2,9 +2,11 @@
 
 use crate::{
     gc::{Finalize, Trace},
-    syntax::ast::node::{join_nodes, MethodDefinitionKind, Node, PropertyDefinition},
+    syntax::ast::node::{
+        declaration::block_to_string, join_nodes, MethodDefinitionKind, Node, PropertyDefinition,
+    },
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -44,51 +46,57 @@ impl Object {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indent: usize,
-    ) -> fmt::Result {
-        f.write_str("{\n")?;
+    ) -> String {
+        let mut buf = "{\n".to_owned();
         let indentation = "    ".repeat(indent + 1);
         for property in self.properties().iter() {
-            match property {
+            buf.push_str(&match property {
                 PropertyDefinition::IdentifierReference(key) => {
-                    writeln!(f, "{}{},", indentation, key)?;
+                    format!("{}{},\n", indentation, key)
                 }
                 PropertyDefinition::Property(key, value) => {
-                    write!(f, "{}{}: ", indentation, key,)?;
-                    value.display_no_indent(f, indent + 1)?;
-                    writeln!(f, ",")?;
+                    format!(
+                        "{}{}: {},\n",
+                        indentation,
+                        key.to_interned_string(interner),
+                        value.to_no_indent_string(interner, indent + 1)
+                    )
                 }
                 PropertyDefinition::SpreadObject(key) => {
-                    writeln!(f, "{}...{},", indentation, key)?;
+                    format!("{}...{},\n", indentation, key.to_interned_string(interner))
                 }
                 PropertyDefinition::MethodDefinition(kind, key, node) => {
-                    write!(f, "{}", indentation)?;
-                    match &kind {
-                        MethodDefinitionKind::Get => write!(f, "get ")?,
-                        MethodDefinitionKind::Set => write!(f, "set ")?,
-                        MethodDefinitionKind::Ordinary
-                        | MethodDefinitionKind::Generator
-                        | MethodDefinitionKind::Async
-                        | MethodDefinitionKind::AsyncGenerator => (),
-                    }
-                    write!(f, "{}(", key)?;
-                    join_nodes(f, node.parameters())?;
-                    write!(f, ") ")?;
-                    node.display_block(f, indent + 1)?;
-                    writeln!(f, ",")?;
+                    format!(
+                        "{}{}{}({}) {},\n",
+                        indentation,
+                        match &kind {
+                            MethodDefinitionKind::Get => "get ",
+                            MethodDefinitionKind::Set => "set ",
+                            MethodDefinitionKind::Ordinary
+                            | MethodDefinitionKind::Generator
+                            | MethodDefinitionKind::Async
+                            | MethodDefinitionKind::AsyncGenerator => "",
+                        },
+                        key.to_interned_string(interner),
+                        join_nodes(interner, node.parameters()),
+                        block_to_string(node.body(), interner, indent + 1)
+                    )
                 }
-            }
+            });
         }
-        write!(f, "{}}}", "    ".repeat(indent))
+        buf.push_str(&format!("{}}}", "    ".repeat(indent)));
+
+        buf
     }
 }
 
-impl fmt::Display for Object {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for Object {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/operator/assign/mod.rs b/boa/src/syntax/ast/node/operator/assign/mod.rs
index fe6a32e0539..5ead4b8ac68 100644
--- a/boa/src/syntax/ast/node/operator/assign/mod.rs
+++ b/boa/src/syntax/ast/node/operator/assign/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -49,9 +49,13 @@ impl Assign {
     }
 }
 
-impl fmt::Display for Assign {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} = {}", self.lhs, self.rhs)
+impl ToInternedString for Assign {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
+            "{} = {}",
+            self.lhs.to_interned_string(interner),
+            self.rhs.to_interned_string(interner)
+        )
     }
 }
 
diff --git a/boa/src/syntax/ast/node/operator/bin_op/mod.rs b/boa/src/syntax/ast/node/operator/bin_op/mod.rs
index f178e4c7e4f..489587800b8 100644
--- a/boa/src/syntax/ast/node/operator/bin_op/mod.rs
+++ b/boa/src/syntax/ast/node/operator/bin_op/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::{node::Node, op},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -52,9 +52,14 @@ impl BinOp {
     }
 }
 
-impl fmt::Display for BinOp {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} {} {}", self.lhs, self.op, self.rhs)
+impl ToInternedString for BinOp {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!(
+            "{} {} {}",
+            self.lhs.to_interned_string(interner),
+            self.op,
+            self.rhs.to_interned_string(interner)
+        )
     }
 }
 
diff --git a/boa/src/syntax/ast/node/operator/unary_op/mod.rs b/boa/src/syntax/ast/node/operator/unary_op/mod.rs
index 69f04c5dd3b..5759d73ea58 100644
--- a/boa/src/syntax/ast/node/operator/unary_op/mod.rs
+++ b/boa/src/syntax/ast/node/operator/unary_op/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::{node::Node, op},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -45,9 +45,9 @@ impl UnaryOp {
     }
 }
 
-impl fmt::Display for UnaryOp {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}{}", self.op, self.target)
+impl ToInternedString for UnaryOp {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("{}{}", self.op, self.target.to_interned_string(interner))
     }
 }
 
diff --git a/boa/src/syntax/ast/node/return_smt/mod.rs b/boa/src/syntax/ast/node/return_smt/mod.rs
index f886269953f..14ff0315e9c 100644
--- a/boa/src/syntax/ast/node/return_smt/mod.rs
+++ b/boa/src/syntax/ast/node/return_smt/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -32,12 +32,12 @@ mod tests;
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct Return {
     expr: Option<Box<Node>>,
-    label: Option<Box<str>>,
+    label: Option<Sym>,
 }
 
 impl Return {
-    pub fn label(&self) -> Option<&str> {
-        self.label.as_ref().map(Box::as_ref)
+    pub fn label(&self) -> Option<Sym> {
+        self.label
     }
 
     pub fn expr(&self) -> Option<&Node> {
@@ -49,7 +49,7 @@ impl Return {
     where
         E: Into<Node>,
         OE: Into<Option<E>>,
-        L: Into<Option<Box<str>>>,
+        L: Into<Option<Sym>>,
     {
         Self {
             expr: expr.into().map(E::into).map(Box::new),
@@ -64,11 +64,11 @@ impl From<Return> for Node {
     }
 }
 
-impl fmt::Display for Return {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for Return {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         match self.expr() {
-            Some(ex) => write!(f, "return {}", ex),
-            None => write!(f, "return"),
+            Some(ex) => format!("return {}", ex.to_interned_string(interner)),
+            None => "return".to_owned(),
         }
     }
 }
diff --git a/boa/src/syntax/ast/node/spread/mod.rs b/boa/src/syntax/ast/node/spread/mod.rs
index d8dd6952a13..11f933f12e2 100644
--- a/boa/src/syntax/ast/node/spread/mod.rs
+++ b/boa/src/syntax/ast/node/spread/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -49,9 +49,9 @@ impl Spread {
     }
 }
 
-impl fmt::Display for Spread {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "...{}", self.val())
+impl ToInternedString for Spread {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("...{}", self.val().to_interned_string(interner))
     }
 }
 
diff --git a/boa/src/syntax/ast/node/statement_list/mod.rs b/boa/src/syntax/ast/node/statement_list/mod.rs
index 9bc7b0f8663..4da5345f874 100644
--- a/boa/src/syntax/ast/node/statement_list/mod.rs
+++ b/boa/src/syntax/ast/node/statement_list/mod.rs
@@ -4,8 +4,10 @@ use crate::{
     gc::{empty_trace, Finalize, Trace},
     syntax::ast::node::{Declaration, Node},
 };
-use std::{collections::HashSet, fmt, ops::Deref, rc::Rc};
+use boa_interner::{Interner, Sym, ToInternedString};
+use std::{ops::Deref, rc::Rc};
 
+use rustc_hash::FxHashSet;
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
 
@@ -48,27 +50,29 @@ impl StatementList {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
+    ) -> String {
+        let mut buf = String::new();
         // Print statements
         for node in self.items.iter() {
             // We rely on the node to add the correct indent.
-            node.display(f, indentation)?;
+            buf.push_str(&node.to_indented_string(interner, indentation));
 
             match node {
                 Node::Block(_) | Node::If(_) | Node::Switch(_) | Node::WhileLoop(_) => {}
-                _ => write!(f, ";")?,
+                _ => buf.push(';'),
             }
-            writeln!(f)?;
+
+            buf.push('\n');
         }
-        Ok(())
+        buf
     }
 
-    pub fn lexically_declared_names(&self) -> HashSet<&str> {
-        let mut set = HashSet::new();
+    pub fn lexically_declared_names(&self, interner: &Interner) -> FxHashSet<Sym> {
+        let mut set = FxHashSet::default();
         for stmt in self.items() {
             if let Node::LetDeclList(decl_list) | Node::ConstDeclList(decl_list) = stmt {
                 for decl in decl_list.as_ref() {
@@ -76,14 +80,20 @@ impl StatementList {
                     // https://tc39.es/ecma262/#sec-block-static-semantics-early-errors
                     match decl {
                         Declaration::Identifier { ident, .. } => {
-                            if !set.insert(ident.as_ref()) {
-                                unreachable!("Redeclaration of {}", ident.as_ref());
+                            if !set.insert(ident.sym()) {
+                                unreachable!(
+                                    "Redeclaration of {}",
+                                    interner.resolve_expect(ident.sym())
+                                );
                             }
                         }
                         Declaration::Pattern(p) => {
-                            for ident in p.idents() {
+                            for ident in p.idents().iter().copied() {
                                 if !set.insert(ident) {
-                                    unreachable!("Redeclaration of {}", ident);
+                                    unreachable!(
+                                        "Redeclaration of {}",
+                                        interner.resolve_expect(ident)
+                                    );
                                 }
                             }
                         }
@@ -94,8 +104,8 @@ impl StatementList {
         set
     }
 
-    pub fn function_declared_names(&self) -> HashSet<&str> {
-        let mut set = HashSet::new();
+    pub fn function_declared_names(&self) -> FxHashSet<Sym> {
+        let mut set = FxHashSet::default();
         for stmt in self.items() {
             if let Node::FunctionDecl(decl) = stmt {
                 set.insert(decl.name());
@@ -104,20 +114,16 @@ impl StatementList {
         set
     }
 
-    pub fn var_declared_names(&self) -> HashSet<&str> {
-        let mut set = HashSet::new();
+    pub fn var_declared_names(&self) -> FxHashSet<Sym> {
+        let mut set = FxHashSet::default();
         for stmt in self.items() {
             if let Node::VarDeclList(decl_list) = stmt {
                 for decl in decl_list.as_ref() {
                     match decl {
                         Declaration::Identifier { ident, .. } => {
-                            set.insert(ident.as_ref());
-                        }
-                        Declaration::Pattern(p) => {
-                            for ident in p.idents() {
-                                set.insert(ident.as_ref());
-                            }
+                            set.insert(ident.sym());
                         }
+                        Declaration::Pattern(p) => set.extend(p.idents().into_iter()),
                     }
                 }
             }
@@ -138,9 +144,9 @@ where
     }
 }
 
-impl fmt::Display for StatementList {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for StatementList {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/switch/mod.rs b/boa/src/syntax/ast/node/switch/mod.rs
index cededb1efdd..b31da6dd148 100644
--- a/boa/src/syntax/ast/node/switch/mod.rs
+++ b/boa/src/syntax/ast/node/switch/mod.rs
@@ -4,7 +4,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 use crate::syntax::ast::node::StatementList;
 
@@ -100,29 +100,38 @@ impl Switch {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
+    ) -> String {
         let indent = "    ".repeat(indentation);
-        writeln!(f, "switch ({}) {{", self.val())?;
+        let mut buf = format!("switch ({}) {{\n", self.val().to_interned_string(interner));
         for e in self.cases().iter() {
-            writeln!(f, "{}    case {}:", indent, e.condition())?;
-            e.body().display(f, indentation + 2)?;
+            buf.push_str(&format!(
+                "{}    case {}:\n{}",
+                indent,
+                e.condition().to_interned_string(interner),
+                e.body().to_indented_string(interner, indentation + 2)
+            ));
         }
 
         if let Some(ref default) = self.default {
-            writeln!(f, "{}    default:", indent)?;
-            default.display(f, indentation + 2)?;
+            buf.push_str(&format!(
+                "{}    default:\n{}",
+                indent,
+                default.to_indented_string(interner, indentation + 2)
+            ));
         }
-        write!(f, "{}}}", indent)
+        buf.push_str(&format!("{}}}", indent));
+
+        buf
     }
 }
 
-impl fmt::Display for Switch {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for Switch {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
diff --git a/boa/src/syntax/ast/node/template/mod.rs b/boa/src/syntax/ast/node/template/mod.rs
index 6c336817ace..f6c05366b45 100644
--- a/boa/src/syntax/ast/node/template/mod.rs
+++ b/boa/src/syntax/ast/node/template/mod.rs
@@ -1,11 +1,11 @@
 //! Template literal node.
 
 use super::Node;
-use gc::{Finalize, Trace};
+use crate::gc::{Finalize, Trace};
+use boa_interner::{Interner, Sym, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
-use std::fmt;
 
 #[cfg(test)]
 mod tests;
@@ -21,52 +21,64 @@ mod tests;
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct TemplateLit {
-    elements: Vec<TemplateElement>,
+    elements: Box<[TemplateElement]>,
 }
 
 impl TemplateLit {
-    pub fn new(elements: Vec<TemplateElement>) -> Self {
-        TemplateLit { elements }
+    pub fn new<E>(elements: E) -> Self
+    where
+        E: Into<Box<[TemplateElement]>>,
+    {
+        TemplateLit {
+            elements: elements.into(),
+        }
     }
 
-    pub(crate) fn elements(&self) -> &Vec<TemplateElement> {
+    pub(crate) fn elements(&self) -> &[TemplateElement] {
         &self.elements
     }
 }
 
-impl fmt::Display for TemplateLit {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "`")?;
-        for elt in &self.elements {
+impl ToInternedString for TemplateLit {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let mut buf = "`".to_owned();
+
+        for elt in self.elements.iter() {
             match elt {
-                TemplateElement::String(s) => write!(f, "{}", s)?,
-                TemplateElement::Expr(n) => write!(f, "${{{}}}", n)?,
+                TemplateElement::String(s) => buf.push_str(interner.resolve_expect(*s)),
+                TemplateElement::Expr(n) => {
+                    buf.push_str(&format!("${{{}}}", n.to_interned_string(interner)))
+                }
             }
         }
-        write!(f, "`")
+        buf.push('`');
+
+        buf
     }
 }
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct TaggedTemplate {
     tag: Box<Node>,
-    raws: Vec<Box<str>>,
-    cookeds: Vec<Option<Box<str>>>,
-    exprs: Vec<Node>,
+    raws: Box<[Sym]>,
+    cookeds: Box<[Option<Sym>]>,
+    exprs: Box<[Node]>,
 }
 
 impl TaggedTemplate {
-    pub fn new(
-        tag: Node,
-        raws: Vec<Box<str>>,
-        cookeds: Vec<Option<Box<str>>>,
-        exprs: Vec<Node>,
-    ) -> Self {
+    /// Creates a new tagged template with a tag, the list of raw strings, the cooked strings and
+    /// the expressions.
+    pub fn new<R, C, E>(tag: Node, raws: R, cookeds: C, exprs: E) -> Self
+    where
+        R: Into<Box<[Sym]>>,
+        C: Into<Box<[Option<Sym>]>>,
+        E: Into<Box<[Node]>>,
+    {
         Self {
             tag: Box::new(tag),
-            raws,
-            cookeds,
-            exprs,
+            raws: raws.into(),
+            cookeds: cookeds.into(),
+            exprs: exprs.into(),
         }
     }
 
@@ -74,26 +86,32 @@ impl TaggedTemplate {
         &self.tag
     }
 
-    pub(crate) fn raws(&self) -> &Vec<Box<str>> {
+    pub(crate) fn raws(&self) -> &[Sym] {
         &self.raws
     }
 
-    pub(crate) fn cookeds(&self) -> &Vec<Option<Box<str>>> {
+    pub(crate) fn cookeds(&self) -> &[Option<Sym>] {
         &self.cookeds
     }
 
-    pub(crate) fn exprs(&self) -> &Vec<Node> {
+    pub(crate) fn exprs(&self) -> &[Node] {
         &self.exprs
     }
 }
 
-impl fmt::Display for TaggedTemplate {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}`", self.tag)?;
-        for (raw, expr) in self.raws.iter().zip(self.exprs.iter()) {
-            write!(f, "{}${{{}}}", raw, expr)?;
+impl ToInternedString for TaggedTemplate {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let mut buf = format!("{}`", self.tag.to_interned_string(interner));
+        for (&raw, expr) in self.raws.iter().zip(self.exprs.iter()) {
+            buf.push_str(&format!(
+                "{}${{{}}}",
+                interner.resolve_expect(raw),
+                expr.to_interned_string(interner)
+            ));
         }
-        write!(f, "`")
+        buf.push('`');
+
+        buf
     }
 }
 
@@ -106,6 +124,6 @@ impl From<TaggedTemplate> for Node {
 #[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub enum TemplateElement {
-    String(Box<str>),
+    String(Sym),
     Expr(Node),
 }
diff --git a/boa/src/syntax/ast/node/throw/mod.rs b/boa/src/syntax/ast/node/throw/mod.rs
index 39facb90826..9ae71c5245a 100644
--- a/boa/src/syntax/ast/node/throw/mod.rs
+++ b/boa/src/syntax/ast/node/throw/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -46,9 +46,9 @@ impl Throw {
     }
 }
 
-impl fmt::Display for Throw {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "throw {}", self.expr)
+impl ToInternedString for Throw {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        format!("throw {}", self.expr.to_interned_string(interner))
     }
 }
 
diff --git a/boa/src/syntax/ast/node/try_node/mod.rs b/boa/src/syntax/ast/node/try_node/mod.rs
index ec304fa5455..16d7ce6329b 100644
--- a/boa/src/syntax/ast/node/try_node/mod.rs
+++ b/boa/src/syntax/ast/node/try_node/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::{Block, Declaration, Node},
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -69,28 +69,31 @@ impl Try {
     }
 
     /// Implements the display formatting with indentation.
-    pub(in crate::syntax::ast::node) fn display(
+    pub(in crate::syntax::ast::node) fn to_indented_string(
         &self,
-        f: &mut fmt::Formatter<'_>,
+        interner: &Interner,
         indentation: usize,
-    ) -> fmt::Result {
-        write!(f, "{}try ", "    ".repeat(indentation))?;
-        self.block.display(f, indentation)?;
+    ) -> String {
+        let mut buf = format!(
+            "{}try {}",
+            "    ".repeat(indentation),
+            self.block.to_indented_string(interner, indentation)
+        );
 
         if let Some(ref catch) = self.catch {
-            catch.display(f, indentation)?;
+            buf.push_str(&catch.to_indented_string(interner, indentation));
         }
 
         if let Some(ref finally) = self.finally {
-            finally.display(f, indentation)?;
+            buf.push_str(&finally.to_indented_string(interner, indentation));
         }
-        Ok(())
+        buf
     }
 }
 
-impl fmt::Display for Try {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for Try {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
@@ -133,19 +136,23 @@ impl Catch {
     }
 
     /// Implements the display formatting with indentation.
-    pub(super) fn display(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
-        f.write_str(" catch")?;
+    pub(super) fn to_indented_string(&self, interner: &Interner, indentation: usize) -> String {
+        let mut buf = " catch".to_owned();
         if let Some(ref param) = self.parameter {
-            write!(f, "({})", param)?;
+            buf.push_str(&format!("({})", param.to_interned_string(interner)));
         }
-        f.write_str(" ")?;
-        self.block.display(f, indentation)
+        buf.push_str(&format!(
+            " {}",
+            self.block.to_indented_string(interner, indentation)
+        ));
+
+        buf
     }
 }
 
-impl fmt::Display for Catch {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f, 0)
+impl ToInternedString for Catch {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        self.to_indented_string(interner, 0)
     }
 }
 
@@ -163,9 +170,11 @@ impl Finally {
     }
 
     /// Implements the display formatting with indentation.
-    pub(super) fn display(&self, f: &mut fmt::Formatter<'_>, indentation: usize) -> fmt::Result {
-        f.write_str(" finally ")?;
-        self.block.display(f, indentation)
+    pub(super) fn to_indented_string(&self, interner: &Interner, indentation: usize) -> String {
+        format!(
+            " finally {}",
+            self.block.to_indented_string(interner, indentation)
+        )
     }
 }
 
diff --git a/boa/src/syntax/ast/node/yield/mod.rs b/boa/src/syntax/ast/node/yield/mod.rs
index 1c134da82b4..999c47f6830 100644
--- a/boa/src/syntax/ast/node/yield/mod.rs
+++ b/boa/src/syntax/ast/node/yield/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     gc::{Finalize, Trace},
     syntax::ast::node::Node,
 };
-use std::fmt;
+use boa_interner::{Interner, ToInternedString};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -50,12 +50,13 @@ impl From<Yield> for Node {
     }
 }
 
-impl fmt::Display for Yield {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl ToInternedString for Yield {
+    fn to_interned_string(&self, interner: &Interner) -> String {
         let y = if self.delegate { "yield*" } else { "yield" };
-        match self.expr() {
-            Some(ex) => write!(f, "{} {}", y, ex),
-            None => write!(f, "{}", y),
+        if let Some(ex) = self.expr() {
+            format!("{} {}", y, ex.to_interned_string(interner))
+        } else {
+            y.to_owned()
         }
     }
 }
diff --git a/boa/src/syntax/ast/punctuator.rs b/boa/src/syntax/ast/punctuator.rs
index 06f225bd9e8..b59425a81b7 100644
--- a/boa/src/syntax/ast/punctuator.rs
+++ b/boa/src/syntax/ast/punctuator.rs
@@ -184,6 +184,67 @@ impl Punctuator {
             _ => None,
         }
     }
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Add => "+",
+            Self::And => "&",
+            Self::Arrow => "=>",
+            Self::Assign => "=",
+            Self::AssignAdd => "+=",
+            Self::AssignAnd => "&=",
+            Self::AssignBoolAnd => "&&=",
+            Self::AssignBoolOr => "||=",
+            Self::AssignCoalesce => "??=",
+            Self::AssignDiv => "/=",
+            Self::AssignLeftSh => "<<=",
+            Self::AssignMod => "%=",
+            Self::AssignMul => "*=",
+            Self::AssignOr => "|=",
+            Self::AssignPow => "**=",
+            Self::AssignRightSh => ">>=",
+            Self::AssignSub => "-=",
+            Self::AssignURightSh => ">>>=",
+            Self::AssignXor => "^=",
+            Self::BoolAnd => "&&",
+            Self::BoolOr => "||",
+            Self::Coalesce => "??",
+            Self::CloseBlock => "}",
+            Self::CloseBracket => "]",
+            Self::CloseParen => ")",
+            Self::Colon => ":",
+            Self::Comma => ",",
+            Self::Dec => "--",
+            Self::Div => "/",
+            Self::Dot => ".",
+            Self::Eq => "==",
+            Self::GreaterThan => ">",
+            Self::GreaterThanOrEq => ">=",
+            Self::Inc => "++",
+            Self::LeftSh => "<<",
+            Self::LessThan => "<",
+            Self::LessThanOrEq => "<=",
+            Self::Mod => "%",
+            Self::Mul => "*",
+            Self::Neg => "~",
+            Self::Not => "!",
+            Self::NotEq => "!=",
+            Self::OpenBlock => "{",
+            Self::OpenBracket => "[",
+            Self::OpenParen => "(",
+            Self::Or => "|",
+            Self::Exp => "**",
+            Self::Question => "?",
+            Self::RightSh => ">>",
+            Self::Semicolon => ";",
+            Self::Spread => "...",
+            Self::StrictEq => "===",
+            Self::StrictNotEq => "!==",
+            Self::Sub => "-",
+            Self::URightSh => ">>>",
+            Self::Xor => "^",
+        }
+    }
 }
 
 impl TryInto<BinOp> for Punctuator {
@@ -196,67 +257,6 @@ impl TryInto<BinOp> for Punctuator {
 
 impl Display for Punctuator {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::Add => "+",
-                Self::And => "&",
-                Self::Arrow => "=>",
-                Self::Assign => "=",
-                Self::AssignAdd => "+=",
-                Self::AssignAnd => "&=",
-                Self::AssignBoolAnd => "&&=",
-                Self::AssignBoolOr => "||=",
-                Self::AssignCoalesce => "??=",
-                Self::AssignDiv => "/=",
-                Self::AssignLeftSh => "<<=",
-                Self::AssignMod => "%=",
-                Self::AssignMul => "*=",
-                Self::AssignOr => "|=",
-                Self::AssignPow => "**=",
-                Self::AssignRightSh => ">>=",
-                Self::AssignSub => "-=",
-                Self::AssignURightSh => ">>>=",
-                Self::AssignXor => "^=",
-                Self::BoolAnd => "&&",
-                Self::BoolOr => "||",
-                Self::Coalesce => "??",
-                Self::CloseBlock => "}",
-                Self::CloseBracket => "]",
-                Self::CloseParen => ")",
-                Self::Colon => ":",
-                Self::Comma => ",",
-                Self::Dec => "--",
-                Self::Div => "/",
-                Self::Dot => ".",
-                Self::Eq => "==",
-                Self::GreaterThan => ">",
-                Self::GreaterThanOrEq => ">=",
-                Self::Inc => "++",
-                Self::LeftSh => "<<",
-                Self::LessThan => "<",
-                Self::LessThanOrEq => "<=",
-                Self::Mod => "%",
-                Self::Mul => "*",
-                Self::Neg => "~",
-                Self::Not => "!",
-                Self::NotEq => "!=",
-                Self::OpenBlock => "{",
-                Self::OpenBracket => "[",
-                Self::OpenParen => "(",
-                Self::Or => "|",
-                Self::Exp => "**",
-                Self::Question => "?",
-                Self::RightSh => ">>",
-                Self::Semicolon => ";",
-                Self::Spread => "...",
-                Self::StrictEq => "===",
-                Self::StrictNotEq => "!==",
-                Self::Sub => "-",
-                Self::URightSh => ">>>",
-                Self::Xor => "^",
-            }
-        )
+        write!(f, "{}", self.as_str())
     }
 }
diff --git a/boa/src/syntax/lexer/regex.rs b/boa/src/syntax/lexer/regex.rs
index ff91c16a1f9..84c20de2385 100644
--- a/boa/src/syntax/lexer/regex.rs
+++ b/boa/src/syntax/lexer/regex.rs
@@ -7,19 +7,14 @@ use crate::{
         ast::Position,
         lexer::{Token, TokenKind},
     },
-    Interner,
 };
 use bitflags::bitflags;
-use std::io::{self, ErrorKind};
-use std::str;
+use boa_interner::{Interner, Sym};
 use std::{
-    fmt::{self, Display, Formatter},
-    io::Read,
+    io::{self, ErrorKind, Read},
+    str,
 };
 
-#[cfg(feature = "deser")]
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
 /// Regex literal lexing.
 ///
 /// Lexes Division, Assigndiv or Regex literal.
@@ -122,7 +117,7 @@ impl<R> Tokenizer<R> for RegexLiteral {
             Ok(Token::new(
                 TokenKind::regular_expression_literal(
                     interner.get_or_intern(body_str),
-                    parse_regex_flags(flags_str, flags_start)?,
+                    parse_regex_flags(flags_str, flags_start, interner)?,
                 ),
                 Span::new(start_pos, cursor.pos()),
             ))
@@ -138,7 +133,7 @@ impl<R> Tokenizer<R> for RegexLiteral {
 bitflags! {
     /// Flags of a regular expression.
     #[derive(Default)]
-    pub struct RegExpFlags: u8 {
+    struct RegExpFlags: u8 {
         const GLOBAL = 0b0000_0001;
         const IGNORE_CASE = 0b0000_0010;
         const MULTILINE = 0b0000_0100;
@@ -148,7 +143,7 @@ bitflags! {
     }
 }
 
-pub(crate) fn parse_regex_flags(s: &str, start: Position) -> Result<RegExpFlags, Error> {
+fn parse_regex_flags(s: &str, start: Position, interner: &mut Interner) -> Result<Sym, Error> {
     let mut flags = RegExpFlags::default();
     for c in s.bytes() {
         let new_flag = match c {
@@ -166,88 +161,39 @@ pub(crate) fn parse_regex_flags(s: &str, start: Position) -> Result<RegExpFlags,
             }
         };
 
-        if !flags.contains(new_flag) {
-            flags.insert(new_flag);
-        } else {
+        if flags.contains(new_flag) {
             return Err(Error::syntax(
-                format!("invalid regular expression flag {}", char::from(c)),
+                format!("repeated regular expression flag {}", char::from(c)),
                 start,
             ));
+        } else {
+            flags.insert(new_flag);
         }
     }
-    Ok(flags)
+    Ok(interner.get_or_intern(flags.to_string()))
 }
 
-impl Display for RegExpFlags {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        use fmt::Write;
-
+impl ToString for RegExpFlags {
+    fn to_string(&self) -> String {
+        let mut s = String::new();
         if self.contains(Self::GLOBAL) {
-            f.write_char('g')?;
+            s.push('g');
         }
         if self.contains(Self::IGNORE_CASE) {
-            f.write_char('i')?;
+            s.push('i');
         }
         if self.contains(Self::MULTILINE) {
-            f.write_char('m')?;
+            s.push('m');
         }
         if self.contains(Self::DOT_ALL) {
-            f.write_char('s')?;
+            s.push('s');
         }
         if self.contains(Self::UNICODE) {
-            f.write_char('u')?;
+            s.push('u');
         }
         if self.contains(Self::STICKY) {
-            f.write_char('y')?;
-        }
-        Ok(())
-    }
-}
-
-#[cfg(feature = "deser")]
-impl Serialize for RegExpFlags {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-#[cfg(feature = "deser")]
-impl<'de> Deserialize<'de> for RegExpFlags {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        use serde::de::{self, Visitor};
-
-        /// Deserializer visitor implementation for `RegExpFlags`.
-        #[derive(Debug, Clone, Copy)]
-        struct RegExpFlagsVisitor;
-
-        impl<'de> Visitor<'de> for RegExpFlagsVisitor {
-            type Value = RegExpFlags;
-
-            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a string representing JavaScript regular expression flags")
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                parse_regex_flags(value, Position::new(0, 0)).map_err(E::custom)
-            }
-
-            fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                self.visit_str(&value)
-            }
+            s.push('y');
         }
-
-        deserializer.deserialize_str(RegExpFlagsVisitor)
+        s
     }
 }
diff --git a/boa/src/syntax/lexer/template.rs b/boa/src/syntax/lexer/template.rs
index 49f811bf128..a466f44c5b8 100644
--- a/boa/src/syntax/lexer/template.rs
+++ b/boa/src/syntax/lexer/template.rs
@@ -46,14 +46,9 @@ impl TemplateString {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-static-semantics-templatestrings
-    pub fn to_owned_cooked(self, interner: &Interner) -> Result<Box<str>, Error> {
-        let mut cursor = Cursor::with_position(
-            interner
-                .resolve(self.raw)
-                .expect("string disappeared")
-                .as_bytes(),
-            self.start_pos,
-        );
+    pub fn to_owned_cooked(self, interner: &mut Interner) -> Result<Sym, Error> {
+        let mut cursor =
+            Cursor::with_position(interner.resolve_expect(self.raw).as_bytes(), self.start_pos);
         let mut buf: Vec<u16> = Vec::new();
 
         loop {
@@ -83,7 +78,9 @@ impl TemplateString {
             }
         }
 
-        Ok(buf.to_string_lossy().into())
+        let str = buf.to_string_lossy();
+
+        Ok(interner.get_or_intern(&str))
     }
 }
 
diff --git a/boa/src/syntax/lexer/tests.rs b/boa/src/syntax/lexer/tests.rs
index d09134af836..a1087000de8 100644
--- a/boa/src/syntax/lexer/tests.rs
+++ b/boa/src/syntax/lexer/tests.rs
@@ -1,7 +1,9 @@
 //! Tests for the lexer.
 #![allow(clippy::indexing_slicing)]
 
-use super::regex::RegExpFlags;
+use boa_interner::Sym;
+
+// use super::regex::RegExpFlags;
 use super::token::Numeric;
 use super::*;
 use super::{Error, Position};
@@ -31,7 +33,7 @@ where
 fn check_single_line_comment() {
     let s1 = "var \n//This is a comment\ntrue";
     let mut lexer = Lexer::new(s1.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::Keyword(Keyword::Var),
@@ -47,7 +49,7 @@ fn check_single_line_comment() {
 fn check_single_line_comment_with_crlf_ending() {
     let s1 = "var \r\n//This is a comment\r\ntrue";
     let mut lexer = Lexer::new(s1.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::Keyword(Keyword::Var),
@@ -63,7 +65,7 @@ fn check_single_line_comment_with_crlf_ending() {
 fn check_multi_line_comment() {
     let s = "var /* await \n break \n*/ x";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("x");
     let expected = [
@@ -79,7 +81,7 @@ fn check_multi_line_comment() {
 fn check_identifier() {
     let s = "x x1 _x $x __ $$ Ѐ ЀЀ x\u{200C}\u{200D} \\u0078 \\u0078\\u0078 \\u{0078}x\\u{0078}";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::identifier(interner.get_or_intern_static("x")),
@@ -105,7 +107,7 @@ fn check_invalid_identifier_start() {
 
     for s in invalid_identifier_starts.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
         lexer
             .next(&mut interner)
             .expect_err("Invalid identifier start not rejected as expected");
@@ -115,13 +117,13 @@ fn check_invalid_identifier_start() {
 #[test]
 fn check_invalid_identifier_part() {
     let invalid_identifier_parts = [" ", "\n", ".", "*", "😀", "\u{007F}"];
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("x");
     for part in invalid_identifier_parts.iter() {
         let s = String::from("x") + part;
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
         assert_eq!(
             lexer.next(&mut interner).unwrap().unwrap().kind(),
             &TokenKind::identifier(sym)
@@ -133,7 +135,7 @@ fn check_invalid_identifier_part() {
 fn check_string() {
     let s = "'aaa' \"bbb\"";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let a_sym = interner.get_or_intern_static("aaa");
     let b_sym = interner.get_or_intern_static("bbb");
@@ -149,7 +151,7 @@ fn check_string() {
 fn check_template_literal_simple() {
     let s = "`I'm a template literal`";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("I'm a template literal");
 
@@ -163,7 +165,7 @@ fn check_template_literal_simple() {
 fn check_template_literal_unterminated() {
     let s = "`I'm a template";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     lexer
         .next(&mut interner)
@@ -177,7 +179,7 @@ fn check_punctuators() {
              + - * % -- << >> >>> & | ^ ! ~ && || ? : \
              = += -= *= &= **= ++ ** <<= >>= >>>= &= |= ^= => ?? ??= &&= ||=";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::Punctuator(Punctuator::OpenBlock),
@@ -246,7 +248,7 @@ fn check_keywords() {
              new return super switch this throw try typeof var void while with yield";
 
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::Keyword(Keyword::Await),
@@ -292,7 +294,7 @@ fn check_keywords() {
 fn check_variable_definition_tokens() {
     let s = "let a = 'hello';";
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let a_sym = interner.get_or_intern_static("a");
     let hello_sym = interner.get_or_intern_static("hello");
@@ -312,7 +314,7 @@ fn check_positions() {
     let s = r#"console.log("hello world"); // Test"#;
     // --------123456789
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     // The first column is 1 (not zero indexed)
     assert_eq!(
@@ -362,7 +364,7 @@ fn check_positions_codepoint() {
     let s = r#"console.log("hello world\u{2764}"); // Test"#;
     // --------123456789
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     // The first column is 1 (not zero indexed)
     assert_eq!(
@@ -412,7 +414,7 @@ fn check_line_numbers() {
     let s = "x\ny\n";
 
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert_eq!(
         lexer.next(&mut interner).unwrap().unwrap().span(),
@@ -437,7 +439,7 @@ fn check_line_numbers() {
 fn check_decrement_advances_lexer_2_places() {
     // Here we want an example of decrementing an integer
     let mut lexer = Lexer::new(&b"let a = b--;"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     for _ in 0..4 {
         lexer.next(&mut interner).unwrap();
@@ -459,7 +461,7 @@ fn check_decrement_advances_lexer_2_places() {
 #[test]
 fn single_int() {
     let mut lexer = Lexer::new(&b"52"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [TokenKind::numeric_literal(52)];
 
@@ -472,7 +474,7 @@ fn numbers() {
         "1 2 0x34 056 7.89 42. 5e3 5e+3 5e-3 0b10 0O123 0999 1.0e1 1.0e-1 1.0E1 1E1 0.0 0.12 -32"
             .as_bytes(),
     );
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -505,7 +507,7 @@ fn numbers_with_separators() {
     let mut lexer = Lexer::new(
         "1_0 2_0 0x3_4 056 7.8_9 4_2. 5_0e2 5_0e+2 5_0e-4 0b1_0 1_0.0_0e2 1.0E-0_1 -3_2".as_bytes(),
     );
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(10),
@@ -535,7 +537,7 @@ fn numbers_with_bad_separators() {
 
     for n in numbers.iter() {
         let mut lexer = Lexer::new(n.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
         assert!(lexer.next(&mut interner).is_err());
     }
 }
@@ -543,7 +545,7 @@ fn numbers_with_bad_separators() {
 #[test]
 fn big_exp_numbers() {
     let mut lexer = Lexer::new(&b"1.0e25 1.0e36 9.0e50"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(10000000000000000000000000.0),
@@ -555,10 +557,9 @@ fn big_exp_numbers() {
 }
 
 #[test]
-#[ignore]
 fn big_literal_numbers() {
     let mut lexer = Lexer::new(&b"10000000000000000000000000"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [TokenKind::numeric_literal(10000000000000000000000000.0)];
 
@@ -568,7 +569,7 @@ fn big_literal_numbers() {
 #[test]
 fn implicit_octal_edge_case() {
     let mut lexer = Lexer::new(&b"044.5 094.5"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(36),
@@ -582,7 +583,7 @@ fn implicit_octal_edge_case() {
 #[test]
 fn hexadecimal_edge_case() {
     let mut lexer = Lexer::new(&b"0xffff.ff 0xffffff"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("ff");
     let expected = [
@@ -598,7 +599,7 @@ fn hexadecimal_edge_case() {
 #[test]
 fn single_number_without_semicolon() {
     let mut lexer = Lexer::new(&b"1"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     if let Some(x) = lexer.next(&mut interner).unwrap() {
         assert_eq!(x.kind(), &TokenKind::numeric_literal(Numeric::Integer(1)));
@@ -610,7 +611,7 @@ fn single_number_without_semicolon() {
 #[test]
 fn number_followed_by_dot() {
     let mut lexer = Lexer::new(&b"1.."[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -623,12 +624,11 @@ fn number_followed_by_dot() {
 #[test]
 fn regex_literal() {
     let mut lexer = Lexer::new(&b"/(?:)/"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
-    let sym = interner.get_or_intern_static("(?:)");
     let expected = [TokenKind::regular_expression_literal(
-        sym,
-        RegExpFlags::default(),
+        interner.get_or_intern_static("(?:)"),
+        Sym::EMPTY_STRING,
     )];
 
     expect_tokens(&mut lexer, &expected, &mut interner);
@@ -637,23 +637,37 @@ fn regex_literal() {
 #[test]
 fn regex_literal_flags() {
     let mut lexer = Lexer::new(&br"/\/[^\/]*\/*/gmi"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
-    let mut flags = RegExpFlags::default();
-    flags.insert(RegExpFlags::GLOBAL);
-    flags.insert(RegExpFlags::MULTILINE);
-    flags.insert(RegExpFlags::IGNORE_CASE);
-
-    let sym = interner.get_or_intern_static("\\/[^\\/]*\\/*");
-    let expected = [TokenKind::regular_expression_literal(sym, flags)];
+    let expected = [TokenKind::regular_expression_literal(
+        interner.get_or_intern_static("\\/[^\\/]*\\/*"),
+        interner.get_or_intern_static("gim"),
+    )];
 
     expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
+#[test]
+fn regex_literal_flags_err() {
+    let mut lexer = Lexer::new(&br"/\/[^\/]*\/*/gmip"[..]);
+    let mut interner = Interner::default();
+
+    lexer
+        .next(&mut interner)
+        .expect_err("Lexer did not handle regex literal with error");
+
+    let mut lexer = Lexer::new(&br"/\/[^\/]*\/*/gmii"[..]);
+    let mut interner = Interner::default();
+
+    lexer
+        .next(&mut interner)
+        .expect_err("Lexer did not handle regex literal with error");
+}
+
 #[test]
 fn addition_no_spaces() {
     let mut lexer = Lexer::new(&b"1+1"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -667,7 +681,7 @@ fn addition_no_spaces() {
 #[test]
 fn addition_no_spaces_left_side() {
     let mut lexer = Lexer::new(&b"1+ 1"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -681,7 +695,7 @@ fn addition_no_spaces_left_side() {
 #[test]
 fn addition_no_spaces_right_side() {
     let mut lexer = Lexer::new(&b"1 +1"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -695,7 +709,7 @@ fn addition_no_spaces_right_side() {
 #[test]
 fn addition_no_spaces_e_number_left_side() {
     let mut lexer = Lexer::new(&b"1e2+ 1"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(100),
@@ -709,7 +723,7 @@ fn addition_no_spaces_e_number_left_side() {
 #[test]
 fn addition_no_spaces_e_number_right_side() {
     let mut lexer = Lexer::new(&b"1 +1e3"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -723,7 +737,7 @@ fn addition_no_spaces_e_number_right_side() {
 #[test]
 fn addition_no_spaces_e_number() {
     let mut lexer = Lexer::new(&b"1e3+1e11"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let expected = [
         TokenKind::numeric_literal(1000),
@@ -840,7 +854,7 @@ fn illegal_following_numeric_literal() {
 
     // Decimal Digit
     let mut lexer = Lexer::new(&b"11.6n3"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let err = lexer
         .next(&mut interner)
@@ -853,7 +867,7 @@ fn illegal_following_numeric_literal() {
 
     // Identifier Start
     let mut lexer = Lexer::new(&b"17.4$"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     if let Error::Syntax(_, pos) = lexer
         .next(&mut interner)
@@ -865,7 +879,7 @@ fn illegal_following_numeric_literal() {
     }
 
     let mut lexer = Lexer::new(&b"17.4_"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     if let Error::Syntax(_, pos) = lexer
         .next(&mut interner)
@@ -880,7 +894,7 @@ fn illegal_following_numeric_literal() {
 #[test]
 fn string_codepoint_with_no_braces() {
     let mut lexer = Lexer::new(&br#""test\uD38Dtest""#[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert!(lexer.next(&mut interner).is_ok());
 }
@@ -891,7 +905,7 @@ fn illegal_code_point_following_numeric_literal() {
     // Checks as per https://tc39.es/ecma262/#sec-literals-numeric-literals that a NumericLiteral cannot
     // be immediately followed by an IdentifierStart where the IdentifierStart
     let mut lexer = Lexer::new(&br#"17.4\u{2764}"#[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert!(
         lexer.next(&mut interner).is_err(),
@@ -905,7 +919,7 @@ fn string_unicode() {
     let s = r#"'中文';"#;
 
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("中文");
     let expected = [
@@ -919,7 +933,7 @@ fn string_unicode() {
 #[test]
 fn string_unicode_escape_with_braces() {
     let mut lexer = Lexer::new(&br#"'{\u{20ac}\u{a0}\u{a0}}'"#[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("{\u{20ac}\u{a0}\u{a0}}");
     let expected = [TokenKind::StringLiteral(sym)];
@@ -954,7 +968,7 @@ fn string_unicode_escape_with_braces_2() {
     let s = r#"'\u{20ac}\u{a0}\u{a0}'"#;
 
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("\u{20ac}\u{a0}\u{a0}");
     let expected = [TokenKind::StringLiteral(sym)];
@@ -967,7 +981,7 @@ fn string_with_single_escape() {
     let s = r#"'\Б'"#;
 
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("Б");
     let expected = [TokenKind::StringLiteral(sym)];
@@ -989,7 +1003,7 @@ fn string_legacy_octal_escape() {
 
     for (s, expected) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
 
         let sym = interner.get_or_intern(expected);
         let expected_tokens = [TokenKind::StringLiteral(sym)];
@@ -999,7 +1013,7 @@ fn string_legacy_octal_escape() {
 
     for (s, _) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
         lexer.set_strict_mode(true);
 
         if let Error::Syntax(_, pos) = lexer
@@ -1019,7 +1033,7 @@ fn string_zero_escape() {
 
     for (s, expected) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
 
         let sym = interner.get_or_intern(expected);
         let expected_tokens = [TokenKind::StringLiteral(sym)];
@@ -1034,7 +1048,7 @@ fn string_non_octal_decimal_escape() {
 
     for (s, expected) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
 
         let sym = interner.get_or_intern(expected);
         let expected_tokens = [TokenKind::StringLiteral(sym)];
@@ -1044,7 +1058,7 @@ fn string_non_octal_decimal_escape() {
 
     for (s, _) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
         lexer.set_strict_mode(true);
 
         if let Error::Syntax(_, pos) = lexer
@@ -1063,7 +1077,7 @@ fn string_line_continuation() {
     let s = "'hello \\\nworld'";
 
     let mut lexer = Lexer::new(s.as_bytes());
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let sym = interner.get_or_intern_static("hello world");
     let expected_tokens = [TokenKind::StringLiteral(sym)];
@@ -1076,7 +1090,7 @@ mod carriage_return {
 
     fn expect_tokens_with_lines(lines: usize, src: &str) {
         let mut lexer = Lexer::new(src.as_bytes());
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
 
         let mut expected = Vec::with_capacity(lines + 2);
         expected.push(TokenKind::Punctuator(Punctuator::Sub));
diff --git a/boa/src/syntax/lexer/token.rs b/boa/src/syntax/lexer/token.rs
index 17a2bb37e1f..259b33e5879 100644
--- a/boa/src/syntax/lexer/token.rs
+++ b/boa/src/syntax/lexer/token.rs
@@ -5,8 +5,6 @@
 //!
 //! [spec]: https://tc39.es/ecma262/#sec-tokens
 
-use super::regex::RegExpFlags;
-
 use crate::{
     syntax::ast::{Keyword, Punctuator, Span},
     syntax::lexer::template::TemplateString,
@@ -54,6 +52,11 @@ impl Token {
     pub(crate) fn to_string(&self, interner: &Interner) -> String {
         self.kind.to_string(interner)
     }
+
+    /// Converts the token to a string interner symbol.
+    pub(crate) fn to_sym(&self, interner: &mut Interner) -> Sym {
+        self.kind.to_sym(interner)
+    }
 }
 
 /// Represents the type differenct types of numeric literals.
@@ -126,7 +129,7 @@ pub enum TokenKind {
     TemplateMiddle(TemplateString),
 
     /// A regular expression, consisting of body and flags.
-    RegularExpressionLiteral(Sym, RegExpFlags),
+    RegularExpressionLiteral(Sym, Sym),
 
     /// Indicates the end of a line (`\n`).
     LineTerminator,
@@ -207,11 +210,8 @@ impl TokenKind {
     }
 
     /// Creates a `RegularExpressionLiteral` token kind.
-    pub fn regular_expression_literal<R>(body: Sym, flags: R) -> Self
-    where
-        R: Into<RegExpFlags>,
-    {
-        Self::RegularExpressionLiteral(body, flags.into())
+    pub fn regular_expression_literal(body: Sym, flags: Sym) -> Self {
+        Self::RegularExpressionLiteral(body, flags)
     }
 
     /// Creates a `LineTerminator` token kind.
@@ -227,39 +227,49 @@ impl TokenKind {
     /// Implements the `ToString` functionality for the `TokenKind`.
     pub fn to_string(&self, interner: &Interner) -> String {
         match *self {
-            Self::BooleanLiteral(ref val) => val.to_string(),
+            Self::BooleanLiteral(val) => val.to_string(),
             Self::EOF => "end of file".to_owned(),
-            Self::Identifier(ident) => interner
-                .resolve(ident)
-                .expect("string disappeared")
-                .to_owned(),
-            Self::Keyword(ref word) => word.to_string(),
+            Self::Identifier(ident) => interner.resolve_expect(ident).to_owned(),
+            Self::Keyword(word) => word.to_string(),
             Self::NullLiteral => "null".to_owned(),
             Self::NumericLiteral(Numeric::Rational(num)) => num.to_string(),
             Self::NumericLiteral(Numeric::Integer(num)) => num.to_string(),
             Self::NumericLiteral(Numeric::BigInt(ref num)) => format!("{}n", num),
-            Self::Punctuator(ref punc) => punc.to_string(),
-            Self::StringLiteral(lit) => interner
-                .resolve(lit)
-                .expect("string disappeared")
-                .to_owned(),
-            Self::TemplateNoSubstitution(ref ts) => interner
-                .resolve(ts.as_raw())
-                .expect("string disappeared")
-                .to_owned(),
-            Self::TemplateMiddle(ref ts) => interner
-                .resolve(ts.as_raw())
-                .expect("string disappeared")
-                .to_owned(),
-            Self::RegularExpressionLiteral(body, ref flags) => {
+            Self::Punctuator(punc) => punc.to_string(),
+            Self::StringLiteral(lit) => interner.resolve_expect(lit).to_owned(),
+            Self::TemplateNoSubstitution(ts) | Self::TemplateMiddle(ts) => {
+                interner.resolve_expect(ts.as_raw()).to_owned()
+            }
+            Self::RegularExpressionLiteral(body, flags) => {
                 format!(
                     "/{}/{}",
-                    interner.resolve(body).expect("string disappeared"),
-                    flags
+                    interner.resolve_expect(body),
+                    interner.resolve_expect(flags),
                 )
             }
             Self::LineTerminator => "line terminator".to_owned(),
             Self::Comment => "comment".to_owned(),
         }
     }
+
+    /// Converts the token to a string interner symbol.
+    ///
+    /// This is an optimization to avoid resolving + re-interning strings.
+    pub(crate) fn to_sym(&self, interner: &mut Interner) -> Sym {
+        match *self {
+            Self::BooleanLiteral(_)
+            | Self::NumericLiteral(_)
+            | Self::RegularExpressionLiteral(_, _) => {
+                interner.get_or_intern(&self.to_string(interner))
+            }
+            Self::EOF => interner.get_or_intern_static("end of file"),
+            Self::Identifier(sym) | Self::StringLiteral(sym) => sym,
+            Self::Keyword(word) => interner.get_or_intern_static(word.as_str()),
+            Self::NullLiteral => Sym::NULL,
+            Self::Punctuator(punc) => interner.get_or_intern_static(punc.as_str()),
+            Self::TemplateNoSubstitution(ts) | Self::TemplateMiddle(ts) => ts.as_raw(),
+            Self::LineTerminator => interner.get_or_intern_static("line terminator"),
+            Self::Comment => interner.get_or_intern_static("comment"),
+        }
+    }
 }
diff --git a/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs b/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs
index 04917e276d3..57e0fd53dcd 100644
--- a/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs
+++ b/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs
@@ -7,7 +7,7 @@ use crate::{
 #[test]
 fn peek_skip_accending() {
     let mut cur = BufferedLexer::from(&b"a b c d e f g h i"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert_eq!(
         *cur.peek(0, false, &mut interner)
@@ -56,7 +56,7 @@ fn peek_skip_accending() {
 #[test]
 fn peek_skip_next() {
     let mut cur = BufferedLexer::from(&b"a b c d e f g h i"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert_eq!(
         *cur.peek(0, false, &mut interner)
@@ -140,7 +140,7 @@ fn peek_skip_next() {
 #[test]
 fn peek_skip_next_alternating() {
     let mut cur = BufferedLexer::from(&b"a b c d e f g h i"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert_eq!(
         *cur.peek(0, false, &mut interner)
@@ -196,7 +196,7 @@ fn peek_skip_next_alternating() {
 #[test]
 fn peek_next_till_end() {
     let mut cur = BufferedLexer::from(&b"a b c d e f g h i"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     loop {
         let peek = cur.peek(0, false, &mut interner).unwrap().cloned();
@@ -213,7 +213,7 @@ fn peek_next_till_end() {
 #[test]
 fn peek_skip_next_till_end() {
     let mut cur = BufferedLexer::from(&b"a b c d e f g h i"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let mut peeked: [Option<Token>; super::MAX_PEEK_SKIP + 1] =
         [None::<Token>, None::<Token>, None::<Token>, None::<Token>];
@@ -236,7 +236,7 @@ fn peek_skip_next_till_end() {
 #[test]
 fn skip_peeked_terminators() {
     let mut cur = BufferedLexer::from(&b"A \n B"[..]);
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     assert_eq!(
         *cur.peek(0, false, &mut interner)
diff --git a/boa/src/syntax/parser/expression/assignment/arrow_function.rs b/boa/src/syntax/parser/expression/assignment/arrow_function.rs
index fc373bff7dd..84b92444c92 100644
--- a/boa/src/syntax/parser/expression/assignment/arrow_function.rs
+++ b/boa/src/syntax/parser/expression/assignment/arrow_function.rs
@@ -139,12 +139,16 @@ where
         // also occurs in the LexicallyDeclaredNames of ConciseBody.
         // https://tc39.es/ecma262/#sec-arrow-function-definitions-static-semantics-early-errors
         {
-            let lexically_declared_names = body.lexically_declared_names();
+            let lexically_declared_names = body.lexically_declared_names(interner);
             for param in params.parameters.as_ref() {
-                for param_name in param.names() {
-                    if lexically_declared_names.contains(param_name) {
+                for param_name in param.names().into_iter() {
+                    if lexically_declared_names.contains(&param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
-                            format!("Redeclaration of formal parameter `{}`", param_name).into(),
+                            format!(
+                                "Redeclaration of formal parameter `{}`",
+                                interner.resolve_expect(param_name)
+                            )
+                            .into(),
                             match cursor.peek(0, interner)? {
                                 Some(token) => token.span().end(),
                                 None => Position::new(1, 1),
diff --git a/boa/src/syntax/parser/expression/left_hand_side/call.rs b/boa/src/syntax/parser/expression/left_hand_side/call.rs
index b6533f20ad7..2e96a4b9e22 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/call.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/call.rs
@@ -92,19 +92,12 @@ where
                 TokenKind::Punctuator(Punctuator::Dot) => {
                     cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?; // We move the parser forward.
 
-                    match &cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    match cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?.kind() {
                         TokenKind::Identifier(name) => {
-                            lhs = GetConstField::new(
-                                lhs,
-                                interner
-                                    .resolve(*name)
-                                    .expect("string disappeared")
-                                    .to_owned(),
-                            )
-                            .into();
+                            lhs = GetConstField::new(lhs, *name).into();
                         }
                         TokenKind::Keyword(kw) => {
-                            lhs = GetConstField::new(lhs, kw.to_string()).into();
+                            lhs = GetConstField::new(lhs, kw.to_sym(interner)).into();
                         }
                         _ => {
                             return Err(ParseError::expected(
diff --git a/boa/src/syntax/parser/expression/left_hand_side/member.rs b/boa/src/syntax/parser/expression/left_hand_side/member.rs
index 0c8300f8d70..9d945072910 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/member.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/member.rs
@@ -94,15 +94,9 @@ where
                     let token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
                     match token.kind() {
-                        TokenKind::Identifier(name) => {
-                            lhs = GetConstField::new(
-                                lhs,
-                                interner.resolve(*name).expect("string disappeared"),
-                            )
-                            .into()
-                        }
+                        TokenKind::Identifier(name) => lhs = GetConstField::new(lhs, *name).into(),
                         TokenKind::Keyword(kw) => {
-                            lhs = GetConstField::new(lhs, kw.to_string()).into()
+                            lhs = GetConstField::new(lhs, kw.to_sym(interner)).into()
                         }
                         _ => {
                             return Err(ParseError::expected(
diff --git a/boa/src/syntax/parser/expression/left_hand_side/template.rs b/boa/src/syntax/parser/expression/left_hand_side/template.rs
index 48a1b39d391..69a1cf4d7ff 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/template.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/template.rs
@@ -61,13 +61,7 @@ where
         loop {
             match token.kind() {
                 TokenKind::TemplateMiddle(template_string) => {
-                    raws.push(
-                        interner
-                            .resolve(template_string.as_raw())
-                            .expect("string disappeared")
-                            .to_owned()
-                            .into_boxed_str(),
-                    );
+                    raws.push(template_string.as_raw());
                     cookeds.push(template_string.to_owned_cooked(interner).ok());
                     exprs.push(
                         Expression::new(true, self.allow_yield, self.allow_await)
@@ -80,13 +74,7 @@ where
                     )?;
                 }
                 TokenKind::TemplateNoSubstitution(template_string) => {
-                    raws.push(
-                        interner
-                            .resolve(template_string.as_raw())
-                            .expect("string disappeared")
-                            .to_owned()
-                            .into_boxed_str(),
-                    );
+                    raws.push(template_string.as_raw());
                     cookeds.push(template_string.to_owned_cooked(interner).ok());
                     return Ok(Node::from(TaggedTemplate::new(
                         self.tag, raws, cookeds, exprs,
diff --git a/boa/src/syntax/parser/expression/primary/array_initializer/tests.rs b/boa/src/syntax/parser/expression/primary/array_initializer/tests.rs
index c2f75aa96b3..c36aaa544ed 100644
--- a/boa/src/syntax/parser/expression/primary/array_initializer/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/array_initializer/tests.rs
@@ -1,5 +1,7 @@
 // ! Tests for array initializer parsing.
 
+use boa_interner::Sym;
+
 use crate::{
     syntax::{
         ast::{node::ArrayDecl, Const},
@@ -11,14 +13,14 @@ use crate::{
 /// Checks an empty array.
 #[test]
 fn check_empty() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser("[]", vec![ArrayDecl::from(vec![]).into()], &mut interner);
 }
 
 /// Checks an array with empty slot.
 #[test]
 fn check_empty_slot() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[,]",
         vec![ArrayDecl::from(vec![Const::Undefined.into()]).into()],
@@ -29,7 +31,7 @@ fn check_empty_slot() {
 /// Checks a numeric array.
 #[test]
 fn check_numeric_array() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[1, 2, 3]",
         vec![ArrayDecl::from(vec![
@@ -45,7 +47,7 @@ fn check_numeric_array() {
 // Checks a numeric array with trailing comma
 #[test]
 fn check_numeric_array_trailing() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[1, 2, 3,]",
         vec![ArrayDecl::from(vec![
@@ -61,7 +63,7 @@ fn check_numeric_array_trailing() {
 /// Checks a numeric array with an elision.
 #[test]
 fn check_numeric_array_elision() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[1, 2, , 3]",
         vec![ArrayDecl::from(vec![
@@ -78,7 +80,7 @@ fn check_numeric_array_elision() {
 /// Checks a numeric array with repeated elisions.
 #[test]
 fn check_numeric_array_repeated_elision() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[1, 2, ,, 3]",
         vec![ArrayDecl::from(vec![
@@ -96,12 +98,12 @@ fn check_numeric_array_repeated_elision() {
 /// Checks a combined array.
 #[test]
 fn check_combined() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[1, \"a\", 2]",
         vec![ArrayDecl::from(vec![
             Const::from(1).into(),
-            Const::from("a").into(),
+            Const::from(interner.get_or_intern_static("a")).into(),
             Const::from(2).into(),
         ])
         .into()],
@@ -112,12 +114,12 @@ fn check_combined() {
 /// Checks a combined array with an empty string
 #[test]
 fn check_combined_empty_str() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "[1, \"\", 2]",
         vec![ArrayDecl::from(vec![
             Const::from(1).into(),
-            Const::from("").into(),
+            Const::from(Sym::EMPTY_STRING).into(),
             Const::from(2).into(),
         ])
         .into()],
diff --git a/boa/src/syntax/parser/expression/primary/async_function_expression/mod.rs b/boa/src/syntax/parser/expression/primary/async_function_expression/mod.rs
index 045d820e241..b1d6f4418ab 100644
--- a/boa/src/syntax/parser/expression/primary/async_function_expression/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/async_function_expression/mod.rs
@@ -1,6 +1,8 @@
 #[cfg(test)]
 mod tests;
 
+use boa_interner::Sym;
+
 use crate::{
     syntax::{
         ast::{node::AsyncFunctionExpr, Keyword, Punctuator},
@@ -69,8 +71,8 @@ where
 
         // Early Error: If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code,
         // it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
-        if let Some(name) = &name {
-            if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
+        if let Some(name) = name {
+            if cursor.strict_mode() && [Sym::EVAL, Sym::ARGUMENTS].contains(&name) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
                     match cursor.peek(0, interner)? {
@@ -125,12 +127,16 @@ where
         // also occurs in the LexicallyDeclaredNames of FunctionBody.
         // https://tc39.es/ecma262/#sec-function-definitions-static-semantics-early-errors
         {
-            let lexically_declared_names = body.lexically_declared_names();
+            let lexically_declared_names = body.lexically_declared_names(interner);
             for param in params.parameters.as_ref() {
                 for param_name in param.names() {
-                    if lexically_declared_names.contains(param_name) {
+                    if lexically_declared_names.contains(&param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
-                            format!("Redeclaration of formal parameter `{}`", param_name).into(),
+                            format!(
+                                "Redeclaration of formal parameter `{}`",
+                                interner.resolve_expect(param_name)
+                            )
+                            .into(),
                             match cursor.peek(0, interner)? {
                                 Some(token) => token.span().end(),
                                 None => Position::new(1, 1),
diff --git a/boa/src/syntax/parser/expression/primary/async_function_expression/tests.rs b/boa/src/syntax/parser/expression/primary/async_function_expression/tests.rs
index ee4a12825a1..7bcfb50ed42 100644
--- a/boa/src/syntax/parser/expression/primary/async_function_expression/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/async_function_expression/tests.rs
@@ -12,7 +12,7 @@ use crate::{
 /// Checks async expression parsing.
 #[test]
 fn check_async_expression() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const add = async function() {
             return 1;
@@ -20,13 +20,12 @@ fn check_async_expression() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "add",
+                interner.get_or_intern_static("add"),
                 Some(
-                    AsyncFunctionExpr::new::<Option<Box<str>>, _, StatementList>(
+                    AsyncFunctionExpr::new::<_, _, StatementList>(
                         None,
                         [],
-                        vec![Return::new::<_, _, Option<Box<str>>>(Const::from(1), None).into()]
-                            .into(),
+                        vec![Return::new(Const::from(1), None).into()].into(),
                     )
                     .into(),
                 ),
@@ -40,7 +39,7 @@ fn check_async_expression() {
 
 #[test]
 fn check_nested_async_expression() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const a = async function() {
             const b = async function() {
@@ -50,24 +49,19 @@ fn check_nested_async_expression() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Some(
-                    AsyncFunctionExpr::new::<Option<Box<str>>, _, StatementList>(
+                    AsyncFunctionExpr::new::<_, _, StatementList>(
                         None,
                         [],
                         vec![DeclarationList::Const(
                             vec![Declaration::new_with_identifier(
-                                "b",
+                                interner.get_or_intern_static("b"),
                                 Some(
-                                    AsyncFunctionExpr::new::<Option<Box<str>>, _, StatementList>(
+                                    AsyncFunctionExpr::new::<_, _, StatementList>(
                                         None,
                                         [],
-                                        vec![Return::new::<_, _, Option<Box<str>>>(
-                                            Const::from(1),
-                                            None,
-                                        )
-                                        .into()]
-                                        .into(),
+                                        vec![Return::new(Const::from(1), None).into()].into(),
                                     )
                                     .into(),
                                 ),
diff --git a/boa/src/syntax/parser/expression/primary/async_generator_expression/mod.rs b/boa/src/syntax/parser/expression/primary/async_generator_expression/mod.rs
index 23c9fc1214c..3069f018e1b 100644
--- a/boa/src/syntax/parser/expression/primary/async_generator_expression/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/async_generator_expression/mod.rs
@@ -8,7 +8,9 @@
 //!
 //! [spec]: https://tc39.es/ecma262/#prod-AsyncGeneratorExpression
 #[cfg(test)]
-mod test;
+mod tests;
+
+use boa_interner::Sym;
 
 use crate::{
     syntax::{
@@ -67,8 +69,8 @@ where
 
         // Early Error: If BindingIdentifier is present and the source code matching BindingIdentifier is strict
         // mode code, it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
-        if let Some(name) = &name {
-            if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
+        if let Some(name) = name {
+            if cursor.strict_mode() && [Sym::EVAL, Sym::ARGUMENTS].contains(&name) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
                     match cursor.peek(0, interner)? {
@@ -130,12 +132,16 @@ where
         // It is a Syntax Error if any element of the BoundNames of FormalParameters
         // also occurs in the LexicallyDeclaredNames of FunctionBody.
         {
-            let lexically_declared_names = body.lexically_declared_names();
+            let lexically_declared_names = body.lexically_declared_names(interner);
             for param in params.parameters.as_ref() {
                 for param_name in param.names() {
-                    if lexically_declared_names.contains(param_name) {
+                    if lexically_declared_names.contains(&param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
-                            format!("Redeclaration of formal parameter `{}`", param_name).into(),
+                            format!(
+                                "Redeclaration of formal parameter `{}`",
+                                interner.resolve_expect(param_name)
+                            )
+                            .into(),
                             match cursor.peek(0, interner)? {
                                 Some(token) => token.span().end(),
                                 None => Position::new(1, 1),
diff --git a/boa/src/syntax/parser/expression/primary/async_generator_expression/test.rs b/boa/src/syntax/parser/expression/primary/async_generator_expression/tests.rs
similarity index 67%
rename from boa/src/syntax/parser/expression/primary/async_generator_expression/test.rs
rename to boa/src/syntax/parser/expression/primary/async_generator_expression/tests.rs
index 7c790717a2a..3ee20f92c5b 100644
--- a/boa/src/syntax/parser/expression/primary/async_generator_expression/test.rs
+++ b/boa/src/syntax/parser/expression/primary/async_generator_expression/tests.rs
@@ -13,7 +13,7 @@ use crate::{
 
 #[test]
 fn check_async_generator_expr() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const add = async function*(){
             return 1;
@@ -21,13 +21,12 @@ fn check_async_generator_expr() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "add",
+                interner.get_or_intern_static("add"),
                 Some(
-                    AsyncGeneratorExpr::new::<Option<Box<str>>, _, StatementList>(
+                    AsyncGeneratorExpr::new::<_, _, StatementList>(
                         None,
                         [],
-                        vec![Return::new::<_, _, Option<Box<str>>>(Const::from(1), None).into()]
-                            .into(),
+                        vec![Return::new(Const::from(1), None).into()].into(),
                     )
                     .into(),
                 ),
@@ -41,7 +40,7 @@ fn check_async_generator_expr() {
 
 #[test]
 fn check_nested_async_generator_expr() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const a = async function*() {
             const b = async function*() {
@@ -51,24 +50,19 @@ fn check_nested_async_generator_expr() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Some(
-                    AsyncGeneratorExpr::new::<Option<Box<str>>, _, StatementList>(
+                    AsyncGeneratorExpr::new::<_, _, StatementList>(
                         None,
                         [],
                         vec![DeclarationList::Const(
                             vec![Declaration::new_with_identifier(
-                                "b",
+                                interner.get_or_intern_static("b"),
                                 Some(
-                                    AsyncGeneratorExpr::new::<Option<Box<str>>, _, StatementList>(
+                                    AsyncGeneratorExpr::new::<_, _, StatementList>(
                                         None,
                                         [],
-                                        vec![Return::new::<_, _, Option<Box<str>>>(
-                                            Const::from(1),
-                                            None,
-                                        )
-                                        .into()]
-                                        .into(),
+                                        vec![Return::new(Const::from(1), None).into()].into(),
                                     )
                                     .into(),
                                 ),
diff --git a/boa/src/syntax/parser/expression/primary/function_expression/mod.rs b/boa/src/syntax/parser/expression/primary/function_expression/mod.rs
index 52b43a9d1ca..487ea69d92a 100644
--- a/boa/src/syntax/parser/expression/primary/function_expression/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/function_expression/mod.rs
@@ -10,6 +10,8 @@
 #[cfg(test)]
 mod tests;
 
+use boa_interner::Sym;
+
 use crate::{
     syntax::{
         ast::{node::FunctionExpr, Keyword, Punctuator},
@@ -65,7 +67,7 @@ where
         // Early Error: If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code,
         // it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
         if let Some(name) = &name {
-            if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
+            if cursor.strict_mode() && [Sym::EVAL, Sym::ARGUMENTS].contains(name) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
                     match cursor.peek(0, interner)? {
@@ -112,12 +114,16 @@ where
         // also occurs in the LexicallyDeclaredNames of FunctionBody.
         // https://tc39.es/ecma262/#sec-function-definitions-static-semantics-early-errors
         {
-            let lexically_declared_names = body.lexically_declared_names();
+            let lexically_declared_names = body.lexically_declared_names(interner);
             for param in params.parameters.as_ref() {
                 for param_name in param.names() {
-                    if lexically_declared_names.contains(param_name) {
+                    if lexically_declared_names.contains(&param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
-                            format!("Redeclaration of formal parameter `{}`", param_name).into(),
+                            format!(
+                                "Redeclaration of formal parameter `{}`",
+                                interner.resolve_expect(param_name)
+                            )
+                            .into(),
                             match cursor.peek(0, interner)? {
                                 Some(token) => token.span().end(),
                                 None => Position::new(1, 1),
diff --git a/boa/src/syntax/parser/expression/primary/function_expression/tests.rs b/boa/src/syntax/parser/expression/primary/function_expression/tests.rs
index 132eb3612a8..bf20ec78983 100644
--- a/boa/src/syntax/parser/expression/primary/function_expression/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/function_expression/tests.rs
@@ -12,7 +12,7 @@ use crate::{
 /// Checks async expression parsing.
 #[test]
 fn check_function_expression() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const add = function() {
             return 1;
@@ -20,13 +20,12 @@ fn check_function_expression() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "add",
+                interner.get_or_intern_static("add"),
                 Some(
-                    FunctionExpr::new::<Option<Box<str>>, _, StatementList>(
+                    FunctionExpr::new::<_, _, StatementList>(
                         None,
                         [],
-                        vec![Return::new::<_, _, Option<Box<str>>>(Const::from(1), None).into()]
-                            .into(),
+                        vec![Return::new(Const::from(1), None).into()].into(),
                     )
                     .into(),
                 ),
@@ -40,7 +39,7 @@ fn check_function_expression() {
 
 #[test]
 fn check_nested_function_expression() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const a = function() {
             const b = function() {
@@ -50,24 +49,19 @@ fn check_nested_function_expression() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Some(
-                    FunctionExpr::new::<Option<Box<str>>, _, StatementList>(
+                    FunctionExpr::new::<_, _, StatementList>(
                         None,
                         [],
                         vec![DeclarationList::Const(
                             vec![Declaration::new_with_identifier(
-                                "b",
+                                interner.get_or_intern_static("b"),
                                 Some(
-                                    FunctionExpr::new::<Option<Box<str>>, _, StatementList>(
+                                    FunctionExpr::new::<_, _, StatementList>(
                                         None,
                                         [],
-                                        vec![Return::new::<_, _, Option<Box<str>>>(
-                                            Const::from(1),
-                                            None,
-                                        )
-                                        .into()]
-                                        .into(),
+                                        vec![Return::new(Const::from(1), None).into()].into(),
                                     )
                                     .into(),
                                 ),
diff --git a/boa/src/syntax/parser/expression/primary/generator_expression/mod.rs b/boa/src/syntax/parser/expression/primary/generator_expression/mod.rs
index ed037728061..8981dda16a8 100644
--- a/boa/src/syntax/parser/expression/primary/generator_expression/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/generator_expression/mod.rs
@@ -10,6 +10,8 @@
 #[cfg(test)]
 mod tests;
 
+use boa_interner::Sym;
+
 use crate::{
     syntax::{
         ast::{node::GeneratorExpr, Punctuator},
@@ -67,7 +69,7 @@ where
         // Early Error: If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code,
         // it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
         if let Some(name) = &name {
-            if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
+            if cursor.strict_mode() && [Sym::EVAL, Sym::ARGUMENTS].contains(name) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
                     match cursor.peek(0, interner)? {
@@ -114,12 +116,16 @@ where
         // also occurs in the LexicallyDeclaredNames of FunctionBody.
         // https://tc39.es/ecma262/#sec-function-definitions-static-semantics-early-errors
         {
-            let lexically_declared_names = body.lexically_declared_names();
+            let lexically_declared_names = body.lexically_declared_names(interner);
             for param in params.parameters.as_ref() {
                 for param_name in param.names() {
-                    if lexically_declared_names.contains(param_name) {
+                    if lexically_declared_names.contains(&param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
-                            format!("Redeclaration of formal parameter `{}`", param_name).into(),
+                            format!(
+                                "Redeclaration of formal parameter `{}`",
+                                interner.resolve_expect(param_name)
+                            )
+                            .into(),
                             match cursor.peek(0, interner)? {
                                 Some(token) => token.span().end(),
                                 None => Position::new(1, 1),
diff --git a/boa/src/syntax/parser/expression/primary/generator_expression/tests.rs b/boa/src/syntax/parser/expression/primary/generator_expression/tests.rs
index 4db852dcca3..968d003e0e2 100644
--- a/boa/src/syntax/parser/expression/primary/generator_expression/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/generator_expression/tests.rs
@@ -11,7 +11,7 @@ use crate::{
 
 #[test]
 fn check_generator_function_expression() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const gen = function*() {
             yield 1;
@@ -19,9 +19,9 @@ fn check_generator_function_expression() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "gen",
+                interner.get_or_intern_static("gen"),
                 Some(
-                    GeneratorExpr::new::<Option<Box<str>>, _, StatementList>(
+                    GeneratorExpr::new::<_, _, StatementList>(
                         None,
                         [],
                         vec![Yield::new(Const::from(1), false).into()].into(),
@@ -38,7 +38,7 @@ fn check_generator_function_expression() {
 
 #[test]
 fn check_generator_function_delegate_yield_expression() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const gen = function*() {
             yield* 1;
@@ -46,9 +46,9 @@ fn check_generator_function_delegate_yield_expression() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "gen",
+                interner.get_or_intern_static("gen"),
                 Some(
-                    GeneratorExpr::new::<Option<Box<str>>, _, StatementList>(
+                    GeneratorExpr::new::<_, _, StatementList>(
                         None,
                         [],
                         vec![Yield::new(Const::from(1), true).into()].into(),
diff --git a/boa/src/syntax/parser/expression/primary/mod.rs b/boa/src/syntax/parser/expression/primary/mod.rs
index c5777b3125c..29fe3e7eb9a 100644
--- a/boa/src/syntax/parser/expression/primary/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/mod.rs
@@ -38,6 +38,7 @@ use crate::{
     },
     Interner,
 };
+use boa_interner::Sym;
 pub(in crate::syntax::parser) use object_initializer::Initializer;
 
 use std::io::Read;
@@ -126,9 +127,7 @@ where
             }
             TokenKind::BooleanLiteral(boolean) => Ok(Const::from(*boolean).into()),
             TokenKind::NullLiteral => Ok(Const::Null.into()),
-            TokenKind::Identifier(ident) => {
-                Ok(Identifier::from(interner.resolve(*ident).expect("string disappeared")).into())
-            }
+            TokenKind::Identifier(ident) => Ok(Identifier::new(*ident).into()),
             TokenKind::Keyword(Keyword::Yield) if self.allow_yield.0 => {
                 // Early Error: It is a Syntax Error if this production has a [Yield] parameter and StringValue of Identifier is "yield".
                 Err(ParseError::general(
@@ -143,7 +142,7 @@ where
                         tok.span().start(),
                     ));
                 }
-                Ok(Identifier::from("yield").into())
+                Ok(Identifier::new(Sym::YIELD).into())
             }
             TokenKind::Keyword(Keyword::Await) if self.allow_await.0 => {
                 // Early Error: It is a Syntax Error if this production has an [Await] parameter and StringValue of Identifier is "await".
@@ -159,11 +158,9 @@ where
                         tok.span().start(),
                     ));
                 }
-                Ok(Identifier::from("await").into())
-            }
-            TokenKind::StringLiteral(lit) => {
-                Ok(Const::from(interner.resolve(*lit).expect("string disappeared")).into())
+                Ok(Identifier::new(Sym::AWAIT).into())
             }
+            TokenKind::StringLiteral(lit) => Ok(Const::from(*lit).into()),
             TokenKind::TemplateNoSubstitution(template_string) => Ok(Const::from(
                 template_string
                     .to_owned_cooked(interner)
@@ -175,24 +172,17 @@ where
             TokenKind::NumericLiteral(Numeric::BigInt(num)) => Ok(Const::from(num.clone()).into()),
             TokenKind::RegularExpressionLiteral(body, flags) => {
                 Ok(Node::from(New::from(Call::new(
-                    Identifier::from("RegExp"),
-                    vec![
-                        Const::from(interner.resolve(*body).expect("string disappeared")).into(),
-                        Const::from(flags.to_string()).into(),
-                    ],
+                    Identifier::new(Sym::REGEXP),
+                    vec![Const::from(*body).into(), Const::from(*flags).into()],
                 ))))
             }
             TokenKind::Punctuator(Punctuator::Div) => {
                 let tok = cursor.lex_regex(tok.span().start(), interner)?;
 
-                if let TokenKind::RegularExpressionLiteral(body, flags) = tok.kind() {
+                if let TokenKind::RegularExpressionLiteral(body, flags) = *tok.kind() {
                     Ok(Node::from(New::from(Call::new(
-                        Identifier::from("RegExp"),
-                        vec![
-                            Const::from(interner.resolve(*body).expect("string disappeared"))
-                                .into(),
-                            Const::from(flags.to_string()).into(),
-                        ],
+                        Identifier::new(Sym::REGEXP),
+                        vec![Const::from(body).into(), Const::from(flags).into()],
                     ))))
                 } else {
                     // A regex was expected and nothing else.
@@ -209,8 +199,7 @@ where
                 tok.span().start(),
                 template_string
                     .to_owned_cooked(interner)
-                    .map_err(ParseError::lex)?
-                    .as_ref(),
+                    .map_err(ParseError::lex)?,
             )
             .parse(cursor, interner)
             .map(Node::TemplateLit),
diff --git a/boa/src/syntax/parser/expression/primary/object_initializer/mod.rs b/boa/src/syntax/parser/expression/primary/object_initializer/mod.rs
index c59166a2684..3ca9e9c15cf 100644
--- a/boa/src/syntax/parser/expression/primary/object_initializer/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/object_initializer/mod.rs
@@ -9,6 +9,8 @@
 
 #[cfg(test)]
 mod tests;
+use boa_interner::Sym;
+
 use crate::{
     syntax::{
         ast::{
@@ -143,9 +145,7 @@ where
                 | TokenKind::Punctuator(Punctuator::Comma) => {
                     let token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
                     let ident = match token.kind() {
-                        TokenKind::Identifier(ident) => {
-                            Identifier::from(interner.resolve(*ident).expect("string disappeared"))
-                        }
+                        TokenKind::Identifier(ident) => Identifier::new(*ident),
                         TokenKind::Keyword(Keyword::Yield) if self.allow_yield.0 => {
                             // Early Error: It is a Syntax Error if this production has a [Yield] parameter and StringValue of Identifier is "yield".
                             return Err(ParseError::general(
@@ -161,7 +161,7 @@ where
                                     token.span().start(),
                                 ));
                             }
-                            Identifier::from("yield")
+                            Identifier::new(Sym::YIELD)
                         }
                         TokenKind::Keyword(Keyword::Await) if self.allow_await.0 => {
                             // Early Error: It is a Syntax Error if this production has an [Await] parameter and StringValue of Identifier is "await".
@@ -178,7 +178,7 @@ where
                                     token.span().start(),
                                 ));
                             }
-                            Identifier::from("yield")
+                            Identifier::new(Sym::YIELD)
                         }
                         _ => {
                             return Err(ParseError::unexpected(
@@ -188,10 +188,7 @@ where
                             ));
                         }
                     };
-                    return Ok(node::PropertyDefinition::property(
-                        ident.clone().as_ref(),
-                        ident,
-                    ));
+                    return Ok(node::PropertyDefinition::property(ident.sym(), ident));
                 }
                 _ => {}
             }
@@ -264,13 +261,16 @@ where
                 // Early Error: It is a Syntax Error if any element of the BoundNames of UniqueFormalParameters also
                 // occurs in the LexicallyDeclaredNames of GeneratorBody.
                 {
-                    let lexically_declared_names = body.lexically_declared_names();
+                    let lexically_declared_names = body.lexically_declared_names(interner);
                     for param in params.parameters.as_ref() {
                         for param_name in param.names() {
-                            if lexically_declared_names.contains(param_name) {
+                            if lexically_declared_names.contains(&param_name) {
                                 return Err(ParseError::lex(LexError::Syntax(
-                                    format!("Redeclaration of formal parameter `{}`", param_name)
-                                        .into(),
+                                    format!(
+                                        "Redeclaration of formal parameter `{}`",
+                                        interner.resolve_expect(param_name)
+                                    )
+                                    .into(),
                                     match cursor.peek(0, interner)? {
                                         Some(token) => token.span().end(),
                                         None => Position::new(1, 1),
@@ -330,13 +330,16 @@ where
                 // Early Error: It is a Syntax Error if any element of the BoundNames of UniqueFormalParameters also
                 // occurs in the LexicallyDeclaredNames of GeneratorBody.
                 {
-                    let lexically_declared_names = body.lexically_declared_names();
+                    let lexically_declared_names = body.lexically_declared_names(interner);
                     for param in params.parameters.as_ref() {
                         for param_name in param.names() {
-                            if lexically_declared_names.contains(param_name) {
+                            if lexically_declared_names.contains(&param_name) {
                                 return Err(ParseError::lex(LexError::Syntax(
-                                    format!("Redeclaration of formal parameter `{}`", param_name)
-                                        .into(),
+                                    format!(
+                                        "Redeclaration of formal parameter `{}`",
+                                        interner.resolve_expect(param_name)
+                                    )
+                                    .into(),
                                     match cursor.peek(0, interner)? {
                                         Some(token) => token.span().end(),
                                         None => Position::new(1, 1),
@@ -408,13 +411,16 @@ where
             // Early Error: It is a Syntax Error if any element of the BoundNames of UniqueFormalParameters also
             // occurs in the LexicallyDeclaredNames of GeneratorBody.
             {
-                let lexically_declared_names = body.lexically_declared_names();
+                let lexically_declared_names = body.lexically_declared_names(interner);
                 for param in params.parameters.as_ref() {
                     for param_name in param.names() {
-                        if lexically_declared_names.contains(param_name) {
+                        if lexically_declared_names.contains(&param_name) {
                             return Err(ParseError::lex(LexError::Syntax(
-                                format!("Redeclaration of formal parameter `{}`", param_name)
-                                    .into(),
+                                format!(
+                                    "Redeclaration of formal parameter `{}`",
+                                    interner.resolve_expect(param_name)
+                                )
+                                .into(),
                                 match cursor.peek(0, interner)? {
                                     Some(token) => token.span().end(),
                                     None => Position::new(1, 1),
@@ -450,7 +456,7 @@ where
 
         match property_name {
             // MethodDefinition[?Yield, ?Await] -> get ClassElementName[?Yield, ?Await] ( ) { FunctionBody[~Yield, ~Await] }
-            node::PropertyName::Literal(str) if str.as_ref() == "get" && !ordinary_method => {
+            node::PropertyName::Literal(str) if str == Sym::GET && !ordinary_method => {
                 property_name = PropertyName::new(self.allow_yield, self.allow_await)
                     .parse(cursor, interner)?;
 
@@ -484,7 +490,7 @@ where
                 ))
             }
             // MethodDefinition[?Yield, ?Await] -> set ClassElementName[?Yield, ?Await] ( PropertySetParameterList ) { FunctionBody[~Yield, ~Await] }
-            node::PropertyName::Literal(str) if str.as_ref() == "set" && !ordinary_method => {
+            node::PropertyName::Literal(str) if str == Sym::SET && !ordinary_method => {
                 property_name = PropertyName::new(self.allow_yield, self.allow_await)
                     .parse(cursor, interner)?;
 
@@ -645,7 +651,7 @@ where
         Ok(cursor
             .next(interner)?
             .ok_or(ParseError::AbruptEnd)?
-            .to_string(interner)
+            .to_sym(interner)
             .into())
     }
 }
diff --git a/boa/src/syntax/parser/expression/primary/object_initializer/tests.rs b/boa/src/syntax/parser/expression/primary/object_initializer/tests.rs
index c2ea593d224..89aa0b6c378 100644
--- a/boa/src/syntax/parser/expression/primary/object_initializer/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/object_initializer/tests.rs
@@ -15,12 +15,13 @@ use crate::{
 /// Checks object literal parsing.
 #[test]
 fn check_object_literal() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(true)),
-        PropertyDefinition::property("b", Const::from(false)),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(true)),
+        PropertyDefinition::property(interner.get_or_intern_static("b"), Const::from(false)),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -29,7 +30,7 @@ fn check_object_literal() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -42,16 +43,17 @@ fn check_object_literal() {
 /// Tests short function syntax.
 #[test]
 fn check_object_short_function() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(true)),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(true)),
         PropertyDefinition::method_definition(
             MethodDefinitionKind::Ordinary,
-            "b",
+            interner.get_or_intern_static("b"),
             FunctionExpr::new(None, vec![], vec![]),
         ),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -60,7 +62,7 @@ fn check_object_short_function() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -73,15 +75,17 @@ fn check_object_short_function() {
 /// Testing short function syntax with arguments.
 #[test]
 fn check_object_short_function_arguments() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(true)),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(true)),
         PropertyDefinition::method_definition(
             MethodDefinitionKind::Ordinary,
-            "b",
+            interner.get_or_intern_static("b"),
             FunctionExpr::new(
                 None,
                 vec![FormalParameter::new(
-                    Declaration::new_with_identifier("test", None),
+                    Declaration::new_with_identifier(interner.get_or_intern_static("test"), None),
                     false,
                 )],
                 vec![],
@@ -89,7 +93,6 @@ fn check_object_short_function_arguments() {
         ),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -98,7 +101,7 @@ fn check_object_short_function_arguments() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -110,16 +113,17 @@ fn check_object_short_function_arguments() {
 
 #[test]
 fn check_object_getter() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(true)),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(true)),
         PropertyDefinition::method_definition(
             MethodDefinitionKind::Get,
-            "b",
+            interner.get_or_intern_static("b"),
             FunctionExpr::new(None, vec![], vec![]),
         ),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -128,7 +132,7 @@ fn check_object_getter() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -140,15 +144,17 @@ fn check_object_getter() {
 
 #[test]
 fn check_object_setter() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(true)),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(true)),
         PropertyDefinition::method_definition(
             MethodDefinitionKind::Set,
-            "b",
+            interner.get_or_intern_static("b"),
             FunctionExpr::new(
                 None,
                 vec![FormalParameter::new(
-                    Declaration::new_with_identifier("test", None),
+                    Declaration::new_with_identifier(interner.get_or_intern_static("test"), None),
                     false,
                 )],
                 vec![],
@@ -156,7 +162,6 @@ fn check_object_setter() {
         ),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -165,7 +170,7 @@ fn check_object_setter() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -177,13 +182,14 @@ fn check_object_setter() {
 
 #[test]
 fn check_object_short_function_get() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![PropertyDefinition::method_definition(
         MethodDefinitionKind::Ordinary,
-        "get",
+        interner.get_or_intern_static("get"),
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             get() {}
@@ -191,7 +197,7 @@ fn check_object_short_function_get() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -203,13 +209,14 @@ fn check_object_short_function_get() {
 
 #[test]
 fn check_object_short_function_set() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![PropertyDefinition::method_definition(
         MethodDefinitionKind::Ordinary,
-        "set",
+        interner.get_or_intern_static("set"),
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             set() {}
@@ -217,7 +224,7 @@ fn check_object_short_function_set() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -229,9 +236,13 @@ fn check_object_short_function_set() {
 
 #[test]
 fn check_object_shorthand_property_names() {
-    let object_properties = vec![PropertyDefinition::property("a", Identifier::from("a"))];
+    let mut interner = Interner::default();
+
+    let object_properties = vec![PropertyDefinition::property(
+        interner.get_or_intern_static("a"),
+        Identifier::new(interner.get_or_intern_static("a")),
+    )];
 
-    let mut interner = Interner::new();
     check_parser(
         "const a = true;
             const x = { a };
@@ -239,7 +250,7 @@ fn check_object_shorthand_property_names() {
         vec![
             DeclarationList::Const(
                 vec![Declaration::new_with_identifier(
-                    "a",
+                    interner.get_or_intern_static("a"),
                     Some(Const::from(true).into()),
                 )]
                 .into(),
@@ -247,7 +258,7 @@ fn check_object_shorthand_property_names() {
             .into(),
             DeclarationList::Const(
                 vec![Declaration::new_with_identifier(
-                    "x",
+                    interner.get_or_intern_static("x"),
                     Some(Object::from(object_properties).into()),
                 )]
                 .into(),
@@ -260,12 +271,19 @@ fn check_object_shorthand_property_names() {
 
 #[test]
 fn check_object_shorthand_multiple_properties() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Identifier::from("a")),
-        PropertyDefinition::property("b", Identifier::from("b")),
+        PropertyDefinition::property(
+            interner.get_or_intern_static("a"),
+            Identifier::new(interner.get_or_intern_static("a")),
+        ),
+        PropertyDefinition::property(
+            interner.get_or_intern_static("b"),
+            Identifier::new(interner.get_or_intern_static("b")),
+        ),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const a = true;
             const b = false;
@@ -274,7 +292,7 @@ fn check_object_shorthand_multiple_properties() {
         vec![
             DeclarationList::Const(
                 vec![Declaration::new_with_identifier(
-                    "a",
+                    interner.get_or_intern_static("a"),
                     Some(Const::from(true).into()),
                 )]
                 .into(),
@@ -282,7 +300,7 @@ fn check_object_shorthand_multiple_properties() {
             .into(),
             DeclarationList::Const(
                 vec![Declaration::new_with_identifier(
-                    "b",
+                    interner.get_or_intern_static("b"),
                     Some(Const::from(false).into()),
                 )]
                 .into(),
@@ -290,7 +308,7 @@ fn check_object_shorthand_multiple_properties() {
             .into(),
             DeclarationList::Const(
                 vec![Declaration::new_with_identifier(
-                    "x",
+                    interner.get_or_intern_static("x"),
                     Some(Object::from(object_properties).into()),
                 )]
                 .into(),
@@ -303,18 +321,19 @@ fn check_object_shorthand_multiple_properties() {
 
 #[test]
 fn check_object_spread() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(1)),
-        PropertyDefinition::spread_object(Identifier::from("b")),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(1)),
+        PropertyDefinition::spread_object(Identifier::new(interner.get_or_intern_static("b"))),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = { a: 1, ...b };
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -326,13 +345,14 @@ fn check_object_spread() {
 
 #[test]
 fn check_async_method() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![PropertyDefinition::method_definition(
         MethodDefinitionKind::Async,
-        "dive",
+        interner.get_or_intern_static("dive"),
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             async dive() {}
@@ -340,7 +360,7 @@ fn check_async_method() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -352,13 +372,14 @@ fn check_async_method() {
 
 #[test]
 fn check_async_generator_method() {
+    let mut interner = Interner::default();
+
     let object_properties = vec![PropertyDefinition::method_definition(
         MethodDefinitionKind::AsyncGenerator,
-        "vroom",
+        interner.get_or_intern_static("vroom"),
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
-    let mut interner = Interner::new();
     check_parser(
         "const x = {
             async* vroom() {}
@@ -366,7 +387,7 @@ fn check_async_generator_method() {
         ",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "x",
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
diff --git a/boa/src/syntax/parser/expression/primary/template/mod.rs b/boa/src/syntax/parser/expression/primary/template/mod.rs
index 498c7db603a..cf81dd612f0 100644
--- a/boa/src/syntax/parser/expression/primary/template/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/template/mod.rs
@@ -10,16 +10,15 @@
 use crate::{
     profiler::BoaProfiler,
     syntax::{
-        ast::node::template::{TemplateElement, TemplateLit},
-        ast::Position,
-        ast::Punctuator,
+        ast::{
+            node::template::{TemplateElement, TemplateLit},
+            Position, Punctuator,
+        },
         lexer::TokenKind,
-        parser::cursor::Cursor,
-        parser::expression::Expression,
-        parser::{AllowAwait, AllowYield, ParseError, TokenParser},
+        parser::{expression::Expression, AllowAwait, AllowYield, Cursor, ParseError, TokenParser},
     },
-    Interner,
 };
+use boa_interner::{Interner, Sym};
 use std::io::Read;
 
 /// Parses a template literal.
@@ -35,12 +34,12 @@ pub(super) struct TemplateLiteral {
     allow_yield: AllowYield,
     allow_await: AllowAwait,
     start: Position,
-    first: String,
+    first: Sym,
 }
 
 impl TemplateLiteral {
     /// Creates a new `TemplateLiteral` parser.
-    pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A, start: Position, first: &str) -> Self
+    pub(super) fn new<Y, A>(allow_yield: Y, allow_await: A, start: Position, first: Sym) -> Self
     where
         Y: Into<AllowYield>,
         A: Into<AllowAwait>,
@@ -49,7 +48,7 @@ impl TemplateLiteral {
             allow_yield: allow_yield.into(),
             allow_await: allow_await.into(),
             start,
-            first: first.to_owned(),
+            first,
         }
     }
 }
@@ -68,7 +67,7 @@ where
         let _timer = BoaProfiler::global().start_event("TemplateLiteral", "Parsing");
 
         let mut elements = vec![
-            TemplateElement::String(self.first.into_boxed_str()),
+            TemplateElement::String(self.first),
             TemplateElement::Expr(
                 Expression::new(true, self.allow_yield, self.allow_await)
                     .parse(cursor, interner)?,
diff --git a/boa/src/syntax/parser/expression/primary/tests.rs b/boa/src/syntax/parser/expression/primary/tests.rs
index f7e9020be25..691b29d2c54 100644
--- a/boa/src/syntax/parser/expression/primary/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/tests.rs
@@ -1,3 +1,5 @@
+use boa_interner::Sym;
+
 use crate::{
     syntax::{ast::Const, parser::tests::check_parser},
     Interner,
@@ -6,14 +8,18 @@ use crate::{
 #[test]
 fn check_string() {
     // Check empty string
-    let mut interner = Interner::new();
-    check_parser("\"\"", vec![Const::from("").into()], &mut interner);
+    let mut interner = Interner::default();
+    check_parser(
+        "\"\"",
+        vec![Const::from(Sym::EMPTY_STRING).into()],
+        &mut interner,
+    );
 
     // Check non-empty string
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "\"hello\"",
-        vec![Const::from("hello").into()],
+        vec![Const::from(interner.get_or_intern_static("hello")).into()],
         &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/expression/tests.rs b/boa/src/syntax/parser/expression/tests.rs
index 2b7bf5783fb..836a093888c 100644
--- a/boa/src/syntax/parser/expression/tests.rs
+++ b/boa/src/syntax/parser/expression/tests.rs
@@ -13,87 +13,147 @@ use crate::{
 /// Checks numeric operations
 #[test]
 fn check_numeric_operations() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a + b",
-        vec![BinOp::new(NumOp::Add, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            NumOp::Add,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a+1",
-        vec![BinOp::new(NumOp::Add, Identifier::from("a"), Const::from(1)).into()],
+        vec![BinOp::new(
+            NumOp::Add,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Const::from(1),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a - b",
-        vec![BinOp::new(NumOp::Sub, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            NumOp::Sub,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a-1",
-        vec![BinOp::new(NumOp::Sub, Identifier::from("a"), Const::from(1)).into()],
+        vec![BinOp::new(
+            NumOp::Sub,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Const::from(1),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a / b",
-        vec![BinOp::new(NumOp::Div, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            NumOp::Div,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a/2",
-        vec![BinOp::new(NumOp::Div, Identifier::from("a"), Const::from(2)).into()],
+        vec![BinOp::new(
+            NumOp::Div,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Const::from(2),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a * b",
-        vec![BinOp::new(NumOp::Mul, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            NumOp::Mul,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a*2",
-        vec![BinOp::new(NumOp::Mul, Identifier::from("a"), Const::from(2)).into()],
+        vec![BinOp::new(
+            NumOp::Mul,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Const::from(2),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a ** b",
-        vec![BinOp::new(NumOp::Exp, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            NumOp::Exp,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a**2",
-        vec![BinOp::new(NumOp::Exp, Identifier::from("a"), Const::from(2)).into()],
+        vec![BinOp::new(
+            NumOp::Exp,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Const::from(2),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a % b",
-        vec![BinOp::new(NumOp::Mod, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            NumOp::Mod,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a%2",
-        vec![BinOp::new(NumOp::Mod, Identifier::from("a"), Const::from(2)).into()],
+        vec![BinOp::new(
+            NumOp::Mod,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Const::from(2),
+        )
+        .into()],
         &mut interner,
     );
 }
@@ -101,18 +161,22 @@ fn check_numeric_operations() {
 // Checks complex numeric operations.
 #[test]
 fn check_complex_numeric_operations() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a + d*(b-3)+1",
         vec![BinOp::new(
             NumOp::Add,
             BinOp::new(
                 NumOp::Add,
-                Identifier::from("a"),
+                Identifier::new(interner.get_or_intern_static("a")),
                 BinOp::new(
                     NumOp::Mul,
-                    Identifier::from("d"),
-                    BinOp::new(NumOp::Sub, Identifier::from("b"), Const::from(3)),
+                    Identifier::new(interner.get_or_intern_static("d")),
+                    BinOp::new(
+                        NumOp::Sub,
+                        Identifier::new(interner.get_or_intern_static("b")),
+                        Const::from(3),
+                    ),
                 ),
             ),
             Const::from(1),
@@ -125,73 +189,123 @@ fn check_complex_numeric_operations() {
 /// Checks bitwise operations.
 #[test]
 fn check_bitwise_operations() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a & b",
-        vec![BinOp::new(BitOp::And, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::And,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a&b",
-        vec![BinOp::new(BitOp::And, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::And,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a | b",
-        vec![BinOp::new(BitOp::Or, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Or,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a|b",
-        vec![BinOp::new(BitOp::Or, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Or,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a ^ b",
-        vec![BinOp::new(BitOp::Xor, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Xor,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a^b",
-        vec![BinOp::new(BitOp::Xor, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Xor,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a << b",
-        vec![BinOp::new(BitOp::Shl, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Shl,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a<<b",
-        vec![BinOp::new(BitOp::Shl, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Shl,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a >> b",
-        vec![BinOp::new(BitOp::Shr, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Shr,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a>>b",
-        vec![BinOp::new(BitOp::Shr, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            BitOp::Shr,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 }
@@ -199,109 +313,169 @@ fn check_bitwise_operations() {
 /// Checks assignment operations.
 #[test]
 fn check_assign_operations() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a += b",
-        vec![BinOp::new(AssignOp::Add, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Add,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a -= b",
-        vec![BinOp::new(AssignOp::Sub, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Sub,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a *= b",
-        vec![BinOp::new(AssignOp::Mul, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Mul,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a **= b",
-        vec![BinOp::new(AssignOp::Exp, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Exp,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a /= b",
-        vec![BinOp::new(AssignOp::Div, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Div,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a %= b",
-        vec![BinOp::new(AssignOp::Mod, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Mod,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a &= b",
-        vec![BinOp::new(AssignOp::And, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::And,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a |= b",
-        vec![BinOp::new(AssignOp::Or, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Or,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a ^= b",
-        vec![BinOp::new(AssignOp::Xor, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Xor,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a <<= b",
-        vec![BinOp::new(AssignOp::Shl, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Shl,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a >>= b",
-        vec![BinOp::new(AssignOp::Shr, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Shr,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a >>>= b",
-        vec![BinOp::new(AssignOp::Ushr, Identifier::from("a"), Identifier::from("b")).into()],
+        vec![BinOp::new(
+            AssignOp::Ushr,
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
+        )
+        .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a %= 10 / 2",
         vec![BinOp::new(
             AssignOp::Mod,
-            Identifier::from("a"),
+            Identifier::new(interner.get_or_intern_static("a")),
             BinOp::new(NumOp::Div, Const::from(10), Const::from(2)),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a ??= b",
         vec![BinOp::new(
             AssignOp::Coalesce,
-            Identifier::from("a"),
-            Identifier::from("b"),
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
         )
         .into()],
         &mut interner,
@@ -310,91 +484,104 @@ fn check_assign_operations() {
 
 #[test]
 fn check_relational_operations() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a < b",
         vec![BinOp::new(
             CompOp::LessThan,
-            Identifier::from("a"),
-            Identifier::from("b"),
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a > b",
         vec![BinOp::new(
             CompOp::GreaterThan,
-            Identifier::from("a"),
-            Identifier::from("b"),
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a <= b",
         vec![BinOp::new(
             CompOp::LessThanOrEqual,
-            Identifier::from("a"),
-            Identifier::from("b"),
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a >= b",
         vec![BinOp::new(
             CompOp::GreaterThanOrEqual,
-            Identifier::from("a"),
-            Identifier::from("b"),
+            Identifier::new(interner.get_or_intern_static("a")),
+            Identifier::new(interner.get_or_intern_static("b")),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "p in o",
-        vec![BinOp::new(CompOp::In, Identifier::from("p"), Identifier::from("o")).into()],
+        vec![BinOp::new(
+            CompOp::In,
+            Identifier::new(interner.get_or_intern_static("p")),
+            Identifier::new(interner.get_or_intern_static("o")),
+        )
+        .into()],
         &mut interner,
     );
 }
 
 #[test]
 fn check_logical_expressions() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a && b || c && d || e",
         vec![BinOp::new(
             LogOp::Or,
-            BinOp::new(LogOp::And, Identifier::from("a"), Identifier::from("b")),
+            BinOp::new(
+                LogOp::And,
+                Identifier::new(interner.get_or_intern_static("a")),
+                Identifier::new(interner.get_or_intern_static("b")),
+            ),
             BinOp::new(
                 LogOp::Or,
-                BinOp::new(LogOp::And, Identifier::from("c"), Identifier::from("d")),
-                Identifier::from("e"),
+                BinOp::new(
+                    LogOp::And,
+                    Identifier::new(interner.get_or_intern_static("c")),
+                    Identifier::new(interner.get_or_intern_static("d")),
+                ),
+                Identifier::new(interner.get_or_intern_static("e")),
             ),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a ?? b ?? c",
         vec![BinOp::new(
             LogOp::Coalesce,
             BinOp::new(
                 LogOp::Coalesce,
-                Identifier::from("a"),
-                Identifier::from("b"),
+                Identifier::new(interner.get_or_intern_static("a")),
+                Identifier::new(interner.get_or_intern_static("b")),
             ),
-            Identifier::from("c"),
+            Identifier::new(interner.get_or_intern_static("c")),
         )
         .into()],
         &mut interner,
diff --git a/boa/src/syntax/parser/expression/update.rs b/boa/src/syntax/parser/expression/update.rs
index 0d0111b2020..eab22f76f3b 100644
--- a/boa/src/syntax/parser/expression/update.rs
+++ b/boa/src/syntax/parser/expression/update.rs
@@ -5,6 +5,8 @@
 //!
 //! [spec]: https://tc39.es/ecma262/#sec-update-expressions
 
+use boa_interner::Sym;
+
 use super::left_hand_side::LeftHandSideExpression;
 use crate::{
     profiler::BoaProfiler,
@@ -97,7 +99,7 @@ where
                     let ok = match &lhs {
                         Node::Identifier(_) if !strict => true,
                         Node::Identifier(ident)
-                            if !["eval", "arguments"].contains(&ident.as_ref()) =>
+                            if ![Sym::EVAL, Sym::ARGUMENTS].contains(&ident.sym()) =>
                         {
                             true
                         }
@@ -122,7 +124,7 @@ where
                     let ok = match &lhs {
                         Node::Identifier(_) if !strict => true,
                         Node::Identifier(ident)
-                            if !["eval", "arguments"].contains(&ident.as_ref()) =>
+                            if ![Sym::EVAL, Sym::ARGUMENTS].contains(&ident.sym()) =>
                         {
                             true
                         }
diff --git a/boa/src/syntax/parser/function/mod.rs b/boa/src/syntax/parser/function/mod.rs
index 61840bd712f..6af078fd35b 100644
--- a/boa/src/syntax/parser/function/mod.rs
+++ b/boa/src/syntax/parser/function/mod.rs
@@ -24,6 +24,7 @@ use crate::{
     },
     BoaProfiler, Interner,
 };
+use boa_interner::Sym;
 use rustc_hash::FxHashSet;
 use std::io::Read;
 
@@ -119,7 +120,7 @@ where
                 is_simple = false;
             }
             for param_name in next_param.names() {
-                if parameter_names.contains(param_name) {
+                if parameter_names.contains(&param_name) {
                     has_duplicates = true;
                 }
                 parameter_names.insert(Box::from(param_name));
@@ -267,7 +268,7 @@ where
             Ok(Self::Output::new(declaration, true))
         } else {
             Ok(Self::Output::new(
-                Declaration::new_with_identifier("", None),
+                Declaration::new_with_identifier(Sym::EMPTY_STRING, None),
                 true,
             ))
         }
@@ -367,7 +368,7 @@ where
             Ok(Self::Output::new(declaration, false))
         } else {
             Ok(Self::Output::new(
-                Declaration::new_with_identifier("", None),
+                Declaration::new_with_identifier(Sym::EMPTY_STRING, None),
                 false,
             ))
         }
@@ -433,7 +434,7 @@ where
                     return Ok(Vec::new().into());
                 }
                 TokenKind::StringLiteral(string)
-                    if interner.resolve(*string).expect("string disappeared") == "use strict" =>
+                    if interner.resolve_expect(*string) == "use strict" =>
                 {
                     cursor.set_strict_mode(true);
                     strict = true;
diff --git a/boa/src/syntax/parser/function/tests.rs b/boa/src/syntax/parser/function/tests.rs
index 616e39cd70f..bff47a15579 100644
--- a/boa/src/syntax/parser/function/tests.rs
+++ b/boa/src/syntax/parser/function/tests.rs
@@ -13,16 +13,16 @@ use crate::{
 /// Checks basic function declaration parsing.
 #[test]
 fn check_basic() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function foo(a) { return a; }",
         vec![FunctionDecl::new(
-            Box::from("foo"),
+            interner.get_or_intern_static("foo"),
             vec![FormalParameter::new(
-                Declaration::new_with_identifier("a", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
                 false,
             )],
-            vec![Return::new(Identifier::from("a"), None).into()],
+            vec![Return::new(Identifier::new(interner.get_or_intern_static("a")), None).into()],
         )
         .into()],
         &mut interner,
@@ -32,16 +32,22 @@ fn check_basic() {
 /// Checks if duplicate parameter names are allowed with strict mode off.
 #[test]
 fn check_duplicates_strict_off() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function foo(a, a) { return a; }",
         vec![FunctionDecl::new(
-            Box::from("foo"),
+            interner.get_or_intern_static("foo"),
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
             ],
-            vec![Return::new(Identifier::from("a"), None).into()],
+            vec![Return::new(Identifier::new(interner.get_or_intern_static("a")), None).into()],
         )
         .into()],
         &mut interner,
@@ -52,7 +58,7 @@ fn check_duplicates_strict_off() {
 #[test]
 fn check_duplicates_strict_on() {
     let js = "'use strict'; function foo(a, a) {}";
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
 
     let res = Parser::new(js.as_bytes(), false).parse_all(&mut interner);
     dbg!(&res);
@@ -62,16 +68,16 @@ fn check_duplicates_strict_on() {
 /// Checks basic function declaration parsing with automatic semicolon insertion.
 #[test]
 fn check_basic_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function foo(a) { return a }",
         vec![FunctionDecl::new(
-            Box::from("foo"),
+            interner.get_or_intern_static("foo"),
             vec![FormalParameter::new(
-                Declaration::new_with_identifier("a", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
                 false,
             )],
-            vec![Return::new(Identifier::from("a"), None).into()],
+            vec![Return::new(Identifier::new(interner.get_or_intern_static("a")), None).into()],
         )
         .into()],
         &mut interner,
@@ -81,13 +87,13 @@ fn check_basic_semicolon_insertion() {
 /// Checks functions with empty returns.
 #[test]
 fn check_empty_return() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function foo(a) { return; }",
         vec![FunctionDecl::new(
-            Box::from("foo"),
+            interner.get_or_intern_static("foo"),
             vec![FormalParameter::new(
-                Declaration::new_with_identifier("a", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
                 false,
             )],
             vec![Return::new::<Node, Option<Node>, Option<_>>(None, None).into()],
@@ -100,13 +106,13 @@ fn check_empty_return() {
 /// Checks functions with empty returns without semicolon
 #[test]
 fn check_empty_return_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function foo(a) { return }",
         vec![FunctionDecl::new(
-            Box::from("foo"),
+            interner.get_or_intern_static("foo"),
             vec![FormalParameter::new(
-                Declaration::new_with_identifier("a", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
                 false,
             )],
             vec![Return::new::<Node, Option<Node>, Option<_>>(None, None).into()],
@@ -119,14 +125,20 @@ fn check_empty_return_semicolon_insertion() {
 /// Checks rest operator parsing.
 #[test]
 fn check_rest_operator() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function foo(a, ...b) {}",
         vec![FunctionDecl::new(
-            Box::from("foo"),
+            interner.get_or_intern_static("foo"),
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("b", None), true),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                    true,
+                ),
             ],
             vec![],
         )
@@ -138,12 +150,12 @@ fn check_rest_operator() {
 /// Checks an arrow function with only a rest parameter.
 #[test]
 fn check_arrow_only_rest() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "(...a) => {}",
         vec![ArrowFunctionDecl::new(
             vec![FormalParameter::new(
-                Declaration::new_with_identifier("a", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
                 true,
             )],
             vec![],
@@ -156,14 +168,23 @@ fn check_arrow_only_rest() {
 /// Checks an arrow function with a rest parameter.
 #[test]
 fn check_arrow_rest() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "(a, b, ...c) => {}",
         vec![ArrowFunctionDecl::new(
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("b", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("c", None), true),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("c"), None),
+                    true,
+                ),
             ],
             vec![],
         )
@@ -175,16 +196,26 @@ fn check_arrow_rest() {
 /// Checks an arrow function with expression return.
 #[test]
 fn check_arrow() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "(a, b) => { return a + b; }",
         vec![ArrowFunctionDecl::new(
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("b", None), false),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                    false,
+                ),
             ],
             vec![Return::new(
-                BinOp::new(NumOp::Add, Identifier::from("a"), Identifier::from("b")),
+                BinOp::new(
+                    NumOp::Add,
+                    Identifier::new(interner.get_or_intern_static("a")),
+                    Identifier::new(interner.get_or_intern_static("b")),
+                ),
                 None,
             )
             .into()],
@@ -197,16 +228,26 @@ fn check_arrow() {
 /// Checks an arrow function with expression return and automatic semicolon insertion
 #[test]
 fn check_arrow_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "(a, b) => { return a + b }",
         vec![ArrowFunctionDecl::new(
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("b", None), false),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                    false,
+                ),
             ],
             vec![Return::new(
-                BinOp::new(NumOp::Add, Identifier::from("a"), Identifier::from("b")),
+                BinOp::new(
+                    NumOp::Add,
+                    Identifier::new(interner.get_or_intern_static("a")),
+                    Identifier::new(interner.get_or_intern_static("b")),
+                ),
                 None,
             )
             .into()],
@@ -219,13 +260,19 @@ fn check_arrow_semicolon_insertion() {
 /// Checks arrow function with empty return
 #[test]
 fn check_arrow_epty_return() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "(a, b) => { return; }",
         vec![ArrowFunctionDecl::new(
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("b", None), false),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                    false,
+                ),
             ],
             vec![Return::new::<Node, Option<_>, Option<_>>(None, None).into()],
         )
@@ -237,13 +284,19 @@ fn check_arrow_epty_return() {
 /// Checks an arrow function with empty return, with automatic semicolon insertion.
 #[test]
 fn check_arrow_empty_return_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "(a, b) => { return }",
         vec![ArrowFunctionDecl::new(
             vec![
-                FormalParameter::new(Declaration::new_with_identifier("a", None), false),
-                FormalParameter::new(Declaration::new_with_identifier("b", None), false),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("a"), None),
+                    false,
+                ),
+                FormalParameter::new(
+                    Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                    false,
+                ),
             ],
             vec![Return::new::<Node, Option<_>, Option<_>>(None, None).into()],
         )
@@ -254,20 +307,23 @@ fn check_arrow_empty_return_semicolon_insertion() {
 
 #[test]
 fn check_arrow_assignment() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = (a) => { return a };",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                Identifier::new(interner.get_or_intern_static("foo")),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![FormalParameter::new(
-                            Declaration::new_with_identifier("a", None),
+                            Declaration::new_with_identifier(
+                                interner.get_or_intern_static("a"),
+                                None,
+                            ),
                             false,
                         )],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -284,20 +340,23 @@ fn check_arrow_assignment() {
 
 #[test]
 fn check_arrow_assignment_nobrackets() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = (a) => a;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                interner.get_or_intern_static("foo"),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![FormalParameter::new(
-                            Declaration::new_with_identifier("a", None),
+                            Declaration::new_with_identifier(
+                                interner.get_or_intern_static("a"),
+                                None,
+                            ),
                             false,
                         )],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -314,20 +373,23 @@ fn check_arrow_assignment_nobrackets() {
 
 #[test]
 fn check_arrow_assignment_noparenthesis() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = a => { return a };",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                interner.get_or_intern_static("foo"),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![FormalParameter::new(
-                            Declaration::new_with_identifier("a", None),
+                            Declaration::new_with_identifier(
+                                interner.get_or_intern_static("a"),
+                                None,
+                            ),
                             false,
                         )],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -344,20 +406,23 @@ fn check_arrow_assignment_noparenthesis() {
 
 #[test]
 fn check_arrow_assignment_noparenthesis_nobrackets() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = a => a;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                Identifier::new(interner.get_or_intern_static("foo")),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![FormalParameter::new(
-                            Declaration::new_with_identifier("a", None),
+                            Declaration::new_with_identifier(
+                                interner.get_or_intern_static("a"),
+                                None,
+                            ),
                             false,
                         )],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -374,26 +439,32 @@ fn check_arrow_assignment_noparenthesis_nobrackets() {
 
 #[test]
 fn check_arrow_assignment_2arg() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = (a, b) => { return a };",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                Identifier::new(interner.get_or_intern_static("foo")),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![
                             FormalParameter::new(
-                                Declaration::new_with_identifier("a", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("a"),
+                                    None,
+                                ),
                                 false,
                             ),
                             FormalParameter::new(
-                                Declaration::new_with_identifier("b", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("b"),
+                                    None,
+                                ),
                                 false,
                             ),
                         ],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -410,26 +481,32 @@ fn check_arrow_assignment_2arg() {
 
 #[test]
 fn check_arrow_assignment_2arg_nobrackets() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = (a, b) => a;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                Identifier::new(interner.get_or_intern_static("foo")),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![
                             FormalParameter::new(
-                                Declaration::new_with_identifier("a", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("a"),
+                                    None,
+                                ),
                                 false,
                             ),
                             FormalParameter::new(
-                                Declaration::new_with_identifier("b", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("b"),
+                                    None,
+                                ),
                                 false,
                             ),
                         ],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -446,30 +523,39 @@ fn check_arrow_assignment_2arg_nobrackets() {
 
 #[test]
 fn check_arrow_assignment_3arg() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = (a, b, c) => { return a };",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                Identifier::new(interner.get_or_intern_static("foo")),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![
                             FormalParameter::new(
-                                Declaration::new_with_identifier("a", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("a"),
+                                    None,
+                                ),
                                 false,
                             ),
                             FormalParameter::new(
-                                Declaration::new_with_identifier("b", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("b"),
+                                    None,
+                                ),
                                 false,
                             ),
                             FormalParameter::new(
-                                Declaration::new_with_identifier("c", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("c"),
+                                    None,
+                                ),
                                 false,
                             ),
                         ],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
@@ -486,30 +572,39 @@ fn check_arrow_assignment_3arg() {
 
 #[test]
 fn check_arrow_assignment_3arg_nobrackets() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let foo = (a, b, c) => a;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                Identifier::from("foo"),
+                Identifier::new(interner.get_or_intern_static("foo")),
                 Some(
                     ArrowFunctionDecl::new(
                         vec![
                             FormalParameter::new(
-                                Declaration::new_with_identifier("a", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("a"),
+                                    None,
+                                ),
                                 false,
                             ),
                             FormalParameter::new(
-                                Declaration::new_with_identifier("b", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("b"),
+                                    None,
+                                ),
                                 false,
                             ),
                             FormalParameter::new(
-                                Declaration::new_with_identifier("c", None),
+                                Declaration::new_with_identifier(
+                                    interner.get_or_intern_static("c"),
+                                    None,
+                                ),
                                 false,
                             ),
                         ],
                         vec![Return::new::<Node, Option<_>, Option<_>>(
-                            Some(Identifier::from("a").into()),
+                            Some(Identifier::new(interner.get_or_intern_static("a")).into()),
                             None,
                         )
                         .into()],
diff --git a/boa/src/syntax/parser/mod.rs b/boa/src/syntax/parser/mod.rs
index 47abec4640f..a451b035664 100644
--- a/boa/src/syntax/parser/mod.rs
+++ b/boa/src/syntax/parser/mod.rs
@@ -139,8 +139,7 @@ where
                 match tok.kind() {
                     // Set the strict mode
                     TokenKind::StringLiteral(string)
-                        if interner.resolve(*string).expect("string disappeared")
-                            == "use strict" =>
+                        if interner.resolve_expect(*string) == "use strict" =>
                     {
                         cursor.set_strict_mode(true);
                         strict = true;
diff --git a/boa/src/syntax/parser/statement/block/tests.rs b/boa/src/syntax/parser/statement/block/tests.rs
index b96e5fde8fb..30d95a8bfe5 100644
--- a/boa/src/syntax/parser/statement/block/tests.rs
+++ b/boa/src/syntax/parser/statement/block/tests.rs
@@ -25,13 +25,14 @@ where
 
 #[test]
 fn empty() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_block("{}", vec![], &mut interner);
 }
 
 #[test]
 fn non_empty() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_block(
         r"{
             var a = 10;
@@ -40,18 +41,20 @@ fn non_empty() {
         vec![
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "a",
+                    a,
                     Some(Const::from(10).into()),
                 )]
                 .into(),
             )
             .into(),
-            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
+            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::new(a)).into(),
         ],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let hello = interner.get_or_intern_static("hello");
+    let a = interner.get_or_intern_static("a");
     check_block(
         r"{
             function hello() {
@@ -63,20 +66,20 @@ fn non_empty() {
         }",
         vec![
             FunctionDecl::new(
-                "hello".to_owned().into_boxed_str(),
+                hello,
                 vec![],
                 vec![Return::new(Const::from(10), None).into()],
             )
             .into(),
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "a",
-                    Node::from(Call::new(Identifier::from("hello"), vec![])),
+                    a,
+                    Node::from(Call::new(Identifier::new(hello), vec![])),
                 )]
                 .into(),
             )
             .into(),
-            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
+            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::new(a)).into(),
         ],
         &mut interner,
     );
@@ -84,7 +87,9 @@ fn non_empty() {
 
 #[test]
 fn hoisting() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let hello = interner.get_or_intern_static("hello");
+    let a = interner.get_or_intern_static("a");
     check_block(
         r"{
             var a = hello();
@@ -94,25 +99,26 @@ fn hoisting() {
         }",
         vec![
             FunctionDecl::new(
-                "hello".to_owned().into_boxed_str(),
+                hello,
                 vec![],
                 vec![Return::new(Const::from(10), None).into()],
             )
             .into(),
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "a",
-                    Node::from(Call::new(Identifier::from("hello"), vec![])),
+                    a,
+                    Node::from(Call::new(Identifier::new(hello), vec![])),
                 )]
                 .into(),
             )
             .into(),
-            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
+            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::new(a)).into(),
         ],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_block(
         r"{
             a = 10;
@@ -121,9 +127,9 @@ fn hoisting() {
             var a;
         }",
         vec![
-            Assign::new(Identifier::from("a"), Const::from(10)).into(),
-            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
-            DeclarationList::Var(vec![Declaration::new_with_identifier("a", None)].into()).into(),
+            Assign::new(Identifier::new(a), Const::from(10)).into(),
+            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::new(a)).into(),
+            DeclarationList::Var(vec![Declaration::new_with_identifier(a, None)].into()).into(),
         ],
         &mut interner,
     );
diff --git a/boa/src/syntax/parser/statement/break_stm/mod.rs b/boa/src/syntax/parser/statement/break_stm/mod.rs
index 893993240a9..c2b4aa17a1f 100644
--- a/boa/src/syntax/parser/statement/break_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/break_stm/mod.rs
@@ -86,6 +86,6 @@ where
             Some(label)
         };
 
-        Ok(Break::new::<_, Box<str>>(label))
+        Ok(Break::new(label))
     }
 }
diff --git a/boa/src/syntax/parser/statement/break_stm/tests.rs b/boa/src/syntax/parser/statement/break_stm/tests.rs
index 142b8c2d932..a6eb3786767 100644
--- a/boa/src/syntax/parser/statement/break_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/break_stm/tests.rs
@@ -11,37 +11,33 @@ use crate::{
 
 #[test]
 fn inline() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) break;",
-        vec![WhileLoop::new(
-            Const::from(true),
-            Node::Break(Break::new::<_, Box<str>>(None)),
-        )
-        .into()],
+        vec![WhileLoop::new(Const::from(true), Node::Break(Break::new(None))).into()],
         &mut interner,
     );
 }
 
 #[test]
 fn new_line() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true)
             break;",
-        vec![WhileLoop::new(Const::from(true), Break::new::<_, Box<str>>(None)).into()],
+        vec![WhileLoop::new(Const::from(true), Break::new(None)).into()],
         &mut interner,
     );
 }
 
 #[test]
 fn inline_block_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {break}",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Break::new(None).into()]),
         )
         .into()],
         &mut interner,
@@ -50,14 +46,16 @@ fn inline_block_semicolon_insertion() {
 
 #[test]
 fn new_line_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             break test
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new("test").into()]),
+            Block::from(vec![
+                Break::new(interner.get_or_intern_static("test")).into()
+            ]),
         )
         .into()],
         &mut interner,
@@ -66,12 +64,12 @@ fn new_line_semicolon_insertion() {
 
 #[test]
 fn inline_block() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {break;}",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Break::new(None).into()]),
         )
         .into()],
         &mut interner,
@@ -80,14 +78,16 @@ fn inline_block() {
 
 #[test]
 fn new_line_block() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             break test;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new("test").into()]),
+            Block::from(vec![
+                Break::new(interner.get_or_intern_static("test")).into()
+            ]),
         )
         .into()],
         &mut interner,
@@ -96,27 +96,31 @@ fn new_line_block() {
 
 #[test]
 fn reserved_label() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             break await;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new("await").into()]),
+            Block::from(vec![
+                Break::new(interner.get_or_intern_static("await")).into()
+            ]),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             break yield;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new("yield").into()]),
+            Block::from(vec![
+                Break::new(interner.get_or_intern_static("yield")).into()
+            ]),
         )
         .into()],
         &mut interner,
@@ -125,14 +129,14 @@ fn reserved_label() {
 
 #[test]
 fn new_line_block_empty() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             break;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Break::new(None).into()]),
         )
         .into()],
         &mut interner,
@@ -141,14 +145,14 @@ fn new_line_block_empty() {
 
 #[test]
 fn new_line_block_empty_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             break
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Break::new(None).into()]),
         )
         .into()],
         &mut interner,
diff --git a/boa/src/syntax/parser/statement/continue_stm/mod.rs b/boa/src/syntax/parser/statement/continue_stm/mod.rs
index d8933eab9e8..ef0d615594f 100644
--- a/boa/src/syntax/parser/statement/continue_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/continue_stm/mod.rs
@@ -85,6 +85,6 @@ where
             Some(label)
         };
 
-        Ok(Continue::new::<_, Box<str>>(label))
+        Ok(Continue::new(label))
     }
 }
diff --git a/boa/src/syntax/parser/statement/continue_stm/tests.rs b/boa/src/syntax/parser/statement/continue_stm/tests.rs
index 88b80c60156..b56c9ef0992 100644
--- a/boa/src/syntax/parser/statement/continue_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/continue_stm/tests.rs
@@ -11,33 +11,33 @@ use crate::{
 
 #[test]
 fn inline() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) continue;",
-        vec![WhileLoop::new(Const::from(true), Continue::new::<_, Box<str>>(None)).into()],
+        vec![WhileLoop::new(Const::from(true), Continue::new(None)).into()],
         &mut interner,
     );
 }
 
 #[test]
 fn new_line() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true)
             continue;",
-        vec![WhileLoop::new(Const::from(true), Continue::new::<_, Box<str>>(None)).into()],
+        vec![WhileLoop::new(Const::from(true), Continue::new(None)).into()],
         &mut interner,
     );
 }
 
 #[test]
 fn inline_block_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {continue}",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Continue::new(None).into()]),
         )
         .into()],
         &mut interner,
@@ -46,14 +46,16 @@ fn inline_block_semicolon_insertion() {
 
 #[test]
 fn new_line_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             continue test
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new("test").into()]),
+            Block::from(vec![
+                Continue::new(interner.get_or_intern_static("test")).into()
+            ]),
         )
         .into()],
         &mut interner,
@@ -62,12 +64,12 @@ fn new_line_semicolon_insertion() {
 
 #[test]
 fn inline_block() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {continue;}",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Continue::new(None).into()]),
         )
         .into()],
         &mut interner,
@@ -76,14 +78,16 @@ fn inline_block() {
 
 #[test]
 fn new_line_block() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             continue test;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new("test").into()]),
+            Block::from(vec![
+                Continue::new(interner.get_or_intern_static("test")).into()
+            ]),
         )
         .into()],
         &mut interner,
@@ -92,27 +96,31 @@ fn new_line_block() {
 
 #[test]
 fn reserved_label() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             continue await;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new("await").into()]),
+            Block::from(vec![
+                Continue::new(interner.get_or_intern_static("await")).into()
+            ]),
         )
         .into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             continue yield;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new("yield").into()]),
+            Block::from(vec![
+                Continue::new(interner.get_or_intern_static("yield")).into()
+            ]),
         )
         .into()],
         &mut interner,
@@ -121,14 +129,14 @@ fn reserved_label() {
 
 #[test]
 fn new_line_block_empty() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             continue;
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Continue::new(None).into()]),
         )
         .into()],
         &mut interner,
@@ -137,14 +145,14 @@ fn new_line_block_empty() {
 
 #[test]
 fn new_line_block_empty_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "while (true) {
             continue
         }",
         vec![WhileLoop::new(
             Const::from(true),
-            Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
+            Block::from(vec![Continue::new(None).into()]),
         )
         .into()],
         &mut interner,
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/tests.rs b/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/tests.rs
index c0f1cb2b026..a4ba0014d76 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/tests.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/tests.rs
@@ -6,10 +6,10 @@ use crate::{
 /// Async function declaration parsing.
 #[test]
 fn async_function_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "async function hello() {}",
-        vec![AsyncFunctionDecl::new(Box::from("hello"), vec![], vec![]).into()],
+        vec![AsyncFunctionDecl::new(interner.get_or_intern_static("hello"), vec![], vec![]).into()],
         &mut interner,
     );
 }
@@ -17,17 +17,17 @@ fn async_function_declaration() {
 /// Async function declaration parsing with keywords.
 #[test]
 fn async_function_declaration_keywords() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "async function yield() {}",
-        vec![AsyncFunctionDecl::new(Box::from("yield"), vec![], vec![]).into()],
+        vec![AsyncFunctionDecl::new(interner.get_or_intern_static("yield"), vec![], vec![]).into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "async function await() {}",
-        vec![AsyncFunctionDecl::new(Box::from("await"), vec![], vec![]).into()],
+        vec![AsyncFunctionDecl::new(interner.get_or_intern_static("await"), vec![], vec![]).into()],
         &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/tests.rs b/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/tests.rs
index 2540dd5837a..2918edc3b13 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/tests.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/tests.rs
@@ -5,10 +5,10 @@ use crate::{
 
 #[test]
 fn async_generator_function_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "async function* gen() {}",
-        vec![AsyncGeneratorDecl::new(Box::from("gen"), vec![], vec![]).into()],
+        vec![AsyncGeneratorDecl::new(interner.get_or_intern_static("gen"), vec![], vec![]).into()],
         &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/tests.rs b/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/tests.rs
index fe86617c4f6..fd0e479c4af 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/tests.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/tests.rs
@@ -6,10 +6,10 @@ use crate::{
 /// Function declaration parsing.
 #[test]
 fn function_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function hello() {}",
-        vec![FunctionDecl::new(Box::from("hello"), vec![], vec![]).into()],
+        vec![FunctionDecl::new(interner.get_or_intern_static("hello"), vec![], vec![]).into()],
         &mut interner,
     );
 }
@@ -17,17 +17,17 @@ fn function_declaration() {
 /// Function declaration parsing with keywords.
 #[test]
 fn function_declaration_keywords() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function yield() {}",
-        vec![FunctionDecl::new(Box::from("yield"), vec![], vec![]).into()],
+        vec![FunctionDecl::new(interner.get_or_intern_static("yield"), vec![], vec![]).into()],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function await() {}",
-        vec![FunctionDecl::new(Box::from("await"), vec![], vec![]).into()],
+        vec![FunctionDecl::new(interner.get_or_intern_static("await"), vec![], vec![]).into()],
         &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/tests.rs b/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/tests.rs
index a856cabb398..1825e6dd7b4 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/tests.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/tests.rs
@@ -5,10 +5,10 @@ use crate::{
 
 #[test]
 fn generator_function_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "function* gen() {}",
-        vec![GeneratorDecl::new(Box::from("gen"), vec![], vec![]).into()],
+        vec![GeneratorDecl::new(interner.get_or_intern_static("gen"), vec![], vec![]).into()],
         &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/mod.rs b/boa/src/syntax/parser/statement/declaration/hoistable/mod.rs
index 61c33112277..ff409a95de4 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/mod.rs
@@ -29,8 +29,9 @@ use crate::{
             AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, ParseResult, TokenParser,
         },
     },
-    BoaProfiler, Interner,
+    BoaProfiler,
 };
+use boa_interner::{Interner, Sym};
 use std::io::Read;
 
 /// Hoistable declaration parsing.
@@ -124,7 +125,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     c: &C,
     cursor: &mut Cursor<R>,
     interner: &mut Interner,
-) -> Result<(Box<str>, Box<[FormalParameter]>, StatementList), ParseError> {
+) -> Result<(Sym, Box<[FormalParameter]>, StatementList), ParseError> {
     let next_token = cursor.peek(0, interner)?;
     let name = if let Some(token) = next_token {
         match token.kind() {
@@ -136,7 +137,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
                         c.error_context(),
                     ));
                 }
-                "default".into()
+                Sym::DEFAULT
             }
             _ => BindingIdentifier::new(c.name_allow_yield(), c.name_allow_await())
                 .parse(cursor, interner)?,
@@ -147,7 +148,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
 
     // Early Error: If BindingIdentifier is present and the source code matching BindingIdentifier is strict mode code,
     // it is a Syntax Error if the StringValue of BindingIdentifier is "eval" or "arguments".
-    if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
+    if cursor.strict_mode() && [Sym::EVAL, Sym::ARGUMENTS].contains(&name) {
         return Err(ParseError::lex(LexError::Syntax(
             "Unexpected eval or arguments in strict mode".into(),
             match cursor.peek(0, interner)? {
@@ -195,12 +196,16 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     // also occurs in the LexicallyDeclaredNames of FunctionBody.
     // https://tc39.es/ecma262/#sec-function-definitions-static-semantics-early-errors
     {
-        let lexically_declared_names = body.lexically_declared_names();
+        let lexically_declared_names = body.lexically_declared_names(interner);
         for param in params.parameters.as_ref() {
             for param_name in param.names() {
-                if lexically_declared_names.contains(param_name) {
+                if lexically_declared_names.contains(&param_name) {
                     return Err(ParseError::lex(LexError::Syntax(
-                        format!("Redeclaration of formal parameter `{}`", param_name).into(),
+                        format!(
+                            "Redeclaration of formal parameter `{}`",
+                            interner.resolve_expect(param_name)
+                        )
+                        .into(),
                         match cursor.peek(0, interner)? {
                             Some(token) => token.span().end(),
                             None => Position::new(1, 1),
diff --git a/boa/src/syntax/parser/statement/declaration/tests.rs b/boa/src/syntax/parser/statement/declaration/tests.rs
index 4910f926fe1..b3e26d47db8 100644
--- a/boa/src/syntax/parser/statement/declaration/tests.rs
+++ b/boa/src/syntax/parser/statement/declaration/tests.rs
@@ -12,12 +12,12 @@ use crate::{
 /// Checks `var` declaration parsing.
 #[test]
 fn var_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "var a = 5;",
         vec![DeclarationList::Var(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Some(Const::from(5).into()),
             )]
             .into(),
@@ -30,12 +30,12 @@ fn var_declaration() {
 /// Checks `var` declaration parsing with reserved words.
 #[test]
 fn var_declaration_keywords() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "var yield = 5;",
         vec![DeclarationList::Var(
             vec![Declaration::new_with_identifier(
-                "yield",
+                interner.get_or_intern_static("yield"),
                 Some(Const::from(5).into()),
             )]
             .into(),
@@ -44,12 +44,12 @@ fn var_declaration_keywords() {
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "var await = 5;",
         vec![DeclarationList::Var(
             vec![Declaration::new_with_identifier(
-                "await",
+                interner.get_or_intern_static("await"),
                 Some(Const::from(5).into()),
             )]
             .into(),
@@ -62,12 +62,12 @@ fn var_declaration_keywords() {
 /// Checks `var` declaration parsing with no spaces.
 #[test]
 fn var_declaration_no_spaces() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "var a=5;",
         vec![DeclarationList::Var(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Some(Const::from(5).into()),
             )]
             .into(),
@@ -80,10 +80,17 @@ fn var_declaration_no_spaces() {
 /// Checks empty `var` declaration parsing.
 #[test]
 fn empty_var_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "var a;",
-        vec![DeclarationList::Var(vec![Declaration::new_with_identifier("a", None)].into()).into()],
+        vec![DeclarationList::Var(
+            vec![Declaration::new_with_identifier(
+                interner.get_or_intern_static("a"),
+                None,
+            )]
+            .into(),
+        )
+        .into()],
         &mut interner,
     );
 }
@@ -91,14 +98,20 @@ fn empty_var_declaration() {
 /// Checks multiple `var` declarations.
 #[test]
 fn multiple_var_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "var a = 5, b, c = 6;",
         vec![DeclarationList::Var(
             vec![
-                Declaration::new_with_identifier("a", Some(Const::from(5).into())),
-                Declaration::new_with_identifier("b", None),
-                Declaration::new_with_identifier("c", Some(Const::from(6).into())),
+                Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
+                    Some(Const::from(5).into()),
+                ),
+                Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                Declaration::new_with_identifier(
+                    interner.get_or_intern_static("c"),
+                    Some(Const::from(6).into()),
+                ),
             ]
             .into(),
         )
@@ -110,12 +123,12 @@ fn multiple_var_declaration() {
 /// Checks `let` declaration parsing.
 #[test]
 fn let_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let a = 5;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -128,12 +141,12 @@ fn let_declaration() {
 /// Checks `let` declaration parsing with reserved words.
 #[test]
 fn let_declaration_keywords() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let yield = 5;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                "yield",
+                interner.get_or_intern_static("yield"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -142,12 +155,12 @@ fn let_declaration_keywords() {
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let await = 5;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                "await",
+                interner.get_or_intern_static("await"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -160,12 +173,12 @@ fn let_declaration_keywords() {
 /// Checks `let` declaration parsing with no spaces.
 #[test]
 fn let_declaration_no_spaces() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let a=5;",
         vec![DeclarationList::Let(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -178,10 +191,17 @@ fn let_declaration_no_spaces() {
 /// Checks empty `let` declaration parsing.
 #[test]
 fn empty_let_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let a;",
-        vec![DeclarationList::Let(vec![Declaration::new_with_identifier("a", None)].into()).into()],
+        vec![DeclarationList::Let(
+            vec![Declaration::new_with_identifier(
+                interner.get_or_intern_static("a"),
+                None,
+            )]
+            .into(),
+        )
+        .into()],
         &mut interner,
     );
 }
@@ -189,14 +209,20 @@ fn empty_let_declaration() {
 /// Checks multiple `let` declarations.
 #[test]
 fn multiple_let_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "let a = 5, b, c = 6;",
         vec![DeclarationList::Let(
             vec![
-                Declaration::new_with_identifier("a", Node::from(Const::from(5))),
-                Declaration::new_with_identifier("b", None),
-                Declaration::new_with_identifier("c", Node::from(Const::from(6))),
+                Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
+                    Node::from(Const::from(5)),
+                ),
+                Declaration::new_with_identifier(interner.get_or_intern_static("b"), None),
+                Declaration::new_with_identifier(
+                    interner.get_or_intern_static("c"),
+                    Node::from(Const::from(6)),
+                ),
             ]
             .into(),
         )
@@ -208,12 +234,12 @@ fn multiple_let_declaration() {
 /// Checks `const` declaration parsing.
 #[test]
 fn const_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const a = 5;",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -226,12 +252,12 @@ fn const_declaration() {
 /// Checks `const` declaration parsing with reserved words.
 #[test]
 fn const_declaration_keywords() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const yield = 5;",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "yield",
+                interner.get_or_intern_static("yield"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -240,12 +266,12 @@ fn const_declaration_keywords() {
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const await = 5;",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "await",
+                interner.get_or_intern_static("await"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -258,12 +284,12 @@ fn const_declaration_keywords() {
 /// Checks `const` declaration parsing with no spaces.
 #[test]
 fn const_declaration_no_spaces() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const a=5;",
         vec![DeclarationList::Const(
             vec![Declaration::new_with_identifier(
-                "a",
+                interner.get_or_intern_static("a"),
                 Node::from(Const::from(5)),
             )]
             .into(),
@@ -282,13 +308,19 @@ fn empty_const_declaration() {
 /// Checks multiple `const` declarations.
 #[test]
 fn multiple_const_declaration() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "const a = 5, c = 6;",
         vec![DeclarationList::Const(
             vec![
-                Declaration::new_with_identifier("a", Node::from(Const::from(5))),
-                Declaration::new_with_identifier("c", Node::from(Const::from(6))),
+                Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
+                    Node::from(Const::from(5)),
+                ),
+                Declaration::new_with_identifier(
+                    interner.get_or_intern_static("c"),
+                    Node::from(Const::from(6)),
+                ),
             ]
             .into(),
         )
diff --git a/boa/src/syntax/parser/statement/if_stm/tests.rs b/boa/src/syntax/parser/statement/if_stm/tests.rs
index b79caabbf0f..4710fe1d78e 100644
--- a/boa/src/syntax/parser/statement/if_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/if_stm/tests.rs
@@ -11,7 +11,7 @@ use crate::{
 
 #[test]
 fn if_without_else_block() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "if (true) {}",
         vec![If::new::<_, _, Node, _>(Const::from(true), Block::from(Vec::new()), None).into()],
@@ -21,7 +21,7 @@ fn if_without_else_block() {
 
 #[test]
 fn if_without_else_block_with_trailing_newline() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "if (true) {}\n",
         vec![If::new::<_, _, Node, _>(Const::from(true), Block::from(Vec::new()), None).into()],
diff --git a/boa/src/syntax/parser/statement/iteration/for_statement.rs b/boa/src/syntax/parser/statement/iteration/for_statement.rs
index c52e95b35ae..a36811676d8 100644
--- a/boa/src/syntax/parser/statement/iteration/for_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/for_statement.rs
@@ -199,7 +199,7 @@ fn node_to_iterable_loop_initializer(
     position: Position,
 ) -> Result<IterableLoopInitializer, ParseError> {
     match node {
-        Node::Identifier(ref name) => Ok(IterableLoopInitializer::Identifier(name.clone())),
+        Node::Identifier(name) => Ok(IterableLoopInitializer::Identifier(*name)),
         Node::VarDeclList(ref list) => match list.as_ref() {
             [var] => {
                 if var.init().is_some() {
diff --git a/boa/src/syntax/parser/statement/iteration/tests.rs b/boa/src/syntax/parser/statement/iteration/tests.rs
index b60d1cb4bfa..9cee454525a 100644
--- a/boa/src/syntax/parser/statement/iteration/tests.rs
+++ b/boa/src/syntax/parser/statement/iteration/tests.rs
@@ -16,7 +16,7 @@ use crate::{
 /// Checks do-while statement parsing.
 #[test]
 fn check_do_while() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"do {
             a += 1;
@@ -24,7 +24,7 @@ fn check_do_while() {
         vec![DoWhileLoop::new(
             Block::from(vec![BinOp::new(
                 AssignOp::Add,
-                Identifier::from("a"),
+                Identifier::new(interner.get_or_intern_static("a")),
                 Const::from(1),
             )
             .into()]),
@@ -38,14 +38,14 @@ fn check_do_while() {
 // Checks automatic semicolon insertion after do-while.
 #[test]
 fn check_do_while_semicolon_insertion() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"var i = 0;
         do {console.log("hello");} while(i++ < 10) console.log("end");"#,
         vec![
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "i",
+                    interner.get_or_intern_static("i"),
                     Some(Const::from(0).into()),
                 )]
                 .into(),
@@ -53,20 +53,29 @@ fn check_do_while_semicolon_insertion() {
             .into(),
             DoWhileLoop::new(
                 Block::from(vec![Call::new(
-                    GetConstField::new(Identifier::from("console"), "log"),
-                    vec![Const::from("hello").into()],
+                    GetConstField::new(
+                        Identifier::new(interner.get_or_intern_static("console")),
+                        interner.get_or_intern_static("log"),
+                    ),
+                    vec![Const::from(interner.get_or_intern_static("hello")).into()],
                 )
                 .into()]),
                 BinOp::new(
                     CompOp::LessThan,
-                    UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("i")),
+                    UnaryOp::new(
+                        op::UnaryOp::IncrementPost,
+                        Identifier::new(interner.get_or_intern_static("i")),
+                    ),
                     Const::from(10),
                 ),
             )
             .into(),
             Call::new(
-                GetConstField::new(Identifier::from("console"), "log"),
-                vec![Const::from("end").into()],
+                GetConstField::new(
+                    Identifier::new(interner.get_or_intern_static("console")),
+                    interner.get_or_intern_static("log"),
+                ),
+                vec![Const::from(interner.get_or_intern_static("end")).into()],
             )
             .into(),
         ],
@@ -78,14 +87,14 @@ fn check_do_while_semicolon_insertion() {
 // and next statement.
 #[test]
 fn check_do_while_semicolon_insertion_no_space() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"var i = 0;
         do {console.log("hello");} while(i++ < 10)console.log("end");"#,
         vec![
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "i",
+                    interner.get_or_intern_static("i"),
                     Some(Const::from(0).into()),
                 )]
                 .into(),
@@ -93,20 +102,29 @@ fn check_do_while_semicolon_insertion_no_space() {
             .into(),
             DoWhileLoop::new(
                 Block::from(vec![Call::new(
-                    GetConstField::new(Identifier::from("console"), "log"),
-                    vec![Const::from("hello").into()],
+                    GetConstField::new(
+                        Identifier::new(interner.get_or_intern_static("console")),
+                        interner.get_or_intern_static("log"),
+                    ),
+                    vec![Const::from(interner.get_or_intern_static("hello")).into()],
                 )
                 .into()]),
                 BinOp::new(
                     CompOp::LessThan,
-                    UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("i")),
+                    UnaryOp::new(
+                        op::UnaryOp::IncrementPost,
+                        Identifier::new(interner.get_or_intern_static("i")),
+                    ),
                     Const::from(10),
                 ),
             )
             .into(),
             Call::new(
-                GetConstField::new(Identifier::from("console"), "log"),
-                vec![Const::from("end").into()],
+                GetConstField::new(
+                    Identifier::new(interner.get_or_intern_static("console")),
+                    interner.get_or_intern_static("log"),
+                ),
+                vec![Const::from(interner.get_or_intern_static("end")).into()],
             )
             .into(),
         ],
@@ -117,7 +135,7 @@ fn check_do_while_semicolon_insertion_no_space() {
 /// Checks parsing of a while statement which is seperated out with line terminators.
 #[test]
 fn while_spaces() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"
 
@@ -132,7 +150,7 @@ fn while_spaces() {
         break;
 
         "#,
-        vec![WhileLoop::new(Const::from(true), Break::new::<_, Box<str>>(None)).into()],
+        vec![WhileLoop::new(Const::from(true), Break::new(None)).into()],
         &mut interner,
     );
 }
@@ -140,7 +158,7 @@ fn while_spaces() {
 /// Checks parsing of a while statement which is seperated out with line terminators.
 #[test]
 fn do_while_spaces() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"
 
@@ -156,7 +174,7 @@ fn do_while_spaces() {
 
         "#,
         vec![DoWhileLoop::new(
-            Block::from(vec![Break::new::<Option<Box<str>>, Box<str>>(None).into()]),
+            Block::from(vec![Break::new(None).into()]),
             Const::Bool(true),
         )
         .into()],
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index 69653409367..3f190597c29 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -1,5 +1,3 @@
-use std::io::Read;
-
 use crate::{
     syntax::{
         ast::{Keyword, Node, Punctuator},
@@ -14,8 +12,11 @@ use crate::{
             AllowYield, TokenParser,
         },
     },
-    BoaProfiler, Interner,
+    BoaProfiler,
 };
+use boa_interner::{Interner, Sym};
+use std::io::Read;
+
 /// Labelled Statement Parsing
 ///
 /// More information
@@ -89,7 +90,7 @@ where
     }
 }
 
-fn set_label_for_node(node: &mut Node, name: Box<str>) {
+fn set_label_for_node(node: &mut Node, name: Sym) {
     match node {
         Node::ForLoop(ref mut for_loop) => for_loop.set_label(name),
         Node::ForOfLoop(ref mut for_of_loop) => for_of_loop.set_label(name),
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 4d5cb814473..ddb39a1e494 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -29,42 +29,33 @@ use self::{
     expression::ExpressionStatement,
     if_stm::IfStatement,
     iteration::{DoWhileStatement, ForStatement, WhileStatement},
+    labelled_stm::LabelledStatement,
     return_stm::ReturnStatement,
     switch::SwitchStatement,
     throw::ThrowStatement,
     try_stm::TryStatement,
     variable::VariableStatement,
 };
-use crate::{
-    syntax::{
-        ast::node::declaration::{
-            DeclarationPattern, DeclarationPatternArray, DeclarationPatternObject,
-        },
-        parser::expression::Initializer,
-    },
-    Interner,
-};
-
 use super::{AllowAwait, AllowIn, AllowReturn, AllowYield, Cursor, ParseError, TokenParser};
-
 use crate::{
     syntax::{
         ast::{
             node::{
                 self,
-                declaration::{BindingPatternTypeArray, BindingPatternTypeObject},
+                declaration::{
+                    BindingPatternTypeArray, BindingPatternTypeObject, DeclarationPattern,
+                    DeclarationPatternArray, DeclarationPatternObject,
+                },
             },
             Keyword, Node, Punctuator,
         },
         lexer::{Error as LexError, InputElement, Position, TokenKind},
-        parser::expression::await_expr::AwaitExpression,
+        parser::expression::{await_expr::AwaitExpression, Initializer},
     },
     BoaProfiler,
 };
-use labelled_stm::LabelledStatement;
-
-use std::io::Read;
-use std::{collections::HashSet, vec};
+use boa_interner::{Interner, Sym};
+use std::{collections::HashSet, io::Read, vec};
 
 /// Statement parsing.
 ///
@@ -322,8 +313,8 @@ where
         // Handle any redeclarations
         // https://tc39.es/ecma262/#sec-block-static-semantics-early-errors
         {
-            let mut lexically_declared_names: HashSet<&str> = HashSet::new();
-            let mut var_declared_names: HashSet<&str> = HashSet::new();
+            let mut lexically_declared_names: HashSet<Sym> = HashSet::new();
+            let mut var_declared_names: HashSet<Sym> = HashSet::new();
 
             // TODO: Use more helpful positions in errors when spans are added to Nodes
             for item in &items {
@@ -334,13 +325,13 @@ where
                             // LexicallyDeclaredNames, raise an error
                             match decl {
                                 node::Declaration::Identifier { ident, .. } => {
-                                    if var_declared_names.contains(ident.as_ref())
-                                        || !lexically_declared_names.insert(ident.as_ref())
+                                    if var_declared_names.contains(&ident.sym())
+                                        || !lexically_declared_names.insert(ident.sym())
                                     {
                                         return Err(ParseError::lex(LexError::Syntax(
                                             format!(
                                                 "Redeclaration of variable `{}`",
-                                                ident.as_ref()
+                                                interner.resolve_expect(ident.sym())
                                             )
                                             .into(),
                                             match cursor.peek(0, interner)? {
@@ -352,12 +343,15 @@ where
                                 }
                                 node::Declaration::Pattern(p) => {
                                     for ident in p.idents() {
-                                        if var_declared_names.contains(ident)
-                                            || !lexically_declared_names.insert(ident.as_ref())
+                                        if var_declared_names.contains(&ident)
+                                            || !lexically_declared_names.insert(ident)
                                         {
                                             return Err(ParseError::lex(LexError::Syntax(
-                                                format!("Redeclaration of variable `{}`", ident)
-                                                    .into(),
+                                                format!(
+                                                    "Redeclaration of variable `{}`",
+                                                    interner.resolve_expect(ident)
+                                                )
+                                                .into(),
                                                 match cursor.peek(0, interner)? {
                                                     Some(token) => token.span().end(),
                                                     None => Position::new(1, 1),
@@ -374,11 +368,11 @@ where
                             match decl {
                                 node::Declaration::Identifier { ident, .. } => {
                                     // if name in LexicallyDeclaredNames, raise an error
-                                    if lexically_declared_names.contains(ident.as_ref()) {
+                                    if lexically_declared_names.contains(&ident.sym()) {
                                         return Err(ParseError::lex(LexError::Syntax(
                                             format!(
                                                 "Redeclaration of variable `{}`",
-                                                ident.as_ref()
+                                                interner.resolve_expect(ident.sym())
                                             )
                                             .into(),
                                             match cursor.peek(0, interner)? {
@@ -388,15 +382,18 @@ where
                                         )));
                                     }
                                     // otherwise, add to VarDeclaredNames
-                                    var_declared_names.insert(ident.as_ref());
+                                    var_declared_names.insert(ident.sym());
                                 }
                                 node::Declaration::Pattern(p) => {
                                     for ident in p.idents() {
                                         // if name in LexicallyDeclaredNames, raise an error
-                                        if lexically_declared_names.contains(ident) {
+                                        if lexically_declared_names.contains(&ident) {
                                             return Err(ParseError::lex(LexError::Syntax(
-                                                format!("Redeclaration of variable `{}`", ident)
-                                                    .into(),
+                                                format!(
+                                                    "Redeclaration of variable `{}`",
+                                                    interner.resolve_expect(ident)
+                                                )
+                                                .into(),
                                                 match cursor.peek(0, interner)? {
                                                     Some(token) => token.span().end(),
                                                     None => Position::new(1, 1),
@@ -404,7 +401,7 @@ where
                                             )));
                                         }
                                         // otherwise, add to VarDeclaredNames
-                                        var_declared_names.insert(ident.as_ref());
+                                        var_declared_names.insert(ident);
                                     }
                                 }
                             }
@@ -530,7 +527,7 @@ impl<R> TokenParser<R> for BindingIdentifier
 where
     R: Read,
 {
-    type Output = Box<str>;
+    type Output = Sym;
 
     /// Strict mode parsing as per <https://tc39.es/ecma262/#sec-identifiers-static-semantics-early-errors>.
     fn parse(
@@ -543,9 +540,7 @@ where
         let next_token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match next_token.kind() {
-            TokenKind::Identifier(ref s) => {
-                Ok(interner.resolve(*s).expect("string disappeared").into())
-            }
+            TokenKind::Identifier(ref s) => Ok(*s),
             TokenKind::Keyword(Keyword::Yield) if self.allow_yield.0 => {
                 // Early Error: It is a Syntax Error if this production has a [Yield] parameter and StringValue of Identifier is "yield".
                 Err(ParseError::general(
@@ -560,7 +555,7 @@ where
                         next_token.span().start(),
                     ))
                 } else {
-                    Ok("yield".into())
+                    Ok(Sym::YIELD)
                 }
             }
             TokenKind::Keyword(Keyword::Await) if self.allow_await.0 => {
@@ -577,7 +572,7 @@ where
                         next_token.span().start(),
                     ))
                 } else {
-                    Ok("await".into())
+                    Ok(Sym::AWAIT)
                 }
             }
             _ => Err(ParseError::expected(
@@ -677,7 +672,7 @@ where
                     .parse(cursor, interner)?,
             };
 
-            property_names.push(property_name.clone());
+            property_names.push(property_name);
 
             if let Some(peek_token) = cursor.peek(0, interner)? {
                 match peek_token.kind() {
@@ -686,7 +681,7 @@ where
                             Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
                                 .parse(cursor, interner)?;
                         patterns.push(BindingPatternTypeObject::SingleName {
-                            ident: property_name.clone(),
+                            ident: property_name,
                             property_name,
                             default_init: Some(init),
                         });
@@ -831,7 +826,7 @@ where
                     }
                     _ => {
                         patterns.push(BindingPatternTypeObject::SingleName {
-                            ident: property_name.clone(),
+                            ident: property_name,
                             property_name,
                             default_init: None,
                         });
diff --git a/boa/src/syntax/parser/statement/switch/tests.rs b/boa/src/syntax/parser/statement/switch/tests.rs
index 35517ee5b1b..d57bf1b6af1 100644
--- a/boa/src/syntax/parser/statement/switch/tests.rs
+++ b/boa/src/syntax/parser/statement/switch/tests.rs
@@ -151,47 +151,53 @@ fn check_seperated_switch() {
         }
         "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let log = interner.get_or_intern_static("log");
+    let console = interner.get_or_intern_static("console");
+    let a = interner.get_or_intern_static("a");
+
     check_parser(
         s,
         vec![
             DeclarationList::Let(
                 vec![Declaration::new_with_identifier(
-                    "a",
+                    a,
                     Node::from(Const::from(10)),
                 )]
                 .into(),
             )
             .into(),
             Switch::new(
-                Identifier::from("a"),
+                Identifier::new(a),
                 vec![
                     Case::new(
                         Const::from(5),
                         vec![
                             Call::new(
-                                GetConstField::new(Identifier::from("console"), "log"),
+                                GetConstField::new(Identifier::new(console), log),
                                 vec![Node::from(Const::from(5))],
                             )
                             .into(),
-                            Break::new::<_, Box<str>>(None).into(),
+                            Break::new(None).into(),
                         ],
                     ),
                     Case::new(
                         Const::from(10),
                         vec![
                             Call::new(
-                                GetConstField::new(Identifier::from("console"), "log"),
+                                GetConstField::new(Identifier::new(console), log),
                                 vec![Node::from(Const::from(10))],
                             )
                             .into(),
-                            Break::new::<_, Box<str>>(None).into(),
+                            Break::new(None).into(),
                         ],
                     ),
                 ],
                 Some(vec![Call::new(
-                    GetConstField::new(Identifier::from("console"), "log"),
-                    vec![Node::from(Const::from("Default"))],
+                    GetConstField::new(Identifier::new(console), log),
+                    vec![Node::from(Const::from(
+                        interner.get_or_intern_static("Default"),
+                    ))],
                 )
                 .into()]),
             )
diff --git a/boa/src/syntax/parser/statement/throw/tests.rs b/boa/src/syntax/parser/statement/throw/tests.rs
index e21bcd63731..89951f72ecc 100644
--- a/boa/src/syntax/parser/statement/throw/tests.rs
+++ b/boa/src/syntax/parser/statement/throw/tests.rs
@@ -8,10 +8,10 @@ use crate::{
 
 #[test]
 fn check_throw_parsing() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "throw 'error';",
-        vec![Throw::new(Const::from("error")).into()],
+        vec![Throw::new(Const::from(interner.get_or_intern_static("error"))).into()],
         &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/try_stm/catch.rs b/boa/src/syntax/parser/statement/try_stm/catch.rs
index bb239f344c0..8c1b907cc32 100644
--- a/boa/src/syntax/parser/statement/try_stm/catch.rs
+++ b/boa/src/syntax/parser/statement/try_stm/catch.rs
@@ -74,7 +74,7 @@ where
 
         let mut set = FxHashSet::default();
         let idents = match &catch_param {
-            Some(node::Declaration::Identifier { ident, .. }) => vec![ident.as_ref()],
+            Some(node::Declaration::Identifier { ident, .. }) => vec![ident.sym()],
             Some(node::Declaration::Pattern(p)) => p.idents(),
             _ => vec![],
         };
@@ -101,18 +101,18 @@ where
 
         // FIXME: `lexically_declared_names` only holds part of LexicallyDeclaredNames of the
         // Block e.g. function names are *not* included but should be.
-        let lexically_declared_names = catch_block.lexically_declared_names();
+        let lexically_declared_names = catch_block.lexically_declared_names(interner);
         let var_declared_names = catch_block.var_declared_named();
 
         for ident in set {
             // FIXME: pass correct position once #1295 lands
-            if lexically_declared_names.contains(ident) {
+            if lexically_declared_names.contains(&ident) {
                 return Err(ParseError::general(
                     "identifier redeclared",
                     Position::new(1, 1),
                 ));
             }
-            if var_declared_names.contains(ident) {
+            if var_declared_names.contains(&ident) {
                 return Err(ParseError::general(
                     "identifier redeclared",
                     Position::new(1, 1),
@@ -181,7 +181,7 @@ where
             TokenKind::Identifier(_) => {
                 let ident = BindingIdentifier::new(self.allow_yield, self.allow_await)
                     .parse(cursor, interner)
-                    .map(Identifier::from)?;
+                    .map(Identifier::new)?;
                 Ok(node::Declaration::new_with_identifier(ident, None))
             }
             _ => Err(ParseError::unexpected(
diff --git a/boa/src/syntax/parser/statement/try_stm/tests.rs b/boa/src/syntax/parser/statement/try_stm/tests.rs
index 51960e37729..72e2f2e7e67 100644
--- a/boa/src/syntax/parser/statement/try_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/try_stm/tests.rs
@@ -14,13 +14,13 @@ use crate::{
 
 #[test]
 fn check_inline_with_empty_try_catch() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try { } catch(e) {}",
         vec![Try::new(
             vec![],
             Some(Catch::new(
-                Declaration::new_with_identifier("e", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("e"), None),
                 vec![],
             )),
             None,
@@ -32,20 +32,20 @@ fn check_inline_with_empty_try_catch() {
 
 #[test]
 fn check_inline_with_var_decl_inside_try() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try { var x = 1; } catch(e) {}",
         vec![Try::new(
             vec![DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "x",
+                    interner.get_or_intern_static("x"),
                     Some(Const::from(1).into()),
                 )]
                 .into(),
             )
             .into()],
             Some(Catch::new(
-                Declaration::new_with_identifier("e", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("e"), None),
                 vec![],
             )),
             None,
@@ -57,23 +57,23 @@ fn check_inline_with_var_decl_inside_try() {
 
 #[test]
 fn check_inline_with_var_decl_inside_catch() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try { var x = 1; } catch(e) { var x = 1; }",
         vec![Try::new(
             vec![DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "x",
+                    interner.get_or_intern_static("x"),
                     Some(Const::from(1).into()),
                 )]
                 .into(),
             )
             .into()],
             Some(Catch::new(
-                Declaration::new_with_identifier("e", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("e"), None),
                 vec![DeclarationList::Var(
                     vec![Declaration::new_with_identifier(
-                        "x",
+                        interner.get_or_intern_static("x"),
                         Some(Const::from(1).into()),
                     )]
                     .into(),
@@ -89,13 +89,13 @@ fn check_inline_with_var_decl_inside_catch() {
 
 #[test]
 fn check_inline_with_empty_try_catch_finally() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try {} catch(e) {} finally {}",
         vec![Try::new(
             vec![],
             Some(Catch::new(
-                Declaration::new_with_identifier("e", None),
+                Declaration::new_with_identifier(interner.get_or_intern_static("e"), None),
                 vec![],
             )),
             Some(Finally::from(vec![])),
@@ -107,7 +107,7 @@ fn check_inline_with_empty_try_catch_finally() {
 
 #[test]
 fn check_inline_with_empty_try_finally() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try {} finally {}",
         vec![Try::new(vec![], None, Some(Finally::from(vec![]))).into()],
@@ -117,7 +117,7 @@ fn check_inline_with_empty_try_finally() {
 
 #[test]
 fn check_inline_with_empty_try_var_decl_in_finally() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try {} finally { var x = 1; }",
         vec![Try::new(
@@ -125,7 +125,7 @@ fn check_inline_with_empty_try_var_decl_in_finally() {
             None,
             Some(Finally::from(vec![DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "x",
+                    interner.get_or_intern_static("x"),
                     Some(Const::from(1).into()),
                 )]
                 .into(),
@@ -139,7 +139,7 @@ fn check_inline_with_empty_try_var_decl_in_finally() {
 
 #[test]
 fn check_inline_empty_try_paramless_catch() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try {} catch { var x = 1; }",
         vec![Try::new(
@@ -148,7 +148,7 @@ fn check_inline_empty_try_paramless_catch() {
                 None,
                 vec![DeclarationList::Var(
                     vec![Declaration::new_with_identifier(
-                        "x",
+                        interner.get_or_intern_static("x"),
                         Some(Const::from(1).into()),
                     )]
                     .into(),
@@ -164,7 +164,8 @@ fn check_inline_empty_try_paramless_catch() {
 
 #[test]
 fn check_inline_with_binding_pattern_object() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_parser(
         "try {} catch ({ a, b: c }) {}",
         vec![Try::new(
@@ -173,13 +174,13 @@ fn check_inline_with_binding_pattern_object() {
                 Some(Declaration::new_with_object_pattern(
                     vec![
                         BindingPatternTypeObject::SingleName {
-                            ident: "a".into(),
-                            property_name: "a".into(),
+                            ident: a,
+                            property_name: a,
                             default_init: None,
                         },
                         BindingPatternTypeObject::SingleName {
-                            ident: "c".into(),
-                            property_name: "b".into(),
+                            ident: interner.get_or_intern_static("c"),
+                            property_name: interner.get_or_intern_static("b"),
                             default_init: None,
                         },
                     ],
@@ -196,7 +197,7 @@ fn check_inline_with_binding_pattern_object() {
 
 #[test]
 fn check_inline_with_binding_pattern_array() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "try {} catch ([a, b]) {}",
         vec![Try::new(
@@ -205,11 +206,11 @@ fn check_inline_with_binding_pattern_array() {
                 Some(Declaration::new_with_array_pattern(
                     vec![
                         BindingPatternTypeArray::SingleName {
-                            ident: "a".into(),
+                            ident: interner.get_or_intern_static("a"),
                             default_init: None,
                         },
                         BindingPatternTypeArray::SingleName {
-                            ident: "b".into(),
+                            ident: interner.get_or_intern_static("b"),
                             default_init: None,
                         },
                     ],
diff --git a/boa/src/syntax/parser/tests.rs b/boa/src/syntax/parser/tests.rs
index d34ce8bd3da..ebf238f8c47 100644
--- a/boa/src/syntax/parser/tests.rs
+++ b/boa/src/syntax/parser/tests.rs
@@ -32,7 +32,7 @@ where
 /// Checks that the given javascript string creates a parse error.
 #[track_caller]
 pub(super) fn check_invalid(js: &str) {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     assert!(Parser::new(js.as_bytes(), false)
         .parse_all(&mut interner)
         .is_err());
@@ -41,13 +41,16 @@ pub(super) fn check_invalid(js: &str) {
 /// Should be parsed as `new Class().method()` instead of `new (Class().method())`
 #[test]
 fn check_construct_call_precedence() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "new Date().getTime()",
         vec![Node::from(Call::new(
             GetConstField::new(
-                New::from(Call::new(Identifier::from("Date"), vec![])),
-                "getTime",
+                New::from(Call::new(
+                    Identifier::new(interner.get_or_intern_static("Date")),
+                    vec![],
+                )),
+                interner.get_or_intern_static("getTime"),
             ),
             vec![],
         ))],
@@ -57,12 +60,16 @@ fn check_construct_call_precedence() {
 
 #[test]
 fn assign_operator_precedence() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         "a = a + 1",
         vec![Assign::new(
-            Identifier::from("a"),
-            BinOp::new(NumOp::Add, Identifier::from("a"), Const::from(1)),
+            Identifier::new(interner.get_or_intern_static("a")),
+            BinOp::new(
+                NumOp::Add,
+                Identifier::new(interner.get_or_intern_static("a")),
+                Const::from(1),
+            ),
         )
         .into()],
         &mut interner,
@@ -71,7 +78,9 @@ fn assign_operator_precedence() {
 
 #[test]
 fn hoisting() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let hello = interner.get_or_intern_static("hello");
+    let a = interner.get_or_intern_static("a");
     check_parser(
         r"
             var a = hello();
@@ -80,25 +89,26 @@ fn hoisting() {
             function hello() { return 10 }",
         vec![
             FunctionDecl::new(
-                Box::from("hello"),
+                hello,
                 vec![],
                 vec![Return::new(Const::from(10), None).into()],
             )
             .into(),
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "a",
-                    Node::from(Call::new(Identifier::from("hello"), vec![])),
+                    a,
+                    Node::from(Call::new(Identifier::new(hello), vec![])),
                 )]
                 .into(),
             )
             .into(),
-            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
+            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::new(a)).into(),
         ],
         &mut interner,
     );
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_parser(
         r"
             a = 10;
@@ -106,9 +116,9 @@ fn hoisting() {
 
             var a;",
         vec![
-            Assign::new(Identifier::from("a"), Const::from(10)).into(),
-            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
-            DeclarationList::Var(vec![Declaration::new_with_identifier("a", None)].into()).into(),
+            Assign::new(Identifier::new(a), Const::from(10)).into(),
+            UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::new(a)).into(),
+            DeclarationList::Var(vec![Declaration::new_with_identifier(a, None)].into()).into(),
         ],
         &mut interner,
     );
@@ -118,13 +128,21 @@ fn hoisting() {
 fn ambigous_regex_divide_expression() {
     let s = "1 / a === 1 / b";
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         s,
         vec![BinOp::new(
             CompOp::StrictEqual,
-            BinOp::new(NumOp::Div, Const::Int(1), Identifier::from("a")),
-            BinOp::new(NumOp::Div, Const::Int(1), Identifier::from("b")),
+            BinOp::new(
+                NumOp::Div,
+                Const::Int(1),
+                Identifier::new(interner.get_or_intern_static("a")),
+            ),
+            BinOp::new(
+                NumOp::Div,
+                Const::Int(1),
+                Identifier::new(interner.get_or_intern_static("b")),
+            ),
         )
         .into()],
         &mut interner,
@@ -135,16 +153,21 @@ fn ambigous_regex_divide_expression() {
 fn two_divisions_in_expression() {
     let s = "a !== 0 || 1 / a === 1 / b;";
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_parser(
         s,
         vec![BinOp::new(
             LogOp::Or,
-            BinOp::new(CompOp::StrictNotEqual, Identifier::from("a"), Const::Int(0)),
+            BinOp::new(CompOp::StrictNotEqual, Identifier::new(a), Const::Int(0)),
             BinOp::new(
                 CompOp::StrictEqual,
-                BinOp::new(NumOp::Div, Const::Int(1), Identifier::from("a")),
-                BinOp::new(NumOp::Div, Const::Int(1), Identifier::from("b")),
+                BinOp::new(NumOp::Div, Const::Int(1), Identifier::new(a)),
+                BinOp::new(
+                    NumOp::Div,
+                    Const::Int(1),
+                    Identifier::new(interner.get_or_intern_static("b")),
+                ),
             ),
         )
         .into()],
@@ -159,21 +182,21 @@ fn comment_semi_colon_insertion() {
     let b = 20;
     "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         s,
         vec![
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "a",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
                     Some(Const::Int(10).into()),
                 )]
                 .into(),
             )
             .into(),
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "b",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("b"),
                     Some(Const::Int(20).into()),
                 )]
                 .into(),
@@ -193,21 +216,21 @@ fn multiline_comment_semi_colon_insertion() {
     */ let b = 20;
     "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         s,
         vec![
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "a",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
                     Some(Const::Int(10).into()),
                 )]
                 .into(),
             )
             .into(),
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "b",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("b"),
                     Some(Const::Int(20).into()),
                 )]
                 .into(),
@@ -224,21 +247,21 @@ fn multiline_comment_no_lineterminator() {
     let a = 10; /* Test comment */ let b = 20;
     "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         s,
         vec![
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "a",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
                     Some(Const::Int(10).into()),
                 )]
                 .into(),
             )
             .into(),
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "b",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("b"),
                     Some(Const::Int(20).into()),
                 )]
                 .into(),
@@ -258,19 +281,23 @@ fn assignment_line_terminator() {
     5;
     "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         s,
         vec![
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "a",
+                vec![Declaration::new_with_identifier(
+                    interner.get_or_intern_static("a"),
                     Some(Const::Int(3).into()),
                 )]
                 .into(),
             )
             .into(),
-            Assign::new(Identifier::from("a"), Const::from(5)).into(),
+            Assign::new(
+                Identifier::new(interner.get_or_intern_static("a")),
+                Const::from(5),
+            )
+            .into(),
         ],
         &mut interner,
     );
@@ -288,19 +315,20 @@ fn assignment_multiline_terminator() {
     5;
     "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_parser(
         s,
         vec![
             DeclarationList::Let(
-                vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                    "a",
+                vec![Declaration::new_with_identifier(
+                    a,
                     Some(Const::Int(3).into()),
                 )]
                 .into(),
             )
             .into(),
-            Assign::new(Identifier::from("a"), Const::from(5)).into(),
+            Assign::new(Identifier::new(a), Const::from(5)).into(),
         ],
         &mut interner,
     );
@@ -310,21 +338,26 @@ fn assignment_multiline_terminator() {
 fn bracketed_expr() {
     let s = r#"(b)"#;
 
-    let mut interner = Interner::new();
-    check_parser(s, vec![Identifier::from("b").into()], &mut interner);
+    let mut interner = Interner::default();
+    check_parser(
+        s,
+        vec![Identifier::new(interner.get_or_intern_static("b")).into()],
+        &mut interner,
+    );
 }
 
 #[test]
 fn increment_in_comma_op() {
     let s = r#"(b++, b)"#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let b = interner.get_or_intern_static("b");
     check_parser(
         s,
         vec![BinOp::new::<_, Node, Node>(
             op::BinOp::Comma,
-            UnaryOp::new::<Node>(op::UnaryOp::IncrementPost, Identifier::from("b").into()).into(),
-            Identifier::from("b").into(),
+            UnaryOp::new::<Node>(op::UnaryOp::IncrementPost, Identifier::new(b).into()).into(),
+            Identifier::new(b).into(),
         )
         .into()],
         &mut interner,
@@ -340,17 +373,18 @@ fn spread_in_object() {
     }
     "#;
 
+    let mut interner = Interner::default();
+
     let object_properties = vec![
-        PropertyDefinition::property("a", Const::from(1)),
-        PropertyDefinition::spread_object(Identifier::from("b")),
+        PropertyDefinition::property(interner.get_or_intern_static("a"), Const::from(1)),
+        PropertyDefinition::spread_object(Identifier::new(interner.get_or_intern_static("b"))),
     ];
 
-    let mut interner = Interner::new();
     check_parser(
         s,
         vec![DeclarationList::Let(
-            vec![Declaration::new_with_identifier::<&str, Option<Node>>(
-                "x",
+            vec![Declaration::new_with_identifier(
+                interner.get_or_intern_static("x"),
                 Some(Object::from(object_properties).into()),
             )]
             .into(),
@@ -368,16 +402,17 @@ fn spread_in_arrow_function() {
     }
     "#;
 
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let b = interner.get_or_intern_static("b");
     check_parser(
         s,
         vec![
             ArrowFunctionDecl::new::<Box<[FormalParameter]>, StatementList>(
                 Box::new([FormalParameter::new(
-                    Declaration::new_with_identifier("b", None),
+                    Declaration::new_with_identifier::<_, Option<Node>>(b, None),
                     true,
                 )]),
-                vec![Identifier::from("b").into()].into(),
+                vec![Identifier::new(b).into()].into(),
             )
             .into(),
         ],
@@ -387,7 +422,8 @@ fn spread_in_arrow_function() {
 
 #[test]
 fn empty_statement() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
+    let a = interner.get_or_intern_static("a");
     check_parser(
         r"
             ;;var a = 10;
@@ -397,14 +433,14 @@ fn empty_statement() {
             Node::Empty,
             DeclarationList::Var(
                 vec![Declaration::new_with_identifier(
-                    "a",
+                    a,
                     Node::from(Const::from(10)),
                 )]
                 .into(),
             )
             .into(),
             Node::If(If::new::<_, _, Node, _>(
-                Identifier::from("a"),
+                Identifier::new(a),
                 Node::Empty,
                 None,
             )),
@@ -415,7 +451,7 @@ fn empty_statement() {
 
 #[test]
 fn hashbang_use_strict_no_with() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"#!\"use strict"
         "#,
@@ -427,7 +463,7 @@ fn hashbang_use_strict_no_with() {
 #[test]
 #[ignore]
 fn hashbang_use_strict_with_with_statement() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(
         r#"#!\"use strict"
         
@@ -440,6 +476,6 @@ fn hashbang_use_strict_with_with_statement() {
 
 #[test]
 fn hashbang_comment() {
-    let mut interner = Interner::new();
+    let mut interner = Interner::default();
     check_parser(r"#!Comment Here", vec![], &mut interner);
 }
diff --git a/boa/src/tests.rs b/boa/src/tests.rs
index 004932f125c..53a5d6fae81 100644
--- a/boa/src/tests.rs
+++ b/boa/src/tests.rs
@@ -1331,7 +1331,6 @@ fn multicharacter_assignment_to_non_assignable() {
 }
 
 #[test]
-#[ignore]
 fn multicharacter_bitwise_assignment_to_non_assignable() {
     let mut context = Context::default();
 
diff --git a/boa/src/value/mod.rs b/boa/src/value/mod.rs
index e7799d595cb..cdcb74fc608 100644
--- a/boa/src/value/mod.rs
+++ b/boa/src/value/mod.rs
@@ -10,12 +10,12 @@ use crate::{
         number::{f64_to_int32, f64_to_uint32},
         Number,
     },
+    gc::{Finalize, Trace},
     object::{JsObject, ObjectData},
     property::{PropertyDescriptor, PropertyKey},
     symbol::{JsSymbol, WellKnownSymbols},
     BoaProfiler, Context, JsBigInt, JsResult, JsString,
 };
-use gc::{Finalize, Trace};
 use num_bigint::BigInt;
 use num_integer::Integer;
 use num_traits::Zero;
diff --git a/boa/src/vm/call_frame.rs b/boa/src/vm/call_frame.rs
index edcc726209a..cc2d0107c63 100644
--- a/boa/src/vm/call_frame.rs
+++ b/boa/src/vm/call_frame.rs
@@ -2,8 +2,7 @@
 //! This module will provides everything needed to implement the CallFrame
 
 use super::CodeBlock;
-use crate::JsValue;
-use gc::Gc;
+use crate::{gc::Gc, JsValue};
 
 #[derive(Debug)]
 pub struct CallFrame {
diff --git a/boa/src/vm/code_block.rs b/boa/src/vm/code_block.rs
index d8b5efa879a..12538a1932b 100644
--- a/boa/src/vm/code_block.rs
+++ b/boa/src/vm/code_block.rs
@@ -12,15 +12,15 @@ use crate::{
         function_environment_record::{BindingStatus, FunctionEnvironmentRecord},
         lexical_environment::Environment,
     },
-    gc::{Finalize, Trace},
+    gc::{Finalize, Gc, Trace},
     object::{internal_methods::get_prototype_from_constructor, JsObject, ObjectData},
     property::PropertyDescriptor,
     syntax::ast::node::FormalParameter,
     vm::{call_frame::FinallyReturn, CallFrame, Opcode},
     Context, JsResult, JsString, JsValue,
 };
-use gc::Gc;
-use std::{convert::TryInto, fmt::Write, mem::size_of};
+use boa_interner::{Interner, Sym, ToInternedString};
+use std::{convert::TryInto, mem::size_of};
 
 /// This represents whether a value can be read from [`CodeBlock`] code.
 ///
@@ -51,7 +51,7 @@ unsafe impl Readable for f64 {}
 #[derive(Clone, Debug, Trace, Finalize)]
 pub struct CodeBlock {
     /// Name of this function
-    pub(crate) name: JsString,
+    pub(crate) name: Sym,
 
     /// The number of arguments expected.
     pub(crate) length: u32,
@@ -86,7 +86,7 @@ pub struct CodeBlock {
 
 impl CodeBlock {
     /// Constructs a new `CodeBlock`.
-    pub fn new(name: JsString, length: u32, strict: bool, constructor: bool) -> Self {
+    pub fn new(name: Sym, length: u32, strict: bool, constructor: bool) -> Self {
         Self {
             code: Vec::new(),
             literals: Vec::new(),
@@ -189,7 +189,7 @@ impl CodeBlock {
                 let operand = self.read::<u32>(*pc);
                 *pc += size_of::<u32>();
                 format!(
-                    "{:04}: '{}' (length: {})",
+                    "{:04}: '{:?}' (length: {})",
                     operand,
                     self.functions[operand as usize].name,
                     self.functions[operand as usize].length
@@ -214,7 +214,7 @@ impl CodeBlock {
             | Opcode::CopyDataProperties => {
                 let operand = self.read::<u32>(*pc);
                 *pc += size_of::<u32>();
-                format!("{:04}: '{}'", operand, self.variables[operand as usize])
+                format!("{:04}: '{:?}'", operand, self.variables[operand as usize])
             }
             Opcode::Pop
             | Opcode::Dup
@@ -296,79 +296,75 @@ impl CodeBlock {
     }
 }
 
-impl std::fmt::Display for CodeBlock {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.name != "<main>" {
-            f.write_char('\n')?;
-        }
+impl ToInternedString for CodeBlock {
+    fn to_interned_string(&self, interner: &Interner) -> String {
+        let name = interner.resolve_expect(self.name);
+        let mut f = if self.name == Sym::MAIN {
+            String::new()
+        } else {
+            "\n".to_owned()
+        };
 
-        writeln!(
-            f,
-            "{:-^width$}",
-            format!("Compiled Output: '{}'", self.name),
+        f.push_str(&format!(
+            "{:-^width$}\n    Location  Count   Opcode                     Operands\n\n",
+            format!("Compiled Output: '{}'", name),
             width = 70
-        )?;
-
-        writeln!(
-            f,
-            "    Location  Count   Opcode                     Operands"
-        )?;
-
-        f.write_char('\n')?;
+        ));
 
         let mut pc = 0;
         let mut count = 0;
         while pc < self.code.len() {
             let opcode: Opcode = self.code[pc].try_into().unwrap();
-            write!(
-                f,
-                "    {:06}    {:04}    {:<27}",
+            let operands = self.instruction_operands(&mut pc);
+            f.push_str(&format!(
+                "    {:06}    {:04}    {:<27}\n{}",
                 pc,
                 count,
-                opcode.as_str()
-            )?;
-            writeln!(f, "{}", self.instruction_operands(&mut pc))?;
+                opcode.as_str(),
+                operands
+            ));
             count += 1;
         }
 
-        f.write_char('\n')?;
+        f.push_str("\nLiterals:\n");
 
-        f.write_str("Literals:\n")?;
         if !self.literals.is_empty() {
             for (i, value) in self.literals.iter().enumerate() {
-                writeln!(f, "    {:04}: <{}> {}", i, value.type_of(), value.display())?;
+                f.push_str(&format!(
+                    "    {:04}: <{}> {}\n",
+                    i,
+                    value.type_of(),
+                    value.display()
+                ));
             }
         } else {
-            writeln!(f, "    <empty>")?;
+            f.push_str("    <empty>");
         }
 
-        f.write_char('\n')?;
-
-        f.write_str("Names:\n")?;
+        f.push_str("\nNames:\n");
         if !self.variables.is_empty() {
             for (i, value) in self.variables.iter().enumerate() {
-                writeln!(f, "    {:04}: {}", i, value)?;
+                f.push_str(&format!("    {:04}: {}\n", i, value));
             }
         } else {
-            writeln!(f, "    <empty>")?;
+            f.push_str("    <empty>");
         }
 
-        f.write_char('\n')?;
-
-        f.write_str("Functions:\n")?;
+        f.push_str("\nFunctions:\n");
         if !self.functions.is_empty() {
             for (i, code) in self.functions.iter().enumerate() {
-                writeln!(
-                    f,
-                    "    {:04}: name: '{}' (length: {})",
-                    i, code.name, code.length
-                )?;
+                f.push_str(&format!(
+                    "    {:04}: name: '{}' (length: {})\n",
+                    i,
+                    interner.resolve_expect(code.name),
+                    code.length
+                ));
             }
         } else {
-            writeln!(f, "    <empty>")?;
+            f.push_str("    <empty>");
         }
 
-        Ok(())
+        f
     }
 }
 
@@ -384,7 +380,7 @@ impl JsVmFunction {
         let prototype = context.construct_object();
 
         let name_property = PropertyDescriptor::builder()
-            .value(code.name.clone())
+            .value(context.interner().resolve_expect(code.name))
             .writable(false)
             .enumerable(false)
             .configurable(true)
@@ -536,10 +532,11 @@ impl JsObject {
                 let mut is_simple_parameter_list = true;
                 let mut has_parameter_expressions = false;
 
+                let arguments = Sym::ARGUMENTS;
                 for param in code.params.iter() {
                     has_parameter_expressions = has_parameter_expressions || param.init().is_some();
                     arguments_in_parameter_names =
-                        arguments_in_parameter_names || param.names().contains(&"arguments");
+                        arguments_in_parameter_names || param.names().contains(&arguments);
                     is_simple_parameter_list = is_simple_parameter_list
                         && !param.is_rest_param()
                         && param.is_identifier()
@@ -569,8 +566,8 @@ impl JsObject {
                                 context,
                             )
                         };
-                    local_env.create_mutable_binding("arguments", false, true, context)?;
-                    local_env.initialize_binding("arguments", arguments_obj.into(), context)?;
+                    local_env.create_mutable_binding(arguments, false, true, context)?;
+                    local_env.initialize_binding(arguments, arguments_obj.into(), context)?;
                 }
 
                 let arg_count = args.len();
@@ -709,7 +706,7 @@ impl JsObject {
                 for param in code.params.iter() {
                     has_parameter_expressions = has_parameter_expressions || param.init().is_some();
                     arguments_in_parameter_names =
-                        arguments_in_parameter_names || param.names().contains(&"arguments");
+                        arguments_in_parameter_names || param.names().contains(&Sym::ARGUMENTS);
                     is_simple_parameter_list = is_simple_parameter_list
                         && !param.is_rest_param()
                         && param.is_identifier()
@@ -739,8 +736,8 @@ impl JsObject {
                                 context,
                             )
                         };
-                    local_env.create_mutable_binding("arguments", false, true, context)?;
-                    local_env.initialize_binding("arguments", arguments_obj.into(), context)?;
+                    local_env.create_mutable_binding(Sym::ARGUMENTS, false, true, context)?;
+                    local_env.initialize_binding(Sym::ARGUMENTS, arguments_obj.into(), context)?;
                 }
 
                 let arg_count = args.len();
diff --git a/boa/src/vm/mod.rs b/boa/src/vm/mod.rs
index e6c1930f397..48ed3db4632 100644
--- a/boa/src/vm/mod.rs
+++ b/boa/src/vm/mod.rs
@@ -14,6 +14,7 @@ use crate::{
     vm::{call_frame::CatchAddresses, code_block::Readable},
     BoaProfiler, Context, JsBigInt, JsResult, JsString, JsValue,
 };
+use boa_interner::ToInternedString;
 use std::{convert::TryInto, mem::size_of, ops::Neg, time::Instant};
 
 mod call_frame;
@@ -300,71 +301,79 @@ impl Context {
             }
             Opcode::DefInitArg => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
                 let value = self.vm.pop();
                 let local_env = self.get_current_environment();
                 local_env
-                    .create_mutable_binding(name.as_ref(), false, true, self)
+                    .create_mutable_binding(name, false, true, self)
                     .expect("Failed to create argument binding");
-                self.initialize_binding(name.as_ref(), value)?;
+                self.initialize_binding(name, value)?;
             }
             Opcode::DefVar => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
 
-                if !self.has_binding(name.as_ref())? {
-                    self.create_mutable_binding(name.as_ref(), false, VariableScope::Function)?;
-                    self.initialize_binding(name.as_ref(), JsValue::Undefined)?;
+                if !self.has_binding(name)? {
+                    self.create_mutable_binding(name, false, VariableScope::Function)?;
+                    self.initialize_binding(name, JsValue::Undefined)?;
                 }
             }
             Opcode::DefInitVar => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
                 let value = self.vm.pop();
 
-                if self.has_binding(name.as_ref())? {
-                    self.set_mutable_binding(name.as_ref(), value, self.strict())?;
+                if self.has_binding(name)? {
+                    self.set_mutable_binding(name, value, self.strict())?;
                 } else {
-                    self.create_mutable_binding(name.as_ref(), false, VariableScope::Function)?;
-                    self.initialize_binding(name.as_ref(), value)?;
+                    self.create_mutable_binding(name, false, VariableScope::Function)?;
+                    self.initialize_binding(name, value)?;
                 }
             }
             Opcode::DefLet => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
 
-                self.create_mutable_binding(name.as_ref(), false, VariableScope::Block)?;
-                self.initialize_binding(name.as_ref(), JsValue::Undefined)?;
+                self.create_mutable_binding(name, false, VariableScope::Block)?;
+                self.initialize_binding(name, JsValue::Undefined)?;
             }
             Opcode::DefInitLet => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
                 let value = self.vm.pop();
 
-                self.create_mutable_binding(name.as_ref(), false, VariableScope::Block)?;
-                self.initialize_binding(name.as_ref(), value)?;
+                self.create_mutable_binding(name, false, VariableScope::Block)?;
+                self.initialize_binding(name, value)?;
             }
             Opcode::DefInitConst => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
                 let value = self.vm.pop();
 
-                self.create_immutable_binding(name.as_ref(), true, VariableScope::Block)?;
-                self.initialize_binding(name.as_ref(), value)?;
+                self.create_immutable_binding(name, true, VariableScope::Block)?;
+                self.initialize_binding(name, value)?;
             }
             Opcode::GetName => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
 
-                let value = self.get_binding_value(&name)?;
+                let value = self.get_binding_value(name)?;
                 self.vm.push(value);
             }
             Opcode::GetNameOrUndefined => {
                 let index = self.vm.read::<u32>();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
 
-                let value = if self.has_binding(&name)? {
-                    self.get_binding_value(&name)?
+                let value = if self.has_binding(name)? {
+                    self.get_binding_value(name)?
                 } else {
                     JsValue::Undefined
                 };
@@ -373,10 +382,11 @@ impl Context {
             Opcode::SetName => {
                 let index = self.vm.read::<u32>();
                 let value = self.vm.pop();
-                let name = self.vm.frame().code.variables[index as usize].clone();
+                let name_str = self.vm.frame().code.variables[index as usize].clone();
+                let name = self.interner_mut().get_or_intern(name_str);
 
                 self.set_mutable_binding(
-                    name.as_ref(),
+                    name,
                     value,
                     self.strict() || self.vm.frame().code.strict,
                 )?;
@@ -1121,7 +1131,10 @@ impl Context {
                 " VM Start "
             };
 
-            println!("{}\n", self.vm.frame().code);
+            println!(
+                "{}\n",
+                self.vm.frame().code.to_interned_string(self.interner())
+            );
             println!(
                 "{:-^width$}",
                 msg,
diff --git a/boa_cli/Cargo.toml b/boa_cli/Cargo.toml
index 5183e437a0e..d6c9530ccd1 100644
--- a/boa_cli/Cargo.toml
+++ b/boa_cli/Cargo.toml
@@ -17,7 +17,7 @@ Boa = { path = "../boa", features = ["deser", "console"] }
 rustyline = "9.1.2"
 rustyline-derive = "0.6.0"
 structopt = "0.3.26"
-serde_json = "1.0.75"
+serde_json = "1.0.76"
 colored = "2.0.0"
 regex = "1.5.4"
 lazy_static = "1.4.0"
diff --git a/boa_cli/src/main.rs b/boa_cli/src/main.rs
index 6e95878944f..6ed3de6c34a 100644
--- a/boa_cli/src/main.rs
+++ b/boa_cli/src/main.rs
@@ -135,7 +135,7 @@ where
     S: AsRef<[u8]>,
 {
     if let Some(ref arg) = args.dump_ast {
-        let mut interner = Interner::new();
+        let mut interner = Interner::default();
         let ast = parse_tokens(src, &mut interner)?;
 
         match arg {
diff --git a/boa_interner/Cargo.toml b/boa_interner/Cargo.toml
index 0cecdd2b997..6d9aaff3d2d 100644
--- a/boa_interner/Cargo.toml
+++ b/boa_interner/Cargo.toml
@@ -12,3 +12,4 @@ rust-version = "1.56"
 [dependencies]
 string-interner = "0.14.0"
 serde = { version = "1.0.134", features = ["derive"], optional = true }
+gc = { version = "0.4.1", features = ["derive"] }
diff --git a/boa_interner/src/lib.rs b/boa_interner/src/lib.rs
index b55a7a3d892..ccbae18565e 100644
--- a/boa_interner/src/lib.rs
+++ b/boa_interner/src/lib.rs
@@ -41,36 +41,285 @@
     rustdoc::missing_doc_code_examples
 )]
 
-use std::num::NonZeroUsize;
+#[cfg(test)]
+mod tests;
 
+use std::{fmt::Display, num::NonZeroUsize};
+
+use gc::{unsafe_empty_trace, Finalize, Trace};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 use string_interner::{backend::BucketBackend, StringInterner, Symbol};
 
+/// Backend of the string interner.
+type Backend = BucketBackend<Sym>;
+
 /// The string interner for Boa.
 ///
 /// This is a type alias that makes it easier to reference it in the code.
-pub type Interner = StringInterner<BucketBackend<Sym>>;
+#[derive(Debug)]
+pub struct Interner {
+    inner: StringInterner<Backend>,
+}
+
+impl Interner {
+    /// Creates a new StringInterner with the given initial capacity.
+    #[inline]
+    pub fn with_capacity(cap: usize) -> Self {
+        Self {
+            inner: StringInterner::with_capacity(cap),
+        }
+    }
+
+    /// Returns the number of strings interned by the interner.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns `true` if the string interner has no interned strings.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    /// Returns the symbol for the given string if any.
+    ///
+    /// Can be used to query if a string has already been interned without interning.
+    pub fn get<T>(&self, string: T) -> Option<Sym>
+    where
+        T: AsRef<str>,
+    {
+        let string = string.as_ref();
+        Self::get_static(string).or_else(|| self.inner.get(string))
+    }
+
+    /// Interns the given string.
+    ///
+    /// Returns a symbol for resolution into the original string.
+    ///
+    /// # Panics
+    /// If the interner already interns the maximum number of strings possible by the chosen symbol type.
+    pub fn get_or_intern<T>(&mut self, string: T) -> Sym
+    where
+        T: AsRef<str>,
+    {
+        let string = string.as_ref();
+        Self::get_static(string).unwrap_or_else(|| self.inner.get_or_intern(string))
+    }
+
+    /// Interns the given `'static` string.
+    ///
+    /// Returns a symbol for resolution into the original string.
+    ///
+    /// # Note
+    ///
+    /// This is more efficient than [`StringInterner::get_or_intern`] since it might
+    /// avoid some memory allocations if the backends supports this.
+    ///
+    /// # Panics
+    ///
+    /// If the interner already interns the maximum number of strings possible
+    /// by the chosen symbol type.
+    pub fn get_or_intern_static(&mut self, string: &'static str) -> Sym {
+        Self::get_static(string).unwrap_or_else(|| self.inner.get_or_intern_static(string))
+    }
+
+    /// Shrink backend capacity to fit the interned strings exactly.
+    #[inline]
+    pub fn shrink_to_fit(&mut self) {
+        self.inner.shrink_to_fit()
+    }
+
+    /// Returns the string for the given symbol if any.
+    #[inline]
+    pub fn resolve(&self, symbol: Sym) -> Option<&str> {
+        let index = symbol.as_raw().get();
+        if index <= Self::STATIC_STRINGS.len() {
+            Some(Self::STATIC_STRINGS[index - 1])
+        } else {
+            self.inner.resolve(symbol)
+        }
+    }
+
+    /// Returns the string for the given symbol.
+    ///
+    /// # Panics
+    ///
+    /// If the interner cannot resolve the given symbol.
+    #[inline]
+    pub fn resolve_expect(&self, symbol: Sym) -> &str {
+        self.resolve(symbol).expect("string disappeared")
+    }
+
+    /// Gets the symbol of the static string if one of them
+    fn get_static(string: &str) -> Option<Sym> {
+        Self::STATIC_STRINGS
+            .into_iter()
+            .enumerate()
+            .find(|&(_i, s)| string == s)
+            .map(|(i, _str)| {
+                let raw = NonZeroUsize::new(i.wrapping_add(1)).expect("static array too big");
+                Sym::from_raw(raw)
+            })
+    }
+}
+
+impl<T> FromIterator<T> for Interner
+where
+    T: AsRef<str>,
+{
+    #[inline]
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        Self {
+            inner: StringInterner::from_iter(iter),
+        }
+    }
+}
+
+impl<T> Extend<T> for Interner
+where
+    T: AsRef<str>,
+{
+    #[inline]
+    fn extend<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.inner.extend(iter)
+    }
+}
+
+impl<'a> IntoIterator for &'a Interner {
+    type Item = (Sym, &'a str);
+    type IntoIter = <&'a Backend as IntoIterator>::IntoIter;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.inner.into_iter()
+    }
+}
+
+impl Default for Interner {
+    fn default() -> Self {
+        Self {
+            inner: StringInterner::new(),
+        }
+    }
+}
 
 /// The string symbol type for Boa.
 ///
 /// This symbol type is internally a `NonZeroUsize`, which makes it pointer-width in size and it's
-/// optimized so that it can ocupy 1 pointer width even in an `Option` type.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+/// optimized so that it can occupy 1 pointer width even in an `Option` type.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Finalize)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(transparent))]
 pub struct Sym {
     value: NonZeroUsize,
 }
 
+impl Sym {
+    /// Padding for the symbol internal value.
+    const PADDING: usize = Interner::STATIC_STRINGS.len() + 1;
+
+    /// Symbol for the empty string (`""`).
+    pub const EMPTY_STRING: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(1)) };
+
+    /// Symbol for the `"arguments"` string.
+    pub const ARGUMENTS: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(2)) };
+
+    /// Symbol for the `"await"` string.
+    pub const AWAIT: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(3)) };
+
+    /// Symbol for the `"yield"` string.
+    pub const YIELD: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(4)) };
+
+    /// Symbol for the `"eval"` string.
+    pub const EVAL: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(5)) };
+
+    /// Symbol for the `"default"` string.
+    pub const DEFAULT: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(6)) };
+
+    /// Symbol for the `"null"` string.
+    pub const NULL: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(7)) };
+
+    /// Symbol for the `"RegExp"` string.
+    pub const REGEXP: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(8)) };
+
+    /// Symbol for the `"get"` string.
+    pub const GET: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(9)) };
+
+    /// Symbol for the `"set"` string.
+    pub const SET: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(10)) };
+
+    /// Symbol for the `"<main>"` string.
+    pub const MAIN: Self = unsafe { Self::from_raw(NonZeroUsize::new_unchecked(11)) };
+
+    /// Creates a `Sym` from a raw `NonZeroUsize`.
+    const fn from_raw(value: NonZeroUsize) -> Self {
+        Self { value }
+    }
+
+    /// Retrieves the raw `NonZeroUsize` for this symbol.`
+    const fn as_raw(self) -> NonZeroUsize {
+        self.value
+    }
+}
+
 impl Symbol for Sym {
     #[inline]
     fn try_from_usize(index: usize) -> Option<Self> {
-        NonZeroUsize::new(index.wrapping_add(1)).map(|value| Self { value })
+        index
+            .checked_add(Self::PADDING)
+            .and_then(NonZeroUsize::new)
+            .map(|value| Self { value })
     }
 
     #[inline]
     fn to_usize(self) -> usize {
-        self.value.get() - 1
+        self.value.get() - Self::PADDING
     }
 }
+
+// Safe because `Sym` implements `Copy`.
+unsafe impl Trace for Sym {
+    unsafe_empty_trace!();
+}
+
+/// Converts a given element to a string using an interner.
+pub trait ToInternedString {
+    /// Converts a given element to a string using an interner.
+    fn to_interned_string(&self, interner: &Interner) -> String;
+}
+
+impl<T> ToInternedString for T
+where
+    T: Display,
+{
+    fn to_interned_string(&self, _interner: &Interner) -> String {
+        format!("{}", self)
+    }
+}
+
+impl Interner {
+    /// List of commonly used static strings.
+    ///
+    /// Make sure that any string added as a `Sym` constant is also added here.
+    const STATIC_STRINGS: [&'static str; 11] = [
+        "",
+        "arguments",
+        "await",
+        "yield",
+        "eval",
+        "default",
+        "null",
+        "RegExp",
+        "get",
+        "set",
+        "<main>",
+    ];
+}
diff --git a/boa_interner/src/tests.rs b/boa_interner/src/tests.rs
new file mode 100644
index 00000000000..bb6de0359f4
--- /dev/null
+++ b/boa_interner/src/tests.rs
@@ -0,0 +1,75 @@
+use crate::{Interner, Sym};
+use std::num::NonZeroUsize;
+
+#[track_caller]
+fn sym_from_usize(index: usize) -> Sym {
+    Sym::from_raw(NonZeroUsize::new(index).expect("Invalid NonZeroUsize"))
+}
+
+#[test]
+fn check_static_strings() {
+    let mut interner = Interner::default();
+
+    for (i, str) in Interner::STATIC_STRINGS.into_iter().enumerate() {
+        assert_eq!(interner.get_or_intern(str), sym_from_usize(i + 1))
+    }
+}
+
+#[test]
+fn check_constants() {
+    assert_eq!(Sym::EMPTY_STRING, sym_from_usize(1));
+    assert_eq!(Sym::ARGUMENTS, sym_from_usize(2));
+    assert_eq!(Sym::AWAIT, sym_from_usize(3));
+    assert_eq!(Sym::YIELD, sym_from_usize(4));
+    assert_eq!(Sym::EVAL, sym_from_usize(5));
+    assert_eq!(Sym::DEFAULT, sym_from_usize(6));
+    assert_eq!(Sym::NULL, sym_from_usize(7));
+    assert_eq!(Sym::REGEXP, sym_from_usize(8));
+    assert_eq!(Sym::GET, sym_from_usize(9));
+    assert_eq!(Sym::SET, sym_from_usize(10));
+    assert_eq!(Sym::MAIN, sym_from_usize(11));
+}
+
+#[test]
+fn check_new_string() {
+    let mut interner = Interner::default();
+
+    assert!(
+        interner.get_or_intern("my test string").as_raw().get() > Interner::STATIC_STRINGS.len()
+    );
+}
+
+#[test]
+fn check_resolve() {
+    let mut interner = Interner::default();
+
+    let strings = ["test string", "arguments", "hello"];
+
+    for string in strings {
+        let sym = interner.get_or_intern(string);
+        let resolved = interner.resolve(sym).unwrap();
+        assert_eq!(string, resolved);
+
+        let new_sym = interner.get_or_intern(string);
+
+        assert_eq!(sym, new_sym);
+    }
+}
+
+#[test]
+fn check_static_resolve() {
+    let mut interner = Interner::default();
+
+    for string in Interner::STATIC_STRINGS
+        .into_iter()
+        .chain(["my test str", "hello world", ";"].into_iter())
+    {
+        let sym = interner.get_or_intern_static(string);
+        let resolved = interner.resolve(sym).unwrap();
+        assert_eq!(string, resolved);
+
+        let new_sym = interner.get_or_intern(string);
+
+        assert_eq!(sym, new_sym);
+    }
+}
diff --git a/boa_tester/Cargo.toml b/boa_tester/Cargo.toml
index c297c96939d..506a99db47b 100644
--- a/boa_tester/Cargo.toml
+++ b/boa_tester/Cargo.toml
@@ -16,7 +16,7 @@ Boa = { path = "../boa" }
 structopt = "0.3.26"
 serde = { version = "1.0.134", features = ["derive"] }
 serde_yaml = "0.8.23"
-serde_json = "1.0.75"
+serde_json = "1.0.76"
 bitflags = "1.3.2"
 regex = "1.5.4"
 once_cell = "1.9.0"
diff --git a/boa_tester/src/exec/mod.rs b/boa_tester/src/exec/mod.rs
index a55d72bb8c4..99ec70053d9 100644
--- a/boa_tester/src/exec/mod.rs
+++ b/boa_tester/src/exec/mod.rs
@@ -181,7 +181,7 @@ impl Test {
                         self.name
                     );
 
-                    let mut interner = Interner::new();
+                    let mut interner = Interner::default();
                     match Parser::new(self.content.as_bytes(), strict).parse_all(&mut interner) {
                         Ok(n) => (false, format!("{:?}", n)),
                         Err(e) => (true, format!("Uncaught {}", e)),
@@ -195,7 +195,7 @@ impl Test {
                     phase: Phase::Runtime,
                     ref error_type,
                 } => {
-                    let mut interner = Interner::new();
+                    let mut interner = Interner::default();
                     if let Err(e) =
                         Parser::new(self.content.as_bytes(), strict).parse_all(&mut interner)
                     {
diff --git a/boa_wasm/Cargo.toml b/boa_wasm/Cargo.toml
index e460c5b627b..060792c3e1a 100644
--- a/boa_wasm/Cargo.toml
+++ b/boa_wasm/Cargo.toml
@@ -14,7 +14,7 @@ rust-version = "1.56"
 [dependencies]
 Boa = { path = "../boa", features = ["console"] }
 wasm-bindgen = "=0.2.78"
-getrandom = { version = "0.2.4", features = ["js"] }
+getrandom = { version = "0.2.3", features = ["js"] }
 
 [lib]
 crate-type = ["cdylib", "lib"]
diff --git a/yarn.lock b/yarn.lock
index 44e65a79dda..e36d303c2ca 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -67,9 +67,9 @@
     "@types/estree" "*"
 
 "@types/eslint@*":
-  version "8.4.0"
-  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.4.0.tgz#95712d5b32fd99a0d9493c31c6197ea7471c3ba6"
-  integrity sha512-JUYa/5JwoqikCy7O7jKtuNe9Z4ZZt615G+1EKfaDGSNEpzaA2OwbV/G1v08Oa7fd1XzlFoSCvt9ePl9/6FyAug==
+  version "8.4.1"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.4.1.tgz#c48251553e8759db9e656de3efc846954ac32304"
+  integrity sha512-GE44+DNEyxxh2Kc6ro/VkIj+9ma0pO0bwv9+uHSyBrikYOHr8zYcdPvnBOp1aw8s+CjRvuSx7CyWqRrNFQ59mA==
   dependencies:
     "@types/estree" "*"
     "@types/json-schema" "*"