Struct rustc_parse::parser::item::FnParseMode

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

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.

Trait Implementations

impl Clone for FnParseMode

fn clone(&self) -> FnParseMode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for FnParseMode

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes