diff --git a/Cargo.lock b/Cargo.lock index 5ec9c48524..f268ead05b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -357,7 +357,6 @@ dependencies = [ "arbitrary", "bitflags 2.4.1", "boa_interner", - "boa_macros", "indexmap 2.1.0", "num-bigint", "rustc-hash", @@ -496,9 +495,9 @@ dependencies = [ "arbitrary", "boa_gc", "boa_macros", + "boa_types", "hashbrown 0.14.2", "indexmap 2.1.0", - "once_cell", "phf", "rustc-hash", "serde", @@ -531,7 +530,6 @@ dependencies = [ "bitflags 2.4.1", "boa_ast", "boa_interner", - "boa_macros", "boa_profiler", "fast-float", "icu_properties", diff --git a/boa_ast/Cargo.toml b/boa_ast/Cargo.toml index 40d371fc52..8f3db6b02d 100644 --- a/boa_ast/Cargo.toml +++ b/boa_ast/Cargo.toml @@ -17,7 +17,6 @@ temporal = [] [dependencies] boa_interner.workspace = true -boa_macros.workspace = true rustc-hash = { workspace = true, features = ["std"] } bitflags.workspace = true num-bigint.workspace = true diff --git a/boa_ast/src/expression/identifier.rs b/boa_ast/src/expression/identifier.rs index db4e024663..c9c316123e 100644 --- a/boa_ast/src/expression/identifier.rs +++ b/boa_ast/src/expression/identifier.rs @@ -1,9 +1,6 @@ //! Local identifier Expression. -use crate::{ - visitor::{VisitWith, Visitor, VisitorMut}, - ToStringEscaped, -}; +use crate::visitor::{VisitWith, Visitor, VisitorMut}; use boa_interner::{Interner, Sym, ToInternedString}; use core::ops::ControlFlow; @@ -83,11 +80,7 @@ impl Identifier { impl ToInternedString for Identifier { #[inline] fn to_interned_string(&self, interner: &Interner) -> String { - interner.resolve_expect(self.ident).join( - String::from, - ToStringEscaped::to_string_escaped, - true, - ) + interner.resolve_expect(self.ident).to_std_string_escaped() } } diff --git a/boa_ast/src/expression/literal/template.rs b/boa_ast/src/expression/literal/template.rs index 1bc6d487b7..ab280bc91b 100644 --- a/boa_ast/src/expression/literal/template.rs +++ b/boa_ast/src/expression/literal/template.rs @@ -1,15 +1,12 @@ //! Template literal Expression. -use core::ops::ControlFlow; -use std::borrow::Cow; - use boa_interner::{Interner, Sym, ToInternedString}; +use core::ops::ControlFlow; use crate::{ expression::Expression, try_break, visitor::{VisitWith, Visitor, VisitorMut}, - ToStringEscaped, }; /// Template literals are string literals allowing embedded expressions. @@ -72,11 +69,9 @@ impl ToInternedString for TemplateLiteral { for elt in &*self.elements { match elt { - TemplateElement::String(s) => buf.push_str(&interner.resolve_expect(*s).join( - Cow::Borrowed, - |utf16| Cow::Owned(utf16.to_string_escaped()), - true, - )), + TemplateElement::String(s) => { + buf.push_str(&interner.resolve_expect(*s).to_std_string_escaped()); + } TemplateElement::Expr(n) => { buf.push_str(&format!("${{{}}}", n.to_interned_string(interner))); } diff --git a/boa_ast/src/function/class.rs b/boa_ast/src/function/class.rs index c7375ae8d0..8fe77070dd 100644 --- a/boa_ast/src/function/class.rs +++ b/boa_ast/src/function/class.rs @@ -6,7 +6,7 @@ use crate::{ property::{MethodDefinition, PropertyName}, try_break, visitor::{VisitWith, Visitor, VisitorMut}, - Declaration, ToStringEscaped, + Declaration, }; use boa_interner::{Interner, Sym, ToIndentedString, ToInternedString}; use core::ops::ControlFlow; @@ -90,11 +90,7 @@ impl Class { impl ToIndentedString for Class { fn to_indented_string(&self, interner: &Interner, indent_n: usize) -> String { let class_name = self.name.map_or(Cow::Borrowed(""), |s| { - interner.resolve_expect(s.sym()).join( - Cow::Borrowed, - |utf16| Cow::Owned(utf16.to_string_escaped()), - true, - ) + Cow::Owned(interner.resolve_expect(s.sym()).to_std_string_escaped()) }); if self.elements.is_empty() && self.constructor().is_none() { return format!( diff --git a/boa_ast/src/keyword/mod.rs b/boa_ast/src/keyword/mod.rs index f1c36ec113..680e723122 100644 --- a/boa_ast/src/keyword/mod.rs +++ b/boa_ast/src/keyword/mod.rs @@ -11,7 +11,6 @@ use crate::expression::operator::binary::{BinaryOp, RelationalOp}; use boa_interner::Sym; -use boa_macros::utf16; use std::{convert::TryFrom, error, fmt, str::FromStr}; #[cfg(test)] @@ -491,49 +490,49 @@ impl Keyword { /// Gets the keyword as a tuple of strings. #[must_use] - pub const fn as_str(self) -> (&'static str, &'static [u16]) { + pub const fn as_str(self) -> &'static str { match self { - Self::Await => ("await", utf16!("await")), - Self::Async => ("async", utf16!("async")), - Self::Break => ("break", utf16!("break")), - Self::Case => ("case", utf16!("case")), - Self::Catch => ("catch", utf16!("catch")), - Self::Class => ("class", utf16!("class")), - Self::Continue => ("continue", utf16!("continue")), - Self::Const => ("const", utf16!("const")), - Self::Debugger => ("debugger", utf16!("debugger")), - Self::Default => ("default", utf16!("default")), - Self::Delete => ("delete", utf16!("delete")), - Self::Do => ("do", utf16!("do")), - Self::Else => ("else", utf16!("else")), - Self::Enum => ("enum", utf16!("enum")), - Self::Extends => ("extends", utf16!("extends")), - Self::Export => ("export", utf16!("export")), - Self::False => ("false", utf16!("false")), - Self::Finally => ("finally", utf16!("finally")), - Self::For => ("for", utf16!("for")), - Self::Function => ("function", utf16!("function")), - Self::If => ("if", utf16!("if")), - Self::In => ("in", utf16!("in")), - Self::InstanceOf => ("instanceof", utf16!("instanceof")), - Self::Import => ("import", utf16!("import")), - Self::Let => ("let", utf16!("let")), - Self::New => ("new", utf16!("new")), - Self::Null => ("null", utf16!("null")), - Self::Of => ("of", utf16!("of")), - Self::Return => ("return", utf16!("return")), - Self::Super => ("super", utf16!("super")), - Self::Switch => ("switch", utf16!("switch")), - Self::This => ("this", utf16!("this")), - Self::Throw => ("throw", utf16!("throw")), - Self::True => ("true", utf16!("true")), - Self::Try => ("try", utf16!("try")), - Self::TypeOf => ("typeof", utf16!("typeof")), - Self::Var => ("var", utf16!("var")), - Self::Void => ("void", utf16!("void")), - Self::While => ("while", utf16!("while")), - Self::With => ("with", utf16!("with")), - Self::Yield => ("yield", utf16!("yield")), + Self::Await => "await", + Self::Async => "async", + Self::Break => "break", + Self::Case => "case", + Self::Catch => "catch", + Self::Class => "class", + Self::Continue => "continue", + Self::Const => "const", + Self::Debugger => "debugger", + Self::Default => "default", + Self::Delete => "delete", + Self::Do => "do", + Self::Else => "else", + Self::Enum => "enum", + Self::Extends => "extends", + Self::Export => "export", + Self::False => "false", + Self::Finally => "finally", + Self::For => "for", + Self::Function => "function", + Self::If => "if", + Self::In => "in", + Self::InstanceOf => "instanceof", + Self::Import => "import", + Self::Let => "let", + Self::New => "new", + Self::Null => "null", + Self::Of => "of", + Self::Return => "return", + Self::Super => "super", + Self::Switch => "switch", + Self::This => "this", + Self::Throw => "throw", + Self::True => "true", + Self::Try => "try", + Self::TypeOf => "typeof", + Self::Var => "var", + Self::Void => "void", + Self::While => "while", + Self::With => "with", + Self::Yield => "yield", } } @@ -661,6 +660,6 @@ impl FromStr for Keyword { impl fmt::Display for Keyword { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::Display::fmt(self.as_str().0, f) + fmt::Display::fmt(self.as_str(), f) } } diff --git a/boa_ast/src/keyword/tests.rs b/boa_ast/src/keyword/tests.rs index 182f685e65..9ff01c2378 100644 --- a/boa_ast/src/keyword/tests.rs +++ b/boa_ast/src/keyword/tests.rs @@ -71,171 +71,130 @@ fn as_binary_op() { fn as_str() { for k in all_keywords() { match k.as_str() { - ("await", utf16) => { + "await" => { assert_eq!(k, Keyword::Await); - assert_eq!(utf16, utf16!("await")); } - ("async", utf16) => { + "async" => { assert_eq!(k, Keyword::Async); - assert_eq!(utf16, utf16!("async")); } - ("break", utf16) => { + "break" => { assert_eq!(k, Keyword::Break); - assert_eq!(utf16, utf16!("break")); } - ("case", utf16) => { + "case" => { assert_eq!(k, Keyword::Case); - assert_eq!(utf16, utf16!("case")); } - ("catch", utf16) => { + "catch" => { assert_eq!(k, Keyword::Catch); - assert_eq!(utf16, utf16!("catch")); } - ("class", utf16) => { + "class" => { assert_eq!(k, Keyword::Class); - assert_eq!(utf16, utf16!("class")); } - ("continue", utf16) => { + "continue" => { assert_eq!(k, Keyword::Continue); - assert_eq!(utf16, utf16!("continue")); } - ("const", utf16) => { + "const" => { assert_eq!(k, Keyword::Const); - assert_eq!(utf16, utf16!("const")); } - ("debugger", utf16) => { + "debugger" => { assert_eq!(k, Keyword::Debugger); - assert_eq!(utf16, utf16!("debugger")); } - ("default", utf16) => { + "default" => { assert_eq!(k, Keyword::Default); - assert_eq!(utf16, utf16!("default")); } - ("delete", utf16) => { + "delete" => { assert_eq!(k, Keyword::Delete); - assert_eq!(utf16, utf16!("delete")); } - ("do", utf16) => { + "do" => { assert_eq!(k, Keyword::Do); - assert_eq!(utf16, utf16!("do")); } - ("else", utf16) => { + "else" => { assert_eq!(k, Keyword::Else); - assert_eq!(utf16, utf16!("else")); } - ("enum", utf16) => { + "enum" => { assert_eq!(k, Keyword::Enum); - assert_eq!(utf16, utf16!("enum")); } - ("extends", utf16) => { + "extends" => { assert_eq!(k, Keyword::Extends); - assert_eq!(utf16, utf16!("extends")); } - ("export", utf16) => { + "export" => { assert_eq!(k, Keyword::Export); - assert_eq!(utf16, utf16!("export")); } - ("false", utf16) => { + "false" => { assert_eq!(k, Keyword::False); - assert_eq!(utf16, utf16!("false")); } - ("finally", utf16) => { + "finally" => { assert_eq!(k, Keyword::Finally); - assert_eq!(utf16, utf16!("finally")); } - ("for", utf16) => { + "for" => { assert_eq!(k, Keyword::For); - assert_eq!(utf16, utf16!("for")); } - ("function", utf16) => { + "function" => { assert_eq!(k, Keyword::Function); - assert_eq!(utf16, utf16!("function")); } - ("if", utf16) => { + "if" => { assert_eq!(k, Keyword::If); - assert_eq!(utf16, utf16!("if")); } - ("in", utf16) => { + "in" => { assert_eq!(k, Keyword::In); - assert_eq!(utf16, utf16!("in")); } - ("instanceof", utf16) => { + "instanceof" => { assert_eq!(k, Keyword::InstanceOf); - assert_eq!(utf16, utf16!("instanceof")); } - ("import", utf16) => { + "import" => { assert_eq!(k, Keyword::Import); - assert_eq!(utf16, utf16!("import")); } - ("let", utf16) => { + "let" => { assert_eq!(k, Keyword::Let); - assert_eq!(utf16, utf16!("let")); } - ("new", utf16) => { + "new" => { assert_eq!(k, Keyword::New); - assert_eq!(utf16, utf16!("new")); } - ("null", utf16) => { + "null" => { assert_eq!(k, Keyword::Null); - assert_eq!(utf16, utf16!("null")); } - ("of", utf16) => { + "of" => { assert_eq!(k, Keyword::Of); - assert_eq!(utf16, utf16!("of")); } - ("return", utf16) => { + "return" => { assert_eq!(k, Keyword::Return); - assert_eq!(utf16, utf16!("return")); } - ("super", utf16) => { + "super" => { assert_eq!(k, Keyword::Super); - assert_eq!(utf16, utf16!("super")); } - ("switch", utf16) => { + "switch" => { assert_eq!(k, Keyword::Switch); - assert_eq!(utf16, utf16!("switch")); } - ("this", utf16) => { + "this" => { assert_eq!(k, Keyword::This); - assert_eq!(utf16, utf16!("this")); } - ("throw", utf16) => { + "throw" => { assert_eq!(k, Keyword::Throw); - assert_eq!(utf16, utf16!("throw")); } - ("true", utf16) => { + "true" => { assert_eq!(k, Keyword::True); - assert_eq!(utf16, utf16!("true")); } - ("try", utf16) => { + "try" => { assert_eq!(k, Keyword::Try); - assert_eq!(utf16, utf16!("try")); } - ("typeof", utf16) => { + "typeof" => { assert_eq!(k, Keyword::TypeOf); - assert_eq!(utf16, utf16!("typeof")); } - ("var", utf16) => { + "var" => { assert_eq!(k, Keyword::Var); - assert_eq!(utf16, utf16!("var")); } - ("void", utf16) => { + "void" => { assert_eq!(k, Keyword::Void); - assert_eq!(utf16, utf16!("void")); } - ("while", utf16) => { + "while" => { assert_eq!(k, Keyword::While); - assert_eq!(utf16, utf16!("while")); } - ("with", utf16) => { + "with" => { assert_eq!(k, Keyword::With); - assert_eq!(utf16, utf16!("with")); } - ("yield", utf16) => { + "yield" => { assert_eq!(k, Keyword::Yield); - assert_eq!(utf16, utf16!("yield")); } - (_, _) => unreachable!("unknown keyword {k:?} found"), + _ => unreachable!("unknown keyword {k:?} found"), } } } @@ -341,7 +300,7 @@ fn try_into_binary_op() { #[test] fn from_str() { for k in all_keywords() { - let str = k.as_str().0; + let str = k.as_str(); assert_eq!(str.parse::().unwrap(), k); } diff --git a/boa_engine/src/bytecompiler/class.rs b/boa_engine/src/bytecompiler/class.rs index cd5a35c2bd..e671294566 100644 --- a/boa_engine/src/bytecompiler/class.rs +++ b/boa_engine/src/bytecompiler/class.rs @@ -269,7 +269,7 @@ impl ByteCompiler<'_, '_> { match name { PropertyName::Literal(name) => { self.emit_push_literal(Literal::String( - self.interner().resolve_expect(*name).into_common(false), + self.interner().resolve_expect(*name).into(), )); } PropertyName::Computed(name) => { diff --git a/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs b/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs index 946be8bae3..b491328e30 100644 --- a/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs +++ b/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs @@ -77,7 +77,7 @@ impl ByteCompiler<'_, '_> { for key in excluded_keys { self.emit_push_literal(Literal::String( - self.interner().resolve_expect(key.sym()).into_common(false), + self.interner().resolve_expect(key.sym()).into(), )); } @@ -98,7 +98,7 @@ impl ByteCompiler<'_, '_> { self.emit_opcode(Opcode::PushEmptyObject); for key in excluded_keys { self.emit_push_literal(Literal::String( - self.interner().resolve_expect(key.sym()).into_common(false), + self.interner().resolve_expect(key.sym()).into(), )); } self.emit( diff --git a/boa_engine/src/bytecompiler/declarations.rs b/boa_engine/src/bytecompiler/declarations.rs index bb6cb4b6f1..33fe1f746b 100644 --- a/boa_engine/src/bytecompiler/declarations.rs +++ b/boa_engine/src/bytecompiler/declarations.rs @@ -286,7 +286,7 @@ impl ByteCompiler<'_, '_> { let function = create_function_object_fast(code, self.context); // c. Perform ? env.CreateGlobalFunctionBinding(fn, fo, false). - let name = js_string!(self.interner().resolve_expect(name.sym()).utf16()); + let name = js_string!(self.interner().resolve_expect(name.sym())); self.context .create_global_function_binding(name, function, false)?; } @@ -454,12 +454,7 @@ impl ByteCompiler<'_, '_> { let private_identifiers = self.context.vm.environments.private_name_descriptions(); let private_identifiers = private_identifiers .into_iter() - .map(|ident| { - self.context - .interner() - .get(ident.as_str().as_str_ref()) - .expect("string should be in interner") - }) + .map(|ident| self.context.interner_mut().get_or_intern(ident.as_str())) .collect(); // 7. If AllPrivateIdentifiersValid of body with argument privateIdentifiers is false, throw a SyntaxError exception. diff --git a/boa_engine/src/bytecompiler/expression/mod.rs b/boa_engine/src/bytecompiler/expression/mod.rs index 51c5c3b1f8..a4ce2f4207 100644 --- a/boa_engine/src/bytecompiler/expression/mod.rs +++ b/boa_engine/src/bytecompiler/expression/mod.rs @@ -22,9 +22,9 @@ use boa_ast::{ impl ByteCompiler<'_, '_> { fn compile_literal(&mut self, lit: &AstLiteral, use_expr: bool) { match lit { - AstLiteral::String(v) => self.emit_push_literal(Literal::String( - self.interner().resolve_expect(*v).into_common(false), - )), + AstLiteral::String(v) => { + self.emit_push_literal(Literal::String(self.interner().resolve_expect(*v).into())); + } AstLiteral::Int(v) => self.emit_push_integer(*v), AstLiteral::Num(v) => self.emit_push_rational(*v), AstLiteral::BigInt(v) => { @@ -58,9 +58,8 @@ impl ByteCompiler<'_, '_> { fn compile_template_literal(&mut self, template_literal: &TemplateLiteral, use_expr: bool) { for element in template_literal.elements() { match element { - TemplateElement::String(s) => self.emit_push_literal(Literal::String( - self.interner().resolve_expect(*s).into_common(false), - )), + TemplateElement::String(s) => self + .emit_push_literal(Literal::String(self.interner().resolve_expect(*s).into())), TemplateElement::Expr(expr) => { self.compile_expr(expr, true); } @@ -269,13 +268,13 @@ impl ByteCompiler<'_, '_> { for (cooked, raw) in template.cookeds().iter().zip(template.raws()) { if let Some(cooked) = cooked { self.emit_push_literal(Literal::String( - self.interner().resolve_expect(*cooked).into_common(false), + self.interner().resolve_expect(*cooked).into(), )); } else { self.emit_opcode(Opcode::PushUndefined); } self.emit_push_literal(Literal::String( - self.interner().resolve_expect(*raw).into_common(false), + self.interner().resolve_expect(*raw).into(), )); } diff --git a/boa_engine/src/bytecompiler/mod.rs b/boa_engine/src/bytecompiler/mod.rs index ddce437535..41c0bf3e68 100644 --- a/boa_engine/src/bytecompiler/mod.rs +++ b/boa_engine/src/bytecompiler/mod.rs @@ -371,9 +371,9 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> { return *index; } - let string = self.interner().resolve_expect(name.sym()).utf16(); + let string = js_string!(self.interner().resolve_expect(name.sym())); let index = self.constants.len() as u32; - self.constants.push(Constant::String(js_string!(string))); + self.constants.push(Constant::String(string)); self.names_map.insert(name, index); index } @@ -1453,7 +1453,6 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> { .context .interner() .resolve_expect(self.function_name) - .utf16() .into(); CodeBlock { diff --git a/boa_engine/src/bytecompiler/module.rs b/boa_engine/src/bytecompiler/module.rs index c417c6b1a7..96ad1e8299 100644 --- a/boa_engine/src/bytecompiler/module.rs +++ b/boa_engine/src/bytecompiler/module.rs @@ -57,10 +57,7 @@ impl ByteCompiler<'_, '_> { self.compile_expr(expr, true); if expr.is_anonymous_function_definition() { - let default = self - .interner() - .resolve_expect(Sym::DEFAULT) - .into_common(false); + let default = self.interner().resolve_expect(Sym::DEFAULT).into(); self.emit_push_literal(Literal::String(default)); self.emit_opcode(Opcode::Swap); self.emit(Opcode::SetFunctionName, &[Operand::U8(0)]); diff --git a/boa_engine/src/context/mod.rs b/boa_engine/src/context/mod.rs index c3f8d95dee..ddf9c18213 100644 --- a/boa_engine/src/context/mod.rs +++ b/boa_engine/src/context/mod.rs @@ -617,7 +617,7 @@ impl Context<'_> { let global_object = self.realm().global_object().clone(); // 3. Let existingProp be ? globalObject.[[GetOwnProperty]](N). - let name = self.interner().resolve_expect(name.sym()).utf16().into(); + let name = JsString::from(self.interner().resolve_expect(name.sym())).into(); let existing_prop = global_object.__get_own_property__(&name, self)?; // 4. If existingProp is undefined, return ? IsExtensible(globalObject). @@ -654,7 +654,7 @@ impl Context<'_> { let global_object = self.realm().global_object().clone(); // 3. Let hasProperty be ? HasOwnProperty(globalObject, N). - let name = PropertyKey::from(self.interner().resolve_expect(name.sym()).utf16()); + let name = JsString::from(self.interner().resolve_expect(name.sym())); let has_property = global_object.has_own_property(name, self)?; // 4. If hasProperty is true, return true. @@ -682,7 +682,7 @@ impl Context<'_> { let global_object = self.realm().global_object().clone(); // 3. Let hasProperty be ? HasOwnProperty(globalObject, N). - let name = PropertyKey::from(self.interner().resolve_expect(name.sym()).utf16()); + let name = JsString::from(self.interner().resolve_expect(name.sym())); let has_property = global_object.has_own_property(name.clone(), self)?; // 4. Let extensible be ? IsExtensible(globalObject). @@ -773,8 +773,8 @@ impl Context<'_> { let global_object = self.realm().global_object().clone(); // 3. Let existingProp be ? globalObject.[[GetOwnProperty]](N). - let name = PropertyKey::from(self.interner().resolve_expect(name.sym()).utf16()); - let existing_prop = global_object.__get_own_property__(&name, self)?; + let name = JsString::from(self.interner().resolve_expect(name.sym())); + let existing_prop = global_object.__get_own_property__(&name.into(), self)?; // 4. If existingProp is undefined, return false. let Some(existing_prop) = existing_prop else { diff --git a/boa_engine/src/environments/runtime/mod.rs b/boa_engine/src/environments/runtime/mod.rs index f873dfd95f..774a72cde0 100644 --- a/boa_engine/src/environments/runtime/mod.rs +++ b/boa_engine/src/environments/runtime/mod.rs @@ -401,12 +401,12 @@ impl EnvironmentStack { } /// Return all private name descriptions in all private environments. - pub(crate) fn private_name_descriptions(&self) -> Vec<&JsString> { + pub(crate) fn private_name_descriptions(&self) -> Vec { let mut names = Vec::new(); for environment in self.private_stack.iter().rev() { for name in environment.descriptions() { - if !names.contains(&name) { - names.push(name); + if !names.contains(name) { + names.push(name.clone()); } } } @@ -523,10 +523,7 @@ impl Context<'_> { } Environment::Object(o) => { let o = o.clone(); - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); if o.has_property(key.clone(), self)? { if let Some(unscopables) = o.get(JsSymbol::unscopables(), self)?.as_object() { @@ -552,19 +549,13 @@ impl Context<'_> { /// Panics if the environment or binding index are out of range. pub(crate) fn is_initialized_binding(&mut self, locator: &BindingLocator) -> JsResult { if locator.global { - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); self.global_object().has_property(key, self) } else { match self.environment_expect(locator.environment_index) { Environment::Declarative(env) => Ok(env.get(locator.binding_index).is_some()), Environment::Object(obj) => { - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); obj.clone().has_property(key, self) } } @@ -579,10 +570,7 @@ impl Context<'_> { pub(crate) fn get_binding(&mut self, locator: BindingLocator) -> JsResult> { if locator.global { let global = self.global_object(); - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); if global.has_property(key.clone(), self)? { global.get(key, self).map(Some) } else { @@ -593,10 +581,7 @@ impl Context<'_> { Environment::Declarative(env) => Ok(env.get(locator.binding_index)), Environment::Object(obj) => { let obj = obj.clone(); - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); obj.get(key, self).map(Some) } } @@ -616,10 +601,7 @@ impl Context<'_> { strict: bool, ) -> JsResult<()> { if locator.global { - let key = self - .interner() - .resolve_expect(locator.name().sym()) - .into_common::(false); + let key: JsString = self.interner().resolve_expect(locator.name().sym()).into(); self.global_object().set(key, value, strict, self)?; } else { @@ -629,10 +611,7 @@ impl Context<'_> { } Environment::Object(obj) => { let obj = obj.clone(); - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); obj.set(key, value, strict, self)?; } @@ -651,20 +630,14 @@ impl Context<'_> { /// Panics if the environment or binding index are out of range. pub(crate) fn delete_binding(&mut self, locator: BindingLocator) -> JsResult { if locator.is_global() { - let key: JsString = self - .interner() - .resolve_expect(locator.name().sym()) - .into_common::(false); + let key: JsString = self.interner().resolve_expect(locator.name().sym()).into(); self.global_object().__delete__(&key.into(), self) } else { match self.environment_expect(locator.environment_index) { Environment::Declarative(_) => Ok(false), Environment::Object(obj) => { let obj = obj.clone(); - let key: JsString = self - .interner() - .resolve_expect(locator.name.sym()) - .into_common(false); + let key: JsString = self.interner().resolve_expect(locator.name.sym()).into(); obj.__delete__(&key.into(), self) } diff --git a/boa_engine/src/module/mod.rs b/boa_engine/src/module/mod.rs index 3a9cb30caa..ec67bc434a 100644 --- a/boa_engine/src/module/mod.rs +++ b/boa_engine/src/module/mod.rs @@ -181,11 +181,7 @@ impl Module { ) -> Self { let names: FxHashSet = export_names .iter() - .map(|string| { - context - .interner_mut() - .get_or_intern(string.as_str().as_str_ref()) - }) + .map(|string| context.interner_mut().get_or_intern(string.as_str())) .collect(); let realm = realm.unwrap_or_else(|| context.realm().clone()); let inner = Gc::new_cyclic(|weak| { @@ -594,15 +590,7 @@ impl ModuleNamespace { // 6. Let sortedExports be a List whose elements are the elements of exports ordered as if an Array of the same values had been sorted using %Array.prototype.sort% using undefined as comparefn. let mut exports = names .into_iter() - .map(|sym| { - ( - context - .interner() - .resolve_expect(sym) - .into_common::(false), - sym, - ) - }) + .map(|sym| (context.interner().resolve_expect(sym).into(), sym)) .collect::>(); exports.sort_keys(); diff --git a/boa_engine/src/module/source.rs b/boa_engine/src/module/source.rs index 9da65acac2..c55ba962f2 100644 --- a/boa_engine/src/module/source.rs +++ b/boa_engine/src/module/source.rs @@ -436,10 +436,8 @@ impl SourceTextModule { // 1. Perform HostLoadImportedModule(module, required, state.[[HostDefined]], state). // 2. NOTE: HostLoadImportedModule will call FinishLoadingImportedModule, which re-enters // the graph loading process through ContinueModuleLoading. - let name_specifier: JsString = context - .interner() - .resolve_expect(required) - .into_common(false); + let name_specifier: JsString = + context.interner().resolve_expect(required).into(); let src = self.clone(); let state = state.clone(); context.module_loader().load_imported_module( diff --git a/boa_engine/src/module/synthetic.rs b/boa_engine/src/module/synthetic.rs index 6c3683fd47..8a4c9267c4 100644 --- a/boa_engine/src/module/synthetic.rs +++ b/boa_engine/src/module/synthetic.rs @@ -359,9 +359,7 @@ impl SyntheticModule { export_value: JsValue, context: &mut Context<'_>, ) -> JsResult<()> { - let identifier = context - .interner_mut() - .get_or_intern(export_name.as_str().as_str_ref()); + let identifier = context.interner_mut().get_or_intern(export_name.as_str()); let identifier = Identifier::new(identifier); let environment = self diff --git a/boa_engine/src/optimizer/pass/constant_folding.rs b/boa_engine/src/optimizer/pass/constant_folding.rs index 818d2bf597..06620964e0 100644 --- a/boa_engine/src/optimizer/pass/constant_folding.rs +++ b/boa_engine/src/optimizer/pass/constant_folding.rs @@ -15,9 +15,7 @@ use boa_ast::{ fn literal_to_js_value(literal: &Literal, context: &mut Context<'_>) -> JsValue { match literal { - Literal::String(v) => JsValue::new(JsString::from( - context.interner().resolve_expect(*v).utf16(), - )), + Literal::String(v) => JsValue::new(JsString::from(context.interner().resolve_expect(*v))), Literal::Num(v) => JsValue::new(*v), Literal::Int(v) => JsValue::new(*v), Literal::BigInt(v) => JsValue::new(JsBigInt::new(v.clone())), @@ -32,11 +30,7 @@ fn js_value_to_literal(value: JsValue, context: &mut Context<'_>) -> Literal { JsValue::Null => Literal::Null, JsValue::Undefined => Literal::Undefined, JsValue::Boolean(v) => Literal::Bool(v), - JsValue::String(v) => Literal::String( - context - .interner_mut() - .get_or_intern(v.as_str().as_str_ref()), - ), + JsValue::String(v) => Literal::String(context.interner_mut().get_or_intern(v.as_str())), JsValue::Rational(v) => Literal::Num(v), JsValue::Integer(v) => Literal::Int(v), JsValue::BigInt(v) => Literal::BigInt(Box::new(v.as_inner().clone())), diff --git a/boa_engine/src/vm/opcode/call/mod.rs b/boa_engine/src/vm/opcode/call/mod.rs index e73a5dee85..11b6389204 100644 --- a/boa_engine/src/vm/opcode/call/mod.rs +++ b/boa_engine/src/vm/opcode/call/mod.rs @@ -299,9 +299,8 @@ impl Operation for ImportCall { panic!("referrer cannot be a synthetic module"); }; - let sym = context - .interner_mut() - .get_or_intern(specifier.as_str().as_str_ref()); + let sym = + context.interner_mut().get_or_intern(specifier.as_str()); let mut loaded_modules = src.loaded_modules().borrow_mut(); diff --git a/boa_interner/Cargo.toml b/boa_interner/Cargo.toml index 4bc9909d61..efdc42f64e 100644 --- a/boa_interner/Cargo.toml +++ b/boa_interner/Cargo.toml @@ -17,10 +17,10 @@ arbitrary = ["dep:arbitrary"] [dependencies] boa_macros.workspace = true boa_gc.workspace = true +boa_types.workspace = true phf = { workspace = true, default-features = false, features = ["macros"] } rustc-hash = { workspace = true, default-features = false } static_assertions.workspace = true -once_cell = { workspace = true, features = ["std"]} indexmap.workspace = true serde = { workspace = true, features = ["derive"], optional = true } arbitrary = { workspace = true, features = ["derive"], optional = true } diff --git a/boa_interner/src/fixed_string.rs b/boa_interner/src/fixed_string.rs deleted file mode 100644 index 745444906d..0000000000 --- a/boa_interner/src/fixed_string.rs +++ /dev/null @@ -1,80 +0,0 @@ -use alloc::vec::Vec; - -use crate::interned_str::InternedStr; - -#[derive(Debug)] -pub(super) struct FixedString { - inner: Vec, -} - -impl Default for FixedString { - fn default() -> Self { - Self { - inner: Vec::default(), - } - } -} - -impl FixedString { - /// Creates a new, pinned [`FixedString`]. - pub(super) fn new(capacity: usize) -> Self { - Self { - inner: Vec::with_capacity(capacity), - } - } - - /// Gets the maximum capacity of the [`FixedString`]. - pub(super) fn capacity(&self) -> usize { - self.inner.capacity() - } - - /// Returns `true` if the [`FixedString`] has length zero, - /// and `false` otherwise. - pub(super) fn is_empty(&self) -> bool { - self.inner.is_empty() - } -} - -impl FixedString -where - Char: Clone, -{ - /// Tries to push `string` to the [`FixedString`], and returns - /// an [`InternedStr`] pointer to the stored `string`, or - /// `None` if the capacity is not enough to store `string`. - /// - /// # Safety - /// - /// The caller is responsible for ensuring `self` outlives the returned - /// [`InternedStr`]. - pub(super) unsafe fn push(&mut self, string: &[Char]) -> Option> { - let capacity = self.inner.capacity(); - (capacity >= self.inner.len() + string.len()).then(|| { - // SAFETY: - // The caller is responsible for extending the lifetime - // of `self` to outlive the return value. - unsafe { self.push_unchecked(string) } - }) - } - - /// Pushes `string` to the [`FixedString`], and returns - /// an [`InternedStr`] pointer to the stored `string`, without - /// checking if the total `capacity` is enough to store `string`, - /// and without checking if the string is correctly aligned. - /// - /// # Safety - /// - /// The caller is responsible for ensuring that `self` outlives the returned - /// [`InternedStr`] and that it has enough capacity to store `string` without - /// reallocating. - pub(super) unsafe fn push_unchecked(&mut self, string: &[Char]) -> InternedStr { - let old_len = self.inner.len(); - self.inner.extend_from_slice(string); - - // SAFETY: The caller is responsible for extending the lifetime - // of `self` to outlive the return value, and for ensuring - // the alignment of `string` is correct. - let ptr = &self.inner[old_len..self.inner.len()]; - unsafe { InternedStr::new(ptr.into()) } - } -} diff --git a/boa_interner/src/interned_str.rs b/boa_interner/src/interned_str.rs deleted file mode 100644 index bdc58e68ff..0000000000 --- a/boa_interner/src/interned_str.rs +++ /dev/null @@ -1,80 +0,0 @@ -use core::{hash::Hash, ptr::NonNull}; - -/// Wrapper for an interned str pointer, required to -/// quickly check using a hash if a string is inside an [`Interner`][`super::Interner`]. -/// -/// # Safety -/// -/// This struct could cause Undefined Behaviour on: -/// - Use without ensuring the referenced memory is still allocated. -/// - Construction of an [`InternedStr`] from an invalid [`NonNull`] pointer. -/// - Construction of an [`InternedStr`] from a [`NonNull`] pointer -/// without checking if the pointed memory of the [`NonNull`] outlives -/// the [`InternedStr`]. -/// -/// In general, this should not be used outside of an [`Interner`][`super::Interner`]. -#[derive(Debug)] -pub(super) struct InternedStr { - ptr: NonNull<[Char]>, -} - -impl InternedStr { - /// Create a new interned string from the given `*const u8` pointer, - /// length and encoding kind - /// - /// # Safety - /// - /// Not maintaining the invariants specified on the struct definition - /// could cause Undefined Behaviour. - pub(super) const unsafe fn new(ptr: NonNull<[Char]>) -> Self { - Self { ptr } - } - - /// Returns a shared reference to the underlying string. - /// - /// # Safety - /// - /// Not maintaining the invariants specified on the struct definition - /// could cause Undefined Behaviour. - pub(super) unsafe fn as_ref(&self) -> &[Char] { - // SAFETY: - // The caller must ensure `ptr` is still valid throughout the - // lifetime of `self`. - unsafe { self.ptr.as_ref() } - } -} - -impl Clone for InternedStr { - fn clone(&self) -> Self { - *self - } -} - -impl Copy for InternedStr {} - -impl Eq for InternedStr where Char: Eq {} - -impl PartialEq for InternedStr -where - Char: PartialEq, -{ - fn eq(&self, other: &Self) -> bool { - // SAFETY: The caller must verify the invariants - // specified in the struct definition. - unsafe { self.as_ref() == other.as_ref() } - } -} - -impl Hash for InternedStr -where - Char: Hash, -{ - fn hash(&self, state: &mut H) { - // SAFETY: - // The caller must ensure `ptr` is still valid throughout the - // lifetime of `self`. - unsafe { - self.as_ref().hash(state); - } - } -} diff --git a/boa_interner/src/lib.rs b/boa_interner/src/lib.rs index 9ac053b421..193ac4b883 100644 --- a/boa_interner/src/lib.rs +++ b/boa_interner/src/lib.rs @@ -77,19 +77,27 @@ extern crate alloc; -mod fixed_string; -mod interned_str; -mod raw; mod sym; #[cfg(test)] mod tests; -use alloc::{borrow::Cow, format, string::String}; -use raw::RawInterner; +use alloc::{format, string::String}; +use boa_types::string::{ + common::{StaticJsStrings, RAW_STATICS}, + JsString, JsStringSlice, +}; +use alloc::vec::Vec; +use core::hash::BuildHasherDefault; +use hashbrown::{hash_map::Entry, HashMap}; +use rustc_hash::FxHasher; pub use sym::*; +pub use boa_types::js_string; + +type Map = HashMap>; + /// An enumeration of all slice types [`Interner`] can internally store. /// /// This struct allows us to intern either `UTF-8` or `UTF-16` str references, which are the two @@ -121,107 +129,47 @@ impl<'a, const N: usize> From<&'a [u16; N]> for JStrRef<'a> { } } -/// A double reference to an interned string inside [`Interner`]. -/// -/// [`JSInternedStrRef::utf8`] returns an [`Option`], since not every `UTF-16` string is fully -/// representable as a `UTF-8` string (because of unpaired surrogates). However, every `UTF-8` -/// string is representable as a `UTF-16` string, so `JSInternedStrRef::utf8` returns a -/// [&\[u16\]][core::slice]. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct JSInternedStrRef<'a, 'b> { - utf8: Option<&'a str>, - utf16: &'b [u16], +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct JSInternedStrRef { + inner: JsString, } -impl<'a, 'b> JSInternedStrRef<'a, 'b> { - /// Returns the inner reference to the interned string in `UTF-8` encoding. - /// if the string is not representable in `UTF-8`, returns [`None`] - #[inline] - #[must_use] - pub const fn utf8(&self) -> Option<&'a str> { - self.utf8 - } - - /// Returns the inner reference to the interned string in `UTF-16` encoding. - #[inline] - #[must_use] - pub const fn utf16(&self) -> &'b [u16] { - self.utf16 - } - - /// Joins the result of both possible strings into a common type. - /// - /// If `self` is representable by a `UTF-8` string and the `prioritize_utf8` argument is set, - /// it will prioritize calling `f`, and will only call `g` if `self` is only representable by a - /// `UTF-16` string. Otherwise, it will directly call `g`. - pub fn join(self, f: F, g: G, prioritize_utf8: bool) -> T - where - F: FnOnce(&'a str) -> T, - G: FnOnce(&'b [u16]) -> T, - { - if prioritize_utf8 { - if let Some(str) = self.utf8 { - return f(str); - } - } - g(self.utf16) +impl core::ops::Deref for JSInternedStrRef { + type Target = JsString; + fn deref(&self) -> &Self::Target { + &self.inner } +} - /// Same as [`join`][`JSInternedStrRef::join`], but where you can pass an additional context. - /// - /// Useful when you have a `&mut Context` context that cannot be borrowed by both closures at - /// the same time. - pub fn join_with_context(self, f: F, g: G, ctx: C, prioritize_utf8: bool) -> T - where - F: FnOnce(&'a str, C) -> T, - G: FnOnce(&'b [u16], C) -> T, - { - if prioritize_utf8 { - if let Some(str) = self.utf8 { - return f(str, ctx); - } - } - g(self.utf16, ctx) +impl From for JSInternedStrRef { + fn from(value: JsString) -> Self { + Self { inner: value } } +} - /// Converts both string types into a common type `C`. - /// - /// If `self` is representable by a `UTF-8` string and the `prioritize_utf8` argument is set, it - /// will prioritize converting its `UTF-8` representation first, and will only convert its - /// `UTF-16` representation if it is only representable by a `UTF-16` string. Otherwise, it will - /// directly convert its `UTF-16` representation. - pub fn into_common(self, prioritize_utf8: bool) -> C - where - C: From<&'a str> + From<&'b [u16]>, - { - self.join(Into::into, Into::into, prioritize_utf8) +impl From for JsString { + fn from(value: JSInternedStrRef) -> Self { + value.inner } } -impl core::fmt::Display for JSInternedStrRef<'_, '_> { +impl core::fmt::Display for JSInternedStrRef { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - self.join_with_context( - core::fmt::Display::fmt, - |js, f| { - char::decode_utf16(js.iter().copied()) - .map(|r| match r { - Ok(c) => String::from(c), - Err(e) => format!("\\u{:04X}", e.unpaired_surrogate()), - }) - .collect::() - .fmt(f) - }, - f, - true, - ) + char::decode_utf16(self.inner.iter()) + .map(|r| match r { + Ok(c) => String::from(c), + Err(e) => format!("\\u{:04X}", e.unpaired_surrogate()), + }) + .collect::() + .fmt(f) } } /// The string interner for Boa. #[derive(Debug, Default)] pub struct Interner { - utf8_interner: RawInterner, - utf16_interner: RawInterner, + symbol_cache: Map, + full: Vec, } impl Interner { @@ -235,10 +183,10 @@ impl Interner { /// Creates a new [`Interner`] with the specified capacity. #[inline] #[must_use] - pub fn with_capacity(capacity: usize) -> Self { + pub fn with_capacity(_capacity: usize) -> Self { Self { - utf8_interner: RawInterner::with_capacity(capacity), - utf16_interner: RawInterner::with_capacity(capacity), + symbol_cache: Map::default(), + full: Vec::new(), } } @@ -246,37 +194,14 @@ impl Interner { #[inline] #[must_use] pub fn len(&self) -> usize { - // `utf16_interner.len()` == `utf8_interner.len()`, - // so we can use any of them. - COMMON_STRINGS_UTF8.len() + self.utf16_interner.len() + self.full.len() } /// Returns `true` if the [`Interner`] contains no interned strings. #[inline] #[must_use] pub fn is_empty(&self) -> bool { - COMMON_STRINGS_UTF8.is_empty() && self.utf16_interner.is_empty() - } - - /// Returns the symbol for the given string if any. - /// - /// Can be used to query if a string has already been interned without interning. - pub fn get<'a, T>(&self, string: T) -> Option - where - T: Into>, - { - let string = string.into(); - Self::get_common(string).or_else(|| { - let index = match string { - JStrRef::Utf8(s) => self.utf8_interner.get(s.as_bytes()), - JStrRef::Utf16(s) => self.utf16_interner.get(s), - }; - // SAFETY: - // `get_or_intern/get_or_intern_static` already have checks to avoid returning indices - // that could cause overflows, meaning the indices returned by - // `idx + 1 + COMMON_STRINGS_UTF8.len()` cannot cause overflows. - unsafe { index.map(|i| Sym::new_unchecked(i + 1 + COMMON_STRINGS_UTF8.len())) } - }) + self.full.is_empty() } /// Interns the given string. @@ -288,116 +213,39 @@ impl Interner { /// If the interner already interns the maximum number of strings possible by the chosen symbol type. pub fn get_or_intern<'a, T>(&mut self, string: T) -> Sym where - T: Into>, + T: Into>, { - let string = string.into(); - self.get(string).unwrap_or_else(|| { - let (utf8, utf16) = match string { - JStrRef::Utf8(s) => ( - Some(Cow::Borrowed(s)), - Cow::Owned(s.encode_utf16().collect()), - ), - JStrRef::Utf16(s) => (String::from_utf16(s).ok().map(Cow::Owned), Cow::Borrowed(s)), - }; - - // We need a way to check for the strings that can be interned by `utf16_interner` but - // not by `utf8_interner` (since there are some UTF-16 strings with surrogates that are - // not representable in UTF-8), so we use the sentinel value `""` as a marker indicating - // that the `Sym` corresponding to that string is only available in `utf16_interner`. - // - // We don't need to worry about matches with `""` inside `get`, because - // `COMMON_STRINGS_UTF8` filters all the empty strings before interning. - let index = if let Some(utf8) = utf8 { - self.utf8_interner.intern(utf8.as_bytes()) - } else { - self.utf8_interner.intern_static(b"") - }; - - let utf16_index = self.utf16_interner.intern(&utf16); - - // Just to check everything is okay - assert_eq!(index, utf16_index); - - index - .checked_add(1 + COMMON_STRINGS_UTF8.len()) - .and_then(Sym::new) - .expect("Cannot intern new string: integer overflow") - }) - } + let string = JsString::from(string.into()); + if let Some(index) = string.as_static() { + return Sym::new(index + 1).expect("should not be zero"); + } + let next_index = self.full.len(); + match self.symbol_cache.entry(string.clone()) { + Entry::Occupied(entry) => { + return Sym::new(*entry.get() + 1 + RAW_STATICS.len()).expect("should not be zero"); + } + Entry::Vacant(entry) => { + entry.insert(next_index); + } + } - /// Interns the given `'static` string. - /// - /// Returns a symbol for resolution into the original string. - /// - /// # Note - /// - /// This is more efficient than [`Interner::get_or_intern`], since it avoids allocating space - /// for one `string` inside the [`Interner`], with the disadvantage that you need to provide - /// both the `UTF-8` and the `UTF-16` representation of the string. - /// - /// # Panics - /// - /// If the interner already interns the maximum number of strings possible by the chosen symbol type. - pub fn get_or_intern_static(&mut self, utf8: &'static str, utf16: &'static [u16]) -> Sym { - // Uses the utf8 because it's quicker to check inside `COMMON_STRINGS_UTF8` - // (which is a perfect hash set) than to check inside `COMMON_STRINGS_UTF16` - // (which is a lazy static hash set). - self.get(utf8).unwrap_or_else(|| { - let index = self.utf8_interner.intern(utf8.as_bytes()); - let utf16_index = self.utf16_interner.intern(utf16); - - // Just to check everything is okay - debug_assert_eq!(index, utf16_index); - - index - .checked_add(1 + COMMON_STRINGS_UTF8.len()) - .and_then(Sym::new) - .expect("Cannot intern new string: integer overflow") - }) + self.full.push(string); + + Sym::new(next_index + 1 + RAW_STATICS.len()).expect("should not be zero") } /// Returns the string for the given symbol if any. - /// - /// # Panics - /// - /// Panics if the size of both statics is not equal or the interners do - /// not have the same size #[must_use] - pub fn resolve(&self, symbol: Sym) -> Option> { - let index = symbol.get() - 1; - - if let Some(utf8) = COMMON_STRINGS_UTF8.index(index).copied() { - let utf16 = COMMON_STRINGS_UTF16 - .get_index(index) - .copied() - .expect("The sizes of both statics must be equal"); - return Some(JSInternedStrRef { - utf8: Some(utf8), - utf16, - }); - } + pub fn resolve(&self, sym: Sym) -> Option { + let index = sym.get() - 1; - let index = index - COMMON_STRINGS_UTF8.len(); - - if let Some(utf16) = self.utf16_interner.index(index) { - let index = index - (self.utf16_interner.len() - self.utf8_interner.len()); - // SAFETY: - // We only manipulate valid UTF-8 `str`s and convert them to `[u8]` for convenience, - // so converting back to a `str` is safe. - let utf8 = unsafe { - core::str::from_utf8_unchecked( - self.utf8_interner - .index(index) - .expect("both interners must have the same size"), - ) - }; - return Some(JSInternedStrRef { - utf8: if utf8.is_empty() { None } else { Some(utf8) }, - utf16, - }); + if index < RAW_STATICS.len() { + return StaticJsStrings::get_string(StaticJsStrings::get(index)?).map(Into::into); } - None + let index = index - RAW_STATICS.len(); + + self.full.get(index).cloned().map(Into::into) } /// Returns the string for the given symbol. @@ -407,27 +255,9 @@ impl Interner { /// If the interner cannot resolve the given symbol. #[inline] #[must_use] - pub fn resolve_expect(&self, symbol: Sym) -> JSInternedStrRef<'_, '_> { + pub fn resolve_expect(&self, symbol: Sym) -> JSInternedStrRef { self.resolve(symbol).expect("string disappeared") } - - /// Gets the symbol of the common string if one of them - fn get_common(string: JStrRef<'_>) -> Option { - match string { - JStrRef::Utf8(s) => COMMON_STRINGS_UTF8.get_index(s).map(|idx| { - // SAFETY: `idx >= 0`, since it's an `usize`, and `idx + 1 > 0`. - // In this case, we don't need to worry about overflows because we have a static - // assertion in place checking that `COMMON_STRINGS.len() < usize::MAX`. - unsafe { Sym::new_unchecked(idx + 1) } - }), - JStrRef::Utf16(s) => COMMON_STRINGS_UTF16.get_index_of(&s).map(|idx| { - // SAFETY: `idx >= 0`, since it's an `usize`, and `idx + 1 > 0`. - // In this case, we don't need to worry about overflows because we have a static - // assertion in place checking that `COMMON_STRINGS.len() < usize::MAX`. - unsafe { Sym::new_unchecked(idx + 1) } - }), - } - } } /// Implements the display formatting with indentation. diff --git a/boa_interner/src/raw.rs b/boa_interner/src/raw.rs deleted file mode 100644 index fdf9162e15..0000000000 --- a/boa_interner/src/raw.rs +++ /dev/null @@ -1,194 +0,0 @@ -use crate::{fixed_string::FixedString, interned_str::InternedStr}; -use alloc::vec::Vec; -use core::hash::{BuildHasherDefault, Hash}; -use hashbrown::HashMap; -use rustc_hash::FxHasher; - -type Map = HashMap>; - -/// Raw string interner, generic by a char type. -#[derive(Debug)] -pub(super) struct RawInterner { - // COMMENT FOR DEVS: - // This interner works on the assumption that - // `head` won't ever be reallocated, since this could invalidate - // some of our stored pointers inside `spans`. - // This means that any operation on `head` and `full` should be carefully - // reviewed to not cause Undefined Behaviour. - // `intern` has a more thorough explanation on this. - // - // Also, if you want to implement `shrink_to_fit` (and friends), - // please check out https://github.com/Robbepop/string-interner/pull/47 first. - // This doesn't implement that method, since implementing it increases - // our memory footprint. - symbol_cache: Map, usize>, - spans: Vec>, - head: FixedString, - full: Vec>, -} - -impl Default for RawInterner { - fn default() -> Self { - Self { - symbol_cache: Map::default(), - spans: Vec::default(), - head: FixedString::default(), - full: Vec::default(), - } - } -} - -impl RawInterner { - /// Creates a new `RawInterner` with the specified capacity. - pub(super) fn with_capacity(capacity: usize) -> Self { - Self { - symbol_cache: Map::default(), - spans: Vec::with_capacity(capacity), - head: FixedString::new(capacity), - full: Vec::new(), - } - } - - /// Returns the number of strings interned by the interner. - pub(super) fn len(&self) -> usize { - self.spans.len() - } - - /// Returns `true` if the interner contains no interned strings. - pub(super) fn is_empty(&self) -> bool { - self.spans.is_empty() - } -} - -impl RawInterner -where - Char: Hash + Eq, -{ - /// Returns the index position for the given string if any. - /// - /// Can be used to query if a string has already been interned without interning. - pub(super) fn get(&self, string: &[Char]) -> Option { - // SAFETY: - // `string` is a valid slice that doesn't outlive the - // created `InternedStr`, so this is safe. - unsafe { - self.symbol_cache - .get(&InternedStr::new(string.into())) - .copied() - } - } - - /// Interns the given `'static` string. - /// - /// Returns the index of `string` within the interner. - /// - /// # Note - /// - /// This is more efficient than [`RawInterner::intern`], since it - /// avoids storing `string` inside the interner. - /// - /// # Panics - /// - /// If the interner already interns the maximum number of strings possible - /// by the chosen symbol type. - pub(super) fn intern_static(&mut self, string: &'static [Char]) -> usize { - // SAFETY: - // A static string reference is always valid, meaning it cannot outlive - // the lifetime of the created `InternedStr`. This makes this - // operation safe. - let string = unsafe { InternedStr::new(string.into()) }; - - // SAFETY: - // A `InternedStr` created from a static reference - // cannot be invalidated by allocations and deallocations, - // so this is safe. - unsafe { self.next_index(string) } - } - - /// Returns the string for the given index if any. - pub(super) fn index(&self, index: usize) -> Option<&[Char]> { - self.spans.get(index).map(|ptr| - // SAFETY: We always ensure the stored `InternedStr`s always - // reference memory inside `head` and `full` - unsafe {ptr.as_ref()}) - } - - /// Inserts a new string pointer into `spans` and returns its index. - /// - /// # Safety - /// - /// The caller must ensure `string` points to a valid - /// memory inside `head` (or only valid in the case of statics) - /// and that it won't be invalidated by allocations and deallocations. - unsafe fn next_index(&mut self, string: InternedStr) -> usize { - let next = self.len(); - self.spans.push(string); - self.symbol_cache.insert(string, next); - next - } -} - -impl RawInterner -where - Char: Hash + Eq + Clone, -{ - /// Interns the given string. - /// - /// Returns the index of `string` within the interner. - /// - /// # Panics - /// - /// If the interner already interns the maximum number of strings possible by the chosen symbol type. - pub(super) fn intern(&mut self, string: &[Char]) -> usize { - // SAFETY: - // - // Firstly, this interner works on the assumption that the allocated - // memory by `head` won't ever be moved from its position on the heap, - // which is an important point to understand why manipulating it like - // this is safe. - // - // `String` (which is simply a `Vec` with additional invariants) - // is essentially a pointer to heap memory that can be moved without - // any problems, since copying a pointer cannot invalidate the memory - // that it points to. - // - // However, `String` CAN be invalidated when pushing, extending or - // shrinking it, since all those operations reallocate on the heap. - // - // To prevent that, we HAVE to ensure the capacity will succeed without - // having to reallocate, and the only way to do that without invalidating - // any other alive `InternedStr` is to create a brand new `head` with - // enough capacity and push the old `head` to `full` to keep it alive - // throughout the lifetime of the whole interner. - // - // `FixedString` encapsulates this by only allowing checked `push`es - // to the internal string, but we still have to ensure the memory - // of `head` is not deallocated until the whole interner deallocates, - // which we can do by moving it inside the interner itself, specifically - // on the `full` vector, where every other old `head` also lives. - let interned_str = unsafe { - self.head.push(string).unwrap_or_else(|| { - let new_cap = - (usize::max(self.head.capacity(), string.len()) + 1).next_power_of_two(); - let new_head = FixedString::new(new_cap); - let old_head = core::mem::replace(&mut self.head, new_head); - - // If the user creates an `Interner` - // with `Interner::with_capacity(BIG_NUMBER)` and - // the first interned string's length is bigger than `BIG_NUMBER`, - // `self.full.push(old_head)` would push a big, empty string of - // allocated size `BIG_NUMBER` into `full`. - // This prevents that case. - if !old_head.is_empty() { - self.full.push(old_head); - } - self.head.push_unchecked(string) - }) - }; - - // SAFETY: We are obtaining a pointer to the internal memory of - // `head`, which is alive through the whole life of the interner, so - // this is safe. - unsafe { self.next_index(interned_str) } - } -} diff --git a/boa_interner/src/tests.rs b/boa_interner/src/tests.rs index 3a79668da3..f1ecd822af 100644 --- a/boa_interner/src/tests.rs +++ b/boa_interner/src/tests.rs @@ -1,4 +1,4 @@ -use crate::{Interner, Sym, COMMON_STRINGS_UTF16, COMMON_STRINGS_UTF8}; +use crate::{Interner, Sym, COMMON_STRINGS_UTF8}; use boa_macros::utf16; #[track_caller] @@ -34,13 +34,13 @@ fn check_resolve() { for (s8, s16) in utf_8_strings.zip(utf_16_strings) { let sym = interner.get_or_intern(s8); let resolved = interner.resolve(sym).unwrap(); - assert_eq!(Some(s8), resolved.utf8()); + assert_eq!(s8, &*resolved); let new_sym = interner.get_or_intern(s8); assert_eq!(sym, new_sym); let sym = interner.get_or_intern(s16); let resolved = interner.resolve(sym).unwrap(); - assert_eq!(s16, resolved.utf16()); + assert_eq!(s16, &*resolved); let new_sym = interner.get_or_intern(s16); assert_eq!(sym, new_sym); } @@ -50,26 +50,16 @@ fn check_resolve() { fn check_static_resolve() { let mut interner = Interner::default(); - for (utf8, utf16) in COMMON_STRINGS_UTF8 + for string in COMMON_STRINGS_UTF8 .into_iter() .copied() - .zip(COMMON_STRINGS_UTF16.iter().copied()) - .chain( - [ - ("my test str", utf16!("my test str")), - ("hello world", utf16!("hello world")), - (";", utf16!(";")), - ] - .into_iter(), - ) + .chain(["my test str", "hello world", ";"].into_iter()) { - let sym = interner.get_or_intern_static(utf8, utf16); + let sym = interner.get_or_intern(string); let resolved = interner.resolve(sym).unwrap(); - assert_eq!(Some(utf8), resolved.utf8()); - assert_eq!(utf16, resolved.utf16()); - - let new_sym = interner.get_or_intern(utf8); + assert_eq!(string, &*resolved); + let new_sym = interner.get_or_intern(string); assert_eq!(sym, new_sym); } } @@ -88,29 +78,18 @@ fn check_unpaired_surrogates() { let sym = interner.get_or_intern("abc"); let sym2 = interner.get_or_intern("def"); - let sym3 = interner.get_or_intern(unp); - let sym4 = interner.get_or_intern(utf16!("ghi")); - let sym5 = interner.get_or_intern(unp2); + let sym3 = interner.get_or_intern(&unp[..]); + let sym4 = interner.get_or_intern("ghi"); + let sym5 = interner.get_or_intern(&unp2[..]); let sym6 = interner.get_or_intern("jkl"); - assert_eq!(interner.resolve_expect(sym).utf8(), Some("abc")); - assert_eq!(interner.resolve_expect(sym).utf16(), utf16!("abc")); - - assert_eq!(interner.resolve_expect(sym2).utf8(), Some("def")); - assert_eq!(interner.resolve_expect(sym2).utf16(), utf16!("def")); - - assert!(interner.resolve_expect(sym3).utf8().is_none()); - assert_eq!(interner.resolve_expect(sym3).utf16(), unp); - - assert_eq!(interner.resolve_expect(sym4).utf8(), Some("ghi")); - assert_eq!(interner.resolve_expect(sym4).utf16(), utf16!("ghi")); - - assert!(interner.resolve_expect(sym5).utf8().is_none()); - assert_eq!(interner.resolve_expect(sym5).utf16(), unp2); - - assert_eq!(interner.resolve_expect(sym6).utf8(), Some("jkl")); - assert_eq!(interner.resolve_expect(sym6).utf16(), utf16!("jkl")); + assert_eq!(&*interner.resolve_expect(sym), "abc"); + assert_eq!(&*interner.resolve_expect(sym2), "def"); + assert_eq!(&*interner.resolve_expect(sym3), &unp[..]); + assert_eq!(&*interner.resolve_expect(sym4), "ghi"); + assert_eq!(&*interner.resolve_expect(sym5), &unp2[..]); + assert_eq!(&*interner.resolve_expect(sym6), "jkl"); } #[test] diff --git a/boa_macros/src/lib.rs b/boa_macros/src/lib.rs index c56fb5f1e0..d9727601d6 100644 --- a/boa_macros/src/lib.rs +++ b/boa_macros/src/lib.rs @@ -178,26 +178,6 @@ pub fn static_syms(input: TokenStream) -> TokenStream { ::static_assertions::const_assert!(COMMON_STRINGS.len() < usize::MAX); COMMON_STRINGS }; - - /// Ordered set of commonly used static `UTF-16` strings. - /// - /// # Note - /// - /// `COMMON_STRINGS_UTF8`, `COMMON_STRINGS_UTF16` and the constants - /// defined in [`Sym`] must always be in sync. - // FIXME: use phf when const expressions are allowed. - // - pub(super) static COMMON_STRINGS_UTF16: ::once_cell::sync::Lazy> = - ::once_cell::sync::Lazy::new(|| { - let mut set = Set::with_capacity_and_hasher( - COMMON_STRINGS_UTF8.len(), - ::core::hash::BuildHasherDefault::default() - ); - #( - set.insert(::boa_macros::utf16!(#literals)); - )* - set - }); }; quote! { diff --git a/boa_parser/Cargo.toml b/boa_parser/Cargo.toml index 3ca20507b2..b6b3d7d305 100644 --- a/boa_parser/Cargo.toml +++ b/boa_parser/Cargo.toml @@ -12,7 +12,6 @@ rust-version.workspace = true [dependencies] boa_interner.workspace = true -boa_macros.workspace = true boa_ast.workspace = true boa_profiler.workspace = true rustc-hash = { workspace = true, features = ["std"] } diff --git a/boa_parser/src/lexer/tests.rs b/boa_parser/src/lexer/tests.rs index ff363d2621..046da342a7 100644 --- a/boa_parser/src/lexer/tests.rs +++ b/boa_parser/src/lexer/tests.rs @@ -7,7 +7,6 @@ use crate::lexer::{ }; use boa_ast::Keyword; use boa_interner::Sym; -use boa_macros::utf16; use std::str; fn span(start: (u32, u32), end: (u32, u32)) -> Span { @@ -66,7 +65,7 @@ fn check_multi_line_comment() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("x", utf16!("x")); + let sym = interner.get_or_intern("x"); let expected = [ TokenKind::Keyword((Keyword::Var, false)), TokenKind::LineTerminator, @@ -83,29 +82,18 @@ fn check_identifier() { let interner = &mut Interner::default(); let expected = [ - TokenKind::identifier(interner.get_or_intern_static("x", utf16!("x"))), - TokenKind::identifier(interner.get_or_intern_static("x1", utf16!("x1"))), - TokenKind::identifier(interner.get_or_intern_static("_x", utf16!("_x"))), - TokenKind::identifier(interner.get_or_intern_static("$x", utf16!("$x"))), - TokenKind::identifier(interner.get_or_intern_static("__", utf16!("__"))), - TokenKind::identifier(interner.get_or_intern_static("$$", utf16!("$$"))), - TokenKind::identifier(interner.get_or_intern_static("Ѐ", utf16!("Ѐ"))), - TokenKind::identifier(interner.get_or_intern_static("ЀЀ", utf16!("ЀЀ"))), - TokenKind::identifier( - interner.get_or_intern_static("x\u{200C}\u{200D}", utf16!("x\u{200C}\u{200D}")), - ), - TokenKind::IdentifierName(( - interner.get_or_intern_static("x", utf16!("x")), - ContainsEscapeSequence(true), - )), - TokenKind::IdentifierName(( - interner.get_or_intern_static("xx", utf16!("xx")), - ContainsEscapeSequence(true), - )), - TokenKind::IdentifierName(( - interner.get_or_intern_static("xxx", utf16!("xxx")), - ContainsEscapeSequence(true), - )), + 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::IdentifierName((interner.get_or_intern("x"), ContainsEscapeSequence(true))), + TokenKind::IdentifierName((interner.get_or_intern("xx"), ContainsEscapeSequence(true))), + TokenKind::IdentifierName((interner.get_or_intern("xxx"), ContainsEscapeSequence(true))), ]; expect_tokens(&mut lexer, &expected, interner); @@ -129,7 +117,7 @@ fn check_invalid_identifier_part() { let invalid_identifier_parts = [" ", "\n", ".", "*", "😀", "\u{007F}"]; let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("x", utf16!("x")); + let sym = interner.get_or_intern("x"); for part in &invalid_identifier_parts { let s = String::from("x") + part; let mut lexer = Lexer::new(s.as_bytes()); @@ -147,8 +135,8 @@ fn check_string() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let a_sym = interner.get_or_intern_static("aaa", utf16!("aaa")); - let b_sym = interner.get_or_intern_static("bbb", utf16!("bbb")); + let a_sym = interner.get_or_intern("aaa"); + let b_sym = interner.get_or_intern("bbb"); let expected = [ TokenKind::string_literal(a_sym, EscapeSequence::empty()), TokenKind::string_literal(b_sym, EscapeSequence::empty()), @@ -163,8 +151,7 @@ fn check_template_literal_simple() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let sym = - interner.get_or_intern_static("I'm a template literal", utf16!("I'm a template literal")); + let sym = interner.get_or_intern("I'm a template literal"); assert_eq!( lexer.next(interner).unwrap().unwrap().kind(), @@ -308,8 +295,8 @@ fn check_variable_definition_tokens() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let a_sym = interner.get_or_intern_static("a", utf16!("a")); - let hello_sym = interner.get_or_intern_static("hello", utf16!("hello")); + let a_sym = interner.get_or_intern("a"); + let hello_sym = interner.get_or_intern("hello"); let expected = [ TokenKind::Keyword((Keyword::Let, false)), TokenKind::identifier(a_sym), @@ -601,7 +588,7 @@ fn hexadecimal_edge_case() { let mut lexer = Lexer::new(&b"0xffff.ff 0xffffff"[..]); let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("ff", utf16!("ff")); + let sym = interner.get_or_intern("ff"); let expected = [ TokenKind::numeric_literal(0xffff), TokenKind::Punctuator(Punctuator::Dot), @@ -641,7 +628,7 @@ fn regex_literal() { let interner = &mut Interner::default(); let expected = [TokenKind::regular_expression_literal( - interner.get_or_intern_static("(?:)", utf16!("(?:)")), + interner.get_or_intern("(?:)"), Sym::EMPTY_STRING, )]; @@ -655,12 +642,9 @@ fn regex_equals_following_assignment() { let expected = [ TokenKind::Keyword((Keyword::Const, false)), - TokenKind::identifier(interner.get_or_intern_static("myRegex", utf16!("myRegex"))), + TokenKind::identifier(interner.get_or_intern("myRegex")), TokenKind::Punctuator(Punctuator::Assign), - TokenKind::regular_expression_literal( - interner.get_or_intern_static("=", utf16!("=")), - Sym::EMPTY_STRING, - ), + TokenKind::regular_expression_literal(interner.get_or_intern("="), Sym::EMPTY_STRING), TokenKind::Punctuator(Punctuator::Semicolon), ]; @@ -673,8 +657,8 @@ fn regex_literal_flags() { let interner = &mut Interner::default(); let expected = [TokenKind::regular_expression_literal( - interner.get_or_intern_static("\\/[^\\/]*\\/*", utf16!("\\/[^\\/]*\\/*")), - interner.get_or_intern_static("gim", utf16!("gim")), + interner.get_or_intern("\\/[^\\/]*\\/*"), + interner.get_or_intern("gim"), )]; expect_tokens(&mut lexer, &expected, interner); @@ -950,7 +934,7 @@ fn string_unicode() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("中文", utf16!("中文")); + let sym = interner.get_or_intern("中文"); let expected = [ TokenKind::StringLiteral((sym, EscapeSequence::empty())), TokenKind::Punctuator(Punctuator::Semicolon), @@ -964,8 +948,7 @@ fn string_unicode_escape_with_braces() { let mut lexer = Lexer::new(&br"'{\u{20ac}\u{a0}\u{a0}}'"[..]); let interner = &mut Interner::default(); - let sym = - interner.get_or_intern_static("{\u{20ac}\u{a0}\u{a0}}", utf16!("{\u{20ac}\u{a0}\u{a0}}")); + let sym = interner.get_or_intern("{\u{20ac}\u{a0}\u{a0}}"); let expected = [TokenKind::StringLiteral((sym, EscapeSequence::OTHER))]; expect_tokens(&mut lexer, &expected, interner); @@ -1000,7 +983,7 @@ fn string_unicode_escape_with_braces_2() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("\u{20ac}\u{a0}\u{a0}", utf16!("\u{20ac}\u{a0}\u{a0}")); + let sym = interner.get_or_intern("\u{20ac}\u{a0}\u{a0}"); let expected = [TokenKind::StringLiteral((sym, EscapeSequence::OTHER))]; expect_tokens(&mut lexer, &expected, interner); @@ -1013,7 +996,7 @@ fn string_with_single_escape() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("Б", utf16!("Б")); + let sym = interner.get_or_intern("Б"); let expected = [TokenKind::StringLiteral((sym, EscapeSequence::OTHER))]; expect_tokens(&mut lexer, &expected, interner); @@ -1115,7 +1098,7 @@ fn string_line_continuation() { let mut lexer = Lexer::new(s.as_bytes()); let interner = &mut Interner::default(); - let sym = interner.get_or_intern_static("hello world", utf16!("hello world")); + let sym = interner.get_or_intern("hello world"); let expected_tokens = [TokenKind::StringLiteral((sym, EscapeSequence::OTHER))]; expect_tokens(&mut lexer, &expected_tokens, interner); diff --git a/boa_parser/src/parser/cursor/buffered_lexer/tests.rs b/boa_parser/src/parser/cursor/buffered_lexer/tests.rs index 923d206bc6..f5c3c664ee 100644 --- a/boa_parser/src/parser/cursor/buffered_lexer/tests.rs +++ b/boa_parser/src/parser/cursor/buffered_lexer/tests.rs @@ -3,7 +3,6 @@ use crate::{ parser::cursor::BufferedLexer, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn peek_skip_accending() { @@ -15,42 +14,42 @@ fn peek_skip_accending() { .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("a", utf16!("a"))) + TokenKind::identifier(interner.get_or_intern("a")) ); assert_eq!( *cur.peek(1, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("b", utf16!("b"))) + TokenKind::identifier(interner.get_or_intern("b")) ); assert_eq!( *cur.peek(2, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("c", utf16!("c"))) + TokenKind::identifier(interner.get_or_intern("c")) ); assert_eq!( *cur.peek(2, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("c", utf16!("c"))) + TokenKind::identifier(interner.get_or_intern("c")) ); assert_eq!( *cur.peek(1, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("b", utf16!("b"))) + TokenKind::identifier(interner.get_or_intern("b")) ); assert_eq!( *cur.peek(0, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("a", utf16!("a"))) + TokenKind::identifier(interner.get_or_intern("a")) ); } @@ -64,77 +63,77 @@ fn peek_skip_next() { .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("a", utf16!("a"))) + TokenKind::identifier(interner.get_or_intern("a")) ); assert_eq!( *cur.peek(1, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("b", utf16!("b"))) + TokenKind::identifier(interner.get_or_intern("b")) ); assert_eq!( *cur.peek(2, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("c", utf16!("c"))) + TokenKind::identifier(interner.get_or_intern("c")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("a", utf16!("a"))) + TokenKind::identifier(interner.get_or_intern("a")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("b", utf16!("b"))) + TokenKind::identifier(interner.get_or_intern("b")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("c", utf16!("c"))) + TokenKind::identifier(interner.get_or_intern("c")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("d", utf16!("d"))) + TokenKind::identifier(interner.get_or_intern("d")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("e", utf16!("e"))) + TokenKind::identifier(interner.get_or_intern("e")) ); assert_eq!( *cur.peek(0, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("f", utf16!("f"))) + TokenKind::identifier(interner.get_or_intern("f")) ); assert_eq!( *cur.peek(1, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("g", utf16!("g"))) + TokenKind::identifier(interner.get_or_intern("g")) ); assert_eq!( *cur.peek(2, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("h", utf16!("h"))) + TokenKind::identifier(interner.get_or_intern("h")) ); } @@ -148,49 +147,49 @@ fn peek_skip_next_alternating() { .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("a", utf16!("a"))) + TokenKind::identifier(interner.get_or_intern("a")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("a", utf16!("a"))) + TokenKind::identifier(interner.get_or_intern("a")) ); assert_eq!( *cur.peek(1, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("c", utf16!("c"))) + TokenKind::identifier(interner.get_or_intern("c")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("b", utf16!("b"))) + TokenKind::identifier(interner.get_or_intern("b")) ); assert_eq!( *cur.peek(1, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("d", utf16!("d"))) + TokenKind::identifier(interner.get_or_intern("d")) ); assert_eq!( *cur.next(false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("c", utf16!("c"))) + TokenKind::identifier(interner.get_or_intern("c")) ); assert_eq!( *cur.peek(2, false, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("f", utf16!("f"))) + TokenKind::identifier(interner.get_or_intern("f")) ); } @@ -244,14 +243,14 @@ fn skip_peeked_terminators() { .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("A", utf16!("A"))) + TokenKind::identifier(interner.get_or_intern("A")) ); assert_eq!( *cur.peek(0, true, interner) .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("A", utf16!("A"))) + TokenKind::identifier(interner.get_or_intern("A")) ); assert_eq!( @@ -266,7 +265,7 @@ fn skip_peeked_terminators() { .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("B", utf16!("B"))) /* This value is after the line terminator */ + TokenKind::identifier(interner.get_or_intern("B")) /* This value is after the line terminator */ ); assert_eq!( @@ -274,7 +273,7 @@ fn skip_peeked_terminators() { .unwrap() .expect("Some value expected") .kind(), - TokenKind::identifier(interner.get_or_intern_static("B", utf16!("B"))) + TokenKind::identifier(interner.get_or_intern("B")) ); // End of stream assert!(cur.peek(2, true, interner).unwrap().is_none()); diff --git a/boa_parser/src/parser/expression/identifiers.rs b/boa_parser/src/parser/expression/identifiers.rs index 6be63c3ed7..33c9c6f7d7 100644 --- a/boa_parser/src/parser/expression/identifiers.rs +++ b/boa_parser/src/parser/expression/identifiers.rs @@ -110,10 +110,8 @@ where let ident = Identifier.parse(cursor, interner)?; match ident.sym() { Sym::ARGUMENTS | Sym::EVAL if cursor.strict() => { - let name = interner - .resolve_expect(ident.sym()) - .utf8() - .expect("keyword must be utf-8"); + let name = interner.resolve_expect(ident.sym()); + name.as_str().as_ascii().expect("keyword must be utf-8"); Err(Error::general( format!("binding identifier `{name}` not allowed in strict mode"), span.start(), @@ -179,7 +177,8 @@ where return Err(Error::unexpected( interner .resolve_expect(ident) - .utf8() + .as_str() + .as_ascii() .expect("keyword must always be utf-8"), tok.span(), "strict reserved word cannot be an identifier", @@ -198,7 +197,8 @@ where return Err(Error::unexpected( interner .resolve_expect(ident) - .utf8() + .as_str() + .as_ascii() .expect("keyword must always be utf-8"), tok.span(), "reserved word cannot be an identifier", diff --git a/boa_parser/src/parser/expression/left_hand_side/mod.rs b/boa_parser/src/parser/expression/left_hand_side/mod.rs index f31d88737a..dee81319fa 100644 --- a/boa_parser/src/parser/expression/left_hand_side/mod.rs +++ b/boa_parser/src/parser/expression/left_hand_side/mod.rs @@ -99,7 +99,7 @@ where return Err(Error::general( format!( "keyword `{}` cannot contain escaped characters", - kw.as_str().0 + kw.as_str() ), next.span().start(), )); diff --git a/boa_parser/src/parser/expression/left_hand_side/optional/tests.rs b/boa_parser/src/parser/expression/left_hand_side/optional/tests.rs index cf640e49a8..3d886cc652 100644 --- a/boa_parser/src/parser/expression/left_hand_side/optional/tests.rs +++ b/boa_parser/src/parser/expression/left_hand_side/optional/tests.rs @@ -8,7 +8,6 @@ use boa_ast::{ Expression, Statement, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn simple() { @@ -21,9 +20,7 @@ fn simple() { Literal::Int(5).into(), vec![OptionalOperation::new( OptionalOperationKind::SimplePropertyAccess { - field: PropertyAccessField::Const( - interner.get_or_intern_static("name", utf16!("name")), - ), + field: PropertyAccessField::Const(interner.get_or_intern("name")), }, true, )] @@ -44,13 +41,11 @@ fn complex_chain() { r#"a?.b(true)?.["c"]"#, vec![Statement::Expression( Optional::new( - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), vec![ OptionalOperation::new( OptionalOperationKind::SimplePropertyAccess { - field: PropertyAccessField::Const( - interner.get_or_intern_static("b", utf16!("b")), - ), + field: PropertyAccessField::Const(interner.get_or_intern("b")), }, true, ), @@ -63,8 +58,7 @@ fn complex_chain() { OptionalOperation::new( OptionalOperationKind::SimplePropertyAccess { field: PropertyAccessField::Expr(Box::new( - Literal::String(interner.get_or_intern_static("c", utf16!("c"))) - .into(), + Literal::String(interner.get_or_intern("c")).into(), )), }, true, diff --git a/boa_parser/src/parser/expression/left_hand_side/tests.rs b/boa_parser/src/parser/expression/left_hand_side/tests.rs index 9e95711fc6..15b8d84a64 100644 --- a/boa_parser/src/parser/expression/left_hand_side/tests.rs +++ b/boa_parser/src/parser/expression/left_hand_side/tests.rs @@ -4,7 +4,6 @@ use boa_ast::{ Expression, Statement, }; use boa_interner::Interner; -use boa_macros::utf16; macro_rules! check_call_property_identifier { ($property:literal) => {{ @@ -14,11 +13,11 @@ macro_rules! check_call_property_identifier { vec![Statement::Expression(Expression::PropertyAccess( SimplePropertyAccess::new( Call::new( - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Box::default(), ) .into(), - interner.get_or_intern_static($property, utf16!($property)), + interner.get_or_intern($property), ) .into(), )) @@ -44,8 +43,8 @@ macro_rules! check_member_property_identifier { format!("a.{}", $property).as_str(), vec![Statement::Expression(Expression::PropertyAccess( SimplePropertyAccess::new( - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - interner.get_or_intern_static($property, utf16!($property)), + Identifier::new(interner.get_or_intern("a")).into(), + interner.get_or_intern($property), ) .into(), )) diff --git a/boa_parser/src/parser/expression/primary/array_initializer/tests.rs b/boa_parser/src/parser/expression/primary/array_initializer/tests.rs index 96a3ef9370..65fbf1affd 100644 --- a/boa_parser/src/parser/expression/primary/array_initializer/tests.rs +++ b/boa_parser/src/parser/expression/primary/array_initializer/tests.rs @@ -6,7 +6,6 @@ use boa_ast::{ Expression, Statement, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; /// Checks an empty array. #[test] @@ -108,7 +107,7 @@ fn check_combined() { vec![ Statement::Expression(Expression::from(ArrayLiteral::from(vec![ Some(Literal::from(1).into()), - Some(Literal::from(interner.get_or_intern_static("a", utf16!("a"))).into()), + Some(Literal::from(interner.get_or_intern("a")).into()), Some(Literal::from(2).into()), ]))) .into(), diff --git a/boa_parser/src/parser/expression/primary/async_function_expression/tests.rs b/boa_parser/src/parser/expression/primary/async_function_expression/tests.rs index 259dc62acc..931ee28259 100644 --- a/boa_parser/src/parser/expression/primary/async_function_expression/tests.rs +++ b/boa_parser/src/parser/expression/primary/async_function_expression/tests.rs @@ -7,13 +7,12 @@ use boa_ast::{ Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; /// Checks async expression parsing. #[test] fn check_async_expression() { let interner = &mut Interner::default(); - let add = interner.get_or_intern_static("add", utf16!("add")); + let add = interner.get_or_intern("add"); check_script_parser( "const add = async function() { return 1; @@ -48,8 +47,8 @@ fn check_async_expression() { #[test] fn check_nested_async_expression() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); - let b = interner.get_or_intern_static("b", utf16!("b")); + let a = interner.get_or_intern("a"); + let b = interner.get_or_intern("b"); check_script_parser( "const a = async function() { const b = async function() { diff --git a/boa_parser/src/parser/expression/primary/async_generator_expression/tests.rs b/boa_parser/src/parser/expression/primary/async_generator_expression/tests.rs index df04d67d08..89244f3460 100644 --- a/boa_parser/src/parser/expression/primary/async_generator_expression/tests.rs +++ b/boa_parser/src/parser/expression/primary/async_generator_expression/tests.rs @@ -7,14 +7,12 @@ use boa_ast::{ Declaration, Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; ///checks async generator expression parsing - #[test] fn check_async_generator_expr() { let interner = &mut Interner::default(); - let add = interner.get_or_intern_static("add", utf16!("add")); + let add = interner.get_or_intern("add"); check_script_parser( "const add = async function*(){ return 1; @@ -49,8 +47,8 @@ fn check_async_generator_expr() { #[test] fn check_nested_async_generator_expr() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); - let b = interner.get_or_intern_static("b", utf16!("b")); + let a = interner.get_or_intern("a"); + let b = interner.get_or_intern("b"); check_script_parser( "const a = async function*() { const b = async function*() { diff --git a/boa_parser/src/parser/expression/primary/function_expression/tests.rs b/boa_parser/src/parser/expression/primary/function_expression/tests.rs index 40da9ca130..10b980fd57 100644 --- a/boa_parser/src/parser/expression/primary/function_expression/tests.rs +++ b/boa_parser/src/parser/expression/primary/function_expression/tests.rs @@ -7,13 +7,12 @@ use boa_ast::{ Declaration, Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; /// Checks async expression parsing. #[test] fn check_function_expression() { let interner = &mut Interner::default(); - let add = interner.get_or_intern_static("add", utf16!("add")); + let add = interner.get_or_intern("add"); check_script_parser( "const add = function() { return 1; @@ -47,8 +46,8 @@ fn check_function_expression() { #[test] fn check_nested_function_expression() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); - let b = interner.get_or_intern_static("b", utf16!("b")); + let a = interner.get_or_intern("a"); + let b = interner.get_or_intern("b"); check_script_parser( "const a = function() { const b = function() { @@ -107,10 +106,10 @@ fn check_function_non_reserved_keyword() { ($keyword:literal, $interner:expr) => { vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - $interner.get_or_intern_static("add", utf16!("add")).into(), + $interner.get_or_intern("add").into(), Some( Function::new_with_binding_identifier( - Some($interner.get_or_intern_static($keyword, utf16!($keyword)).into()), + Some($interner.get_or_intern($keyword).into()), FormalParameterList::default(), FunctionBody::new( vec![StatementListItem::Statement( diff --git a/boa_parser/src/parser/expression/primary/generator_expression/tests.rs b/boa_parser/src/parser/expression/primary/generator_expression/tests.rs index 3e80cfb274..4e59e839b0 100644 --- a/boa_parser/src/parser/expression/primary/generator_expression/tests.rs +++ b/boa_parser/src/parser/expression/primary/generator_expression/tests.rs @@ -6,12 +6,11 @@ use boa_ast::{ Declaration, Expression, Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn check_generator_function_expression() { let interner = &mut Interner::default(); - let gen = interner.get_or_intern_static("gen", utf16!("gen")); + let gen = interner.get_or_intern("gen"); check_script_parser( "const gen = function*() { yield 1; @@ -46,7 +45,7 @@ fn check_generator_function_expression() { #[test] fn check_generator_function_delegate_yield_expression() { let interner = &mut Interner::default(); - let gen = interner.get_or_intern_static("gen", utf16!("gen")); + let gen = interner.get_or_intern("gen"); check_script_parser( "const gen = function*() { yield* 1; diff --git a/boa_parser/src/parser/expression/primary/object_initializer/mod.rs b/boa_parser/src/parser/expression/primary/object_initializer/mod.rs index 58f4c73d58..6f340f8fcd 100644 --- a/boa_parser/src/parser/expression/primary/object_initializer/mod.rs +++ b/boa_parser/src/parser/expression/primary/object_initializer/mod.rs @@ -37,8 +37,7 @@ use boa_ast::{ property::{self, MethodDefinition}, Expression, Keyword, Punctuator, }; -use boa_interner::{Interner, Sym}; -use boa_macros::utf16; +use boa_interner::{js_string, Interner, Sym}; use boa_profiler::Profiler; use std::io::Read; @@ -358,9 +357,9 @@ where )?; let name = property_name.literal().map(|name| { - let s = interner.resolve_expect(name).utf16(); + let s = interner.resolve_expect(name); interner - .get_or_intern([utf16!("get "), s].concat().as_slice()) + .get_or_intern(js_string!("get ", &*s).as_str()) .into() }); @@ -451,9 +450,9 @@ where )?; let name = property_name.literal().map(|name| { - let s = interner.resolve_expect(name).utf16(); + let s = interner.resolve_expect(name); interner - .get_or_intern([utf16!("set "), s].concat().as_slice()) + .get_or_intern(js_string!("set ", &*s).as_str()) .into() }); @@ -599,10 +598,7 @@ where Numeric::Integer(num) => Expression::Literal(Literal::from(*num)).into(), Numeric::BigInt(num) => Expression::Literal(Literal::from(num.clone())).into(), }, - TokenKind::Keyword((word, _)) => { - let (utf8, utf16) = word.as_str(); - interner.get_or_intern_static(utf8, utf16).into() - } + TokenKind::Keyword((word, _)) => interner.get_or_intern(word.as_str()).into(), TokenKind::NullLiteral(_) => (Sym::NULL).into(), TokenKind::BooleanLiteral((bool, _)) => match bool { true => Sym::TRUE.into(), diff --git a/boa_parser/src/parser/expression/primary/object_initializer/tests.rs b/boa_parser/src/parser/expression/primary/object_initializer/tests.rs index 98c33ec24f..ad98425013 100644 --- a/boa_parser/src/parser/expression/primary/object_initializer/tests.rs +++ b/boa_parser/src/parser/expression/primary/object_initializer/tests.rs @@ -13,7 +13,6 @@ use boa_ast::{ Declaration, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; /// Checks object literal parsing. #[test] @@ -22,11 +21,11 @@ fn check_object_literal() { let object_properties = vec![ PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Literal::from(true).into(), ), PropertyDefinition::Property( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), Literal::from(false).into(), ), ]; @@ -39,7 +38,7 @@ fn check_object_literal() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -57,13 +56,13 @@ fn check_object_short_function() { let object_properties = vec![ PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Literal::from(true).into(), ), PropertyDefinition::MethodDefinition( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), MethodDefinition::Ordinary(Function::new( - Some(interner.get_or_intern_static("b", utf16!("b")).into()), + Some(interner.get_or_intern("b").into()), FormalParameterList::default(), FunctionBody::default(), )), @@ -78,7 +77,7 @@ fn check_object_short_function() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -95,10 +94,7 @@ fn check_object_short_function_arguments() { let interner = &mut Interner::default(); let parameters = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier( - interner.get_or_intern_static("test", utf16!("test")).into(), - None, - ), + Variable::from_identifier(interner.get_or_intern("test").into(), None), false, )); @@ -107,13 +103,13 @@ fn check_object_short_function_arguments() { let object_properties = vec![ PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Literal::from(true).into(), ), PropertyDefinition::MethodDefinition( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), MethodDefinition::Ordinary(Function::new( - Some(interner.get_or_intern_static("b", utf16!("b")).into()), + Some(interner.get_or_intern("b").into()), parameters, FunctionBody::default(), )), @@ -128,7 +124,7 @@ fn check_object_short_function_arguments() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -145,17 +141,13 @@ fn check_object_getter() { let object_properties = vec![ PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Literal::from(true).into(), ), PropertyDefinition::MethodDefinition( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), MethodDefinition::Get(Function::new( - Some( - interner - .get_or_intern_static("get b", utf16!("get b")) - .into(), - ), + Some(interner.get_or_intern("get b").into()), FormalParameterList::default(), FunctionBody::default(), )), @@ -170,7 +162,7 @@ fn check_object_getter() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -186,10 +178,7 @@ fn check_object_setter() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier( - interner.get_or_intern_static("test", utf16!("test")).into(), - None, - ), + Variable::from_identifier(interner.get_or_intern("test").into(), None), false, )); @@ -198,17 +187,13 @@ fn check_object_setter() { let object_properties = vec![ PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Literal::from(true).into(), ), PropertyDefinition::MethodDefinition( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), MethodDefinition::Set(Function::new( - Some( - interner - .get_or_intern_static("set b", utf16!("set b")) - .into(), - ), + Some(interner.get_or_intern("set b").into()), params, FunctionBody::default(), )), @@ -223,7 +208,7 @@ fn check_object_setter() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -241,7 +226,7 @@ fn check_object_short_function_get() { let object_properties = vec![PropertyDefinition::MethodDefinition( Sym::GET.into(), MethodDefinition::Ordinary(Function::new( - Some(interner.get_or_intern_static("get", utf16!("get")).into()), + Some(interner.get_or_intern("get").into()), FormalParameterList::default(), FunctionBody::default(), )), @@ -254,7 +239,7 @@ fn check_object_short_function_get() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -272,7 +257,7 @@ fn check_object_short_function_set() { let object_properties = vec![PropertyDefinition::MethodDefinition( Sym::SET.into(), MethodDefinition::Ordinary(Function::new( - Some(interner.get_or_intern_static("set", utf16!("set")).into()), + Some(interner.get_or_intern("set").into()), FormalParameterList::default(), FunctionBody::default(), )), @@ -285,7 +270,7 @@ fn check_object_short_function_set() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -301,7 +286,7 @@ fn check_object_shorthand_property_names() { let interner = &mut Interner::default(); let object_properties = vec![PropertyDefinition::IdentifierReference( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), )]; check_script_parser( @@ -311,7 +296,7 @@ fn check_object_shorthand_property_names() { vec![ Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(true).into()), )] .try_into() @@ -320,7 +305,7 @@ fn check_object_shorthand_property_names() { .into(), Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -337,12 +322,8 @@ fn check_object_shorthand_multiple_properties() { let interner = &mut Interner::default(); let object_properties = vec![ - PropertyDefinition::IdentifierReference( - interner.get_or_intern_static("a", utf16!("a")).into(), - ), - PropertyDefinition::IdentifierReference( - interner.get_or_intern_static("b", utf16!("b")).into(), - ), + PropertyDefinition::IdentifierReference(interner.get_or_intern("a").into()), + PropertyDefinition::IdentifierReference(interner.get_or_intern("b").into()), ]; check_script_parser( @@ -353,7 +334,7 @@ fn check_object_shorthand_multiple_properties() { vec![ Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(true).into()), )] .try_into() @@ -362,7 +343,7 @@ fn check_object_shorthand_multiple_properties() { .into(), Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), Some(Literal::from(false).into()), )] .try_into() @@ -371,7 +352,7 @@ fn check_object_shorthand_multiple_properties() { .into(), Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -388,13 +369,8 @@ fn check_object_spread() { let interner = &mut Interner::default(); let object_properties = vec![ - PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), - Literal::from(1).into(), - ), - PropertyDefinition::SpreadObject( - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), - ), + PropertyDefinition::Property(interner.get_or_intern("a").into(), Literal::from(1).into()), + PropertyDefinition::SpreadObject(Identifier::new(interner.get_or_intern("b")).into()), ]; check_script_parser( @@ -402,7 +378,7 @@ fn check_object_spread() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -418,9 +394,9 @@ fn check_async_method() { let interner = &mut Interner::default(); let object_properties = vec![PropertyDefinition::MethodDefinition( - interner.get_or_intern_static("dive", utf16!("dive")).into(), + interner.get_or_intern("dive").into(), MethodDefinition::Async(AsyncFunction::new( - Some(interner.get_or_intern_static("dive", utf16!("dive")).into()), + Some(interner.get_or_intern("dive").into()), FormalParameterList::default(), FunctionBody::default(), false, @@ -434,7 +410,7 @@ fn check_async_method() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -450,15 +426,9 @@ fn check_async_generator_method() { let interner = &mut Interner::default(); let object_properties = vec![PropertyDefinition::MethodDefinition( - interner - .get_or_intern_static("vroom", utf16!("vroom")) - .into(), + interner.get_or_intern("vroom").into(), MethodDefinition::AsyncGenerator(AsyncGenerator::new( - Some( - interner - .get_or_intern_static("vroom", utf16!("vroom")) - .into(), - ), + Some(interner.get_or_intern("vroom").into()), FormalParameterList::default(), FunctionBody::default(), false, @@ -472,7 +442,7 @@ fn check_async_generator_method() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -510,13 +480,9 @@ fn check_async_ordinary_method() { let interner = &mut Interner::default(); let object_properties = vec![PropertyDefinition::MethodDefinition( - PropertyName::Literal(interner.get_or_intern_static("async", utf16!("async"))), + PropertyName::Literal(interner.get_or_intern("async")), MethodDefinition::Ordinary(Function::new( - Some( - interner - .get_or_intern_static("async", utf16!("async")) - .into(), - ), + Some(interner.get_or_intern("async").into()), FormalParameterList::default(), FunctionBody::default(), )), @@ -529,7 +495,7 @@ fn check_async_ordinary_method() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -545,7 +511,7 @@ fn check_async_property() { let interner = &mut Interner::default(); let object_properties = vec![PropertyDefinition::Property( - PropertyName::Literal(interner.get_or_intern_static("async", utf16!("async"))), + PropertyName::Literal(interner.get_or_intern("async")), Literal::from(true).into(), )]; @@ -556,7 +522,7 @@ fn check_async_property() { ", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() diff --git a/boa_parser/src/parser/expression/primary/tests.rs b/boa_parser/src/parser/expression/primary/tests.rs index f78a361bd9..09190e2cfd 100644 --- a/boa_parser/src/parser/expression/primary/tests.rs +++ b/boa_parser/src/parser/expression/primary/tests.rs @@ -1,7 +1,6 @@ use crate::parser::tests::check_script_parser; use boa_ast::{expression::literal::Literal, Expression, Statement}; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; #[test] fn check_string() { @@ -17,7 +16,7 @@ fn check_string() { check_script_parser( "\"hello\"", vec![Statement::Expression(Expression::from(Literal::from( - interner.get_or_intern_static("hello", utf16!("hello")), + interner.get_or_intern("hello"), ))) .into()], interner, diff --git a/boa_parser/src/parser/expression/tests.rs b/boa_parser/src/parser/expression/tests.rs index a8627d6fbe..a743bf0c91 100644 --- a/boa_parser/src/parser/expression/tests.rs +++ b/boa_parser/src/parser/expression/tests.rs @@ -13,7 +13,6 @@ use boa_ast::{ Declaration, Expression, Statement, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; /// Checks numeric operations #[test] @@ -23,8 +22,8 @@ fn check_numeric_operations() { "a + b", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Add.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -35,7 +34,7 @@ fn check_numeric_operations() { "a+1", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Add.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(1).into(), ))) .into()], @@ -47,8 +46,8 @@ fn check_numeric_operations() { "a - b", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Sub.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -59,7 +58,7 @@ fn check_numeric_operations() { "a-1", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Sub.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(1).into(), ))) .into()], @@ -71,8 +70,8 @@ fn check_numeric_operations() { "a / b", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Div.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -83,7 +82,7 @@ fn check_numeric_operations() { "a/2", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Div.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(2).into(), ))) .into()], @@ -95,16 +94,8 @@ fn check_numeric_operations() { "let myRegex = /=/;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner - .get_or_intern_static("myRegex", utf16!("myRegex")) - .into(), - Some( - RegExpLiteral::new( - interner.get_or_intern_static("=", utf16!("=")), - Sym::EMPTY_STRING, - ) - .into(), - ), + interner.get_or_intern("myRegex").into(), + Some(RegExpLiteral::new(interner.get_or_intern("="), Sym::EMPTY_STRING).into()), )] .try_into() .unwrap(), @@ -117,13 +108,8 @@ fn check_numeric_operations() { check_script_parser( "fn(/=/);", vec![Statement::Expression(Expression::from(Call::new( - Identifier::new(interner.get_or_intern_static("fn", utf16!("fn"))).into(), - vec![RegExpLiteral::new( - interner.get_or_intern_static("=", utf16!("=")), - Sym::EMPTY_STRING, - ) - .into()] - .into(), + Identifier::new(interner.get_or_intern("fn")).into(), + vec![RegExpLiteral::new(interner.get_or_intern("="), Sym::EMPTY_STRING).into()].into(), ))) .into()], interner, @@ -133,11 +119,11 @@ fn check_numeric_operations() { check_script_parser( "fn(a / b);", vec![Statement::Expression(Expression::from(Call::new( - Identifier::new(interner.get_or_intern_static("fn", utf16!("fn"))).into(), + Identifier::new(interner.get_or_intern("fn")).into(), vec![Expression::from(Binary::new( ArithmeticOp::Div.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))] .into(), ))) @@ -151,12 +137,11 @@ fn check_numeric_operations() { vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Div.into(), Call::new( - Identifier::new(interner.get_or_intern_static("fn", utf16!("fn"))).into(), - vec![Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into()] - .into(), + Identifier::new(interner.get_or_intern("fn")).into(), + vec![Identifier::new(interner.get_or_intern("a")).into()].into(), ) .into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -167,8 +152,8 @@ fn check_numeric_operations() { "a * b", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Mul.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -179,7 +164,7 @@ fn check_numeric_operations() { "a*2", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Mul.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(2).into(), ))) .into()], @@ -191,8 +176,8 @@ fn check_numeric_operations() { "a ** b", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Exp.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -203,7 +188,7 @@ fn check_numeric_operations() { "a**2", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Exp.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(2).into(), ))) .into()], @@ -215,8 +200,8 @@ fn check_numeric_operations() { "a % b", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Mod.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -227,7 +212,7 @@ fn check_numeric_operations() { "a%2", vec![Statement::Expression(Expression::from(Binary::new( ArithmeticOp::Mod.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(2).into(), ))) .into()], @@ -245,14 +230,14 @@ fn check_complex_numeric_operations() { ArithmeticOp::Add.into(), Binary::new( ArithmeticOp::Add.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Binary::new( ArithmeticOp::Mul.into(), - Identifier::new(interner.get_or_intern_static("d", utf16!("d"))).into(), + Identifier::new(interner.get_or_intern("d")).into(), Parenthesized::new( Binary::new( ArithmeticOp::Sub.into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("b")).into(), Literal::from(3).into(), ) .into(), @@ -277,8 +262,8 @@ fn check_bitwise_operations() { "a & b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::And.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -289,8 +274,8 @@ fn check_bitwise_operations() { "a&b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::And.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -301,8 +286,8 @@ fn check_bitwise_operations() { "a | b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Or.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -313,8 +298,8 @@ fn check_bitwise_operations() { "a|b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Or.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -325,8 +310,8 @@ fn check_bitwise_operations() { "a ^ b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Xor.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -337,8 +322,8 @@ fn check_bitwise_operations() { "a^b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Xor.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -349,8 +334,8 @@ fn check_bitwise_operations() { "a << b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Shl.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -361,8 +346,8 @@ fn check_bitwise_operations() { "a<> b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Shr.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -385,8 +370,8 @@ fn check_bitwise_operations() { "a>>b", vec![Statement::Expression(Expression::from(Binary::new( BitwiseOp::Shr.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -401,8 +386,8 @@ fn check_assign_operations() { "a += b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Add, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -413,8 +398,8 @@ fn check_assign_operations() { "a -= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Sub, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -425,8 +410,8 @@ fn check_assign_operations() { "a *= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Mul, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -437,8 +422,8 @@ fn check_assign_operations() { "a **= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Exp, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -449,8 +434,8 @@ fn check_assign_operations() { "a /= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Div, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -461,8 +446,8 @@ fn check_assign_operations() { "a %= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Mod, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -473,8 +458,8 @@ fn check_assign_operations() { "a &= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::And, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -485,8 +470,8 @@ fn check_assign_operations() { "a |= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Or, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -497,8 +482,8 @@ fn check_assign_operations() { "a ^= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Xor, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -509,8 +494,8 @@ fn check_assign_operations() { "a <<= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Shl, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -521,8 +506,8 @@ fn check_assign_operations() { "a >>= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Shr, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -533,8 +518,8 @@ fn check_assign_operations() { "a >>>= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Ushr, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -545,7 +530,7 @@ fn check_assign_operations() { "a %= 10 / 2", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Mod, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Binary::new( ArithmeticOp::Div.into(), Literal::from(10).into(), @@ -562,8 +547,8 @@ fn check_assign_operations() { "a ??= b", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Coalesce, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -577,8 +562,8 @@ fn check_relational_operations() { "a < b", vec![Statement::Expression(Expression::from(Binary::new( RelationalOp::LessThan.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -589,8 +574,8 @@ fn check_relational_operations() { "a > b", vec![Statement::Expression(Expression::from(Binary::new( RelationalOp::GreaterThan.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -601,8 +586,8 @@ fn check_relational_operations() { "a <= b", vec![Statement::Expression(Expression::from(Binary::new( RelationalOp::LessThanOrEqual.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -613,8 +598,8 @@ fn check_relational_operations() { "a >= b", vec![Statement::Expression(Expression::from(Binary::new( RelationalOp::GreaterThanOrEqual.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ))) .into()], interner, @@ -625,8 +610,8 @@ fn check_relational_operations() { "p in o", vec![Statement::Expression(Expression::from(Binary::new( RelationalOp::In.into(), - Identifier::new(interner.get_or_intern_static("p", utf16!("p"))).into(), - Identifier::new(interner.get_or_intern_static("o", utf16!("o"))).into(), + Identifier::new(interner.get_or_intern("p")).into(), + Identifier::new(interner.get_or_intern("o")).into(), ))) .into()], interner, @@ -642,19 +627,19 @@ fn check_logical_expressions() { LogicalOp::Or.into(), Binary::new( LogicalOp::And.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ) .into(), Binary::new( LogicalOp::Or.into(), Binary::new( LogicalOp::And.into(), - Identifier::new(interner.get_or_intern_static("c", utf16!("c"))).into(), - Identifier::new(interner.get_or_intern_static("d", utf16!("d"))).into(), + Identifier::new(interner.get_or_intern("c")).into(), + Identifier::new(interner.get_or_intern("d")).into(), ) .into(), - Identifier::new(interner.get_or_intern_static("e", utf16!("e"))).into(), + Identifier::new(interner.get_or_intern("e")).into(), ) .into(), ))) @@ -669,11 +654,11 @@ fn check_logical_expressions() { LogicalOp::Coalesce.into(), Binary::new( LogicalOp::Coalesce.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ) .into(), - Identifier::new(interner.get_or_intern_static("c", utf16!("c"))).into(), + Identifier::new(interner.get_or_intern("c")).into(), ))) .into()], interner, @@ -691,11 +676,7 @@ macro_rules! check_non_reserved_identifier { check_script_parser( format!("({})", $keyword).as_str(), vec![Statement::Expression( - Parenthesized::new( - Identifier::new(interner.get_or_intern_static($keyword, utf16!($keyword))) - .into(), - ) - .into(), + Parenthesized::new(Identifier::new(interner.get_or_intern($keyword)).into()).into(), ) .into()], interner, diff --git a/boa_parser/src/parser/function/tests.rs b/boa_parser/src/parser/function/tests.rs index b74f564369..2c8a31d850 100644 --- a/boa_parser/src/parser/function/tests.rs +++ b/boa_parser/src/parser/function/tests.rs @@ -13,14 +13,13 @@ use boa_ast::{ Declaration, Expression, Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; /// Checks basic function declaration parsing. #[test] fn check_basic() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -29,13 +28,11 @@ fn check_basic() { check_script_parser( "function foo(a) { return a; }", vec![Declaration::Function(Function::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( - Return::new(Some( - Identifier::from(interner.get_or_intern_static("a", utf16!("a"))).into(), - )), + Return::new(Some(Identifier::from(interner.get_or_intern("a")).into())), ))] .into(), ), @@ -51,11 +48,11 @@ fn check_duplicates_strict_off() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), ]); @@ -67,13 +64,11 @@ fn check_duplicates_strict_off() { check_script_parser( "function foo(a, a) { return a; }", vec![Declaration::Function(Function::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( - Return::new(Some( - Identifier::from(interner.get_or_intern_static("a", utf16!("a"))).into(), - )), + Return::new(Some(Identifier::from(interner.get_or_intern("a")).into())), ))] .into(), ), @@ -94,7 +89,7 @@ fn check_duplicates_strict_on() { fn check_basic_semicolon_insertion() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -103,13 +98,11 @@ fn check_basic_semicolon_insertion() { check_script_parser( "function foo(a) { return a }", vec![Declaration::Function(Function::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( - Return::new(Some( - Identifier::from(interner.get_or_intern_static("a", utf16!("a"))).into(), - )), + Return::new(Some(Identifier::from(interner.get_or_intern("a")).into())), ))] .into(), ), @@ -124,7 +117,7 @@ fn check_basic_semicolon_insertion() { fn check_empty_return() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -132,7 +125,7 @@ fn check_empty_return() { check_script_parser( "function foo(a) { return; }", vec![Declaration::Function(Function::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( @@ -151,7 +144,7 @@ fn check_empty_return() { fn check_empty_return_semicolon_insertion() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -159,7 +152,7 @@ fn check_empty_return_semicolon_insertion() { check_script_parser( "function foo(a) { return }", vec![Declaration::Function(Function::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( @@ -179,11 +172,11 @@ fn check_rest_operator() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), true, ), ]); @@ -195,7 +188,7 @@ fn check_rest_operator() { check_script_parser( "function foo(a, ...b) {}", vec![Declaration::Function(Function::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::default(), )) @@ -209,7 +202,7 @@ fn check_rest_operator() { fn check_arrow_only_rest() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), true, )); assert_eq!( @@ -235,15 +228,15 @@ fn check_arrow_rest() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("c", utf16!("c")).into(), None), + Variable::from_identifier(interner.get_or_intern("c").into(), None), true, ), ]); @@ -270,11 +263,11 @@ fn check_arrow() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), ]); @@ -290,8 +283,8 @@ fn check_arrow() { Return::new(Some( Binary::new( ArithmeticOp::Add.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ) .into(), )), @@ -310,11 +303,11 @@ fn check_arrow_semicolon_insertion() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), ]); @@ -328,8 +321,8 @@ fn check_arrow_semicolon_insertion() { Return::new(Some( Binary::new( ArithmeticOp::Add.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), + Identifier::new(interner.get_or_intern("b")).into(), ) .into(), )), @@ -348,11 +341,11 @@ fn check_arrow_epty_return() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), ]); @@ -379,11 +372,11 @@ fn check_arrow_empty_return_semicolon_insertion() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), ]); @@ -408,7 +401,7 @@ fn check_arrow_empty_return_semicolon_insertion() { fn check_arrow_assignment() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -417,18 +410,15 @@ fn check_arrow_assignment() { "let foo = (a) => { return a };", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - Identifier::new(interner.get_or_intern_static("foo", utf16!("foo"))), + Identifier::new(interner.get_or_intern("foo")), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -449,7 +439,7 @@ fn check_arrow_assignment() { fn check_arrow_assignment_nobrackets() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -458,18 +448,15 @@ fn check_arrow_assignment_nobrackets() { "let foo = (a) => a;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("foo", utf16!("foo")).into(), + interner.get_or_intern("foo").into(), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -490,7 +477,7 @@ fn check_arrow_assignment_nobrackets() { fn check_arrow_assignment_noparenthesis() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -499,18 +486,15 @@ fn check_arrow_assignment_noparenthesis() { "let foo = a => { return a };", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("foo", utf16!("foo")).into(), + interner.get_or_intern("foo").into(), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -531,7 +515,7 @@ fn check_arrow_assignment_noparenthesis() { fn check_arrow_assignment_noparenthesis_nobrackets() { let interner = &mut Interner::default(); let params = FormalParameterList::from(FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, )); assert_eq!(params.flags(), FormalParameterListFlags::default()); @@ -540,18 +524,15 @@ fn check_arrow_assignment_noparenthesis_nobrackets() { "let foo = a => a;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - Identifier::new(interner.get_or_intern_static("foo", utf16!("foo"))), + Identifier::new(interner.get_or_intern("foo")), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -573,11 +554,11 @@ fn check_arrow_assignment_2arg() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), ]); @@ -587,18 +568,15 @@ fn check_arrow_assignment_2arg() { "let foo = (a, b) => { return a };", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - Identifier::new(interner.get_or_intern_static("foo", utf16!("foo"))), + Identifier::new(interner.get_or_intern("foo")), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -620,11 +598,11 @@ fn check_arrow_assignment_2arg_nobrackets() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), ]); @@ -634,18 +612,15 @@ fn check_arrow_assignment_2arg_nobrackets() { "let foo = (a, b) => a;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - Identifier::new(interner.get_or_intern_static("foo", utf16!("foo"))), + Identifier::new(interner.get_or_intern("foo")), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -667,15 +642,15 @@ fn check_arrow_assignment_3arg() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("c", utf16!("c")).into(), None), + Variable::from_identifier(interner.get_or_intern("c").into(), None), false, ), ]); @@ -685,18 +660,15 @@ fn check_arrow_assignment_3arg() { "let foo = (a, b, c) => { return a };", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - Identifier::new(interner.get_or_intern_static("foo", utf16!("foo"))), + Identifier::new(interner.get_or_intern("foo")), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), @@ -718,15 +690,15 @@ fn check_arrow_assignment_3arg_nobrackets() { let interner = &mut Interner::default(); let params = FormalParameterList::from(vec![ FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("a", utf16!("a")).into(), None), + Variable::from_identifier(interner.get_or_intern("a").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("b", utf16!("b")).into(), None), + Variable::from_identifier(interner.get_or_intern("b").into(), None), false, ), FormalParameter::new( - Variable::from_identifier(interner.get_or_intern_static("c", utf16!("c")).into(), None), + Variable::from_identifier(interner.get_or_intern("c").into(), None), false, ), ]); @@ -736,18 +708,15 @@ fn check_arrow_assignment_3arg_nobrackets() { "let foo = (a, b, c) => a;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - Identifier::new(interner.get_or_intern_static("foo", utf16!("foo"))), + Identifier::new(interner.get_or_intern("foo")), Some( ArrowFunction::new( - Some(interner.get_or_intern_static("foo", utf16!("foo")).into()), + Some(interner.get_or_intern("foo").into()), params, FunctionBody::new( vec![StatementListItem::Statement(Statement::Return( Return::new(Some( - Identifier::new( - interner.get_or_intern_static("a", utf16!("a")), - ) - .into(), + Identifier::new(interner.get_or_intern("a")).into(), )), ))] .into(), diff --git a/boa_parser/src/parser/statement/block/tests.rs b/boa_parser/src/parser/statement/block/tests.rs index 4015c29eeb..4299484eaa 100644 --- a/boa_parser/src/parser/statement/block/tests.rs +++ b/boa_parser/src/parser/statement/block/tests.rs @@ -17,7 +17,6 @@ use boa_ast::{ Declaration, Expression, Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; /// Helper function to check a block. #[track_caller] @@ -40,7 +39,7 @@ fn empty() { #[test] fn non_empty() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_block( r"{ var a = 10; @@ -66,8 +65,8 @@ fn non_empty() { ); let interner = &mut Interner::default(); - let hello = interner.get_or_intern_static("hello", utf16!("hello")); - let a = interner.get_or_intern_static("a", utf16!("a")); + let hello = interner.get_or_intern("hello"); + let a = interner.get_or_intern("a"); check_block( r"{ function hello() { @@ -111,8 +110,8 @@ fn non_empty() { #[test] fn hoisting() { let interner = &mut Interner::default(); - let hello = interner.get_or_intern_static("hello", utf16!("hello")); - let a = interner.get_or_intern_static("a", utf16!("a")); + let hello = interner.get_or_intern("hello"); + let a = interner.get_or_intern("a"); check_block( r"{ var a = hello(); @@ -151,7 +150,7 @@ fn hoisting() { ); let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_block( r"{ a = 10; diff --git a/boa_parser/src/parser/statement/break_stm/tests.rs b/boa_parser/src/parser/statement/break_stm/tests.rs index eef361e05e..4b341c4f02 100644 --- a/boa_parser/src/parser/statement/break_stm/tests.rs +++ b/boa_parser/src/parser/statement/break_stm/tests.rs @@ -5,7 +5,6 @@ use boa_ast::{ Statement, StatementListItem, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; #[test] fn inline() { @@ -61,11 +60,11 @@ fn new_line_semicolon_insertion() { LabelledItem::Statement(Statement::WhileLoop(WhileLoop::new( Literal::from(true).into(), Block::from(vec![StatementListItem::Statement(Statement::Break( - Break::new(Some(interner.get_or_intern_static("test", utf16!("test")))), + Break::new(Some(interner.get_or_intern("test"))), ))]) .into(), ))), - interner.get_or_intern_static("test", utf16!("test")), + interner.get_or_intern("test"), )) .into()], interner, @@ -99,11 +98,11 @@ fn new_line_block() { LabelledItem::Statement(Statement::WhileLoop(WhileLoop::new( Literal::from(true).into(), Block::from(vec![StatementListItem::Statement(Statement::Break( - Break::new(Some(interner.get_or_intern_static("test", utf16!("test")))), + Break::new(Some(interner.get_or_intern("test"))), ))]) .into(), ))), - interner.get_or_intern_static("test", utf16!("test")), + interner.get_or_intern("test"), )) .into()], interner, diff --git a/boa_parser/src/parser/statement/continue_stm/tests.rs b/boa_parser/src/parser/statement/continue_stm/tests.rs index 9891b7c2c7..0086e09b1b 100644 --- a/boa_parser/src/parser/statement/continue_stm/tests.rs +++ b/boa_parser/src/parser/statement/continue_stm/tests.rs @@ -5,7 +5,6 @@ use boa_ast::{ Statement, StatementListItem, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; #[test] fn inline() { @@ -61,11 +60,11 @@ fn new_line_semicolon_insertion() { LabelledItem::Statement(Statement::WhileLoop(WhileLoop::new( Literal::from(true).into(), Block::from(vec![StatementListItem::Statement(Statement::Continue( - Continue::new(Some(interner.get_or_intern_static("test", utf16!("test")))), + Continue::new(Some(interner.get_or_intern("test"))), ))]) .into(), ))), - interner.get_or_intern_static("test", utf16!("test")), + interner.get_or_intern("test"), )) .into()], interner, @@ -99,11 +98,11 @@ fn new_line_block() { LabelledItem::Statement(Statement::WhileLoop(WhileLoop::new( Literal::from(true).into(), Block::from(vec![StatementListItem::Statement(Statement::Continue( - Continue::new(Some(interner.get_or_intern_static("test", utf16!("test")))), + Continue::new(Some(interner.get_or_intern("test"))), ))]) .into(), ))), - interner.get_or_intern_static("test", utf16!("test")), + interner.get_or_intern("test"), )) .into()], interner, diff --git a/boa_parser/src/parser/statement/declaration/export.rs b/boa_parser/src/parser/statement/declaration/export.rs index b406593fdd..084617bda9 100644 --- a/boa_parser/src/parser/statement/declaration/export.rs +++ b/boa_parser/src/parser/statement/declaration/export.rs @@ -307,7 +307,7 @@ where match tok.kind() { TokenKind::StringLiteral((ident, _)) => { - if interner.resolve_expect(*ident).utf8().is_none() { + if !interner.resolve_expect(*ident).as_str().is_ascii() { return Err(Error::general( "import specifiers don't allow unpaired surrogates", tok.span().end(), diff --git a/boa_parser/src/parser/statement/declaration/hoistable/async_function_decl/tests.rs b/boa_parser/src/parser/statement/declaration/hoistable/async_function_decl/tests.rs index 6984959468..40d780f89a 100644 --- a/boa_parser/src/parser/statement/declaration/hoistable/async_function_decl/tests.rs +++ b/boa_parser/src/parser/statement/declaration/hoistable/async_function_decl/tests.rs @@ -4,7 +4,6 @@ use boa_ast::{ Declaration, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; /// Async function declaration parsing. #[test] @@ -13,11 +12,7 @@ fn async_function_declaration() { check_script_parser( "async function hello() {}", vec![Declaration::AsyncFunction(AsyncFunction::new( - Some( - interner - .get_or_intern_static("hello", utf16!("hello")) - .into(), - ), + Some(interner.get_or_intern("hello").into()), FormalParameterList::default(), FunctionBody::default(), false, diff --git a/boa_parser/src/parser/statement/declaration/hoistable/async_generator_decl/tests.rs b/boa_parser/src/parser/statement/declaration/hoistable/async_generator_decl/tests.rs index aea08f6a0b..6e4ef89378 100644 --- a/boa_parser/src/parser/statement/declaration/hoistable/async_generator_decl/tests.rs +++ b/boa_parser/src/parser/statement/declaration/hoistable/async_generator_decl/tests.rs @@ -4,7 +4,6 @@ use boa_ast::{ Declaration, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn async_generator_function_declaration() { @@ -12,7 +11,7 @@ fn async_generator_function_declaration() { check_script_parser( "async function* gen() {}", vec![Declaration::AsyncGenerator(AsyncGenerator::new( - Some(interner.get_or_intern_static("gen", utf16!("gen")).into()), + Some(interner.get_or_intern("gen").into()), FormalParameterList::default(), FunctionBody::default(), false, diff --git a/boa_parser/src/parser/statement/declaration/hoistable/class_decl/mod.rs b/boa_parser/src/parser/statement/declaration/hoistable/class_decl/mod.rs index a4c4e773f6..2025709439 100644 --- a/boa_parser/src/parser/statement/declaration/hoistable/class_decl/mod.rs +++ b/boa_parser/src/parser/statement/declaration/hoistable/class_decl/mod.rs @@ -28,8 +28,7 @@ use boa_ast::{ property::{ClassElementName, MethodDefinition}, Expression, Keyword, Punctuator, }; -use boa_interner::{Interner, Sym}; -use boa_macros::utf16; +use boa_interner::{js_string, Interner, Sym}; use rustc_hash::{FxHashMap, FxHashSet}; use std::io::Read; @@ -1162,11 +1161,8 @@ where } TokenKind::PrivateIdentifier(name) => { let name = *name; - let name_private = interner.get_or_intern( - [utf16!("#"), interner.resolve_expect(name).utf16()] - .concat() - .as_slice(), - ); + let name_private = interner + .get_or_intern(js_string!("#", &*interner.resolve_expect(name)).as_str()); cursor.advance(interner); let token = cursor.peek(0, interner).or_abrupt()?; match token.kind() { diff --git a/boa_parser/src/parser/statement/declaration/hoistable/class_decl/tests.rs b/boa_parser/src/parser/statement/declaration/hoistable/class_decl/tests.rs index e5f3424650..f9c0a7f2bd 100644 --- a/boa_parser/src/parser/statement/declaration/hoistable/class_decl/tests.rs +++ b/boa_parser/src/parser/statement/declaration/hoistable/class_decl/tests.rs @@ -11,14 +11,13 @@ use boa_ast::{ Declaration, Expression, Statement, StatementList, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn check_async_ordinary_method() { let interner = &mut Interner::default(); let elements = vec![ClassElement::MethodDefinition( - PropertyName::Literal(interner.get_or_intern_static("async", utf16!("async"))), + PropertyName::Literal(interner.get_or_intern("async")), MethodDefinition::Ordinary(Function::new( None, FormalParameterList::default(), @@ -32,7 +31,7 @@ fn check_async_ordinary_method() { } ", [Declaration::Class(Class::new( - Some(interner.get_or_intern_static("A", utf16!("A")).into()), + Some(interner.get_or_intern("A").into()), None, None, elements.into(), @@ -48,7 +47,7 @@ fn check_async_field_initialization() { let interner = &mut Interner::default(); let elements = vec![ClassElement::FieldDefinition( - PropertyName::Literal(interner.get_or_intern_static("async", utf16!("async"))), + PropertyName::Literal(interner.get_or_intern("async")), Some(Literal::from(1).into()), )]; @@ -59,7 +58,7 @@ fn check_async_field_initialization() { } ", [Declaration::Class(Class::new( - Some(interner.get_or_intern_static("A", utf16!("A")).into()), + Some(interner.get_or_intern("A").into()), None, None, elements.into(), @@ -75,7 +74,7 @@ fn check_async_field() { let interner = &mut Interner::default(); let elements = vec![ClassElement::FieldDefinition( - PropertyName::Literal(interner.get_or_intern_static("async", utf16!("async"))), + PropertyName::Literal(interner.get_or_intern("async")), None, )]; @@ -85,7 +84,7 @@ fn check_async_field() { } ", [Declaration::Class(Class::new( - Some(interner.get_or_intern_static("A", utf16!("A")).into()), + Some(interner.get_or_intern("A").into()), None, None, elements.into(), @@ -101,24 +100,20 @@ fn check_new_target_with_property_access() { let interner = &mut Interner::default(); let new_target = Expression::PropertyAccess( - SimplePropertyAccess::new( - Expression::NewTarget, - interner.get_or_intern_static("name", utf16!("name")), - ) - .into(), + SimplePropertyAccess::new(Expression::NewTarget, interner.get_or_intern("name")).into(), ); let console = Expression::Call(Call::new( PropertyAccess::Simple(SimplePropertyAccess::new( - Identifier::from(interner.get_or_intern_static("console", utf16!("console"))).into(), - interner.get_or_intern_static("log", utf16!("log")), + Identifier::from(interner.get_or_intern("console")).into(), + interner.get_or_intern("log"), )) .into(), [new_target].into(), )); let constructor = Function::new( - Some(interner.get_or_intern_static("A", utf16!("A")).into()), + Some(interner.get_or_intern("A").into()), FormalParameterList::default(), FunctionBody::new(StatementList::new( [Statement::Expression(console).into()], @@ -127,7 +122,7 @@ fn check_new_target_with_property_access() { ); let class = Class::new( - Some(interner.get("A").unwrap().into()), + Some(interner.get_or_intern("A").into()), None, Some(constructor), Box::default(), @@ -136,7 +131,7 @@ fn check_new_target_with_property_access() { let instantiation = Expression::New( Call::new( - Identifier::from(interner.get("A").unwrap()).into(), + Identifier::from(interner.get_or_intern("A")).into(), Box::default(), ) .into(), @@ -145,7 +140,7 @@ fn check_new_target_with_property_access() { let const_decl = LexicalDeclaration::Const( VariableList::new( [Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(instantiation), )] .into(), diff --git a/boa_parser/src/parser/statement/declaration/hoistable/function_decl/tests.rs b/boa_parser/src/parser/statement/declaration/hoistable/function_decl/tests.rs index 5bf2fbdf7f..4cb055ccab 100644 --- a/boa_parser/src/parser/statement/declaration/hoistable/function_decl/tests.rs +++ b/boa_parser/src/parser/statement/declaration/hoistable/function_decl/tests.rs @@ -4,7 +4,6 @@ use boa_ast::{ Declaration, }; use boa_interner::Interner; -use boa_macros::utf16; /// Function declaration parsing. #[test] @@ -13,11 +12,7 @@ fn function_declaration() { check_script_parser( "function hello() {}", vec![Declaration::Function(Function::new( - Some( - interner - .get_or_intern_static("hello", utf16!("hello")) - .into(), - ), + Some(interner.get_or_intern("hello").into()), FormalParameterList::default(), FunctionBody::default(), )) @@ -32,11 +27,7 @@ fn function_declaration_keywords() { macro_rules! genast { ($keyword:literal, $interner:expr) => { vec![Declaration::Function(Function::new( - Some( - $interner - .get_or_intern_static($keyword, utf16!($keyword)) - .into(), - ), + Some($interner.get_or_intern($keyword).into()), FormalParameterList::default(), FunctionBody::default(), )) diff --git a/boa_parser/src/parser/statement/declaration/hoistable/generator_decl/tests.rs b/boa_parser/src/parser/statement/declaration/hoistable/generator_decl/tests.rs index 215d3f8ba2..eb3d7d8bd8 100644 --- a/boa_parser/src/parser/statement/declaration/hoistable/generator_decl/tests.rs +++ b/boa_parser/src/parser/statement/declaration/hoistable/generator_decl/tests.rs @@ -4,7 +4,6 @@ use boa_ast::{ Declaration, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn generator_function_declaration() { @@ -12,7 +11,7 @@ fn generator_function_declaration() { check_script_parser( "function* gen() {}", vec![Declaration::Generator(Generator::new( - Some(interner.get_or_intern_static("gen", utf16!("gen")).into()), + Some(interner.get_or_intern("gen").into()), FormalParameterList::default(), FunctionBody::default(), false, diff --git a/boa_parser/src/parser/statement/declaration/import.rs b/boa_parser/src/parser/statement/declaration/import.rs index 4177c76561..6558a0954a 100644 --- a/boa_parser/src/parser/statement/declaration/import.rs +++ b/boa_parser/src/parser/statement/declaration/import.rs @@ -298,7 +298,7 @@ where match tok.kind() { TokenKind::StringLiteral((name, _)) => { let name = *name; - if interner.resolve_expect(name).utf8().is_none() { + if !interner.resolve_expect(name).as_str().is_ascii() { return Err(Error::general( "import specifiers don't allow unpaired surrogates", tok.span().end(), diff --git a/boa_parser/src/parser/statement/declaration/tests.rs b/boa_parser/src/parser/statement/declaration/tests.rs index 078248147c..a13450a7c1 100644 --- a/boa_parser/src/parser/statement/declaration/tests.rs +++ b/boa_parser/src/parser/statement/declaration/tests.rs @@ -5,7 +5,6 @@ use boa_ast::{ Declaration, Statement, }; use boa_interner::{Interner, Sym}; -use boa_macros::utf16; /// Checks `var` declaration parsing. #[test] @@ -15,7 +14,7 @@ fn var_declaration() { "var a = 5;", vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), )] .try_into() @@ -68,7 +67,7 @@ fn var_declaration_no_spaces() { "var a=5;", vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), )] .try_into() @@ -87,7 +86,7 @@ fn empty_var_declaration() { "var a;", vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), None, )] .try_into() @@ -107,15 +106,12 @@ fn multiple_var_declaration() { vec![Statement::Var(VarDeclaration( vec![ Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), ), + Variable::from_identifier(interner.get_or_intern("b").into(), None), Variable::from_identifier( - interner.get_or_intern_static("b", utf16!("b")).into(), - None, - ), - Variable::from_identifier( - interner.get_or_intern_static("c", utf16!("c")).into(), + interner.get_or_intern("c").into(), Some(Literal::from(6).into()), ), ] @@ -135,7 +131,7 @@ fn let_declaration() { "let a = 5;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), )] .try_into() @@ -188,7 +184,7 @@ fn let_declaration_no_spaces() { "let a=5;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), )] .try_into() @@ -207,7 +203,7 @@ fn empty_let_declaration() { "let a;", vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), None, )] .try_into() @@ -227,15 +223,12 @@ fn multiple_let_declaration() { vec![Declaration::Lexical(LexicalDeclaration::Let( vec![ Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), ), + Variable::from_identifier(interner.get_or_intern("b").into(), None), Variable::from_identifier( - interner.get_or_intern_static("b", utf16!("b")).into(), - None, - ), - Variable::from_identifier( - interner.get_or_intern_static("c", utf16!("c")).into(), + interner.get_or_intern("c").into(), Some(Literal::from(6).into()), ), ] @@ -255,7 +248,7 @@ fn const_declaration() { "const a = 5;", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), )] .try_into() @@ -308,7 +301,7 @@ fn const_declaration_no_spaces() { "const a=5;", vec![Declaration::Lexical(LexicalDeclaration::Const( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), )] .try_into() @@ -334,11 +327,11 @@ fn multiple_const_declaration() { vec![Declaration::Lexical(LexicalDeclaration::Const( vec![ Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::from(5).into()), ), Variable::from_identifier( - interner.get_or_intern_static("c", utf16!("c")).into(), + interner.get_or_intern("c").into(), Some(Literal::from(6).into()), ), ] diff --git a/boa_parser/src/parser/statement/iteration/tests.rs b/boa_parser/src/parser/statement/iteration/tests.rs index 314914a118..0555236dd7 100644 --- a/boa_parser/src/parser/statement/iteration/tests.rs +++ b/boa_parser/src/parser/statement/iteration/tests.rs @@ -16,7 +16,6 @@ use boa_ast::{ Expression, Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; /// Checks do-while statement parsing. #[test] @@ -31,7 +30,7 @@ fn check_do_while() { vec![StatementListItem::Statement(Statement::Expression( Expression::from(Assign::new( AssignOp::Add, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(1).into(), )), ))] @@ -54,7 +53,7 @@ fn check_do_while_semicolon_insertion() { vec![ Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("i", utf16!("i")).into(), + interner.get_or_intern("i").into(), Some(Literal::from(0).into()), )] .try_into() @@ -67,19 +66,12 @@ fn check_do_while_semicolon_insertion() { Expression::from(Call::new( Expression::PropertyAccess( SimplePropertyAccess::new( - Identifier::new( - interner.get_or_intern_static("console", utf16!("console")), - ) - .into(), - interner.get_or_intern_static("log", utf16!("log")), + Identifier::new(interner.get_or_intern("console")).into(), + interner.get_or_intern("log"), ) .into(), ), - vec![Literal::from( - interner.get_or_intern_static("hello", utf16!("hello")), - ) - .into()] - .into(), + vec![Literal::from(interner.get_or_intern("hello")).into()].into(), )), ))] .into(), @@ -88,9 +80,7 @@ fn check_do_while_semicolon_insertion() { RelationalOp::LessThan.into(), Update::new( UpdateOp::IncrementPost, - UpdateTarget::Identifier(Identifier::new( - interner.get_or_intern_static("i", utf16!("i")), - )), + UpdateTarget::Identifier(Identifier::new(interner.get_or_intern("i"))), ) .into(), Literal::from(10).into(), @@ -101,16 +91,12 @@ fn check_do_while_semicolon_insertion() { Statement::Expression(Expression::from(Call::new( Expression::PropertyAccess( SimplePropertyAccess::new( - Identifier::new( - interner.get_or_intern_static("console", utf16!("console")), - ) - .into(), - interner.get_or_intern_static("log", utf16!("log")), + Identifier::new(interner.get_or_intern("console")).into(), + interner.get_or_intern("log"), ) .into(), ), - vec![Literal::from(interner.get_or_intern_static("end", utf16!("end"))).into()] - .into(), + vec![Literal::from(interner.get_or_intern("end")).into()].into(), ))) .into(), ], @@ -129,7 +115,7 @@ fn check_do_while_semicolon_insertion_no_space() { vec![ Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("i", utf16!("i")).into(), + interner.get_or_intern("i").into(), Some(Literal::from(0).into()), )] .try_into() @@ -142,19 +128,12 @@ fn check_do_while_semicolon_insertion_no_space() { Expression::from(Call::new( Expression::PropertyAccess( SimplePropertyAccess::new( - Identifier::new( - interner.get_or_intern_static("console", utf16!("console")), - ) - .into(), - interner.get_or_intern_static("log", utf16!("log")), + Identifier::new(interner.get_or_intern("console")).into(), + interner.get_or_intern("log"), ) .into(), ), - vec![Literal::from( - interner.get_or_intern_static("hello", utf16!("hello")), - ) - .into()] - .into(), + vec![Literal::from(interner.get_or_intern("hello")).into()].into(), )), ))] .into(), @@ -163,9 +142,7 @@ fn check_do_while_semicolon_insertion_no_space() { RelationalOp::LessThan.into(), Update::new( UpdateOp::IncrementPost, - UpdateTarget::Identifier(Identifier::new( - interner.get_or_intern_static("i", utf16!("i")), - )), + UpdateTarget::Identifier(Identifier::new(interner.get_or_intern("i"))), ) .into(), Literal::from(10).into(), @@ -176,16 +153,12 @@ fn check_do_while_semicolon_insertion_no_space() { Statement::Expression(Expression::from(Call::new( Expression::PropertyAccess( SimplePropertyAccess::new( - Identifier::new( - interner.get_or_intern_static("console", utf16!("console")), - ) - .into(), - interner.get_or_intern_static("log", utf16!("log")), + Identifier::new(interner.get_or_intern("console")).into(), + interner.get_or_intern("log"), ) .into(), ), - vec![Literal::from(interner.get_or_intern_static("end", utf16!("end"))).into()] - .into(), + vec![Literal::from(interner.get_or_intern("end")).into()].into(), ))) .into(), ], diff --git a/boa_parser/src/parser/statement/mod.rs b/boa_parser/src/parser/statement/mod.rs index 0e6fe17d5d..6a6895ec60 100644 --- a/boa_parser/src/parser/statement/mod.rs +++ b/boa_parser/src/parser/statement/mod.rs @@ -56,7 +56,6 @@ use boa_ast::{ Keyword, Punctuator, }; use boa_interner::Interner; -use boa_macros::utf16; use boa_profiler::Profiler; use std::io::Read; @@ -317,12 +316,9 @@ where ast::StatementListItem::Statement(ast::Statement::Expression( ast::Expression::Literal(ast::expression::literal::Literal::String(string)), )) if !strict => { - if interner.resolve_expect(*string).join( - |s| s == "use strict", - |g| g == utf16!("use strict"), - true, - ) && directives_stack.last().expect("token should exist").1 - == EscapeSequence::empty() + if &*interner.resolve_expect(*string) == "use strict" + && directives_stack.last().expect("token should exist").1 + == EscapeSequence::empty() { cursor.set_strict(true); strict = true; diff --git a/boa_parser/src/parser/statement/switch/tests.rs b/boa_parser/src/parser/statement/switch/tests.rs index b1de2ff839..4af77eddb5 100644 --- a/boa_parser/src/parser/statement/switch/tests.rs +++ b/boa_parser/src/parser/statement/switch/tests.rs @@ -6,7 +6,6 @@ use boa_ast::{ Declaration, Expression, Statement, }; use boa_interner::Interner; -use boa_macros::utf16; /// Checks parsing malformed switch with no closeblock. #[test] @@ -148,9 +147,9 @@ fn check_separated_switch() { "#; let interner = &mut Interner::default(); - let log = interner.get_or_intern_static("log", utf16!("log")); - let console = interner.get_or_intern_static("console", utf16!("console")); - let a = interner.get_or_intern_static("a", utf16!("a")); + let log = interner.get_or_intern("log"); + let console = interner.get_or_intern("console"); + let a = interner.get_or_intern("a"); check_script_parser( s, @@ -203,11 +202,7 @@ fn check_separated_switch() { SimplePropertyAccess::new(Identifier::new(console).into(), log) .into(), ), - vec![Literal::from( - interner.get_or_intern_static("Default", utf16!("Default")), - ) - .into()] - .into(), + vec![Literal::from(interner.get_or_intern("Default")).into()].into(), ))) .into()] .into(), diff --git a/boa_parser/src/parser/statement/throw/tests.rs b/boa_parser/src/parser/statement/throw/tests.rs index 0b922f9a0c..533748b4a6 100644 --- a/boa_parser/src/parser/statement/throw/tests.rs +++ b/boa_parser/src/parser/statement/throw/tests.rs @@ -1,7 +1,6 @@ use crate::parser::tests::check_script_parser; use boa_ast::{expression::literal::Literal, statement::Throw, Statement}; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn check_throw_parsing() { @@ -9,7 +8,7 @@ fn check_throw_parsing() { check_script_parser( "throw 'error';", vec![Statement::Throw(Throw::new( - Literal::from(interner.get_or_intern_static("error", utf16!("error"))).into(), + Literal::from(interner.get_or_intern("error")).into(), )) .into()], interner, diff --git a/boa_parser/src/parser/statement/try_stm/tests.rs b/boa_parser/src/parser/statement/try_stm/tests.rs index 2320deff47..ad2345dc7a 100644 --- a/boa_parser/src/parser/statement/try_stm/tests.rs +++ b/boa_parser/src/parser/statement/try_stm/tests.rs @@ -8,7 +8,6 @@ use boa_ast::{ Statement, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; #[test] fn check_inline_with_empty_try_catch() { @@ -18,7 +17,7 @@ fn check_inline_with_empty_try_catch() { vec![Statement::Try(Try::new( Block::default(), ErrorHandler::Catch(Catch::new( - Some(Identifier::from(interner.get_or_intern_static("e", utf16!("e"))).into()), + Some(Identifier::from(interner.get_or_intern("e")).into()), Block::default(), )), )) @@ -35,7 +34,7 @@ fn check_inline_with_var_decl_inside_try() { vec![Statement::Try(Try::new( vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(Literal::from(1).into()), )] .try_into() @@ -44,7 +43,7 @@ fn check_inline_with_var_decl_inside_try() { .into()] .into(), ErrorHandler::Catch(Catch::new( - Some(Identifier::from(interner.get_or_intern_static("e", utf16!("e"))).into()), + Some(Identifier::from(interner.get_or_intern("e")).into()), Block::default(), )), )) @@ -61,7 +60,7 @@ fn check_inline_with_var_decl_inside_catch() { vec![Statement::Try(Try::new( vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(Literal::from(1).into()), )] .try_into() @@ -70,10 +69,10 @@ fn check_inline_with_var_decl_inside_catch() { .into()] .into(), ErrorHandler::Catch(Catch::new( - Some(Identifier::from(interner.get_or_intern_static("e", utf16!("e"))).into()), + Some(Identifier::from(interner.get_or_intern("e")).into()), vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(Literal::from(1).into()), )] .try_into() @@ -97,7 +96,7 @@ fn check_inline_with_empty_try_catch_finally() { Block::default(), ErrorHandler::Full( Catch::new( - Some(Identifier::from(interner.get_or_intern_static("e", utf16!("e"))).into()), + Some(Identifier::from(interner.get_or_intern("e")).into()), Block::default(), ), Finally::from(Block::default()), @@ -131,7 +130,7 @@ fn check_inline_with_empty_try_var_decl_in_finally() { ErrorHandler::Finally(Finally::from(Block::from(vec![ StatementListItem::Statement(Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(Literal::from(1).into()), )] .try_into() @@ -155,7 +154,7 @@ fn check_inline_empty_try_paramless_catch() { None, vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(Literal::from(1).into()), )] .try_into() @@ -173,7 +172,7 @@ fn check_inline_empty_try_paramless_catch() { #[test] fn check_inline_with_binding_pattern_object() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_script_parser( "try {} catch ({ a, b: c }) {}", vec![Statement::Try(Try::new( @@ -187,10 +186,8 @@ fn check_inline_with_binding_pattern_object() { default_init: None, }, ObjectPatternElement::SingleName { - ident: interner.get_or_intern_static("c", utf16!("c")).into(), - name: PropertyName::Literal( - interner.get_or_intern_static("b", utf16!("b")), - ), + ident: interner.get_or_intern("c").into(), + name: PropertyName::Literal(interner.get_or_intern("b")), default_init: None, }, ]) @@ -215,11 +212,11 @@ fn check_inline_with_binding_pattern_array() { Some( Pattern::from(vec![ ArrayPatternElement::SingleName { - ident: interner.get_or_intern_static("a", utf16!("a")).into(), + ident: interner.get_or_intern("a").into(), default_init: None, }, ArrayPatternElement::SingleName { - ident: interner.get_or_intern_static("b", utf16!("b")).into(), + ident: interner.get_or_intern("b").into(), default_init: None, }, ]) @@ -241,13 +238,11 @@ fn check_catch_with_var_redeclaration() { vec![Statement::Try(Try::new( Block::from(vec![]), ErrorHandler::Catch(Catch::new( - Some(Identifier::new(interner.get_or_intern_static("e", utf16!("e"))).into()), + Some(Identifier::new(interner.get_or_intern("e")).into()), vec![Statement::Var(VarDeclaration( vec![Variable::from_identifier( - interner.get_or_intern_static("e", utf16!("e")).into(), - Some( - Literal::from(interner.get_or_intern_static("oh", utf16!("oh"))).into(), - ), + interner.get_or_intern("e").into(), + Some(Literal::from(interner.get_or_intern("oh")).into()), )] .try_into() .unwrap(), diff --git a/boa_parser/src/parser/tests/mod.rs b/boa_parser/src/parser/tests/mod.rs index 89744438cb..a5ca09c3c0 100644 --- a/boa_parser/src/parser/tests/mod.rs +++ b/boa_parser/src/parser/tests/mod.rs @@ -27,7 +27,6 @@ use boa_ast::{ Expression, Script, Statement, StatementList, StatementListItem, }; use boa_interner::Interner; -use boa_macros::utf16; /// Checks that the given JavaScript string gives the expected expression. #[track_caller] @@ -61,12 +60,11 @@ fn check_construct_call_precedence() { Expression::PropertyAccess( SimplePropertyAccess::new( New::from(Call::new( - Identifier::new(interner.get_or_intern_static("Date", utf16!("Date"))) - .into(), + Identifier::new(interner.get_or_intern("Date")).into(), Box::default(), )) .into(), - interner.get_or_intern_static("getTime", utf16!("getTime")), + interner.get_or_intern("getTime"), ) .into(), ), @@ -84,10 +82,10 @@ fn assign_operator_precedence() { "a = a + 1", vec![Statement::Expression(Expression::from(Assign::new( AssignOp::Assign, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Binary::new( ArithmeticOp::Add.into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(1).into(), ) .into(), @@ -100,8 +98,8 @@ fn assign_operator_precedence() { #[test] fn hoisting() { let interner = &mut Interner::default(); - let hello = interner.get_or_intern_static("hello", utf16!("hello")); - let a = interner.get_or_intern_static("a", utf16!("a")); + let hello = interner.get_or_intern("hello"); + let a = interner.get_or_intern("a"); check_script_parser( r" var a = hello(); @@ -137,7 +135,7 @@ fn hoisting() { ); let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_script_parser( r" a = 10; @@ -179,13 +177,13 @@ fn ambigous_regex_divide_expression() { Binary::new( ArithmeticOp::Div.into(), Literal::Int(1).into(), - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), ) .into(), Binary::new( ArithmeticOp::Div.into(), Literal::Int(1).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("b")).into(), ) .into(), ))) @@ -199,7 +197,7 @@ fn two_divisions_in_expression() { let s = "a !== 0 || 1 / a === 1 / b;"; let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_script_parser( s, vec![Statement::Expression(Expression::from(Binary::new( @@ -221,7 +219,7 @@ fn two_divisions_in_expression() { Binary::new( ArithmeticOp::Div.into(), Literal::Int(1).into(), - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), + Identifier::new(interner.get_or_intern("b")).into(), ) .into(), ) @@ -245,7 +243,7 @@ fn comment_semi_colon_insertion() { vec![ Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::Int(10).into()), )] .try_into() @@ -254,7 +252,7 @@ fn comment_semi_colon_insertion() { .into(), Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), Some(Literal::Int(20).into()), )] .try_into() @@ -281,7 +279,7 @@ fn multiline_comment_semi_colon_insertion() { vec![ Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::Int(10).into()), )] .try_into() @@ -290,7 +288,7 @@ fn multiline_comment_semi_colon_insertion() { .into(), Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), Some(Literal::Int(20).into()), )] .try_into() @@ -314,7 +312,7 @@ fn multiline_comment_no_lineterminator() { vec![ Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::Int(10).into()), )] .try_into() @@ -323,7 +321,7 @@ fn multiline_comment_no_lineterminator() { .into(), Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("b", utf16!("b")).into(), + interner.get_or_intern("b").into(), Some(Literal::Int(20).into()), )] .try_into() @@ -350,7 +348,7 @@ fn assignment_line_terminator() { vec![ Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("a", utf16!("a")).into(), + interner.get_or_intern("a").into(), Some(Literal::Int(3).into()), )] .try_into() @@ -359,7 +357,7 @@ fn assignment_line_terminator() { .into(), Statement::Expression(Expression::from(Assign::new( AssignOp::Assign, - Identifier::new(interner.get_or_intern_static("a", utf16!("a"))).into(), + Identifier::new(interner.get_or_intern("a")).into(), Literal::from(5).into(), ))) .into(), @@ -381,7 +379,7 @@ fn assignment_multiline_terminator() { "#; let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_script_parser( s, vec![ @@ -413,10 +411,7 @@ fn bracketed_expr() { check_script_parser( s, vec![Statement::Expression( - Parenthesized::new( - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), - ) - .into(), + Parenthesized::new(Identifier::new(interner.get_or_intern("b")).into()).into(), ) .into()], interner, @@ -428,7 +423,7 @@ fn increment_in_comma_op() { let s = r#"(b++, b)"#; let interner = &mut Interner::default(); - let b = interner.get_or_intern_static("b", utf16!("b")); + let b = interner.get_or_intern("b"); check_script_parser( s, vec![Statement::Expression( @@ -463,20 +458,15 @@ fn spread_in_object() { let interner = &mut Interner::default(); let object_properties = vec![ - PropertyDefinition::Property( - interner.get_or_intern_static("a", utf16!("a")).into(), - Literal::from(1).into(), - ), - PropertyDefinition::SpreadObject( - Identifier::new(interner.get_or_intern_static("b", utf16!("b"))).into(), - ), + PropertyDefinition::Property(interner.get_or_intern("a").into(), Literal::from(1).into()), + PropertyDefinition::SpreadObject(Identifier::new(interner.get_or_intern("b")).into()), ]; check_script_parser( s, vec![Declaration::Lexical(LexicalDeclaration::Let( vec![Variable::from_identifier( - interner.get_or_intern_static("x", utf16!("x")).into(), + interner.get_or_intern("x").into(), Some(ObjectLiteral::from(object_properties).into()), )] .try_into() @@ -496,7 +486,7 @@ fn spread_in_arrow_function() { "#; let interner = &mut Interner::default(); - let b = interner.get_or_intern_static("b", utf16!("b")); + let b = interner.get_or_intern("b"); let params = FormalParameterList::from(FormalParameter::new( Variable::from_identifier(b.into(), None), true, @@ -520,7 +510,7 @@ fn spread_in_arrow_function() { #[test] fn empty_statement() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); + let a = interner.get_or_intern("a"); check_script_parser( r" ;;var a = 10; @@ -547,11 +537,9 @@ fn empty_statement() { #[test] fn empty_statement_ends_directive_prologues() { let interner = &mut Interner::default(); - let a = interner.get_or_intern_static("a", utf16!("a")); - let use_strict = interner.get_or_intern_static("use strict", utf16!("use strict")); - let public = interner - .get_or_intern_static("public", utf16!("public")) - .into(); + let a = interner.get_or_intern("a"); + let use_strict = interner.get_or_intern("use strict"); + let public = interner.get_or_intern("public").into(); check_script_parser( r#" "a"; diff --git a/boa_types/src/string/common.rs b/boa_types/src/string/common.rs index 5f8e0c884a..8b2ba97177 100644 --- a/boa_types/src/string/common.rs +++ b/boa_types/src/string/common.rs @@ -60,7 +60,8 @@ impl StaticJsStrings { /// Gets the `JsString` corresponding to `string`, or `None` if the string /// doesn't exist inside the static array. - pub(crate) fn get_string(string: &str) -> Option { + #[must_use] + pub fn get_string(string: &str) -> Option { if string.len() > MAX_STATIC_LENGTH { return None; } @@ -74,7 +75,8 @@ impl StaticJsStrings { /// Gets the `&[u16]` slice corresponding to the provided index, or `None` if the index /// provided exceeds the size of the static array. - pub(crate) fn get(index: usize) -> Option<&'static str> { + #[must_use] + pub fn get(index: usize) -> Option<&'static str> { RAW_STATICS.index(index).copied() } @@ -206,8 +208,82 @@ const MAX_STATIC_LENGTH: usize = { }; /// Array of raw static strings that aren't reference counted. -const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( +pub const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( + // Reserved identifiers + // See: + // Note, they must all be together. + "break", + "case", + "catch", + "class", + "const", + "continue", + "debugger", + "default", + "delete", + "do", + "else", + "enum", + "export", + "extends", + "false", + "finally", + "for", + "function", + "if", + "import", + "in", + "instanceof", + "new", + "null", + "return", + "super", + "switch", + "this", + "throw", + "true", + "try", + "typeof", + "var", + "void", + "while", + "with", + // End reserved identifier + + // strict reserved identifiers. + // See: + // Note, they must all be together. + "implements", + "interface", + "let", + "package", + "private", + "protected", + "public", + "static", + "yield", + // End strict reserved identifiers "", + "prototype", + "constructor", + "arguments", + "eval", + "RegExp", + "get", + "set", + "
", + "raw", + "anonymous", + "async", + "of", + "target", + "as", + "from", + "__proto__", + "name", + "await", + "*default*", + "meta", // Well known symbols "Symbol.asyncIterator", "[Symbol.asyncIterator]", @@ -259,7 +335,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "URIError", "escape", "unescape", - "eval", "Function", "Generator", "GeneratorFunction", @@ -282,7 +357,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "Promise", "Proxy", "Reflect", - "RegExp", "Set", "String", "Symbol", @@ -321,28 +395,18 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( ",", ":", // Generic use - "name", "length", - "arguments", - "prototype", - "constructor", - "return", - "throw", "global", "globalThis", // typeof - "null", "undefined", "number", "string", "symbol", "bigint", "object", - "function", // Property descriptor "value", - "get", - "set", "writable", "enumerable", "configurable", @@ -381,7 +445,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "__defineSetter__", "__lookupGetter__", "__lookupSetter__", - "__proto__", "get __proto__", "set __proto__", // Function object @@ -393,9 +456,7 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "callee", // Array object "at", - "from", "isArray", - "of", "copyWithin", "every", "fill", @@ -427,7 +488,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "toReversed", "toSorted", "toSpliced", - "with", // String object "charAt", "charCodeAt", @@ -442,7 +502,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "normalize", "padEnd", "padStart", - "raw", "repeat", "replace", "replaceAll", @@ -519,7 +578,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "get flags", "get source", // Symbol object - "for", "keyFor", "description", "asyncIterator", @@ -533,7 +591,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "get description", // Map object "clear", - "delete", "has", "size", // Set object @@ -601,8 +658,6 @@ const RAW_STATICS: phf::OrderedSet<&'static str> = phf::phf_ordered_set!( "any", "race", "then", - "catch", - "finally", "withResolvers", // Iterator object "Array Iterator", diff --git a/boa_types/src/string/mod.rs b/boa_types/src/string/mod.rs index 582ecc2e5e..607fb474b1 100644 --- a/boa_types/src/string/mod.rs +++ b/boa_types/src/string/mod.rs @@ -867,6 +867,12 @@ impl JsString { pub fn is_static(&self) -> bool { self.ptr.is_tagged() } + pub fn as_static(&self) -> Option { + if let UnwrappedTagged::Tag(index) = self.ptr.unwrap() { + return Some(index); + } + None + } pub fn get<'a, I>(&'a self, index: I) -> Option where