feat: deno_ast 0.52

Cargo.toml

@@ -23,7 +23,7 @@ test = true
 default = []
 
 [dependencies]
-deno_ast = { version = "0.51.0", features = ["scopes", "transforms", "utils", "visit", "view", "react"] }
+deno_ast = { version = "0.52.0", features = ["scopes", "transforms", "utils", "visit", "view", "react"] }
 log = "0.4.20"
 serde = { version = "1.0.195", features = ["derive"] }
 serde_json = "1.0.111"

src/rules/adjacent_overload_signatures.rs

@@ -185,7 +185,9 @@ impl ExtractMethod for ast_view::TsTypeElement<'_> {
         ref key, ..
       }) => match key {
         Expr::Ident(ident) => Some(Method::Method(ident.sym().to_string())),
-        Expr::Lit(Lit::Str(s)) => Some(Method::Method(s.value().to_string())),
+        Expr::Lit(Lit::Str(s)) => {
+          Some(Method::Method(s.value().to_string_lossy().into_owned()))
+        }
         _ => None,
       },
       TsTypeElement::TsCallSignatureDecl(_) => Some(Method::CallSignature),

src/rules/camelcase.rs

@@ -607,9 +607,11 @@ impl Handler for CamelcaseHandler {
         local,
         IdentToCheck::named_import(
           local.inner,
-          Some(match imported {
-            ast_view::ModuleExportName::Ident(ident) => ident.sym(),
-            ast_view::ModuleExportName::Str(str) => str.value(),
+          Some(&match imported {
+            ast_view::ModuleExportName::Ident(ident) => ident.sym().to_string(),
+            ast_view::ModuleExportName::Str(str) => {
+              str.value().to_string_lossy().into_owned()
+            }
           }),
         ),
       );

src/rules/jsx_button_has_type.rs

@@ -100,18 +100,9 @@ impl Handler for HasButtonTypeHandler {
           if let Some(attr_value) = attr.value {
             let kind = DiagnosticKind::WrongValue;
             match attr_value {
-              JSXAttrValue::Lit(lit) => {
-                if let Lit::Str(lit_str) = lit {
-                  let value = lit_str.value();
-                  if !is_valid_value(value) {
-                    ctx.add_diagnostic_with_hint(
-                      attr_value.range(),
-                      CODE,
-                      kind.message(),
-                      kind.hint(),
-                    );
-                  }
-                } else {
+              JSXAttrValue::Str(lit_str) => {
+                let value = lit_str.value().to_string_lossy();
+                if !is_valid_value(&value) {
                   ctx.add_diagnostic_with_hint(
                     attr_value.range(),
                     CODE,
@@ -227,8 +218,8 @@ fn check_literal_value(ctx: &mut Context, lit: &Lit) {
 
   match lit {
     Lit::Str(lit_str) => {
-      let value = lit_str.value();
-      if !is_valid_value(value) {
+      let value = lit_str.value().to_string_lossy();
+      if !is_valid_value(&value) {
         ctx.add_diagnostic_with_hint(
           lit.range(),
           CODE,

src/rules/jsx_curly_braces.rs

@@ -86,7 +86,7 @@ impl Handler for JSXCurlyBracesHandler {
       if let JSXElementChild::JSXExprContainer(child_expr) = child {
         if let JSXExpr::Expr(Expr::Lit(Lit::Str(lit_str))) = child_expr.expr {
           // Ignore entities which would require escaping.
-          if IGNORE_CHARS.is_match(lit_str.inner.value.as_str()) {
+          if IGNORE_CHARS.is_match(&lit_str.inner.value.to_string_lossy()) {
             continue;
           }
 
@@ -111,7 +111,7 @@ impl Handler for JSXCurlyBracesHandler {
             vec![LintFix {
               description: "Remove curly braces around JSX child".into(),
               changes: vec![LintFixChange {
-                new_text: lit_str.value().to_string().into(),
+                new_text: lit_str.value().to_string_lossy().into_owned().into(),
                 range: child.range(),
               }],
             }],
@@ -135,7 +135,11 @@ impl Handler for JSXCurlyBracesHandler {
                 description: "Remove curly braces around JSX attribute value"
                   .into(),
                 changes: vec![LintFixChange {
-                  new_text: format!("\"{}\"", lit_str.value()).into(),
+                  new_text: format!(
+                    "\"{}\"",
+                    lit_str.value().to_string_lossy()
+                  )
+                  .into(),
                   range: value.range(),
                 }],
               }],

src/rules/no_deprecated_deno_api.rs

@@ -46,7 +46,7 @@ fn extract_symbol<'a>(
     MemberProp::Ident(ident) => Some(ident.sym()),
     MemberProp::PrivateName(ident) => Some(ident.name()),
     MemberProp::Computed(prop) => match &prop.expr {
-      Expr::Lit(Lit::Str(s)) => Some(s.value()),
+      Expr::Lit(Lit::Str(s)) => s.value().as_str(),
       Expr::Ident(ident) => Some(ident.sym()),
       Expr::Tpl(Tpl { exprs, quasis, .. })
         if exprs.is_empty() && quasis.len() == 1 =>

src/rules/no_dupe_class_members.rs

@@ -143,11 +143,15 @@ impl Visit for ClassVisitor<'_, '_, '_> {
 fn normalize_prop_name(name: &PropName) -> Option<String> {
   let normalized = match *name {
     PropName::Ident(IdentName { ref sym, .. }) => sym.to_string(),
-    PropName::Str(Str { ref value, .. }) => value.to_string(),
+    PropName::Str(Str { ref value, .. }) => {
+      value.to_string_lossy().into_owned()
+    }
     PropName::Num(Number { ref value, .. }) => value.to_string(),
     PropName::BigInt(BigInt { ref value, .. }) => value.to_string(),
     PropName::Computed(ComputedPropName { ref expr, .. }) => match &**expr {
-      Expr::Lit(Lit::Str(Str { ref value, .. })) => value.to_string(),
+      Expr::Lit(Lit::Str(Str { ref value, .. })) => {
+        value.to_string_lossy().into_owned()
+      }
       Expr::Lit(Lit::Bool(Bool { ref value, .. })) => value.to_string(),
       Expr::Lit(Lit::Null(Null { .. })) => "null".to_string(),
       Expr::Lit(Lit::Num(Number { ref value, .. })) => value.to_string(),

src/rules/no_external_imports.rs

@@ -50,7 +50,8 @@ struct NoExternalImportHandler;
 
 impl NoExternalImportHandler {
   fn check_import_path(&self, decl: &ImportDecl, ctx: &mut Context) {
-    let parsed_src = ModuleSpecifier::parse(decl.src.value());
+    let parsed_src =
+      ModuleSpecifier::parse(&decl.src.value().to_string_lossy());
     let maybe_file_path = ctx.specifier().to_file_path().ok();
     let file_stem = maybe_file_path
       .as_ref()

src/rules/no_import_assertions.rs

@@ -84,7 +84,7 @@ impl Handler for NoImportAssertionsHandler {
                   }
                 },
                 ast_view::PropName::Str(str) => {
-                  if str.value().as_ref() == "assert" {
+                  if str.value().as_str() == Some("assert") {
                     ctx.add_diagnostic_with_hint(
                       str.range(),
                       CODE,

src/rules/no_import_prefix.rs

@@ -37,7 +37,7 @@ struct NoImportPrefixHandler;
 
 impl Handler for NoImportPrefixHandler {
   fn import_decl(&mut self, node: &ImportDecl, ctx: &mut Context) {
-    if is_non_bare(node.src.value()) {
+    if is_non_bare(&node.src.value().to_string_lossy()) {
       ctx.add_diagnostic_with_hint(node.src.range(), CODE, MESSAGE, HINT);
     }
   }
@@ -46,7 +46,7 @@ impl Handler for NoImportPrefixHandler {
     if let Callee::Import(_) = node.callee {
       if let Some(arg) = node.args.first() {
         if let Expr::Lit(Lit::Str(lit)) = arg.expr {
-          if is_non_bare(lit.value()) {
+          if is_non_bare(&lit.value().to_string_lossy()) {
             ctx.add_diagnostic_with_hint(arg.range(), CODE, MESSAGE, HINT);
           }
         }

src/rules/no_invalid_regexp.rs

@@ -45,8 +45,8 @@ impl LintRule for NoInvalidRegexp {
 
 fn check_expr_for_string_literal(expr: &Expr) -> Option<String> {
   if let Expr::Lit(deno_ast::swc::ast::Lit::Str(pattern_string)) = expr {
-    let s: &str = &pattern_string.value;
-    return Some(s.to_owned());
+    let s = pattern_string.value.to_string_lossy();
+    return Some(s.into_owned());
   }
   None
 }