From 4f0e11383e4fb97fd02c9dbc86ef238e8a52323d Mon Sep 17 00:00:00 2001
From: Peter Ammon <rf@fishshell.com>
Date: Sun, 27 Apr 2025 12:37:28 -0700
Subject: [PATCH] ast: Remove as_mut_foo() functions

Kinds have replaced these.
---
 src/ast.rs | 215 -----------------------------------------------------
 1 file changed, 215 deletions(-)

diff --git a/src/ast.rs b/src/ast.rs
index 2201b356c..ae18cc502 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -533,221 +533,6 @@ fn as_job_list(&self) -> Option<&JobList> {
             _ => None,
         }
     }
-
-    // Mutable variants.
-    fn as_mut_redirection(&mut self) -> Option<&mut Redirection> {
-        match self.kind_mut() {
-            KindMut::Redirection(node) => Some(node),
-            _ => None,
-        }
-    }
-
-    fn as_mut_variable_assignment(&mut self) -> Option<&mut VariableAssignment> {
-        match self.kind_mut() {
-            KindMut::VariableAssignment(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_variable_assignment_list(&mut self) -> Option<&mut VariableAssignmentList> {
-        match self.kind_mut() {
-            KindMut::VariableAssignmentList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_argument_or_redirection(&mut self) -> Option<&mut ArgumentOrRedirection> {
-        match self.kind_mut() {
-            KindMut::ArgumentOrRedirection(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_argument_or_redirection_list(&mut self) -> Option<&mut ArgumentOrRedirectionList> {
-        match self.kind_mut() {
-            KindMut::ArgumentOrRedirectionList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_statement(&mut self) -> Option<&mut Statement> {
-        match self.kind_mut() {
-            KindMut::Statement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_pipeline(&mut self) -> Option<&mut JobPipeline> {
-        match self.kind_mut() {
-            KindMut::JobPipeline(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_conjunction(&mut self) -> Option<&mut JobConjunction> {
-        match self.kind_mut() {
-            KindMut::JobConjunction(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_for_header(&mut self) -> Option<&mut ForHeader> {
-        match self.kind_mut() {
-            KindMut::ForHeader(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_while_header(&mut self) -> Option<&mut WhileHeader> {
-        match self.kind_mut() {
-            KindMut::WhileHeader(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_function_header(&mut self) -> Option<&mut FunctionHeader> {
-        match self.kind_mut() {
-            KindMut::FunctionHeader(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_begin_header(&mut self) -> Option<&mut BeginHeader> {
-        match self.kind_mut() {
-            KindMut::BeginHeader(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_block_statement(&mut self) -> Option<&mut BlockStatement> {
-        match self.kind_mut() {
-            KindMut::BlockStatement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_brace_statement(&mut self) -> Option<&mut BraceStatement> {
-        match self.kind_mut() {
-            KindMut::BraceStatement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_if_clause(&mut self) -> Option<&mut IfClause> {
-        match self.kind_mut() {
-            KindMut::IfClause(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_elseif_clause(&mut self) -> Option<&mut ElseifClause> {
-        match self.kind_mut() {
-            KindMut::ElseifClause(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_elseif_clause_list(&mut self) -> Option<&mut ElseifClauseList> {
-        match self.kind_mut() {
-            KindMut::ElseifClauseList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_else_clause(&mut self) -> Option<&mut ElseClause> {
-        match self.kind_mut() {
-            KindMut::ElseClause(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_if_statement(&mut self) -> Option<&mut IfStatement> {
-        match self.kind_mut() {
-            KindMut::IfStatement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_case_item(&mut self) -> Option<&mut CaseItem> {
-        match self.kind_mut() {
-            KindMut::CaseItem(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_switch_statement(&mut self) -> Option<&mut SwitchStatement> {
-        match self.kind_mut() {
-            KindMut::SwitchStatement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_decorated_statement(&mut self) -> Option<&mut DecoratedStatement> {
-        match self.kind_mut() {
-            KindMut::DecoratedStatement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_not_statement(&mut self) -> Option<&mut NotStatement> {
-        match self.kind_mut() {
-            KindMut::NotStatement(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_continuation(&mut self) -> Option<&mut JobContinuation> {
-        match self.kind_mut() {
-            KindMut::JobContinuation(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_continuation_list(&mut self) -> Option<&mut JobContinuationList> {
-        match self.kind_mut() {
-            KindMut::JobContinuationList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_conjunction_continuation(&mut self) -> Option<&mut JobConjunctionContinuation> {
-        match self.kind_mut() {
-            KindMut::JobConjunctionContinuation(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_andor_job(&mut self) -> Option<&mut AndorJob> {
-        match self.kind_mut() {
-            KindMut::AndorJob(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_andor_job_list(&mut self) -> Option<&mut AndorJobList> {
-        match self.kind_mut() {
-            KindMut::AndorJobList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_freestanding_argument_list(&mut self) -> Option<&mut FreestandingArgumentList> {
-        match self.kind_mut() {
-            KindMut::FreestandingArgumentList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_conjunction_continuation_list(
-        &mut self,
-    ) -> Option<&mut JobConjunctionContinuationList> {
-        match self.kind_mut() {
-            KindMut::JobConjunctionContinuationList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_maybe_newlines(&mut self) -> Option<&mut MaybeNewlines> {
-        match self.kind_mut() {
-            KindMut::MaybeNewlines(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_case_item_list(&mut self) -> Option<&mut CaseItemList> {
-        match self.kind_mut() {
-            KindMut::CaseItemList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_argument(&mut self) -> Option<&mut Argument> {
-        match self.kind_mut() {
-            KindMut::Argument(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_argument_list(&mut self) -> Option<&mut ArgumentList> {
-        match self.kind_mut() {
-            KindMut::ArgumentList(node) => Some(node),
-            _ => None,
-        }
-    }
-    fn as_mut_job_list(&mut self) -> Option<&mut JobList> {
-        match self.kind_mut() {
-            KindMut::JobList(node) => Some(node),
-            _ => None,
-        }
-    }
 }
 
 /// Trait for all "leaf" nodes: nodes with no ast children.