diff --git a/Cargo.lock b/Cargo.lock
index c242a4aab67..c98c6faf4cd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -28,9 +28,21 @@ dependencies = [
  "ryu-js",
  "serde",
  "serde_json",
+ "string-interner",
  "unicode-normalization",
 ]
 
+[[package]]
+name = "ahash"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "version_check",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.18"
@@ -493,6 +505,9 @@ name = "hashbrown"
 version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+dependencies = [
+ "ahash",
+]
 
 [[package]]
 name = "heck"
@@ -1233,6 +1248,17 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d44a3643b4ff9caf57abcee9c2c621d6c03d9135e0d8b589bd9afb5992cb176a"
 
+[[package]]
+name = "string-interner"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e2531d8525b29b514d25e275a43581320d587b86db302b9a7e464bac579648"
+dependencies = [
+ "cfg-if",
+ "hashbrown",
+ "serde",
+]
+
 [[package]]
 name = "strsim"
 version = "0.8.0"
diff --git a/boa/Cargo.toml b/boa/Cargo.toml
index c990a3d3706..7e943f2cdf2 100644
--- a/boa/Cargo.toml
+++ b/boa/Cargo.toml
@@ -40,6 +40,7 @@ once_cell = "1.9.0"
 
 # Optional Dependencies
 measureme = { version = "10.0.0", optional = true }
+string-interner = "0.14.0"
 
 [target.wasm32-unknown-unknown.dependencies]
 getrandom = { version = "0.2.3", features = ["js"] }
diff --git a/boa/src/context.rs b/boa/src/context.rs
index df9658f4f6a..a85dd18b68c 100644
--- a/boa/src/context.rs
+++ b/boa/src/context.rs
@@ -11,7 +11,7 @@ use crate::{
     realm::Realm,
     syntax::Parser,
     vm::{FinallyReturn, Vm},
-    BoaProfiler, JsResult, JsString, JsValue,
+    BoaProfiler, Interner, JsResult, JsString, JsValue,
 };
 
 #[cfg(feature = "console")]
@@ -366,6 +366,9 @@ pub struct Context {
     /// realm holds both the global object and the environment
     pub(crate) realm: Realm,
 
+    /// String interner
+    interner: Interner,
+
     /// console object state.
     #[cfg(feature = "console")]
     console: Console,
@@ -393,6 +396,7 @@ impl Default for Context {
         let realm = Realm::create();
         let mut context = Self {
             realm,
+            interner: Interner::new(),
             #[cfg(feature = "console")]
             console: Console::default(),
             iterator_prototypes: IteratorPrototypes::default(),
@@ -434,6 +438,16 @@ impl Context {
         Default::default()
     }
 
+    /// Gets the interner of the context.
+    pub fn interner(&self) -> &Interner {
+        &self.interner
+    }
+
+    /// Gets the interner of the context mutably.
+    pub fn interner_mut(&mut self) -> &mut Interner {
+        &mut self.interner
+    }
+
     /// A helper function for getting an immutable reference to the `console` object.
     #[cfg(feature = "console")]
     pub(crate) fn console(&self) -> &Console {
@@ -875,7 +889,7 @@ impl Context {
         let src_bytes: &[u8] = src.as_ref();
 
         let parsing_result = Parser::new(src_bytes, false)
-            .parse_all()
+            .parse_all(&mut self.interner)
             .map_err(|e| e.to_string());
 
         let statement_list = match parsing_result {
diff --git a/boa/src/lib.rs b/boa/src/lib.rs
index e4e1ca7194b..b3fba4374d1 100644
--- a/boa/src/lib.rs
+++ b/boa/src/lib.rs
@@ -64,9 +64,12 @@ pub mod prelude {
     pub use crate::{object::JsObject, Context, JsBigInt, JsResult, JsString, JsValue};
 }
 
-use std::result::Result as StdResult;
-
 pub(crate) use crate::profiler::BoaProfiler;
+use std::{num::NonZeroUsize, result::Result as StdResult};
+use string_interner::{backend::BufferBackend, StringInterner, Symbol};
+
+#[cfg(feature = "deser")]
+use serde::{Deserialize, Serialize};
 
 // Export things to root level
 #[doc(inline)]
@@ -83,14 +86,40 @@ use crate::syntax::{
 #[must_use]
 pub type JsResult<T> = StdResult<T, JsValue>;
 
+/// The string interner for Boa.
+pub type Interner = StringInterner<BufferBackend<Sym>>;
+
+/// The string symbol type for Boa.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "deser", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "deser", serde(transparent))]
+pub struct Sym {
+    value: NonZeroUsize,
+}
+
+impl Symbol for Sym {
+    #[inline]
+    fn try_from_usize(index: usize) -> Option<Self> {
+        NonZeroUsize::new(index.wrapping_add(1)).map(|value| Self { value })
+    }
+
+    #[inline]
+    fn to_usize(self) -> usize {
+        self.value.get() - 1
+    }
+}
+
 /// Parses the given source code.
 ///
 /// It will return either the statement list AST node for the code, or a parsing error if something
 /// goes wrong.
 #[inline]
-pub fn parse<T: AsRef<[u8]>>(src: T, strict_mode: bool) -> StdResult<StatementList, ParseError> {
-    let src_bytes: &[u8] = src.as_ref();
-    Parser::new(src_bytes, strict_mode).parse_all()
+pub fn parse<T: AsRef<[u8]>>(
+    src: T,
+    strict_mode: bool,
+    interner: &mut Interner,
+) -> StdResult<StatementList, ParseError> {
+    Parser::new(src.as_ref(), strict_mode).parse_all(interner)
 }
 
 /// Execute the code using an existing Context
diff --git a/boa/src/syntax/ast/node/mod.rs b/boa/src/syntax/ast/node/mod.rs
index dfe1e890582..c450a7f76cd 100644
--- a/boa/src/syntax/ast/node/mod.rs
+++ b/boa/src/syntax/ast/node/mod.rs
@@ -667,6 +667,8 @@ unsafe impl Trace for PropertyName {
 /// level.
 #[cfg(test)]
 fn test_formatting(source: &'static str) {
+    use crate::Interner;
+
     // Remove preceding newline.
     let source = &source[1..];
 
@@ -680,7 +682,8 @@ 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 result = format!("{}", crate::parse(&scenario, false).unwrap());
+    let mut interner = Interner::new();
+    let result = format!("{}", crate::parse(&scenario, false, &mut interner).unwrap());
     if scenario != result {
         eprint!("========= Expected:\n{}", scenario);
         eprint!("========= Got:\n{}", result);
diff --git a/boa/src/syntax/lexer/comment.rs b/boa/src/syntax/lexer/comment.rs
index 24c94c1903a..8ebe66b43b6 100644
--- a/boa/src/syntax/lexer/comment.rs
+++ b/boa/src/syntax/lexer/comment.rs
@@ -7,6 +7,7 @@ use crate::{
         ast::{Position, Span},
         lexer::{Token, TokenKind},
     },
+    Interner,
 };
 use core::convert::TryFrom;
 use std::io::Read;
@@ -24,7 +25,12 @@ use std::io::Read;
 pub(super) struct SingleLineComment;
 
 impl<R> Tokenizer<R> for SingleLineComment {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -59,7 +65,12 @@ impl<R> Tokenizer<R> for SingleLineComment {
 pub(super) struct MultiLineComment;
 
 impl<R> Tokenizer<R> for MultiLineComment {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        _interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -103,7 +114,12 @@ impl<R> Tokenizer<R> for MultiLineComment {
 pub(super) struct HashbangComment;
 
 impl<R> Tokenizer<R> for HashbangComment {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        _interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
diff --git a/boa/src/syntax/lexer/identifier.rs b/boa/src/syntax/lexer/identifier.rs
index 5fef7bf7d13..48cf2d8e462 100644
--- a/boa/src/syntax/lexer/identifier.rs
+++ b/boa/src/syntax/lexer/identifier.rs
@@ -7,6 +7,7 @@ use crate::{
         ast::{Keyword, Position, Span},
         lexer::{StringLiteral, Token, TokenKind},
     },
+    Interner,
 };
 use boa_unicode::UnicodeProperties;
 use core::convert::TryFrom;
@@ -80,7 +81,12 @@ impl Identifier {
 }
 
 impl<R> Tokenizer<R> for Identifier {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -123,7 +129,7 @@ impl<R> Tokenizer<R> for Identifier {
                     start_pos,
                 ));
             }
-            TokenKind::identifier(identifier_name.into_boxed_str())
+            TokenKind::identifier(interner.get_or_intern(identifier_name))
         };
 
         Ok(Token::new(token_kind, Span::new(start_pos, cursor.pos())))
diff --git a/boa/src/syntax/lexer/mod.rs b/boa/src/syntax/lexer/mod.rs
index e2ed8227e65..496bd041a33 100644
--- a/boa/src/syntax/lexer/mod.rs
+++ b/boa/src/syntax/lexer/mod.rs
@@ -40,8 +40,11 @@ use self::{
     string::StringLiteral,
     template::TemplateLiteral,
 };
-use crate::syntax::ast::{Punctuator, Span};
 pub use crate::{profiler::BoaProfiler, syntax::ast::Position};
+use crate::{
+    syntax::ast::{Punctuator, Span},
+    Interner,
+};
 use core::convert::TryFrom;
 pub use error::Error;
 use std::io::Read;
@@ -49,7 +52,12 @@ pub use token::{Token, TokenKind};
 
 trait Tokenizer<R> {
     /// Lexes the next token.
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read;
 }
@@ -120,7 +128,11 @@ impl<R> Lexer<R> {
     // that means it could be multiple different tokens depending on the input token.
     //
     // As per https://tc39.es/ecma262/#sec-ecmascript-language-lexical-grammar
-    pub(crate) fn lex_slash_token(&mut self, start: Position) -> Result<Token, Error>
+    pub(crate) fn lex_slash_token(
+        &mut self,
+        start: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -130,11 +142,11 @@ impl<R> Lexer<R> {
             match c {
                 b'/' => {
                     self.cursor.next_byte()?.expect("/ token vanished"); // Consume the '/'
-                    SingleLineComment.lex(&mut self.cursor, start)
+                    SingleLineComment.lex(&mut self.cursor, start, interner)
                 }
                 b'*' => {
                     self.cursor.next_byte()?.expect("* token vanished"); // Consume the '*'
-                    MultiLineComment.lex(&mut self.cursor, start)
+                    MultiLineComment.lex(&mut self.cursor, start, interner)
                 }
                 ch => {
                     match self.get_goal() {
@@ -157,7 +169,7 @@ impl<R> Lexer<R> {
                         }
                         InputElement::RegExp => {
                             // Can be a regular expression.
-                            RegexLiteral.lex(&mut self.cursor, start)
+                            RegexLiteral.lex(&mut self.cursor, start, interner)
                         }
                     }
                 }
@@ -173,7 +185,7 @@ impl<R> Lexer<R> {
     /// Retrieves the next token from the lexer.
     // We intentionally don't implement Iterator trait as Result<Option> is cleaner to handle.
     #[allow(clippy::should_implement_trait)]
-    pub fn next(&mut self) -> Result<Option<Token>, Error>
+    pub fn next(&mut self, interner: &mut Interner) -> Result<Option<Token>, Error>
     where
         R: Read,
     {
@@ -196,8 +208,8 @@ impl<R> Lexer<R> {
         if start.column_number() == 1 && start.line_number() == 1 && next_ch == 0x23 {
             if let Some(hashbang_peek) = self.cursor.peek()? {
                 if hashbang_peek == 0x21 {
-                    let _token = HashbangComment.lex(&mut self.cursor, start);
-                    return self.next();
+                    let _token = HashbangComment.lex(&mut self.cursor, start, interner);
+                    return self.next(interner);
                 }
             }
         };
@@ -208,8 +220,8 @@ impl<R> Lexer<R> {
                     TokenKind::LineTerminator,
                     Span::new(start, self.cursor.pos()),
                 )),
-                '"' | '\'' => StringLiteral::new(c).lex(&mut self.cursor, start),
-                '`' => TemplateLiteral.lex(&mut self.cursor, start),
+                '"' | '\'' => StringLiteral::new(c).lex(&mut self.cursor, start, interner),
+                '`' => TemplateLiteral.lex(&mut self.cursor, start, interner),
                 ';' => Ok(Token::new(
                     Punctuator::Semicolon.into(),
                     Span::new(start, self.cursor.pos()),
@@ -220,9 +232,9 @@ impl<R> Lexer<R> {
                 )),
                 '.' => {
                     if self.cursor.peek()?.map(|c| (b'0'..=b'9').contains(&c)) == Some(true) {
-                        NumberLiteral::new(next_ch as u8).lex(&mut self.cursor, start)
+                        NumberLiteral::new(next_ch as u8).lex(&mut self.cursor, start, interner)
                     } else {
-                        SpreadLiteral::new().lex(&mut self.cursor, start)
+                        SpreadLiteral::new().lex(&mut self.cursor, start, interner)
                     }
                 }
                 '(' => Ok(Token::new(
@@ -253,18 +265,18 @@ impl<R> Lexer<R> {
                     Punctuator::CloseBracket.into(),
                     Span::new(start, self.cursor.pos()),
                 )),
-                '/' => self.lex_slash_token(start),
+                '/' => self.lex_slash_token(start, interner),
                 '=' | '*' | '+' | '-' | '%' | '|' | '&' | '^' | '<' | '>' | '!' | '~' | '?' => {
-                    Operator::new(next_ch as u8).lex(&mut self.cursor, start)
+                    Operator::new(next_ch as u8).lex(&mut self.cursor, start, interner)
                 }
                 '\\' if self.cursor.peek()? == Some(b'u') => {
-                    Identifier::new(c).lex(&mut self.cursor, start)
+                    Identifier::new(c).lex(&mut self.cursor, start, interner)
                 }
                 _ if Identifier::is_identifier_start(c as u32) => {
-                    Identifier::new(c).lex(&mut self.cursor, start)
+                    Identifier::new(c).lex(&mut self.cursor, start, interner)
                 }
                 _ if c.is_digit(10) => {
-                    NumberLiteral::new(next_ch as u8).lex(&mut self.cursor, start)
+                    NumberLiteral::new(next_ch as u8).lex(&mut self.cursor, start, interner)
                 }
                 _ => {
                     let details = format!(
@@ -279,7 +291,7 @@ impl<R> Lexer<R> {
 
             if token.kind() == &TokenKind::Comment {
                 // Skip comment
-                self.next()
+                self.next(interner)
             } else {
                 Ok(Some(token))
             }
@@ -296,11 +308,16 @@ impl<R> Lexer<R> {
         }
     }
 
-    pub(crate) fn lex_template(&mut self, start: Position) -> Result<Token, Error>
+    /// Performs the lexing of a template literal.
+    pub(crate) fn lex_template(
+        &mut self,
+        start: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
-        TemplateLiteral.lex(&mut self.cursor, start)
+        TemplateLiteral.lex(&mut self.cursor, start, interner)
     }
 }
 
diff --git a/boa/src/syntax/lexer/number.rs b/boa/src/syntax/lexer/number.rs
index a37d95d3467..c8f716dcc0d 100644
--- a/boa/src/syntax/lexer/number.rs
+++ b/boa/src/syntax/lexer/number.rs
@@ -7,7 +7,7 @@ use crate::{
         ast::{Position, Span},
         lexer::{token::Numeric, Token},
     },
-    JsBigInt,
+    Interner, JsBigInt,
 };
 use std::io::Read;
 use std::str;
@@ -178,7 +178,12 @@ where
 }
 
 impl<R> Tokenizer<R> for NumberLiteral {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        _interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
diff --git a/boa/src/syntax/lexer/operator.rs b/boa/src/syntax/lexer/operator.rs
index 0be8d94a421..10eddc64626 100644
--- a/boa/src/syntax/lexer/operator.rs
+++ b/boa/src/syntax/lexer/operator.rs
@@ -2,6 +2,7 @@
 
 use super::{Cursor, Error, Tokenizer};
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     profiler::BoaProfiler,
     syntax::{
@@ -94,7 +95,12 @@ impl Operator {
 }
 
 impl<R> Tokenizer<R> for Operator {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        _interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
diff --git a/boa/src/syntax/lexer/regex.rs b/boa/src/syntax/lexer/regex.rs
index d162423a59d..ff91c16a1f9 100644
--- a/boa/src/syntax/lexer/regex.rs
+++ b/boa/src/syntax/lexer/regex.rs
@@ -7,6 +7,7 @@ use crate::{
         ast::Position,
         lexer::{Token, TokenKind},
     },
+    Interner,
 };
 use bitflags::bitflags;
 use std::io::{self, ErrorKind};
@@ -35,7 +36,12 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 pub(super) struct RegexLiteral;
 
 impl<R> Tokenizer<R> for RegexLiteral {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -115,7 +121,7 @@ impl<R> Tokenizer<R> for RegexLiteral {
         if let Ok(body_str) = str::from_utf8(body.as_slice()) {
             Ok(Token::new(
                 TokenKind::regular_expression_literal(
-                    body_str,
+                    interner.get_or_intern(body_str),
                     parse_regex_flags(flags_str, flags_start)?,
                 ),
                 Span::new(start_pos, cursor.pos()),
diff --git a/boa/src/syntax/lexer/spread.rs b/boa/src/syntax/lexer/spread.rs
index 422ed97ab9e..a4db4696a48 100644
--- a/boa/src/syntax/lexer/spread.rs
+++ b/boa/src/syntax/lexer/spread.rs
@@ -7,6 +7,7 @@ use crate::{
         ast::{Position, Punctuator, Span},
         lexer::Token,
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -31,7 +32,12 @@ impl SpreadLiteral {
 }
 
 impl<R> Tokenizer<R> for SpreadLiteral {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        _interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
diff --git a/boa/src/syntax/lexer/string.rs b/boa/src/syntax/lexer/string.rs
index 0f306e38163..af43c73230f 100644
--- a/boa/src/syntax/lexer/string.rs
+++ b/boa/src/syntax/lexer/string.rs
@@ -7,6 +7,7 @@ use crate::{
         ast::{Position, Span},
         lexer::{Token, TokenKind},
     },
+    Interner,
 };
 use std::{
     io::{self, ErrorKind, Read},
@@ -77,7 +78,12 @@ impl UTF16CodeUnitsBuffer for Vec<u16> {
 }
 
 impl<R> Tokenizer<R> for StringLiteral {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -86,7 +92,10 @@ impl<R> Tokenizer<R> for StringLiteral {
         let (lit, span) =
             Self::take_string_characters(cursor, start_pos, self.terminator, cursor.strict_mode())?;
 
-        Ok(Token::new(TokenKind::string_literal(lit), span))
+        Ok(Token::new(
+            TokenKind::string_literal(interner.get_or_intern(lit)),
+            span,
+        ))
     }
 }
 
diff --git a/boa/src/syntax/lexer/template.rs b/boa/src/syntax/lexer/template.rs
index 76aedeaa7a4..ab4dced8c6f 100644
--- a/boa/src/syntax/lexer/template.rs
+++ b/boa/src/syntax/lexer/template.rs
@@ -8,6 +8,7 @@ use crate::{
         ast::{Position, Span},
         lexer::{Token, TokenKind},
     },
+    Interner, Sym,
 };
 use std::io::{self, ErrorKind, Read};
 
@@ -20,18 +21,13 @@ pub struct TemplateString {
     /// The start position of the template string. Used to make lexer error if `to_owned_cooked` failed.
     start_pos: Position,
     /// The template string of template literal with argument `raw` true.
-    raw: Box<str>,
+    raw: Sym,
 }
 
 impl TemplateString {
-    pub fn new<R>(raw: R, start_pos: Position) -> Self
-    where
-        R: Into<Box<str>>,
-    {
-        Self {
-            start_pos,
-            raw: raw.into(),
-        }
+    /// Creates a new `TemplateString` with the given raw template ans start position.
+    pub fn new(raw: Sym, start_pos: Position) -> Self {
+        Self { start_pos, raw }
     }
 
     /// Converts the raw template string into a mutable string slice.
@@ -40,8 +36,8 @@ impl TemplateString {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-static-semantics-templatestrings
-    pub fn as_raw(&self) -> &str {
-        self.raw.as_ref()
+    pub fn as_raw(&self) -> Sym {
+        self.raw
     }
 
     /// Creats a new cooked template string. Returns a lexer error if it fails to cook the template string.
@@ -50,8 +46,14 @@ impl TemplateString {
     ///  - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-static-semantics-templatestrings
-    pub fn to_owned_cooked(&self) -> Result<Box<str>, Error> {
-        let mut cursor = Cursor::with_position(self.raw.as_bytes(), self.start_pos);
+    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,
+        );
         let mut buf: Vec<u16> = Vec::new();
 
         loop {
@@ -99,7 +101,12 @@ impl TemplateString {
 pub(super) struct TemplateLiteral;
 
 impl<R> Tokenizer<R> for TemplateLiteral {
-    fn lex(&mut self, cursor: &mut Cursor<R>, start_pos: Position) -> Result<Token, Error>
+    fn lex(
+        &mut self,
+        cursor: &mut Cursor<R>,
+        start_pos: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, Error>
     where
         R: Read,
     {
@@ -117,7 +124,8 @@ impl<R> Tokenizer<R> for TemplateLiteral {
             match ch {
                 0x0060 /* ` */ => {
                     let raw = buf.to_string_lossy();
-                    let template_string = TemplateString::new(raw, start_pos);
+                    let raw_sym = interner.get_or_intern(raw);
+                    let template_string = TemplateString::new(raw_sym, start_pos);
 
                     return Ok(Token::new(
                         TokenKind::template_no_substitution(template_string),
@@ -126,7 +134,8 @@ impl<R> Tokenizer<R> for TemplateLiteral {
                 }
                 0x0024 /* $ */ if cursor.next_is(b'{')? => {
                     let raw = buf.to_string_lossy();
-                    let template_string = TemplateString::new(raw, start_pos);
+                    let raw_sym = interner.get_or_intern(raw);
+                    let template_string = TemplateString::new(raw_sym, start_pos);
 
                     return Ok(Token::new(
                         TokenKind::template_middle(template_string),
diff --git a/boa/src/syntax/lexer/tests.rs b/boa/src/syntax/lexer/tests.rs
index 6ae0cdffb23..e5609d33a5d 100644
--- a/boa/src/syntax/lexer/tests.rs
+++ b/boa/src/syntax/lexer/tests.rs
@@ -13,16 +13,16 @@ fn span(start: (u32, u32), end: (u32, u32)) -> Span {
     Span::new(Position::new(start.0, start.1), Position::new(end.0, end.1))
 }
 
-fn expect_tokens<R>(lexer: &mut Lexer<R>, expected: &[TokenKind])
+fn expect_tokens<R>(lexer: &mut Lexer<R>, expected: &[TokenKind], interner: &mut Interner)
 where
     R: Read,
 {
     for expect in expected.iter() {
-        assert_eq!(&lexer.next().unwrap().unwrap().kind(), &expect);
+        assert_eq!(&lexer.next(interner).unwrap().unwrap().kind(), &expect);
     }
 
     assert!(
-        lexer.next().unwrap().is_none(),
+        lexer.next(interner).unwrap().is_none(),
         "Unexpected extra token lexed at end of input"
     );
 }
@@ -31,6 +31,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 expected = [
         TokenKind::Keyword(Keyword::Var),
@@ -39,13 +40,14 @@ fn check_single_line_comment() {
         TokenKind::BooleanLiteral(true),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 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 expected = [
         TokenKind::Keyword(Keyword::Var),
@@ -54,54 +56,59 @@ fn check_single_line_comment_with_crlf_ending() {
         TokenKind::BooleanLiteral(true),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 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 sym = interner.get_or_intern("x");
     let expected = [
         TokenKind::Keyword(Keyword::Var),
         TokenKind::LineTerminator,
-        TokenKind::identifier("x"),
+        TokenKind::identifier(sym),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 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 expected = [
-        TokenKind::identifier("x"),
-        TokenKind::identifier("x1"),
-        TokenKind::identifier("_x"),
-        TokenKind::identifier("$x"),
-        TokenKind::identifier("__"),
-        TokenKind::identifier("$$"),
-        TokenKind::identifier("Ѐ"),
-        TokenKind::identifier("ЀЀ"),
-        TokenKind::identifier("x\u{200C}\u{200D}"),
-        TokenKind::identifier("x"),
-        TokenKind::identifier("xx"),
-        TokenKind::identifier("xxx"),
+        TokenKind::identifier(interner.get_or_intern("x")),
+        TokenKind::identifier(interner.get_or_intern("x1")),
+        TokenKind::identifier(interner.get_or_intern("_x")),
+        TokenKind::identifier(interner.get_or_intern("$x")),
+        TokenKind::identifier(interner.get_or_intern("__")),
+        TokenKind::identifier(interner.get_or_intern("$$")),
+        TokenKind::identifier(interner.get_or_intern("Ѐ")),
+        TokenKind::identifier(interner.get_or_intern("ЀЀ")),
+        TokenKind::identifier(interner.get_or_intern("x\u{200C}\u{200D}")),
+        TokenKind::identifier(interner.get_or_intern("x")),
+        TokenKind::identifier(interner.get_or_intern("xx")),
+        TokenKind::identifier(interner.get_or_intern("xxx")),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn check_invalid_identifier_start() {
     let invalid_identifier_starts = ["\u{200C}", "\u{200D}", "😀"];
+    let mut interner = Interner::new();
 
     for s in invalid_identifier_starts.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
+        let mut interner = Interner::new();
         lexer
-            .next()
+            .next(&mut interner)
             .expect_err("Invalid identifier start not rejected as expected");
     }
 }
@@ -109,13 +116,16 @@ fn check_invalid_identifier_start() {
 #[test]
 fn check_invalid_identifier_part() {
     let invalid_identifier_parts = [" ", "\n", ".", "*", "😀", "\u{007F}"];
+    let mut interner = Interner::new();
 
+    let sym = interner.get_or_intern("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();
         assert_eq!(
-            lexer.next().unwrap().unwrap().kind(),
-            &TokenKind::identifier("x")
+            lexer.next(&mut interner).unwrap().unwrap().kind(),
+            &TokenKind::identifier(sym)
         );
     }
 }
@@ -124,26 +134,29 @@ 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 a_sym = interner.get_or_intern("aaa");
+    let b_sym = interner.get_or_intern("bbb");
     let expected = [
-        TokenKind::string_literal("aaa"),
-        TokenKind::string_literal("bbb"),
+        TokenKind::string_literal(a_sym),
+        TokenKind::string_literal(b_sym),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 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 sym = interner.get_or_intern("I'm a template literal");
 
     assert_eq!(
-        lexer.next().unwrap().unwrap().kind(),
-        &TokenKind::template_no_substitution(TemplateString::new(
-            "I'm a template literal",
-            Position::new(1, 1)
-        ))
+        lexer.next(&mut interner).unwrap().unwrap().kind(),
+        &TokenKind::template_no_substitution(TemplateString::new(sym, Position::new(1, 1)))
     );
 }
 
@@ -151,9 +164,10 @@ 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();
 
     lexer
-        .next()
+        .next(&mut interner)
         .expect_err("Lexer did not handle unterminated literal with error");
 }
 
@@ -164,6 +178,7 @@ fn check_punctuators() {
              + - * % -- << >> >>> & | ^ ! ~ && || ? : \
              = += -= *= &= **= ++ ** <<= >>= >>>= &= |= ^= => ?? ??= &&= ||=";
     let mut lexer = Lexer::new(s.as_bytes());
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::Punctuator(Punctuator::OpenBlock),
@@ -221,7 +236,7 @@ fn check_punctuators() {
         TokenKind::Punctuator(Punctuator::AssignBoolOr),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -232,6 +247,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 expected = [
         TokenKind::Keyword(Keyword::Await),
@@ -270,23 +286,26 @@ fn check_keywords() {
         TokenKind::Keyword(Keyword::Yield),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn check_variable_definition_tokens() {
     let s = "let a = 'hello';";
     let mut lexer = Lexer::new(s.as_bytes());
+    let mut interner = Interner::new();
 
+    let a_sym = interner.get_or_intern("a");
+    let hello_sym = interner.get_or_intern("hello");
     let expected = [
         TokenKind::Keyword(Keyword::Let),
-        TokenKind::identifier("a"),
+        TokenKind::identifier(a_sym),
         TokenKind::Punctuator(Punctuator::Assign),
-        TokenKind::string_literal("hello"),
+        TokenKind::string_literal(hello_sym),
         TokenKind::Punctuator(Punctuator::Semicolon),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -294,37 +313,47 @@ 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();
 
     // The first column is 1 (not zero indexed)
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 1), (1, 8)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 1), (1, 8))
+    );
 
     // Dot Token starts on column 8
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 8), (1, 9)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 8), (1, 9))
+    );
 
     // Log Token starts on column 9
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 9), (1, 12)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 9), (1, 12))
+    );
 
     // Open parenthesis token starts on column 12
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 12), (1, 13))
     );
 
     // String token starts on column 13
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 13), (1, 26))
     );
 
     // Close parenthesis token starts on column 26.
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 26), (1, 27))
     );
 
     // Semi Colon token starts on column 35
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 27), (1, 28))
     );
 }
@@ -334,37 +363,47 @@ 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();
 
     // The first column is 1 (not zero indexed)
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 1), (1, 8)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 1), (1, 8))
+    );
 
     // Dot Token starts on column 8
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 8), (1, 9)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 8), (1, 9))
+    );
 
     // Log Token starts on column 9
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 9), (1, 12)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 9), (1, 12))
+    );
 
     // Open parenthesis token starts on column 12
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 12), (1, 13))
     );
 
     // String token starts on column 13
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 13), (1, 34))
     );
 
     // Close parenthesis token starts on column 34
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 34), (1, 35))
     );
 
     // Semi Colon token starts on column 35
     assert_eq!(
-        lexer.next().unwrap().unwrap().span(),
+        lexer.next(&mut interner).unwrap().unwrap().span(),
         span((1, 35), (1, 36))
     );
 }
@@ -374,11 +413,24 @@ fn check_line_numbers() {
     let s = "x\ny\n";
 
     let mut lexer = Lexer::new(s.as_bytes());
+    let mut interner = Interner::new();
 
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 1), (1, 2)));
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((1, 2), (2, 1)));
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((2, 1), (2, 2)));
-    assert_eq!(lexer.next().unwrap().unwrap().span(), span((2, 2), (3, 1)));
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 1), (1, 2))
+    );
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((1, 2), (2, 1))
+    );
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((2, 1), (2, 2))
+    );
+    assert_eq!(
+        lexer.next(&mut interner).unwrap().unwrap().span(),
+        span((2, 2), (3, 1))
+    );
 }
 
 // Increment/Decrement
@@ -386,20 +438,21 @@ 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();
 
     for _ in 0..4 {
-        lexer.next().unwrap();
+        lexer.next(&mut interner).unwrap();
     }
 
     assert_eq!(
-        lexer.next().unwrap().unwrap().kind(),
+        lexer.next(&mut interner).unwrap().unwrap().kind(),
         &TokenKind::Punctuator(Punctuator::Dec)
     );
     // Decrementing means adding 2 characters '--', the lexer should consume it as a single token
     // and move the curser forward by 2, meaning the next token should be a semicolon
 
     assert_eq!(
-        lexer.next().unwrap().unwrap().kind(),
+        lexer.next(&mut interner).unwrap().unwrap().kind(),
         &TokenKind::Punctuator(Punctuator::Semicolon)
     );
 }
@@ -407,10 +460,11 @@ fn check_decrement_advances_lexer_2_places() {
 #[test]
 fn single_int() {
     let mut lexer = Lexer::new(&b"52"[..]);
+    let mut interner = Interner::new();
 
     let expected = [TokenKind::numeric_literal(52)];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -419,6 +473,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 expected = [
         TokenKind::numeric_literal(1),
@@ -443,7 +498,7 @@ fn numbers() {
         TokenKind::numeric_literal(32),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -451,6 +506,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 expected = [
         TokenKind::numeric_literal(10),
@@ -469,7 +525,7 @@ fn numbers_with_separators() {
         TokenKind::numeric_literal(32),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -480,13 +536,15 @@ fn numbers_with_bad_separators() {
 
     for n in numbers.iter() {
         let mut lexer = Lexer::new(n.as_bytes());
-        assert!(lexer.next().is_err());
+        let mut interner = Interner::new();
+        assert!(lexer.next(&mut interner).is_err());
     }
 }
 
 #[test]
 fn big_exp_numbers() {
     let mut lexer = Lexer::new(&b"1.0e25 1.0e36 9.0e50"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(10000000000000000000000000.0),
@@ -494,22 +552,24 @@ fn big_exp_numbers() {
         TokenKind::numeric_literal(900000000000000000000000000000000000000000000000000.0),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 #[ignore]
 fn big_literal_numbers() {
     let mut lexer = Lexer::new(&b"10000000000000000000000000"[..]);
+    let mut interner = Interner::new();
 
     let expected = [TokenKind::numeric_literal(10000000000000000000000000.0)];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn implicit_octal_edge_case() {
     let mut lexer = Lexer::new(&b"044.5 094.5"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(36),
@@ -517,27 +577,31 @@ fn implicit_octal_edge_case() {
         TokenKind::numeric_literal(94.5),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn hexadecimal_edge_case() {
     let mut lexer = Lexer::new(&b"0xffff.ff 0xffffff"[..]);
+    let mut interner = Interner::new();
 
+    let sym = interner.get_or_intern("ff");
     let expected = [
         TokenKind::numeric_literal(0xffff),
         TokenKind::Punctuator(Punctuator::Dot),
-        TokenKind::identifier("ff"),
+        TokenKind::identifier(sym),
         TokenKind::numeric_literal(0x00ff_ffff),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn single_number_without_semicolon() {
     let mut lexer = Lexer::new(&b"1"[..]);
-    if let Some(x) = lexer.next().unwrap() {
+    let mut interner = Interner::new();
+
+    if let Some(x) = lexer.next(&mut interner).unwrap() {
         assert_eq!(x.kind(), &TokenKind::numeric_literal(Numeric::Integer(1)));
     } else {
         panic!("Failed to lex 1 without semicolon");
@@ -547,47 +611,50 @@ fn single_number_without_semicolon() {
 #[test]
 fn number_followed_by_dot() {
     let mut lexer = Lexer::new(&b"1.."[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(1),
         TokenKind::Punctuator(Punctuator::Dot),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn regex_literal() {
     let mut lexer = Lexer::new(&b"/(?:)/"[..]);
+    let mut interner = Interner::new();
 
+    let sym = interner.get_or_intern("(?:)");
     let expected = [TokenKind::regular_expression_literal(
-        "(?:)",
+        sym,
         RegExpFlags::default(),
     )];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn regex_literal_flags() {
     let mut lexer = Lexer::new(&br"/\/[^\/]*\/*/gmi"[..]);
+    let mut interner = Interner::new();
 
     let mut flags = RegExpFlags::default();
     flags.insert(RegExpFlags::GLOBAL);
     flags.insert(RegExpFlags::MULTILINE);
     flags.insert(RegExpFlags::IGNORE_CASE);
 
-    let expected = [TokenKind::regular_expression_literal(
-        "\\/[^\\/]*\\/*",
-        flags,
-    )];
+    let sym = interner.get_or_intern("\\/[^\\/]*\\/*");
+    let expected = [TokenKind::regular_expression_literal(sym, flags)];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn addition_no_spaces() {
     let mut lexer = Lexer::new(&b"1+1"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -595,12 +662,13 @@ fn addition_no_spaces() {
         TokenKind::numeric_literal(1),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn addition_no_spaces_left_side() {
     let mut lexer = Lexer::new(&b"1+ 1"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -608,12 +676,13 @@ fn addition_no_spaces_left_side() {
         TokenKind::numeric_literal(1),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn addition_no_spaces_right_side() {
     let mut lexer = Lexer::new(&b"1 +1"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -621,12 +690,13 @@ fn addition_no_spaces_right_side() {
         TokenKind::numeric_literal(1),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn addition_no_spaces_e_number_left_side() {
     let mut lexer = Lexer::new(&b"1e2+ 1"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(100),
@@ -634,12 +704,13 @@ fn addition_no_spaces_e_number_left_side() {
         TokenKind::numeric_literal(1),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn addition_no_spaces_e_number_right_side() {
     let mut lexer = Lexer::new(&b"1 +1e3"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(1),
@@ -647,12 +718,13 @@ fn addition_no_spaces_e_number_right_side() {
         TokenKind::numeric_literal(1000),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
 fn addition_no_spaces_e_number() {
     let mut lexer = Lexer::new(&b"1e3+1e11"[..]);
+    let mut interner = Interner::new();
 
     let expected = [
         TokenKind::numeric_literal(1000),
@@ -660,7 +732,7 @@ fn addition_no_spaces_e_number() {
         TokenKind::numeric_literal(100_000_000_000.0),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -769,8 +841,10 @@ fn illegal_following_numeric_literal() {
 
     // Decimal Digit
     let mut lexer = Lexer::new(&b"11.6n3"[..]);
+    let mut interner = Interner::new();
+
     let err = lexer
-        .next()
+        .next(&mut interner)
         .expect_err("DecimalDigit following NumericLiteral not rejected as expected");
     if let Error::Syntax(_, pos) = err {
         assert_eq!(pos, Position::new(1, 5))
@@ -780,8 +854,10 @@ fn illegal_following_numeric_literal() {
 
     // Identifier Start
     let mut lexer = Lexer::new(&b"17.4$"[..]);
+    let mut interner = Interner::new();
+
     if let Error::Syntax(_, pos) = lexer
-        .next()
+        .next(&mut interner)
         .expect_err("IdentifierStart '$' following NumericLiteral not rejected as expected")
     {
         assert_eq!(pos, Position::new(1, 5));
@@ -790,8 +866,10 @@ fn illegal_following_numeric_literal() {
     }
 
     let mut lexer = Lexer::new(&b"17.4_"[..]);
+    let mut interner = Interner::new();
+
     if let Error::Syntax(_, pos) = lexer
-        .next()
+        .next(&mut interner)
         .expect_err("IdentifierStart '_' following NumericLiteral not rejected as expected")
     {
         assert_eq!(pos, Position::new(1, 5));
@@ -803,7 +881,9 @@ fn illegal_following_numeric_literal() {
 #[test]
 fn string_codepoint_with_no_braces() {
     let mut lexer = Lexer::new(&br#""test\uD38Dtest""#[..]);
-    assert!(lexer.next().is_ok());
+    let mut interner = Interner::new();
+
+    assert!(lexer.next(&mut interner).is_ok());
 }
 
 #[test]
@@ -812,8 +892,10 @@ 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();
+
     assert!(
-        lexer.next().is_err(),
+        lexer.next(&mut interner).is_err(),
         "{}",
         r#"IdentifierStart \u{2764} following NumericLiteral not rejected as expected"#
     );
@@ -824,27 +906,31 @@ fn string_unicode() {
     let s = r#"'中文';"#;
 
     let mut lexer = Lexer::new(s.as_bytes());
+    let mut interner = Interner::new();
 
+    let sym = interner.get_or_intern("中文");
     let expected = [
-        TokenKind::StringLiteral("中文".into()),
+        TokenKind::StringLiteral(sym),
         TokenKind::Punctuator(Punctuator::Semicolon),
     ];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[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 expected = [TokenKind::StringLiteral("{\u{20ac}\u{a0}\u{a0}}".into())];
+    let sym = interner.get_or_intern("{\u{20ac}\u{a0}\u{a0}}");
+    let expected = [TokenKind::StringLiteral(sym)];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 
     lexer = Lexer::new(&br#"\u{{a0}"#[..]);
 
     if let Error::Syntax(_, pos) = lexer
-        .next()
+        .next(&mut interner)
         .expect_err("Malformed Unicode character sequence expected")
     {
         assert_eq!(pos, Position::new(1, 1));
@@ -855,7 +941,7 @@ fn string_unicode_escape_with_braces() {
     lexer = Lexer::new(&br#"\u{{a0}}"#[..]);
 
     if let Error::Syntax(_, pos) = lexer
-        .next()
+        .next(&mut interner)
         .expect_err("Malformed Unicode character sequence expected")
     {
         assert_eq!(pos, Position::new(1, 1));
@@ -869,10 +955,12 @@ 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 expected = [TokenKind::StringLiteral("\u{20ac}\u{a0}\u{a0}".into())];
+    let sym = interner.get_or_intern("\u{20ac}\u{a0}\u{a0}");
+    let expected = [TokenKind::StringLiteral(sym)];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -880,10 +968,12 @@ fn string_with_single_escape() {
     let s = r#"'\Б'"#;
 
     let mut lexer = Lexer::new(s.as_bytes());
+    let mut interner = Interner::new();
 
-    let expected = [TokenKind::StringLiteral("Б".into())];
+    let sym = interner.get_or_intern("Б");
+    let expected = [TokenKind::StringLiteral(sym)];
 
-    expect_tokens(&mut lexer, &expected);
+    expect_tokens(&mut lexer, &expected, &mut interner);
 }
 
 #[test]
@@ -900,18 +990,21 @@ 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 expected_tokens = [TokenKind::StringLiteral((*expected).into())];
+        let sym = interner.get_or_intern(expected);
+        let expected_tokens = [TokenKind::StringLiteral(sym)];
 
-        expect_tokens(&mut lexer, &expected_tokens);
+        expect_tokens(&mut lexer, &expected_tokens, &mut interner);
     }
 
     for (s, _) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
+        let mut interner = Interner::new();
         lexer.set_strict_mode(true);
 
         if let Error::Syntax(_, pos) = lexer
-            .next()
+            .next(&mut interner)
             .expect_err("Octal-escape in strict mode not rejected as expected")
         {
             assert_eq!(pos, Position::new(1, 2));
@@ -927,10 +1020,12 @@ 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 expected_tokens = [TokenKind::StringLiteral((*expected).into())];
+        let sym = interner.get_or_intern(expected);
+        let expected_tokens = [TokenKind::StringLiteral(sym)];
 
-        expect_tokens(&mut lexer, &expected_tokens);
+        expect_tokens(&mut lexer, &expected_tokens, &mut interner);
     }
 }
 
@@ -940,18 +1035,21 @@ 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 expected_tokens = [TokenKind::StringLiteral((*expected).into())];
+        let sym = interner.get_or_intern(expected);
+        let expected_tokens = [TokenKind::StringLiteral(sym)];
 
-        expect_tokens(&mut lexer, &expected_tokens);
+        expect_tokens(&mut lexer, &expected_tokens, &mut interner);
     }
 
     for (s, _) in test_cases.iter() {
         let mut lexer = Lexer::new(s.as_bytes());
+        let mut interner = Interner::new();
         lexer.set_strict_mode(true);
 
         if let Error::Syntax(_, pos) = lexer
-            .next()
+            .next(&mut interner)
             .expect_err("Non-octal-decimal-escape in strict mode not rejected as expected")
         {
             assert_eq!(pos, Position::new(1, 2));
@@ -966,10 +1064,12 @@ fn string_line_continuation() {
     let s = "'hello \\\nworld'";
 
     let mut lexer = Lexer::new(s.as_bytes());
+    let mut interner = Interner::new();
 
-    let expected_tokens = [TokenKind::StringLiteral("hello world".into())];
+    let sym = interner.get_or_intern("hello world");
+    let expected_tokens = [TokenKind::StringLiteral(sym)];
 
-    expect_tokens(&mut lexer, &expected_tokens);
+    expect_tokens(&mut lexer, &expected_tokens, &mut interner);
 }
 
 mod carriage_return {
@@ -977,6 +1077,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 expected = Vec::with_capacity(lines + 2);
         expected.push(TokenKind::Punctuator(Punctuator::Sub));
@@ -985,7 +1086,7 @@ mod carriage_return {
         }
         expected.push(TokenKind::NumericLiteral(Numeric::Integer(3)));
 
-        expect_tokens(&mut lexer, &expected);
+        expect_tokens(&mut lexer, &expected, &mut interner);
     }
 
     #[test]
diff --git a/boa/src/syntax/lexer/token.rs b/boa/src/syntax/lexer/token.rs
index 0f125e38832..a2f078e62c6 100644
--- a/boa/src/syntax/lexer/token.rs
+++ b/boa/src/syntax/lexer/token.rs
@@ -10,9 +10,9 @@ use super::regex::RegExpFlags;
 use crate::{
     syntax::ast::{Keyword, Punctuator, Span},
     syntax::lexer::template::TemplateString,
-    JsBigInt,
+    Interner, JsBigInt, Sym,
 };
-use std::fmt::{self, Debug, Display, Formatter};
+use std::fmt::{self, Debug, Formatter};
 
 #[cfg(feature = "deser")]
 use serde::{Deserialize, Serialize};
@@ -50,11 +50,20 @@ impl Token {
     pub fn span(&self) -> Span {
         self.span
     }
-}
 
-impl Display for Token {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.kind)
+    /// Implements the `Display` functionality for `Token`.
+    pub fn display(&self, f: &mut Formatter<'_>, interner: &Interner) -> fmt::Result {
+        self.kind.display(f, interner)
+    }
+
+    /// Converts the token to a `String`.
+    pub(crate) fn to_string(&self, interner: &Interner) -> String {
+        let mut buf = String::new();
+        let mut formatter = Formatter::new(&mut buf);
+        // Bypass format_args!() to avoid write_str with zero-length strs
+        self.display(&mut formatter, interner)
+            .expect("a Display implementation returned an error unexpectedly");
+        buf
     }
 }
 
@@ -104,7 +113,7 @@ pub enum TokenKind {
     EOF,
 
     /// An identifier.
-    Identifier(Box<str>),
+    Identifier(Sym),
 
     /// A keyword.
     Keyword(Keyword),
@@ -119,7 +128,7 @@ pub enum TokenKind {
     Punctuator(Punctuator),
 
     /// A string literal.
-    StringLiteral(Box<str>),
+    StringLiteral(Sym),
 
     /// A part of a template literal without substitution.
     TemplateNoSubstitution(TemplateString),
@@ -128,7 +137,7 @@ pub enum TokenKind {
     TemplateMiddle(TemplateString),
 
     /// A regular expression, consisting of body and flags.
-    RegularExpressionLiteral(Box<str>, RegExpFlags),
+    RegularExpressionLiteral(Sym, RegExpFlags),
 
     /// Indicates the end of a line (`\n`).
     LineTerminator,
@@ -173,11 +182,8 @@ impl TokenKind {
     }
 
     /// Creates an `Identifier` token type.
-    pub fn identifier<I>(ident: I) -> Self
-    where
-        I: Into<Box<str>>,
-    {
-        Self::Identifier(ident.into())
+    pub fn identifier(ident: Sym) -> Self {
+        Self::Identifier(ident)
     }
 
     /// Creates a `Keyword` token kind.
@@ -199,11 +205,8 @@ impl TokenKind {
     }
 
     /// Creates a `StringLiteral` token type.
-    pub fn string_literal<S>(lit: S) -> Self
-    where
-        S: Into<Box<str>>,
-    {
-        Self::StringLiteral(lit.into())
+    pub fn string_literal(lit: Sym) -> Self {
+        Self::StringLiteral(lit)
     }
 
     pub fn template_middle(template_string: TemplateString) -> Self {
@@ -215,12 +218,11 @@ impl TokenKind {
     }
 
     /// Creates a `RegularExpressionLiteral` token kind.
-    pub fn regular_expression_literal<B, R>(body: B, flags: R) -> Self
+    pub fn regular_expression_literal<R>(body: Sym, flags: R) -> Self
     where
-        B: Into<Box<str>>,
         R: Into<RegExpFlags>,
     {
-        Self::RegularExpressionLiteral(body.into(), flags.into())
+        Self::RegularExpressionLiteral(body, flags.into())
     }
 
     /// Creates a `LineTerminator` token kind.
@@ -232,24 +234,44 @@ impl TokenKind {
     pub fn comment() -> Self {
         Self::Comment
     }
-}
 
-impl Display for TokenKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    /// Implements the `Display` functionality for the `TokenKind`.
+    pub fn display(&self, f: &mut Formatter<'_>, interner: &Interner) -> fmt::Result {
         match *self {
             Self::BooleanLiteral(ref val) => write!(f, "{}", val),
             Self::EOF => write!(f, "end of file"),
-            Self::Identifier(ref ident) => write!(f, "{}", ident),
+            Self::Identifier(ident) => write!(
+                f,
+                "{}",
+                interner.resolve(ident).expect("string disappeared")
+            ),
             Self::Keyword(ref word) => write!(f, "{}", word),
             Self::NullLiteral => write!(f, "null"),
             Self::NumericLiteral(Numeric::Rational(num)) => write!(f, "{}", num),
             Self::NumericLiteral(Numeric::Integer(num)) => write!(f, "{}", num),
             Self::NumericLiteral(Numeric::BigInt(ref num)) => write!(f, "{}n", num),
             Self::Punctuator(ref punc) => write!(f, "{}", punc),
-            Self::StringLiteral(ref lit) => write!(f, "{}", lit),
-            Self::TemplateNoSubstitution(ref ts) => write!(f, "{}", ts.as_raw()),
-            Self::TemplateMiddle(ref ts) => write!(f, "{}", ts.as_raw()),
-            Self::RegularExpressionLiteral(ref body, ref flags) => write!(f, "/{}/{}", body, flags),
+            Self::StringLiteral(lit) => {
+                write!(f, "{}", interner.resolve(lit).expect("string disappeared"))
+            }
+            Self::TemplateNoSubstitution(ref ts) => write!(
+                f,
+                "{}",
+                interner.resolve(ts.as_raw()).expect("string disappeared")
+            ),
+            Self::TemplateMiddle(ref ts) => write!(
+                f,
+                "{}",
+                interner.resolve(ts.as_raw()).expect("string disappeared")
+            ),
+            Self::RegularExpressionLiteral(body, ref flags) => {
+                write!(
+                    f,
+                    "/{}/{}",
+                    interner.resolve(body).expect("string disappeared"),
+                    flags
+                )
+            }
             Self::LineTerminator => write!(f, "line terminator"),
             Self::Comment => write!(f, "comment"),
         }
diff --git a/boa/src/syntax/parser/cursor/buffered_lexer/mod.rs b/boa/src/syntax/parser/cursor/buffered_lexer/mod.rs
index 1a471395f92..45f1c564f1d 100644
--- a/boa/src/syntax/parser/cursor/buffered_lexer/mod.rs
+++ b/boa/src/syntax/parser/cursor/buffered_lexer/mod.rs
@@ -4,6 +4,7 @@ use crate::{
         lexer::{InputElement, Lexer, Position, Token, TokenKind},
         parser::error::ParseError,
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -78,16 +79,28 @@ where
 
     /// Lexes the next tokens as a regex assuming that the starting '/' has already been consumed.
     #[inline]
-    pub(super) fn lex_regex(&mut self, start: Position) -> Result<Token, ParseError> {
+    pub(super) fn lex_regex(
+        &mut self,
+        start: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, ParseError> {
         let _timer = BoaProfiler::global().start_event("cursor::lex_regex()", "Parsing");
         self.set_goal(InputElement::RegExp);
-        self.lexer.lex_slash_token(start).map_err(|e| e.into())
+        self.lexer
+            .lex_slash_token(start, interner)
+            .map_err(|e| e.into())
     }
 
     /// Lexes the next tokens as template middle or template tail assuming that the starting
     /// '}' has already been consumed.
-    pub(super) fn lex_template(&mut self, start: Position) -> Result<Token, ParseError> {
-        self.lexer.lex_template(start).map_err(ParseError::from)
+    pub(super) fn lex_template(
+        &mut self,
+        start: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, ParseError> {
+        self.lexer
+            .lex_template(start, interner)
+            .map_err(ParseError::from)
     }
 
     #[inline]
@@ -103,7 +116,7 @@ where
     /// Fills the peeking buffer with the next token.
     ///
     /// It will not fill two line terminators one after the other.
-    fn fill(&mut self) -> Result<(), ParseError> {
+    fn fill(&mut self, interner: &mut Interner) -> Result<(), ParseError> {
         debug_assert!(
             self.write_index < PEEK_BUF_SIZE,
             "write index went out of bounds"
@@ -116,7 +129,7 @@ where
                 // We don't want to have multiple contiguous line terminators in the buffer, since
                 // they have no meaning.
                 let next = loop {
-                    let next = self.lexer.next()?;
+                    let next = self.lexer.next(interner)?;
                     if let Some(ref token) = next {
                         if token.kind() != &TokenKind::LineTerminator {
                             break next;
@@ -128,10 +141,10 @@ where
 
                 self.peeked[self.write_index] = next;
             } else {
-                self.peeked[self.write_index] = self.lexer.next()?;
+                self.peeked[self.write_index] = self.lexer.next(interner)?;
             }
         } else {
-            self.peeked[self.write_index] = self.lexer.next()?;
+            self.peeked[self.write_index] = self.lexer.next(interner)?;
         }
         self.write_index = (self.write_index + 1) % PEEK_BUF_SIZE;
 
@@ -157,9 +170,10 @@ where
     pub(super) fn next(
         &mut self,
         skip_line_terminators: bool,
+        interner: &mut Interner,
     ) -> Result<Option<Token>, ParseError> {
         if self.read_index == self.write_index {
-            self.fill()?;
+            self.fill(interner)?;
         }
 
         if let Some(ref token) = self.peeked[self.read_index] {
@@ -168,7 +182,7 @@ where
                 // was a line terminator, we know that the next won't be one.
                 self.read_index = (self.read_index + 1) % PEEK_BUF_SIZE;
                 if self.read_index == self.write_index {
-                    self.fill()?;
+                    self.fill(interner)?;
                 }
             }
             let tok = self.peeked[self.read_index].take();
@@ -202,6 +216,7 @@ where
         &mut self,
         skip_n: usize,
         skip_line_terminators: bool,
+        interner: &mut Interner,
     ) -> Result<Option<&Token>, ParseError> {
         assert!(
             skip_n <= MAX_PEEK_SKIP,
@@ -213,7 +228,7 @@ where
         let mut count = 0;
         let res_token = loop {
             if read_index == self.write_index {
-                self.fill()?;
+                self.fill(interner)?;
             }
 
             if let Some(ref token) = self.peeked[read_index] {
@@ -222,7 +237,7 @@ where
                     // We only store 1 contiguous line terminator, so if the one at `self.read_index`
                     // was a line terminator, we know that the next won't be one.
                     if read_index == self.write_index {
-                        self.fill()?;
+                        self.fill(interner)?;
                     }
                 }
                 if count == skip_n {
diff --git a/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs b/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs
index a79ad9afc42..13a644a1a4b 100644
--- a/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs
+++ b/boa/src/syntax/parser/cursor/buffered_lexer/tests.rs
@@ -1,199 +1,206 @@
 use super::BufferedLexer;
-use crate::syntax::lexer::{Token, TokenKind};
+use crate::{
+    syntax::lexer::{Token, TokenKind},
+    Interner,
+};
 
 #[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();
 
     assert_eq!(
-        *cur.peek(0, false)
+        *cur.peek(0, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("a")
+        TokenKind::identifier(interner.get_or_intern("a"))
     );
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("b")
+        TokenKind::identifier(interner.get_or_intern("b"))
     );
     assert_eq!(
-        *cur.peek(2, false)
+        *cur.peek(2, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("c")
+        TokenKind::identifier(interner.get_or_intern("c"))
     );
     assert_eq!(
-        *cur.peek(2, false)
+        *cur.peek(2, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("c")
+        TokenKind::identifier(interner.get_or_intern("c"))
     );
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("b")
+        TokenKind::identifier(interner.get_or_intern("b"))
     );
     assert_eq!(
-        *cur.peek(0, false)
+        *cur.peek(0, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("a")
+        TokenKind::identifier(interner.get_or_intern("a"))
     );
 }
 
 #[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();
 
     assert_eq!(
-        *cur.peek(0, false)
+        *cur.peek(0, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("a")
+        TokenKind::identifier(interner.get_or_intern("a"))
     );
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("b")
+        TokenKind::identifier(interner.get_or_intern("b"))
     );
     assert_eq!(
-        *cur.peek(2, false)
+        *cur.peek(2, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("c")
+        TokenKind::identifier(interner.get_or_intern("c"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("a")
+        TokenKind::identifier(interner.get_or_intern("a"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("b")
+        TokenKind::identifier(interner.get_or_intern("b"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("c")
+        TokenKind::identifier(interner.get_or_intern("c"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("d")
+        TokenKind::identifier(interner.get_or_intern("d"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("e")
+        TokenKind::identifier(interner.get_or_intern("e"))
     );
     assert_eq!(
-        *cur.peek(0, false)
+        *cur.peek(0, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("f")
+        TokenKind::identifier(interner.get_or_intern("f"))
     );
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("g")
+        TokenKind::identifier(interner.get_or_intern("g"))
     );
     assert_eq!(
-        *cur.peek(2, false)
+        *cur.peek(2, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("h")
+        TokenKind::identifier(interner.get_or_intern("h"))
     );
 }
 
 #[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();
 
     assert_eq!(
-        *cur.peek(0, false)
+        *cur.peek(0, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("a")
+        TokenKind::identifier(interner.get_or_intern("a"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("a")
+        TokenKind::identifier(interner.get_or_intern("a"))
     );
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("c")
+        TokenKind::identifier(interner.get_or_intern("c"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("b")
+        TokenKind::identifier(interner.get_or_intern("b"))
     );
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("d")
+        TokenKind::identifier(interner.get_or_intern("d"))
     );
     assert_eq!(
-        *cur.next(false)
+        *cur.next(false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("c")
+        TokenKind::identifier(interner.get_or_intern("c"))
     );
     assert_eq!(
-        *cur.peek(2, false)
+        *cur.peek(2, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("f")
+        TokenKind::identifier(interner.get_or_intern("f"))
     );
 }
 
 #[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();
 
     loop {
-        let peek = cur.peek(0, false).unwrap().cloned();
-        let next = cur.next(false).unwrap();
+        let peek = cur.peek(0, false, &mut interner).unwrap().cloned();
+        let next = cur.next(false, &mut interner).unwrap();
 
         assert_eq!(peek, next);
 
@@ -206,17 +213,18 @@ 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 peeked: [Option<Token>; super::MAX_PEEK_SKIP + 1] =
         [None::<Token>, None::<Token>, None::<Token>, None::<Token>];
 
     loop {
         for (i, peek) in peeked.iter_mut().enumerate() {
-            *peek = cur.peek(i, false).unwrap().cloned();
+            *peek = cur.peek(i, false, &mut interner).unwrap().cloned();
         }
 
         for peek in &peeked {
-            assert_eq!(&cur.next(false).unwrap(), peek);
+            assert_eq!(&cur.next(false, &mut interner).unwrap(), peek);
         }
 
         if peeked[super::MAX_PEEK_SKIP - 1].is_none() {
@@ -228,43 +236,45 @@ 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();
+
     assert_eq!(
-        *cur.peek(0, false)
+        *cur.peek(0, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("A")
+        TokenKind::identifier(interner.get_or_intern("A"))
     );
     assert_eq!(
-        *cur.peek(0, true)
+        *cur.peek(0, true, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("A")
+        TokenKind::identifier(interner.get_or_intern("A"))
     );
 
     assert_eq!(
-        *cur.peek(1, false)
+        *cur.peek(1, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
         TokenKind::LineTerminator,
     );
     assert_eq!(
-        *cur.peek(1, true)
+        *cur.peek(1, true, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("B") // This value is after the line terminator
+        TokenKind::identifier(interner.get_or_intern("B")) // This value is after the line terminator
     );
 
     assert_eq!(
-        *cur.peek(2, false)
+        *cur.peek(2, false, &mut interner)
             .unwrap()
             .expect("Some value expected")
             .kind(),
-        TokenKind::identifier("B")
+        TokenKind::identifier(interner.get_or_intern("B"))
     );
     // End of stream
-    assert!(cur.peek(2, true).unwrap().is_none());
+    assert!(cur.peek(2, true, &mut interner).unwrap().is_none());
 }
diff --git a/boa/src/syntax/parser/cursor/mod.rs b/boa/src/syntax/parser/cursor/mod.rs
index 61ddcb55a81..d792780d2b3 100644
--- a/boa/src/syntax/parser/cursor/mod.rs
+++ b/boa/src/syntax/parser/cursor/mod.rs
@@ -2,9 +2,12 @@
 mod buffered_lexer;
 
 use super::ParseError;
-use crate::syntax::{
-    ast::Punctuator,
-    lexer::{InputElement, Lexer, Position, Token, TokenKind},
+use crate::{
+    syntax::{
+        ast::Punctuator,
+        lexer::{InputElement, Lexer, Position, Token, TokenKind},
+    },
+    Interner,
 };
 use buffered_lexer::BufferedLexer;
 use std::io::Read;
@@ -42,23 +45,35 @@ where
     }
 
     #[inline]
-    pub(super) fn lex_regex(&mut self, start: Position) -> Result<Token, ParseError> {
-        self.buffered_lexer.lex_regex(start)
+    pub(super) fn lex_regex(
+        &mut self,
+        start: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, ParseError> {
+        self.buffered_lexer.lex_regex(start, interner)
     }
 
     #[inline]
-    pub(super) fn lex_template(&mut self, start: Position) -> Result<Token, ParseError> {
-        self.buffered_lexer.lex_template(start)
+    pub(super) fn lex_template(
+        &mut self,
+        start: Position,
+        interner: &mut Interner,
+    ) -> Result<Token, ParseError> {
+        self.buffered_lexer.lex_template(start, interner)
     }
 
     #[inline]
-    pub(super) fn next(&mut self) -> Result<Option<Token>, ParseError> {
-        self.buffered_lexer.next(true)
+    pub(super) fn next(&mut self, interner: &mut Interner) -> Result<Option<Token>, ParseError> {
+        self.buffered_lexer.next(true, interner)
     }
 
     #[inline]
-    pub(super) fn peek(&mut self, skip_n: usize) -> Result<Option<&Token>, ParseError> {
-        self.buffered_lexer.peek(skip_n, true)
+    pub(super) fn peek(
+        &mut self,
+        skip_n: usize,
+        interner: &mut Interner,
+    ) -> Result<Option<&Token>, ParseError> {
+        self.buffered_lexer.peek(skip_n, true, interner)
     }
 
     #[inline]
@@ -73,11 +88,16 @@ where
 
     /// Returns an error if the next token is not of kind `kind`.
     #[inline]
-    pub(super) fn expect<K>(&mut self, kind: K, context: &'static str) -> Result<Token, ParseError>
+    pub(super) fn expect<K>(
+        &mut self,
+        kind: K,
+        context: &'static str,
+        interner: &mut Interner,
+    ) -> Result<Token, ParseError>
     where
         K: Into<TokenKind>,
     {
-        let next_token = self.next()?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = self.next(interner)?.ok_or(ParseError::AbruptEnd)?;
         let kind = kind.into();
 
         if next_token.kind() == &kind {
@@ -93,8 +113,11 @@ where
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-automatic-semicolon-insertion
     #[inline]
-    pub(super) fn peek_semicolon(&mut self) -> Result<SemicolonResult<'_>, ParseError> {
-        match self.buffered_lexer.peek(0, false)? {
+    pub(super) fn peek_semicolon(
+        &mut self,
+        interner: &mut Interner,
+    ) -> Result<SemicolonResult<'_>, ParseError> {
+        match self.buffered_lexer.peek(0, false, interner)? {
             Some(tk) => match tk.kind() {
                 TokenKind::Punctuator(Punctuator::Semicolon)
                 | TokenKind::LineTerminator
@@ -113,19 +136,24 @@ where
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-automatic-semicolon-insertion
     #[inline]
-    pub(super) fn expect_semicolon(&mut self, context: &'static str) -> Result<(), ParseError> {
-        match self.peek_semicolon()? {
+    pub(super) fn expect_semicolon(
+        &mut self,
+        context: &'static str,
+        interner: &mut Interner,
+    ) -> Result<(), ParseError> {
+        match self.peek_semicolon(interner)? {
             SemicolonResult::Found(Some(tk)) => match *tk.kind() {
                 TokenKind::Punctuator(Punctuator::Semicolon) | TokenKind::LineTerminator => {
-                    let _ = self.buffered_lexer.next(false)?;
+                    let _ = self.buffered_lexer.next(false, interner)?;
                     Ok(())
                 }
                 _ => Ok(()),
             },
             SemicolonResult::Found(None) => Ok(()),
             SemicolonResult::NotFound(tk) => Err(ParseError::expected(
-                vec![TokenKind::Punctuator(Punctuator::Semicolon)],
-                tk.clone(),
+                vec![";"],
+                tk.to_string(interner),
+                tk.span(),
                 context,
             )),
         }
@@ -141,10 +169,15 @@ where
         &mut self,
         skip_n: usize,
         context: &'static str,
+        interner: &mut Interner,
     ) -> Result<&Token, ParseError> {
-        if let Some(t) = self.buffered_lexer.peek(skip_n, false)? {
+        if let Some(t) = self.buffered_lexer.peek(skip_n, false, interner)? {
             if t.kind() == &TokenKind::LineTerminator {
-                Err(ParseError::unexpected(t.clone(), context))
+                Err(ParseError::unexpected(
+                    t.to_string(interner),
+                    t.span(),
+                    context,
+                ))
             } else {
                 Ok(t)
             }
@@ -159,13 +192,17 @@ where
     ///
     /// No next token also returns None.
     #[inline]
-    pub(super) fn next_if<K>(&mut self, kind: K) -> Result<Option<Token>, ParseError>
+    pub(super) fn next_if<K>(
+        &mut self,
+        kind: K,
+        interner: &mut Interner,
+    ) -> Result<Option<Token>, ParseError>
     where
         K: Into<TokenKind>,
     {
-        Ok(if let Some(token) = self.peek(0)? {
+        Ok(if let Some(token) = self.peek(0, interner)? {
             if token.kind() == &kind.into() {
-                self.next()?
+                self.next(interner)?
             } else {
                 None
             }
diff --git a/boa/src/syntax/parser/error.rs b/boa/src/syntax/parser/error.rs
index c7f40d831f2..c3bee8041ac 100644
--- a/boa/src/syntax/parser/error.rs
+++ b/boa/src/syntax/parser/error.rs
@@ -1,7 +1,8 @@
 //! Error and result implementation for the parser.
 
+use crate::syntax::ast::Span;
 use crate::syntax::ast::{position::Position, Node};
-use crate::syntax::lexer::{Error as LexError, Token, TokenKind};
+use crate::syntax::lexer::Error as LexError;
 use std::fmt;
 
 /// Result of a parsing operation.
@@ -28,13 +29,15 @@ impl From<LexError> for ParseError {
 pub enum ParseError {
     /// When it expected a certain kind of token, but got another as part of something
     Expected {
-        expected: Box<[TokenKind]>,
-        found: Token,
+        expected: Box<[&'static str]>,
+        found: Box<str>,
+        span: Span,
         context: &'static str,
     },
     /// When a token is unexpected
     Unexpected {
-        found: Token,
+        found: Box<str>,
+        span: Span,
         message: Option<&'static str>,
     },
     /// When there is an abrupt end to the parsing
@@ -58,31 +61,38 @@ impl ParseError {
     fn context(self, new_context: &'static str) -> Self {
         match self {
             Self::Expected {
-                expected, found, ..
-            } => Self::expected(expected, found, new_context),
+                expected,
+                found,
+                span,
+                ..
+            } => Self::expected(expected, found, span, new_context),
             e => e,
         }
     }
 
     /// Creates an `Expected` parsing error.
-    pub(super) fn expected<E>(expected: E, found: Token, context: &'static str) -> Self
+    pub(super) fn expected<E, F>(expected: E, found: F, span: Span, context: &'static str) -> Self
     where
-        E: Into<Box<[TokenKind]>>,
+        E: Into<Box<[&'static str]>>,
+        F: Into<Box<str>>,
     {
         Self::Expected {
             expected: expected.into(),
-            found,
+            found: found.into(),
+            span,
             context,
         }
     }
 
     /// Creates an `Expected` parsing error.
-    pub(super) fn unexpected<C>(found: Token, message: C) -> Self
+    pub(super) fn unexpected<F, C>(found: F, span: Span, message: C) -> Self
     where
+        F: Into<Box<str>>,
         C: Into<Option<&'static str>>,
     {
         Self::Unexpected {
-            found,
+            found: found.into(),
+            span,
             message: message.into(),
         }
     }
@@ -118,15 +128,13 @@ impl fmt::Display for ParseError {
             Self::Expected {
                 expected,
                 found,
+                span,
                 context,
             } => write!(
                 f,
                 "expected {}, got '{}' in {} at line {}, col {}",
                 if expected.len() == 1 {
-                    format!(
-                        "token '{}'",
-                        expected.first().map(TokenKind::to_string).unwrap()
-                    )
+                    format!("token '{}'", expected.first().unwrap())
                 } else {
                     format!(
                         "one of {}",
@@ -151,10 +159,14 @@ impl fmt::Display for ParseError {
                 },
                 found,
                 context,
-                found.span().start().line_number(),
-                found.span().start().column_number()
+                span.start().line_number(),
+                span.start().column_number()
             ),
-            Self::Unexpected { found, message } => write!(
+            Self::Unexpected {
+                found,
+                span,
+                message,
+            } => write!(
                 f,
                 "unexpected token '{}'{} at line {}, col {}",
                 found,
@@ -163,8 +175,8 @@ impl fmt::Display for ParseError {
                 } else {
                     String::new()
                 },
-                found.span().start().line_number(),
-                found.span().start().column_number()
+                span.start().line_number(),
+                span.start().column_number()
             ),
             Self::AbruptEnd => f.write_str("abrupt end"),
             Self::General { message, position } => write!(
diff --git a/boa/src/syntax/parser/expression/assignment/arrow_function.rs b/boa/src/syntax/parser/expression/assignment/arrow_function.rs
index 47807dd2f2b..fc373bff7dd 100644
--- a/boa/src/syntax/parser/expression/assignment/arrow_function.rs
+++ b/boa/src/syntax/parser/expression/assignment/arrow_function.rs
@@ -25,7 +25,7 @@ use crate::{
             AllowAwait, AllowIn, AllowYield, Cursor, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -71,44 +71,52 @@ where
 {
     type Output = ArrowFunctionDecl;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ArrowFunction", "Parsing");
-        let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
-
-        let (params, params_start_position) = if let TokenKind::Punctuator(Punctuator::OpenParen) =
-            &next_token.kind()
-        {
-            // CoverParenthesizedExpressionAndArrowParameterList
-            let params_start_position = cursor
-                .expect(Punctuator::OpenParen, "arrow function")?
-                .span()
-                .end();
-
-            let params = FormalParameters::new(self.allow_yield, self.allow_await).parse(cursor)?;
-            cursor.expect(Punctuator::CloseParen, "arrow function")?;
-            (params, params_start_position)
-        } else {
-            let params_start_position = next_token.span().start();
-            let param = BindingIdentifier::new(self.allow_yield, self.allow_await)
-                .parse(cursor)
-                .context("arrow function")?;
-            (
-                FormalParameterList {
-                    parameters: Box::new([FormalParameter::new(
-                        Declaration::new_with_identifier(param, None),
-                        false,
-                    )]),
-                    is_simple: true,
-                    has_duplicates: false,
-                },
-                params_start_position,
-            )
-        };
-
-        cursor.peek_expect_no_lineterminator(0, "arrow function")?;
-
-        cursor.expect(TokenKind::Punctuator(Punctuator::Arrow), "arrow function")?;
-        let body = ConciseBody::new(self.allow_in).parse(cursor)?;
+        let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
+
+        let (params, params_start_position) =
+            if let TokenKind::Punctuator(Punctuator::OpenParen) = &next_token.kind() {
+                // CoverParenthesizedExpressionAndArrowParameterList
+                let params_start_position = cursor
+                    .expect(Punctuator::OpenParen, "arrow function", interner)?
+                    .span()
+                    .end();
+
+                let params = FormalParameters::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
+                cursor.expect(Punctuator::CloseParen, "arrow function", interner)?;
+                (params, params_start_position)
+            } else {
+                let params_start_position = next_token.span().start();
+                let param = BindingIdentifier::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)
+                    .context("arrow function")?;
+                (
+                    FormalParameterList {
+                        parameters: Box::new([FormalParameter::new(
+                            Declaration::new_with_identifier(param, None),
+                            false,
+                        )]),
+                        is_simple: true,
+                        has_duplicates: false,
+                    },
+                    params_start_position,
+                )
+            };
+
+        cursor.peek_expect_no_lineterminator(0, "arrow function", interner)?;
+
+        cursor.expect(
+            TokenKind::Punctuator(Punctuator::Arrow),
+            "arrow function",
+            interner,
+        )?;
+        let body = ConciseBody::new(self.allow_in).parse(cursor, interner)?;
 
         // Early Error: ArrowFormalParameters are UniqueFormalParameters.
         if params.has_duplicates {
@@ -137,7 +145,7 @@ where
                     if lexically_declared_names.contains(param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
                             format!("Redeclaration of formal parameter `{}`", param_name).into(),
-                            match cursor.peek(0)? {
+                            match cursor.peek(0, interner)? {
                                 Some(token) => token.span().end(),
                                 None => Position::new(1, 1),
                             },
@@ -175,16 +183,24 @@ where
 {
     type Output = StatementList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        match cursor
+            .peek(0, interner)?
+            .ok_or(ParseError::AbruptEnd)?
+            .kind()
+        {
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
-                let _ = cursor.next();
-                let body = FunctionBody::new(false, false).parse(cursor)?;
-                cursor.expect(Punctuator::CloseBlock, "arrow function")?;
+                let _ = cursor.next(interner)?;
+                let body = FunctionBody::new(false, false).parse(cursor, interner)?;
+                cursor.expect(Punctuator::CloseBlock, "arrow function", interner)?;
                 Ok(body)
             }
             _ => Ok(StatementList::from(vec![Return::new(
-                ExpressionBody::new(self.allow_in, false).parse(cursor)?,
+                ExpressionBody::new(self.allow_in, false).parse(cursor, interner)?,
                 None,
             )
             .into()])),
@@ -219,7 +235,7 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
-        AssignmentExpression::new(self.allow_in, false, self.allow_await).parse(cursor)
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
+        AssignmentExpression::new(self.allow_in, false, self.allow_await).parse(cursor, interner)
     }
 }
diff --git a/boa/src/syntax/parser/expression/assignment/conditional.rs b/boa/src/syntax/parser/expression/assignment/conditional.rs
index aa9998e4151..49e81460380 100644
--- a/boa/src/syntax/parser/expression/assignment/conditional.rs
+++ b/boa/src/syntax/parser/expression/assignment/conditional.rs
@@ -8,6 +8,7 @@
 //! [spec]: https://tc39.es/ecma262/#sec-conditional-operator
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::ConditionalOp, Node, Punctuator},
@@ -62,23 +63,23 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("ConditionalExpression", "Parsing");
 
         let lhs = ShortCircuitExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-            .parse(cursor)?;
+            .parse(cursor, interner)?;
 
-        if let Some(tok) = cursor.peek(0)? {
+        if let Some(tok) = cursor.peek(0, interner)? {
             if tok.kind() == &TokenKind::Punctuator(Punctuator::Question) {
-                cursor.next()?.expect("? character vanished"); // Consume the token.
+                cursor.next(interner)?.expect("? character vanished"); // Consume the token.
                 let then_clause =
                     AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
-                cursor.expect(Punctuator::Colon, "conditional expression")?;
+                        .parse(cursor, interner)?;
+                cursor.expect(Punctuator::Colon, "conditional expression", interner)?;
 
                 let else_clause =
                     AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
                 return Ok(ConditionalOp::new(lhs, then_clause, else_clause).into());
             }
         }
diff --git a/boa/src/syntax/parser/expression/assignment/exponentiation.rs b/boa/src/syntax/parser/expression/assignment/exponentiation.rs
index e9eac4c9dd9..c09820c534c 100644
--- a/boa/src/syntax/parser/expression/assignment/exponentiation.rs
+++ b/boa/src/syntax/parser/expression/assignment/exponentiation.rs
@@ -9,6 +9,7 @@
 
 use super::ParseError;
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{
@@ -55,11 +56,14 @@ impl ExponentiationExpression {
 }
 
 /// Checks by looking at the next token to see whether it's a unary operator or not.
-fn is_unary_expression<R>(cursor: &mut Cursor<R>) -> Result<bool, ParseError>
+fn is_unary_expression<R>(
+    cursor: &mut Cursor<R>,
+    interner: &mut Interner,
+) -> Result<bool, ParseError>
 where
     R: Read,
 {
-    Ok(if let Some(tok) = cursor.peek(0)? {
+    Ok(if let Some(tok) = cursor.peek(0, interner)? {
         matches!(
             tok.kind(),
             TokenKind::Keyword(Keyword::Delete)
@@ -81,18 +85,20 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("ExponentiationExpression", "Parsing");
 
-        if is_unary_expression(cursor)? {
-            return UnaryExpression::new(self.allow_yield, self.allow_await).parse(cursor);
+        if is_unary_expression(cursor, interner)? {
+            return UnaryExpression::new(self.allow_yield, self.allow_await)
+                .parse(cursor, interner);
         }
 
-        let lhs = UpdateExpression::new(self.allow_yield, self.allow_await).parse(cursor)?;
-        if let Some(tok) = cursor.peek(0)? {
+        let lhs =
+            UpdateExpression::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
+        if let Some(tok) = cursor.peek(0, interner)? {
             if let TokenKind::Punctuator(Punctuator::Exp) = tok.kind() {
-                cursor.next()?.expect("** token vanished"); // Consume the token.
-                return Ok(BinOp::new(NumOp::Exp, lhs, self.parse(cursor)?).into());
+                cursor.next(interner)?.expect("** token vanished"); // Consume the token.
+                return Ok(BinOp::new(NumOp::Exp, lhs, self.parse(cursor, interner)?).into());
             }
         }
         Ok(lhs)
diff --git a/boa/src/syntax/parser/expression/assignment/mod.rs b/boa/src/syntax/parser/expression/assignment/mod.rs
index 067aa39dcdb..b451311ffed 100644
--- a/boa/src/syntax/parser/expression/assignment/mod.rs
+++ b/boa/src/syntax/parser/expression/assignment/mod.rs
@@ -15,6 +15,7 @@ mod r#yield;
 use self::r#yield::YieldExpression;
 use self::{arrow_function::ArrowFunction, conditional::ConditionalExpression};
 use crate::syntax::lexer::{Error as LexError, InputElement, TokenKind};
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{
@@ -80,46 +81,53 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("AssignmentExpression", "Parsing");
         cursor.set_goal(InputElement::Div);
 
-        match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+        match cursor
+            .peek(0, interner)?
+            .ok_or(ParseError::AbruptEnd)?
+            .kind()
+        {
             // [+Yield]YieldExpression[?In, ?Await]
             TokenKind::Keyword(Keyword::Yield) if self.allow_yield.0 => {
-                return YieldExpression::new(self.allow_in, self.allow_await).parse(cursor)
+                return YieldExpression::new(self.allow_in, self.allow_await)
+                    .parse(cursor, interner)
             }
             // ArrowFunction[?In, ?Yield, ?Await] -> ArrowParameters[?Yield, ?Await] -> BindingIdentifier[?Yield, ?Await]
             TokenKind::Identifier(_)
             | TokenKind::Keyword(Keyword::Yield)
             | TokenKind::Keyword(Keyword::Await) => {
-                if let Ok(tok) = cursor.peek_expect_no_lineterminator(1, "assignment expression") {
+                if let Ok(tok) =
+                    cursor.peek_expect_no_lineterminator(1, "assignment expression", interner)
+                {
                     if tok.kind() == &TokenKind::Punctuator(Punctuator::Arrow) {
                         return ArrowFunction::new(
                             self.allow_in,
                             self.allow_yield,
                             self.allow_await,
                         )
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::ArrowFunctionDecl);
                     }
                 }
             }
             // ArrowFunction[?In, ?Yield, ?Await] -> ArrowParameters[?Yield, ?Await] -> CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]
             TokenKind::Punctuator(Punctuator::OpenParen) => {
-                if let Some(next_token) = cursor.peek(1)? {
+                if let Some(next_token) = cursor.peek(1, interner)? {
                     match *next_token.kind() {
                         TokenKind::Punctuator(Punctuator::CloseParen) => {
                             // Need to check if the token after the close paren is an arrow, if so then this is an ArrowFunction
                             // otherwise it is an expression of the form (b).
-                            if let Some(t) = cursor.peek(2)? {
+                            if let Some(t) = cursor.peek(2, interner)? {
                                 if t.kind() == &TokenKind::Punctuator(Punctuator::Arrow) {
                                     return ArrowFunction::new(
                                         self.allow_in,
                                         self.allow_yield,
                                         self.allow_await,
                                     )
-                                    .parse(cursor)
+                                    .parse(cursor, interner)
                                     .map(Node::ArrowFunctionDecl);
                                 }
                             }
@@ -130,11 +138,11 @@ where
                                 self.allow_yield,
                                 self.allow_await,
                             )
-                            .parse(cursor)
+                            .parse(cursor, interner)
                             .map(Node::ArrowFunctionDecl);
                         }
                         TokenKind::Identifier(_) => {
-                            if let Some(t) = cursor.peek(2)? {
+                            if let Some(t) = cursor.peek(2, interner)? {
                                 match *t.kind() {
                                     TokenKind::Punctuator(Punctuator::Comma) => {
                                         // This must be an argument list and therefore (a, b) => {}
@@ -143,13 +151,13 @@ where
                                             self.allow_yield,
                                             self.allow_await,
                                         )
-                                        .parse(cursor)
+                                        .parse(cursor, interner)
                                         .map(Node::ArrowFunctionDecl);
                                     }
                                     TokenKind::Punctuator(Punctuator::CloseParen) => {
                                         // Need to check if the token after the close paren is an arrow, if so then this is an ArrowFunction
                                         // otherwise it is an expression of the form (b).
-                                        if let Some(t) = cursor.peek(3)? {
+                                        if let Some(t) = cursor.peek(3, interner)? {
                                             if t.kind() == &TokenKind::Punctuator(Punctuator::Arrow)
                                             {
                                                 return ArrowFunction::new(
@@ -157,7 +165,7 @@ where
                                                     self.allow_yield,
                                                     self.allow_await,
                                                 )
-                                                .parse(cursor)
+                                                .parse(cursor, interner)
                                                 .map(Node::ArrowFunctionDecl);
                                             }
                                         }
@@ -177,16 +185,16 @@ where
         cursor.set_goal(InputElement::Div);
 
         let mut lhs = ConditionalExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-            .parse(cursor)?;
+            .parse(cursor, interner)?;
 
         // Review if we are trying to assign to an invalid left hand side expression.
         // TODO: can we avoid cloning?
-        if let Some(tok) = cursor.peek(0)?.cloned() {
+        if let Some(tok) = cursor.peek(0, interner)?.cloned() {
             match tok.kind() {
                 TokenKind::Punctuator(Punctuator::Assign) => {
-                    cursor.next()?.expect("= token vanished"); // Consume the token.
+                    cursor.next(interner)?.expect("= token vanished"); // Consume the token.
                     if is_assignable(&lhs) {
-                        lhs = Assign::new(lhs, self.parse(cursor)?).into();
+                        lhs = Assign::new(lhs, self.parse(cursor, interner)?).into();
                     } else {
                         return Err(ParseError::lex(LexError::Syntax(
                             "Invalid left-hand side in assignment".into(),
@@ -195,10 +203,10 @@ where
                     }
                 }
                 TokenKind::Punctuator(p) if p.as_binop().is_some() && p != &Punctuator::Comma => {
-                    cursor.next()?.expect("token vanished"); // Consume the token.
+                    cursor.next(interner)?.expect("token vanished"); // Consume the token.
                     if is_assignable(&lhs) {
                         let binop = p.as_binop().expect("binop disappeared");
-                        let expr = self.parse(cursor)?;
+                        let expr = self.parse(cursor, interner)?;
 
                         lhs = BinOp::new(binop, lhs, expr).into();
                     } else {
diff --git a/boa/src/syntax/parser/expression/assignment/yield.rs b/boa/src/syntax/parser/expression/assignment/yield.rs
index 2845f148e3c..703b40aafb6 100644
--- a/boa/src/syntax/parser/expression/assignment/yield.rs
+++ b/boa/src/syntax/parser/expression/assignment/yield.rs
@@ -16,7 +16,7 @@ use crate::{
         lexer::TokenKind,
         parser::{cursor::SemicolonResult, AllowAwait, AllowIn, Cursor, ParseResult, TokenParser},
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -57,26 +57,38 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("YieldExpression", "Parsing");
 
-        cursor.expect(TokenKind::Keyword(Keyword::Yield), "yield expression")?;
+        cursor.expect(
+            TokenKind::Keyword(Keyword::Yield),
+            "yield expression",
+            interner,
+        )?;
 
         let mut expr = None;
         let mut delegate = false;
 
-        if let SemicolonResult::Found(_) = cursor.peek_semicolon()? {
+        if let SemicolonResult::Found(_) = cursor.peek_semicolon(interner)? {
             cursor.expect(
                 TokenKind::Punctuator(Punctuator::Semicolon),
                 "token disappeared",
+                interner,
             )?;
-        } else if let Ok(next_token) = cursor.peek_expect_no_lineterminator(0, "yield expression") {
+        } else if let Ok(next_token) =
+            cursor.peek_expect_no_lineterminator(0, "yield expression", interner)
+        {
             if let TokenKind::Punctuator(Punctuator::Mul) = next_token.kind() {
-                cursor.expect(TokenKind::Punctuator(Punctuator::Mul), "token disappeared")?;
+                cursor.expect(
+                    TokenKind::Punctuator(Punctuator::Mul),
+                    "token disappeared",
+                    interner,
+                )?;
                 delegate = true;
             }
             expr = Some(
-                AssignmentExpression::new(self.allow_in, true, self.allow_await).parse(cursor)?,
+                AssignmentExpression::new(self.allow_in, true, self.allow_await)
+                    .parse(cursor, interner)?,
             );
         }
 
diff --git a/boa/src/syntax/parser/expression/await_expr.rs b/boa/src/syntax/parser/expression/await_expr.rs
index 2ecf34a6fe5..6f988a33ed2 100644
--- a/boa/src/syntax/parser/expression/await_expr.rs
+++ b/boa/src/syntax/parser/expression/await_expr.rs
@@ -9,10 +9,13 @@
 
 use super::unary::UnaryExpression;
 
-use crate::syntax::{
-    ast::{node::AwaitExpr, Keyword},
-    lexer::TokenKind,
-    parser::{AllowYield, Cursor, ParseError, TokenParser},
+use crate::{
+    syntax::{
+        ast::{node::AwaitExpr, Keyword},
+        lexer::TokenKind,
+        parser::{AllowYield, Cursor, ParseError, TokenParser},
+    },
+    Interner,
 };
 use std::io::Read;
 
@@ -47,12 +50,17 @@ where
 {
     type Output = AwaitExpr;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         cursor.expect(
             TokenKind::Keyword(Keyword::Await),
             "Await expression parsing",
+            interner,
         )?;
-        let expr = UnaryExpression::new(self.allow_yield, true).parse(cursor)?;
+        let expr = UnaryExpression::new(self.allow_yield, true).parse(cursor, interner)?;
         Ok(expr.into())
     }
 }
diff --git a/boa/src/syntax/parser/expression/left_hand_side/arguments.rs b/boa/src/syntax/parser/expression/left_hand_side/arguments.rs
index 7be4886f6cc..2ddd79d7c2b 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/arguments.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/arguments.rs
@@ -8,6 +8,7 @@
 //! [spec]: https://tc39.es/ecma262/#prod-Arguments
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::Spread, Node, Punctuator},
@@ -56,49 +57,55 @@ where
 {
     type Output = Box<[Node]>;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Arguments", "Parsing");
 
-        cursor.expect(Punctuator::OpenParen, "arguments")?;
+        cursor.expect(Punctuator::OpenParen, "arguments", interner)?;
         let mut args = Vec::new();
         loop {
-            let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+            let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
             match next_token.kind() {
                 TokenKind::Punctuator(Punctuator::CloseParen) => {
-                    cursor.next()?.expect(") token vanished"); // Consume the token.
+                    cursor.next(interner)?.expect(") token vanished"); // Consume the token.
                     break;
                 }
                 TokenKind::Punctuator(Punctuator::Comma) => {
-                    let next_token = cursor.next()?.expect(", token vanished"); // Consume the token.
+                    let next_token = cursor.next(interner)?.expect(", token vanished"); // Consume the token.
 
                     if args.is_empty() {
-                        return Err(ParseError::unexpected(next_token, None));
+                        return Err(ParseError::unexpected(
+                            next_token.to_string(interner),
+                            next_token.span(),
+                            None,
+                        ));
                     }
 
-                    if cursor.next_if(Punctuator::CloseParen)?.is_some() {
+                    if cursor.next_if(Punctuator::CloseParen, interner)?.is_some() {
                         break;
                     }
                 }
                 _ => {
                     if !args.is_empty() {
                         return Err(ParseError::expected(
-                            vec![
-                                TokenKind::Punctuator(Punctuator::Comma),
-                                TokenKind::Punctuator(Punctuator::CloseParen),
-                            ],
-                            next_token.clone(),
+                            vec![",", "}"],
+                            next_token.to_string(interner),
+                            next_token.span(),
                             "argument list",
                         ));
                     }
                 }
             }
 
-            if cursor.next_if(Punctuator::Spread)?.is_some() {
+            if cursor.next_if(Punctuator::Spread, interner)?.is_some() {
                 args.push(
                     Spread::new(
                         AssignmentExpression::new(true, self.allow_yield, self.allow_await)
-                            .parse(cursor)?,
+                            .parse(cursor, interner)?,
                     )
                     .into(),
                 );
@@ -106,7 +113,7 @@ where
                 cursor.set_goal(InputElement::RegExp);
                 args.push(
                     AssignmentExpression::new(true, self.allow_yield, self.allow_await)
-                        .parse(cursor)?,
+                        .parse(cursor, interner)?,
                 );
             }
         }
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 238823a2e85..357c182068b 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/call.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/call.rs
@@ -23,7 +23,7 @@ use crate::{
             AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -62,54 +62,65 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("CallExpression", "Parsing");
 
-        let token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         let mut lhs = if token.kind() == &TokenKind::Punctuator(Punctuator::OpenParen) {
-            let args = Arguments::new(self.allow_yield, self.allow_await).parse(cursor)?;
+            let args =
+                Arguments::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
             Node::from(Call::new(self.first_member_expr, args))
         } else {
-            let next_token = cursor.next()?.expect("token vanished");
+            let next_token = cursor.next(interner)?.expect("token vanished");
             return Err(ParseError::expected(
-                vec![TokenKind::Punctuator(Punctuator::OpenParen)],
-                next_token,
+                vec!["("],
+                next_token.to_string(interner),
+                next_token.span(),
                 "call expression",
             ));
         };
 
-        while let Some(tok) = cursor.peek(0)? {
+        while let Some(tok) = cursor.peek(0, interner)? {
             let token = tok.clone();
             match token.kind() {
                 TokenKind::Punctuator(Punctuator::OpenParen) => {
-                    let args = Arguments::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                    let args = Arguments::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
                     lhs = Node::from(Call::new(lhs, args));
                 }
                 TokenKind::Punctuator(Punctuator::Dot) => {
-                    cursor.next()?.ok_or(ParseError::AbruptEnd)?; // We move the parser forward.
+                    cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?; // We move the parser forward.
 
-                    match &cursor.next()?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    match &cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?.kind() {
                         TokenKind::Identifier(name) => {
-                            lhs = GetConstField::new(lhs, name.clone()).into();
+                            lhs = GetConstField::new(
+                                lhs,
+                                interner
+                                    .resolve(*name)
+                                    .expect("string disappeared")
+                                    .to_owned(),
+                            )
+                            .into();
                         }
                         TokenKind::Keyword(kw) => {
                             lhs = GetConstField::new(lhs, kw.to_string()).into();
                         }
                         _ => {
                             return Err(ParseError::expected(
-                                vec![TokenKind::identifier("identifier")],
-                                token,
+                                vec!["identifier"],
+                                token.to_string(interner),
+                                token.span(),
                                 "call expression",
                             ));
                         }
                     }
                 }
                 TokenKind::Punctuator(Punctuator::OpenBracket) => {
-                    let _ = cursor.next()?.ok_or(ParseError::AbruptEnd)?; // We move the parser.
-                    let idx =
-                        Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
-                    cursor.expect(Punctuator::CloseBracket, "call expression")?;
+                    let _ = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?; // We move the parser.
+                    let idx = Expression::new(true, self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
+                    cursor.expect(Punctuator::CloseBracket, "call expression", interner)?;
                     lhs = GetField::new(lhs, idx).into();
                 }
                 TokenKind::TemplateNoSubstitution { .. } | TokenKind::TemplateMiddle { .. } => {
@@ -119,7 +130,7 @@ where
                         tok.span().start(),
                         lhs,
                     )
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
                 }
                 _ => break,
             }
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 3bf4ad7287d..7ecc3691501 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/member.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/member.rs
@@ -24,7 +24,7 @@ use crate::{
             AllowAwait, AllowYield, Cursor, ParseError, ParseResult, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -61,17 +61,20 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("MemberExpression", "Parsing");
 
-        let mut lhs = if cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind()
+        let mut lhs = if cursor
+            .peek(0, interner)?
+            .ok_or(ParseError::AbruptEnd)?
+            .kind()
             == &TokenKind::Keyword(Keyword::New)
         {
-            let _ = cursor.next().expect("new keyword disappeared");
-            let lhs = self.parse(cursor)?;
-            let args = match cursor.peek(0)? {
+            let _ = cursor.next(interner).expect("new keyword disappeared");
+            let lhs = self.parse(cursor, interner)?;
+            let args = match cursor.peek(0, interner)? {
                 Some(next) if next.kind() == &TokenKind::Punctuator(Punctuator::OpenParen) => {
-                    Arguments::new(self.allow_yield, self.allow_await).parse(cursor)?
+                    Arguments::new(self.allow_yield, self.allow_await).parse(cursor, interner)?
                 }
                 _ => Box::new([]),
             };
@@ -79,26 +82,33 @@ where
 
             Node::from(New::from(call_node))
         } else {
-            PrimaryExpression::new(self.allow_yield, self.allow_await).parse(cursor)?
+            PrimaryExpression::new(self.allow_yield, self.allow_await).parse(cursor, interner)?
         };
-        while let Some(tok) = cursor.peek(0)? {
+        while let Some(tok) = cursor.peek(0, interner)? {
             match tok.kind() {
                 TokenKind::Punctuator(Punctuator::Dot) => {
-                    cursor.next()?.expect("dot punctuator token disappeared"); // We move the parser forward.
+                    cursor
+                        .next(interner)?
+                        .expect("dot punctuator token disappeared"); // We move the parser forward.
 
-                    let token = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+                    let token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
                     match token.kind() {
                         TokenKind::Identifier(name) => {
-                            lhs = GetConstField::new(lhs, name.clone()).into()
+                            lhs = GetConstField::new(
+                                lhs,
+                                interner.resolve(*name).expect("string disappeared").clone(),
+                            )
+                            .into()
                         }
                         TokenKind::Keyword(kw) => {
                             lhs = GetConstField::new(lhs, kw.to_string()).into()
                         }
                         _ => {
                             return Err(ParseError::expected(
-                                vec![TokenKind::identifier("identifier")],
-                                token,
+                                vec!["identifier"],
+                                token.to_string(interner),
+                                token.span(),
                                 "member expression",
                             ));
                         }
@@ -106,11 +116,11 @@ where
                 }
                 TokenKind::Punctuator(Punctuator::OpenBracket) => {
                     cursor
-                        .next()?
+                        .next(interner)?
                         .expect("open bracket punctuator token disappeared"); // We move the parser forward.
-                    let idx =
-                        Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
-                    cursor.expect(Punctuator::CloseBracket, "member expression")?;
+                    let idx = Expression::new(true, self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
+                    cursor.expect(Punctuator::CloseBracket, "member expression", interner)?;
                     lhs = GetField::new(lhs, idx).into();
                 }
                 TokenKind::TemplateNoSubstitution { .. } | TokenKind::TemplateMiddle { .. } => {
@@ -120,7 +130,7 @@ where
                         tok.span().start(),
                         lhs,
                     )
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
                 }
                 _ => break,
             }
diff --git a/boa/src/syntax/parser/expression/left_hand_side/mod.rs b/boa/src/syntax/parser/expression/left_hand_side/mod.rs
index 76f36e3f3dd..d40da0d47fb 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/mod.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/mod.rs
@@ -18,8 +18,9 @@ use crate::{
     syntax::{
         ast::{Node, Punctuator},
         lexer::{InputElement, TokenKind},
-        parser::{AllowAwait, AllowYield, Cursor, ParseError, TokenParser},
+        parser::{AllowAwait, AllowYield, Cursor, ParseResult, TokenParser},
     },
+    Interner,
 };
 
 use std::io::Read;
@@ -58,16 +59,18 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("LeftHandSIdeExpression", "Parsing");
 
         cursor.set_goal(InputElement::TemplateTail);
 
         // TODO: Implement NewExpression: new MemberExpression
-        let lhs = MemberExpression::new(self.allow_yield, self.allow_await).parse(cursor)?;
-        if let Some(tok) = cursor.peek(0)? {
+        let lhs =
+            MemberExpression::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
+        if let Some(tok) = cursor.peek(0, interner)? {
             if tok.kind() == &TokenKind::Punctuator(Punctuator::OpenParen) {
-                return CallExpression::new(self.allow_yield, self.allow_await, lhs).parse(cursor);
+                return CallExpression::new(self.allow_yield, self.allow_await, lhs)
+                    .parse(cursor, interner);
             }
         }
         Ok(lhs)
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 a08194ec98f..48a1b39d391 100644
--- a/boa/src/syntax/parser/expression/left_hand_side/template.rs
+++ b/boa/src/syntax/parser/expression/left_hand_side/template.rs
@@ -9,6 +9,7 @@ use crate::{
             ParseResult, TokenParser,
         },
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -48,31 +49,45 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("TaggedTemplateLiteral", "Parsing");
 
         let mut raws = Vec::new();
         let mut cookeds = Vec::new();
         let mut exprs = Vec::new();
 
-        let mut token = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+        let mut token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
         loop {
             match token.kind() {
                 TokenKind::TemplateMiddle(template_string) => {
-                    raws.push(template_string.as_raw().to_owned().into_boxed_str());
-                    cookeds.push(template_string.to_owned_cooked().ok());
+                    raws.push(
+                        interner
+                            .resolve(template_string.as_raw())
+                            .expect("string disappeared")
+                            .to_owned()
+                            .into_boxed_str(),
+                    );
+                    cookeds.push(template_string.to_owned_cooked(interner).ok());
                     exprs.push(
-                        Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?,
+                        Expression::new(true, self.allow_yield, self.allow_await)
+                            .parse(cursor, interner)?,
                     );
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::CloseBlock),
                         "template literal",
+                        interner,
                     )?;
                 }
                 TokenKind::TemplateNoSubstitution(template_string) => {
-                    raws.push(template_string.as_raw().to_owned().into_boxed_str());
-                    cookeds.push(template_string.to_owned_cooked().ok());
+                    raws.push(
+                        interner
+                            .resolve(template_string.as_raw())
+                            .expect("string disappeared")
+                            .to_owned()
+                            .into_boxed_str(),
+                    );
+                    cookeds.push(template_string.to_owned_cooked(interner).ok());
                     return Ok(Node::from(TaggedTemplate::new(
                         self.tag, raws, cookeds, exprs,
                     )));
@@ -84,7 +99,7 @@ where
                     ))
                 }
             }
-            token = cursor.lex_template(self.start)?;
+            token = cursor.lex_template(self.start, interner)?;
         }
     }
 }
diff --git a/boa/src/syntax/parser/expression/mod.rs b/boa/src/syntax/parser/expression/mod.rs
index 418081d07c9..62ab3e78373 100644
--- a/boa/src/syntax/parser/expression/mod.rs
+++ b/boa/src/syntax/parser/expression/mod.rs
@@ -32,6 +32,7 @@ use crate::{
         lexer::{InputElement, TokenKind},
         parser::ParseError,
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -75,30 +76,30 @@ macro_rules! expression { ($name:ident, $lower:ident, [$( $op:path ),*], [$( $lo
     {
         type Output = Node;
 
-        fn parse(self, cursor: &mut Cursor<R>)-> ParseResult {
+        fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner)-> ParseResult {
             let _timer = BoaProfiler::global().start_event(stringify!($name), "Parsing");
 
             if $goal.is_some() {
                 cursor.set_goal($goal.unwrap());
             }
 
-            let mut lhs = $lower::new($( self.$low_param ),*).parse(cursor)?;
-            while let Some(tok) = cursor.peek(0)? {
+            let mut lhs = $lower::new($( self.$low_param ),*).parse(cursor, interner)?;
+            while let Some(tok) = cursor.peek(0, interner)? {
                 match *tok.kind() {
                     TokenKind::Punctuator(op) if $( op == $op )||* => {
-                        let _ = cursor.next().expect("token disappeared");
+                        let _ = cursor.next(interner).expect("token disappeared");
                         lhs = BinOp::new(
                             op.as_binop().expect("Could not get binary operation."),
                             lhs,
-                            $lower::new($( self.$low_param ),*).parse(cursor)?
+                            $lower::new($( self.$low_param ),*).parse(cursor, interner)?
                         ).into();
                     }
                     TokenKind::Keyword(op) if $( op == $op )||* => {
-                        let _ = cursor.next().expect("token disappeared");
+                        let _ = cursor.next(interner).expect("token disappeared");
                         lhs = BinOp::new(
                             op.as_binop().expect("Could not get binary operation."),
                             lhs,
-                            $lower::new($( self.$low_param ),*).parse(cursor)?
+                            $lower::new($( self.$low_param ),*).parse(cursor, interner)?
                         ).into();
                     }
                     _ => break
@@ -214,41 +215,41 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("ShortCircuitExpression", "Parsing");
 
         let mut current_node =
             BitwiseORExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-                .parse(cursor)?;
+                .parse(cursor, interner)?;
         let mut previous = self.previous;
 
-        while let Some(tok) = cursor.peek(0)? {
+        while let Some(tok) = cursor.peek(0, interner)? {
             match tok.kind() {
                 TokenKind::Punctuator(Punctuator::BoolAnd) => {
                     if previous == PreviousExpr::Coalesce {
                         return Err(ParseError::expected(
-                            [TokenKind::Punctuator(Punctuator::Coalesce)],
-                            tok.clone(),
+                            ["??"],
+                            tok.to_string(interner), tok.span(),
                             "logical expression (cannot use '??' without parentheses within '||' or '&&')",
                         ));
                     }
-                    let _ = cursor.next()?.expect("'&&' expected");
+                    let _ = cursor.next(interner)?.expect("'&&' expected");
                     previous = PreviousExpr::Logical;
                     let rhs =
                         BitwiseORExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-                            .parse(cursor)?;
+                            .parse(cursor, interner)?;
 
                     current_node = BinOp::new(LogOp::And, current_node, rhs).into();
                 }
                 TokenKind::Punctuator(Punctuator::BoolOr) => {
                     if previous == PreviousExpr::Coalesce {
                         return Err(ParseError::expected(
-                            [TokenKind::Punctuator(Punctuator::Coalesce)],
-                            tok.clone(),
+                            ["??"],
+                            tok.to_string(interner), tok.span(),
                             "logical expression (cannot use '??' without parentheses within '||' or '&&')",
                         ));
                     }
-                    let _ = cursor.next()?.expect("'||' expected");
+                    let _ = cursor.next(interner)?.expect("'||' expected");
                     previous = PreviousExpr::Logical;
                     let rhs = ShortCircuitExpression::with_previous(
                         self.allow_in,
@@ -256,25 +257,23 @@ where
                         self.allow_await,
                         PreviousExpr::Logical,
                     )
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
                     current_node = BinOp::new(LogOp::Or, current_node, rhs).into();
                 }
                 TokenKind::Punctuator(Punctuator::Coalesce) => {
                     if previous == PreviousExpr::Logical {
                         return Err(ParseError::expected(
-                            [
-                                TokenKind::Punctuator(Punctuator::BoolAnd),
-                                TokenKind::Punctuator(Punctuator::BoolOr),
-                            ],
-                            tok.clone(),
+                            ["&&", "||"],
+                            tok.to_string(interner),
+                            tok.span(),
                             "cannot use '??' unparenthesized within '||' or '&&'",
                         ));
                     }
-                    let _ = cursor.next()?.expect("'??' expected");
+                    let _ = cursor.next(interner)?.expect("'??' expected");
                     previous = PreviousExpr::Coalesce;
                     let rhs =
                         BitwiseORExpression::new(self.allow_in, self.allow_yield, self.allow_await)
-                            .parse(cursor)?;
+                            .parse(cursor, interner)?;
                     current_node = BinOp::new(LogOp::Coalesce, current_node, rhs).into();
                 }
                 _ => break,
@@ -482,15 +481,16 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("Relation Expression", "Parsing");
 
         if None::<InputElement>.is_some() {
             cursor.set_goal(None::<InputElement>.unwrap());
         }
 
-        let mut lhs = ShiftExpression::new(self.allow_yield, self.allow_await).parse(cursor)?;
-        while let Some(tok) = cursor.peek(0)? {
+        let mut lhs =
+            ShiftExpression::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
+        while let Some(tok) = cursor.peek(0, interner)? {
             match *tok.kind() {
                 TokenKind::Punctuator(op)
                     if op == Punctuator::LessThan
@@ -498,11 +498,12 @@ where
                         || op == Punctuator::LessThanOrEq
                         || op == Punctuator::GreaterThanOrEq =>
                 {
-                    let _ = cursor.next().expect("token disappeared");
+                    let _ = cursor.next(interner).expect("token disappeared");
                     lhs = BinOp::new(
                         op.as_binop().expect("Could not get binary operation."),
                         lhs,
-                        ShiftExpression::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                        ShiftExpression::new(self.allow_yield, self.allow_await)
+                            .parse(cursor, interner)?,
                     )
                     .into();
                 }
@@ -510,11 +511,12 @@ where
                     if op == Keyword::InstanceOf
                         || (op == Keyword::In && self.allow_in == AllowIn(true)) =>
                 {
-                    let _ = cursor.next().expect("token disappeared");
+                    let _ = cursor.next(interner).expect("token disappeared");
                     lhs = BinOp::new(
                         op.as_binop().expect("Could not get binary operation."),
                         lhs,
-                        ShiftExpression::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                        ShiftExpression::new(self.allow_yield, self.allow_await)
+                            .parse(cursor, interner)?,
                     )
                     .into();
                 }
diff --git a/boa/src/syntax/parser/expression/primary/array_initializer/mod.rs b/boa/src/syntax/parser/expression/primary/array_initializer/mod.rs
index 427e7f8cd73..53f751a87f1 100644
--- a/boa/src/syntax/parser/expression/primary/array_initializer/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/array_initializer/mod.rs
@@ -21,7 +21,7 @@ use crate::{
             TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -60,33 +60,40 @@ where
 {
     type Output = ArrayDecl;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ArrayLiteral", "Parsing");
         let mut elements = Vec::new();
 
         loop {
             // TODO: Support all features.
-            while cursor.next_if(Punctuator::Comma)?.is_some() {
+            while cursor.next_if(Punctuator::Comma, interner)?.is_some() {
                 elements.push(Node::Const(Const::Undefined));
             }
 
-            if cursor.next_if(Punctuator::CloseBracket)?.is_some() {
+            if cursor
+                .next_if(Punctuator::CloseBracket, interner)?
+                .is_some()
+            {
                 break;
             }
 
-            let _ = cursor.peek(0)?.ok_or(ParseError::AbruptEnd); // Check that there are more tokens to read.
+            let _ = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd); // Check that there are more tokens to read.
 
-            if cursor.next_if(Punctuator::Spread)?.is_some() {
+            if cursor.next_if(Punctuator::Spread, interner)?.is_some() {
                 let node = AssignmentExpression::new(true, self.allow_yield, self.allow_await)
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
                 elements.push(Spread::new(node).into());
             } else {
                 elements.push(
                     AssignmentExpression::new(true, self.allow_yield, self.allow_await)
-                        .parse(cursor)?,
+                        .parse(cursor, interner)?,
                 );
             }
-            cursor.next_if(Punctuator::Comma)?;
+            cursor.next_if(Punctuator::Comma, interner)?;
         }
 
         Ok(elements.into())
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 d2b51d6177c..c2f75aa96b3 100644
--- a/boa/src/syntax/parser/expression/primary/array_initializer/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/array_initializer/tests.rs
@@ -1,28 +1,35 @@
 // ! Tests for array initializer parsing.
 
-use crate::syntax::{
-    ast::{node::ArrayDecl, Const},
-    parser::tests::check_parser,
+use crate::{
+    syntax::{
+        ast::{node::ArrayDecl, Const},
+        parser::tests::check_parser,
+    },
+    Interner,
 };
 
 /// Checks an empty array.
 #[test]
 fn check_empty() {
-    check_parser("[]", vec![ArrayDecl::from(vec![]).into()]);
+    let mut interner = Interner::new();
+    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();
     check_parser(
         "[,]",
         vec![ArrayDecl::from(vec![Const::Undefined.into()]).into()],
+        &mut interner,
     );
 }
 
 /// Checks a numeric array.
 #[test]
 fn check_numeric_array() {
+    let mut interner = Interner::new();
     check_parser(
         "[1, 2, 3]",
         vec![ArrayDecl::from(vec![
@@ -31,12 +38,14 @@ fn check_numeric_array() {
             Const::from(3).into(),
         ])
         .into()],
+        &mut interner,
     );
 }
 
 // Checks a numeric array with trailing comma
 #[test]
 fn check_numeric_array_trailing() {
+    let mut interner = Interner::new();
     check_parser(
         "[1, 2, 3,]",
         vec![ArrayDecl::from(vec![
@@ -45,12 +54,14 @@ fn check_numeric_array_trailing() {
             Const::from(3).into(),
         ])
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks a numeric array with an elision.
 #[test]
 fn check_numeric_array_elision() {
+    let mut interner = Interner::new();
     check_parser(
         "[1, 2, , 3]",
         vec![ArrayDecl::from(vec![
@@ -60,12 +71,14 @@ fn check_numeric_array_elision() {
             Const::from(3).into(),
         ])
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks a numeric array with repeated elisions.
 #[test]
 fn check_numeric_array_repeated_elision() {
+    let mut interner = Interner::new();
     check_parser(
         "[1, 2, ,, 3]",
         vec![ArrayDecl::from(vec![
@@ -76,12 +89,14 @@ fn check_numeric_array_repeated_elision() {
             Const::from(3).into(),
         ])
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks a combined array.
 #[test]
 fn check_combined() {
+    let mut interner = Interner::new();
     check_parser(
         "[1, \"a\", 2]",
         vec![ArrayDecl::from(vec![
@@ -90,12 +105,14 @@ fn check_combined() {
             Const::from(2).into(),
         ])
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks a combined array with an empty string
 #[test]
 fn check_combined_empty_str() {
+    let mut interner = Interner::new();
     check_parser(
         "[1, \"\", 2]",
         vec![ArrayDecl::from(vec![
@@ -104,5 +121,6 @@ fn check_combined_empty_str() {
             Const::from(2).into(),
         ])
         .into()],
+        &mut interner,
     );
 }
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 ad4cf6e2fb6..045d820e241 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
@@ -11,7 +11,7 @@ use crate::{
             AllowYield, Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -47,17 +47,21 @@ where
 {
     type Output = AsyncFunctionExpr;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("AsyncFunctionExpression", "Parsing");
-        cursor.peek_expect_no_lineterminator(0, "async function expression")?;
-        cursor.expect(Keyword::Function, "async function expression")?;
+        cursor.peek_expect_no_lineterminator(0, "async function expression", interner)?;
+        cursor.expect(Keyword::Function, "async function expression", interner)?;
 
-        let tok = cursor.peek(0)?;
+        let tok = cursor.peek(0, interner)?;
 
         let name = if let Some(token) = tok {
             match token.kind() {
                 TokenKind::Punctuator(Punctuator::OpenParen) => None,
-                _ => Some(BindingIdentifier::new(self.allow_yield, true).parse(cursor)?),
+                _ => Some(BindingIdentifier::new(self.allow_yield, true).parse(cursor, interner)?),
             }
         } else {
             return Err(ParseError::AbruptEnd);
@@ -69,7 +73,7 @@ where
             if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
-                    match cursor.peek(0)? {
+                    match cursor.peek(0, interner)? {
                         Some(token) => token.span().end(),
                         None => Position::new(1, 1),
                     },
@@ -78,18 +82,26 @@ where
         }
 
         let params_start_position = cursor
-            .expect(Punctuator::OpenParen, "async function expression")?
+            .expect(Punctuator::OpenParen, "async function expression", interner)?
             .span()
             .end();
 
-        let params = FormalParameters::new(false, true).parse(cursor)?;
+        let params = FormalParameters::new(false, true).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseParen, "async function expression")?;
-        cursor.expect(Punctuator::OpenBlock, "async function expression")?;
+        cursor.expect(
+            Punctuator::CloseParen,
+            "async function expression",
+            interner,
+        )?;
+        cursor.expect(Punctuator::OpenBlock, "async function expression", interner)?;
 
-        let body = FunctionBody::new(false, true).parse(cursor)?;
+        let body = FunctionBody::new(false, true).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseBlock, "async function expression")?;
+        cursor.expect(
+            Punctuator::CloseBlock,
+            "async function expression",
+            interner,
+        )?;
 
         // Early Error: If the source code matching FormalParameters is strict mode code,
         // the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
@@ -119,7 +131,7 @@ where
                     if lexically_declared_names.contains(param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
                             format!("Redeclaration of formal parameter `{}`", param_name).into(),
-                            match cursor.peek(0)? {
+                            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 111d868f4c8..ee4a12825a1 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
@@ -1,14 +1,18 @@
-use crate::syntax::{
-    ast::{
-        node::{AsyncFunctionExpr, Declaration, DeclarationList, Return, StatementList},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{AsyncFunctionExpr, Declaration, DeclarationList, Return, StatementList},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 /// Checks async expression parsing.
 #[test]
 fn check_async_expression() {
+    let mut interner = Interner::new();
     check_parser(
         "const add = async function() {
             return 1;
@@ -30,11 +34,13 @@ fn check_async_expression() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_nested_async_expression() {
+    let mut interner = Interner::new();
     check_parser(
         "const a = async function() {
             const b = async function() {
@@ -77,5 +83,6 @@ fn check_nested_async_expression() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
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 2217cc690c0..23c9fc1214c 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
@@ -20,7 +20,7 @@ use crate::{
             Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -41,20 +41,25 @@ where
     //The below needs to be implemented in ast::node
     type Output = AsyncGeneratorExpr;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("AsyncGeneratorExpression", "Parsing");
 
-        cursor.peek_expect_no_lineterminator(0, "async generator expression")?;
-        cursor.expect(Keyword::Function, "async generator expression")?;
+        cursor.peek_expect_no_lineterminator(0, "async generator expression", interner)?;
+        cursor.expect(Keyword::Function, "async generator expression", interner)?;
         cursor.expect(
             TokenKind::Punctuator(Punctuator::Mul),
             "async generator expression",
+            interner,
         )?;
 
-        let name = if let Some(token) = cursor.peek(0)? {
+        let name = if let Some(token) = cursor.peek(0, interner)? {
             match token.kind() {
                 TokenKind::Punctuator(Punctuator::OpenParen) => None,
-                _ => Some(BindingIdentifier::new(true, true).parse(cursor)?),
+                _ => Some(BindingIdentifier::new(true, true).parse(cursor, interner)?),
             }
         } else {
             return Err(ParseError::AbruptEnd);
@@ -66,7 +71,7 @@ where
             if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
-                    match cursor.peek(0)? {
+                    match cursor.peek(0, interner)? {
                         Some(token) => token.span().end(),
                         None => Position::new(1, 1),
                     },
@@ -75,18 +80,34 @@ where
         }
 
         let params_start_position = cursor
-            .expect(Punctuator::OpenParen, "async generator expression")?
+            .expect(
+                Punctuator::OpenParen,
+                "async generator expression",
+                interner,
+            )?
             .span()
             .end();
 
-        let params = FormalParameters::new(true, true).parse(cursor)?;
+        let params = FormalParameters::new(true, true).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseParen, "async generator expression")?;
-        cursor.expect(Punctuator::OpenBlock, "async generator expression")?;
+        cursor.expect(
+            Punctuator::CloseParen,
+            "async generator expression",
+            interner,
+        )?;
+        cursor.expect(
+            Punctuator::OpenBlock,
+            "async generator expression",
+            interner,
+        )?;
 
-        let body = FunctionBody::new(true, true).parse(cursor)?;
+        let body = FunctionBody::new(true, true).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseBlock, "async generator expression")?;
+        cursor.expect(
+            Punctuator::CloseBlock,
+            "async generator expression",
+            interner,
+        )?;
 
         // Early Error: If the source code matching FormalParameters is strict mode code,
         // the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
@@ -115,7 +136,7 @@ where
                     if lexically_declared_names.contains(param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
                             format!("Redeclaration of formal parameter `{}`", param_name).into(),
-                            match cursor.peek(0)? {
+                            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/test.rs
index e9ef670a353..7c790717a2a 100644
--- a/boa/src/syntax/parser/expression/primary/async_generator_expression/test.rs
+++ b/boa/src/syntax/parser/expression/primary/async_generator_expression/test.rs
@@ -1,15 +1,19 @@
-use crate::syntax::{
-    ast::{
-        node::{AsyncGeneratorExpr, Declaration, DeclarationList, Return, StatementList},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{AsyncGeneratorExpr, Declaration, DeclarationList, Return, StatementList},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 ///checks async generator expression parsing
 
 #[test]
 fn check_async_generator_expr() {
+    let mut interner = Interner::new();
     check_parser(
         "const add = async function*(){
             return 1;
@@ -31,11 +35,13 @@ fn check_async_generator_expr() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_nested_async_generator_expr() {
+    let mut interner = Interner::new();
     check_parser(
         "const a = async function*() {
             const b = async function*() {
@@ -78,5 +84,6 @@ fn check_nested_async_generator_expr() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
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 7958957c410..52b43a9d1ca 100644
--- a/boa/src/syntax/parser/expression/primary/function_expression/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/function_expression/mod.rs
@@ -20,7 +20,7 @@ use crate::{
             Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -42,15 +42,19 @@ where
 {
     type Output = FunctionExpr;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("FunctionExpression", "Parsing");
 
-        let name = if let Some(token) = cursor.peek(0)? {
+        let name = if let Some(token) = cursor.peek(0, interner)? {
             match token.kind() {
                 TokenKind::Identifier(_)
                 | TokenKind::Keyword(Keyword::Yield)
                 | TokenKind::Keyword(Keyword::Await) => {
-                    Some(BindingIdentifier::new(false, false).parse(cursor)?)
+                    Some(BindingIdentifier::new(false, false).parse(cursor, interner)?)
                 }
                 _ => None,
             }
@@ -64,7 +68,7 @@ where
             if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
-                    match cursor.peek(0)? {
+                    match cursor.peek(0, interner)? {
                         Some(token) => token.span().end(),
                         None => Position::new(1, 1),
                     },
@@ -73,18 +77,18 @@ where
         }
 
         let params_start_position = cursor
-            .expect(Punctuator::OpenParen, "function expression")?
+            .expect(Punctuator::OpenParen, "function expression", interner)?
             .span()
             .end();
 
-        let params = FormalParameters::new(false, false).parse(cursor)?;
+        let params = FormalParameters::new(false, false).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseParen, "function expression")?;
-        cursor.expect(Punctuator::OpenBlock, "function expression")?;
+        cursor.expect(Punctuator::CloseParen, "function expression", interner)?;
+        cursor.expect(Punctuator::OpenBlock, "function expression", interner)?;
 
-        let body = FunctionBody::new(false, false).parse(cursor)?;
+        let body = FunctionBody::new(false, false).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseBlock, "function expression")?;
+        cursor.expect(Punctuator::CloseBlock, "function expression", interner)?;
 
         // Early Error: If the source code matching FormalParameters is strict mode code,
         // the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
@@ -114,7 +118,7 @@ where
                     if lexically_declared_names.contains(param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
                             format!("Redeclaration of formal parameter `{}`", param_name).into(),
-                            match cursor.peek(0)? {
+                            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 d7c143227a9..132eb3612a8 100644
--- a/boa/src/syntax/parser/expression/primary/function_expression/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/function_expression/tests.rs
@@ -1,14 +1,18 @@
-use crate::syntax::{
-    ast::{
-        node::{Declaration, DeclarationList, FunctionExpr, Return, StatementList},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{Declaration, DeclarationList, FunctionExpr, Return, StatementList},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 /// Checks async expression parsing.
 #[test]
 fn check_function_expression() {
+    let mut interner = Interner::new();
     check_parser(
         "const add = function() {
             return 1;
@@ -30,11 +34,13 @@ fn check_function_expression() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_nested_function_expression() {
+    let mut interner = Interner::new();
     check_parser(
         "const a = function() {
             const b = function() {
@@ -77,5 +83,6 @@ fn check_nested_function_expression() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
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 1e216658195..ed037728061 100644
--- a/boa/src/syntax/parser/expression/primary/generator_expression/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/generator_expression/mod.rs
@@ -20,7 +20,7 @@ use crate::{
             Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -42,18 +42,23 @@ where
 {
     type Output = GeneratorExpr;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("GeneratorExpression", "Parsing");
 
         cursor.expect(
             TokenKind::Punctuator(Punctuator::Mul),
             "generator expression",
+            interner,
         )?;
 
-        let name = if let Some(token) = cursor.peek(0)? {
+        let name = if let Some(token) = cursor.peek(0, interner)? {
             match token.kind() {
                 TokenKind::Punctuator(Punctuator::OpenParen) => None,
-                _ => Some(BindingIdentifier::new(true, false).parse(cursor)?),
+                _ => Some(BindingIdentifier::new(true, false).parse(cursor, interner)?),
             }
         } else {
             return Err(ParseError::AbruptEnd);
@@ -65,7 +70,7 @@ where
             if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
                 return Err(ParseError::lex(LexError::Syntax(
                     "Unexpected eval or arguments in strict mode".into(),
-                    match cursor.peek(0)? {
+                    match cursor.peek(0, interner)? {
                         Some(token) => token.span().end(),
                         None => Position::new(1, 1),
                     },
@@ -74,18 +79,18 @@ where
         }
 
         let params_start_position = cursor
-            .expect(Punctuator::OpenParen, "generator expression")?
+            .expect(Punctuator::OpenParen, "generator expression", interner)?
             .span()
             .end();
 
-        let params = FormalParameters::new(true, false).parse(cursor)?;
+        let params = FormalParameters::new(true, false).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseParen, "generator expression")?;
-        cursor.expect(Punctuator::OpenBlock, "generator expression")?;
+        cursor.expect(Punctuator::CloseParen, "generator expression", interner)?;
+        cursor.expect(Punctuator::OpenBlock, "generator expression", interner)?;
 
-        let body = FunctionBody::new(true, false).parse(cursor)?;
+        let body = FunctionBody::new(true, false).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseBlock, "generator expression")?;
+        cursor.expect(Punctuator::CloseBlock, "generator expression", interner)?;
 
         // Early Error: If the source code matching FormalParameters is strict mode code,
         // the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
@@ -115,7 +120,7 @@ where
                     if lexically_declared_names.contains(param_name) {
                         return Err(ParseError::lex(LexError::Syntax(
                             format!("Redeclaration of formal parameter `{}`", param_name).into(),
-                            match cursor.peek(0)? {
+                            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 b3a9d3f51c7..4db852dcca3 100644
--- a/boa/src/syntax/parser/expression/primary/generator_expression/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/generator_expression/tests.rs
@@ -1,13 +1,17 @@
-use crate::syntax::{
-    ast::{
-        node::{Declaration, DeclarationList, GeneratorExpr, StatementList, Yield},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{Declaration, DeclarationList, GeneratorExpr, StatementList, Yield},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 #[test]
 fn check_generator_function_expression() {
+    let mut interner = Interner::new();
     check_parser(
         "const gen = function*() {
             yield 1;
@@ -28,11 +32,13 @@ fn check_generator_function_expression() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_generator_function_delegate_yield_expression() {
+    let mut interner = Interner::new();
     check_parser(
         "const gen = function*() {
             yield* 1;
@@ -53,5 +59,6 @@ fn check_generator_function_delegate_yield_expression() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/expression/primary/mod.rs b/boa/src/syntax/parser/expression/primary/mod.rs
index 1e78329e3b7..c5777b3125c 100644
--- a/boa/src/syntax/parser/expression/primary/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/mod.rs
@@ -36,6 +36,7 @@ use crate::{
             ParseError, ParseResult, TokenParser,
         },
     },
+    Interner,
 };
 pub(in crate::syntax::parser) use object_initializer::Initializer;
 
@@ -75,55 +76,59 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("PrimaryExpression", "Parsing");
 
         // TODO: tok currently consumes the token instead of peeking, so the token
         // isn't passed and consumed by parsers according to spec (EX: GeneratorExpression)
-        let tok = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::This) => Ok(Node::This),
             TokenKind::Keyword(Keyword::Function) => {
-                let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+                let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
                 if next_token.kind() == &TokenKind::Punctuator(Punctuator::Mul) {
-                    GeneratorExpression.parse(cursor).map(Node::from)
+                    GeneratorExpression.parse(cursor, interner).map(Node::from)
                 } else {
-                    FunctionExpression.parse(cursor).map(Node::from)
+                    FunctionExpression.parse(cursor, interner).map(Node::from)
                 }
             }
             TokenKind::Keyword(Keyword::Async) => {
-                let mul_peek = cursor.peek(1)?.ok_or(ParseError::AbruptEnd)?;
+                let mul_peek = cursor.peek(1, interner)?.ok_or(ParseError::AbruptEnd)?;
                 if mul_peek.kind() == &TokenKind::Punctuator(Punctuator::Mul) {
-                    AsyncGeneratorExpression.parse(cursor).map(Node::from)
+                    AsyncGeneratorExpression
+                        .parse(cursor, interner)
+                        .map(Node::from)
                 } else {
                     AsyncFunctionExpression::new(self.allow_yield)
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::from)
                 }
             }
             TokenKind::Punctuator(Punctuator::OpenParen) => {
                 cursor.set_goal(InputElement::RegExp);
-                let expr =
-                    Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
-                cursor.expect(Punctuator::CloseParen, "primary expression")?;
+                let expr = Expression::new(true, self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
+                cursor.expect(Punctuator::CloseParen, "primary expression", interner)?;
                 Ok(expr)
             }
             TokenKind::Punctuator(Punctuator::OpenBracket) => {
                 cursor.set_goal(InputElement::RegExp);
                 ArrayLiteral::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::ArrayDecl)
             }
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
                 cursor.set_goal(InputElement::RegExp);
                 Ok(ObjectLiteral::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)?
+                    .parse(cursor, interner)?
                     .into())
             }
             TokenKind::BooleanLiteral(boolean) => Ok(Const::from(*boolean).into()),
             TokenKind::NullLiteral => Ok(Const::Null.into()),
-            TokenKind::Identifier(ident) => Ok(Identifier::from(ident.as_ref()).into()),
+            TokenKind::Identifier(ident) => {
+                Ok(Identifier::from(interner.resolve(*ident).expect("string disappeared")).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(
@@ -156,10 +161,15 @@ where
                 }
                 Ok(Identifier::from("await").into())
             }
-            TokenKind::StringLiteral(s) => Ok(Const::from(s.as_ref()).into()),
-            TokenKind::TemplateNoSubstitution(template_string) => {
-                Ok(Const::from(template_string.to_owned_cooked().map_err(ParseError::lex)?).into())
+            TokenKind::StringLiteral(lit) => {
+                Ok(Const::from(interner.resolve(*lit).expect("string disappeared")).into())
             }
+            TokenKind::TemplateNoSubstitution(template_string) => Ok(Const::from(
+                template_string
+                    .to_owned_cooked(interner)
+                    .map_err(ParseError::lex)?,
+            )
+            .into()),
             TokenKind::NumericLiteral(Numeric::Integer(num)) => Ok(Const::from(*num).into()),
             TokenKind::NumericLiteral(Numeric::Rational(num)) => Ok(Const::from(*num).into()),
             TokenKind::NumericLiteral(Numeric::BigInt(num)) => Ok(Const::from(num.clone()).into()),
@@ -167,25 +177,30 @@ where
                 Ok(Node::from(New::from(Call::new(
                     Identifier::from("RegExp"),
                     vec![
-                        Const::from(body.as_ref()).into(),
+                        Const::from(interner.resolve(*body).expect("string disappeared")).into(),
                         Const::from(flags.to_string()).into(),
                     ],
                 ))))
             }
             TokenKind::Punctuator(Punctuator::Div) => {
-                let tok = cursor.lex_regex(tok.span().start())?;
+                let tok = cursor.lex_regex(tok.span().start(), interner)?;
 
                 if let TokenKind::RegularExpressionLiteral(body, flags) = tok.kind() {
                     Ok(Node::from(New::from(Call::new(
                         Identifier::from("RegExp"),
                         vec![
-                            Const::from(body.as_ref()).into(),
+                            Const::from(interner.resolve(*body).expect("string disappeared"))
+                                .into(),
                             Const::from(flags.to_string()).into(),
                         ],
                     ))))
                 } else {
                     // A regex was expected and nothing else.
-                    Err(ParseError::unexpected(tok, "regular expression literal"))
+                    Err(ParseError::unexpected(
+                        tok.to_string(interner),
+                        tok.span(),
+                        "regular expression literal",
+                    ))
                 }
             }
             TokenKind::TemplateMiddle(template_string) => TemplateLiteral::new(
@@ -193,13 +208,17 @@ where
                 self.allow_await,
                 tok.span().start(),
                 template_string
-                    .to_owned_cooked()
+                    .to_owned_cooked(interner)
                     .map_err(ParseError::lex)?
                     .as_ref(),
             )
-            .parse(cursor)
+            .parse(cursor, interner)
             .map(Node::TemplateLit),
-            _ => Err(ParseError::unexpected(tok.clone(), "primary expression")),
+            _ => Err(ParseError::unexpected(
+                tok.to_string(interner),
+                tok.span(),
+                "primary expression",
+            )),
         }
     }
 }
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 1a89b826361..6a0f889a8e2 100644
--- a/boa/src/syntax/parser/expression/primary/object_initializer/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/object_initializer/mod.rs
@@ -22,7 +22,7 @@ use crate::{
             AllowAwait, AllowIn, AllowYield, Cursor, ParseError, ParseResult, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -60,30 +60,34 @@ where
 {
     type Output = Object;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ObjectLiteral", "Parsing");
         let mut elements = Vec::new();
 
         loop {
-            if cursor.next_if(Punctuator::CloseBlock)?.is_some() {
+            if cursor.next_if(Punctuator::CloseBlock, interner)?.is_some() {
                 break;
             }
 
-            elements
-                .push(PropertyDefinition::new(self.allow_yield, self.allow_await).parse(cursor)?);
+            elements.push(
+                PropertyDefinition::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?,
+            );
 
-            if cursor.next_if(Punctuator::CloseBlock)?.is_some() {
+            if cursor.next_if(Punctuator::CloseBlock, interner)?.is_some() {
                 break;
             }
 
-            if cursor.next_if(Punctuator::Comma)?.is_none() {
-                let next_token = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+            if cursor.next_if(Punctuator::Comma, interner)?.is_none() {
+                let next_token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
                 return Err(ParseError::expected(
-                    vec![
-                        TokenKind::Punctuator(Punctuator::Comma),
-                        TokenKind::Punctuator(Punctuator::CloseBlock),
-                    ],
-                    next_token,
+                    vec![",", "}"],
+                    next_token.to_string(interner),
+                    next_token.span(),
                     "object literal",
                 ));
             }
@@ -125,17 +129,23 @@ where
 {
     type Output = node::PropertyDefinition;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("PropertyDefinition", "Parsing");
 
         // IdentifierReference[?Yield, ?Await]
-        if let Some(next_token) = cursor.peek(1)? {
+        if let Some(next_token) = cursor.peek(1, interner)? {
             match next_token.kind() {
                 TokenKind::Punctuator(Punctuator::CloseBlock)
                 | TokenKind::Punctuator(Punctuator::Comma) => {
-                    let token = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+                    let token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
                     let ident = match token.kind() {
-                        TokenKind::Identifier(ident) => Identifier::from(ident.as_ref()),
+                        TokenKind::Identifier(ident) => {
+                            Identifier::from(interner.resolve(*ident).expect("string disappeared"))
+                        }
                         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(
@@ -172,7 +182,8 @@ where
                         }
                         _ => {
                             return Err(ParseError::unexpected(
-                                token.clone(),
+                                token.to_string(interner),
+                                token.span(),
                                 "expected IdentifierReference",
                             ));
                         }
@@ -187,29 +198,37 @@ where
         }
 
         //  ... AssignmentExpression[+In, ?Yield, ?Await]
-        if cursor.next_if(Punctuator::Spread)?.is_some() {
+        if cursor.next_if(Punctuator::Spread, interner)?.is_some() {
             let node = AssignmentExpression::new(true, self.allow_yield, self.allow_await)
-                .parse(cursor)?;
+                .parse(cursor, interner)?;
             return Ok(node::PropertyDefinition::SpreadObject(node));
         }
 
         //Async [AsyncMethod, AsyncGeneratorMethod] object methods
-        if cursor.next_if(Keyword::Async)?.is_some() {
-            cursor.peek_expect_no_lineterminator(0, "Async object methods")?;
+        if cursor.next_if(Keyword::Async, interner)?.is_some() {
+            cursor.peek_expect_no_lineterminator(0, "Async object methods", interner)?;
 
-            let mul_check = cursor.next_if(Punctuator::Mul)?;
+            let mul_check = cursor.next_if(Punctuator::Mul, interner)?;
             let property_name =
-                PropertyName::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                PropertyName::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
             if mul_check.is_some() {
                 // MethodDefinition[?Yield, ?Await] -> AsyncGeneratorMethod[?Yield, ?Await]
 
                 let params_start_position = cursor
-                    .expect(Punctuator::OpenParen, "async generator method definition")?
+                    .expect(
+                        Punctuator::OpenParen,
+                        "async generator method definition",
+                        interner,
+                    )?
                     .span()
                     .start();
-                let params = FormalParameters::new(true, true).parse(cursor)?;
-                cursor.expect(Punctuator::CloseParen, "async generator method definition")?;
+                let params = FormalParameters::new(true, true).parse(cursor, interner)?;
+                cursor.expect(
+                    Punctuator::CloseParen,
+                    "async generator method definition",
+                    interner,
+                )?;
 
                 // Early Error: UniqueFormalParameters : FormalParameters
                 // NOTE: does not appear to formally be in ECMAScript specs for method
@@ -223,11 +242,13 @@ where
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::OpenBlock),
                     "async generator method definition",
+                    interner,
                 )?;
-                let body = FunctionBody::new(true, true).parse(cursor)?;
+                let body = FunctionBody::new(true, true).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseBlock),
                     "async generator method definition",
+                    interner,
                 )?;
 
                 // Early Error: It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody is true
@@ -250,7 +271,7 @@ where
                                 return Err(ParseError::lex(LexError::Syntax(
                                     format!("Redeclaration of formal parameter `{}`", param_name)
                                         .into(),
-                                    match cursor.peek(0)? {
+                                    match cursor.peek(0, interner)? {
                                         Some(token) => token.span().end(),
                                         None => Position::new(1, 1),
                                     },
@@ -269,11 +290,11 @@ where
                 // MethodDefinition[?Yield, ?Await] -> AsyncMethod[?Yield, ?Await]
 
                 let params_start_position = cursor
-                    .expect(Punctuator::OpenParen, "async method definition")?
+                    .expect(Punctuator::OpenParen, "async method definition", interner)?
                     .span()
                     .start();
-                let params = FormalParameters::new(false, true).parse(cursor)?;
-                cursor.expect(Punctuator::CloseParen, "async method definition")?;
+                let params = FormalParameters::new(false, true).parse(cursor, interner)?;
+                cursor.expect(Punctuator::CloseParen, "async method definition", interner)?;
 
                 // Early Error: UniqueFormalParameters : FormalParameters
                 // NOTE: does not appear to be in ECMAScript specs
@@ -287,11 +308,13 @@ where
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::OpenBlock),
                     "async method definition",
+                    interner,
                 )?;
-                let body = FunctionBody::new(true, true).parse(cursor)?;
+                let body = FunctionBody::new(true, true).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseBlock),
                     "async method definition",
+                    interner,
                 )?;
 
                 // Early Error: It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody is true
@@ -314,7 +337,7 @@ where
                                 return Err(ParseError::lex(LexError::Syntax(
                                     format!("Redeclaration of formal parameter `{}`", param_name)
                                         .into(),
-                                    match cursor.peek(0)? {
+                                    match cursor.peek(0, interner)? {
                                         Some(token) => token.span().end(),
                                         None => Position::new(1, 1),
                                     },
@@ -332,16 +355,24 @@ where
         }
 
         // MethodDefinition[?Yield, ?Await] -> GeneratorMethod[?Yield, ?Await]
-        if cursor.next_if(Punctuator::Mul)?.is_some() {
+        if cursor.next_if(Punctuator::Mul, interner)?.is_some() {
             let property_name =
-                PropertyName::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                PropertyName::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
             let params_start_position = cursor
-                .expect(Punctuator::OpenParen, "generator method definition")?
+                .expect(
+                    Punctuator::OpenParen,
+                    "generator method definition",
+                    interner,
+                )?
                 .span()
                 .start();
-            let params = FormalParameters::new(false, false).parse(cursor)?;
-            cursor.expect(Punctuator::CloseParen, "generator method definition")?;
+            let params = FormalParameters::new(false, false).parse(cursor, interner)?;
+            cursor.expect(
+                Punctuator::CloseParen,
+                "generator method definition",
+                interner,
+            )?;
 
             // Early Error: UniqueFormalParameters : FormalParameters
             // NOTE: does not appear to be in ECMAScript specs for GeneratorMethod
@@ -355,11 +386,13 @@ where
             cursor.expect(
                 TokenKind::Punctuator(Punctuator::OpenBlock),
                 "generator method definition",
+                interner,
             )?;
-            let body = FunctionBody::new(true, false).parse(cursor)?;
+            let body = FunctionBody::new(true, false).parse(cursor, interner)?;
             cursor.expect(
                 TokenKind::Punctuator(Punctuator::CloseBlock),
                 "generator method definition",
+                interner,
             )?;
 
             // Early Error: It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody is true
@@ -382,7 +415,7 @@ where
                             return Err(ParseError::lex(LexError::Syntax(
                                 format!("Redeclaration of formal parameter `{}`", param_name)
                                     .into(),
-                                match cursor.peek(0)? {
+                                match cursor.peek(0, interner)? {
                                     Some(token) => token.span().end(),
                                     None => Position::new(1, 1),
                                 },
@@ -400,41 +433,48 @@ where
         }
 
         let mut property_name =
-            PropertyName::new(self.allow_yield, self.allow_await).parse(cursor)?;
+            PropertyName::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
         //  PropertyName[?Yield, ?Await] : AssignmentExpression[+In, ?Yield, ?Await]
-        if cursor.next_if(Punctuator::Colon)?.is_some() {
+        if cursor.next_if(Punctuator::Colon, interner)?.is_some() {
             let value = AssignmentExpression::new(true, self.allow_yield, self.allow_await)
-                .parse(cursor)?;
+                .parse(cursor, interner)?;
             return Ok(node::PropertyDefinition::property(property_name, value));
         }
 
-        let ordinary_method = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind()
+        let ordinary_method = cursor
+            .peek(0, interner)?
+            .ok_or(ParseError::AbruptEnd)?
+            .kind()
             == &TokenKind::Punctuator(Punctuator::OpenParen);
 
         match property_name {
             // MethodDefinition[?Yield, ?Await] -> get ClassElementName[?Yield, ?Await] ( ) { FunctionBody[~Yield, ~Await] }
             node::PropertyName::Literal(str) if str.as_ref() == "get" && !ordinary_method => {
-                property_name =
-                    PropertyName::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                property_name = PropertyName::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
 
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::OpenParen),
                     "get method definition",
+                    interner,
                 )?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseParen),
                     "get method definition",
+                    interner,
                 )?;
 
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::OpenBlock),
                     "get method definition",
+                    interner,
                 )?;
-                let body = FunctionBody::new(false, false).parse(cursor)?;
+                let body = FunctionBody::new(false, false).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseBlock),
                     "get method definition",
+                    interner,
                 )?;
 
                 Ok(node::PropertyDefinition::method_definition(
@@ -445,20 +485,22 @@ where
             }
             // MethodDefinition[?Yield, ?Await] -> set ClassElementName[?Yield, ?Await] ( PropertySetParameterList ) { FunctionBody[~Yield, ~Await] }
             node::PropertyName::Literal(str) if str.as_ref() == "set" && !ordinary_method => {
-                property_name =
-                    PropertyName::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                property_name = PropertyName::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
 
                 let params_start_position = cursor
                     .expect(
                         TokenKind::Punctuator(Punctuator::OpenParen),
                         "set method definition",
+                        interner,
                     )?
                     .span()
                     .end();
-                let params = FormalParameters::new(false, false).parse(cursor)?;
+                let params = FormalParameters::new(false, false).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseParen),
                     "set method definition",
+                    interner,
                 )?;
                 if params.parameters.len() != 1 {
                     return Err(ParseError::general(
@@ -470,11 +512,13 @@ where
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::OpenBlock),
                     "set method definition",
+                    interner,
                 )?;
-                let body = FunctionBody::new(false, false).parse(cursor)?;
+                let body = FunctionBody::new(false, false).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseBlock),
                     "set method definition",
+                    interner,
                 )?;
 
                 // Early Error: It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody is true
@@ -499,13 +543,15 @@ where
                     .expect(
                         TokenKind::Punctuator(Punctuator::OpenParen),
                         "method definition",
+                        interner,
                     )?
                     .span()
                     .end();
-                let params = FormalParameters::new(false, false).parse(cursor)?;
+                let params = FormalParameters::new(false, false).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseParen),
                     "method definition",
+                    interner,
                 )?;
 
                 // Early Error: UniqueFormalParameters : FormalParameters
@@ -519,11 +565,13 @@ where
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::OpenBlock),
                     "method definition",
+                    interner,
                 )?;
-                let body = FunctionBody::new(false, false).parse(cursor)?;
+                let body = FunctionBody::new(false, false).parse(cursor, interner)?;
                 cursor.expect(
                     TokenKind::Punctuator(Punctuator::CloseBlock),
                     "method definition",
+                    interner,
                 )?;
 
                 // Early Error: It is a Syntax Error if FunctionBodyContainsUseStrict of FunctionBody is true
@@ -578,22 +626,26 @@ where
 {
     type Output = node::PropertyName;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("PropertyName", "Parsing");
 
         // ComputedPropertyName[?Yield, ?Await] -> [ AssignmentExpression[+In, ?Yield, ?Await] ]
-        if cursor.next_if(Punctuator::OpenBracket)?.is_some() {
+        if cursor.next_if(Punctuator::OpenBracket, interner)?.is_some() {
             let node = AssignmentExpression::new(false, self.allow_yield, self.allow_await)
-                .parse(cursor)?;
-            cursor.expect(Punctuator::CloseBracket, "expected token ']'")?;
+                .parse(cursor, interner)?;
+            cursor.expect(Punctuator::CloseBracket, "expected token ']'", interner)?;
             return Ok(node.into());
         }
 
         // LiteralPropertyName
         Ok(cursor
-            .next()?
+            .next(interner)?
             .ok_or(ParseError::AbruptEnd)?
-            .to_string()
+            .to_string(interner)
             .into())
     }
 }
@@ -637,10 +689,11 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("Initializer", "Parsing");
 
-        cursor.expect(Punctuator::Assign, "initializer")?;
-        AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await).parse(cursor)
+        cursor.expect(Punctuator::Assign, "initializer", interner)?;
+        AssignmentExpression::new(self.allow_in, self.allow_yield, self.allow_await)
+            .parse(cursor, interner)
     }
 }
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 87cc27b5643..c2ea593d224 100644
--- a/boa/src/syntax/parser/expression/primary/object_initializer/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/object_initializer/tests.rs
@@ -1,12 +1,15 @@
-use crate::syntax::{
-    ast::{
-        node::{
-            Declaration, DeclarationList, FormalParameter, FunctionExpr, Identifier,
-            MethodDefinitionKind, Object, PropertyDefinition,
+use crate::{
+    syntax::{
+        ast::{
+            node::{
+                Declaration, DeclarationList, FormalParameter, FunctionExpr, Identifier,
+                MethodDefinitionKind, Object, PropertyDefinition,
+            },
+            Const,
         },
-        Const,
+        parser::tests::{check_invalid, check_parser},
     },
-    parser::tests::{check_invalid, check_parser},
+    Interner,
 };
 
 /// Checks object literal parsing.
@@ -17,6 +20,7 @@ fn check_object_literal() {
         PropertyDefinition::property("b", Const::from(false)),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -31,6 +35,7 @@ fn check_object_literal() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -46,6 +51,7 @@ fn check_object_short_function() {
         ),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -60,6 +66,7 @@ fn check_object_short_function() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -82,6 +89,7 @@ fn check_object_short_function_arguments() {
         ),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -96,6 +104,7 @@ fn check_object_short_function_arguments() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -110,6 +119,7 @@ fn check_object_getter() {
         ),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -124,6 +134,7 @@ fn check_object_getter() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -145,6 +156,7 @@ fn check_object_setter() {
         ),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             a: true,
@@ -159,6 +171,7 @@ fn check_object_setter() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -170,6 +183,7 @@ fn check_object_short_function_get() {
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             get() {}
@@ -183,6 +197,7 @@ fn check_object_short_function_get() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -194,6 +209,7 @@ fn check_object_short_function_set() {
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             set() {}
@@ -207,6 +223,7 @@ fn check_object_short_function_set() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -214,6 +231,7 @@ fn check_object_short_function_set() {
 fn check_object_shorthand_property_names() {
     let object_properties = vec![PropertyDefinition::property("a", Identifier::from("a"))];
 
+    let mut interner = Interner::new();
     check_parser(
         "const a = true;
             const x = { a };
@@ -236,6 +254,7 @@ fn check_object_shorthand_property_names() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
@@ -246,6 +265,7 @@ fn check_object_shorthand_multiple_properties() {
         PropertyDefinition::property("b", Identifier::from("b")),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const a = true;
             const b = false;
@@ -277,6 +297,7 @@ fn check_object_shorthand_multiple_properties() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
@@ -287,6 +308,7 @@ fn check_object_spread() {
         PropertyDefinition::spread_object(Identifier::from("b")),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = { a: 1, ...b };
         ",
@@ -298,6 +320,7 @@ fn check_object_spread() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -309,6 +332,7 @@ fn check_async_method() {
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             async dive() {}
@@ -322,6 +346,7 @@ fn check_async_method() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -333,6 +358,7 @@ fn check_async_generator_method() {
         FunctionExpr::new(None, vec![], vec![]),
     )];
 
+    let mut interner = Interner::new();
     check_parser(
         "const x = {
             async* vroom() {}
@@ -346,6 +372,7 @@ fn check_async_generator_method() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
diff --git a/boa/src/syntax/parser/expression/primary/template/mod.rs b/boa/src/syntax/parser/expression/primary/template/mod.rs
index 77721bbacd7..498c7db603a 100644
--- a/boa/src/syntax/parser/expression/primary/template/mod.rs
+++ b/boa/src/syntax/parser/expression/primary/template/mod.rs
@@ -18,6 +18,7 @@ use crate::{
         parser::expression::Expression,
         parser::{AllowAwait, AllowYield, ParseError, TokenParser},
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -59,36 +60,48 @@ where
 {
     type Output = TemplateLit;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("TemplateLiteral", "Parsing");
 
         let mut elements = vec![
             TemplateElement::String(self.first.into_boxed_str()),
             TemplateElement::Expr(
-                Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?,
+                Expression::new(true, self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?,
             ),
         ];
         cursor.expect(
             TokenKind::Punctuator(Punctuator::CloseBlock),
             "template literal",
+            interner,
         )?;
 
         loop {
-            match cursor.lex_template(self.start)?.kind() {
+            match cursor.lex_template(self.start, interner)?.kind() {
                 TokenKind::TemplateMiddle(template_string) => {
-                    let cooked = template_string.to_owned_cooked().map_err(ParseError::lex)?;
+                    let cooked = template_string
+                        .to_owned_cooked(interner)
+                        .map_err(ParseError::lex)?;
 
                     elements.push(TemplateElement::String(cooked));
                     elements.push(TemplateElement::Expr(
-                        Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?,
+                        Expression::new(true, self.allow_yield, self.allow_await)
+                            .parse(cursor, interner)?,
                     ));
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::CloseBlock),
                         "template literal",
+                        interner,
                     )?;
                 }
                 TokenKind::TemplateNoSubstitution(template_string) => {
-                    let cooked = template_string.to_owned_cooked().map_err(ParseError::lex)?;
+                    let cooked = template_string
+                        .to_owned_cooked(interner)
+                        .map_err(ParseError::lex)?;
 
                     elements.push(TemplateElement::String(cooked));
                     return Ok(TemplateLit::new(elements));
diff --git a/boa/src/syntax/parser/expression/primary/tests.rs b/boa/src/syntax/parser/expression/primary/tests.rs
index e13a4d84011..f7e9020be25 100644
--- a/boa/src/syntax/parser/expression/primary/tests.rs
+++ b/boa/src/syntax/parser/expression/primary/tests.rs
@@ -1,10 +1,19 @@
-use crate::syntax::{ast::Const, parser::tests::check_parser};
+use crate::{
+    syntax::{ast::Const, parser::tests::check_parser},
+    Interner,
+};
 
 #[test]
 fn check_string() {
     // Check empty string
-    check_parser("\"\"", vec![Const::from("").into()]);
+    let mut interner = Interner::new();
+    check_parser("\"\"", vec![Const::from("").into()], &mut interner);
 
     // Check non-empty string
-    check_parser("\"hello\"", vec![Const::from("hello").into()]);
+    let mut interner = Interner::new();
+    check_parser(
+        "\"hello\"",
+        vec![Const::from("hello").into()],
+        &mut interner,
+    );
 }
diff --git a/boa/src/syntax/parser/expression/tests.rs b/boa/src/syntax/parser/expression/tests.rs
index 1f1a882b1c7..2b7bf5783fb 100644
--- a/boa/src/syntax/parser/expression/tests.rs
+++ b/boa/src/syntax/parser/expression/tests.rs
@@ -1,68 +1,107 @@
-use crate::syntax::{
-    ast::op::{AssignOp, BitOp, CompOp, LogOp, NumOp},
-    ast::{
-        node::{BinOp, Identifier},
-        Const,
+use crate::{
+    syntax::{
+        ast::op::{AssignOp, BitOp, CompOp, LogOp, NumOp},
+        ast::{
+            node::{BinOp, Identifier},
+            Const,
+        },
+        parser::tests::{check_invalid, check_parser},
     },
-    parser::tests::{check_invalid, check_parser},
+    Interner,
 };
 
 /// Checks numeric operations
 #[test]
 fn check_numeric_operations() {
+    let mut interner = Interner::new();
     check_parser(
         "a + b",
         vec![BinOp::new(NumOp::Add, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a+1",
         vec![BinOp::new(NumOp::Add, Identifier::from("a"), Const::from(1)).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a - b",
         vec![BinOp::new(NumOp::Sub, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a-1",
         vec![BinOp::new(NumOp::Sub, Identifier::from("a"), Const::from(1)).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a / b",
         vec![BinOp::new(NumOp::Div, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a/2",
         vec![BinOp::new(NumOp::Div, Identifier::from("a"), Const::from(2)).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a * b",
         vec![BinOp::new(NumOp::Mul, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a*2",
         vec![BinOp::new(NumOp::Mul, Identifier::from("a"), Const::from(2)).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a ** b",
         vec![BinOp::new(NumOp::Exp, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a**2",
         vec![BinOp::new(NumOp::Exp, Identifier::from("a"), Const::from(2)).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a % b",
         vec![BinOp::new(NumOp::Mod, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a%2",
         vec![BinOp::new(NumOp::Mod, Identifier::from("a"), Const::from(2)).into()],
+        &mut interner,
     );
 }
 
 // Checks complex numeric operations.
 #[test]
 fn check_complex_numeric_operations() {
+    let mut interner = Interner::new();
     check_parser(
         "a + d*(b-3)+1",
         vec![BinOp::new(
@@ -79,109 +118,172 @@ fn check_complex_numeric_operations() {
             Const::from(1),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks bitwise operations.
 #[test]
 fn check_bitwise_operations() {
+    let mut interner = Interner::new();
     check_parser(
         "a & b",
         vec![BinOp::new(BitOp::And, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a&b",
         vec![BinOp::new(BitOp::And, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "a | b",
         vec![BinOp::new(BitOp::Or, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a|b",
         vec![BinOp::new(BitOp::Or, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "a ^ b",
         vec![BinOp::new(BitOp::Xor, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a^b",
         vec![BinOp::new(BitOp::Xor, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "a << b",
         vec![BinOp::new(BitOp::Shl, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a<<b",
         vec![BinOp::new(BitOp::Shl, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "a >> b",
         vec![BinOp::new(BitOp::Shr, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a>>b",
         vec![BinOp::new(BitOp::Shr, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
 }
 
 /// Checks assignment operations.
 #[test]
 fn check_assign_operations() {
+    let mut interner = Interner::new();
     check_parser(
         "a += b",
         vec![BinOp::new(AssignOp::Add, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a -= b",
         vec![BinOp::new(AssignOp::Sub, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a *= b",
         vec![BinOp::new(AssignOp::Mul, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a **= b",
         vec![BinOp::new(AssignOp::Exp, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a /= b",
         vec![BinOp::new(AssignOp::Div, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a %= b",
         vec![BinOp::new(AssignOp::Mod, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a &= b",
         vec![BinOp::new(AssignOp::And, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a |= b",
         vec![BinOp::new(AssignOp::Or, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a ^= b",
         vec![BinOp::new(AssignOp::Xor, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a <<= b",
         vec![BinOp::new(AssignOp::Shl, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a >>= b",
         vec![BinOp::new(AssignOp::Shr, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a >>>= b",
         vec![BinOp::new(AssignOp::Ushr, Identifier::from("a"), Identifier::from("b")).into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a %= 10 / 2",
         vec![BinOp::new(
@@ -190,7 +292,10 @@ fn check_assign_operations() {
             BinOp::new(NumOp::Div, Const::from(10), Const::from(2)),
         )
         .into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a ??= b",
         vec![BinOp::new(
@@ -199,11 +304,13 @@ fn check_assign_operations() {
             Identifier::from("b"),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_relational_operations() {
+    let mut interner = Interner::new();
     check_parser(
         "a < b",
         vec![BinOp::new(
@@ -212,7 +319,10 @@ fn check_relational_operations() {
             Identifier::from("b"),
         )
         .into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a > b",
         vec![BinOp::new(
@@ -221,7 +331,10 @@ fn check_relational_operations() {
             Identifier::from("b"),
         )
         .into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a <= b",
         vec![BinOp::new(
@@ -230,7 +343,10 @@ fn check_relational_operations() {
             Identifier::from("b"),
         )
         .into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "a >= b",
         vec![BinOp::new(
@@ -239,15 +355,20 @@ fn check_relational_operations() {
             Identifier::from("b"),
         )
         .into()],
+        &mut interner,
     );
+
+    let mut interner = Interner::new();
     check_parser(
         "p in o",
         vec![BinOp::new(CompOp::In, Identifier::from("p"), Identifier::from("o")).into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_logical_expressions() {
+    let mut interner = Interner::new();
     check_parser(
         "a && b || c && d || e",
         vec![BinOp::new(
@@ -260,8 +381,10 @@ fn check_logical_expressions() {
             ),
         )
         .into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "a ?? b ?? c",
         vec![BinOp::new(
@@ -274,6 +397,7 @@ fn check_logical_expressions() {
             Identifier::from("c"),
         )
         .into()],
+        &mut interner,
     );
 
     check_invalid("a ?? b && c");
diff --git a/boa/src/syntax/parser/expression/unary.rs b/boa/src/syntax/parser/expression/unary.rs
index ac8da4227e6..4255e620721 100644
--- a/boa/src/syntax/parser/expression/unary.rs
+++ b/boa/src/syntax/parser/expression/unary.rs
@@ -21,6 +21,7 @@ use crate::{
             ParseResult, TokenParser,
         },
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -58,15 +59,15 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("UnaryExpression", "Parsing");
 
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
         let token_start = tok.span().start();
         match tok.kind() {
             TokenKind::Keyword(Keyword::Delete) => {
-                cursor.next()?.expect("Delete keyword vanished"); // Consume the token.
-                let val = self.parse(cursor)?;
+                cursor.next(interner)?.expect("Delete keyword vanished"); // Consume the token.
+                let val = self.parse(cursor, interner)?;
 
                 if cursor.strict_mode() {
                     if let Node::Identifier(_) = val {
@@ -80,30 +81,30 @@ where
                 Ok(node::UnaryOp::new(UnaryOp::Delete, val).into())
             }
             TokenKind::Keyword(Keyword::Void) => {
-                cursor.next()?.expect("Void keyword vanished"); // Consume the token.
-                Ok(node::UnaryOp::new(UnaryOp::Void, self.parse(cursor)?).into())
+                cursor.next(interner)?.expect("Void keyword vanished"); // Consume the token.
+                Ok(node::UnaryOp::new(UnaryOp::Void, self.parse(cursor, interner)?).into())
             }
             TokenKind::Keyword(Keyword::TypeOf) => {
-                cursor.next()?.expect("TypeOf keyword vanished"); // Consume the token.
-                Ok(node::UnaryOp::new(UnaryOp::TypeOf, self.parse(cursor)?).into())
+                cursor.next(interner)?.expect("TypeOf keyword vanished"); // Consume the token.
+                Ok(node::UnaryOp::new(UnaryOp::TypeOf, self.parse(cursor, interner)?).into())
             }
             TokenKind::Punctuator(Punctuator::Add) => {
-                cursor.next()?.expect("+ token vanished"); // Consume the token.
-                Ok(node::UnaryOp::new(UnaryOp::Plus, self.parse(cursor)?).into())
+                cursor.next(interner)?.expect("+ token vanished"); // Consume the token.
+                Ok(node::UnaryOp::new(UnaryOp::Plus, self.parse(cursor, interner)?).into())
             }
             TokenKind::Punctuator(Punctuator::Sub) => {
-                cursor.next()?.expect("- token vanished"); // Consume the token.
-                Ok(node::UnaryOp::new(UnaryOp::Minus, self.parse(cursor)?).into())
+                cursor.next(interner)?.expect("- token vanished"); // Consume the token.
+                Ok(node::UnaryOp::new(UnaryOp::Minus, self.parse(cursor, interner)?).into())
             }
             TokenKind::Punctuator(Punctuator::Neg) => {
-                cursor.next()?.expect("~ token vanished"); // Consume the token.
-                Ok(node::UnaryOp::new(UnaryOp::Tilde, self.parse(cursor)?).into())
+                cursor.next(interner)?.expect("~ token vanished"); // Consume the token.
+                Ok(node::UnaryOp::new(UnaryOp::Tilde, self.parse(cursor, interner)?).into())
             }
             TokenKind::Punctuator(Punctuator::Not) => {
-                cursor.next()?.expect("! token vanished"); // Consume the token.
-                Ok(node::UnaryOp::new(UnaryOp::Not, self.parse(cursor)?).into())
+                cursor.next(interner)?.expect("! token vanished"); // Consume the token.
+                Ok(node::UnaryOp::new(UnaryOp::Not, self.parse(cursor, interner)?).into())
             }
-            _ => UpdateExpression::new(self.allow_yield, self.allow_await).parse(cursor),
+            _ => UpdateExpression::new(self.allow_yield, self.allow_await).parse(cursor, interner),
         }
     }
 }
diff --git a/boa/src/syntax/parser/expression/update.rs b/boa/src/syntax/parser/expression/update.rs
index 876296e84ea..0d0111b2020 100644
--- a/boa/src/syntax/parser/expression/update.rs
+++ b/boa/src/syntax/parser/expression/update.rs
@@ -16,6 +16,7 @@ use crate::{
             ParseResult, TokenParser,
         },
     },
+    Interner,
 };
 
 use std::io::Read;
@@ -52,37 +53,46 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("UpdateExpression", "Parsing");
 
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
         match tok.kind() {
             TokenKind::Punctuator(Punctuator::Inc) => {
-                cursor.next()?.expect("Punctuator::Inc token disappeared");
+                cursor
+                    .next(interner)?
+                    .expect("Punctuator::Inc token disappeared");
                 return Ok(node::UnaryOp::new(
                     UnaryOp::IncrementPre,
-                    UnaryExpression::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                    UnaryExpression::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?,
                 )
                 .into());
             }
             TokenKind::Punctuator(Punctuator::Dec) => {
-                cursor.next()?.expect("Punctuator::Dec token disappeared");
+                cursor
+                    .next(interner)?
+                    .expect("Punctuator::Dec token disappeared");
                 return Ok(node::UnaryOp::new(
                     UnaryOp::DecrementPre,
-                    UnaryExpression::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                    UnaryExpression::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?,
                 )
                 .into());
             }
             _ => {}
         }
 
-        let lhs = LeftHandSideExpression::new(self.allow_yield, self.allow_await).parse(cursor)?;
+        let lhs = LeftHandSideExpression::new(self.allow_yield, self.allow_await)
+            .parse(cursor, interner)?;
         let strict = cursor.strict_mode();
-        if let Some(tok) = cursor.peek(0)? {
+        if let Some(tok) = cursor.peek(0, interner)? {
             let token_start = tok.span().start();
             match tok.kind() {
                 TokenKind::Punctuator(Punctuator::Inc) => {
-                    cursor.next()?.expect("Punctuator::Inc token disappeared");
+                    cursor
+                        .next(interner)?
+                        .expect("Punctuator::Inc token disappeared");
                     // https://tc39.es/ecma262/#sec-update-expressions-static-semantics-early-errors
                     let ok = match &lhs {
                         Node::Identifier(_) if !strict => true,
@@ -105,7 +115,9 @@ where
                     return Ok(node::UnaryOp::new(UnaryOp::IncrementPost, lhs).into());
                 }
                 TokenKind::Punctuator(Punctuator::Dec) => {
-                    cursor.next()?.expect("Punctuator::Dec token disappeared");
+                    cursor
+                        .next(interner)?
+                        .expect("Punctuator::Dec token disappeared");
                     // https://tc39.es/ecma262/#sec-update-expressions-static-semantics-early-errors
                     let ok = match &lhs {
                         Node::Identifier(_) if !strict => true,
diff --git a/boa/src/syntax/parser/function/mod.rs b/boa/src/syntax/parser/function/mod.rs
index fe89bed82f5..61840bd712f 100644
--- a/boa/src/syntax/parser/function/mod.rs
+++ b/boa/src/syntax/parser/function/mod.rs
@@ -22,7 +22,7 @@ use crate::{
             AllowAwait, AllowYield, Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use rustc_hash::FxHashSet;
 use std::io::Read;
@@ -68,7 +68,11 @@ where
 {
     type Output = FormalParameterList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("FormalParameters", "Parsing");
         cursor.set_goal(InputElement::RegExp);
 
@@ -76,7 +80,7 @@ where
         let mut is_simple = true;
         let mut has_duplicates = false;
 
-        let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
         if next_token.kind() == &TokenKind::Punctuator(Punctuator::CloseParen) {
             return Ok(FormalParameterList {
                 parameters: params.into_boxed_slice(),
@@ -91,12 +95,14 @@ where
         loop {
             let mut rest_param = false;
 
-            let next_param = match cursor.peek(0)? {
+            let next_param = match cursor.peek(0, interner)? {
                 Some(tok) if tok.kind() == &TokenKind::Punctuator(Punctuator::Spread) => {
                     rest_param = true;
-                    FunctionRestParameter::new(self.allow_yield, self.allow_await).parse(cursor)?
+                    FunctionRestParameter::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?
                 }
-                _ => FormalParameter::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                _ => FormalParameter::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?,
             };
 
             if next_param.is_rest_param() && next_param.init().is_some() {
@@ -120,20 +126,25 @@ where
             }
             params.push(next_param);
 
-            if cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind()
+            if cursor
+                .peek(0, interner)?
+                .ok_or(ParseError::AbruptEnd)?
+                .kind()
                 == &TokenKind::Punctuator(Punctuator::CloseParen)
             {
                 break;
             }
 
             if rest_param {
+                let next = cursor.next(interner)?.expect("peeked token disappeared");
                 return Err(ParseError::unexpected(
-                    cursor.next()?.expect("peeked token disappeared"),
+                    next.to_string(interner),
+                    next.span(),
                     "rest parameter must be the last formal parameter",
                 ));
             }
 
-            cursor.expect(Punctuator::Comma, "parameter list")?;
+            cursor.expect(Punctuator::Comma, "parameter list", interner)?;
         }
 
         // Early Error: It is a Syntax Error if IsSimpleParameterList of FormalParameterList is false
@@ -197,25 +208,30 @@ where
 {
     type Output = node::FormalParameter;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("BindingRestElement", "Parsing");
-        cursor.expect(Punctuator::Spread, "rest parameter")?;
+        cursor.expect(Punctuator::Spread, "rest parameter", interner)?;
 
-        if let Some(t) = cursor.peek(0)? {
+        if let Some(t) = cursor.peek(0, interner)? {
             let declaration = match *t.kind() {
                 TokenKind::Punctuator(Punctuator::OpenBlock) => {
                     let param = ObjectBindingPattern::new(true, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
 
                     let init = cursor
-                        .peek(0)?
+                        .peek(0, interner)?
                         .cloned()
                         .filter(|t| {
                             // Check that this is an initializer before attempting parse.
                             *t.kind() == TokenKind::Punctuator(Punctuator::Assign)
                         })
                         .map(|_| {
-                            Initializer::new(true, self.allow_yield, self.allow_await).parse(cursor)
+                            Initializer::new(true, self.allow_yield, self.allow_await)
+                                .parse(cursor, interner)
                         })
                         .transpose()?;
                     Declaration::new_with_object_pattern(param, init)
@@ -224,23 +240,24 @@ where
                 TokenKind::Punctuator(Punctuator::OpenBracket) => {
                     Declaration::new_with_array_pattern(
                         ArrayBindingPattern::new(true, self.allow_yield, self.allow_await)
-                            .parse(cursor)?,
+                            .parse(cursor, interner)?,
                         None,
                     )
                 }
 
                 _ => {
-                    let params =
-                        BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                    let params = BindingIdentifier::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
                     let init = cursor
-                        .peek(0)?
+                        .peek(0, interner)?
                         .cloned()
                         .filter(|t| {
                             // Check that this is an initializer before attempting parse.
                             *t.kind() == TokenKind::Punctuator(Punctuator::Assign)
                         })
                         .map(|_| {
-                            Initializer::new(true, self.allow_yield, self.allow_await).parse(cursor)
+                            Initializer::new(true, self.allow_yield, self.allow_await)
+                                .parse(cursor, interner)
                         })
                         .transpose()?;
 
@@ -291,24 +308,29 @@ where
 {
     type Output = node::FormalParameter;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("FormalParameter", "Parsing");
 
-        if let Some(t) = cursor.peek(0)? {
+        if let Some(t) = cursor.peek(0, interner)? {
             let declaration = match *t.kind() {
                 TokenKind::Punctuator(Punctuator::OpenBlock) => {
                     let param = ObjectBindingPattern::new(true, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
 
                     let init = cursor
-                        .peek(0)?
+                        .peek(0, interner)?
                         .cloned()
                         .filter(|t| {
                             // Check that this is an initializer before attempting parse.
                             *t.kind() == TokenKind::Punctuator(Punctuator::Assign)
                         })
                         .map(|_| {
-                            Initializer::new(true, self.allow_yield, self.allow_await).parse(cursor)
+                            Initializer::new(true, self.allow_yield, self.allow_await)
+                                .parse(cursor, interner)
                         })
                         .transpose()?;
 
@@ -318,23 +340,24 @@ where
                 TokenKind::Punctuator(Punctuator::OpenBracket) => {
                     Declaration::new_with_array_pattern(
                         ArrayBindingPattern::new(true, self.allow_yield, self.allow_await)
-                            .parse(cursor)?,
+                            .parse(cursor, interner)?,
                         None,
                     )
                 }
 
                 _ => {
-                    let params =
-                        BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                    let params = BindingIdentifier::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
                     let init = cursor
-                        .peek(0)?
+                        .peek(0, interner)?
                         .cloned()
                         .filter(|t| {
                             // Check that this is an initializer before attempting parse.
                             *t.kind() == TokenKind::Punctuator(Punctuator::Assign)
                         })
                         .map(|_| {
-                            Initializer::new(true, self.allow_yield, self.allow_await).parse(cursor)
+                            Initializer::new(true, self.allow_yield, self.allow_await)
+                                .parse(cursor, interner)
                         })
                         .transpose()?;
 
@@ -394,18 +417,24 @@ where
 {
     type Output = node::StatementList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("FunctionStatementList", "Parsing");
 
         let global_strict_mode = cursor.strict_mode();
         let mut strict = false;
 
-        if let Some(tk) = cursor.peek(0)? {
+        if let Some(tk) = cursor.peek(0, interner)? {
             match tk.kind() {
                 TokenKind::Punctuator(Punctuator::CloseBlock) => {
                     return Ok(Vec::new().into());
                 }
-                TokenKind::StringLiteral(string) if string.as_ref() == "use strict" => {
+                TokenKind::StringLiteral(string)
+                    if interner.resolve(*string).expect("string disappeared") == "use strict" =>
+                {
                     cursor.set_strict_mode(true);
                     strict = true;
                 }
@@ -420,7 +449,7 @@ where
             true,
             &FUNCTION_BREAK_TOKENS,
         )
-        .parse(cursor);
+        .parse(cursor, interner);
 
         // Reset strict mode back to the global scope.
         cursor.set_strict_mode(global_strict_mode);
diff --git a/boa/src/syntax/parser/function/tests.rs b/boa/src/syntax/parser/function/tests.rs
index 8f499ea8f4e..616e39cd70f 100644
--- a/boa/src/syntax/parser/function/tests.rs
+++ b/boa/src/syntax/parser/function/tests.rs
@@ -1,15 +1,19 @@
-use crate::syntax::{
-    ast::node::{
-        ArrowFunctionDecl, BinOp, Declaration, DeclarationList, FormalParameter, FunctionDecl,
-        Identifier, Node, Return,
+use crate::{
+    syntax::{
+        ast::node::{
+            ArrowFunctionDecl, BinOp, Declaration, DeclarationList, FormalParameter, FunctionDecl,
+            Identifier, Node, Return,
+        },
+        ast::op::NumOp,
+        parser::{tests::check_parser, Parser},
     },
-    ast::op::NumOp,
-    parser::{tests::check_parser, Parser},
+    Interner,
 };
 
 /// Checks basic function declaration parsing.
 #[test]
 fn check_basic() {
+    let mut interner = Interner::new();
     check_parser(
         "function foo(a) { return a; }",
         vec![FunctionDecl::new(
@@ -21,12 +25,14 @@ fn check_basic() {
             vec![Return::new(Identifier::from("a"), None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks if duplicate parameter names are allowed with strict mode off.
 #[test]
 fn check_duplicates_strict_off() {
+    let mut interner = Interner::new();
     check_parser(
         "function foo(a, a) { return a; }",
         vec![FunctionDecl::new(
@@ -38,6 +44,7 @@ fn check_duplicates_strict_off() {
             vec![Return::new(Identifier::from("a"), None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -45,8 +52,9 @@ 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 res = Parser::new(js.as_bytes(), false).parse_all();
+    let res = Parser::new(js.as_bytes(), false).parse_all(&mut interner);
     dbg!(&res);
     assert!(res.is_err());
 }
@@ -54,6 +62,7 @@ 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();
     check_parser(
         "function foo(a) { return a }",
         vec![FunctionDecl::new(
@@ -65,12 +74,14 @@ fn check_basic_semicolon_insertion() {
             vec![Return::new(Identifier::from("a"), None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks functions with empty returns.
 #[test]
 fn check_empty_return() {
+    let mut interner = Interner::new();
     check_parser(
         "function foo(a) { return; }",
         vec![FunctionDecl::new(
@@ -82,12 +93,14 @@ fn check_empty_return() {
             vec![Return::new::<Node, Option<Node>, Option<_>>(None, None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks functions with empty returns without semicolon
 #[test]
 fn check_empty_return_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "function foo(a) { return }",
         vec![FunctionDecl::new(
@@ -99,12 +112,14 @@ fn check_empty_return_semicolon_insertion() {
             vec![Return::new::<Node, Option<Node>, Option<_>>(None, None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks rest operator parsing.
 #[test]
 fn check_rest_operator() {
+    let mut interner = Interner::new();
     check_parser(
         "function foo(a, ...b) {}",
         vec![FunctionDecl::new(
@@ -116,12 +131,14 @@ fn check_rest_operator() {
             vec![],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks an arrow function with only a rest parameter.
 #[test]
 fn check_arrow_only_rest() {
+    let mut interner = Interner::new();
     check_parser(
         "(...a) => {}",
         vec![ArrowFunctionDecl::new(
@@ -132,12 +149,14 @@ fn check_arrow_only_rest() {
             vec![],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks an arrow function with a rest parameter.
 #[test]
 fn check_arrow_rest() {
+    let mut interner = Interner::new();
     check_parser(
         "(a, b, ...c) => {}",
         vec![ArrowFunctionDecl::new(
@@ -149,12 +168,14 @@ fn check_arrow_rest() {
             vec![],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks an arrow function with expression return.
 #[test]
 fn check_arrow() {
+    let mut interner = Interner::new();
     check_parser(
         "(a, b) => { return a + b; }",
         vec![ArrowFunctionDecl::new(
@@ -169,12 +190,14 @@ fn check_arrow() {
             .into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks an arrow function with expression return and automatic semicolon insertion
 #[test]
 fn check_arrow_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "(a, b) => { return a + b }",
         vec![ArrowFunctionDecl::new(
@@ -189,12 +212,14 @@ fn check_arrow_semicolon_insertion() {
             .into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks arrow function with empty return
 #[test]
 fn check_arrow_epty_return() {
+    let mut interner = Interner::new();
     check_parser(
         "(a, b) => { return; }",
         vec![ArrowFunctionDecl::new(
@@ -205,12 +230,14 @@ fn check_arrow_epty_return() {
             vec![Return::new::<Node, Option<_>, Option<_>>(None, None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks an arrow function with empty return, with automatic semicolon insertion.
 #[test]
 fn check_arrow_empty_return_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "(a, b) => { return }",
         vec![ArrowFunctionDecl::new(
@@ -221,11 +248,13 @@ fn check_arrow_empty_return_semicolon_insertion() {
             vec![Return::new::<Node, Option<_>, Option<_>>(None, None).into()],
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = (a) => { return a };",
         vec![DeclarationList::Let(
@@ -249,11 +278,13 @@ fn check_arrow_assignment() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_nobrackets() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = (a) => a;",
         vec![DeclarationList::Let(
@@ -277,11 +308,13 @@ fn check_arrow_assignment_nobrackets() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_noparenthesis() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = a => { return a };",
         vec![DeclarationList::Let(
@@ -305,11 +338,13 @@ fn check_arrow_assignment_noparenthesis() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_noparenthesis_nobrackets() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = a => a;",
         vec![DeclarationList::Let(
@@ -333,11 +368,13 @@ fn check_arrow_assignment_noparenthesis_nobrackets() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_2arg() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = (a, b) => { return a };",
         vec![DeclarationList::Let(
@@ -367,11 +404,13 @@ fn check_arrow_assignment_2arg() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_2arg_nobrackets() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = (a, b) => a;",
         vec![DeclarationList::Let(
@@ -401,11 +440,13 @@ fn check_arrow_assignment_2arg_nobrackets() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_3arg() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = (a, b, c) => { return a };",
         vec![DeclarationList::Let(
@@ -439,11 +480,13 @@ fn check_arrow_assignment_3arg() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_arrow_assignment_3arg_nobrackets() {
+    let mut interner = Interner::new();
     check_parser(
         "let foo = (a, b, c) => a;",
         vec![DeclarationList::Let(
@@ -477,5 +520,6 @@ fn check_arrow_assignment_3arg_nobrackets() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/mod.rs b/boa/src/syntax/parser/mod.rs
index 2a06f7afdde..47abec4640f 100644
--- a/boa/src/syntax/parser/mod.rs
+++ b/boa/src/syntax/parser/mod.rs
@@ -9,7 +9,10 @@ mod statement;
 mod tests;
 
 pub use self::error::{ParseError, ParseResult};
-use crate::syntax::{ast::node::StatementList, lexer::TokenKind};
+use crate::{
+    syntax::{ast::node::StatementList, lexer::TokenKind},
+    Interner,
+};
 
 use cursor::Cursor;
 
@@ -28,7 +31,11 @@ where
     /// Parses the token stream using the current parser.
     ///
     /// This method needs to be provided by the implementor type.
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError>;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError>;
 }
 
 /// Boolean representing if the parser should allow a `yield` keyword.
@@ -98,11 +105,11 @@ impl<R> Parser<R> {
         Self { cursor }
     }
 
-    pub fn parse_all(&mut self) -> Result<StatementList, ParseError>
+    pub fn parse_all(&mut self, interner: &mut Interner) -> Result<StatementList, ParseError>
     where
         R: Read,
     {
-        Script.parse(&mut self.cursor)
+        Script.parse(&mut self.cursor, interner)
     }
 }
 
@@ -121,18 +128,26 @@ where
 {
     type Output = StatementList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        match cursor.peek(0)? {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        match cursor.peek(0, interner)? {
             Some(tok) => {
                 let mut strict = false;
                 match tok.kind() {
-                    TokenKind::StringLiteral(string) if string.as_ref() == "use strict" => {
+                    // Set the strict mode
+                    TokenKind::StringLiteral(string)
+                        if interner.resolve(*string).expect("string disappeared")
+                            == "use strict" =>
+                    {
                         cursor.set_strict_mode(true);
                         strict = true;
                     }
                     _ => {}
                 }
-                let mut statement_list = ScriptBody.parse(cursor)?;
+                let mut statement_list = ScriptBody.parse(cursor, interner)?;
                 statement_list.set_strict(strict);
                 Ok(statement_list)
             }
@@ -156,7 +171,11 @@ where
 {
     type Output = StatementList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        self::statement::StatementList::new(false, false, false, false, &[]).parse(cursor)
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        self::statement::StatementList::new(false, false, false, false, &[]).parse(cursor, interner)
     }
 }
diff --git a/boa/src/syntax/parser/statement/block/mod.rs b/boa/src/syntax/parser/statement/block/mod.rs
index a568e47ea26..6da242f54e7 100644
--- a/boa/src/syntax/parser/statement/block/mod.rs
+++ b/boa/src/syntax/parser/statement/block/mod.rs
@@ -11,14 +11,14 @@
 mod tests;
 
 use super::StatementList;
-
-use crate::syntax::lexer::TokenKind;
 use crate::{
     profiler::BoaProfiler,
     syntax::{
         ast::{node, Punctuator},
+        lexer::TokenKind,
         parser::{AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, TokenParser},
     },
+    Interner,
 };
 
 use std::io::Read;
@@ -71,12 +71,16 @@ where
 {
     type Output = node::Block;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Block", "Parsing");
-        cursor.expect(Punctuator::OpenBlock, "block")?;
-        if let Some(tk) = cursor.peek(0)? {
+        cursor.expect(Punctuator::OpenBlock, "block", interner)?;
+        if let Some(tk) = cursor.peek(0, interner)? {
             if tk.kind() == &TokenKind::Punctuator(Punctuator::CloseBlock) {
-                cursor.next()?.expect("} token vanished");
+                cursor.next(interner)?.expect("} token vanished");
                 return Ok(node::Block::from(vec![]));
             }
         }
@@ -88,9 +92,9 @@ where
             true,
             &BLOCK_BREAK_TOKENS,
         )
-        .parse(cursor)
+        .parse(cursor, interner)
         .map(node::Block::from)?;
-        cursor.expect(Punctuator::CloseBlock, "block")?;
+        cursor.expect(Punctuator::CloseBlock, "block", interner)?;
 
         Ok(statement_list)
     }
diff --git a/boa/src/syntax/parser/statement/block/tests.rs b/boa/src/syntax/parser/statement/block/tests.rs
index 25d8418e5c6..b96e5fde8fb 100644
--- a/boa/src/syntax/parser/statement/block/tests.rs
+++ b/boa/src/syntax/parser/statement/block/tests.rs
@@ -1,32 +1,37 @@
 //! Block statement parsing tests.
 
-use crate::syntax::{
-    ast::{
-        node::{
-            Assign, Block, Call, Declaration, DeclarationList, FunctionDecl, Identifier, Node,
-            Return, UnaryOp,
+use crate::{
+    syntax::{
+        ast::{
+            node::{
+                Assign, Block, Call, Declaration, DeclarationList, FunctionDecl, Identifier, Node,
+                Return, UnaryOp,
+            },
+            op, Const,
         },
-        op, Const,
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 /// Helper function to check a block.
 // TODO: #[track_caller]: https://github.com/rust-lang/rust/issues/47809
-fn check_block<B>(js: &str, block: B)
+fn check_block<B>(js: &str, block: B, interner: &mut Interner)
 where
     B: Into<Box<[Node]>>,
 {
-    check_parser(js, vec![Block::from(block.into()).into()]);
+    check_parser(js, vec![Block::from(block.into()).into()], interner);
 }
 
 #[test]
 fn empty() {
-    check_block("{}", vec![]);
+    let mut interner = Interner::new();
+    check_block("{}", vec![], &mut interner);
 }
 
 #[test]
 fn non_empty() {
+    let mut interner = Interner::new();
     check_block(
         r"{
             var a = 10;
@@ -43,8 +48,10 @@ fn non_empty() {
             .into(),
             UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
         ],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_block(
         r"{
             function hello() {
@@ -71,11 +78,13 @@ fn non_empty() {
             .into(),
             UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
         ],
+        &mut interner,
     );
 }
 
 #[test]
 fn hoisting() {
+    let mut interner = Interner::new();
     check_block(
         r"{
             var a = hello();
@@ -100,8 +109,10 @@ fn hoisting() {
             .into(),
             UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
         ],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_block(
         r"{
             a = 10;
@@ -114,5 +125,6 @@ fn hoisting() {
             UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("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 bc0cc70e9f0..893993240a9 100644
--- a/boa/src/syntax/parser/statement/break_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/break_stm/mod.rs
@@ -13,6 +13,7 @@ mod tests;
 use super::LabelIdentifier;
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::Break, Keyword, Punctuator},
@@ -60,22 +61,27 @@ where
 {
     type Output = Break;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("BreakStatement", "Parsing");
-        cursor.expect(Keyword::Break, "break statement")?;
+        cursor.expect(Keyword::Break, "break statement", interner)?;
 
-        let label = if let SemicolonResult::Found(tok) = cursor.peek_semicolon()? {
+        let label = if let SemicolonResult::Found(tok) = cursor.peek_semicolon(interner)? {
             match tok {
                 Some(tok) if tok.kind() == &TokenKind::Punctuator(Punctuator::Semicolon) => {
-                    let _ = cursor.next()?;
+                    let _ = cursor.next(interner)?;
                 }
                 _ => {}
             }
 
             None
         } else {
-            let label = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
-            cursor.expect_semicolon("break statement")?;
+            let label =
+                LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
+            cursor.expect_semicolon("break statement", interner)?;
 
             Some(label)
         };
diff --git a/boa/src/syntax/parser/statement/break_stm/tests.rs b/boa/src/syntax/parser/statement/break_stm/tests.rs
index 1507b0917bb..142b8c2d932 100644
--- a/boa/src/syntax/parser/statement/break_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/break_stm/tests.rs
@@ -1,13 +1,17 @@
-use crate::syntax::{
-    ast::{
-        node::{Block, Break, Node, WhileLoop},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{Block, Break, Node, WhileLoop},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 #[test]
 fn inline() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) break;",
         vec![WhileLoop::new(
@@ -15,20 +19,24 @@ fn inline() {
             Node::Break(Break::new::<_, Box<str>>(None)),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true)
             break;",
         vec![WhileLoop::new(Const::from(true), Break::new::<_, Box<str>>(None)).into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn inline_block_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {break}",
         vec![WhileLoop::new(
@@ -36,11 +44,13 @@ fn inline_block_semicolon_insertion() {
             Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             break test
@@ -50,11 +60,13 @@ fn new_line_semicolon_insertion() {
             Block::from(vec![Break::new("test").into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn inline_block() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {break;}",
         vec![WhileLoop::new(
@@ -62,11 +74,13 @@ fn inline_block() {
             Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_block() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             break test;
@@ -76,11 +90,13 @@ fn new_line_block() {
             Block::from(vec![Break::new("test").into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn reserved_label() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             break await;
@@ -90,8 +106,10 @@ fn reserved_label() {
             Block::from(vec![Break::new("await").into()]),
         )
         .into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             break yield;
@@ -101,11 +119,13 @@ fn reserved_label() {
             Block::from(vec![Break::new("yield").into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_block_empty() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             break;
@@ -115,11 +135,13 @@ fn new_line_block_empty() {
             Block::from(vec![Break::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_block_empty_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             break
@@ -129,5 +151,6 @@ fn new_line_block_empty_semicolon_insertion() {
             Block::from(vec![Break::new::<_, Box<str>>(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 48fed421bbe..d8933eab9e8 100644
--- a/boa/src/syntax/parser/statement/continue_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/continue_stm/mod.rs
@@ -11,6 +11,7 @@
 mod tests;
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::Continue, Keyword, Punctuator},
@@ -59,22 +60,27 @@ where
 {
     type Output = Continue;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ContinueStatement", "Parsing");
-        cursor.expect(Keyword::Continue, "continue statement")?;
+        cursor.expect(Keyword::Continue, "continue statement", interner)?;
 
-        let label = if let SemicolonResult::Found(tok) = cursor.peek_semicolon()? {
+        let label = if let SemicolonResult::Found(tok) = cursor.peek_semicolon(interner)? {
             match tok {
                 Some(tok) if tok.kind() == &TokenKind::Punctuator(Punctuator::Semicolon) => {
-                    let _ = cursor.next();
+                    let _ = cursor.next(interner)?;
                 }
                 _ => {}
             }
 
             None
         } else {
-            let label = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
-            cursor.expect_semicolon("continue statement")?;
+            let label =
+                LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
+            cursor.expect_semicolon("continue statement", interner)?;
 
             Some(label)
         };
diff --git a/boa/src/syntax/parser/statement/continue_stm/tests.rs b/boa/src/syntax/parser/statement/continue_stm/tests.rs
index b8aba8bb089..88b80c60156 100644
--- a/boa/src/syntax/parser/statement/continue_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/continue_stm/tests.rs
@@ -1,30 +1,38 @@
-use crate::syntax::{
-    ast::{
-        node::{Block, Continue, WhileLoop},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{Block, Continue, WhileLoop},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 #[test]
 fn inline() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) continue;",
         vec![WhileLoop::new(Const::from(true), Continue::new::<_, Box<str>>(None)).into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true)
             continue;",
         vec![WhileLoop::new(Const::from(true), Continue::new::<_, Box<str>>(None)).into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn inline_block_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {continue}",
         vec![WhileLoop::new(
@@ -32,11 +40,13 @@ fn inline_block_semicolon_insertion() {
             Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             continue test
@@ -46,11 +56,13 @@ fn new_line_semicolon_insertion() {
             Block::from(vec![Continue::new("test").into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn inline_block() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {continue;}",
         vec![WhileLoop::new(
@@ -58,11 +70,13 @@ fn inline_block() {
             Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_block() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             continue test;
@@ -72,11 +86,13 @@ fn new_line_block() {
             Block::from(vec![Continue::new("test").into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn reserved_label() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             continue await;
@@ -86,8 +102,10 @@ fn reserved_label() {
             Block::from(vec![Continue::new("await").into()]),
         )
         .into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             continue yield;
@@ -97,11 +115,13 @@ fn reserved_label() {
             Block::from(vec![Continue::new("yield").into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_block_empty() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             continue;
@@ -111,11 +131,13 @@ fn new_line_block_empty() {
             Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn new_line_block_empty_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         "while (true) {
             continue
@@ -125,5 +147,6 @@ fn new_line_block_empty_semicolon_insertion() {
             Block::from(vec![Continue::new::<_, Box<str>>(None).into()]),
         )
         .into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/mod.rs b/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/mod.rs
index 9fa9e1ca115..e3cbe35c069 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/async_function_decl/mod.rs
@@ -1,12 +1,15 @@
 #[cfg(test)]
 mod tests;
 
-use crate::syntax::{
-    ast::{node::AsyncFunctionDecl, Keyword},
-    parser::{
-        statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
-        AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+use crate::{
+    syntax::{
+        ast::{node::AsyncFunctionDecl, Keyword},
+        parser::{
+            statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
+            AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+        },
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -74,12 +77,16 @@ where
 {
     type Output = AsyncFunctionDecl;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        cursor.expect(Keyword::Async, "async hoistable declaration")?;
-        cursor.peek_expect_no_lineterminator(0, "async hoistable declaration")?;
-        cursor.expect(Keyword::Function, "async hoistable declaration")?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        cursor.expect(Keyword::Async, "async function declaration", interner)?;
+        cursor.peek_expect_no_lineterminator(0, "async function declaration", interner)?;
+        cursor.expect(Keyword::Function, "async function declaration", interner)?;
 
-        let result = parse_callable_declaration(&self, cursor)?;
+        let result = parse_callable_declaration(&self, cursor, interner)?;
 
         Ok(AsyncFunctionDecl::new(result.0, result.1, result.2))
     }
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 a7648b74e57..c0f1cb2b026 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
@@ -1,24 +1,33 @@
-use crate::syntax::{ast::node::AsyncFunctionDecl, parser::tests::check_parser};
+use crate::{
+    syntax::{ast::node::AsyncFunctionDecl, parser::tests::check_parser},
+    Interner,
+};
 
 /// Async function declaration parsing.
 #[test]
 fn async_function_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "async function hello() {}",
         vec![AsyncFunctionDecl::new(Box::from("hello"), vec![], vec![]).into()],
+        &mut interner,
     );
 }
 
 /// Async function declaration parsing with keywords.
 #[test]
 fn async_function_declaration_keywords() {
+    let mut interner = Interner::new();
     check_parser(
         "async function yield() {}",
         vec![AsyncFunctionDecl::new(Box::from("yield"), vec![], vec![]).into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "async function await() {}",
         vec![AsyncFunctionDecl::new(Box::from("await"), vec![], vec![]).into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/mod.rs b/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/mod.rs
index 683aea1e2c4..44a4e50ad67 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/async_generator_decl/mod.rs
@@ -6,12 +6,15 @@
 
 #[cfg(test)]
 mod tests;
-use crate::syntax::{
-    ast::{node::AsyncGeneratorDecl, Keyword, Punctuator},
-    parser::{
-        statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
-        AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+use crate::{
+    syntax::{
+        ast::{node::AsyncGeneratorDecl, Keyword, Punctuator},
+        parser::{
+            statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
+            AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+        },
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -92,13 +95,17 @@ where
 {
     type Output = AsyncGeneratorDecl;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        cursor.expect(Keyword::Async, "async hoistable declaration")?;
-        cursor.peek_expect_no_lineterminator(0, "async hoistable declaration")?;
-        cursor.expect(Keyword::Function, "async hoistable declaration")?;
-        cursor.expect(Punctuator::Mul, "async generator declaration")?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        cursor.expect(Keyword::Async, "async generator declaration", interner)?;
+        cursor.peek_expect_no_lineterminator(0, "async generator declaration", interner)?;
+        cursor.expect(Keyword::Function, "async generator declaration", interner)?;
+        cursor.expect(Punctuator::Mul, "async generator declaration", interner)?;
 
-        let result = parse_callable_declaration(&self, cursor)?;
+        let result = parse_callable_declaration(&self, cursor, interner)?;
 
         Ok(AsyncGeneratorDecl::new(result.0, result.1, result.2))
     }
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 1a35bbb996b..2540dd5837a 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
@@ -1,9 +1,14 @@
-use crate::syntax::{ast::node::AsyncGeneratorDecl, parser::tests::check_parser};
+use crate::{
+    syntax::{ast::node::AsyncGeneratorDecl, parser::tests::check_parser},
+    Interner,
+};
 
 #[test]
 fn async_generator_function_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "async function* gen() {}",
         vec![AsyncGeneratorDecl::new(Box::from("gen"), vec![], vec![]).into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/mod.rs b/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/mod.rs
index f878d2684d4..1793900c668 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/function_decl/mod.rs
@@ -1,12 +1,15 @@
 #[cfg(test)]
 mod tests;
 
-use crate::syntax::{
-    ast::{node::FunctionDecl, Keyword},
-    parser::{
-        statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
-        AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+use crate::{
+    syntax::{
+        ast::{node::FunctionDecl, Keyword},
+        parser::{
+            statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
+            AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+        },
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -79,10 +82,14 @@ where
 {
     type Output = FunctionDecl;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        cursor.expect(Keyword::Function, "function declaration")?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        cursor.expect(Keyword::Function, "function declaration", interner)?;
 
-        let result = parse_callable_declaration(&self, cursor)?;
+        let result = parse_callable_declaration(&self, cursor, interner)?;
 
         Ok(FunctionDecl::new(result.0, result.1, result.2))
     }
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 c9cff722c90..fe86617c4f6 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
@@ -1,24 +1,33 @@
-use crate::syntax::{ast::node::FunctionDecl, parser::tests::check_parser};
+use crate::{
+    syntax::{ast::node::FunctionDecl, parser::tests::check_parser},
+    Interner,
+};
 
 /// Function declaration parsing.
 #[test]
 fn function_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "function hello() {}",
         vec![FunctionDecl::new(Box::from("hello"), vec![], vec![]).into()],
+        &mut interner,
     );
 }
 
 /// Function declaration parsing with keywords.
 #[test]
 fn function_declaration_keywords() {
+    let mut interner = Interner::new();
     check_parser(
         "function yield() {}",
         vec![FunctionDecl::new(Box::from("yield"), vec![], vec![]).into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "function await() {}",
         vec![FunctionDecl::new(Box::from("await"), vec![], vec![]).into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/mod.rs b/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/mod.rs
index 67eed08a136..e82979d717c 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/generator_decl/mod.rs
@@ -1,12 +1,15 @@
 #[cfg(test)]
 mod tests;
 
-use crate::syntax::{
-    ast::{node::declaration::generator_decl::GeneratorDecl, Keyword, Punctuator},
-    parser::{
-        statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
-        AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+use crate::{
+    syntax::{
+        ast::{node::declaration::generator_decl::GeneratorDecl, Keyword, Punctuator},
+        parser::{
+            statement::declaration::hoistable::{parse_callable_declaration, CallableDeclaration},
+            AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, TokenParser,
+        },
     },
+    Interner,
 };
 use std::io::Read;
 
@@ -74,11 +77,15 @@ where
 {
     type Output = GeneratorDecl;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        cursor.expect(Keyword::Function, "generator declaration")?;
-        cursor.expect(Punctuator::Mul, "generator declaration")?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        cursor.expect(Keyword::Function, "generator declaration", interner)?;
+        cursor.expect(Punctuator::Mul, "generator declaration", interner)?;
 
-        let result = parse_callable_declaration(&self, cursor)?;
+        let result = parse_callable_declaration(&self, cursor, interner)?;
 
         Ok(GeneratorDecl::new(result.0, result.1, result.2))
     }
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 d914972d1f5..a856cabb398 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
@@ -1,9 +1,14 @@
-use crate::syntax::{ast::node::GeneratorDecl, parser::tests::check_parser};
+use crate::{
+    syntax::{ast::node::GeneratorDecl, parser::tests::check_parser},
+    Interner,
+};
 
 #[test]
 fn generator_function_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "function* gen() {}",
         vec![GeneratorDecl::new(Box::from("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 52caf17f005..61c33112277 100644
--- a/boa/src/syntax/parser/statement/declaration/hoistable/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/hoistable/mod.rs
@@ -29,7 +29,7 @@ use crate::{
             AllowAwait, AllowDefault, AllowYield, Cursor, ParseError, ParseResult, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -68,36 +68,36 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("HoistableDeclaration", "Parsing");
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::Function) => {
-                let next_token = cursor.peek(1)?.ok_or(ParseError::AbruptEnd)?;
+                let next_token = cursor.peek(1, interner)?.ok_or(ParseError::AbruptEnd)?;
                 if let TokenKind::Punctuator(Punctuator::Mul) = next_token.kind() {
                     GeneratorDeclaration::new(self.allow_yield, self.allow_await, self.is_default)
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::from)
                 } else {
                     FunctionDeclaration::new(self.allow_yield, self.allow_await, self.is_default)
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::from)
                 }
             }
             TokenKind::Keyword(Keyword::Async) => {
-                let next_token = cursor.peek(2)?.ok_or(ParseError::AbruptEnd)?;
+                let next_token = cursor.peek(2, interner)?.ok_or(ParseError::AbruptEnd)?;
                 if let TokenKind::Punctuator(Punctuator::Mul) = next_token.kind() {
                     AsyncGeneratorDeclaration::new(
                         self.allow_yield,
                         self.allow_await,
                         self.is_default,
                     )
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
                 } else {
                     AsyncFunctionDeclaration::new(self.allow_yield, self.allow_await, false)
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::from)
                 }
             }
@@ -123,19 +123,23 @@ trait CallableDeclaration {
 fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     c: &C,
     cursor: &mut Cursor<R>,
+    interner: &mut Interner,
 ) -> Result<(Box<str>, Box<[FormalParameter]>, StatementList), ParseError> {
-    let next_token = cursor.peek(0)?;
+    let next_token = cursor.peek(0, interner)?;
     let name = if let Some(token) = next_token {
         match token.kind() {
             TokenKind::Punctuator(Punctuator::OpenParen) => {
                 if !c.is_default() {
-                    return Err(ParseError::unexpected(token.clone(), c.error_context()));
+                    return Err(ParseError::unexpected(
+                        token.to_string(interner),
+                        token.span(),
+                        c.error_context(),
+                    ));
                 }
                 "default".into()
             }
-            _ => {
-                BindingIdentifier::new(c.name_allow_yield(), c.name_allow_await()).parse(cursor)?
-            }
+            _ => BindingIdentifier::new(c.name_allow_yield(), c.name_allow_await())
+                .parse(cursor, interner)?,
         }
     } else {
         return Err(ParseError::AbruptEnd);
@@ -146,7 +150,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     if cursor.strict_mode() && ["eval", "arguments"].contains(&name.as_ref()) {
         return Err(ParseError::lex(LexError::Syntax(
             "Unexpected eval or arguments in strict mode".into(),
-            match cursor.peek(0)? {
+            match cursor.peek(0, interner)? {
                 Some(token) => token.span().end(),
                 None => Position::new(1, 1),
             },
@@ -154,19 +158,20 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
     }
 
     let params_start_position = cursor
-        .expect(Punctuator::OpenParen, c.error_context())?
+        .expect(Punctuator::OpenParen, c.error_context(), interner)?
         .span()
         .end();
 
     let params = FormalParameters::new(c.parameters_allow_yield(), c.parameters_allow_await())
-        .parse(cursor)?;
+        .parse(cursor, interner)?;
 
-    cursor.expect(Punctuator::CloseParen, c.error_context())?;
-    cursor.expect(Punctuator::OpenBlock, c.error_context())?;
+    cursor.expect(Punctuator::CloseParen, c.error_context(), interner)?;
+    cursor.expect(Punctuator::OpenBlock, c.error_context(), interner)?;
 
-    let body = FunctionBody::new(c.body_allow_yield(), c.body_allow_await()).parse(cursor)?;
+    let body =
+        FunctionBody::new(c.body_allow_yield(), c.body_allow_await()).parse(cursor, interner)?;
 
-    cursor.expect(Punctuator::CloseBlock, c.error_context())?;
+    cursor.expect(Punctuator::CloseBlock, c.error_context(), interner)?;
 
     // Early Error: If the source code matching FormalParameters is strict mode code,
     // the Early Error rules for UniqueFormalParameters : FormalParameters are applied.
@@ -196,7 +201,7 @@ fn parse_callable_declaration<R: Read, C: CallableDeclaration>(
                 if lexically_declared_names.contains(param_name) {
                     return Err(ParseError::lex(LexError::Syntax(
                         format!("Redeclaration of formal parameter `{}`", param_name).into(),
-                        match cursor.peek(0)? {
+                        match cursor.peek(0, interner)? {
                             Some(token) => token.span().end(),
                             None => Position::new(1, 1),
                         },
diff --git a/boa/src/syntax/parser/statement/declaration/lexical.rs b/boa/src/syntax/parser/statement/declaration/lexical.rs
index aca9b7bd1aa..2d6fa9431ac 100644
--- a/boa/src/syntax/parser/statement/declaration/lexical.rs
+++ b/boa/src/syntax/parser/statement/declaration/lexical.rs
@@ -24,7 +24,7 @@ use crate::{
             AllowAwait, AllowIn, AllowYield, ParseError, ParseResult, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -71,9 +71,9 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("LexicalDeclaration", "Parsing");
-        let tok = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::Const) => BindingList::new(
@@ -83,7 +83,7 @@ where
                 true,
                 self.const_init_required,
             )
-            .parse(cursor),
+            .parse(cursor, interner),
             TokenKind::Keyword(Keyword::Let) => BindingList::new(
                 self.allow_in,
                 self.allow_yield,
@@ -91,7 +91,7 @@ where
                 false,
                 self.const_init_required,
             )
-            .parse(cursor),
+            .parse(cursor, interner),
             _ => unreachable!("unknown token found: {:?}", tok),
         }
     }
@@ -145,7 +145,7 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("BindingList", "Parsing");
 
         // Create vectors to store the variable declarations
@@ -155,7 +155,7 @@ where
 
         loop {
             let decl = LexicalBinding::new(self.allow_in, self.allow_yield, self.allow_await)
-                .parse(cursor)?;
+                .parse(cursor, interner)?;
 
             if self.is_const {
                 if self.const_init_required {
@@ -168,9 +168,11 @@ where
                     if init_is_some {
                         const_decls.push(decl);
                     } else {
+                        let next = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
                         return Err(ParseError::expected(
-                            vec![TokenKind::Punctuator(Punctuator::Assign)],
-                            cursor.next()?.ok_or(ParseError::AbruptEnd)?,
+                            vec!["="],
+                            next.to_string(interner),
+                            next.span(),
                             "const declaration",
                         ));
                     }
@@ -181,7 +183,7 @@ where
                 let_decls.push(decl);
             }
 
-            match cursor.peek_semicolon()? {
+            match cursor.peek_semicolon(interner)? {
                 SemicolonResult::Found(_) => break,
                 SemicolonResult::NotFound(tk)
                     if tk.kind() == &TokenKind::Keyword(Keyword::Of)
@@ -193,17 +195,16 @@ where
                     if tk.kind() == &TokenKind::Punctuator(Punctuator::Comma) =>
                 {
                     // We discard the comma
-                    let _ = cursor.next()?;
+                    let _ = cursor.next(interner)?;
                 }
                 _ => {
+                    let next = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
                     return Err(ParseError::expected(
-                        vec![
-                            TokenKind::Punctuator(Punctuator::Semicolon),
-                            TokenKind::LineTerminator,
-                        ],
-                        cursor.next()?.ok_or(ParseError::AbruptEnd)?,
+                        vec![";", "line terminator"],
+                        next.to_string(interner),
+                        next.span(),
                         "lexical declaration binding list",
-                    ))
+                    ));
                 }
             }
         }
@@ -250,22 +251,26 @@ where
 {
     type Output = Declaration;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("LexicalBinding", "Parsing");
 
-        let peek_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let peek_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match peek_token.kind() {
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
                 let bindings =
                     ObjectBindingPattern::new(self.allow_in, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
 
-                let init = if let Some(t) = cursor.peek(0)? {
+                let init = if let Some(t) = cursor.peek(0, interner)? {
                     if *t.kind() == TokenKind::Punctuator(Punctuator::Assign) {
                         Some(
                             Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                .parse(cursor)?,
+                                .parse(cursor, interner)?,
                         )
                     } else {
                         None
@@ -279,13 +284,13 @@ where
             TokenKind::Punctuator(Punctuator::OpenBracket) => {
                 let bindings =
                     ArrayBindingPattern::new(self.allow_in, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
 
-                let init = if let Some(t) = cursor.peek(0)? {
+                let init = if let Some(t) = cursor.peek(0, interner)? {
                     if *t.kind() == TokenKind::Punctuator(Punctuator::Assign) {
                         Some(
                             Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                .parse(cursor)?,
+                                .parse(cursor, interner)?,
                         )
                     } else {
                         None
@@ -298,14 +303,14 @@ where
             }
 
             _ => {
-                let ident =
-                    BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                let ident = BindingIdentifier::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
 
-                let init = if let Some(t) = cursor.peek(0)? {
+                let init = if let Some(t) = cursor.peek(0, interner)? {
                     if *t.kind() == TokenKind::Punctuator(Punctuator::Assign) {
                         Some(
                             Initializer::new(true, self.allow_yield, self.allow_await)
-                                .parse(cursor)?,
+                                .parse(cursor, interner)?,
                         )
                     } else {
                         None
diff --git a/boa/src/syntax/parser/statement/declaration/mod.rs b/boa/src/syntax/parser/statement/declaration/mod.rs
index e6abaac0e29..da48978e0c0 100644
--- a/boa/src/syntax/parser/statement/declaration/mod.rs
+++ b/boa/src/syntax/parser/statement/declaration/mod.rs
@@ -15,6 +15,7 @@ mod tests;
 use self::{hoistable::HoistableDeclaration, lexical::LexicalDeclaration};
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{Keyword, Node},
@@ -58,13 +59,18 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Declaration", "Parsing");
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::Function) | TokenKind::Keyword(Keyword::Async) => {
-                HoistableDeclaration::new(self.allow_yield, self.allow_await, false).parse(cursor)
+                HoistableDeclaration::new(self.allow_yield, self.allow_await, false)
+                    .parse(cursor, interner)
             }
             TokenKind::Keyword(Keyword::Const) | TokenKind::Keyword(Keyword::Let) => {
                 LexicalDeclaration::new(
@@ -73,7 +79,7 @@ where
                     self.allow_await,
                     self.const_init_required,
                 )
-                .parse(cursor)
+                .parse(cursor, interner)
             }
             _ => unreachable!("unknown token found: {:?}", tok),
         }
diff --git a/boa/src/syntax/parser/statement/declaration/tests.rs b/boa/src/syntax/parser/statement/declaration/tests.rs
index c7d9fb8f03e..4910f926fe1 100644
--- a/boa/src/syntax/parser/statement/declaration/tests.rs
+++ b/boa/src/syntax/parser/statement/declaration/tests.rs
@@ -1,14 +1,18 @@
-use crate::syntax::{
-    ast::{
-        node::{Declaration, DeclarationList, Node},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{Declaration, DeclarationList, Node},
+            Const,
+        },
+        parser::tests::{check_invalid, check_parser},
     },
-    parser::tests::{check_invalid, check_parser},
+    Interner,
 };
 
 /// Checks `var` declaration parsing.
 #[test]
 fn var_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "var a = 5;",
         vec![DeclarationList::Var(
@@ -19,12 +23,14 @@ fn var_declaration() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `var` declaration parsing with reserved words.
 #[test]
 fn var_declaration_keywords() {
+    let mut interner = Interner::new();
     check_parser(
         "var yield = 5;",
         vec![DeclarationList::Var(
@@ -35,8 +41,10 @@ fn var_declaration_keywords() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "var await = 5;",
         vec![DeclarationList::Var(
@@ -47,12 +55,14 @@ fn var_declaration_keywords() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `var` declaration parsing with no spaces.
 #[test]
 fn var_declaration_no_spaces() {
+    let mut interner = Interner::new();
     check_parser(
         "var a=5;",
         vec![DeclarationList::Var(
@@ -63,21 +73,25 @@ fn var_declaration_no_spaces() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks empty `var` declaration parsing.
 #[test]
 fn empty_var_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "var a;",
         vec![DeclarationList::Var(vec![Declaration::new_with_identifier("a", None)].into()).into()],
+        &mut interner,
     );
 }
 
 /// Checks multiple `var` declarations.
 #[test]
 fn multiple_var_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "var a = 5, b, c = 6;",
         vec![DeclarationList::Var(
@@ -89,12 +103,14 @@ fn multiple_var_declaration() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `let` declaration parsing.
 #[test]
 fn let_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "let a = 5;",
         vec![DeclarationList::Let(
@@ -105,12 +121,14 @@ fn let_declaration() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `let` declaration parsing with reserved words.
 #[test]
 fn let_declaration_keywords() {
+    let mut interner = Interner::new();
     check_parser(
         "let yield = 5;",
         vec![DeclarationList::Let(
@@ -121,8 +139,10 @@ fn let_declaration_keywords() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "let await = 5;",
         vec![DeclarationList::Let(
@@ -133,12 +153,14 @@ fn let_declaration_keywords() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `let` declaration parsing with no spaces.
 #[test]
 fn let_declaration_no_spaces() {
+    let mut interner = Interner::new();
     check_parser(
         "let a=5;",
         vec![DeclarationList::Let(
@@ -149,21 +171,25 @@ fn let_declaration_no_spaces() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks empty `let` declaration parsing.
 #[test]
 fn empty_let_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "let a;",
         vec![DeclarationList::Let(vec![Declaration::new_with_identifier("a", None)].into()).into()],
+        &mut interner,
     );
 }
 
 /// Checks multiple `let` declarations.
 #[test]
 fn multiple_let_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "let a = 5, b, c = 6;",
         vec![DeclarationList::Let(
@@ -175,12 +201,14 @@ fn multiple_let_declaration() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `const` declaration parsing.
 #[test]
 fn const_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "const a = 5;",
         vec![DeclarationList::Const(
@@ -191,12 +219,14 @@ fn const_declaration() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `const` declaration parsing with reserved words.
 #[test]
 fn const_declaration_keywords() {
+    let mut interner = Interner::new();
     check_parser(
         "const yield = 5;",
         vec![DeclarationList::Const(
@@ -207,8 +237,10 @@ fn const_declaration_keywords() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         "const await = 5;",
         vec![DeclarationList::Const(
@@ -219,12 +251,14 @@ fn const_declaration_keywords() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
 /// Checks `const` declaration parsing with no spaces.
 #[test]
 fn const_declaration_no_spaces() {
+    let mut interner = Interner::new();
     check_parser(
         "const a=5;",
         vec![DeclarationList::Const(
@@ -235,6 +269,7 @@ fn const_declaration_no_spaces() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -247,6 +282,7 @@ fn empty_const_declaration() {
 /// Checks multiple `const` declarations.
 #[test]
 fn multiple_const_declaration() {
+    let mut interner = Interner::new();
     check_parser(
         "const a = 5, c = 6;",
         vec![DeclarationList::Const(
@@ -257,5 +293,6 @@ fn multiple_const_declaration() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/expression/mod.rs b/boa/src/syntax/parser/statement/expression/mod.rs
index eb663846790..faacaa25f87 100644
--- a/boa/src/syntax/parser/statement/expression/mod.rs
+++ b/boa/src/syntax/parser/statement/expression/mod.rs
@@ -5,7 +5,7 @@ use crate::{
         lexer::TokenKind,
         parser::{AllowAwait, AllowYield, Cursor, ParseError, TokenParser},
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -41,10 +41,10 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> ParseResult {
+    fn parse(self, cursor: &mut Cursor<R>, interner: &mut Interner) -> ParseResult {
         let _timer = BoaProfiler::global().start_event("ExpressionStatement", "Parsing");
 
-        let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
         match next_token.kind() {
             TokenKind::Keyword(Keyword::Function) | TokenKind::Keyword(Keyword::Class) => {
                 return Err(ParseError::general(
@@ -53,7 +53,7 @@ where
                 ));
             }
             TokenKind::Keyword(Keyword::Async) => {
-                let next_token = cursor.peek(1)?.ok_or(ParseError::AbruptEnd)?;
+                let next_token = cursor.peek(1, interner)?.ok_or(ParseError::AbruptEnd)?;
                 if next_token.kind() == &TokenKind::Keyword(Keyword::Function) {
                     return Err(ParseError::general(
                         "expected statement",
@@ -62,7 +62,7 @@ where
                 }
             }
             TokenKind::Keyword(Keyword::Let) => {
-                let next_token = cursor.peek(1)?.ok_or(ParseError::AbruptEnd)?;
+                let next_token = cursor.peek(1, interner)?.ok_or(ParseError::AbruptEnd)?;
                 if next_token.kind() == &TokenKind::Punctuator(Punctuator::OpenBracket) {
                     return Err(ParseError::general(
                         "expected statement",
@@ -73,9 +73,10 @@ where
             _ => {}
         }
 
-        let expr = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let expr =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
-        cursor.expect_semicolon("expression statement")?;
+        cursor.expect_semicolon("expression statement", interner)?;
 
         Ok(expr)
     }
diff --git a/boa/src/syntax/parser/statement/if_stm/mod.rs b/boa/src/syntax/parser/statement/if_stm/mod.rs
index 326abff45b6..8fca9674f7d 100644
--- a/boa/src/syntax/parser/statement/if_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/if_stm/mod.rs
@@ -11,7 +11,7 @@ use crate::{
             AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -54,31 +54,39 @@ where
 {
     type Output = If;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("IfStatement", "Parsing");
 
-        cursor.expect(Keyword::If, "if statement")?;
-        cursor.expect(Punctuator::OpenParen, "if statement")?;
+        cursor.expect(Keyword::If, "if statement", interner)?;
+        cursor.expect(Punctuator::OpenParen, "if statement", interner)?;
 
-        let condition = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let condition =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
         let position = cursor
-            .expect(Punctuator::CloseParen, "if statement")?
+            .expect(Punctuator::CloseParen, "if statement", interner)?
             .span()
             .end();
 
         let then_node = if !cursor.strict_mode()
-            && cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind()
+            && cursor
+                .peek(0, interner)?
+                .ok_or(ParseError::AbruptEnd)?
+                .kind()
                 == &TokenKind::Keyword(Keyword::Function)
         {
             // FunctionDeclarations in IfStatement Statement Clauses
             // https://tc39.es/ecma262/#sec-functiondeclarations-in-ifstatement-statement-clauses
             FunctionDeclaration::new(self.allow_yield, self.allow_await, false)
-                .parse(cursor)?
+                .parse(cursor, interner)?
                 .into()
         } else {
             let node = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
-                .parse(cursor)?;
+                .parse(cursor, interner)?;
 
             // Early Error: It is a Syntax Error if IsLabelledFunction(the first Statement) is true.
             if let Node::FunctionDecl(_) = node {
@@ -88,23 +96,30 @@ where
             node
         };
 
-        let else_node = if cursor.next_if(Keyword::Else)?.is_some() {
-            let position = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.span().start();
+        let else_node = if cursor.next_if(Keyword::Else, interner)?.is_some() {
+            let position = cursor
+                .peek(0, interner)?
+                .ok_or(ParseError::AbruptEnd)?
+                .span()
+                .start();
 
             if !cursor.strict_mode()
-                && cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind()
+                && cursor
+                    .peek(0, interner)?
+                    .ok_or(ParseError::AbruptEnd)?
+                    .kind()
                     == &TokenKind::Keyword(Keyword::Function)
             {
                 // FunctionDeclarations in IfStatement Statement Clauses
                 // https://tc39.es/ecma262/#sec-functiondeclarations-in-ifstatement-statement-clauses
                 Some(
                     FunctionDeclaration::new(self.allow_yield, self.allow_await, false)
-                        .parse(cursor)?
+                        .parse(cursor, interner)?
                         .into(),
                 )
             } else {
                 let node = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
                 // Early Error: It is a Syntax Error if IsLabelledFunction(the second Statement) is true.
                 if let Node::FunctionDecl(_) = node {
diff --git a/boa/src/syntax/parser/statement/if_stm/tests.rs b/boa/src/syntax/parser/statement/if_stm/tests.rs
index 852ce4a8396..b79caabbf0f 100644
--- a/boa/src/syntax/parser/statement/if_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/if_stm/tests.rs
@@ -1,23 +1,30 @@
-use crate::syntax::{
-    ast::{
-        node::{Block, If, Node},
-        Const,
+use crate::{
+    syntax::{
+        ast::{
+            node::{Block, If, Node},
+            Const,
+        },
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 #[test]
 fn if_without_else_block() {
+    let mut interner = Interner::new();
     check_parser(
         "if (true) {}",
         vec![If::new::<_, _, Node, _>(Const::from(true), Block::from(Vec::new()), None).into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn if_without_else_block_with_trailing_newline() {
+    let mut interner = Interner::new();
     check_parser(
         "if (true) {}\n",
         vec![If::new::<_, _, Node, _>(Const::from(true), Block::from(Vec::new()), None).into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/iteration/do_while_statement.rs b/boa/src/syntax/parser/statement/iteration/do_while_statement.rs
index 6518841ff5e..ff69548da56 100644
--- a/boa/src/syntax/parser/statement/iteration/do_while_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/do_while_statement.rs
@@ -16,7 +16,7 @@ use crate::{
             Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -61,46 +61,52 @@ where
 {
     type Output = DoWhileLoop;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("DoWhileStatement", "Parsing");
 
         let position = cursor
-            .expect(Keyword::Do, "do while statement")?
+            .expect(Keyword::Do, "do while statement", interner)?
             .span()
             .end();
 
-        let body =
-            Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+        let body = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
+            .parse(cursor, interner)?;
 
         // Early Error: It is a Syntax Error if IsLabelledFunction(Statement) is true.
         if let Node::FunctionDecl(_) = body {
             return Err(ParseError::wrong_function_declaration_non_strict(position));
         }
 
-        let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         if next_token.kind() != &TokenKind::Keyword(Keyword::While) {
             return Err(ParseError::expected(
-                vec![TokenKind::Keyword(Keyword::While)],
-                next_token.clone(),
+                vec!["while"],
+                next_token.to_string(interner),
+                next_token.span(),
                 "do while statement",
             ));
         }
 
-        cursor.expect(Keyword::While, "do while statement")?;
+        cursor.expect(Keyword::While, "do while statement", interner)?;
 
-        cursor.expect(Punctuator::OpenParen, "do while statement")?;
+        cursor.expect(Punctuator::OpenParen, "do while statement", interner)?;
 
-        let cond = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let cond =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseParen, "do while statement")?;
+        cursor.expect(Punctuator::CloseParen, "do while statement", interner)?;
 
         // Here, we only care to read the next token if it's a semicolon. If it's not, we
         // automatically "enter" or assume a semicolon, since we have just read the `)` token:
         // https://tc39.es/ecma262/#sec-automatic-semicolon-insertion
-        if let Some(tok) = cursor.peek(0)? {
+        if let Some(tok) = cursor.peek(0, interner)? {
             if let TokenKind::Punctuator(Punctuator::Semicolon) = *tok.kind() {
-                cursor.next()?;
+                cursor.next(interner)?;
             }
         }
 
diff --git a/boa/src/syntax/parser/statement/iteration/for_statement.rs b/boa/src/syntax/parser/statement/iteration/for_statement.rs
index 0b7cfc4d29f..c52e95b35ae 100644
--- a/boa/src/syntax/parser/statement/iteration/for_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/for_statement.rs
@@ -21,7 +21,7 @@ use crate::{
             AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -66,45 +66,57 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ForStatement", "Parsing");
-        cursor.expect(Keyword::For, "for statement")?;
+        cursor.expect(Keyword::For, "for statement", interner)?;
         let init_position = cursor
-            .expect(Punctuator::OpenParen, "for statement")?
+            .expect(Punctuator::OpenParen, "for statement", interner)?
             .span()
             .end();
 
-        let init = match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+        let init = match cursor
+            .peek(0, interner)?
+            .ok_or(ParseError::AbruptEnd)?
+            .kind()
+        {
             TokenKind::Keyword(Keyword::Var) => {
-                let _ = cursor.next()?;
+                let _ = cursor.next(interner)?;
                 Some(
                     VariableDeclarationList::new(false, self.allow_yield, self.allow_await)
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::from)?,
                 )
             }
-            TokenKind::Keyword(Keyword::Let) | TokenKind::Keyword(Keyword::Const) => {
-                Some(Declaration::new(self.allow_yield, self.allow_await, false).parse(cursor)?)
-            }
+            TokenKind::Keyword(Keyword::Let) | TokenKind::Keyword(Keyword::Const) => Some(
+                Declaration::new(self.allow_yield, self.allow_await, false)
+                    .parse(cursor, interner)?,
+            ),
             TokenKind::Punctuator(Punctuator::Semicolon) => None,
-            _ => Some(Expression::new(false, self.allow_yield, self.allow_await).parse(cursor)?),
+            _ => Some(
+                Expression::new(false, self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?,
+            ),
         };
 
-        match cursor.peek(0)? {
+        match cursor.peek(0, interner)? {
             Some(tok) if tok.kind() == &TokenKind::Keyword(Keyword::In) && init.is_some() => {
                 let init = node_to_iterable_loop_initializer(&init.unwrap(), init_position)?;
 
-                let _ = cursor.next();
-                let expr =
-                    Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+                let _ = cursor.next(interner)?;
+                let expr = Expression::new(true, self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
 
                 let position = cursor
-                    .expect(Punctuator::CloseParen, "for in statement")?
+                    .expect(Punctuator::CloseParen, "for in statement", interner)?
                     .span()
                     .end();
 
                 let body = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
                 // Early Error: It is a Syntax Error if IsLabelledFunction(the first Statement) is true.
                 if let Node::FunctionDecl(_) = body {
@@ -116,17 +128,17 @@ where
             Some(tok) if tok.kind() == &TokenKind::Keyword(Keyword::Of) && init.is_some() => {
                 let init = node_to_iterable_loop_initializer(&init.unwrap(), init_position)?;
 
-                let _ = cursor.next();
-                let iterable =
-                    Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+                let _ = cursor.next(interner)?;
+                let iterable = Expression::new(true, self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
 
                 let position = cursor
-                    .expect(Punctuator::CloseParen, "for of statement")?
+                    .expect(Punctuator::CloseParen, "for of statement", interner)?
                     .span()
                     .end();
 
                 let body = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
                 // Early Error: It is a Syntax Error if IsLabelledFunction(the first Statement) is true.
                 if let Node::FunctionDecl(_) = body {
@@ -138,31 +150,38 @@ where
             _ => {}
         }
 
-        cursor.expect(Punctuator::Semicolon, "for statement")?;
+        cursor.expect(Punctuator::Semicolon, "for statement", interner)?;
 
-        let cond = if cursor.next_if(Punctuator::Semicolon)?.is_some() {
+        let cond = if cursor.next_if(Punctuator::Semicolon, interner)?.is_some() {
             Const::from(true).into()
         } else {
-            let step = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
-            cursor.expect(Punctuator::Semicolon, "for statement")?;
+            let step = Expression::new(true, self.allow_yield, self.allow_await)
+                .parse(cursor, interner)?;
+            cursor.expect(Punctuator::Semicolon, "for statement", interner)?;
             step
         };
 
-        let step = if cursor.next_if(Punctuator::CloseParen)?.is_some() {
+        let step = if cursor.next_if(Punctuator::CloseParen, interner)?.is_some() {
             None
         } else {
-            let step = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+            let step = Expression::new(true, self.allow_yield, self.allow_await)
+                .parse(cursor, interner)?;
             cursor.expect(
                 TokenKind::Punctuator(Punctuator::CloseParen),
                 "for statement",
+                interner,
             )?;
             Some(step)
         };
 
-        let position = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.span().start();
+        let position = cursor
+            .peek(0, interner)?
+            .ok_or(ParseError::AbruptEnd)?
+            .span()
+            .start();
 
-        let body =
-            Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+        let body = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
+            .parse(cursor, interner)?;
 
         // Early Error: It is a Syntax Error if IsLabelledFunction(the first Statement) is true.
         if let Node::FunctionDecl(_) = body {
diff --git a/boa/src/syntax/parser/statement/iteration/tests.rs b/boa/src/syntax/parser/statement/iteration/tests.rs
index b4854984b89..b60d1cb4bfa 100644
--- a/boa/src/syntax/parser/statement/iteration/tests.rs
+++ b/boa/src/syntax/parser/statement/iteration/tests.rs
@@ -1,18 +1,22 @@
-use crate::syntax::{
-    ast::{
-        node::{
-            field::GetConstField, BinOp, Block, Break, Call, Declaration, DeclarationList,
-            DoWhileLoop, Identifier, UnaryOp, WhileLoop,
+use crate::{
+    syntax::{
+        ast::{
+            node::{
+                field::GetConstField, BinOp, Block, Break, Call, Declaration, DeclarationList,
+                DoWhileLoop, Identifier, UnaryOp, WhileLoop,
+            },
+            op::{self, AssignOp, CompOp},
+            Const,
         },
-        op::{self, AssignOp, CompOp},
-        Const,
+        parser::tests::check_parser,
     },
-    parser::tests::check_parser,
+    Interner,
 };
 
 /// Checks do-while statement parsing.
 #[test]
 fn check_do_while() {
+    let mut interner = Interner::new();
     check_parser(
         r#"do {
             a += 1;
@@ -27,12 +31,14 @@ fn check_do_while() {
             Const::from(true),
         )
         .into()],
+        &mut interner,
     );
 }
 
 // Checks automatic semicolon insertion after do-while.
 #[test]
 fn check_do_while_semicolon_insertion() {
+    let mut interner = Interner::new();
     check_parser(
         r#"var i = 0;
         do {console.log("hello");} while(i++ < 10) console.log("end");"#,
@@ -64,6 +70,7 @@ fn check_do_while_semicolon_insertion() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
@@ -71,6 +78,7 @@ fn check_do_while_semicolon_insertion() {
 // and next statement.
 #[test]
 fn check_do_while_semicolon_insertion_no_space() {
+    let mut interner = Interner::new();
     check_parser(
         r#"var i = 0;
         do {console.log("hello");} while(i++ < 10)console.log("end");"#,
@@ -102,12 +110,14 @@ fn check_do_while_semicolon_insertion_no_space() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
 /// Checks parsing of a while statement which is seperated out with line terminators.
 #[test]
 fn while_spaces() {
+    let mut interner = Interner::new();
     check_parser(
         r#"
 
@@ -123,12 +133,14 @@ fn while_spaces() {
 
         "#,
         vec![WhileLoop::new(Const::from(true), Break::new::<_, Box<str>>(None)).into()],
+        &mut interner,
     );
 }
 
 /// Checks parsing of a while statement which is seperated out with line terminators.
 #[test]
 fn do_while_spaces() {
+    let mut interner = Interner::new();
     check_parser(
         r#"
 
@@ -148,5 +160,6 @@ fn do_while_spaces() {
             Const::Bool(true),
         )
         .into()],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/iteration/while_statement.rs b/boa/src/syntax/parser/statement/iteration/while_statement.rs
index 56ff0b4cd0d..7c8f999619f 100644
--- a/boa/src/syntax/parser/statement/iteration/while_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/while_statement.rs
@@ -6,7 +6,7 @@ use crate::{
             Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -52,21 +52,26 @@ where
 {
     type Output = WhileLoop;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("WhileStatement", "Parsing");
-        cursor.expect(Keyword::While, "while statement")?;
+        cursor.expect(Keyword::While, "while statement", interner)?;
 
-        cursor.expect(Punctuator::OpenParen, "while statement")?;
+        cursor.expect(Punctuator::OpenParen, "while statement", interner)?;
 
-        let cond = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let cond =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
         let position = cursor
-            .expect(Punctuator::CloseParen, "while statement")?
+            .expect(Punctuator::CloseParen, "while statement", interner)?
             .span()
             .end();
 
-        let body =
-            Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+        let body = Statement::new(self.allow_yield, self.allow_await, self.allow_return)
+            .parse(cursor, interner)?;
 
         // Early Error: It is a Syntax Error if IsLabelledFunction(Statement) is true.
         if let Node::FunctionDecl(_) = body {
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index 241d96f3085..69653409367 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -14,7 +14,7 @@ use crate::{
             AllowYield, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 /// Labelled Statement Parsing
 ///
@@ -52,15 +52,20 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
 
-        let name = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
+        let name =
+            LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::Colon, "Labelled Statement")?;
+        cursor.expect(Punctuator::Colon, "Labelled Statement", interner)?;
 
         let strict = cursor.strict_mode();
-        let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
         let mut node = match next_token.kind() {
             // Early Error: It is a Syntax Error if any strict mode source code matches this rule.
             // https://tc39.es/ecma262/#sec-labelled-statements-static-semantics-early-errors
@@ -73,10 +78,10 @@ where
             }
             TokenKind::Keyword(Keyword::Function) => {
                 FunctionDeclaration::new(self.allow_yield, self.allow_await, false)
-                .parse(cursor)?
+                .parse(cursor, interner)?
                 .into()
             }
-            _ => Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?
+            _ => Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor, interner)?
         };
 
         set_label_for_node(&mut node, name);
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 1e9447c14a3..cf8580ab1c6 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -35,11 +35,14 @@ use self::{
     try_stm::TryStatement,
     variable::VariableStatement,
 };
-use crate::syntax::{
-    ast::node::declaration::{
-        DeclarationPattern, DeclarationPatternArray, DeclarationPatternObject,
+use crate::{
+    syntax::{
+        ast::node::declaration::{
+            DeclarationPattern, DeclarationPatternArray, DeclarationPatternObject,
+        },
+        parser::expression::Initializer,
     },
-    parser::expression::Initializer,
+    Interner,
 };
 
 use super::{AllowAwait, AllowIn, AllowReturn, AllowYield, Cursor, ParseError, TokenParser};
@@ -118,88 +121,96 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Statement", "Parsing");
         // TODO: add BreakableStatement and divide Whiles, fors and so on to another place.
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::Await) => AwaitExpression::new(self.allow_yield)
-                .parse(cursor)
+                .parse(cursor, interner)
                 .map(Node::from),
             TokenKind::Keyword(Keyword::If) => {
                 IfStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Var) => {
                 VariableStatement::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::While) => {
                 WhileStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Do) => {
                 DoWhileStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::For) => {
                 ForStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Return) => {
                 if self.allow_return.0 {
                     ReturnStatement::new(self.allow_yield, self.allow_await)
-                        .parse(cursor)
+                        .parse(cursor, interner)
                         .map(Node::from)
                 } else {
-                    Err(ParseError::unexpected(tok.clone(), "statement"))
+                    Err(ParseError::unexpected(
+                        tok.to_string(interner),
+                        tok.span(),
+                        "statement",
+                    ))
                 }
             }
             TokenKind::Keyword(Keyword::Break) => {
                 BreakStatement::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Continue) => {
                 ContinueStatement::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Try) => {
                 TryStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Throw) => {
                 ThrowStatement::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::Switch) => {
                 SwitchStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
                 BlockStatement::new(self.allow_yield, self.allow_await, self.allow_return)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from)
             }
             TokenKind::Punctuator(Punctuator::Semicolon) => {
                 // parse the EmptyStatement
-                cursor.next().expect("semicolon disappeared");
+                cursor.next(interner).expect("semicolon disappeared");
                 Ok(Node::Empty)
             }
             TokenKind::Identifier(_) => {
                 // Labelled Statement check
                 cursor.set_goal(InputElement::Div);
-                let tok = cursor.peek(1)?;
+                let tok = cursor.peek(1, interner)?;
                 if tok.is_some()
                     && matches!(
                         tok.unwrap().kind(),
@@ -211,14 +222,16 @@ where
                         self.allow_await,
                         self.allow_return,
                     )
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Node::from);
                 }
 
-                ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor)
+                ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor, interner)
             }
 
-            _ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor),
+            _ => {
+                ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor, interner)
+            }
         }
     }
 }
@@ -278,12 +291,16 @@ where
     ///
     /// Note that the last token which causes the parse to finish is not
     /// consumed.
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("StatementList", "Parsing");
         let mut items = Vec::new();
 
         loop {
-            match cursor.peek(0)? {
+            match cursor.peek(0, interner)? {
                 Some(token) if self.break_nodes.contains(token.kind()) => break,
                 None => break,
                 _ => {}
@@ -295,11 +312,11 @@ where
                 self.allow_return,
                 self.in_block,
             )
-            .parse(cursor)?;
+            .parse(cursor, interner)?;
             items.push(item);
 
             // move the cursor forward for any consecutive semicolon.
-            while cursor.next_if(Punctuator::Semicolon)?.is_some() {}
+            while cursor.next_if(Punctuator::Semicolon, interner)?.is_some() {}
         }
 
         // Handle any redeclarations
@@ -326,7 +343,7 @@ where
                                                 ident.as_ref()
                                             )
                                             .into(),
-                                            match cursor.peek(0)? {
+                                            match cursor.peek(0, interner)? {
                                                 Some(token) => token.span().end(),
                                                 None => Position::new(1, 1),
                                             },
@@ -341,7 +358,7 @@ where
                                             return Err(ParseError::lex(LexError::Syntax(
                                                 format!("Redeclaration of variable `{}`", ident)
                                                     .into(),
-                                                match cursor.peek(0)? {
+                                                match cursor.peek(0, interner)? {
                                                     Some(token) => token.span().end(),
                                                     None => Position::new(1, 1),
                                                 },
@@ -364,7 +381,7 @@ where
                                                 ident.as_ref()
                                             )
                                             .into(),
-                                            match cursor.peek(0)? {
+                                            match cursor.peek(0, interner)? {
                                                 Some(token) => token.span().end(),
                                                 None => Position::new(1, 1),
                                             },
@@ -380,7 +397,7 @@ where
                                             return Err(ParseError::lex(LexError::Syntax(
                                                 format!("Redeclaration of variable `{}`", ident)
                                                     .into(),
-                                                match cursor.peek(0)? {
+                                                match cursor.peek(0, interner)? {
                                                     Some(token) => token.span().end(),
                                                     None => Position::new(1, 1),
                                                 },
@@ -445,10 +462,14 @@ where
 {
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("StatementListItem", "Parsing");
         let strict_mode = cursor.strict_mode();
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match *tok.kind() {
             TokenKind::Keyword(Keyword::Function) | TokenKind::Keyword(Keyword::Async) => {
@@ -458,14 +479,13 @@ where
                         tok.span().start(),
                     )));
                 }
-                Declaration::new(self.allow_yield, self.allow_await, true).parse(cursor)
+                Declaration::new(self.allow_yield, self.allow_await, true).parse(cursor, interner)
             }
             TokenKind::Keyword(Keyword::Const) | TokenKind::Keyword(Keyword::Let) => {
-                Declaration::new(self.allow_yield, self.allow_await, true).parse(cursor)
-            }
-            _ => {
-                Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)
+                Declaration::new(self.allow_yield, self.allow_await, true).parse(cursor, interner)
             }
+            _ => Statement::new(self.allow_yield, self.allow_await, self.allow_return)
+                .parse(cursor, interner),
         }
     }
 }
@@ -513,13 +533,19 @@ where
     type Output = Box<str>;
 
     /// Strict mode parsing as per <https://tc39.es/ecma262/#sec-identifiers-static-semantics-early-errors>.
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("BindingIdentifier", "Parsing");
 
-        let next_token = cursor.next()?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = cursor.next(interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match next_token.kind() {
-            TokenKind::Identifier(ref s) => Ok(s.clone()),
+            TokenKind::Identifier(ref s) => {
+                Ok(interner.resolve(*s).expect("string disappeared").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(
@@ -555,8 +581,9 @@ where
                 }
             }
             _ => Err(ParseError::expected(
-                vec![TokenKind::identifier("identifier")],
-                next_token,
+                vec!["identifier"],
+                next_token.to_string(interner),
+                next_token.span(),
                 "binding identifier",
             )),
         }
@@ -598,12 +625,17 @@ where
 {
     type Output = Vec<BindingPatternTypeObject>;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ObjectBindingPattern", "Parsing");
 
         cursor.expect(
             TokenKind::Punctuator(Punctuator::OpenBlock),
             "object binding pattern",
+            interner,
         )?;
 
         let mut patterns = Vec::new();
@@ -611,11 +643,16 @@ where
         let mut rest_property_name = None;
 
         loop {
-            let property_name = match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+            let property_name = match cursor
+                .peek(0, interner)?
+                .ok_or(ParseError::AbruptEnd)?
+                .kind()
+            {
                 TokenKind::Punctuator(Punctuator::CloseBlock) => {
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::CloseBlock),
                         "object binding pattern",
+                        interner,
                     )?;
                     break;
                 }
@@ -623,27 +660,31 @@ where
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::Spread),
                         "object binding pattern",
+                        interner,
                     )?;
                     rest_property_name = Some(
-                        BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                        BindingIdentifier::new(self.allow_yield, self.allow_await)
+                            .parse(cursor, interner)?,
                     );
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::CloseBlock),
                         "object binding pattern",
+                        interner,
                     )?;
                     break;
                 }
-                _ => BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?,
+                _ => BindingIdentifier::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?,
             };
 
             property_names.push(property_name.clone());
 
-            if let Some(peek_token) = cursor.peek(0)? {
+            if let Some(peek_token) = cursor.peek(0, interner)? {
                 match peek_token.kind() {
                     TokenKind::Punctuator(Punctuator::Assign) => {
                         let init =
                             Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                .parse(cursor)?;
+                                .parse(cursor, interner)?;
                         patterns.push(BindingPatternTypeObject::SingleName {
                             ident: property_name.clone(),
                             property_name,
@@ -654,9 +695,10 @@ where
                         cursor.expect(
                             TokenKind::Punctuator(Punctuator::Colon),
                             "object binding pattern",
+                            interner,
                         )?;
 
-                        if let Some(peek_token) = cursor.peek(0)? {
+                        if let Some(peek_token) = cursor.peek(0, interner)? {
                             match peek_token.kind() {
                                 TokenKind::Punctuator(Punctuator::OpenBlock) => {
                                     let bindings = ObjectBindingPattern::new(
@@ -664,9 +706,9 @@ where
                                         self.allow_yield,
                                         self.allow_await,
                                     )
-                                    .parse(cursor)?;
+                                    .parse(cursor, interner)?;
 
-                                    if let Some(peek_token) = cursor.peek(0)? {
+                                    if let Some(peek_token) = cursor.peek(0, interner)? {
                                         match peek_token.kind() {
                                             TokenKind::Punctuator(Punctuator::Assign) => {
                                                 let init = Initializer::new(
@@ -674,7 +716,7 @@ where
                                                     self.allow_yield,
                                                     self.allow_await,
                                                 )
-                                                .parse(cursor)?;
+                                                .parse(cursor, interner)?;
                                                 patterns.push(
                                                     BindingPatternTypeObject::BindingPattern {
                                                         ident: property_name,
@@ -709,9 +751,9 @@ where
                                         self.allow_yield,
                                         self.allow_await,
                                     )
-                                    .parse(cursor)?;
+                                    .parse(cursor, interner)?;
 
-                                    if let Some(peek_token) = cursor.peek(0)? {
+                                    if let Some(peek_token) = cursor.peek(0, interner)? {
                                         match peek_token.kind() {
                                             TokenKind::Punctuator(Punctuator::Assign) => {
                                                 let init = Initializer::new(
@@ -719,7 +761,7 @@ where
                                                     self.allow_yield,
                                                     self.allow_await,
                                                 )
-                                                .parse(cursor)?;
+                                                .parse(cursor, interner)?;
                                                 patterns.push(
                                                     BindingPatternTypeObject::BindingPattern {
                                                         ident: property_name,
@@ -753,9 +795,9 @@ where
                                     //       Should parse https://tc39.es/ecma262/#prod-PropertyName
                                     let ident =
                                         BindingIdentifier::new(self.allow_yield, self.allow_await)
-                                            .parse(cursor)?;
+                                            .parse(cursor, interner)?;
 
-                                    if let Some(peek_token) = cursor.peek(0)? {
+                                    if let Some(peek_token) = cursor.peek(0, interner)? {
                                         match peek_token.kind() {
                                             TokenKind::Punctuator(Punctuator::Assign) => {
                                                 let init = Initializer::new(
@@ -763,7 +805,7 @@ where
                                                     self.allow_yield,
                                                     self.allow_await,
                                                 )
-                                                .parse(cursor)?;
+                                                .parse(cursor, interner)?;
                                                 patterns.push(
                                                     BindingPatternTypeObject::SingleName {
                                                         ident,
@@ -797,11 +839,12 @@ where
                 }
             }
 
-            if let Some(peek_token) = cursor.peek(0)? {
+            if let Some(peek_token) = cursor.peek(0, interner)? {
                 if let TokenKind::Punctuator(Punctuator::Comma) = peek_token.kind() {
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::Comma),
                         "object binding pattern",
+                        interner,
                     )?;
                 }
             }
@@ -863,23 +906,33 @@ where
 {
     type Output = Vec<BindingPatternTypeArray>;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ArrayBindingPattern", "Parsing");
 
         cursor.expect(
             TokenKind::Punctuator(Punctuator::OpenBracket),
             "array binding pattern",
+            interner,
         )?;
 
         let mut patterns = Vec::new();
         let mut last_elision_or_first = true;
 
         loop {
-            match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+            match cursor
+                .peek(0, interner)?
+                .ok_or(ParseError::AbruptEnd)?
+                .kind()
+            {
                 TokenKind::Punctuator(Punctuator::CloseBracket) => {
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::CloseBracket),
                         "array binding pattern",
+                        interner,
                     )?;
                     break;
                 }
@@ -887,6 +940,7 @@ where
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::Comma),
                         "array binding pattern",
+                        interner,
                     )?;
                     if last_elision_or_first {
                         patterns.push(BindingPatternTypeArray::Elision);
@@ -899,16 +953,21 @@ where
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::Spread),
                         "array binding pattern",
+                        interner,
                     )?;
 
-                    match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    match cursor
+                        .peek(0, interner)?
+                        .ok_or(ParseError::AbruptEnd)?
+                        .kind()
+                    {
                         TokenKind::Punctuator(Punctuator::OpenBlock) => {
                             let bindings = ObjectBindingPattern::new(
                                 self.allow_in,
                                 self.allow_yield,
                                 self.allow_await,
                             )
-                            .parse(cursor)?;
+                            .parse(cursor, interner)?;
                             patterns.push(BindingPatternTypeArray::BindingPatternRest {
                                 pattern: DeclarationPattern::Object(DeclarationPatternObject::new(
                                     bindings, None,
@@ -921,7 +980,7 @@ where
                                 self.allow_yield,
                                 self.allow_await,
                             )
-                            .parse(cursor)?;
+                            .parse(cursor, interner)?;
                             patterns.push(BindingPatternTypeArray::BindingPatternRest {
                                 pattern: DeclarationPattern::Array(DeclarationPatternArray::new(
                                     bindings, None,
@@ -931,7 +990,7 @@ where
                         _ => {
                             let rest_property_name =
                                 BindingIdentifier::new(self.allow_yield, self.allow_await)
-                                    .parse(cursor)?;
+                                    .parse(cursor, interner)?;
                             patterns.push(BindingPatternTypeArray::SingleNameRest {
                                 ident: rest_property_name,
                             });
@@ -941,6 +1000,7 @@ where
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::CloseBracket),
                         "array binding pattern",
+                        interner,
                     )?;
                     break;
                 }
@@ -952,13 +1012,17 @@ where
                         self.allow_yield,
                         self.allow_await,
                     )
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
-                    match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    match cursor
+                        .peek(0, interner)?
+                        .ok_or(ParseError::AbruptEnd)?
+                        .kind()
+                    {
                         TokenKind::Punctuator(Punctuator::Assign) => {
                             let default_init =
                                 Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                    .parse(cursor)?;
+                                    .parse(cursor, interner)?;
                             patterns.push(BindingPatternTypeArray::BindingPattern {
                                 pattern: DeclarationPattern::Object(DeclarationPatternObject::new(
                                     bindings,
@@ -980,13 +1044,17 @@ where
 
                     let bindings =
                         ArrayBindingPattern::new(self.allow_in, self.allow_yield, self.allow_await)
-                            .parse(cursor)?;
+                            .parse(cursor, interner)?;
 
-                    match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    match cursor
+                        .peek(0, interner)?
+                        .ok_or(ParseError::AbruptEnd)?
+                        .kind()
+                    {
                         TokenKind::Punctuator(Punctuator::Assign) => {
                             let default_init =
                                 Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                    .parse(cursor)?;
+                                    .parse(cursor, interner)?;
                             patterns.push(BindingPatternTypeArray::BindingPattern {
                                 pattern: DeclarationPattern::Array(DeclarationPatternArray::new(
                                     bindings,
@@ -1006,13 +1074,17 @@ where
                 _ => {
                     last_elision_or_first = false;
 
-                    let ident =
-                        BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
-                    match cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.kind() {
+                    let ident = BindingIdentifier::new(self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
+                    match cursor
+                        .peek(0, interner)?
+                        .ok_or(ParseError::AbruptEnd)?
+                        .kind()
+                    {
                         TokenKind::Punctuator(Punctuator::Assign) => {
                             let default_init =
                                 Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                    .parse(cursor)?;
+                                    .parse(cursor, interner)?;
                             patterns.push(BindingPatternTypeArray::SingleName {
                                 ident,
                                 default_init: Some(default_init),
@@ -1028,11 +1100,12 @@ where
                 }
             }
 
-            if let Some(peek_token) = cursor.peek(0)? {
+            if let Some(peek_token) = cursor.peek(0, interner)? {
                 if let TokenKind::Punctuator(Punctuator::Comma) = peek_token.kind() {
                     cursor.expect(
                         TokenKind::Punctuator(Punctuator::Comma),
                         "array binding pattern",
+                        interner,
                     )?;
                     if last_elision_or_first {
                         patterns.push(BindingPatternTypeArray::Elision);
diff --git a/boa/src/syntax/parser/statement/return_stm/mod.rs b/boa/src/syntax/parser/statement/return_stm/mod.rs
index 83e8e77e66b..cc79b8d77c8 100644
--- a/boa/src/syntax/parser/statement/return_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/return_stm/mod.rs
@@ -2,6 +2,7 @@
 mod tests;
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::Return, Keyword, Node, Punctuator},
@@ -50,14 +51,18 @@ where
 {
     type Output = Return;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ReturnStatement", "Parsing");
-        cursor.expect(Keyword::Return, "return statement")?;
+        cursor.expect(Keyword::Return, "return statement", interner)?;
 
-        if let SemicolonResult::Found(tok) = cursor.peek_semicolon()? {
+        if let SemicolonResult::Found(tok) = cursor.peek_semicolon(interner)? {
             match tok {
                 Some(tok) if tok.kind() == &TokenKind::Punctuator(Punctuator::Semicolon) => {
-                    let _ = cursor.next();
+                    let _ = cursor.next(interner)?;
                 }
                 _ => {}
             }
@@ -65,9 +70,10 @@ where
             return Ok(Return::new::<Node, Option<_>, Option<_>>(None, None));
         }
 
-        let expr = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let expr =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
-        cursor.expect_semicolon("return statement")?;
+        cursor.expect_semicolon("return statement", interner)?;
 
         Ok(Return::new(expr, None))
     }
diff --git a/boa/src/syntax/parser/statement/switch/mod.rs b/boa/src/syntax/parser/statement/switch/mod.rs
index 83a4532f99c..d5c987a031f 100644
--- a/boa/src/syntax/parser/statement/switch/mod.rs
+++ b/boa/src/syntax/parser/statement/switch/mod.rs
@@ -10,7 +10,7 @@ use crate::{
             Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -59,17 +59,23 @@ where
 {
     type Output = Switch;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("SwitchStatement", "Parsing");
-        cursor.expect(Keyword::Switch, "switch statement")?;
-        cursor.expect(Punctuator::OpenParen, "switch statement")?;
+        cursor.expect(Keyword::Switch, "switch statement", interner)?;
+        cursor.expect(Punctuator::OpenParen, "switch statement", interner)?;
 
-        let condition = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let condition =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
-        cursor.expect(Punctuator::CloseParen, "switch statement")?;
+        cursor.expect(Punctuator::CloseParen, "switch statement", interner)?;
 
         let (cases, default) =
-            CaseBlock::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+            CaseBlock::new(self.allow_yield, self.allow_await, self.allow_return)
+                .parse(cursor, interner)?;
 
         Ok(Switch::new(condition, cases, default))
     }
@@ -110,20 +116,24 @@ where
 {
     type Output = (Box<[node::Case]>, Option<node::StatementList>);
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        cursor.expect(Punctuator::OpenBlock, "switch case block")?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        cursor.expect(Punctuator::OpenBlock, "switch case block", interner)?;
 
         let mut cases = Vec::new();
         let mut default = None;
 
         loop {
-            match cursor.next()? {
+            match cursor.next(interner)? {
                 Some(token) if token.kind() == &TokenKind::Keyword(Keyword::Case) => {
                     // Case statement.
-                    let cond =
-                        Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+                    let cond = Expression::new(true, self.allow_yield, self.allow_await)
+                        .parse(cursor, interner)?;
 
-                    cursor.expect(Punctuator::Colon, "switch case block")?;
+                    cursor.expect(Punctuator::Colon, "switch case block", interner)?;
 
                     let statement_list = StatementList::new(
                         self.allow_yield,
@@ -132,7 +142,7 @@ where
                         false,
                         &CASE_BREAK_TOKENS,
                     )
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
                     cases.push(node::Case::new(cond, statement_list));
                 }
@@ -140,12 +150,13 @@ where
                     if default.is_some() {
                         // If default has already been defined then it cannot be defined again and to do so is an error.
                         return Err(ParseError::unexpected(
-                            token,
+                            token.to_string(interner),
+                            token.span(),
                             Some("more than one switch default"),
                         ));
                     }
 
-                    cursor.expect(Punctuator::Colon, "switch default block")?;
+                    cursor.expect(Punctuator::Colon, "switch default block", interner)?;
 
                     let statement_list = StatementList::new(
                         self.allow_yield,
@@ -154,7 +165,7 @@ where
                         false,
                         &CASE_BREAK_TOKENS,
                     )
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
                     default = Some(statement_list);
                 }
@@ -163,12 +174,9 @@ where
                 }
                 Some(token) => {
                     return Err(ParseError::expected(
-                        vec![
-                            TokenKind::Keyword(Keyword::Case),
-                            TokenKind::Keyword(Keyword::Default),
-                            TokenKind::Punctuator(Punctuator::CloseBlock),
-                        ],
-                        token,
+                        vec!["case", "default", "}"],
+                        token.to_string(interner),
+                        token.span(),
                         "switch case block",
                     ))
                 }
diff --git a/boa/src/syntax/parser/statement/switch/tests.rs b/boa/src/syntax/parser/statement/switch/tests.rs
index 18a6c52ceef..35517ee5b1b 100644
--- a/boa/src/syntax/parser/statement/switch/tests.rs
+++ b/boa/src/syntax/parser/statement/switch/tests.rs
@@ -1,12 +1,15 @@
-use crate::syntax::{
-    ast::{
-        node::{
-            Break, Call, Case, Declaration, DeclarationList, GetConstField, Identifier, Node,
-            Switch,
+use crate::{
+    syntax::{
+        ast::{
+            node::{
+                Break, Call, Case, Declaration, DeclarationList, GetConstField, Identifier, Node,
+                Switch,
+            },
+            Const,
         },
-        Const,
+        parser::tests::{check_invalid, check_parser},
     },
-    parser::tests::{check_invalid, check_parser},
+    Interner,
 };
 
 /// Checks parsing malformed switch with no closeblock.
@@ -148,6 +151,7 @@ fn check_seperated_switch() {
         }
         "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -193,5 +197,6 @@ fn check_seperated_switch() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
diff --git a/boa/src/syntax/parser/statement/throw/mod.rs b/boa/src/syntax/parser/statement/throw/mod.rs
index 14f3c711ecc..7bb5e1dd3bf 100644
--- a/boa/src/syntax/parser/statement/throw/mod.rs
+++ b/boa/src/syntax/parser/statement/throw/mod.rs
@@ -2,6 +2,7 @@
 mod tests;
 
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::Throw, Keyword, Punctuator},
@@ -46,16 +47,21 @@ where
 {
     type Output = Throw;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("ThrowStatement", "Parsing");
-        cursor.expect(Keyword::Throw, "throw statement")?;
+        cursor.expect(Keyword::Throw, "throw statement", interner)?;
 
-        cursor.peek_expect_no_lineterminator(0, "throw statement")?;
+        cursor.peek_expect_no_lineterminator(0, "throw statement", interner)?;
 
-        let expr = Expression::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
-        if let Some(tok) = cursor.peek(0)? {
+        let expr =
+            Expression::new(true, self.allow_yield, self.allow_await).parse(cursor, interner)?;
+        if let Some(tok) = cursor.peek(0, interner)? {
             if tok.kind() == &TokenKind::Punctuator(Punctuator::Semicolon) {
-                let _ = cursor.next();
+                let _ = cursor.next(interner).expect("token disappeared");
             }
         }
 
diff --git a/boa/src/syntax/parser/statement/throw/tests.rs b/boa/src/syntax/parser/statement/throw/tests.rs
index fad2603a72f..e21bcd63731 100644
--- a/boa/src/syntax/parser/statement/throw/tests.rs
+++ b/boa/src/syntax/parser/statement/throw/tests.rs
@@ -1,12 +1,17 @@
-use crate::syntax::{
-    ast::{node::Throw, Const},
-    parser::tests::check_parser,
+use crate::{
+    syntax::{
+        ast::{node::Throw, Const},
+        parser::tests::check_parser,
+    },
+    Interner,
 };
 
 #[test]
 fn check_throw_parsing() {
+    let mut interner = Interner::new();
     check_parser(
         "throw 'error';",
         vec![Throw::new(Const::from("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 8295b1ac5ec..bb239f344c0 100644
--- a/boa/src/syntax/parser/statement/try_stm/catch.rs
+++ b/boa/src/syntax/parser/statement/try_stm/catch.rs
@@ -12,7 +12,7 @@ use crate::{
             AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use rustc_hash::FxHashSet;
@@ -55,14 +55,18 @@ where
 {
     type Output = node::Catch;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Catch", "Parsing");
-        cursor.expect(Keyword::Catch, "try statement")?;
-        let catch_param = if cursor.next_if(Punctuator::OpenParen)?.is_some() {
+        cursor.expect(Keyword::Catch, "try statement", interner)?;
+        let catch_param = if cursor.next_if(Punctuator::OpenParen, interner)?.is_some() {
             let catch_param =
-                CatchParameter::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                CatchParameter::new(self.allow_yield, self.allow_await).parse(cursor, interner)?;
 
-            cursor.expect(Punctuator::CloseParen, "catch in try statement")?;
+            cursor.expect(Punctuator::CloseParen, "catch in try statement", interner)?;
             Some(catch_param)
         } else {
             None
@@ -88,8 +92,8 @@ where
         }
 
         // Catch block
-        let catch_block =
-            Block::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+        let catch_block = Block::new(self.allow_yield, self.allow_await, self.allow_return)
+            .parse(cursor, interner)?;
 
         // It is a Syntax Error if any element of the BoundNames of CatchParameter also occurs in the LexicallyDeclaredNames of Block.
         // It is a Syntax Error if any element of the BoundNames of CatchParameter also occurs in the VarDeclaredNames of Block.
@@ -155,28 +159,36 @@ where
 {
     type Output = node::Declaration;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        let token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        let token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match token.kind() {
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
                 let pat = ObjectBindingPattern::new(true, self.allow_yield, self.allow_await)
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
 
                 Ok(node::Declaration::new_with_object_pattern(pat, None))
             }
             TokenKind::Punctuator(Punctuator::OpenBracket) => {
                 let pat = ArrayBindingPattern::new(true, self.allow_yield, self.allow_await)
-                    .parse(cursor)?;
+                    .parse(cursor, interner)?;
                 Ok(node::Declaration::new_with_array_pattern(pat, None))
             }
             TokenKind::Identifier(_) => {
                 let ident = BindingIdentifier::new(self.allow_yield, self.allow_await)
-                    .parse(cursor)
+                    .parse(cursor, interner)
                     .map(Identifier::from)?;
                 Ok(node::Declaration::new_with_identifier(ident, None))
             }
-            _ => Err(ParseError::unexpected(token.clone(), None)),
+            _ => Err(ParseError::unexpected(
+                token.to_string(interner),
+                token.span(),
+                None,
+            )),
         }
     }
 }
diff --git a/boa/src/syntax/parser/statement/try_stm/finally.rs b/boa/src/syntax/parser/statement/try_stm/finally.rs
index 125d57df9dd..b0d090c7dea 100644
--- a/boa/src/syntax/parser/statement/try_stm/finally.rs
+++ b/boa/src/syntax/parser/statement/try_stm/finally.rs
@@ -6,7 +6,7 @@ use crate::{
             TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 
 use std::io::Read;
@@ -48,12 +48,16 @@ where
 {
     type Output = node::Finally;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Finally", "Parsing");
-        cursor.expect(Keyword::Finally, "try statement")?;
+        cursor.expect(Keyword::Finally, "try statement", interner)?;
         Ok(
             Block::new(self.allow_yield, self.allow_await, self.allow_return)
-                .parse(cursor)?
+                .parse(cursor, interner)?
                 .into(),
         )
     }
diff --git a/boa/src/syntax/parser/statement/try_stm/mod.rs b/boa/src/syntax/parser/statement/try_stm/mod.rs
index e554d48ea18..21f0eeaea2d 100644
--- a/boa/src/syntax/parser/statement/try_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/try_stm/mod.rs
@@ -8,6 +8,7 @@ use self::catch::Catch;
 use self::finally::Finally;
 use super::block::Block;
 use crate::syntax::lexer::TokenKind;
+use crate::Interner;
 use crate::{
     syntax::{
         ast::{node::Try, Keyword},
@@ -55,41 +56,46 @@ where
 {
     type Output = Try;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Try, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("TryStatement", "Parsing");
         // TRY
-        cursor.expect(Keyword::Try, "try statement")?;
+        cursor.expect(Keyword::Try, "try statement", interner)?;
 
-        let try_clause =
-            Block::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+        let try_clause = Block::new(self.allow_yield, self.allow_await, self.allow_return)
+            .parse(cursor, interner)?;
 
-        let next_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let next_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         if next_token.kind() != &TokenKind::Keyword(Keyword::Catch)
             && next_token.kind() != &TokenKind::Keyword(Keyword::Finally)
         {
             return Err(ParseError::expected(
-                vec![
-                    TokenKind::Keyword(Keyword::Catch),
-                    TokenKind::Keyword(Keyword::Finally),
-                ],
-                next_token.clone(),
+                vec!["catch", "finally"],
+                next_token.to_string(interner),
+                next_token.span(),
                 "try statement",
             ));
         }
 
         let catch = if next_token.kind() == &TokenKind::Keyword(Keyword::Catch) {
-            Some(Catch::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?)
+            Some(
+                Catch::new(self.allow_yield, self.allow_await, self.allow_return)
+                    .parse(cursor, interner)?,
+            )
         } else {
             None
         };
 
-        let next_token = cursor.peek(0)?;
+        let next_token = cursor.peek(0, interner)?;
         let finally_block = if let Some(token) = next_token {
             match token.kind() {
                 TokenKind::Keyword(Keyword::Finally) => Some(
                     Finally::new(self.allow_yield, self.allow_await, self.allow_return)
-                        .parse(cursor)?,
+                        .parse(cursor, interner)?,
                 ),
                 _ => None,
             }
diff --git a/boa/src/syntax/parser/statement/try_stm/tests.rs b/boa/src/syntax/parser/statement/try_stm/tests.rs
index 619fd805b48..51960e37729 100644
--- a/boa/src/syntax/parser/statement/try_stm/tests.rs
+++ b/boa/src/syntax/parser/statement/try_stm/tests.rs
@@ -1,16 +1,20 @@
-use crate::syntax::{
-    ast::{
-        node::{
-            declaration::{BindingPatternTypeArray, BindingPatternTypeObject},
-            Block, Catch, Declaration, DeclarationList, Finally, Try,
+use crate::{
+    syntax::{
+        ast::{
+            node::{
+                declaration::{BindingPatternTypeArray, BindingPatternTypeObject},
+                Block, Catch, Declaration, DeclarationList, Finally, Try,
+            },
+            Const,
         },
-        Const,
+        parser::tests::{check_invalid, check_parser},
     },
-    parser::tests::{check_invalid, check_parser},
+    Interner,
 };
 
 #[test]
 fn check_inline_with_empty_try_catch() {
+    let mut interner = Interner::new();
     check_parser(
         "try { } catch(e) {}",
         vec![Try::new(
@@ -22,11 +26,13 @@ fn check_inline_with_empty_try_catch() {
             None,
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_var_decl_inside_try() {
+    let mut interner = Interner::new();
     check_parser(
         "try { var x = 1; } catch(e) {}",
         vec![Try::new(
@@ -45,11 +51,13 @@ fn check_inline_with_var_decl_inside_try() {
             None,
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_var_decl_inside_catch() {
+    let mut interner = Interner::new();
     check_parser(
         "try { var x = 1; } catch(e) { var x = 1; }",
         vec![Try::new(
@@ -75,11 +83,13 @@ fn check_inline_with_var_decl_inside_catch() {
             None,
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_empty_try_catch_finally() {
+    let mut interner = Interner::new();
     check_parser(
         "try {} catch(e) {} finally {}",
         vec![Try::new(
@@ -91,19 +101,23 @@ fn check_inline_with_empty_try_catch_finally() {
             Some(Finally::from(vec![])),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_empty_try_finally() {
+    let mut interner = Interner::new();
     check_parser(
         "try {} finally {}",
         vec![Try::new(vec![], None, Some(Finally::from(vec![]))).into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_empty_try_var_decl_in_finally() {
+    let mut interner = Interner::new();
     check_parser(
         "try {} finally { var x = 1; }",
         vec![Try::new(
@@ -119,11 +133,13 @@ fn check_inline_with_empty_try_var_decl_in_finally() {
             .into()])),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_empty_try_paramless_catch() {
+    let mut interner = Interner::new();
     check_parser(
         "try {} catch { var x = 1; }",
         vec![Try::new(
@@ -142,11 +158,13 @@ fn check_inline_empty_try_paramless_catch() {
             None,
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_binding_pattern_object() {
+    let mut interner = Interner::new();
     check_parser(
         "try {} catch ({ a, b: c }) {}",
         vec![Try::new(
@@ -172,11 +190,13 @@ fn check_inline_with_binding_pattern_object() {
             None,
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn check_inline_with_binding_pattern_array() {
+    let mut interner = Interner::new();
     check_parser(
         "try {} catch ([a, b]) {}",
         vec![Try::new(
@@ -200,6 +220,7 @@ fn check_inline_with_binding_pattern_array() {
             None,
         )
         .into()],
+        &mut interner,
     );
 }
 
diff --git a/boa/src/syntax/parser/statement/variable/mod.rs b/boa/src/syntax/parser/statement/variable/mod.rs
index 975be821872..1751ebe3609 100644
--- a/boa/src/syntax/parser/statement/variable/mod.rs
+++ b/boa/src/syntax/parser/statement/variable/mod.rs
@@ -15,7 +15,7 @@ use crate::{
             AllowAwait, AllowIn, AllowYield, ParseError, TokenParser,
         },
     },
-    BoaProfiler,
+    BoaProfiler, Interner,
 };
 use std::io::Read;
 
@@ -55,14 +55,18 @@ where
 {
     type Output = DeclarationList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("VariableStatement", "Parsing");
-        cursor.expect(Keyword::Var, "variable statement")?;
+        cursor.expect(Keyword::Var, "variable statement", interner)?;
 
-        let decl_list =
-            VariableDeclarationList::new(true, self.allow_yield, self.allow_await).parse(cursor)?;
+        let decl_list = VariableDeclarationList::new(true, self.allow_yield, self.allow_await)
+            .parse(cursor, interner)?;
 
-        cursor.expect_semicolon("variable statement")?;
+        cursor.expect_semicolon("variable statement", interner)?;
 
         Ok(decl_list)
     }
@@ -109,20 +113,24 @@ where
 {
     type Output = DeclarationList;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
         let mut list = Vec::new();
 
         loop {
             list.push(
                 VariableDeclaration::new(self.allow_in, self.allow_yield, self.allow_await)
-                    .parse(cursor)?,
+                    .parse(cursor, interner)?,
             );
 
-            match cursor.peek_semicolon()? {
+            match cursor.peek_semicolon(interner)? {
                 SemicolonResult::NotFound(tk)
                     if tk.kind() == &TokenKind::Punctuator(Punctuator::Comma) =>
                 {
-                    let _ = cursor.next();
+                    let _ = cursor.next(interner).expect("token disappeared");
                 }
                 _ => break,
             }
@@ -167,20 +175,24 @@ where
 {
     type Output = Declaration;
 
-    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
-        let peek_token = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+    fn parse(
+        self,
+        cursor: &mut Cursor<R>,
+        interner: &mut Interner,
+    ) -> Result<Self::Output, ParseError> {
+        let peek_token = cursor.peek(0, interner)?.ok_or(ParseError::AbruptEnd)?;
 
         match peek_token.kind() {
             TokenKind::Punctuator(Punctuator::OpenBlock) => {
                 let bindings =
                     ObjectBindingPattern::new(self.allow_in, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
 
-                let init = if let Some(t) = cursor.peek(0)? {
+                let init = if let Some(t) = cursor.peek(0, interner)? {
                     if *t.kind() == TokenKind::Punctuator(Punctuator::Assign) {
                         Some(
                             Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                .parse(cursor)?,
+                                .parse(cursor, interner)?,
                         )
                     } else {
                         None
@@ -194,13 +206,13 @@ where
             TokenKind::Punctuator(Punctuator::OpenBracket) => {
                 let bindings =
                     ArrayBindingPattern::new(self.allow_in, self.allow_yield, self.allow_await)
-                        .parse(cursor)?;
+                        .parse(cursor, interner)?;
 
-                let init = if let Some(t) = cursor.peek(0)? {
+                let init = if let Some(t) = cursor.peek(0, interner)? {
                     if *t.kind() == TokenKind::Punctuator(Punctuator::Assign) {
                         Some(
                             Initializer::new(self.allow_in, self.allow_yield, self.allow_await)
-                                .parse(cursor)?,
+                                .parse(cursor, interner)?,
                         )
                     } else {
                         None
@@ -213,14 +225,14 @@ where
             }
 
             _ => {
-                let ident =
-                    BindingIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
+                let ident = BindingIdentifier::new(self.allow_yield, self.allow_await)
+                    .parse(cursor, interner)?;
 
-                let init = if let Some(t) = cursor.peek(0)? {
+                let init = if let Some(t) = cursor.peek(0, interner)? {
                     if *t.kind() == TokenKind::Punctuator(Punctuator::Assign) {
                         Some(
                             Initializer::new(true, self.allow_yield, self.allow_await)
-                                .parse(cursor)?,
+                                .parse(cursor, interner)?,
                         )
                     } else {
                         None
diff --git a/boa/src/syntax/parser/tests.rs b/boa/src/syntax/parser/tests.rs
index f0e88a4f3c5..d34ce8bd3da 100644
--- a/boa/src/syntax/parser/tests.rs
+++ b/boa/src/syntax/parser/tests.rs
@@ -1,26 +1,29 @@
 //! Tests for the parser.
 
 use super::Parser;
-use crate::syntax::ast::{
-    node::{
-        field::GetConstField, ArrowFunctionDecl, Assign, BinOp, Call, Declaration, DeclarationList,
-        FormalParameter, FunctionDecl, Identifier, If, New, Node, Object, PropertyDefinition,
-        Return, StatementList, UnaryOp,
+use crate::{
+    syntax::ast::{
+        node::{
+            field::GetConstField, ArrowFunctionDecl, Assign, BinOp, Call, Declaration,
+            DeclarationList, FormalParameter, FunctionDecl, Identifier, If, New, Node, Object,
+            PropertyDefinition, Return, StatementList, UnaryOp,
+        },
+        op::{self, CompOp, LogOp, NumOp},
+        Const,
     },
-    op::{self, CompOp, LogOp, NumOp},
-    Const,
+    Interner,
 };
 
 /// Checks that the given JavaScript string gives the expected expression.
 #[allow(clippy::unwrap_used)]
 #[track_caller]
-pub(super) fn check_parser<L>(js: &str, expr: L)
+pub(super) fn check_parser<L>(js: &str, expr: L, interner: &mut Interner)
 where
     L: Into<Box<[Node]>>,
 {
     assert_eq!(
         Parser::new(js.as_bytes(), false)
-            .parse_all()
+            .parse_all(interner)
             .expect("failed to parse"),
         StatementList::from(expr)
     );
@@ -29,12 +32,16 @@ where
 /// Checks that the given javascript string creates a parse error.
 #[track_caller]
 pub(super) fn check_invalid(js: &str) {
-    assert!(Parser::new(js.as_bytes(), false).parse_all().is_err());
+    let mut interner = Interner::new();
+    assert!(Parser::new(js.as_bytes(), false)
+        .parse_all(&mut interner)
+        .is_err());
 }
 
 /// Should be parsed as `new Class().method()` instead of `new (Class().method())`
 #[test]
 fn check_construct_call_precedence() {
+    let mut interner = Interner::new();
     check_parser(
         "new Date().getTime()",
         vec![Node::from(Call::new(
@@ -44,11 +51,13 @@ fn check_construct_call_precedence() {
             ),
             vec![],
         ))],
+        &mut interner,
     );
 }
 
 #[test]
 fn assign_operator_precedence() {
+    let mut interner = Interner::new();
     check_parser(
         "a = a + 1",
         vec![Assign::new(
@@ -56,11 +65,13 @@ fn assign_operator_precedence() {
             BinOp::new(NumOp::Add, Identifier::from("a"), Const::from(1)),
         )
         .into()],
+        &mut interner,
     );
 }
 
 #[test]
 fn hoisting() {
+    let mut interner = Interner::new();
     check_parser(
         r"
             var a = hello();
@@ -84,8 +95,10 @@ fn hoisting() {
             .into(),
             UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
         ],
+        &mut interner,
     );
 
+    let mut interner = Interner::new();
     check_parser(
         r"
             a = 10;
@@ -97,6 +110,7 @@ fn hoisting() {
             UnaryOp::new(op::UnaryOp::IncrementPost, Identifier::from("a")).into(),
             DeclarationList::Var(vec![Declaration::new_with_identifier("a", None)].into()).into(),
         ],
+        &mut interner,
     );
 }
 
@@ -104,6 +118,7 @@ fn hoisting() {
 fn ambigous_regex_divide_expression() {
     let s = "1 / a === 1 / b";
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![BinOp::new(
@@ -112,6 +127,7 @@ fn ambigous_regex_divide_expression() {
             BinOp::new(NumOp::Div, Const::Int(1), Identifier::from("b")),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -119,6 +135,7 @@ fn ambigous_regex_divide_expression() {
 fn two_divisions_in_expression() {
     let s = "a !== 0 || 1 / a === 1 / b;";
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![BinOp::new(
@@ -131,6 +148,7 @@ fn two_divisions_in_expression() {
             ),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -141,6 +159,7 @@ fn comment_semi_colon_insertion() {
     let b = 20;
     "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -161,6 +180,7 @@ fn comment_semi_colon_insertion() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
@@ -173,6 +193,7 @@ fn multiline_comment_semi_colon_insertion() {
     */ let b = 20;
     "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -193,6 +214,7 @@ fn multiline_comment_semi_colon_insertion() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
@@ -202,6 +224,7 @@ fn multiline_comment_no_lineterminator() {
     let a = 10; /* Test comment */ let b = 20;
     "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -222,6 +245,7 @@ fn multiline_comment_no_lineterminator() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
@@ -234,6 +258,7 @@ fn assignment_line_terminator() {
     5;
     "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -247,6 +272,7 @@ fn assignment_line_terminator() {
             .into(),
             Assign::new(Identifier::from("a"), Const::from(5)).into(),
         ],
+        &mut interner,
     );
 }
 
@@ -262,6 +288,7 @@ fn assignment_multiline_terminator() {
     5;
     "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -275,6 +302,7 @@ fn assignment_multiline_terminator() {
             .into(),
             Assign::new(Identifier::from("a"), Const::from(5)).into(),
         ],
+        &mut interner,
     );
 }
 
@@ -282,13 +310,15 @@ fn assignment_multiline_terminator() {
 fn bracketed_expr() {
     let s = r#"(b)"#;
 
-    check_parser(s, vec![Identifier::from("b").into()]);
+    let mut interner = Interner::new();
+    check_parser(s, vec![Identifier::from("b").into()], &mut interner);
 }
 
 #[test]
 fn increment_in_comma_op() {
     let s = r#"(b++, b)"#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![BinOp::new::<_, Node, Node>(
@@ -297,6 +327,7 @@ fn increment_in_comma_op() {
             Identifier::from("b").into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -314,6 +345,7 @@ fn spread_in_object() {
         PropertyDefinition::spread_object(Identifier::from("b")),
     ];
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![DeclarationList::Let(
@@ -324,6 +356,7 @@ fn spread_in_object() {
             .into(),
         )
         .into()],
+        &mut interner,
     );
 }
 
@@ -335,6 +368,7 @@ fn spread_in_arrow_function() {
     }
     "#;
 
+    let mut interner = Interner::new();
     check_parser(
         s,
         vec![
@@ -347,11 +381,13 @@ fn spread_in_arrow_function() {
             )
             .into(),
         ],
+        &mut interner,
     );
 }
 
 #[test]
 fn empty_statement() {
+    let mut interner = Interner::new();
     check_parser(
         r"
             ;;var a = 10;
@@ -373,31 +409,37 @@ fn empty_statement() {
                 None,
             )),
         ],
+        &mut interner,
     );
 }
 
 #[test]
 fn hashbang_use_strict_no_with() {
+    let mut interner = Interner::new();
     check_parser(
         r#"#!\"use strict"
         "#,
         vec![],
+        &mut interner,
     );
 }
 
 #[test]
 #[ignore]
 fn hashbang_use_strict_with_with_statement() {
+    let mut interner = Interner::new();
     check_parser(
         r#"#!\"use strict"
         
         with({}) {}
         "#,
         vec![],
+        &mut interner,
     );
 }
 
 #[test]
 fn hashbang_comment() {
-    check_parser(r"#!Comment Here", vec![]);
+    let mut interner = Interner::new();
+    check_parser(r"#!Comment Here", vec![], &mut interner);
 }