Struct Mutator

Source

pub struct Mutator<'a, T: Debug + Clone, const N: usize> {
    pub mutated: [bool; N],
    pub mutator: &'a T,
}

Expand description

The Mutator struct is used to mutate an AST in very targeted way. The Mutator struct is totally generic, so it can be thought of a game console: its purpose is to mutate an AST but it doesn’t know how to do it until an implementor is loaded. This implementor will tell Mutator how it should behave.

A new Mutator can be easily created using Mutator::default(), which returns a Mutator<'_, EmptyMutator, 1>. This Mutator is useless up to this point, but thanks to the ToMutate trait, an implementor can be seamlessly loaded to the Mutator, releasing its whole power.

Once configured, the mutate method can be called to mutate the AST.

use test_builder::TestBuilder;
use rust_writer::ast::{
  mutator::{Mutator, ToMutate},
  implementors::ItemToTrait
};
use syn::{
  visit_mut::VisitMut,
  parse_quote,
  TraitItem
};

TestBuilder::default()
 .with_trait_ast()
 .execute(|mut builder|{
  let ast = builder.get_mut_ast_file("trait.rs").expect("This exists; qed;");

  // Define the ItemToTrait implementor. This implementor means:
  // 1. We're looking inside a trait called `MyTrait`   .
  // 2. We're interested in adding a type called `Type3` with trait bound `From<String>` to
  //    that trait.
  let item_to_trait: ItemToTrait =
   ("MyTrait", parse_quote! {type Type3: From<String>;}).into();

  // Create the Mutator and load this particular implementor
  let mut mutator = Mutator::default().to_mutate(&item_to_trait);

  // Mutate the AST
  assert!(mutator.mutate(ast).is_ok());
});

Fields§

§mutated: [bool; N]

A Mutator can act in different parts of the AST at the same time. This array keeps track of which of these mutations succeeded.

§mutator: &'a T

Placeholder to load an implementor.

Struct MutatorCopy item path

Fields§

Implementations§

impl<'a, T, const N: usize> Mutator<'a, T, N>where T: Debug + Clone, Mutator<'a, T, N>: VisitMut,

pub fn mutate(&mut self, ast: &mut File) -> Result<(), Error>

impl<T, const N: usize> Mutator<'_, T, N>where T: Debug + Clone,

pub fn reset(&mut self)

Trait Implementations§

impl<'a, T: Clone + Debug + Clone, const N: usize> Clone for Mutator<'a, T, N>

fn clone(&self) -> Mutator<'a, T, N>

fn clone_from(&mut self, source: &Self)

impl<'a, T: Debug + Debug + Clone, const N: usize> Debug for Mutator<'a, T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Default for Mutator<'_, EmptyMutator, 1>

fn default() -> Self

impl<'a> ToMutate<'a, ItemToFile, 1> for Mutator<'_, EmptyMutator, 1>

fn to_mutate(self, mutator: &'a ItemToFile) -> Mutator<'a, ItemToFile, 1>

impl<'a> ToMutate<'a, ItemToImpl<'a>, 1> for Mutator<'_, EmptyMutator, 1>

fn to_mutate( self, mutator: &'a ItemToImpl<'a>, ) -> Mutator<'a, ItemToImpl<'a>, 1>

impl<'a> ToMutate<'a, ItemToMod<'a>, 1> for Mutator<'_, EmptyMutator, 1>

fn to_mutate(self, mutator: &'a ItemToMod<'a>) -> Mutator<'a, ItemToMod<'a>, 1>

impl<'a> ToMutate<'a, ItemToTrait<'a>, 1> for Mutator<'_, EmptyMutator, 1>

fn to_mutate( self, mutator: &'a ItemToTrait<'a>, ) -> Mutator<'a, ItemToTrait<'a>, 1>

impl<'a> ToMutate<'a, TokenStreamToMacro, 1> for Mutator<'_, EmptyMutator, 1>

fn to_mutate( self, mutator: &'a TokenStreamToMacro, ) -> Mutator<'a, TokenStreamToMacro, 1>

impl VisitMut for Mutator<'_, ItemToFile, 1>

fn visit_file_mut(&mut self, file: &mut File)

fn visit_abi_mut(&mut self, i: &mut Abi)

fn visit_angle_bracketed_generic_arguments_mut( &mut self, i: &mut AngleBracketedGenericArguments, )

fn visit_arm_mut(&mut self, i: &mut Arm)

fn visit_assoc_const_mut(&mut self, i: &mut AssocConst)

fn visit_assoc_type_mut(&mut self, i: &mut AssocType)

fn visit_attr_style_mut(&mut self, i: &mut AttrStyle)

fn visit_attribute_mut(&mut self, i: &mut Attribute)

fn visit_attributes_mut(&mut self, i: &mut Vec<Attribute>)

fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg)

fn visit_bare_variadic_mut(&mut self, i: &mut BareVariadic)

fn visit_bin_op_mut(&mut self, i: &mut BinOp)

fn visit_block_mut(&mut self, i: &mut Block)

fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes)

fn visit_captured_param_mut(&mut self, i: &mut CapturedParam)

fn visit_const_param_mut(&mut self, i: &mut ConstParam)

fn visit_constraint_mut(&mut self, i: &mut Constraint)

fn visit_data_mut(&mut self, i: &mut Data)

fn visit_data_enum_mut(&mut self, i: &mut DataEnum)

fn visit_data_struct_mut(&mut self, i: &mut DataStruct)

fn visit_data_union_mut(&mut self, i: &mut DataUnion)

fn visit_derive_input_mut(&mut self, i: &mut DeriveInput)

fn visit_expr_mut(&mut self, i: &mut Expr)

fn visit_expr_array_mut(&mut self, i: &mut ExprArray)

fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign)

fn visit_expr_async_mut(&mut self, i: &mut ExprAsync)

fn visit_expr_await_mut(&mut self, i: &mut ExprAwait)

fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary)

fn visit_expr_block_mut(&mut self, i: &mut ExprBlock)

fn visit_expr_break_mut(&mut self, i: &mut ExprBreak)

fn visit_expr_call_mut(&mut self, i: &mut ExprCall)

fn visit_expr_cast_mut(&mut self, i: &mut ExprCast)

fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure)

fn visit_expr_const_mut(&mut self, i: &mut ExprConst)

fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue)

fn visit_expr_field_mut(&mut self, i: &mut ExprField)

fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop)

fn visit_expr_group_mut(&mut self, i: &mut ExprGroup)

fn visit_expr_if_mut(&mut self, i: &mut ExprIf)

fn visit_expr_index_mut(&mut self, i: &mut ExprIndex)

fn visit_expr_infer_mut(&mut self, i: &mut ExprInfer)

fn visit_expr_let_mut(&mut self, i: &mut ExprLet)

fn visit_expr_lit_mut(&mut self, i: &mut ExprLit)

fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop)

fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro)

fn visit_expr_match_mut(&mut self, i: &mut ExprMatch)

fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall)

fn visit_expr_paren_mut(&mut self, i: &mut ExprParen)

fn visit_expr_path_mut(&mut self, i: &mut ExprPath)

fn visit_expr_range_mut(&mut self, i: &mut ExprRange)

fn visit_expr_raw_addr_mut(&mut self, i: &mut ExprRawAddr)

fn visit_expr_reference_mut(&mut self, i: &mut ExprReference)

fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat)

fn visit_expr_return_mut(&mut self, i: &mut ExprReturn)

Struct Mutator

impl<'a, T, const N: usize> Mutator<'a, T, N>
where T: Debug + Clone, Mutator<'a, T, N>: VisitMut,

impl<T, const N: usize> Mutator<'_, T, N>
where T: Debug + Clone,