Struct AstFunctionPrefix 

struct AstFunctionPrefix<'db> {
    visibility: Option<AstVisibility<'db>>,
    effects: AstFunctionEffects<'db>,
    fn_keyword: Span<'db>,
}

The prefix parses a fn declaration up until the fn keyword. That is what we need to see to know that we should be parsing a function. Parsing always succeeds with Ok(Some) or errors; the intent is that you probe with can_eat.

Fields

visibility: Option<AstVisibility<'db>>

Visibility of the class

effects: AstFunctionEffects<'db>

fn_keyword: Span<'db>

Trait Implementations

impl<'db> Parse<'db> for AstFunctionPrefix<'db>

type Output = AstFunctionPrefix<'db>

fn opt_parse( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<Self>, ParseFail<'db>>

Parse a single instance of Self, returning Ok(Some(v)). Returns Ok(None) if Self was not present or Err(err) if Self appeared to be present but was ill-formed.

fn expected() -> Expected

fn can_eat(db: &'db dyn Db, parser: &Parser<'_, 'db>) -> bool

Speculatively parses to see if we could eat a Self without any error. Never consumes tokens nor produces an error.

fn eat( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Self::Output, ParseFail<'db>>

Parses an instance of Self from the given Parser, reporting an error if no instance is found.

fn eat_comma( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>>

Parse zero-or-more comma-separated instances of Self returning a vector. Accepts trailing commas.

fn eat_many( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>>

Parse zero-or-more instances of Self returning a vector.

fn eat_delimited<T>( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, delimiter: Delimiter, eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>, ) -> Result<T, ParseFail<'db>>

Eat a comma separated list of Self, delimited by delimiter (e.g., (a, b, c)).

fn opt_parse_delimited<T>( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, delimiter: Delimiter, eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>, ) -> Result<Option<T>, ParseFail<'db>>

Parse a delimited list of Self e.g., (a, b, c) or [a, b, c]. Returns None if the given delimiters indicated by delimiter are not found.

fn opt_parse_comma( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>>

Parse a comma separated list of Self

fn opt_parse_separated( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, separator: Op, ) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>>

Parse a separator separated list of Self

fn opt_parse_guarded( guard_op: impl ParseGuard, db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<Self::Output>, ParseFail<'db>>

If guard_op appears, then parse Self

impl<'db> Update for AstFunctionPrefix<'db>

unsafe fn maybe_update(old_pointer_: *mut Self, new_value_: Self) -> bool

Returns