Skip to content

Commit a27b68b

Browse files
epageepage
committed
refactor: Use more serde_untagged
1 parent 17c4431 commit a27b68b

File tree

2 files changed

+47
-156
lines changed

2 files changed

+47
-156
lines changed

‎src/cargo/util/toml/mod.rs

Lines changed: 43 additions & 154 deletions
Original file line numberDiff line numberDiff line change
@@ -1171,195 +1171,84 @@ type MaybeWorkspaceSemverVersion = MaybeWorkspace<semver::Version, TomlWorkspace
11711171

11721172
type MaybeWorkspaceString = MaybeWorkspace<String, TomlWorkspaceField>;
11731173
impl<'de> de::Deserialize<'de> for MaybeWorkspaceString {
1174-
fn deserialize<D>(d: D) -> Result<Self, D::Error>
1174+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
11751175
where
11761176
D: de::Deserializer<'de>,
11771177
{
1178-
struct Visitor;
1179-
1180-
impl<'de> de::Visitor<'de> for Visitor {
1181-
type Value = MaybeWorkspaceString;
1182-
1183-
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
1184-
f.write_str("a string or workspace")
1185-
}
1186-
1187-
fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
1188-
where
1189-
E: de::Error,
1190-
{
1191-
Ok(MaybeWorkspaceString::Defined(value))
1192-
}
1193-
1194-
fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
1195-
where
1196-
V: de::MapAccess<'de>,
1197-
{
1198-
let mvd = de::value::MapAccessDeserializer::new(map);
1199-
TomlWorkspaceField::deserialize(mvd).map(MaybeWorkspace::Workspace)
1200-
}
1201-
}
1202-
1203-
d.deserialize_any(Visitor)
1178+
UntaggedEnumVisitor::new()
1179+
.expecting("a string or workspace")
1180+
.string(|value| Ok(MaybeWorkspace::Defined(value.to_owned())))
1181+
.map(|value| value.deserialize().map(MaybeWorkspace::Workspace))
1182+
.deserialize(deserializer)
12041183
}
12051184
}
12061185

12071186
type MaybeWorkspacePartialVersion = MaybeWorkspace<PartialVersion, TomlWorkspaceField>;
12081187
impl<'de> de::Deserialize<'de> for MaybeWorkspacePartialVersion {
1209-
fn deserialize<D>(d: D) -> Result<Self, D::Error>
1188+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
12101189
where
12111190
D: de::Deserializer<'de>,
12121191
{
1213-
struct Visitor;
1214-
1215-
impl<'de> de::Visitor<'de> for Visitor {
1216-
type Value = MaybeWorkspacePartialVersion;
1217-
1218-
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
1219-
f.write_str("a semver or workspace")
1220-
}
1221-
1222-
fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
1223-
where
1224-
E: de::Error,
1225-
{
1226-
let value = value.parse::<PartialVersion>().map_err(|e| E::custom(e))?;
1227-
Ok(MaybeWorkspacePartialVersion::Defined(value))
1228-
}
1229-
1230-
fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
1231-
where
1232-
V: de::MapAccess<'de>,
1233-
{
1234-
let mvd = de::value::MapAccessDeserializer::new(map);
1235-
TomlWorkspaceField::deserialize(mvd).map(MaybeWorkspace::Workspace)
1236-
}
1237-
}
1238-
1239-
d.deserialize_any(Visitor)
1192+
use serde::de::Error as _;
1193+
UntaggedEnumVisitor::new()
1194+
.expecting("a SemVer version or workspace")
1195+
.string(|value| {
1196+
let value = value
1197+
.parse::<PartialVersion>()
1198+
.map_err(|e| serde_untagged::de::Error::custom(e))?;
1199+
Ok(MaybeWorkspace::Defined(value))
1200+
})
1201+
.map(|value| value.deserialize().map(MaybeWorkspace::Workspace))
1202+
.deserialize(deserializer)
12401203
}
12411204
}
12421205

12431206
type MaybeWorkspaceVecString = MaybeWorkspace<Vec<String>, TomlWorkspaceField>;
12441207
impl<'de> de::Deserialize<'de> for MaybeWorkspaceVecString {
1245-
fn deserialize<D>(d: D) -> Result<Self, D::Error>
1208+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
12461209
where
12471210
D: de::Deserializer<'de>,
12481211
{
1249-
struct Visitor;
1250-
1251-
impl<'de> de::Visitor<'de> for Visitor {
1252-
type Value = MaybeWorkspaceVecString;
1253-
1254-
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
1255-
f.write_str("a vector of strings or workspace")
1256-
}
1257-
fn visit_seq<A>(self, v: A) -> Result<Self::Value, A::Error>
1258-
where
1259-
A: de::SeqAccess<'de>,
1260-
{
1261-
let seq = de::value::SeqAccessDeserializer::new(v);
1262-
Vec::deserialize(seq).map(MaybeWorkspace::Defined)
1263-
}
1264-
1265-
fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
1266-
where
1267-
V: de::MapAccess<'de>,
1268-
{
1269-
let mvd = de::value::MapAccessDeserializer::new(map);
1270-
TomlWorkspaceField::deserialize(mvd).map(MaybeWorkspace::Workspace)
1271-
}
1272-
}
1273-
1274-
d.deserialize_any(Visitor)
1212+
UntaggedEnumVisitor::new()
1213+
.expecting("a vector of strings or workspace")
1214+
.seq(|value| value.deserialize().map(MaybeWorkspace::Defined))
1215+
.map(|value| value.deserialize().map(MaybeWorkspace::Workspace))
1216+
.deserialize(deserializer)
12751217
}
12761218
}
12771219

12781220
type MaybeWorkspaceStringOrBool = MaybeWorkspace<StringOrBool, TomlWorkspaceField>;
12791221
impl<'de> de::Deserialize<'de> for MaybeWorkspaceStringOrBool {
1280-
fn deserialize<D>(d: D) -> Result<Self, D::Error>
1222+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
12811223
where
12821224
D: de::Deserializer<'de>,
12831225
{
1284-
struct Visitor;
1285-
1286-
impl<'de> de::Visitor<'de> for Visitor {
1287-
type Value = MaybeWorkspaceStringOrBool;
1288-
1289-
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
1290-
f.write_str("a string, a bool, or workspace")
1291-
}
1292-
1293-
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
1294-
where
1295-
E: de::Error,
1296-
{
1297-
let b = de::value::BoolDeserializer::new(v);
1298-
StringOrBool::deserialize(b).map(MaybeWorkspace::Defined)
1299-
}
1300-
1301-
fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1302-
where
1303-
E: de::Error,
1304-
{
1305-
let string = de::value::StringDeserializer::new(v);
1306-
StringOrBool::deserialize(string).map(MaybeWorkspace::Defined)
1307-
}
1308-
1309-
fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
1310-
where
1311-
V: de::MapAccess<'de>,
1312-
{
1313-
let mvd = de::value::MapAccessDeserializer::new(map);
1314-
TomlWorkspaceField::deserialize(mvd).map(MaybeWorkspace::Workspace)
1315-
}
1316-
}
1317-
1318-
d.deserialize_any(Visitor)
1226+
UntaggedEnumVisitor::new()
1227+
.expecting("a string, a bool, or workspace")
1228+
.bool(|b| Ok(StringOrBool::Bool(b)).map(MaybeWorkspace::Defined))
1229+
.string(|s| Ok(StringOrBool::String(s.to_owned())).map(MaybeWorkspace::Defined))
1230+
.map(|value| value.deserialize().map(MaybeWorkspace::Workspace))
1231+
.deserialize(deserializer)
13191232
}
13201233
}
13211234

13221235
type MaybeWorkspaceVecStringOrBool = MaybeWorkspace<VecStringOrBool, TomlWorkspaceField>;
13231236
impl<'de> de::Deserialize<'de> for MaybeWorkspaceVecStringOrBool {
1324-
fn deserialize<D>(d: D) -> Result<Self, D::Error>
1237+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
13251238
where
13261239
D: de::Deserializer<'de>,
13271240
{
1328-
struct Visitor;
1329-
1330-
impl<'de> de::Visitor<'de> for Visitor {
1331-
type Value = MaybeWorkspaceVecStringOrBool;
1332-
1333-
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
1334-
f.write_str("a boolean, a vector of strings, or workspace")
1335-
}
1336-
1337-
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
1338-
where
1339-
E: de::Error,
1340-
{
1341-
let b = de::value::BoolDeserializer::new(v);
1342-
VecStringOrBool::deserialize(b).map(MaybeWorkspace::Defined)
1343-
}
1344-
1345-
fn visit_seq<A>(self, v: A) -> Result<Self::Value, A::Error>
1346-
where
1347-
A: de::SeqAccess<'de>,
1348-
{
1349-
let seq = de::value::SeqAccessDeserializer::new(v);
1350-
VecStringOrBool::deserialize(seq).map(MaybeWorkspace::Defined)
1351-
}
1352-
1353-
fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
1354-
where
1355-
V: de::MapAccess<'de>,
1356-
{
1357-
let mvd = de::value::MapAccessDeserializer::new(map);
1358-
TomlWorkspaceField::deserialize(mvd).map(MaybeWorkspace::Workspace)
1359-
}
1360-
}
1361-
1362-
d.deserialize_any(Visitor)
1241+
UntaggedEnumVisitor::new()
1242+
.expecting("a boolean, a vector of strings, or workspace")
1243+
.bool(|value| Ok(VecStringOrBool::Bool(value)).map(MaybeWorkspace::Defined))
1244+
.seq(|value| {
1245+
value
1246+
.deserialize()
1247+
.map(VecStringOrBool::VecString)
1248+
.map(MaybeWorkspace::Defined)
1249+
})
1250+
.map(|value| value.deserialize().map(MaybeWorkspace::Workspace))
1251+
.deserialize(deserializer)
13631252
}
13641253
}
13651254

‎tests/testsuite/inheritable_workspace_fields.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1234,11 +1234,13 @@ fn error_workspace_false() {
12341234
[ERROR] failed to parse manifest at `[CWD]/Cargo.toml`
12351235
12361236
Caused by:
1237-
TOML parse error at line 7, column 41
1237+
TOML parse error at line 7, column 27
12381238
|
12391239
7 | description = { workspace = false }
1240-
| ^^^^^
1240+
| ^^^^^^^^^^^^^^^^^^^^^
12411241
`workspace` cannot be false
1242+
in `workspace`
1243+
12421244
",
12431245
)
12441246
.run();

0 commit comments

Comments
 (0)