Struct AcceptContext 

pub struct AcceptContext<'f, 'sess, S: Stage> {
    pub(crate) shared: SharedContext<'f, 'sess, S>,
    pub(crate) attr_span: Span,
    pub(crate) inner_span: Span,
    pub(crate) attr_style: AttrStyle,
    pub(crate) parsed_description: ParsedDescription,
    pub(crate) template: &'f AttributeTemplate,
    pub(crate) attr_path: AttrPath,
}

Context given to every attribute parser when accepting

Gives AttributeParsers enough information to create errors, for example.

Fields

shared: SharedContext<'f, 'sess, S>

attr_span: Span

The outer span of the attribute currently being parsed

#[attribute(...)]
^^^^^^^^^^^^^^^^^ outer span

For attributes in cfg_attr, the outer span and inner spans are equal.

inner_span: Span

The inner span of the attribute currently being parsed.

#[attribute(...)]
  ^^^^^^^^^^^^^^  inner span

attr_style: AttrStyle

Whether it is an inner or outer attribute.

parsed_description: ParsedDescription

A description of the thing we are parsing using this attribute parser. We are not only using these parsers for attributes, but also for macros such as the cfg!() macro.

template: &'f AttributeTemplate

The expected structure of the attribute.

Used in reporting errors to give a hint to users what the attribute should look like.

attr_path: AttrPath

The name of the attribute we’re currently accepting.

Implementations

impl<S: Stage> AcceptContext<'_, '_, S>

pub(crate) fn parse_limit_int(&mut self, nv: &NameValueParser) -> Option<Limit>

impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S>

pub(crate) fn adcx(&mut self) -> AttributeDiagnosticContext<'_, 'f, 'sess, S>

pub(crate) fn single_element_list<'arg>( &mut self, arg: &'arg ArgParser, span: Span, ) -> Option<&'arg MetaItemOrLitParser>

Asserts that this MetaItem is a list that contains a single element. Emits an error and returns None if it is not the case.

Some examples:

• In #[allow(warnings)], warnings is returned
• In #[cfg_attr(docsrs, doc = "foo")], None is returned, “expected a single argument here” is emitted.
• In #[cfg()], None is returned, “expected an argument here” is emitted.

The provided span is used as a fallback for diagnostic generation in case arg does not contain any. It should be the span of the node that contains arg.

Methods from Deref<Target = SharedContext<'f, 'sess, S>>

pub(crate) fn emit_err( &self, diag: impl for<'x> Diagnostic<'x>, ) -> ErrorGuaranteed

pub(crate) fn emit_lint( &mut self, lint: &'static Lint, kind: AttributeLintKind, span: impl Into<MultiSpan>, )

Emit a lint. This method is somewhat special, since lints emitted during attribute parsing must be delayed until after HIR is built. This method will take care of the details of that.

pub(crate) fn emit_dyn_lint<F: for<'a> Fn(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + DynSync + 'static>( &mut self, lint: &'static Lint, callback: F, span: impl Into<MultiSpan>, )

Emit a lint. This method is somewhat special, since lints emitted during attribute parsing must be delayed until after HIR is built. This method will take care of the details of that.

fn emit_lint_inner( &mut self, lint: &'static Lint, kind: EmitAttribute, span: impl Into<MultiSpan>, )

pub(crate) fn warn_unused_duplicate( &mut self, used_span: Span, unused_span: Span, )

pub(crate) fn warn_unused_duplicate_future_error( &mut self, used_span: Span, unused_span: Span, )

Methods from Deref<Target = AttributeParser<'sess, S>>

pub(crate) fn sess(&self) -> &'sess Session

pub(crate) fn features(&self) -> &'sess Features

pub(crate) fn features_option(&self) -> Option<&'sess Features>

pub(crate) fn dcx(&self) -> DiagCtxtHandle<'sess>

pub fn parse_attribute_list( &mut self, attrs: &[Attribute], target_span: Span, target: Target, omit_doc: OmitDoc, lower_span: impl Copy + Fn(Span) -> Span, emit_lint: impl FnMut(LintId, MultiSpan, EmitAttribute), ) -> Vec<Attribute>

Parse a list of attributes.

target_span is the span of the thing this list of attributes is applied to, and when omit_doc is set, doc attributes are filtered out.

fn lower_attr_args( &self, args: &AttrArgs, lower_span: impl Fn(Span) -> Span, ) -> AttrArgs

pub fn check_attribute_safety( &mut self, attr_path: &AttrPath, attr_span: Span, attr_safety: Safety, expected_safety: AttributeSafety, emit_lint: &mut impl FnMut(LintId, MultiSpan, EmitAttribute), )

pub(crate) fn check_invalid_crate_level_attr_item( &self, attr: &AttrItem, inner_span: Span, )

fn first_line_of_next_item(&self, span: Span) -> Option<Span>

pub(crate) fn check_invalid_where_predicate_attrs<'attr>( &self, attrs: impl IntoIterator<Item = &'attr Attribute>, )

Trait Implementations

impl<'f, 'sess, S: Stage> Deref for AcceptContext<'f, 'sess, S>

type Target = SharedContext<'f, 'sess, S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'f, 'sess, S: Stage> DerefMut for AcceptContext<'f, 'sess, S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

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: 96 bytes