Struct style::stylesheets::rule_parser::NestedRuleParser

#[repr(transparent)]
struct NestedRuleParser<'a, 'i>(TopLevelRuleParser<'a, 'i>);

Tuple Fields

0: TopLevelRuleParser<'a, 'i>

Implementations

impl<'a, 'i> NestedRuleParser<'a, 'i>

fn parse_relative(&self) -> ParseRelative

fn at_rule_allowed(&self, prelude: &AtRulePrelude) -> bool

fn nest_for_rule<R>( &mut self, rule_type: CssRuleType, cb: impl FnOnce(&mut Self) -> R, ) -> R

fn parse_nested_rules( &mut self, input: &mut Parser<'i, '_>, rule_type: CssRuleType, source_location: SourceLocation, ) -> Arc<Locked<CssRules>>

fn parse_nested( &mut self, input: &mut Parser<'i, '_>, rule_type: CssRuleType, wants_first_declaration_block: bool, source_location: SourceLocation, ) -> NestedParseResult

fn handle_error_reporting_selectors_pre( &mut self, start: &ParserState, selectors: &SelectorList<SelectorImpl>, )

fn handle_error_reporting_selectors_post(&mut self)

fn flush_declarations(&mut self, source_location: SourceLocation)

Methods from Deref<Target = TopLevelRuleParser<'a, 'i>>

fn nested(&mut self) -> &mut NestedRuleParser<'a, 'i>

pub fn state(&self) -> State

Returns the current state of the parser.

pub fn can_parse_declarations(&self) -> bool

If we’re in a nested state, this returns whether declarations can be parsed. See RuleBodyItemParser::parse_declarations().

fn in_style_rule(&self) -> bool

fn in_page_rule(&self) -> bool

fn in_style_or_page_rule(&self) -> bool

fn check_state(&mut self, new_state: State) -> bool

Checks whether we can parse a rule that would transition us to new_state.

This is usually a simple branch, but we may need more bookkeeping if doing insertRule from CSSOM.

Trait Implementations

impl<'a, 'i> AtRuleParser<'i> for NestedRuleParser<'a, 'i>

type Prelude = AtRulePrelude

The intermediate representation of prelude of an at-rule.

type AtRule = ()

The finished representation of an at-rule.

type Error = StyleParseErrorKind<'i>

The error type that is included in the ParseError value that can be returned.

fn parse_prelude<'t>( &mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>, ) -> Result<Self::Prelude, ParseError<'i>>

Parse the prelude of an at-rule with the given name.

fn parse_block<'t>( &mut self, prelude: AtRulePrelude, start: &ParserState, input: &mut Parser<'i, 't>, ) -> Result<(), ParseError<'i>>

Parse the content of a { /* ... */ } block for the body of the at-rule.

fn rule_without_block( &mut self, prelude: AtRulePrelude, start: &ParserState, ) -> Result<(), ()>

End an at-rule which doesn’t have block. Return the finished representation of the at-rule.

impl<'a, 'i> DeclarationParser<'i> for NestedRuleParser<'a, 'i>

type Declaration = ()

The finished representation of a declaration.

type Error = StyleParseErrorKind<'i>

The error type that is included in the ParseError value that can be returned.

fn parse_value<'t>( &mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>, ) -> Result<(), ParseError<'i>>

Parse the value of a declaration with the given name.

impl<'a, 'i> DerefMut for NestedRuleParser<'a, 'i>

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

Mutably dereferences the value.

impl<'a, 'i> QualifiedRuleParser<'i> for NestedRuleParser<'a, 'i>

type Prelude = SelectorList<SelectorImpl>

The intermediate representation of a qualified rule prelude.

type QualifiedRule = ()

The finished representation of a qualified rule.

type Error = StyleParseErrorKind<'i>

The error type that is included in the ParseError value that can be returned.

fn parse_prelude<'t>( &mut self, input: &mut Parser<'i, 't>, ) -> Result<Self::Prelude, ParseError<'i>>

Parse the prelude of a qualified rule. For style rules, this is as Selector list.

fn parse_block<'t>( &mut self, selectors: Self::Prelude, start: &ParserState, input: &mut Parser<'i, 't>, ) -> Result<(), ParseError<'i>>

Parse the content of a { /* ... */ } block for the body of the qualified rule.

impl<'a, 'i> RuleBodyItemParser<'i, (), StyleParseErrorKind<'i>> for NestedRuleParser<'a, 'i>

fn parse_declarations(&self) -> bool

If nesting is disabled, we can’t get there for a non-style-rule. If it’s enabled, we parse raw declarations there.

fn parse_qualified(&self) -> bool

Whether we should attempt to parse qualified rules. If you know you won’t, returning false would be slightly faster.

impl<'a, 'i> Deref for NestedRuleParser<'a, 'i>

type Target = TopLevelRuleParser<'a, 'i>

The resulting type after dereferencing.

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

Dereferences the value.