Struct rustc_parse::parser::item::FnParseMode

source ·

pub(crate) struct FnParseMode {
    pub req_name: fn(_: Edition) -> bool,
    pub req_body: bool,
}

Expand description

Parsing configuration for functions.

The syntax of function items is slightly different within trait definitions, impl blocks, and modules. It is still parsed using the same code, just with different flags set, so that even when the input is wrong and produces a parse error, it still gets into the AST and the rest of the parser and type checker can run.

Fields§

§req_name: fn(_: Edition) -> bool

A function pointer that decides if, per-parameter p, p must have a pattern or just a type. This field affects parsing of the parameters list.

fn foo(alef: A) -> X { X::new() }
       -----^^ affects parsing this part of the function signature
       |
       if req_name returns false, then this name is optional

fn bar(A) -> X;
       ^
       |
       if req_name returns true, this is an error

Calling this function pointer should only return false if:

The item is being parsed inside of a trait definition. Within an impl block or a module, it should always evaluate to true.
The span is from Edition 2015. In particular, you can get a 2015 span inside a 2021 crate using macros.

§req_body: bool

If this flag is set to true, then plain, semicolon-terminated function prototypes are not allowed here.

fn foo(alef: A) -> X { X::new() }
                     ^^^^^^^^^^^^
                     |
                     this is always allowed

fn bar(alef: A, bet: B) -> X;
                            ^
                            |
                            if req_body is set to true, this is an error

This field should only be set to false if the item is inside of a trait definition or extern block. Within an impl block or a module, it should always be set to true.

Struct rustc_parse::parser::item::FnParseModeCopy item path

Fields§

Trait Implementations§

impl Clone for FnParseMode

fn clone(&self) -> FnParseMode

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

impl Copy for FnParseMode

Auto Trait Implementations§

impl DynSend for FnParseMode

impl DynSync for FnParseMode

impl Freeze for FnParseMode

impl RefUnwindSafe for FnParseMode

impl Send for FnParseMode

impl Sync for FnParseMode

impl Unpin for FnParseMode

impl UnwindSafe for FnParseMode

Blanket Implementations§

impl<T> Aligned for T

const ALIGN: Alignment = _

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere T: Copy,

fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T

fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T> ) -> &'a mut [T]

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T, R> CollectAndApply<T, R> for T

fn collect_and_apply<I, F>(iter: I, f: F) -> Rwhere I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

type Output = R

impl<T> Filterable for T

fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<'a, T> Captures<'a> for Twhere T: ?Sized,

impl<T> ErasedDestructor for Twhere T: 'static,

impl<T> MaybeSendSync for Twhere T: Send + Sync,

Layout§

Struct rustc_parse::parser::item::FnParseMode

impl<T> Any for T
where T: 'static + ?Sized,

impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<'a, T> Captures<'a> for T
where T: ?Sized,

impl<T> ErasedDestructor for T
where T: 'static,

impl<T> MaybeSendSync for T
where T: Send + Sync,