1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! # Support for literal values.
//!
//! This module provides support for interpreting literal values from the UDL,
//! which appear in places such as default arguments.
use anyhow::{bail, Result};
use uniffi_meta::Checksum;
use super::types::Type;
// Represents a literal value.
// Used for e.g. default argument values.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Checksum)]
pub enum Literal {
Boolean(bool),
String(String),
// Integers are represented as the widest representation we can.
// Number formatting vary with language and radix, so we avoid a lot of parsing and
// formatting duplication by using only signed and unsigned variants.
UInt(u64, Radix, Type),
Int(i64, Radix, Type),
// Pass the string representation through as typed in the UDL.
// This avoids a lot of uncertainty around precision and accuracy,
// though bindings for languages less sophisticated number parsing than WebIDL
// will have to do extra work.
Float(String, Type),
Enum(String, Type),
EmptySequence,
EmptyMap,
Null,
}
// Represent the radix of integer literal values.
// We preserve the radix into the generated bindings for readability reasons.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Checksum)]
pub enum Radix {
Decimal = 10,
Octal = 8,
Hexadecimal = 16,
}
pub(super) fn convert_default_value(
default_value: &weedle::literal::DefaultValue<'_>,
type_: &Type,
) -> Result<Literal> {
fn convert_integer(literal: &weedle::literal::IntegerLit<'_>, type_: &Type) -> Result<Literal> {
let (string, radix) = match literal {
weedle::literal::IntegerLit::Dec(v) => (v.0, Radix::Decimal),
weedle::literal::IntegerLit::Hex(v) => (v.0, Radix::Hexadecimal),
weedle::literal::IntegerLit::Oct(v) => (v.0, Radix::Octal),
};
// This is the radix of the parsed number, passed to `from_str_radix`.
let src_radix = radix as u32;
// This radix tells the backends how to represent the number in the output languages.
let dest_radix = if string == "0" || string.starts_with('-') {
// 1. weedle parses "0" as an octal literal, but we most likely want to treat this as a decimal.
// 2. Explicitly negatively signed hex numbers won't convert via i64 very well if they're not 64 bit.
// For ease of implementation, output will use decimal.
Radix::Decimal
} else {
radix
};
// Clippy seems to think we should be using `strip_prefix` here, but
// it seems confused as to what this is actually doing.
#[allow(clippy::manual_strip)]
let string = if string.starts_with('-') {
("-".to_string() + string[1..].trim_start_matches("0x")).to_lowercase()
} else {
string.trim_start_matches("0x").to_lowercase()
};
Ok(match type_ {
Type::Int8 | Type::Int16 | Type::Int32 | Type::Int64 => Literal::Int(
i64::from_str_radix(&string, src_radix)?,
dest_radix,
type_.clone(),
),
Type::UInt8 | Type::UInt16 | Type::UInt32 | Type::UInt64 => Literal::UInt(
u64::from_str_radix(&string, src_radix)?,
dest_radix,
type_.clone(),
),
_ => bail!("Cannot coerce literal {} into a non-integer type", string),
})
}
fn convert_float(literal: &weedle::literal::FloatLit<'_>, type_: &Type) -> Result<Literal> {
let string = match literal {
weedle::literal::FloatLit::Value(v) => v.0,
_ => bail!("Infinity and NaN is not currently supported"),
};
Ok(match type_ {
Type::Float32 | Type::Float64 => Literal::Float(string.to_string(), type_.clone()),
_ => bail!("Cannot coerce literal {} into a non-float type", string),
})
}
Ok(match (default_value, type_) {
(weedle::literal::DefaultValue::Boolean(b), Type::Boolean) => Literal::Boolean(b.0),
(weedle::literal::DefaultValue::String(s), Type::String) => {
// Note that weedle doesn't parse escaped double quotes.
// Keeping backends using double quotes (possible for all to date)
// means we don't need to escape single quotes. But we haven't spent a lot of time
// trying to break default values with weird escapes and quotes.
Literal::String(s.0.to_string())
}
(weedle::literal::DefaultValue::EmptyArray(_), Type::Sequence(_)) => Literal::EmptySequence,
(weedle::literal::DefaultValue::String(s), Type::Enum(_)) => {
Literal::Enum(s.0.to_string(), type_.clone())
}
(weedle::literal::DefaultValue::Null(_), Type::Optional(_)) => Literal::Null,
(_, Type::Optional(inner_type)) => convert_default_value(default_value, inner_type)?,
// We'll ensure the type safety in the convert_* number methods.
(weedle::literal::DefaultValue::Integer(i), _) => convert_integer(i, type_)?,
(weedle::literal::DefaultValue::Float(i), _) => convert_float(i, type_)?,
_ => bail!("No support for {:?} literal yet", default_value),
})
}
#[cfg(test)]
mod test {
use super::*;
use weedle::Parse;
fn parse_and_convert(expr: &str, t: Type) -> Result<Literal> {
let (_, node) = weedle::literal::DefaultValue::parse(expr).unwrap();
convert_default_value(&node, &t)
}
#[test]
fn test_default_value_conversion() -> Result<()> {
assert!(matches!(
parse_and_convert("0", Type::UInt8)?,
Literal::UInt(0, Radix::Decimal, Type::UInt8)
));
assert!(matches!(
parse_and_convert("-12", Type::Int32)?,
Literal::Int(-12, Radix::Decimal, Type::Int32)
));
assert!(
matches!(parse_and_convert("3.14", Type::Float32)?, Literal::Float(v, Type::Float32) if v == "3.14")
);
assert!(matches!(
parse_and_convert("false", Type::Boolean)?,
Literal::Boolean(false)
));
assert!(
matches!(parse_and_convert("\"TEST\"", Type::String)?, Literal::String(v) if v == "TEST")
);
assert!(
matches!(parse_and_convert("\"one\"", Type::Enum("E".into()))?, Literal::Enum(v, Type::Enum(e)) if v == "one" && e == "E")
);
assert!(matches!(
parse_and_convert("[]", Type::Sequence(Box::new(Type::String)))?,
Literal::EmptySequence
));
assert!(matches!(
parse_and_convert("null", Type::Optional(Box::new(Type::String)))?,
Literal::Null
));
Ok(())
}
#[test]
fn test_error_on_type_mismatch() {
assert_eq!(
parse_and_convert("0", Type::Boolean)
.unwrap_err()
.to_string(),
"Cannot coerce literal 0 into a non-integer type"
);
assert!(parse_and_convert("{}", Type::Boolean)
.unwrap_err()
.to_string()
.starts_with("No support for"));
}
}
|
