@@ -69,7 +69,7 @@ pub trait DeclarationParser {
69
69
/// If `!important` can be used in a given context,
70
70
/// `input.try(parse_important).is_ok()` should be used at the end
71
71
/// of the implementation of this method and the result should be part of the return value.
72
- fn parse_value ( & self , name : & str , input : & mut Parser ) -> Result < Self :: Declaration , ( ) > ;
72
+ fn parse_value ( & mut self , name : & str , input : & mut Parser ) -> Result < Self :: Declaration , ( ) > ;
73
73
}
74
74
75
75
@@ -106,7 +106,7 @@ pub trait AtRuleParser {
106
106
/// The given `input` is a "delimited" parser
107
107
/// that ends wherever the prelude should end.
108
108
/// (Before the next semicolon, the next `{`, or the end of the current block.)
109
- fn parse_prelude ( & self , name : & str , input : & mut Parser )
109
+ fn parse_prelude ( & mut self , name : & str , input : & mut Parser )
110
110
-> Result < AtRuleType < Self :: Prelude , Self :: AtRule > , ( ) > {
111
111
let _ = name;
112
112
let _ = input;
@@ -121,7 +121,7 @@ pub trait AtRuleParser {
121
121
///
122
122
/// This is only called when `parse_prelude` returned `WithBlock` or `OptionalBlock`,
123
123
/// and a block was indeed found following the prelude.
124
- fn parse_block ( & self , prelude : Self :: Prelude , input : & mut Parser )
124
+ fn parse_block ( & mut self , prelude : Self :: Prelude , input : & mut Parser )
125
125
-> Result < Self :: AtRule , ( ) > {
126
126
let _ = prelude;
127
127
let _ = input;
@@ -132,7 +132,7 @@ pub trait AtRuleParser {
132
132
///
133
133
/// Convert the prelude into the finished representation of the at-rule
134
134
/// as returned by `RuleListParser::next` or `DeclarationListParser::next`.
135
- fn rule_without_block ( & self , prelude : Self :: Prelude ) -> Self :: AtRule {
135
+ fn rule_without_block ( & mut self , prelude : Self :: Prelude ) -> Self :: AtRule {
136
136
let _ = prelude;
137
137
panic ! ( "The `AtRuleParser::rule_without_block` method must be overriden \
138
138
if `AtRuleParser::parse_prelude` ever returns `AtRuleType::OptionalBlock`.")
@@ -166,7 +166,7 @@ pub trait QualifiedRuleParser {
166
166
///
167
167
/// The given `input` is a "delimited" parser
168
168
/// that ends where the prelude should end (before the next `{`).
169
- fn parse_prelude ( & self , input : & mut Parser ) -> Result < Self :: Prelude , ( ) > {
169
+ fn parse_prelude ( & mut self , input : & mut Parser ) -> Result < Self :: Prelude , ( ) > {
170
170
let _ = input;
171
171
Err ( ( ) )
172
172
}
@@ -176,7 +176,7 @@ pub trait QualifiedRuleParser {
176
176
/// Return the finished representation of the qualified rule
177
177
/// as returned by `RuleListParser::next`,
178
178
/// or `Err(())` to ignore the entire at-rule as invalid.
179
- fn parse_block ( & self , prelude : Self :: Prelude , input : & mut Parser )
179
+ fn parse_block ( & mut self , prelude : Self :: Prelude , input : & mut Parser )
180
180
-> Result < Self :: QualifiedRule , ( ) > {
181
181
let _ = prelude;
182
182
let _ = input;
0 commit comments