diff --git a/dependencies/syn/src/expr.rs b/dependencies/syn/src/expr.rs index a997ccee36..23da12ea9b 100644 --- a/dependencies/syn/src/expr.rs +++ b/dependencies/syn/src/expr.rs @@ -24,9 +24,9 @@ use crate::token; use crate::ty::ReturnType; use crate::ty::Type; use crate::verus::{ - Assert, AssertForall, Assume, BigAnd, BigOr, ClosureArg, Decreases, Ensures, ExprFinal, - ExprGetField, ExprHas, ExprHasNot, ExprIs, ExprIsNot, ExprMatches, FnProofOptions, Invariant, - InvariantEnsures, InvariantExceptBreak, Requires, RevealHide, View, + Assert, AssertForall, Assume, AtomicallyBlock, BigAnd, BigOr, ClosureArg, Decreases, Ensures, + ExprFinal, ExprGetField, ExprHas, ExprHasNot, ExprIs, ExprIsNot, ExprMatches, FnProofOptions, + Invariant, InvariantEnsures, InvariantExceptBreak, Requires, RevealHide, View, }; use alloc::boxed::Box; use alloc::vec::Vec; @@ -373,6 +373,7 @@ ast_struct! { pub func: Box, pub paren_token: token::Paren, pub args: Punctuated, + pub atomically: Option, } } @@ -580,6 +581,7 @@ ast_struct! { pub turbofish: Option, pub paren_token: token::Paren, pub args: Punctuated, + pub atomically: Option, } } @@ -1790,6 +1792,7 @@ pub(crate) mod parsing { func: Box::new(e), paren_token: parenthesized!(content in input), args: content.parse_terminated(Expr::parse, Token![,])?, + atomically: input.parse()?, }); } else if input.peek(Token![->]) { let arrow_token: Token![->] = input.parse()?; @@ -1846,7 +1849,9 @@ pub(crate) mod parsing { turbofish, paren_token: parenthesized!(content in input), args: content.parse_terminated(Expr::parse, Token![,])?, + atomically: input.parse()?, }); + continue; } } @@ -1901,6 +1906,7 @@ pub(crate) mod parsing { func: Box::new(e), paren_token: parenthesized!(content in input), args: content.parse_terminated(Expr::parse, Token![,])?, + atomically: input.parse()?, }); } else if input.peek(Token![.]) && !input.peek(Token![..]) @@ -1936,6 +1942,7 @@ pub(crate) mod parsing { turbofish, paren_token: parenthesized!(content in input), args: content.parse_terminated(Expr::parse, Token![,])?, + atomically: input.parse()?, }); continue; } @@ -3459,14 +3466,14 @@ pub(crate) mod printing { tokens.append_all(attrs.outer()); } + #[cfg(not(feature = "full"))] + pub(crate) fn outer_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {} + #[cfg(feature = "full")] fn inner_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) { tokens.append_all(attrs.inner()); } - #[cfg(not(feature = "full"))] - pub(crate) fn outer_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {} - pub(crate) fn print_subexpression( expr: &Expr, needs_group: bool, @@ -3818,6 +3825,8 @@ pub(crate) mod printing { e.paren_token.surround(tokens, |tokens| { e.args.to_tokens(tokens); }); + + e.atomically.to_tokens(tokens); } #[cfg_attr(docsrs, doc(cfg(feature = "printing")))] @@ -4157,6 +4166,7 @@ pub(crate) mod printing { e.paren_token.surround(tokens, |tokens| { e.args.to_tokens(tokens); }); + e.atomically.to_tokens(tokens); } #[cfg_attr(docsrs, doc(cfg(feature = "printing")))] diff --git a/dependencies/syn/src/gen/clone.rs b/dependencies/syn/src/gen/clone.rs index f0e6253e97..2b3605ba06 100644 --- a/dependencies/syn/src/gen/clone.rs +++ b/dependencies/syn/src/gen/clone.rs @@ -128,6 +128,43 @@ impl Clone for crate::AssumeSpecification { } } } +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::AtomicSpec { + fn clone(&self) -> Self { + crate::AtomicSpec { + atomically_token: self.atomically_token.clone(), + paren_token: self.paren_token.clone(), + atomic_update: self.atomic_update.clone(), + block_token: self.block_token.clone(), + type_clause: self.type_clause.clone(), + perm_clause: self.perm_clause.clone(), + requires: self.requires.clone(), + ensures: self.ensures.clone(), + outer_mask: self.outer_mask.clone(), + inner_mask: self.inner_mask.clone(), + comma_token: self.comma_token.clone(), + } + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::AtomicallyBlock { + fn clone(&self) -> Self { + crate::AtomicallyBlock { + label: self.label.clone(), + atomically_token: self.atomically_token.clone(), + loop_token: self.loop_token.clone(), + or1_token: self.or1_token.clone(), + update_fn_binder: self.update_fn_binder.clone(), + comma_token: self.comma_token.clone(), + or2_token: self.or2_token.clone(), + spec_au_binder: self.spec_au_binder.clone(), + invariant_except_breaks: self.invariant_except_breaks.clone(), + invariants: self.invariants.clone(), + ensures: self.ensures.clone(), + body: self.body.clone(), + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Copy for crate::AttrStyle {} @@ -583,6 +620,7 @@ impl Clone for crate::ExprCall { func: self.func.clone(), paren_token: self.paren_token.clone(), args: self.args.clone(), + atomically: self.atomically.clone(), } } } @@ -875,6 +913,7 @@ impl Clone for crate::ExprMethodCall { turbofish: self.turbofish.clone(), paren_token: self.paren_token.clone(), args: self.args.clone(), + atomically: self.atomically.clone(), } } } @@ -1458,6 +1497,16 @@ impl Clone for crate::Index { } } #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::InnerMask { + fn clone(&self) -> Self { + crate::InnerMask { + token: self.token.clone(), + set: self.set.clone(), + comma_token: self.comma_token.clone(), + } + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::Invariant { fn clone(&self) -> Self { crate::Invariant { @@ -1495,6 +1544,9 @@ impl Clone for crate::InvariantNameSet { crate::InvariantNameSet::List(v0) => { crate::InvariantNameSet::List(v0.clone()) } + crate::InvariantNameSet::ListCompl(v0) => { + crate::InvariantNameSet::ListCompl(v0.clone()) + } crate::InvariantNameSet::Set(v0) => crate::InvariantNameSet::Set(v0.clone()), } } @@ -1517,6 +1569,17 @@ impl Clone for crate::InvariantNameSetList { } } #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::InvariantNameSetListCompl { + fn clone(&self) -> Self { + crate::InvariantNameSetListCompl { + any_token: self.any_token.clone(), + op_token: self.op_token.clone(), + bracket_token: self.bracket_token.clone(), + exprs: self.exprs.clone(), + } + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::InvariantNameSetNone { fn clone(&self) -> Self { crate::InvariantNameSetNone { @@ -2082,6 +2145,16 @@ impl Clone for crate::OpenRestricted { } } } +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::OuterMask { + fn clone(&self) -> Self { + crate::OuterMask { + token: self.token.clone(), + set: self.set.clone(), + comma_token: self.comma_token.clone(), + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::ParenthesizedGenericArguments { @@ -2281,6 +2354,36 @@ impl Clone for crate::PathSegment { } } } +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::PermClause { + fn clone(&self) -> Self { + crate::PermClause { + old_perms: self.old_perms.clone(), + arrow_token: self.arrow_token.clone(), + new_perms: self.new_perms.clone(), + comma_token: self.comma_token.clone(), + } + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::PermTuple { + fn clone(&self) -> Self { + crate::PermTuple { + paren_token: self.paren_token.clone(), + fields: self.fields.clone(), + } + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::PermTupleField { + fn clone(&self) -> Self { + crate::PermTupleField { + ident: self.ident.clone(), + colon_token: self.colon_token.clone(), + ty: self.ty.clone(), + } + } +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::PointerMutability { @@ -2307,6 +2410,16 @@ impl Clone for crate::PreciseCapture { } } } +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::PredTypeClause { + fn clone(&self) -> Self { + crate::PredTypeClause { + type_token: self.type_token.clone(), + ident: self.ident.clone(), + comma_token: self.comma_token.clone(), + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::PredicateLifetime { @@ -2410,6 +2523,20 @@ impl Clone for crate::Requires { } } } +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::ReturnPat { + fn clone(&self) -> Self { + match self { + crate::ReturnPat::Default => crate::ReturnPat::Default, + crate::ReturnPat::Pat(v0, v1, v2, v3) => { + crate::ReturnPat::Pat(v0.clone(), v1.clone(), v2.clone(), v3.clone()) + } + crate::ReturnPat::Type(v0, v1) => { + crate::ReturnPat::Type(v0.clone(), v1.clone()) + } + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::ReturnType { @@ -2423,6 +2550,15 @@ impl Clone for crate::ReturnType { } } #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] +impl Clone for crate::ReturnValue { + fn clone(&self) -> Self { + crate::ReturnValue { + token: self.token.clone(), + pat: self.pat.clone(), + } + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))] impl Clone for crate::Returns { fn clone(&self) -> Self { crate::Returns { @@ -2484,6 +2620,7 @@ impl Clone for crate::SignatureInvariants { crate::SignatureInvariants { token: self.token.clone(), set: self.set.clone(), + comma: self.comma.clone(), } } } @@ -2492,6 +2629,7 @@ impl Clone for crate::SignatureSpec { fn clone(&self) -> Self { crate::SignatureSpec { prover: self.prover.clone(), + atomic_spec: self.atomic_spec.clone(), requires: self.requires.clone(), recommends: self.recommends.clone(), ensures: self.ensures.clone(), diff --git a/dependencies/syn/src/gen/debug.rs b/dependencies/syn/src/gen/debug.rs index 7b0fa16462..d7a67ac284 100644 --- a/dependencies/syn/src/gen/debug.rs +++ b/dependencies/syn/src/gen/debug.rs @@ -135,6 +135,43 @@ impl Debug for crate::AssumeSpecification { formatter.finish() } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::AtomicSpec { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("AtomicSpec"); + formatter.field("atomically_token", &self.atomically_token); + formatter.field("paren_token", &self.paren_token); + formatter.field("atomic_update", &self.atomic_update); + formatter.field("block_token", &self.block_token); + formatter.field("type_clause", &self.type_clause); + formatter.field("perm_clause", &self.perm_clause); + formatter.field("requires", &self.requires); + formatter.field("ensures", &self.ensures); + formatter.field("outer_mask", &self.outer_mask); + formatter.field("inner_mask", &self.inner_mask); + formatter.field("comma_token", &self.comma_token); + formatter.finish() + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::AtomicallyBlock { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("AtomicallyBlock"); + formatter.field("label", &self.label); + formatter.field("atomically_token", &self.atomically_token); + formatter.field("loop_token", &self.loop_token); + formatter.field("or1_token", &self.or1_token); + formatter.field("update_fn_binder", &self.update_fn_binder); + formatter.field("comma_token", &self.comma_token); + formatter.field("or2_token", &self.or2_token); + formatter.field("spec_au_binder", &self.spec_au_binder); + formatter.field("invariant_except_breaks", &self.invariant_except_breaks); + formatter.field("invariants", &self.invariants); + formatter.field("ensures", &self.ensures); + formatter.field("body", &self.body); + formatter.finish() + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::AttrStyle { @@ -899,6 +936,7 @@ impl crate::ExprCall { formatter.field("func", &self.func); formatter.field("paren_token", &self.paren_token); formatter.field("args", &self.args); + formatter.field("atomically", &self.atomically); formatter.finish() } } @@ -1322,6 +1360,7 @@ impl crate::ExprMethodCall { formatter.field("turbofish", &self.turbofish); formatter.field("paren_token", &self.paren_token); formatter.field("args", &self.args); + formatter.field("atomically", &self.atomically); formatter.finish() } } @@ -2134,6 +2173,16 @@ impl Debug for crate::Index { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::InnerMask { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("InnerMask"); + formatter.field("token", &self.token); + formatter.field("set", &self.set); + formatter.field("comma_token", &self.comma_token); + formatter.finish() + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::Invariant { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let mut formatter = formatter.debug_struct("Invariant"); @@ -2168,6 +2217,7 @@ impl Debug for crate::InvariantNameSet { crate::InvariantNameSet::Any(v0) => v0.debug(formatter, "Any"), crate::InvariantNameSet::None(v0) => v0.debug(formatter, "None"), crate::InvariantNameSet::List(v0) => v0.debug(formatter, "List"), + crate::InvariantNameSet::ListCompl(v0) => v0.debug(formatter, "ListCompl"), crate::InvariantNameSet::Set(v0) => v0.debug(formatter, "Set"), } } @@ -2200,6 +2250,22 @@ impl crate::InvariantNameSetList { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::InvariantNameSetListCompl { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + self.debug(formatter, "InvariantNameSetListCompl") + } +} +impl crate::InvariantNameSetListCompl { + fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result { + let mut formatter = formatter.debug_struct(name); + formatter.field("any_token", &self.any_token); + formatter.field("op_token", &self.op_token); + formatter.field("bracket_token", &self.bracket_token); + formatter.field("exprs", &self.exprs); + formatter.finish() + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::InvariantNameSetNone { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { self.debug(formatter, "InvariantNameSetNone") @@ -2955,6 +3021,16 @@ impl Debug for crate::OpenRestricted { formatter.finish() } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::OuterMask { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("OuterMask"); + formatter.field("token", &self.token); + formatter.field("set", &self.set); + formatter.field("comma_token", &self.comma_token); + formatter.finish() + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::ParenthesizedGenericArguments { @@ -3238,6 +3314,36 @@ impl Debug for crate::PathSegment { formatter.finish() } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::PermClause { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("PermClause"); + formatter.field("old_perms", &self.old_perms); + formatter.field("arrow_token", &self.arrow_token); + formatter.field("new_perms", &self.new_perms); + formatter.field("comma_token", &self.comma_token); + formatter.finish() + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::PermTuple { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("PermTuple"); + formatter.field("paren_token", &self.paren_token); + formatter.field("fields", &self.fields); + formatter.finish() + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::PermTupleField { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("PermTupleField"); + formatter.field("ident", &self.ident); + formatter.field("colon_token", &self.colon_token); + formatter.field("ty", &self.ty); + formatter.finish() + } +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::PointerMutability { @@ -3269,6 +3375,16 @@ impl Debug for crate::PreciseCapture { formatter.finish() } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::PredTypeClause { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("PredTypeClause"); + formatter.field("type_token", &self.type_token); + formatter.field("ident", &self.ident); + formatter.field("comma_token", &self.comma_token); + formatter.finish() + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::PredicateLifetime { @@ -3396,6 +3512,29 @@ impl Debug for crate::Requires { formatter.finish() } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::ReturnPat { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str("ReturnPat::")?; + match self { + crate::ReturnPat::Default => formatter.write_str("Default"), + crate::ReturnPat::Pat(v0, v1, v2, v3) => { + let mut formatter = formatter.debug_tuple("Pat"); + formatter.field(v0); + formatter.field(v1); + formatter.field(v2); + formatter.field(v3); + formatter.finish() + } + crate::ReturnPat::Type(v0, v1) => { + let mut formatter = formatter.debug_tuple("Type"); + formatter.field(v0); + formatter.field(v1); + formatter.finish() + } + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::ReturnType { @@ -3415,6 +3554,15 @@ impl Debug for crate::ReturnType { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Debug for crate::ReturnValue { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + let mut formatter = formatter.debug_struct("ReturnValue"); + formatter.field("token", &self.token); + formatter.field("pat", &self.pat); + formatter.finish() + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Debug for crate::Returns { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let mut formatter = formatter.debug_struct("Returns"); @@ -3476,6 +3624,7 @@ impl Debug for crate::SignatureInvariants { let mut formatter = formatter.debug_struct("SignatureInvariants"); formatter.field("token", &self.token); formatter.field("set", &self.set); + formatter.field("comma", &self.comma); formatter.finish() } } @@ -3484,6 +3633,7 @@ impl Debug for crate::SignatureSpec { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let mut formatter = formatter.debug_struct("SignatureSpec"); formatter.field("prover", &self.prover); + formatter.field("atomic_spec", &self.atomic_spec); formatter.field("requires", &self.requires); formatter.field("recommends", &self.recommends); formatter.field("ensures", &self.ensures); diff --git a/dependencies/syn/src/gen/eq.rs b/dependencies/syn/src/gen/eq.rs index 567b365901..b5e382712f 100644 --- a/dependencies/syn/src/gen/eq.rs +++ b/dependencies/syn/src/gen/eq.rs @@ -101,6 +101,33 @@ impl PartialEq for crate::AssumeSpecification { && self.unwind == other.unwind } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::AtomicSpec {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::AtomicSpec { + fn eq(&self, other: &Self) -> bool { + self.atomic_update == other.atomic_update + && self.type_clause == other.type_clause + && self.perm_clause == other.perm_clause && self.requires == other.requires + && self.ensures == other.ensures && self.outer_mask == other.outer_mask + && self.inner_mask == other.inner_mask + && self.comma_token == other.comma_token + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::AtomicallyBlock {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::AtomicallyBlock { + fn eq(&self, other: &Self) -> bool { + self.label == other.label && self.loop_token == other.loop_token + && self.update_fn_binder == other.update_fn_binder + && self.comma_token == other.comma_token + && self.spec_au_binder == other.spec_au_binder + && self.invariant_except_breaks == other.invariant_except_breaks + && self.invariants == other.invariants && self.ensures == other.ensures + && self.body == other.body + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::AttrStyle {} @@ -608,6 +635,7 @@ impl Eq for crate::ExprCall {} impl PartialEq for crate::ExprCall { fn eq(&self, other: &Self) -> bool { self.attrs == other.attrs && self.func == other.func && self.args == other.args + && self.atomically == other.atomically } } #[cfg(any(feature = "derive", feature = "full"))] @@ -847,7 +875,7 @@ impl PartialEq for crate::ExprMethodCall { fn eq(&self, other: &Self) -> bool { self.attrs == other.attrs && self.receiver == other.receiver && self.method == other.method && self.turbofish == other.turbofish - && self.args == other.args + && self.args == other.args && self.atomically == other.atomically } } #[cfg(any(feature = "derive", feature = "full"))] @@ -1444,6 +1472,14 @@ impl PartialEq for crate::ImplRestriction { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::InnerMask {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::InnerMask { + fn eq(&self, other: &Self) -> bool { + self.set == other.set && self.comma_token == other.comma_token + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::Invariant {} #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl PartialEq for crate::Invariant { @@ -1485,6 +1521,10 @@ impl PartialEq for crate::InvariantNameSet { crate::InvariantNameSet::List(self0), crate::InvariantNameSet::List(other0), ) => self0 == other0, + ( + crate::InvariantNameSet::ListCompl(self0), + crate::InvariantNameSet::ListCompl(other0), + ) => self0 == other0, ( crate::InvariantNameSet::Set(self0), crate::InvariantNameSet::Set(other0), @@ -1510,6 +1550,14 @@ impl PartialEq for crate::InvariantNameSetList { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::InvariantNameSetListCompl {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::InvariantNameSetListCompl { + fn eq(&self, other: &Self) -> bool { + self.exprs == other.exprs + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::InvariantNameSetNone {} #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl PartialEq for crate::InvariantNameSetNone { @@ -2034,6 +2082,14 @@ impl PartialEq for crate::OpenRestricted { self.in_token == other.in_token && self.path == other.path } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::OuterMask {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::OuterMask { + fn eq(&self, other: &Self) -> bool { + self.set == other.set && self.comma_token == other.comma_token + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::ParenthesizedGenericArguments {} @@ -2236,6 +2292,31 @@ impl PartialEq for crate::PathSegment { self.ident == other.ident && self.arguments == other.arguments } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::PermClause {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::PermClause { + fn eq(&self, other: &Self) -> bool { + self.old_perms == other.old_perms && self.arrow_token == other.arrow_token + && self.new_perms == other.new_perms && self.comma_token == other.comma_token + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::PermTuple {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::PermTuple { + fn eq(&self, other: &Self) -> bool { + self.fields == other.fields + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::PermTupleField {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::PermTupleField { + fn eq(&self, other: &Self) -> bool { + self.ident == other.ident && self.ty == other.ty + } +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::PointerMutability {} @@ -2262,6 +2343,14 @@ impl PartialEq for crate::PreciseCapture { self.params == other.params } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::PredTypeClause {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::PredTypeClause { + fn eq(&self, other: &Self) -> bool { + self.ident == other.ident + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::PredicateLifetime {} @@ -2368,6 +2457,24 @@ impl PartialEq for crate::Requires { self.exprs == other.exprs } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::ReturnPat {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::ReturnPat { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (crate::ReturnPat::Default, crate::ReturnPat::Default) => true, + ( + crate::ReturnPat::Pat(_, _, self2, self3), + crate::ReturnPat::Pat(_, _, other2, other3), + ) => self2 == other2 && self3 == other3, + (crate::ReturnPat::Type(_, self1), crate::ReturnPat::Type(_, other1)) => { + self1 == other1 + } + _ => false, + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::ReturnType {} @@ -2386,6 +2493,14 @@ impl PartialEq for crate::ReturnType { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Eq for crate::ReturnValue {} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl PartialEq for crate::ReturnValue { + fn eq(&self, other: &Self) -> bool { + self.pat == other.pat + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Eq for crate::Returns {} #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl PartialEq for crate::Returns { @@ -2434,7 +2549,7 @@ impl Eq for crate::SignatureInvariants {} #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl PartialEq for crate::SignatureInvariants { fn eq(&self, other: &Self) -> bool { - self.set == other.set + self.set == other.set && self.comma == other.comma } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] @@ -2442,8 +2557,9 @@ impl Eq for crate::SignatureSpec {} #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl PartialEq for crate::SignatureSpec { fn eq(&self, other: &Self) -> bool { - self.prover == other.prover && self.requires == other.requires - && self.recommends == other.recommends && self.ensures == other.ensures + self.prover == other.prover && self.atomic_spec == other.atomic_spec + && self.requires == other.requires && self.recommends == other.recommends + && self.ensures == other.ensures && self.default_ensures == other.default_ensures && self.returns == other.returns && self.decreases == other.decreases && self.invariants == other.invariants && self.unwind == other.unwind diff --git a/dependencies/syn/src/gen/fold.rs b/dependencies/syn/src/gen/fold.rs index 91224f1fd6..3dc69501ec 100644 --- a/dependencies/syn/src/gen/fold.rs +++ b/dependencies/syn/src/gen/fold.rs @@ -72,6 +72,15 @@ pub trait Fold { ) -> crate::AssumeSpecification { fold_assume_specification(self, i) } + fn fold_atomic_spec(&mut self, i: crate::AtomicSpec) -> crate::AtomicSpec { + fold_atomic_spec(self, i) + } + fn fold_atomically_block( + &mut self, + i: crate::AtomicallyBlock, + ) -> crate::AtomicallyBlock { + fold_atomically_block(self, i) + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn fold_attr_style(&mut self, i: crate::AttrStyle) -> crate::AttrStyle { @@ -585,6 +594,9 @@ pub trait Fold { fn fold_index(&mut self, i: crate::Index) -> crate::Index { fold_index(self, i) } + fn fold_inner_mask(&mut self, i: crate::InnerMask) -> crate::InnerMask { + fold_inner_mask(self, i) + } fn fold_invariant(&mut self, i: crate::Invariant) -> crate::Invariant { fold_invariant(self, i) } @@ -618,6 +630,12 @@ pub trait Fold { ) -> crate::InvariantNameSetList { fold_invariant_name_set_list(self, i) } + fn fold_invariant_name_set_list_compl( + &mut self, + i: crate::InvariantNameSetListCompl, + ) -> crate::InvariantNameSetListCompl { + fold_invariant_name_set_list_compl(self, i) + } fn fold_invariant_name_set_none( &mut self, i: crate::InvariantNameSetNone, @@ -859,6 +877,9 @@ pub trait Fold { ) -> crate::OpenRestricted { fold_open_restricted(self, i) } + fn fold_outer_mask(&mut self, i: crate::OuterMask) -> crate::OuterMask { + fold_outer_mask(self, i) + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn fold_parenthesized_generic_arguments( @@ -945,6 +966,18 @@ pub trait Fold { fn fold_path_segment(&mut self, i: crate::PathSegment) -> crate::PathSegment { fold_path_segment(self, i) } + fn fold_perm_clause(&mut self, i: crate::PermClause) -> crate::PermClause { + fold_perm_clause(self, i) + } + fn fold_perm_tuple(&mut self, i: crate::PermTuple) -> crate::PermTuple { + fold_perm_tuple(self, i) + } + fn fold_perm_tuple_field( + &mut self, + i: crate::PermTupleField, + ) -> crate::PermTupleField { + fold_perm_tuple_field(self, i) + } #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "full")))] fn fold_pointer_mutability( @@ -961,6 +994,12 @@ pub trait Fold { ) -> crate::PreciseCapture { fold_precise_capture(self, i) } + fn fold_pred_type_clause( + &mut self, + i: crate::PredTypeClause, + ) -> crate::PredTypeClause { + fold_pred_type_clause(self, i) + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn fold_predicate_lifetime( @@ -1001,11 +1040,17 @@ pub trait Fold { fn fold_requires(&mut self, i: crate::Requires) -> crate::Requires { fold_requires(self, i) } + fn fold_return_pat(&mut self, i: crate::ReturnPat) -> crate::ReturnPat { + fold_return_pat(self, i) + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn fold_return_type(&mut self, i: crate::ReturnType) -> crate::ReturnType { fold_return_type(self, i) } + fn fold_return_value(&mut self, i: crate::ReturnValue) -> crate::ReturnValue { + fold_return_value(self, i) + } fn fold_returns(&mut self, i: crate::Returns) -> crate::Returns { fold_returns(self, i) } @@ -1437,6 +1482,47 @@ where semi: node.semi, } } +pub fn fold_atomic_spec(f: &mut F, node: crate::AtomicSpec) -> crate::AtomicSpec +where + F: Fold + ?Sized, +{ + crate::AtomicSpec { + atomically_token: node.atomically_token, + paren_token: node.paren_token, + atomic_update: f.fold_ident(node.atomic_update), + block_token: node.block_token, + type_clause: (node.type_clause).map(|it| f.fold_pred_type_clause(it)), + perm_clause: f.fold_perm_clause(node.perm_clause), + requires: (node.requires).map(|it| f.fold_requires(it)), + ensures: (node.ensures).map(|it| f.fold_ensures(it)), + outer_mask: (node.outer_mask).map(|it| f.fold_outer_mask(it)), + inner_mask: (node.inner_mask).map(|it| f.fold_inner_mask(it)), + comma_token: node.comma_token, + } +} +pub fn fold_atomically_block( + f: &mut F, + node: crate::AtomicallyBlock, +) -> crate::AtomicallyBlock +where + F: Fold + ?Sized, +{ + crate::AtomicallyBlock { + label: (node.label).map(|it| full!(f.fold_label(it))), + atomically_token: node.atomically_token, + loop_token: node.loop_token, + or1_token: node.or1_token, + update_fn_binder: f.fold_ident(node.update_fn_binder), + comma_token: node.comma_token, + or2_token: node.or2_token, + spec_au_binder: f.fold_return_pat(node.spec_au_binder), + invariant_except_breaks: (node.invariant_except_breaks) + .map(|it| f.fold_invariant_except_break(it)), + invariants: (node.invariants).map(|it| f.fold_invariant(it)), + ensures: (node.ensures).map(|it| f.fold_ensures(it)), + body: Box::new(full!(f.fold_block(* node.body))), + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn fold_attr_style(f: &mut F, node: crate::AttrStyle) -> crate::AttrStyle @@ -2034,6 +2120,7 @@ where func: Box::new(f.fold_expr(*node.func)), paren_token: node.paren_token, args: crate::punctuated::fold(node.args, f, F::fold_expr), + atomically: (node.atomically).map(|it| f.fold_atomically_block(it)), } } #[cfg(any(feature = "derive", feature = "full"))] @@ -2353,6 +2440,7 @@ where .map(|it| f.fold_angle_bracketed_generic_arguments(it)), paren_token: node.paren_token, args: crate::punctuated::fold(node.args, f, F::fold_expr), + atomically: (node.atomically).map(|it| f.fold_atomically_block(it)), } } #[cfg(any(feature = "derive", feature = "full"))] @@ -3083,6 +3171,16 @@ where span: f.fold_span(node.span), } } +pub fn fold_inner_mask(f: &mut F, node: crate::InnerMask) -> crate::InnerMask +where + F: Fold + ?Sized, +{ + crate::InnerMask { + token: node.token, + set: f.fold_invariant_name_set(node.set), + comma_token: node.comma_token, + } +} pub fn fold_invariant(f: &mut F, node: crate::Invariant) -> crate::Invariant where F: Fold + ?Sized, @@ -3133,6 +3231,11 @@ where crate::InvariantNameSet::List(_binding_0) => { crate::InvariantNameSet::List(f.fold_invariant_name_set_list(_binding_0)) } + crate::InvariantNameSet::ListCompl(_binding_0) => { + crate::InvariantNameSet::ListCompl( + f.fold_invariant_name_set_list_compl(_binding_0), + ) + } crate::InvariantNameSet::Set(_binding_0) => { crate::InvariantNameSet::Set(f.fold_invariant_name_set_set(_binding_0)) } @@ -3161,6 +3264,20 @@ where exprs: crate::punctuated::fold(node.exprs, f, F::fold_expr), } } +pub fn fold_invariant_name_set_list_compl( + f: &mut F, + node: crate::InvariantNameSetListCompl, +) -> crate::InvariantNameSetListCompl +where + F: Fold + ?Sized, +{ + crate::InvariantNameSetListCompl { + any_token: node.any_token, + op_token: node.op_token, + bracket_token: node.bracket_token, + exprs: crate::punctuated::fold(node.exprs, f, F::fold_expr), + } +} pub fn fold_invariant_name_set_none( f: &mut F, node: crate::InvariantNameSetNone, @@ -3911,6 +4028,16 @@ where path: Box::new(f.fold_path(*node.path)), } } +pub fn fold_outer_mask(f: &mut F, node: crate::OuterMask) -> crate::OuterMask +where + F: Fold + ?Sized, +{ + crate::OuterMask { + token: node.token, + set: f.fold_invariant_name_set(node.set), + comma_token: node.comma_token, + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn fold_parenthesized_generic_arguments( @@ -4147,6 +4274,39 @@ where arguments: f.fold_path_arguments(node.arguments), } } +pub fn fold_perm_clause(f: &mut F, node: crate::PermClause) -> crate::PermClause +where + F: Fold + ?Sized, +{ + crate::PermClause { + old_perms: f.fold_perm_tuple(node.old_perms), + arrow_token: node.arrow_token, + new_perms: f.fold_perm_tuple(node.new_perms), + comma_token: node.comma_token, + } +} +pub fn fold_perm_tuple(f: &mut F, node: crate::PermTuple) -> crate::PermTuple +where + F: Fold + ?Sized, +{ + crate::PermTuple { + paren_token: node.paren_token, + fields: crate::punctuated::fold(node.fields, f, F::fold_perm_tuple_field), + } +} +pub fn fold_perm_tuple_field( + f: &mut F, + node: crate::PermTupleField, +) -> crate::PermTupleField +where + F: Fold + ?Sized, +{ + crate::PermTupleField { + ident: f.fold_ident(node.ident), + colon_token: node.colon_token, + ty: f.fold_type(node.ty), + } +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "full")))] pub fn fold_pointer_mutability( @@ -4181,6 +4341,19 @@ where gt_token: node.gt_token, } } +pub fn fold_pred_type_clause( + f: &mut F, + node: crate::PredTypeClause, +) -> crate::PredTypeClause +where + F: Fold + ?Sized, +{ + crate::PredTypeClause { + type_token: node.type_token, + ident: f.fold_ident(node.ident), + comma_token: node.comma_token, + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn fold_predicate_lifetime( @@ -4302,6 +4475,25 @@ where exprs: f.fold_specification(node.exprs), } } +pub fn fold_return_pat(f: &mut F, node: crate::ReturnPat) -> crate::ReturnPat +where + F: Fold + ?Sized, +{ + match node { + crate::ReturnPat::Default => crate::ReturnPat::Default, + crate::ReturnPat::Pat(_binding_0, _binding_1, _binding_2, _binding_3) => { + crate::ReturnPat::Pat( + _binding_0, + _binding_1, + full!(f.fold_pat(_binding_2)), + (_binding_3).map(|it| Box::new(((*it).0, f.fold_type((*it).1)))), + ) + } + crate::ReturnPat::Type(_binding_0, _binding_1) => { + crate::ReturnPat::Type(_binding_0, Box::new(f.fold_type(*_binding_1))) + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn fold_return_type(f: &mut F, node: crate::ReturnType) -> crate::ReturnType @@ -4321,6 +4513,15 @@ where } } } +pub fn fold_return_value(f: &mut F, node: crate::ReturnValue) -> crate::ReturnValue +where + F: Fold + ?Sized, +{ + crate::ReturnValue { + token: node.token, + pat: full!(f.fold_pat(node.pat)), + } +} pub fn fold_returns(f: &mut F, node: crate::Returns) -> crate::Returns where F: Fold + ?Sized, @@ -4391,6 +4592,7 @@ where crate::SignatureInvariants { token: node.token, set: f.fold_invariant_name_set(node.set), + comma: node.comma, } } pub fn fold_signature_spec( @@ -4402,6 +4604,7 @@ where { crate::SignatureSpec { prover: (node.prover).map(|it| f.fold_prover(it)), + atomic_spec: (node.atomic_spec).map(|it| f.fold_atomic_spec(it)), requires: (node.requires).map(|it| f.fold_requires(it)), recommends: (node.recommends).map(|it| f.fold_recommends(it)), ensures: (node.ensures).map(|it| f.fold_ensures(it)), diff --git a/dependencies/syn/src/gen/hash.rs b/dependencies/syn/src/gen/hash.rs index 8f7b2ae87e..0867bff81f 100644 --- a/dependencies/syn/src/gen/hash.rs +++ b/dependencies/syn/src/gen/hash.rs @@ -123,6 +123,39 @@ impl Hash for crate::AssumeSpecification { self.unwind.hash(state); } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::AtomicSpec { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.atomic_update.hash(state); + self.type_clause.hash(state); + self.perm_clause.hash(state); + self.requires.hash(state); + self.ensures.hash(state); + self.outer_mask.hash(state); + self.inner_mask.hash(state); + self.comma_token.hash(state); + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::AtomicallyBlock { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.label.hash(state); + self.loop_token.hash(state); + self.update_fn_binder.hash(state); + self.comma_token.hash(state); + self.spec_au_binder.hash(state); + self.invariant_except_breaks.hash(state); + self.invariants.hash(state); + self.ensures.hash(state); + self.body.hash(state); + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::AttrStyle { @@ -895,6 +928,7 @@ impl Hash for crate::ExprCall { self.attrs.hash(state); self.func.hash(state); self.args.hash(state); + self.atomically.hash(state); } } #[cfg(any(feature = "derive", feature = "full"))] @@ -1183,6 +1217,7 @@ impl Hash for crate::ExprMethodCall { self.method.hash(state); self.turbofish.hash(state); self.args.hash(state); + self.atomically.hash(state); } } #[cfg(any(feature = "derive", feature = "full"))] @@ -1872,6 +1907,16 @@ impl Hash for crate::ImplRestriction { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::InnerMask { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.set.hash(state); + self.comma_token.hash(state); + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::Invariant { fn hash(&self, state: &mut H) where @@ -1917,10 +1962,14 @@ impl Hash for crate::InvariantNameSet { state.write_u8(2u8); v0.hash(state); } - crate::InvariantNameSet::Set(v0) => { + crate::InvariantNameSet::ListCompl(v0) => { state.write_u8(3u8); v0.hash(state); } + crate::InvariantNameSet::Set(v0) => { + state.write_u8(4u8); + v0.hash(state); + } } } } @@ -1941,6 +1990,15 @@ impl Hash for crate::InvariantNameSetList { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::InvariantNameSetListCompl { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.exprs.hash(state); + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::InvariantNameSetNone { fn hash(&self, _state: &mut H) where @@ -2608,6 +2666,16 @@ impl Hash for crate::OpenRestricted { self.path.hash(state); } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::OuterMask { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.set.hash(state); + self.comma_token.hash(state); + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::ParenthesizedGenericArguments { @@ -2872,6 +2940,37 @@ impl Hash for crate::PathSegment { self.arguments.hash(state); } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::PermClause { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.old_perms.hash(state); + self.arrow_token.hash(state); + self.new_perms.hash(state); + self.comma_token.hash(state); + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::PermTuple { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.fields.hash(state); + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::PermTupleField { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.ident.hash(state); + self.ty.hash(state); + } +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::PointerMutability { @@ -2899,6 +2998,15 @@ impl Hash for crate::PreciseCapture { self.params.hash(state); } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::PredTypeClause { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.ident.hash(state); + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::PredicateLifetime { @@ -3022,6 +3130,28 @@ impl Hash for crate::Requires { self.exprs.hash(state); } } +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::ReturnPat { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + match self { + crate::ReturnPat::Default => { + state.write_u8(0u8); + } + crate::ReturnPat::Pat(_, _, v2, v3) => { + state.write_u8(1u8); + v2.hash(state); + v3.hash(state); + } + crate::ReturnPat::Type(_, v1) => { + state.write_u8(2u8); + v1.hash(state); + } + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::ReturnType { @@ -3043,6 +3173,15 @@ impl Hash for crate::ReturnType { } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] +impl Hash for crate::ReturnValue { + fn hash(&self, state: &mut H) + where + H: Hasher, + { + self.pat.hash(state); + } +} +#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] impl Hash for crate::Returns { fn hash(&self, state: &mut H) where @@ -3105,6 +3244,7 @@ impl Hash for crate::SignatureInvariants { H: Hasher, { self.set.hash(state); + self.comma.hash(state); } } #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))] @@ -3114,6 +3254,7 @@ impl Hash for crate::SignatureSpec { H: Hasher, { self.prover.hash(state); + self.atomic_spec.hash(state); self.requires.hash(state); self.recommends.hash(state); self.ensures.hash(state); diff --git a/dependencies/syn/src/gen/token.css b/dependencies/syn/src/gen/token.css index ede928ceb3..1330ff8e35 100644 --- a/dependencies/syn/src/gen/token.css +++ b/dependencies/syn/src/gen/token.css @@ -8,6 +8,7 @@ a.struct[title="struct syn::token::Assume"], a.struct[title="struct syn::token::AssumeSpecification"], a.struct[title="struct syn::token::Async"], a.struct[title="struct syn::token::At"], +a.struct[title="struct syn::token::Atomically"], a.struct[title="struct syn::token::Auto"], a.struct[title="struct syn::token::Await"], a.struct[title="struct syn::token::Axiom"], @@ -67,6 +68,7 @@ a.struct[title="struct syn::token::Impl"], a.struct[title="struct syn::token::Implies"], a.struct[title="struct syn::token::Imply"], a.struct[title="struct syn::token::In"], +a.struct[title="struct syn::token::InnerMask"], a.struct[title="struct syn::token::InvAny"], a.struct[title="struct syn::token::InvNone"], a.struct[title="struct syn::token::Invariant"], @@ -97,6 +99,7 @@ a.struct[title="struct syn::token::OpensInvariants"], a.struct[title="struct syn::token::Or"], a.struct[title="struct syn::token::OrEq"], a.struct[title="struct syn::token::OrOr"], +a.struct[title="struct syn::token::OuterMask"], a.struct[title="struct syn::token::Override"], a.struct[title="struct syn::token::PathSep"], a.struct[title="struct syn::token::Percent"], @@ -173,6 +176,7 @@ a.struct[title="struct syn::token::Assume"]::before, a.struct[title="struct syn::token::AssumeSpecification"]::before, a.struct[title="struct syn::token::Async"]::before, a.struct[title="struct syn::token::At"]::before, +a.struct[title="struct syn::token::Atomically"]::before, a.struct[title="struct syn::token::Auto"]::before, a.struct[title="struct syn::token::Await"]::before, a.struct[title="struct syn::token::Axiom"]::before, @@ -232,6 +236,7 @@ a.struct[title="struct syn::token::Impl"]::before, a.struct[title="struct syn::token::Implies"]::before, a.struct[title="struct syn::token::Imply"]::before, a.struct[title="struct syn::token::In"]::before, +a.struct[title="struct syn::token::InnerMask"]::before, a.struct[title="struct syn::token::InvAny"]::before, a.struct[title="struct syn::token::InvNone"]::before, a.struct[title="struct syn::token::Invariant"]::before, @@ -262,6 +267,7 @@ a.struct[title="struct syn::token::OpensInvariants"]::before, a.struct[title="struct syn::token::Or"]::before, a.struct[title="struct syn::token::OrEq"]::before, a.struct[title="struct syn::token::OrOr"]::before, +a.struct[title="struct syn::token::OuterMask"]::before, a.struct[title="struct syn::token::Override"]::before, a.struct[title="struct syn::token::PathSep"]::before, a.struct[title="struct syn::token::Percent"]::before, @@ -368,6 +374,10 @@ a.struct[title="struct syn::token::At"]::before { content: "Token![@]"; } +a.struct[title="struct syn::token::Atomically"]::before { + content: "Token![atomically]"; +} + a.struct[title="struct syn::token::Auto"]::before { content: "Token![auto]"; } @@ -605,6 +615,10 @@ a.struct[title="struct syn::token::In"]::before { content: "Token![in]"; } +a.struct[title="struct syn::token::InnerMask"]::before { + content: "Token![inner_mask]"; +} + a.struct[title="struct syn::token::InvAny"]::before { content: "Token![any]"; } @@ -725,6 +739,10 @@ a.struct[title="struct syn::token::OrOr"]::before { content: "Token![||]"; } +a.struct[title="struct syn::token::OuterMask"]::before { + content: "Token![outer_mask]"; +} + a.struct[title="struct syn::token::Override"]::before { content: "Token![override]"; } @@ -1067,6 +1085,7 @@ a.struct[title="struct syn::token::As"]::after, a.struct[title="struct syn::token::Assert"]::after, a.struct[title="struct syn::token::Assume"]::after, a.struct[title="struct syn::token::Async"]::after, +a.struct[title="struct syn::token::Atomically"]::after, a.struct[title="struct syn::token::Auto"]::after, a.struct[title="struct syn::token::Await"]::after, a.struct[title="struct syn::token::Axiom"]::after, @@ -1156,9 +1175,11 @@ a.struct[title="struct syn::token::Yield"]::after { a.struct[title="struct syn::token::AssumeSpecification"]::after, a.struct[title="struct syn::token::DefaultEnsures"]::after, +a.struct[title="struct syn::token::InnerMask"]::after, a.struct[title="struct syn::token::InvariantEnsures"]::after, a.struct[title="struct syn::token::NoUnwind"]::after, a.struct[title="struct syn::token::OpensInvariants"]::after, +a.struct[title="struct syn::token::OuterMask"]::after, a.struct[title="struct syn::token::ProofFn"]::after, a.struct[title="struct syn::token::SizeOf"]::after { content: "........."; diff --git a/dependencies/syn/src/gen/visit.rs b/dependencies/syn/src/gen/visit.rs index eed8086f70..f43b595384 100644 --- a/dependencies/syn/src/gen/visit.rs +++ b/dependencies/syn/src/gen/visit.rs @@ -66,6 +66,12 @@ pub trait Visit<'ast> { fn visit_assume_specification(&mut self, i: &'ast crate::AssumeSpecification) { visit_assume_specification(self, i); } + fn visit_atomic_spec(&mut self, i: &'ast crate::AtomicSpec) { + visit_atomic_spec(self, i); + } + fn visit_atomically_block(&mut self, i: &'ast crate::AtomicallyBlock) { + visit_atomically_block(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_attr_style(&mut self, i: &'ast crate::AttrStyle) { @@ -544,6 +550,9 @@ pub trait Visit<'ast> { fn visit_index(&mut self, i: &'ast crate::Index) { visit_index(self, i); } + fn visit_inner_mask(&mut self, i: &'ast crate::InnerMask) { + visit_inner_mask(self, i); + } fn visit_invariant(&mut self, i: &'ast crate::Invariant) { visit_invariant(self, i); } @@ -562,6 +571,12 @@ pub trait Visit<'ast> { fn visit_invariant_name_set_list(&mut self, i: &'ast crate::InvariantNameSetList) { visit_invariant_name_set_list(self, i); } + fn visit_invariant_name_set_list_compl( + &mut self, + i: &'ast crate::InvariantNameSetListCompl, + ) { + visit_invariant_name_set_list_compl(self, i); + } fn visit_invariant_name_set_none(&mut self, i: &'ast crate::InvariantNameSetNone) { visit_invariant_name_set_none(self, i); } @@ -770,6 +785,9 @@ pub trait Visit<'ast> { fn visit_open_restricted(&mut self, i: &'ast crate::OpenRestricted) { visit_open_restricted(self, i); } + fn visit_outer_mask(&mut self, i: &'ast crate::OuterMask) { + visit_outer_mask(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_parenthesized_generic_arguments( @@ -853,6 +871,15 @@ pub trait Visit<'ast> { fn visit_path_segment(&mut self, i: &'ast crate::PathSegment) { visit_path_segment(self, i); } + fn visit_perm_clause(&mut self, i: &'ast crate::PermClause) { + visit_perm_clause(self, i); + } + fn visit_perm_tuple(&mut self, i: &'ast crate::PermTuple) { + visit_perm_tuple(self, i); + } + fn visit_perm_tuple_field(&mut self, i: &'ast crate::PermTupleField) { + visit_perm_tuple_field(self, i); + } #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "full")))] fn visit_pointer_mutability(&mut self, i: &'ast crate::PointerMutability) { @@ -863,6 +890,9 @@ pub trait Visit<'ast> { fn visit_precise_capture(&mut self, i: &'ast crate::PreciseCapture) { visit_precise_capture(self, i); } + fn visit_pred_type_clause(&mut self, i: &'ast crate::PredTypeClause) { + visit_pred_type_clause(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_predicate_lifetime(&mut self, i: &'ast crate::PredicateLifetime) { @@ -900,11 +930,17 @@ pub trait Visit<'ast> { fn visit_requires(&mut self, i: &'ast crate::Requires) { visit_requires(self, i); } + fn visit_return_pat(&mut self, i: &'ast crate::ReturnPat) { + visit_return_pat(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_return_type(&mut self, i: &'ast crate::ReturnType) { visit_return_type(self, i); } + fn visit_return_value(&mut self, i: &'ast crate::ReturnValue) { + visit_return_value(self, i); + } fn visit_returns(&mut self, i: &'ast crate::Returns) { visit_returns(self, i); } @@ -1329,6 +1365,57 @@ where } skip!(node.semi); } +pub fn visit_atomic_spec<'ast, V>(v: &mut V, node: &'ast crate::AtomicSpec) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.atomically_token); + skip!(node.paren_token); + v.visit_ident(&node.atomic_update); + skip!(node.block_token); + if let Some(it) = &node.type_clause { + v.visit_pred_type_clause(it); + } + v.visit_perm_clause(&node.perm_clause); + if let Some(it) = &node.requires { + v.visit_requires(it); + } + if let Some(it) = &node.ensures { + v.visit_ensures(it); + } + if let Some(it) = &node.outer_mask { + v.visit_outer_mask(it); + } + if let Some(it) = &node.inner_mask { + v.visit_inner_mask(it); + } + skip!(node.comma_token); +} +pub fn visit_atomically_block<'ast, V>(v: &mut V, node: &'ast crate::AtomicallyBlock) +where + V: Visit<'ast> + ?Sized, +{ + if let Some(it) = &node.label { + full!(v.visit_label(it)); + } + skip!(node.atomically_token); + skip!(node.loop_token); + skip!(node.or1_token); + v.visit_ident(&node.update_fn_binder); + skip!(node.comma_token); + skip!(node.or2_token); + v.visit_return_pat(&node.spec_au_binder); + if let Some(it) = &node.invariant_except_breaks { + v.visit_invariant_except_break(it); + } + if let Some(it) = &node.invariants { + v.visit_invariant(it); + } + if let Some(it) = &node.ensures { + v.visit_ensures(it); + } + full!(v.visit_block(& * node.body)); +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_attr_style<'ast, V>(v: &mut V, node: &'ast crate::AttrStyle) @@ -2028,6 +2115,9 @@ where let it = el.value(); v.visit_expr(it); } + if let Some(it) = &node.atomically { + v.visit_atomically_block(it); + } } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] @@ -2388,6 +2478,9 @@ where let it = el.value(); v.visit_expr(it); } + if let Some(it) = &node.atomically { + v.visit_atomically_block(it); + } } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] @@ -3110,6 +3203,14 @@ where skip!(node.index); v.visit_span(&node.span); } +pub fn visit_inner_mask<'ast, V>(v: &mut V, node: &'ast crate::InnerMask) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.token); + v.visit_invariant_name_set(&node.set); + skip!(node.comma_token); +} pub fn visit_invariant<'ast, V>(v: &mut V, node: &'ast crate::Invariant) where V: Visit<'ast> + ?Sized, @@ -3148,6 +3249,9 @@ where crate::InvariantNameSet::List(_binding_0) => { v.visit_invariant_name_set_list(_binding_0); } + crate::InvariantNameSet::ListCompl(_binding_0) => { + v.visit_invariant_name_set_list_compl(_binding_0); + } crate::InvariantNameSet::Set(_binding_0) => { v.visit_invariant_name_set_set(_binding_0); } @@ -3175,6 +3279,21 @@ where v.visit_expr(it); } } +pub fn visit_invariant_name_set_list_compl<'ast, V>( + v: &mut V, + node: &'ast crate::InvariantNameSetListCompl, +) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.any_token); + skip!(node.op_token); + skip!(node.bracket_token); + for el in Punctuated::pairs(&node.exprs) { + let it = el.value(); + v.visit_expr(it); + } +} pub fn visit_invariant_name_set_none<'ast, V>( v: &mut V, node: &'ast crate::InvariantNameSetNone, @@ -3915,6 +4034,14 @@ where skip!(node.in_token); v.visit_path(&*node.path); } +pub fn visit_outer_mask<'ast, V>(v: &mut V, node: &'ast crate::OuterMask) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.token); + v.visit_invariant_name_set(&node.set); + skip!(node.comma_token); +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_parenthesized_generic_arguments<'ast, V>( @@ -4191,6 +4318,33 @@ where v.visit_ident(&node.ident); v.visit_path_arguments(&node.arguments); } +pub fn visit_perm_clause<'ast, V>(v: &mut V, node: &'ast crate::PermClause) +where + V: Visit<'ast> + ?Sized, +{ + v.visit_perm_tuple(&node.old_perms); + skip!(node.arrow_token); + v.visit_perm_tuple(&node.new_perms); + skip!(node.comma_token); +} +pub fn visit_perm_tuple<'ast, V>(v: &mut V, node: &'ast crate::PermTuple) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.paren_token); + for el in Punctuated::pairs(&node.fields) { + let it = el.value(); + v.visit_perm_tuple_field(it); + } +} +pub fn visit_perm_tuple_field<'ast, V>(v: &mut V, node: &'ast crate::PermTupleField) +where + V: Visit<'ast> + ?Sized, +{ + v.visit_ident(&node.ident); + skip!(node.colon_token); + v.visit_type(&node.ty); +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "full")))] pub fn visit_pointer_mutability<'ast, V>(v: &mut V, node: &'ast crate::PointerMutability) @@ -4220,6 +4374,14 @@ where } skip!(node.gt_token); } +pub fn visit_pred_type_clause<'ast, V>(v: &mut V, node: &'ast crate::PredTypeClause) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.type_token); + v.visit_ident(&node.ident); + skip!(node.comma_token); +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_predicate_lifetime<'ast, V>(v: &mut V, node: &'ast crate::PredicateLifetime) @@ -4342,6 +4504,27 @@ where skip!(node.token); v.visit_specification(&node.exprs); } +pub fn visit_return_pat<'ast, V>(v: &mut V, node: &'ast crate::ReturnPat) +where + V: Visit<'ast> + ?Sized, +{ + match node { + crate::ReturnPat::Default => {} + crate::ReturnPat::Pat(_binding_0, _binding_1, _binding_2, _binding_3) => { + skip!(_binding_0); + skip!(_binding_1); + full!(v.visit_pat(_binding_2)); + if let Some(it) = _binding_3 { + skip!((* * it).0); + v.visit_type(&(**it).1); + } + } + crate::ReturnPat::Type(_binding_0, _binding_1) => { + skip!(_binding_0); + v.visit_type(&**_binding_1); + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_return_type<'ast, V>(v: &mut V, node: &'ast crate::ReturnType) @@ -4362,6 +4545,13 @@ where } } } +pub fn visit_return_value<'ast, V>(v: &mut V, node: &'ast crate::ReturnValue) +where + V: Visit<'ast> + ?Sized, +{ + skip!(node.token); + full!(v.visit_pat(& node.pat)); +} pub fn visit_returns<'ast, V>(v: &mut V, node: &'ast crate::Returns) where V: Visit<'ast> + ?Sized, @@ -4441,6 +4631,7 @@ where { skip!(node.token); v.visit_invariant_name_set(&node.set); + skip!(node.comma); } pub fn visit_signature_spec<'ast, V>(v: &mut V, node: &'ast crate::SignatureSpec) where @@ -4449,6 +4640,9 @@ where if let Some(it) = &node.prover { v.visit_prover(it); } + if let Some(it) = &node.atomic_spec { + v.visit_atomic_spec(it); + } if let Some(it) = &node.requires { v.visit_requires(it); } diff --git a/dependencies/syn/src/gen/visit_mut.rs b/dependencies/syn/src/gen/visit_mut.rs index 9fae7c3c70..7c111fc6b4 100644 --- a/dependencies/syn/src/gen/visit_mut.rs +++ b/dependencies/syn/src/gen/visit_mut.rs @@ -69,6 +69,12 @@ pub trait VisitMut { fn visit_assume_specification_mut(&mut self, i: &mut crate::AssumeSpecification) { visit_assume_specification_mut(self, i); } + fn visit_atomic_spec_mut(&mut self, i: &mut crate::AtomicSpec) { + visit_atomic_spec_mut(self, i); + } + fn visit_atomically_block_mut(&mut self, i: &mut crate::AtomicallyBlock) { + visit_atomically_block_mut(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_attr_style_mut(&mut self, i: &mut crate::AttrStyle) { @@ -554,6 +560,9 @@ pub trait VisitMut { fn visit_index_mut(&mut self, i: &mut crate::Index) { visit_index_mut(self, i); } + fn visit_inner_mask_mut(&mut self, i: &mut crate::InnerMask) { + visit_inner_mask_mut(self, i); + } fn visit_invariant_mut(&mut self, i: &mut crate::Invariant) { visit_invariant_mut(self, i); } @@ -575,6 +584,12 @@ pub trait VisitMut { ) { visit_invariant_name_set_list_mut(self, i); } + fn visit_invariant_name_set_list_compl_mut( + &mut self, + i: &mut crate::InvariantNameSetListCompl, + ) { + visit_invariant_name_set_list_compl_mut(self, i); + } fn visit_invariant_name_set_none_mut( &mut self, i: &mut crate::InvariantNameSetNone, @@ -786,6 +801,9 @@ pub trait VisitMut { fn visit_open_restricted_mut(&mut self, i: &mut crate::OpenRestricted) { visit_open_restricted_mut(self, i); } + fn visit_outer_mask_mut(&mut self, i: &mut crate::OuterMask) { + visit_outer_mask_mut(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_parenthesized_generic_arguments_mut( @@ -869,6 +887,15 @@ pub trait VisitMut { fn visit_path_segment_mut(&mut self, i: &mut crate::PathSegment) { visit_path_segment_mut(self, i); } + fn visit_perm_clause_mut(&mut self, i: &mut crate::PermClause) { + visit_perm_clause_mut(self, i); + } + fn visit_perm_tuple_mut(&mut self, i: &mut crate::PermTuple) { + visit_perm_tuple_mut(self, i); + } + fn visit_perm_tuple_field_mut(&mut self, i: &mut crate::PermTupleField) { + visit_perm_tuple_field_mut(self, i); + } #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "full")))] fn visit_pointer_mutability_mut(&mut self, i: &mut crate::PointerMutability) { @@ -879,6 +906,9 @@ pub trait VisitMut { fn visit_precise_capture_mut(&mut self, i: &mut crate::PreciseCapture) { visit_precise_capture_mut(self, i); } + fn visit_pred_type_clause_mut(&mut self, i: &mut crate::PredTypeClause) { + visit_pred_type_clause_mut(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_predicate_lifetime_mut(&mut self, i: &mut crate::PredicateLifetime) { @@ -916,11 +946,17 @@ pub trait VisitMut { fn visit_requires_mut(&mut self, i: &mut crate::Requires) { visit_requires_mut(self, i); } + fn visit_return_pat_mut(&mut self, i: &mut crate::ReturnPat) { + visit_return_pat_mut(self, i); + } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] fn visit_return_type_mut(&mut self, i: &mut crate::ReturnType) { visit_return_type_mut(self, i); } + fn visit_return_value_mut(&mut self, i: &mut crate::ReturnValue) { + visit_return_value_mut(self, i); + } fn visit_returns_mut(&mut self, i: &mut crate::Returns) { visit_returns_mut(self, i); } @@ -1335,6 +1371,57 @@ where } skip!(node.semi); } +pub fn visit_atomic_spec_mut(v: &mut V, node: &mut crate::AtomicSpec) +where + V: VisitMut + ?Sized, +{ + skip!(node.atomically_token); + skip!(node.paren_token); + v.visit_ident_mut(&mut node.atomic_update); + skip!(node.block_token); + if let Some(it) = &mut node.type_clause { + v.visit_pred_type_clause_mut(it); + } + v.visit_perm_clause_mut(&mut node.perm_clause); + if let Some(it) = &mut node.requires { + v.visit_requires_mut(it); + } + if let Some(it) = &mut node.ensures { + v.visit_ensures_mut(it); + } + if let Some(it) = &mut node.outer_mask { + v.visit_outer_mask_mut(it); + } + if let Some(it) = &mut node.inner_mask { + v.visit_inner_mask_mut(it); + } + skip!(node.comma_token); +} +pub fn visit_atomically_block_mut(v: &mut V, node: &mut crate::AtomicallyBlock) +where + V: VisitMut + ?Sized, +{ + if let Some(it) = &mut node.label { + full!(v.visit_label_mut(it)); + } + skip!(node.atomically_token); + skip!(node.loop_token); + skip!(node.or1_token); + v.visit_ident_mut(&mut node.update_fn_binder); + skip!(node.comma_token); + skip!(node.or2_token); + v.visit_return_pat_mut(&mut node.spec_au_binder); + if let Some(it) = &mut node.invariant_except_breaks { + v.visit_invariant_except_break_mut(it); + } + if let Some(it) = &mut node.invariants { + v.visit_invariant_mut(it); + } + if let Some(it) = &mut node.ensures { + v.visit_ensures_mut(it); + } + full!(v.visit_block_mut(& mut * node.body)); +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_attr_style_mut(v: &mut V, node: &mut crate::AttrStyle) @@ -2006,6 +2093,9 @@ where let it = el.value_mut(); v.visit_expr_mut(it); } + if let Some(it) = &mut node.atomically { + v.visit_atomically_block_mut(it); + } } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] @@ -2318,6 +2408,9 @@ where let it = el.value_mut(); v.visit_expr_mut(it); } + if let Some(it) = &mut node.atomically { + v.visit_atomically_block_mut(it); + } } #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] @@ -2983,6 +3076,14 @@ where skip!(node.index); v.visit_span_mut(&mut node.span); } +pub fn visit_inner_mask_mut(v: &mut V, node: &mut crate::InnerMask) +where + V: VisitMut + ?Sized, +{ + skip!(node.token); + v.visit_invariant_name_set_mut(&mut node.set); + skip!(node.comma_token); +} pub fn visit_invariant_mut(v: &mut V, node: &mut crate::Invariant) where V: VisitMut + ?Sized, @@ -3021,6 +3122,9 @@ where crate::InvariantNameSet::List(_binding_0) => { v.visit_invariant_name_set_list_mut(_binding_0); } + crate::InvariantNameSet::ListCompl(_binding_0) => { + v.visit_invariant_name_set_list_compl_mut(_binding_0); + } crate::InvariantNameSet::Set(_binding_0) => { v.visit_invariant_name_set_set_mut(_binding_0); } @@ -3048,6 +3152,21 @@ where v.visit_expr_mut(it); } } +pub fn visit_invariant_name_set_list_compl_mut( + v: &mut V, + node: &mut crate::InvariantNameSetListCompl, +) +where + V: VisitMut + ?Sized, +{ + skip!(node.any_token); + skip!(node.op_token); + skip!(node.bracket_token); + for mut el in Punctuated::pairs_mut(&mut node.exprs) { + let it = el.value_mut(); + v.visit_expr_mut(it); + } +} pub fn visit_invariant_name_set_none_mut( v: &mut V, node: &mut crate::InvariantNameSetNone, @@ -3749,6 +3868,14 @@ where skip!(node.in_token); v.visit_path_mut(&mut *node.path); } +pub fn visit_outer_mask_mut(v: &mut V, node: &mut crate::OuterMask) +where + V: VisitMut + ?Sized, +{ + skip!(node.token); + v.visit_invariant_name_set_mut(&mut node.set); + skip!(node.comma_token); +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_parenthesized_generic_arguments_mut( @@ -4003,6 +4130,33 @@ where v.visit_ident_mut(&mut node.ident); v.visit_path_arguments_mut(&mut node.arguments); } +pub fn visit_perm_clause_mut(v: &mut V, node: &mut crate::PermClause) +where + V: VisitMut + ?Sized, +{ + v.visit_perm_tuple_mut(&mut node.old_perms); + skip!(node.arrow_token); + v.visit_perm_tuple_mut(&mut node.new_perms); + skip!(node.comma_token); +} +pub fn visit_perm_tuple_mut(v: &mut V, node: &mut crate::PermTuple) +where + V: VisitMut + ?Sized, +{ + skip!(node.paren_token); + for mut el in Punctuated::pairs_mut(&mut node.fields) { + let it = el.value_mut(); + v.visit_perm_tuple_field_mut(it); + } +} +pub fn visit_perm_tuple_field_mut(v: &mut V, node: &mut crate::PermTupleField) +where + V: VisitMut + ?Sized, +{ + v.visit_ident_mut(&mut node.ident); + skip!(node.colon_token); + v.visit_type_mut(&mut node.ty); +} #[cfg(feature = "full")] #[cfg_attr(docsrs, doc(cfg(feature = "full")))] pub fn visit_pointer_mutability_mut(v: &mut V, node: &mut crate::PointerMutability) @@ -4032,6 +4186,14 @@ where } skip!(node.gt_token); } +pub fn visit_pred_type_clause_mut(v: &mut V, node: &mut crate::PredTypeClause) +where + V: VisitMut + ?Sized, +{ + skip!(node.type_token); + v.visit_ident_mut(&mut node.ident); + skip!(node.comma_token); +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_predicate_lifetime_mut(v: &mut V, node: &mut crate::PredicateLifetime) @@ -4152,6 +4314,27 @@ where skip!(node.token); v.visit_specification_mut(&mut node.exprs); } +pub fn visit_return_pat_mut(v: &mut V, node: &mut crate::ReturnPat) +where + V: VisitMut + ?Sized, +{ + match node { + crate::ReturnPat::Default => {} + crate::ReturnPat::Pat(_binding_0, _binding_1, _binding_2, _binding_3) => { + skip!(_binding_0); + skip!(_binding_1); + full!(v.visit_pat_mut(_binding_2)); + if let Some(it) = _binding_3 { + skip!((* * it).0); + v.visit_type_mut(&mut (**it).1); + } + } + crate::ReturnPat::Type(_binding_0, _binding_1) => { + skip!(_binding_0); + v.visit_type_mut(&mut **_binding_1); + } + } +} #[cfg(any(feature = "derive", feature = "full"))] #[cfg_attr(docsrs, doc(cfg(any(feature = "derive", feature = "full"))))] pub fn visit_return_type_mut(v: &mut V, node: &mut crate::ReturnType) @@ -4172,6 +4355,13 @@ where } } } +pub fn visit_return_value_mut(v: &mut V, node: &mut crate::ReturnValue) +where + V: VisitMut + ?Sized, +{ + skip!(node.token); + full!(v.visit_pat_mut(& mut node.pat)); +} pub fn visit_returns_mut(v: &mut V, node: &mut crate::Returns) where V: VisitMut + ?Sized, @@ -4246,6 +4436,7 @@ where { skip!(node.token); v.visit_invariant_name_set_mut(&mut node.set); + skip!(node.comma); } pub fn visit_signature_spec_mut(v: &mut V, node: &mut crate::SignatureSpec) where @@ -4254,6 +4445,9 @@ where if let Some(it) = &mut node.prover { v.visit_prover_mut(it); } + if let Some(it) = &mut node.atomic_spec { + v.visit_atomic_spec_mut(it); + } if let Some(it) = &mut node.requires { v.visit_requires_mut(it); } diff --git a/dependencies/syn/src/lib.rs b/dependencies/syn/src/lib.rs index a300d17339..5abc18ca75 100644 --- a/dependencies/syn/src/lib.rs +++ b/dependencies/syn/src/lib.rs @@ -556,17 +556,18 @@ mod whitespace; mod verus; pub use crate::verus::rejoin_tokens; pub use crate::verus::{ - Assert, AssertForall, Assume, AssumeSpecification, BigAnd, BigAndExpr, BigOr, BigOrExpr, - BroadcastUse, Closed, ClosureArg, DataMode, Decreases, DefaultEnsures, Ensures, ExprFinal, - ExprGetField, ExprHas, ExprHasNot, ExprIs, ExprIsNot, ExprMatches, FnMode, FnProofArg, - FnProofOptions, Global, GlobalInner, GlobalLayout, GlobalSizeOf, Invariant, InvariantEnsures, - InvariantExceptBreak, InvariantNameSet, InvariantNameSetAny, InvariantNameSetList, - InvariantNameSetNone, InvariantNameSetSet, ItemBroadcastGroup, LoopSpec, MatchesOpExpr, - MatchesOpToken, Mode, ModeExec, ModeGhost, ModeProof, ModeProofAxiom, ModeSpec, - ModeSpecChecked, ModeTracked, Open, OpenRestricted, Prover, Publish, Recommends, Requires, - Returns, RevealHide, SignatureDecreases, SignatureInvariants, SignatureSpec, SignatureSpecAttr, - SignatureUnwind, Specification, TypeFnProof, TypeFnSpec, Uninterp, View, WithSpecOnExpr, - WithSpecOnFn, + Assert, AssertForall, Assume, AssumeSpecification, AtomicSpec, AtomicallyBlock, BigAnd, + BigAndExpr, BigOr, BigOrExpr, BroadcastUse, Closed, ClosureArg, DataMode, Decreases, + DefaultEnsures, Ensures, ExprFinal, ExprGetField, ExprHas, ExprHasNot, ExprIs, ExprIsNot, + ExprMatches, FnMode, FnProofArg, FnProofOptions, Global, GlobalInner, GlobalLayout, + GlobalSizeOf, InnerMask, Invariant, InvariantEnsures, InvariantExceptBreak, InvariantNameSet, + InvariantNameSetAny, InvariantNameSetList, InvariantNameSetListCompl, InvariantNameSetNone, + InvariantNameSetSet, ItemBroadcastGroup, LoopSpec, MatchesOpExpr, MatchesOpToken, Mode, + ModeExec, ModeGhost, ModeProof, ModeProofAxiom, ModeSpec, ModeSpecChecked, ModeTracked, Open, + OpenRestricted, OuterMask, PermClause, PermTuple, PermTupleField, PredTypeClause, Prover, + Publish, Recommends, Requires, ReturnPat, ReturnValue, Returns, RevealHide, SignatureDecreases, + SignatureInvariants, SignatureSpec, SignatureSpecAttr, SignatureUnwind, Specification, + TypeFnProof, TypeFnSpec, Uninterp, View, WithSpecOnExpr, WithSpecOnFn, }; #[rustfmt::skip] // https://github.com/rust-lang/rustfmt/issues/6176 diff --git a/dependencies/syn/src/punctuated.rs b/dependencies/syn/src/punctuated.rs index 7545c66926..b6d62198e1 100644 --- a/dependencies/syn/src/punctuated.rs +++ b/dependencies/syn/src/punctuated.rs @@ -277,6 +277,12 @@ impl Punctuated { } } + /// Retains only the elements specified by the predicate. + pub fn retain(&mut self, mut f: impl FnMut(&T, Option<&P>) -> bool) { + self.inner.retain(|(value, punct)| f(&value, Some(punct))); + self.last.take_if(|value| !f(value, None)); + } + /// Clears the sequence of all values and punctuation, making it empty. pub fn clear(&mut self) { self.inner.clear(); diff --git a/dependencies/syn/src/token.rs b/dependencies/syn/src/token.rs index 237ba89b1d..22174e353e 100644 --- a/dependencies/syn/src/token.rs +++ b/dependencies/syn/src/token.rs @@ -794,6 +794,10 @@ define_keywords! { "broadcast" pub struct Broadcast "group" pub struct BroadcastGroup "assume_specification" pub struct AssumeSpecification + "atomically" pub struct Atomically + "outer_mask" pub struct OuterMask + "inner_mask" pub struct InnerMask + "no_abort" pub struct NoAbort } define_punctuation! { @@ -1050,12 +1054,12 @@ macro_rules! Token { [default_ensures] => { $crate::token::DefaultEnsures }; [returns] => { $crate::token::Returns }; [decreases] => { $crate::token::Decreases }; - [with] => { $crate::token::With }; - [opens_invariants] => { $crate::token::OpensInvariants }; - [invariant_except_break] => { $crate::token::InvariantExceptBreak }; + [with] => { $crate::token::With }; + [opens_invariants] => { $crate::token::OpensInvariants }; + [invariant_except_break] => { $crate::token::InvariantExceptBreak }; [no_unwind] => { $crate::token::NoUnwind }; [invariant] => { $crate::token::Invariant }; - [invariant_ensures] => { $crate::token::InvariantEnsures }; + [invariant_ensures] => { $crate::token::InvariantEnsures }; [assert] => { $crate::token::Assert }; [assume] => { $crate::token::Assume }; [reveal] => { $crate::token::Reveal }; @@ -1083,7 +1087,10 @@ macro_rules! Token { [FnSpec] => { $crate::token::FnSpec }; [SpecFn] => { $crate::token::SpecFn }; [proof_fn] => { $crate::token::ProofFn }; - [assume_specification] => { $crate::token::AssumeSpecification }; + [assume_specification] => { $crate::token::AssumeSpecification }; + [atomically] => { $crate::token::Atomically }; + [outer_mask] => { $crate::token::OuterMask }; + [inner_mask] => { $crate::token::InnerMask }; [&&&] => { $crate::token::BigAnd }; [|||] => { $crate::token::BigOr }; [<==>] => { $crate::token::Equiv }; diff --git a/dependencies/syn/src/verus.rs b/dependencies/syn/src/verus.rs index c467595eda..11eadb4c31 100644 --- a/dependencies/syn/src/verus.rs +++ b/dependencies/syn/src/verus.rs @@ -219,6 +219,7 @@ ast_struct! { pub struct SignatureInvariants { pub token: Token![opens_invariants], pub set: InvariantNameSet, + pub comma: Option, } } @@ -234,6 +235,7 @@ ast_enum_of_structs! { Any(InvariantNameSetAny), None(InvariantNameSetNone), List(InvariantNameSetList), + ListCompl(InvariantNameSetListCompl), Set(InvariantNameSetSet), } } @@ -257,6 +259,15 @@ ast_struct! { } } +ast_struct! { + pub struct InvariantNameSetListCompl { + pub any_token: Token![any], + pub op_token: Token![/], + pub bracket_token: token::Bracket, + pub exprs: Punctuated, + } +} + ast_struct! { pub struct InvariantNameSetSet { pub expr: Expr, @@ -285,6 +296,7 @@ ast_struct! { pub struct SignatureSpec { // When adding Verus fields here, update erase_spec_fields: pub prover: Option, + pub atomic_spec: Option, pub requires: Option, pub recommends: Option, pub ensures: Option, @@ -300,6 +312,7 @@ ast_struct! { impl SignatureSpec { pub fn erase_spec_fields(&mut self) { self.prover = None; + self.atomic_spec = None; self.requires = None; self.recommends = None; self.ensures = None; @@ -609,6 +622,104 @@ ast_struct! { } } +ast_struct! { + pub struct ReturnValue { + pub token: Token![->], + pub pat: Pat, + } +} + +ast_enum! { + pub enum ReturnPat { + Default, + Pat(Token![->], token::Paren, Pat, Option>), + Type(Token![->], Box), + } +} + +ast_struct! { + pub struct AtomicallyBlock { + pub label: Option