Struct AcceptContext

pub(crate) struct AcceptContext<'f, 'sess, S: Stage> {
    pub(crate) shared: SharedContext<'f, 'sess, S>,
    pub(crate) attr_span: Span,
    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 span of the attribute currently being parsed

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<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S>

pub(crate) fn unknown_key( &self, span: Span, found: String, options: &'static [&'static str], ) -> ErrorGuaranteed

pub(crate) fn expected_string_literal( &self, span: Span, actual_literal: Option<&MetaItemLit>, ) -> ErrorGuaranteed

error that a string literal was expected. You can optionally give the literal you did find (which you found not to be a string literal) which can make better errors. For example, if the literal was a byte string it will suggest removing the b prefix.

pub(crate) fn expected_list(&self, span: Span) -> ErrorGuaranteed

pub(crate) fn expected_no_args(&self, args_span: Span) -> ErrorGuaranteed

pub(crate) fn expected_name_value( &self, span: Span, name: Option<Symbol>, ) -> ErrorGuaranteed

emit an error that a name = value pair was expected at this span. The symbol can be given for a nicer error message talking about the specific name that was found lacking a value.

pub(crate) fn duplicate_key(&self, span: Span, key: Symbol) -> ErrorGuaranteed

emit an error that a name = value pair was found where that name was already seen.

pub(crate) fn unexpected_literal(&self, span: Span) -> ErrorGuaranteed

an error that should be emitted when a MetaItemOrLitParser was expected not to be a literal, but instead a meta item.

pub(crate) fn expected_single_argument(&self, span: Span) -> ErrorGuaranteed

pub(crate) fn expected_at_least_one_argument( &self, span: Span, ) -> ErrorGuaranteed

pub(crate) fn expected_specific_argument( &self, span: Span, possibilities: Vec<&'static str>, ) -> ErrorGuaranteed

pub(crate) fn expected_specific_argument_strings( &self, span: Span, possibilities: Vec<&'static str>, ) -> ErrorGuaranteed

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: AttributeLintKind, span: Span)

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 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 dcx(&self) -> DiagCtxtHandle<'sess>

pub fn parse_attribute_list( &mut self, attrs: &[Attribute], target_span: Span, target_id: S::Id, omit_doc: OmitDoc, lower_span: impl Copy + Fn(Span) -> Span, emit_lint: impl FnMut(AttributeLint<S::Id>), ) -> 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

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: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.