Clean up

Author: Armd04

crates/deno_task_shell/src/parser.rs

@@ -426,16 +426,11 @@ pub enum ArithmeticPart {
     operator: BinaryOp,
     right: Box<ArithmeticPart>,
   },
-  #[error("Invalid pre arithmetic expression")]
-  PreArithmeticExpr {
-    operator: PreArithmeticOp,
+  #[error("Invalid unary arithmetic expression")]
+  UnaryAritheticExpr {
+    operator: UnaryArithmeticOp,
     operand: Box<ArithmeticPart>,
   },
-  #[error("Invalid post arithmetic expression")]
-  PostArithmeticExpr {
-    operand: Box<ArithmeticPart>,
-    operator: PostArithmeticOp,
-  },
   #[error("Invalid variable")]
   Variable(String),
   #[error("Invalid number")]
@@ -498,6 +493,14 @@ pub enum PostArithmeticOp {
   Decrement, // --
 }
 
+#[cfg_attr(feature = "serialization", derive(serde::Serialize))]
+#[cfg_attr(feature = "serialization", serde(rename_all = "camelCase"))]
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum UnaryArithmeticOp {
+  Pre(PreArithmeticOp),
+  Post(PostArithmeticOp),
+}
+
 #[cfg_attr(feature = "serialization", derive(serde::Serialize))]
 #[cfg_attr(
   feature = "serialization",
@@ -1460,16 +1463,16 @@ fn unary_pre_arithmetic_expr(pair: Pair<Rule>) -> Result<ArithmeticPart> {
   match first.as_rule() {
     Rule::pre_arithmetic_op => {
       let op = parse_pre_arithmetic_op(first)?;
-      Ok(ArithmeticPart::PreArithmeticExpr {
-        operator: op,
-        operand: (Box::new(operand)),
+      Ok(ArithmeticPart::UnaryAritheticExpr {
+        operator: UnaryArithmeticOp::Pre(op),
+        operand: Box::new(operand),
       })
     }
     Rule::post_arithmetic_op => {
       let op = parse_pre_arithmetic_op(first)?;
-      Ok(ArithmeticPart::PreArithmeticExpr {
-        operator: op,
-        operand: (Box::new(operand)),
+      Ok(ArithmeticPart::UnaryAritheticExpr {
+        operator: UnaryArithmeticOp::Pre(op),
+        operand: Box::new(operand),
       })
     }
     _ => Err(miette!(
@@ -1502,17 +1505,17 @@ fn unary_post_arithmetic_expr(pair: Pair<Rule>) -> Result<ArithmeticPart> {
     )),
   }?;
   let op = parse_post_arithmetic_op(second)?;
-  Ok(ArithmeticPart::PostArithmeticExpr {
-    operator: op,
-    operand: (Box::new(operand)),
+  Ok(ArithmeticPart::UnaryAritheticExpr {
+    operator: UnaryArithmeticOp::Post(op),
+    operand: Box::new(operand),
   })
 }
 
 fn parse_pre_arithmetic_op(pair: Pair<Rule>) -> Result<PreArithmeticOp> {
   let first = pair
     .into_inner()
     .next()
-    .ok_or_else(|| miette!("Expected increment or decreament operator"))?;
+    .ok_or_else(|| miette!("Expected increment or decrement operator"))?;
   match first.as_rule() {
     Rule::increment => Ok(PreArithmeticOp::Increment),
     Rule::decrement => Ok(PreArithmeticOp::Decrement),
@@ -1531,7 +1534,7 @@ fn parse_post_arithmetic_op(pair: Pair<Rule>) -> Result<PostArithmeticOp> {
   let first = pair
     .into_inner()
     .next()
-    .ok_or_else(|| miette!("Expected increment or decreament operator"))?;
+    .ok_or_else(|| miette!("Expected increment or decrement operator"))?;
   match first.as_rule() {
     Rule::increment => Ok(PostArithmeticOp::Increment),
     Rule::decrement => Ok(PostArithmeticOp::Decrement),

crates/deno_task_shell/src/shell/execute.rs

@@ -13,48 +13,23 @@ use thiserror::Error;
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
 
-use crate::parser::AssignmentOp;
-use crate::parser::BinaryOp;
-use crate::parser::Condition;
-use crate::parser::ConditionInner;
-use crate::parser::ElsePart;
-use crate::parser::IoFile;
-use crate::parser::PostArithmeticOp;
-use crate::parser::PreArithmeticOp;
-use crate::parser::RedirectOpInput;
-use crate::parser::RedirectOpOutput;
-use crate::parser::UnaryOp;
-use crate::shell::commands::ShellCommand;
-use crate::shell::commands::ShellCommandContext;
-use crate::shell::types::pipe;
-use crate::shell::types::ArithmeticResult;
-use crate::shell::types::ArithmeticValue;
-use crate::shell::types::EnvChange;
-use crate::shell::types::ExecuteResult;
-use crate::shell::types::FutureExecuteResult;
-use crate::shell::types::ShellPipeReader;
-use crate::shell::types::ShellPipeWriter;
-use crate::shell::types::ShellState;
-
-use crate::parser::Arithmetic;
-use crate::parser::ArithmeticPart;
-use crate::parser::BinaryArithmeticOp;
-use crate::parser::Command;
-use crate::parser::CommandInner;
-use crate::parser::IfClause;
-use crate::parser::PipeSequence;
-use crate::parser::PipeSequenceOperator;
-use crate::parser::Pipeline;
-use crate::parser::PipelineInner;
-use crate::parser::Redirect;
-use crate::parser::RedirectFd;
-use crate::parser::RedirectOp;
-use crate::parser::Sequence;
-use crate::parser::SequentialList;
-use crate::parser::SimpleCommand;
-use crate::parser::Word;
-use crate::parser::WordPart;
-use crate::shell::types::WordEvalResult;
+use crate::parser::{
+  AssignmentOp, BinaryOp, Condition, ConditionInner, ElsePart, IoFile,
+  RedirectOpInput, RedirectOpOutput, UnaryArithmeticOp, UnaryOp,
+};
+use crate::shell::commands::{ShellCommand, ShellCommandContext};
+use crate::shell::types::{
+  pipe, ArithmeticResult, ArithmeticValue, EnvChange, ExecuteResult,
+  FutureExecuteResult, ShellPipeReader, ShellPipeWriter, ShellState,
+  WordEvalResult,
+};
+
+use crate::parser::{
+  Arithmetic, ArithmeticPart, BinaryArithmeticOp, Command, CommandInner,
+  IfClause, PipeSequence, PipeSequenceOperator, Pipeline, PipelineInner,
+  Redirect, RedirectFd, RedirectOp, Sequence, SequentialList, SimpleCommand,
+  Word, WordPart,
+};
 
 use super::command::execute_unresolved_command_name;
 use super::command::UnresolvedCommandName;
@@ -643,13 +618,17 @@ async fn evaluate_arithmetic_part(
       let rhs = Box::pin(evaluate_arithmetic_part(right, state)).await?;
       apply_conditional_binary_op(lhs, operator, rhs)
     }
-    ArithmeticPart::PostArithmeticExpr { operand, operator } => {
+    // ArithmeticPart::PostArithmeticExpr { operand, operator } => {
+    //   let val = Box::pin(evaluate_arithmetic_part(operand, state)).await?;
+    //   apply_post_op(state, *operator, val, operand)
+    // }
+    // ArithmeticPart::PreArithmeticExpr { operator, operand } => {
+    //   let val = Box::pin(evaluate_arithmetic_part(operand, state)).await?;
+    //   apply_pre_op(state, *operator, val, operand)
+    // }
+    ArithmeticPart::UnaryAritheticExpr { operator, operand } => {
       let val = Box::pin(evaluate_arithmetic_part(operand, state)).await?;
-      apply_post_op(state, *operator, val, operand)
-    }
-    ArithmeticPart::PreArithmeticExpr { operator, operand } => {
-      let val = Box::pin(evaluate_arithmetic_part(operand, state)).await?;
-      apply_pre_op(state, *operator, val, operand)
+      apply_unary_op(state, *operator, val, operand)
     }
     ArithmeticPart::Variable(name) => state
       .get_var(name)
@@ -732,51 +711,16 @@ fn apply_conditional_binary_op(
   }
 }
 
-fn apply_pre_op(
-  state: &mut ShellState,
-  op: PreArithmeticOp,
-  val: ArithmeticResult,
-  operand: &ArithmeticPart,
-) -> Result<ArithmeticResult, Error> {
-  match op {
-    PreArithmeticOp::Increment => {
-      let result = val.pre_increment(operand)?;
-      let result_clone = result.clone();
-      state.apply_changes(&result_clone.changes);
-      Ok(result)
-    }
-    PreArithmeticOp::Decrement => {
-      let result = val.pre_decreament(operand)?;
-      let result_clone = result.clone();
-      state.apply_changes(&result_clone.changes);
-      Ok(result)
-    }
-    _ => {
-      todo!("Pre arithmetic operator {:?} is not implemented", op)
-    }
-  }
-}
-
-fn apply_post_op(
+fn apply_unary_op(
   state: &mut ShellState,
-  op: PostArithmeticOp,
+  op: UnaryArithmeticOp,
   val: ArithmeticResult,
   operand: &ArithmeticPart,
 ) -> Result<ArithmeticResult, Error> {
-  match op {
-    PostArithmeticOp::Increment => {
-      let result = val.post_increment(operand)?;
-      let result_clone = result.clone();
-      state.apply_changes(&result_clone.changes);
-      Ok(result)
-    }
-    PostArithmeticOp::Decrement => {
-      let result = val.post_decreament(operand)?;
-      let result_clone = result.clone();
-      state.apply_changes(&result_clone.changes);
-      Ok(result)
-    }
-  }
+  let result = val.unary_op(operand, op)?;
+  let result_clone = result.clone();
+  state.apply_changes(&result_clone.changes);
+  Ok(result)
 }
 
 async fn execute_pipe_sequence(