Struct c2rust_refactor::matcher::MatchCtxt

pub struct MatchCtxt<'a, 'tcx: 'a> {
    pub bindings: Bindings,
    pub types: BindingTypes,
    pub debug: bool,
    // some fields omitted
}

Pattern-matching context. Stores configuration that affects pattern matching behavior, and collects bindings captured during the match.

Fields

bindings: Bindings

types: BindingTypes

debug: bool

Methods

impl<'a, 'tcx> MatchCtxt<'a, 'tcx>

pub fn new(
    st: &'a CommandState,
    cx: &'a RefactorCtxt<'a, 'tcx>
) -> MatchCtxt<'a, 'tcx>

pub fn parse_expr(&mut self, src: &str) -> P<Expr>

pub fn parse_pat(&mut self, src: &str) -> P<Pat>

pub fn parse_ty(&mut self, src: &str) -> P<Ty>

pub fn parse_stmts(&mut self, src: &str) -> Vec<Stmt>

pub fn parse_items(&mut self, src: &str) -> Vec<P<Item>>

pub fn try_match<T: TryMatch>(&mut self, pat: &T, target: &T) -> Result<()>

Try to match target against pat, updating self.bindings with the results.

pub fn from_match<T: TryMatch>(
    st: &'a CommandState,
    cx: &'a RefactorCtxt<'a, 'tcx>,
    pat: &T,
    target: &T
) -> Result<MatchCtxt<'a, 'tcx>>

Build a new MatchCtxt, and try to match target against pat in that context.

pub fn clone_match<T: TryMatch>(
    &self,
    pat: &T,
    target: &T
) -> Result<MatchCtxt<'a, 'tcx>>

Clone this context and try to perform a match in the clone, returning Ok if it succeeds.

pub fn set_type<S: IntoSymbol>(&mut self, name: S, ty: BindingType)

pub fn maybe_capture_ident(
    &mut self,
    pattern: &Ident,
    target: &Ident
) -> Result<bool>

Try to capture an ident. Returns Ok(true) if it captured, Ok(false) if pattern is not a capturing pattern, or Err(_) if capturing failed.

pub fn maybe_capture_label(
    &mut self,
    pattern: &Label,
    target: &Label
) -> Result<bool>

pub fn maybe_capture_path(
    &mut self,
    pattern: &Path,
    target: &Path
) -> Result<bool>

pub fn maybe_capture_expr(
    &mut self,
    pattern: &Expr,
    target: &Expr
) -> Result<bool>

pub fn maybe_capture_pat(&mut self, pattern: &Pat, target: &Pat) -> Result<bool>

pub fn maybe_capture_ty(&mut self, pattern: &Ty, target: &Ty) -> Result<bool>

pub fn maybe_capture_stmt(
    &mut self,
    pattern: &Stmt,
    target: &Stmt
) -> Result<bool>

pub fn do_marked<T, F>(
    &mut self,
    tts: &TokenStream,
    func: F,
    target: &T
) -> Result<()> where
    T: TryMatch + GetNodeId,
    F: for<'b> FnOnce(&mut Parser<'b>) -> PResult<'b, T>, 

Handle the marked!(...) matching form.

pub fn do_def_expr(&mut self, tts: &TokenStream, target: &Expr) -> Result<()>

Handle the def!(...) matching form for exprs.

pub fn do_def_ty(&mut self, tts: &TokenStream, target: &Ty) -> Result<()>

Handle the def!(...) matching form for exprs.

pub fn do_typed<T, F>(
    &mut self,
    tts: &TokenStream,
    func: F,
    target: &T
) -> Result<()> where
    T: TryMatch + GetNodeId,
    F: for<'b> FnOnce(&mut Parser<'b>) -> PResult<'b, T>, 

Handle the typed!(...) matching form.

pub fn do_cast<F>(
    &mut self,
    tts: &TokenStream,
    func: F,
    target: &Expr
) -> Result<()> where
    F: for<'b> FnOnce(&mut Parser<'b>) -> PResult<'b, P<Expr>>, 

Trait Implementations

impl<'a, 'tcx: 'a> Clone for MatchCtxt<'a, 'tcx>

fn clone(&self) -> MatchCtxt<'a, 'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.