remove allow(dead_code)

Author: nathanwhit

src/generation/generate.rs

@@ -9048,15 +9048,6 @@ fn gen_for_member_like_expr_item<'a>(item: &MemberLikeExprItem<'a>, context: &mu
       }
       items
     }
-    MemberLikeExprItem::Token(token) => {
-      // don't bother with intertwined comments as its too much trouble
-      let mut items = PrintItems::new();
-      if !is_first {
-        items.push_sc(sc!("."));
-      }
-      items.push_string(token.text_fast(context.program).to_string());
-      items
-    }
     MemberLikeExprItem::CallExpr(node) => {
       let mut items = PrintItems::new();
 

src/generation/generate_types.rs

@@ -167,29 +167,6 @@ fn get_inner_range_for_object_like(range: &SourceRange) -> SourceRange {
   SourceRange::new(range.start + 1, range.end - 1)
 }
 
-pub trait NodeExtensions<'a> {
-  fn get_type_parameters(&self) -> Option<&'a TSTypeParameterDeclaration<'a>>;
-}
-
-impl<'a> NodeExtensions<'a> for Node<'a> {
-  fn get_type_parameters(&self) -> Option<&'a TSTypeParameterDeclaration<'a>> {
-    match self {
-      Node::Class(node) => node.type_parameters.as_deref(),
-      Node::TSInterfaceDeclaration(node) => node.type_parameters.as_deref(),
-      Node::Function(node) => node.type_parameters.as_deref(),
-      Node::MethodDefinition(node) => node.value.type_parameters.as_deref(),
-      Node::TSTypeAliasDeclaration(node) => node.type_parameters.as_deref(),
-      Node::ArrowFunctionExpression(node) => node.type_parameters.as_deref(),
-      Node::TSCallSignatureDeclaration(node) => node.type_parameters.as_deref(),
-      Node::TSConstructSignatureDeclaration(node) => node.type_parameters.as_deref(),
-      Node::TSMethodSignature(node) => node.type_parameters.as_deref(),
-      Node::TSConstructorType(node) => node.type_parameters.as_deref(),
-      Node::TSFunctionType(node) => node.type_parameters.as_deref(),
-      _ => None,
-    }
-  }
-}
-
 /* ParametersRanged */
 
 pub trait ParametersRanged {

src/generation/mod.rs

@@ -3,26 +3,17 @@
 // commented out (kept on disk as the porting reference) and `generate` is a stub
 // so the rest of the crate compiles and can be exercised.
 
-#[allow(dead_code)]
 mod comments;
-#[allow(dead_code)]
 mod context;
-#[allow(dead_code)]
 mod oxc_helpers;
-#[allow(dead_code)]
 mod to_node;
-#[allow(dead_code)]
 mod tokens;
 
-#[allow(dead_code)]
 mod swc;
 
-#[allow(dead_code)]
 mod sorting;
 
-#[allow(dead_code)]
 mod generate_types;
-#[allow(dead_code)]
 mod node_helpers;
 
 mod generate;

src/generation/node_helpers.rs

@@ -101,19 +101,6 @@ pub fn has_surrounding_different_line_comments<'a>(node: Node<'a>, program: Prog
   false
 }
 
-pub fn nodes_have_only_spaces_between<'a>(previous_node: Node<'a>, next_node: Node<'a>, program: ProgramInfo<'a>) -> bool {
-  if let Node::JSXText(previous_node) = previous_node {
-    let previous_node_text = previous_node.text_fast(program);
-    crate::utils::has_no_new_lines_in_trailing_whitespace(previous_node_text) && previous_node_text.ends_with(' ')
-  } else if let Node::JSXText(next_node) = next_node {
-    let next_node_text = next_node.text_fast(program);
-    crate::utils::has_no_new_lines_in_leading_whitespace(next_node_text) && next_node_text.starts_with(' ')
-  } else {
-    let between_text = &program.text()[previous_node.end() as usize..next_node.start() as usize];
-    crate::utils::is_not_empty_and_only_spaces(between_text)
-  }
-}
-
 pub fn has_jsx_space_expr_text(node: Node, program: ProgramInfo) -> bool {
   get_jsx_space_expr_space_count(node, program) > 0
 }

src/generation/oxc_helpers.rs

@@ -69,11 +69,6 @@ impl<'a> ProgramInfo<'a> {
     }
   }
 
-  #[inline]
-  pub fn program(&self) -> &'a Program<'a> {
-    self.program
-  }
-
   #[inline]
   pub fn text_info(&self) -> &'a SourceTextInfo {
     self.text_info
@@ -204,11 +199,6 @@ impl<'a> CommentsIterator<'a> {
     self.comments.extend(other);
   }
 
-  /// Remaining comments without consuming the iterator.
-  pub fn as_slice(&self) -> &[&'a Comment] {
-    &self.comments[self.index..]
-  }
-
   /// The last remaining comment without consuming the iterator.
   pub fn peek_last_comment(&self) -> Option<&'a Comment> {
     self.comments[self.index..].last().copied()
@@ -401,10 +391,8 @@ impl RangeContains for SourceRange {
 /// code invoked directly on positions live here. There's no ambiguity with
 /// `SourceRanged` because `u32` doesn't implement `GetSpan`.
 pub trait PosExt {
-  fn as_source_pos(&self) -> SourcePos;
   fn range(&self) -> SourceRange;
   fn start(&self) -> SourcePos;
-  fn end(&self) -> SourcePos;
   fn start_line_fast(&self, program: ProgramInfo) -> usize;
   fn end_line_fast(&self, program: ProgramInfo) -> usize;
   fn start_column_fast(&self, program: ProgramInfo) -> usize;
@@ -416,11 +404,6 @@ pub trait PosExt {
 }
 
 impl PosExt for SourcePos {
-  #[inline]
-  fn as_source_pos(&self) -> SourcePos {
-    *self
-  }
-
   #[inline]
   fn range(&self) -> SourceRange {
     SourceRange::new(*self, *self)
@@ -431,11 +414,6 @@ impl PosExt for SourcePos {
     *self
   }
 
-  #[inline]
-  fn end(&self) -> SourcePos {
-    *self
-  }
-
   fn start_line_fast(&self, program: ProgramInfo) -> usize {
     self.line_fast(program)
   }

src/generation/swc/extensions.rs

@@ -4,15 +4,11 @@ pub trait BinaryOpExtensions {
   fn is_add_sub(&self) -> bool;
   fn is_mul_div(&self) -> bool;
   fn is_bitwise_or_arithmetic(&self) -> bool;
-  fn is_logical(&self) -> bool;
   fn is_bit_logical(&self) -> bool;
   fn is_bit_shift(&self) -> bool;
   fn is_equality(&self) -> bool;
 }
 
-// Note: SWC's `BinaryOp` unified logical and binary operators; oxc splits them
-// into `BinaryOperator` and `LogicalOperator`. Logical operators are therefore
-// handled via `LogicalExpression` nodes, and `is_logical` here is always false.
 impl BinaryOpExtensions for BinaryOperator {
   fn is_add_sub(&self) -> bool {
     matches!(self, BinaryOperator::Addition | BinaryOperator::Subtraction)
@@ -39,10 +35,6 @@ impl BinaryOpExtensions for BinaryOperator {
     )
   }
 
-  fn is_logical(&self) -> bool {
-    false
-  }
-
   fn is_bit_logical(&self) -> bool {
     matches!(self, BinaryOperator::BitwiseOR | BinaryOperator::BitwiseAnd | BinaryOperator::BitwiseXOR)
   }

src/generation/swc/flatten_member_like_expr.rs

@@ -1,5 +1,4 @@
 use deno_ast::oxc::ast::ast::ChainElement;
-use deno_ast::oxc::parser::Token;
 use deno_ast::oxc::span::GetSpan;
 use deno_ast::oxc::span::Span;
 
@@ -27,7 +26,6 @@ pub enum MemberLikeExprItem<'a> {
     range: Span,
     is_optional: bool,
   },
-  Token(&'a Token),
   CallExpr(Box<MemberLikeExprItemCallExpr<'a>>),
 }
 
@@ -36,7 +34,6 @@ impl<'a> GetSpan for MemberLikeExprItem<'a> {
     match self {
       MemberLikeExprItem::Node { node, .. } => node.span(),
       MemberLikeExprItem::Computed { range, .. } => *range,
-      MemberLikeExprItem::Token(token) => Span::new(token.start(), token.end()),
       MemberLikeExprItem::CallExpr(call_expr) => Span::new(call_expr.callee.span().start, call_expr.original_call_expr.end()),
     }
   }
@@ -51,15 +48,6 @@ impl<'a> MemberLikeExprItem<'a> {
     match self {
       MemberLikeExprItem::Node { is_optional, .. } | MemberLikeExprItem::Computed { is_optional, .. } => *is_optional,
       MemberLikeExprItem::CallExpr(call_expr) => call_expr.original_call_expr.is_optional(),
-      MemberLikeExprItem::Token(_) => false,
-    }
-  }
-
-  fn get_top_node(&self) -> Option<Node<'a>> {
-    match self {
-      MemberLikeExprItem::Node { node, .. } | MemberLikeExprItem::Computed { node, .. } => Some(*node),
-      MemberLikeExprItem::Token(_) => None,
-      MemberLikeExprItem::CallExpr(call_expr) => Some(Node::CallExpression(call_expr.original_call_expr.inner())),
     }
   }
 }

src/utils/string_utils.rs

@@ -66,20 +66,6 @@ pub fn has_no_new_lines_in_trailing_whitespace(text: &str) -> bool {
   true
 }
 
-pub fn is_not_empty_and_only_spaces(text: &str) -> bool {
-  if text.is_empty() {
-    return false;
-  }
-
-  for c in text.chars() {
-    if c != ' ' {
-      return false;
-    }
-  }
-
-  true
-}
-
 #[derive(Debug, PartialEq, Eq)]
 pub struct SplitLinesItem<'a> {
   pub text: &'a str,