refactor(ast): rename TemplateLiteral::quasi to TemplateLiteral::single_quasi

Author: Dunqing

crates/oxc_ast/src/ast_impl/js.rs

@@ -459,9 +459,7 @@ impl<'a> PropertyKey<'a> {
             Self::NumericLiteral(lit) => Some(Cow::Owned(lit.value.to_string())),
             Self::BigIntLiteral(lit) => Some(Cow::Borrowed(lit.value.as_str())),
             Self::NullLiteral(_) => Some(Cow::Borrowed("null")),
-            Self::TemplateLiteral(lit) => {
-                lit.expressions.is_empty().then(|| lit.quasi()).flatten().map(Into::into)
-            }
+            Self::TemplateLiteral(lit) => lit.single_quasi().map(Into::into),
             _ => None,
         }
     }
@@ -548,7 +546,7 @@ impl<'a> TemplateLiteral<'a> {
     }
 
     /// Get single quasi from `template`
-    pub fn quasi(&self) -> Option<Atom<'a>> {
+    pub fn single_quasi(&self) -> Option<Atom<'a>> {
         if self.is_no_substitution_template() { self.quasis[0].value.cooked } else { None }
     }
 }

crates/oxc_ast/src/ast_impl/ts.rs

@@ -19,7 +19,7 @@ impl<'a> TSEnumMemberName<'a> {
             Self::Identifier(ident) => ident.name,
             Self::String(lit) | Self::ComputedString(lit) => lit.value,
             Self::ComputedTemplateString(template) => template
-                .quasi()
+                .single_quasi()
                 .expect("`TSEnumMemberName::TemplateString` should have no substitution and at least one quasi"),
         }
     }

crates/oxc_ast/src/ast_kind_impl.rs

@@ -251,7 +251,7 @@ impl AstKind<'_> {
             Self::RegExpLiteral(r) => format!("RegExpLiteral({})", r.regex).into(),
             Self::TemplateLiteral(t) => format!(
                 "TemplateLiteral({})",
-                t.quasi().map_or_else(|| "None".into(), |q| format!("Some({q})"))
+                t.single_quasi().map_or_else(|| "None".into(), |q| format!("Some({q})"))
             )
             .into(),
             Self::TemplateElement(_) => "TemplateElement".into(),

crates/oxc_ecmascript/src/side_effects/may_have_side_effects.rs

@@ -417,7 +417,7 @@ impl<'a> MayHaveSideEffects<'a> for ComputedMemberExpression<'a> {
             Expression::StringLiteral(s) => {
                 property_access_may_have_side_effects(&self.object, &s.value, ctx)
             }
-            Expression::TemplateLiteral(t) => t.quasi().is_some_and(|quasi| {
+            Expression::TemplateLiteral(t) => t.single_quasi().is_some_and(|quasi| {
                 property_access_may_have_side_effects(&self.object, &quasi, ctx)
             }),
             Expression::NumericLiteral(n) => !n.value.to_integer_index().is_some_and(|n| {

crates/oxc_ecmascript/src/to_primitive.rs

@@ -92,9 +92,9 @@ pub fn maybe_object_with_to_primitive_related_properties_overridden(
             PropertyKey::StringLiteral(str) => {
                 matches!(str.value.as_str(), "toString" | "valueOf")
             }
-            PropertyKey::TemplateLiteral(temp) => {
-                temp.quasi().is_some_and(|val| matches!(val.as_str(), "toString" | "valueOf"))
-            }
+            PropertyKey::TemplateLiteral(temp) => temp
+                .single_quasi()
+                .is_some_and(|val| matches!(val.as_str(), "toString" | "valueOf")),
             _ => true,
         },
         ObjectPropertyKind::SpreadProperty(e) => match &e.argument {

crates/oxc_linter/src/ast_util.rs

@@ -308,7 +308,7 @@ pub fn extract_regex_flags<'a>(
     }
     let flag_arg = match &args[1] {
         Argument::StringLiteral(flag_arg) => flag_arg.value,
-        Argument::TemplateLiteral(template) => template.quasi()?,
+        Argument::TemplateLiteral(template) => template.single_quasi()?,
         _ => return None,
     };
     let mut flags = RegExpFlags::empty();

crates/oxc_linter/src/rules/eslint/valid_typeof.rs

@@ -124,7 +124,7 @@ impl Rule for ValidTypeof {
         }
 
         if let Expression::TemplateLiteral(template) = sibling {
-            if template.quasi().is_some_and(|value| !VALID_TYPES.contains(&value.as_str())) {
+            if template.single_quasi().is_some_and(|value| !VALID_TYPES.contains(&value.as_str())) {
                 ctx.diagnostic(invalid_value(None, sibling.span()));
                 return;
             }

crates/oxc_linter/src/rules/jest/no_identical_title.rs

@@ -149,9 +149,9 @@ fn filter_and_process_jest_result<'a>(
         Some(Argument::StringLiteral(string_lit)) => {
             Some((string_lit.span, &string_lit.value, kind, parent_id))
         }
-        Some(Argument::TemplateLiteral(template_lit)) => {
-            template_lit.quasi().map(|quasi| (template_lit.span, quasi.as_str(), kind, parent_id))
-        }
+        Some(Argument::TemplateLiteral(template_lit)) => template_lit
+            .single_quasi()
+            .map(|quasi| (template_lit.span, quasi.as_str(), kind, parent_id)),
         _ => None,
     }
 }

crates/oxc_linter/src/rules/jest/prefer_lowercase_title/mod.rs

@@ -238,7 +238,7 @@ impl Rule for PreferLowercaseTitle {
         if let Argument::StringLiteral(string_expr) = arg {
             self.lint_string(ctx, string_expr.value.as_str(), string_expr.span);
         } else if let Argument::TemplateLiteral(template_expr) = arg {
-            let Some(template_string) = template_expr.quasi() else {
+            let Some(template_string) = template_expr.single_quasi() else {
                 return;
             };
             self.lint_string(ctx, template_string.as_str(), template_expr.span);

crates/oxc_linter/src/rules/jest/valid_title.rs

@@ -180,7 +180,7 @@ impl ValidTitle {
                 );
             }
             Argument::TemplateLiteral(template_literal) => {
-                if let Some(quasi) = template_literal.quasi() {
+                if let Some(quasi) = template_literal.single_quasi() {
                     validate_title(
                         quasi.as_str(),
                         template_literal.span,