Skip to content

Commit 0d4a3dd

Browse files
author
bors-servo
authored
Auto merge of #264 - servo:those-without-syn, r=nox
Fix using the `match_ignore_ascii_case` macro inside another macro expansion
2 parents 2c5c2ef + 431df46 commit 0d4a3dd

File tree

8 files changed

+116
-97
lines changed

8 files changed

+116
-97
lines changed

‎Cargo.toml

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "cssparser"
3-
version = "0.26.0"
3+
version = "0.27.0"
44
authors = [ "Simon Sapin <simon.sapin@exyr.org>" ]
55

66
description = "Rust implementation of CSS Syntax Level 3"
@@ -19,7 +19,7 @@ difference = "2.0"
1919
encoding_rs = "0.8"
2020

2121
[dependencies]
22-
cssparser-macros = {path = "./macros", version = "0.4"}
22+
cssparser-macros = {path = "./macros", version = "0.5"}
2323
dtoa-short = "0.3"
2424
heapsize = {version = ">= 0.3, < 0.5", optional = true}
2525
itoa = "0.4"

‎build/match_byte.rs

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,12 @@ fn get_byte_from_expr_lit(expr: &Box<syn::Expr>) -> u8 {
7373
}
7474

7575
/// Parse a pattern and fill the table accordingly
76-
fn parse_pat_to_table<'a>(pat: &'a syn::Pat, case_id: u8, wildcard: &mut Option<&'a syn::Ident>, table: &mut [u8; 256]) {
76+
fn parse_pat_to_table<'a>(
77+
pat: &'a syn::Pat,
78+
case_id: u8,
79+
wildcard: &mut Option<&'a syn::Ident>,
80+
table: &mut [u8; 256],
81+
) {
7782
match pat {
7883
&syn::Pat::Lit(syn::PatLit { ref expr, .. }) => {
7984
let value = get_byte_from_expr_lit(expr);
@@ -108,7 +113,7 @@ fn parse_pat_to_table<'a>(pat: &'a syn::Pat, case_id: u8, wildcard: &mut Option<
108113
*byte = case_id;
109114
}
110115
}
111-
},
116+
}
112117
&syn::Pat::Or(syn::PatOr { ref cases, .. }) => {
113118
for case in cases {
114119
parse_pat_to_table(case, case_id, wildcard, table);

‎macros/Cargo.toml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "cssparser-macros"
3-
version = "0.4.0"
3+
version = "0.5.0"
44
authors = ["Simon Sapin <simon.sapin@exyr.org>"]
55
description = "Procedural macros for cssparser"
66
documentation = "https://docs.rs/cssparser-macros/"

‎macros/lib.rs

Lines changed: 39 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -6,103 +6,72 @@ extern crate proc_macro;
66

77
use proc_macro::TokenStream;
88

9-
/// Input: a `match` expression.
10-
///
11-
/// Output: a `MAX_LENGTH` constant with the length of the longest string pattern.
12-
///
13-
/// Panic if the arms contain non-string patterns,
14-
/// or string patterns that contains ASCII uppercase letters.
9+
/// Implementation detail of the `match_ignore_ascii_case!` macro
1510
#[allow(non_snake_case)]
1611
#[proc_macro]
17-
pub fn cssparser_internal__assert_ascii_lowercase__max_len(input: TokenStream) -> TokenStream {
18-
let expr: syn::ExprMatch = syn::parse_macro_input!(input);
19-
let strings = expr
20-
.arms
21-
.iter()
22-
.flat_map(|arm| match arm.pat {
23-
syn::Pat::Or(ref p) => p.cases.iter().collect(),
24-
ref p => vec![p],
25-
})
26-
.filter_map(|pattern| {
27-
let expr = match pattern {
28-
syn::Pat::Lit(expr) => expr,
29-
syn::Pat::Wild(_) => return None,
30-
_ => panic!("expected string or wildcard pattern, got {:?}", pattern),
31-
};
32-
match *expr.expr {
33-
syn::Expr::Lit(syn::ExprLit {
34-
lit: syn::Lit::Str(ref lit),
35-
..
36-
}) => {
37-
assert_eq!(
38-
lit.value(),
39-
lit.value().to_ascii_lowercase(),
40-
"string patterns must be given in ASCII lowercase"
41-
);
42-
Some(lit)
43-
}
44-
_ => panic!("expected string pattern, got {:?}", expr),
45-
}
46-
});
47-
max_len(strings)
48-
}
49-
50-
/// Input: string literals with no separator
51-
///
52-
/// Output: a `MAX_LENGTH` constant with the length of the longest string.
53-
#[allow(non_snake_case)]
54-
#[proc_macro]
55-
pub fn cssparser_internal__max_len(input: TokenStream) -> TokenStream {
56-
struct Input(Vec<syn::LitStr>);
12+
pub fn cssparser_internal__match_ignore_ascii_case__support(input: TokenStream) -> TokenStream {
13+
struct Input {
14+
max_length: usize,
15+
}
5716

5817
impl syn::parse::Parse for Input {
5918
fn parse(input: syn::parse::ParseStream) -> syn::parse::Result<Self> {
60-
let mut strings = Vec::new();
19+
let mut max_length = 0;
6120
while !input.is_empty() {
62-
strings.push(input.parse()?)
21+
if input.peek(syn::Token![_]) {
22+
input.parse::<syn::Token![_]>().unwrap();
23+
continue;
24+
}
25+
let lit: syn::LitStr = input.parse()?;
26+
let value = lit.value();
27+
if value.to_ascii_lowercase() != value {
28+
return Err(syn::Error::new(lit.span(), "must be ASCII-lowercase"));
29+
}
30+
max_length = max_length.max(value.len());
6331
}
64-
Ok(Self(strings))
32+
Ok(Input { max_length })
6533
}
6634
}
6735

68-
let strings: Input = syn::parse_macro_input!(input);
69-
max_len(strings.0.iter())
70-
}
71-
72-
fn max_len<'a, I: Iterator<Item = &'a syn::LitStr>>(strings: I) -> TokenStream {
73-
let max_length = strings
74-
.map(|s| s.value().len())
75-
.max()
76-
.expect("expected at least one string");
77-
quote::quote!( pub(super) const MAX_LENGTH: usize = #max_length; ).into()
36+
let Input { max_length } = syn::parse_macro_input!(input);
37+
quote::quote!(
38+
pub(super) const MAX_LENGTH: usize = #max_length;
39+
)
40+
.into()
7841
}
7942

80-
/// Input: A type, followed by pairs of string literal keys and expression values. No separator.
81-
///
82-
/// Output: a rust-phf map, with keys ASCII-lowercased:
83-
/// ```text
84-
/// static MAP: &'static ::cssparser::phf::Map<&'static str, $ValueType> = …;
85-
/// ```
43+
/// Implementation detail of the `ascii_case_insensitive_phf_map!` macro
8644
#[allow(non_snake_case)]
8745
#[proc_macro]
88-
pub fn cssparser_internal__phf_map(input: TokenStream) -> TokenStream {
46+
pub fn cssparser_internal__ascii_case_insensitive_phf_map__support(
47+
input: TokenStream,
48+
) -> TokenStream {
8949
struct Input {
9050
value_type: syn::Type,
51+
max_key_length: usize,
9152
keys: Vec<syn::LitStr>,
9253
values: Vec<syn::Expr>,
9354
}
9455

9556
impl syn::parse::Parse for Input {
9657
fn parse(input: syn::parse::ParseStream) -> syn::parse::Result<Self> {
58+
let value_type = input.parse()?;
59+
let mut max_key_length = 0;
9760
let mut keys = Vec::new();
9861
let mut values = Vec::new();
99-
let value_type = input.parse()?;
10062
while !input.is_empty() {
101-
keys.push(input.parse()?);
63+
let key: syn::LitStr = input.parse()?;
64+
let key_value = key.value();
65+
max_key_length = max_key_length.max(key_value.len());
66+
keys.push(syn::LitStr::new(
67+
&key_value.to_ascii_lowercase(),
68+
key.span(),
69+
));
10270
values.push(input.parse()?);
10371
}
10472
Ok(Input {
10573
value_type,
74+
max_key_length,
10675
keys,
10776
values,
10877
})
@@ -111,14 +80,12 @@ pub fn cssparser_internal__phf_map(input: TokenStream) -> TokenStream {
11180

11281
let Input {
11382
value_type,
83+
max_key_length,
11484
keys,
11585
values,
11686
} = syn::parse_macro_input!(input);
117-
let keys = keys
118-
.iter()
119-
.map(|s| syn::LitStr::new(&s.value().to_ascii_lowercase(), s.span()));
120-
12187
quote::quote!(
88+
pub(super) const MAX_LENGTH: usize = #max_key_length;
12289
pub(super) static MAP: Map<&'static str, #value_type> = phf_map! {
12390
#(
12491
#keys => #values,

‎src/macros.rs

Lines changed: 13 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -32,23 +32,28 @@ use std::mem::MaybeUninit;
3232
/// ```
3333
#[macro_export]
3434
macro_rules! match_ignore_ascii_case {
35-
( $input:expr, $( $match_body:tt )* ) => {
35+
( $input:expr,
36+
$(
37+
$( $pattern: pat )|+ $( if $guard: expr )? => $then: expr
38+
),+
39+
$(,)?
40+
) => {
3641
{
3742
// This dummy module works around the feature gate
3843
// `error[E0658]: procedural macros cannot be expanded to statements`
3944
// by forcing the macro to be in an item context
4045
// rather than expression/statement context,
4146
// even though the macro only expands to items.
4247
mod cssparser_internal {
43-
cssparser_internal__assert_ascii_lowercase__max_len! {
44-
match x { $( $match_body )* }
45-
}
48+
cssparser_internal__match_ignore_ascii_case__support!( $( $( $pattern )+ )+ );
4649
}
4750
cssparser_internal__to_lowercase!($input, cssparser_internal::MAX_LENGTH => lowercase);
4851
// "A" is a short string that we know is different for every string pattern,
4952
// since we’ve verified that none of them include ASCII upper case letters.
5053
match lowercase.unwrap_or("A") {
51-
$( $match_body )*
54+
$(
55+
$( $pattern )|+ $( if $guard )? => $then,
56+
)+
5257
}
5358
}
5459
};
@@ -90,8 +95,9 @@ macro_rules! ascii_case_insensitive_phf_map {
9095
mod cssparser_internal {
9196
use $crate::_internal__phf::{Map, phf_map};
9297
#[allow(unused)] use super::*;
93-
cssparser_internal__max_len!( $( $key )+ );
94-
cssparser_internal__phf_map!( $ValueType $( $key $value )+ );
98+
cssparser_internal__ascii_case_insensitive_phf_map__support!(
99+
$ValueType $( $key $value )+
100+
);
95101
}
96102
cssparser_internal__to_lowercase!(input, cssparser_internal::MAX_LENGTH => lowercase);
97103
lowercase.and_then(|s| cssparser_internal::MAP.get(s))

‎src/rules_and_declarations.rs

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -268,9 +268,7 @@ where
268268
let start = self.input.state();
269269
// FIXME: remove intermediate variable when lifetimes are non-lexical
270270
let ident = match self.input.next_including_whitespace_and_comments() {
271-
Ok(&Token::WhiteSpace(_)) | Ok(&Token::Comment(_)) | Ok(&Token::Semicolon) => {
272-
continue
273-
}
271+
Ok(&Token::WhiteSpace(_)) | Ok(&Token::Comment(_)) | Ok(&Token::Semicolon) => continue,
274272
Ok(&Token::Ident(ref name)) => Ok(Ok(name.clone())),
275273
Ok(&Token::AtKeyword(ref name)) => Ok(Err(name.clone())),
276274
Ok(token) => Err(token.clone()),

‎src/serializer.rs

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -451,15 +451,24 @@ impl TokenSerializationType {
451451
),
452452
Number => matches!(
453453
other.0,
454-
Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | DelimPercent | Dimension
454+
Ident
455+
| Function
456+
| UrlOrBadUrl
457+
| DelimMinus
458+
| Number
459+
| Percentage
460+
| DelimPercent
461+
| Dimension
455462
),
456463
DelimAt => matches!(other.0, Ident | Function | UrlOrBadUrl | DelimMinus),
457464
DelimDotOrPlus => matches!(other.0, Number | Percentage | Dimension),
458465
DelimAssorted | DelimAsterisk => matches!(other.0, DelimEquals),
459466
DelimBar => matches!(other.0, DelimEquals | DelimBar | DashMatch),
460467
DelimSlash => matches!(other.0, DelimAsterisk | SubstringMatch),
461468
Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen
462-
| DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => false,
469+
| DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => {
470+
false
471+
}
463472
}
464473
}
465474
}

‎src/tests.rs

Lines changed: 42 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66
extern crate test;
77

88
use encoding_rs;
9-
use serde_json::{self, Value, json, Map};
9+
use serde_json::{self, json, Map, Value};
1010

1111
#[cfg(feature = "bench")]
1212
use self::test::Bencher;
@@ -30,7 +30,7 @@ fn almost_equals(a: &Value, b: &Value) -> bool {
3030
let a = a.as_f64().unwrap();
3131
let b = b.as_f64().unwrap();
3232
(a - b).abs() <= a.abs() * 1e-6
33-
},
33+
}
3434

3535
(&Value::Bool(a), &Value::Bool(b)) => a == b,
3636
(&Value::String(ref a), &Value::String(ref b)) => a == b,
@@ -410,15 +410,16 @@ fn unicode_range() {
410410
Ok(None)
411411
}
412412
});
413-
result.unwrap()
413+
result
414+
.unwrap()
414415
.iter()
415-
.map(|v|
416-
if let Some((v0, v1)) = v{
416+
.map(|v| {
417+
if let Some((v0, v1)) = v {
417418
json!([v0, v1])
418419
} else {
419420
Value::Null
420421
}
421-
)
422+
})
422423
.collect::<Vec<_>>()
423424
.to_json()
424425
});
@@ -809,7 +810,11 @@ trait ToJson {
809810
fn to_json(&self) -> Value;
810811
}
811812

812-
impl<T> ToJson for T where T: Clone, Value: From<T> {
813+
impl<T> ToJson for T
814+
where
815+
T: Clone,
816+
Value: From<T>,
817+
{
813818
fn to_json(&self) -> Value {
814819
Value::from(self.clone())
815820
}
@@ -935,7 +940,7 @@ impl<'i> AtRuleParser<'i> for JsonParser {
935940
"media" | "foo-with-block" => Ok(AtRuleType::WithBlock(prelude)),
936941
"charset" => {
937942
Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name.clone()).into()))
938-
}
943+
},
939944
_ => Ok(AtRuleType::WithoutBlock(prelude)),
940945
}
941946
}
@@ -1392,3 +1397,32 @@ fn utf16_columns() {
13921397
assert_eq!(parser.current_source_location().column, test.1);
13931398
}
13941399
}
1400+
1401+
#[test]
1402+
fn servo_define_css_keyword_enum() {
1403+
macro_rules! define_css_keyword_enum {
1404+
(pub enum $name:ident { $($variant:ident = $css:expr,)+ }) => {
1405+
#[derive(PartialEq, Debug)]
1406+
pub enum $name {
1407+
$($variant),+
1408+
}
1409+
1410+
impl $name {
1411+
pub fn from_ident(ident: &str) -> Result<$name, ()> {
1412+
match_ignore_ascii_case! { ident,
1413+
$($css => Ok($name::$variant),)+
1414+
_ => Err(())
1415+
}
1416+
}
1417+
}
1418+
}
1419+
}
1420+
define_css_keyword_enum! {
1421+
pub enum UserZoom {
1422+
Zoom = "zoom",
1423+
Fixed = "fixed",
1424+
}
1425+
}
1426+
1427+
assert_eq!(UserZoom::from_ident("fixed"), Ok(UserZoom::Fixed));
1428+
}

0 commit comments

Comments
 (0)