feat: upgrade to deno_ast 0.9 (#332)

Author: dsherret

.github/workflows/ci.yml

@@ -36,6 +36,9 @@ jobs:
     - name: Build debug
       if: matrix.config.kind == 'test_debug'
       run: cargo build
+    #- name: Lint
+    #  if: matrix.config.kind == 'test_debug'
+    #  run: cargo clippy
     - name: Test debug
       if: matrix.config.kind == 'test_debug'
       run: cargo test

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dprint-plugin-typescript"
-version = "0.61.0"
+version = "0.62.0"
 authors = ["David Sherret <dsherret@gmail.com>"]
 edition = "2021"
 homepage = "https://github.com/dprint/dprint-plugin-typescript"
@@ -26,7 +26,7 @@ tracing = ["dprint-core/tracing"]
 
 [dependencies]
 anyhow = "1.0.51"
-deno_ast = { version = "0.8.0", features = ["view"] }
+deno_ast = { version = "0.9.0", features = ["view"] }
 dprint-core = { version = "0.49.0", features = ["formatting"] }
 rustc-hash = "1.1.0"
 serde = { version = "1.0.118", features = ["derive"] }

src/generation/parser.rs src/generation/generate.rssrc/generation/parser.rs renamed to src/generation/generate.rs

@@ -169,6 +169,7 @@ fn gen_node_with_inner_gen<'a>(node: Node<'a>, context: &mut Context<'a>, inner_
       Node::AwaitExpr(node) => gen_await_expr(node, context),
       Node::BinExpr(node) => gen_binary_expr(node, context),
       Node::CallExpr(node) => gen_call_expr(node, context),
+      Node::Import(_) => "import".into(),
       Node::ClassExpr(node) => gen_class_expr(node, context),
       Node::CondExpr(node) => gen_conditional_expr(node, context),
       Node::ExprOrSpread(node) => gen_expr_or_spread(node, context),
@@ -178,6 +179,7 @@ fn gen_node_with_inner_gen<'a>(node: Node<'a>, context: &mut Context<'a>, inner_
       Node::AssignProp(node) => gen_assign_prop(node, context),
       Node::MemberExpr(node) => gen_member_expr(node, context),
       Node::MetaPropExpr(node) => gen_meta_prop_expr(node, context),
+      Node::SuperPropExpr(node) => gen_super_prop_expr(node, context),
       Node::NewExpr(node) => gen_new_expr(node, context),
       Node::ObjectLit(node) => gen_object_lit(node, context),
       Node::OptChainExpr(node) => gen_node(node.expr.into(), context),
@@ -474,7 +476,7 @@ fn gen_class_prop<'a>(node: &'a ClassProp, context: &mut Context<'a>) -> PrintIt
       type_ann: &node.type_ann,
       is_static: node.is_static(),
       decorators: &node.decorators,
-      computed: node.key.kind() == NodeKind::ComputedPropName,
+      computed: matches!(node.key, PropName::Computed(_)),
       is_declare: node.declare(),
       accessibility: node.accessibility(),
       is_abstract: node.is_abstract(),
@@ -1925,9 +1927,9 @@ fn gen_call_expr<'a>(node: &'a CallExpr, context: &mut Context<'a>) -> PrintItem
     items.extend(gen_test_library_arguments(&node.args, context));
     return items;
 
-    fn gen_test_library_callee<'a>(callee: &'a ExprOrSuper, context: &mut Context<'a>) -> PrintItems {
+    fn gen_test_library_callee<'a>(callee: &'a Callee, context: &mut Context<'a>) -> PrintItems {
       match callee {
-        ExprOrSuper::Expr(expr) => match expr {
+        Callee::Expr(expr) => match expr {
           Expr::Member(member_expr) => {
             let mut items = PrintItems::new();
             items.extend(gen_node(member_expr.obj.into(), context));
@@ -2241,7 +2243,7 @@ fn should_add_parens_around_expr(node: Node, context: &Context) -> bool {
       }
       Node::ExprStmt(_) => return true,
       Node::MemberExpr(expr) => {
-        if expr.computed() && expr.prop.span().contains(original_node.span()) {
+        if matches!(expr.prop, MemberProp::Computed(_)) && expr.prop.span().contains(original_node.span()) {
           return false;
         }
       }
@@ -2315,6 +2317,11 @@ fn gen_meta_prop_expr<'a>(node: &'a MetaPropExpr, context: &mut Context<'a>) ->
   gen_for_flattened_member_like_expr(flattened_meta_prop_expr, context)
 }
 
+fn gen_super_prop_expr<'a>(node: &'a SuperPropExpr, context: &mut Context<'a>) -> PrintItems {
+  let flattened_member_expr = flatten_member_like_expr(node.into(), context.program);
+  gen_for_flattened_member_like_expr(flattened_member_expr, context)
+}
+
 fn gen_new_expr<'a>(node: &'a NewExpr, context: &mut Context<'a>) -> PrintItems {
   let mut items = PrintItems::new();
   items.push_str("new ");
@@ -2433,7 +2440,13 @@ fn should_skip_paren_expr(node: &ParenExpr, context: &Context) -> bool {
   let parent = node.parent();
   if matches!(
     parent.kind(),
-    NodeKind::ParenExpr | NodeKind::ExprStmt | NodeKind::JSXElement | NodeKind::JSXFragment | NodeKind::JSXExprContainer | NodeKind::UpdateExpr
+    NodeKind::ParenExpr
+      | NodeKind::ExprStmt
+      | NodeKind::JSXElement
+      | NodeKind::JSXFragment
+      | NodeKind::JSXExprContainer
+      | NodeKind::UpdateExpr
+      | NodeKind::ComputedPropName
   ) {
     return true;
   }
@@ -2455,7 +2468,7 @@ fn should_skip_paren_expr(node: &ParenExpr, context: &Context) -> bool {
   }
 
   if let Node::MemberExpr(member_expr) = parent {
-    if member_expr.computed() && member_expr.prop.span().contains(node.span()) {
+    if matches!(member_expr.prop, MemberProp::Computed(_)) && member_expr.prop.span().contains(node.span()) {
       return true;
     }
   }
@@ -2615,7 +2628,7 @@ fn gen_template_literal<'a>(quasis: Vec<Node<'a>>, exprs: Vec<Node<'a>>, context
   // handle this on a case by case basis for now
   fn get_keep_on_one_line(node: &Node) -> bool {
     match node {
-      Node::Ident(_) | Node::ThisExpr(_) | Node::Super(_) | Node::Str(_) | Node::PrivateName(_) => true,
+      Node::Ident(_) | Node::ThisExpr(_) | Node::SuperPropExpr(_) | Node::MetaPropExpr(_) | Node::Str(_) | Node::PrivateName(_) => true,
       Node::MemberExpr(expr) => keep_member_expr_on_one_line(expr),
       Node::CallExpr(expr) => keep_call_expr_on_one_line(expr),
       _ => false,
@@ -2633,7 +2646,7 @@ fn gen_template_literal<'a>(quasis: Vec<Node<'a>>, exprs: Vec<Node<'a>>, context
   }
 
   fn keep_member_expr_on_one_line(expr: &MemberExpr) -> bool {
-    get_keep_on_one_line(&expr.obj.into()) && get_keep_on_one_line(&expr.prop.into()) && !expr.computed()
+    get_keep_on_one_line(&expr.obj.into()) && get_keep_on_one_line(&expr.prop.into()) && !matches!(expr.prop, MemberProp::Computed(_))
   }
 
   fn keep_call_expr_on_one_line(expr: &CallExpr) -> bool {
@@ -6464,10 +6477,8 @@ where
 
     fn is_dynamic_import(node: &Node) -> bool {
       if let Node::CallExpr(call_expr) = &node {
-        if let ExprOrSuper::Expr(Expr::Ident(ident)) = &call_expr.callee {
-          if (ident.sym() as &str) == "import" {
-            return true;
-          }
+        if let Callee::Import(_) = &call_expr.callee {
+          return true;
         }
       }
 
@@ -6571,10 +6582,7 @@ fn gen_close_paren_with_type<'a>(opts: GenCloseParenWithTypeOptions<'a>, context
           // look good especially when the return type then becomes multi-line.
           match type_node {
             Node::TsUnionType(_) | Node::TsIntersectionType(_) => false,
-            Node::TsTypeAnn(type_ann) => match type_ann.type_ann {
-              TsType::TsUnionOrIntersectionType(_) => false,
-              _ => true,
-            },
+            Node::TsTypeAnn(type_ann) => !matches!(type_ann.type_ann, TsType::TsUnionOrIntersectionType(_)),
             _ => true,
           }
         } else {
@@ -7096,35 +7104,21 @@ fn gen_for_member_like_expr_item<'a>(item: &MemberLikeExprItem<'a>, context: &mu
         if !is_first {
           if is_optional {
             items.push_str("?.");
-          } else {
+          } else if node.kind() != NodeKind::ComputedPropName {
             items.push_str(".");
           }
         }
         items.extend(node_items);
         items
       })
     }
-    MemberLikeExprItem::Computed(node) => {
-      let is_optional = item.is_optional();
+    MemberLikeExprItem::Token(token) => {
+      // don't bother with intertwined comments as its too much trouble
       let mut items = PrintItems::new();
-
-      if is_optional {
-        items.push_str("?.");
+      if !is_first {
+        items.push_str(".");
       }
-      items.extend(gen_computed_prop_like(
-        |context| gen_node(node.inner_node, context),
-        GenComputedPropLikeOptions {
-          inner_node_span: node.inner_node.span(),
-        },
-        context,
-      ));
-
-      if !is_last {
-        // Manually generate the trailing comments of the close bracket token
-        // because it doesn't go through the gen_node method
-        items.extend(gen_trailing_comments(item, context));
-      }
-
+      items.push_str(token.text_fast(context.program));
       items
     }
     MemberLikeExprItem::CallExpr(node) => {
@@ -7164,8 +7158,7 @@ fn gen_for_flattened_member_like_expr<'a>(node: FlattenedMemberLikeExpr<'a>, con
   for (i, item) in node.nodes.iter().enumerate().skip(1) {
     let force_use_new_line =
       !context.config.member_expression_prefer_single_line && node_helpers::get_use_new_lines_for_nodes(&node.nodes[i - 1], &node.nodes[i], context.program);
-    let is_optional = item.is_optional();
-    if is_optional || !item.is_computed() {
+    if item.is_optional() || !item.is_computed() {
       if force_use_new_line {
         items.push_signal(Signal::NewLine);
       } else if !context.config.member_expression_line_per_expression {
@@ -7909,7 +7902,7 @@ fn gen_jsx_children<'a>(opts: GenJsxChildrenOptions<'a>, context: &mut Context<'
         inner_span,
         items: children.into_iter().map(|(a, b)| (a, Some(b.into()))).collect(),
         should_use_space: Some(Box::new(|previous, next, context| {
-          if has_jsx_space_between(previous, next, &context.program) {
+          if has_jsx_space_between(previous, next, context.program) {
             true
           } else if let Node::JSXText(element) = previous {
             element.text_fast(context.program).ends_with(' ')
@@ -7920,7 +7913,7 @@ fn gen_jsx_children<'a>(opts: GenJsxChildrenOptions<'a>, context: &mut Context<'
           }
         })),
         should_use_new_line: Some(Box::new(|previous, next, context| {
-          if has_jsx_space_between(previous, next, &context.program) {
+          if has_jsx_space_between(previous, next, context.program) {
             false // prefer collapsing
           } else if let Node::JSXText(next) = next {
             !utils::has_no_new_lines_in_leading_whitespace(next.text_fast(context.program))
@@ -8512,16 +8505,21 @@ fn allows_inline_multi_line(node: &Node, context: &Context, has_siblings: bool)
 
   fn allow_inline_for_call_expr(node: &CallExpr) -> bool {
     // do not allow call exprs with nested call exprs in the member expr to be inline
-    return allow_for_expr_or_super(&node.callee);
+    return allow_for_callee(&node.callee);
 
-    fn allow_for_expr_or_super(expr_or_super: &ExprOrSuper) -> bool {
-      match expr_or_super {
-        ExprOrSuper::Expr(expr) => match expr {
-          Expr::Member(member_expr) => allow_for_expr_or_super(&member_expr.obj),
-          Expr::Call(_) => false,
-          _ => true,
-        },
-        ExprOrSuper::Super(_) => true,
+    fn allow_for_callee(callee: &Callee) -> bool {
+      match callee {
+        Callee::Expr(expr) => allow_for_expr(expr),
+        Callee::Import(_) => false,
+        Callee::Super(_) => true,
+      }
+    }
+
+    fn allow_for_expr(expr: &Expr) -> bool {
+      match expr {
+        Expr::Member(member_expr) => allow_for_expr(&member_expr.obj),
+        Expr::Call(_) => false,
+        _ => true,
       }
     }
   }

src/generation/parser_types.rs src/generation/generate_types.rssrc/generation/parser_types.rs renamed to src/generation/generate_types.rs

@@ -1,17 +1,17 @@
 mod comments;
 mod context;
+mod generate;
+mod generate_types;
 mod helpers;
 mod node_helpers;
-mod parser;
-mod parser_types;
 mod sorting;
 mod swc;
 mod tokens;
 
 use comments::*;
 use context::*;
+use generate_types::*;
 use helpers::*;
-use parser_types::*;
 use tokens::*;
 
-pub use parser::generate;
+pub use generate::generate;

src/generation/mod.rs

@@ -172,8 +172,8 @@ pub fn is_test_library_call_expr(node: &CallExpr, program: &Program) -> bool {
 
   return node.start_line_fast(program) == node.args[1].start_line_fast(program);
 
-  fn is_valid_callee(callee: &ExprOrSuper) -> bool {
-    return match get_first_identifier_text(&callee) {
+  fn is_valid_callee(callee: &Callee) -> bool {
+    return match get_first_identifier_text_from_callee(&callee) {
       Some("it") | Some("describe") | Some("test") => true,
       _ => {
         // support call expressions like `Deno.test("description", ...)`
@@ -184,27 +184,38 @@ pub fn is_test_library_call_expr(node: &CallExpr, program: &Program) -> bool {
       }
     };
 
-    fn get_first_identifier_text<'a>(callee: &'a ExprOrSuper<'a>) -> Option<&'a str> {
-      return match callee {
-        ExprOrSuper::Super(_) => None,
-        ExprOrSuper::Expr(expr) => match expr {
-          Expr::Ident(ident) => Some(ident.sym()),
-          Expr::Member(member) if member.prop.kind() == NodeKind::Ident => get_first_identifier_text(&member.obj),
-          _ => None,
-        },
-      };
+    fn get_first_identifier_text_from_callee<'a>(callee: &'a Callee<'a>) -> Option<&'a str> {
+      match callee {
+        Callee::Super(_) | Callee::Import(_) => None,
+        Callee::Expr(expr) => get_first_identifier_text_from_expr(expr),
+      }
+    }
+
+    fn get_first_identifier_text_from_expr<'a>(expr: &'a Expr<'a>) -> Option<&'a str> {
+      match expr {
+        Expr::Ident(ident) => Some(ident.sym()),
+        Expr::Member(member) if member.prop.kind() == NodeKind::Ident => get_first_identifier_text_from_expr(&member.obj),
+        _ => None,
+      }
     }
 
-    fn get_last_identifier_text<'a>(callee: &'a ExprOrSuper<'a>) -> Option<&'a str> {
+    fn get_last_identifier_text<'a>(callee: &'a Callee<'a>) -> Option<&'a str> {
       return match callee {
-        ExprOrSuper::Super(_) => None,
-        ExprOrSuper::Expr(expr) => get_last_identifier_text_from_expr(expr),
+        Callee::Expr(expr) => from_expr(expr),
+        Callee::Super(_) | Callee::Import(_) => None,
       };
 
-      fn get_last_identifier_text_from_expr<'a>(expr: &'a Expr<'a>) -> Option<&'a str> {
+      fn from_expr<'a>(expr: &'a Expr<'a>) -> Option<&'a str> {
         match expr {
           Expr::Ident(ident) => Some(ident.sym()),
-          Expr::Member(member) if (member.obj).kind() == NodeKind::Ident => get_last_identifier_text_from_expr(&member.prop),
+          Expr::Member(member) if (member.obj).kind() == NodeKind::Ident => from_member_prop(&member.prop),
+          _ => None,
+        }
+      }
+
+      fn from_member_prop<'a>(member_prop: &'a MemberProp<'a>) -> Option<&'a str> {
+        match member_prop {
+          MemberProp::Ident(ident) => Some(ident.sym()),
           _ => None,
         }
       }