Skip to content

Instantly share code, notes, and snippets.

@scottmcm

scottmcm/prom-attire-expanded.rs Secret

Created March 27, 2018 07:06
Show Gist options
  • Save scottmcm/0cd3e3f1c9d85302a130dcda932ce289 to your computer and use it in GitHub Desktop.
Save scottmcm/0cd3e3f1c9d85302a130dcda932ce289 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
prom-attire-expanded.rs
#[test]
pub fn split_attribute_of_parent_moving() {
struct A {
#[attire(split_attribute_of = "b")]
c: Option<String>,
#[attire(split_attribute_of = "b")]
d: Option<String>,
}
#[allow(dead_code)]
enum AFromAttributesError<'a> {
LiteralTy {
value: &'a ::syn::Lit,
ty: &'static str,
scope: Option<&'static str>,
attr: &'a str,
},
Parsing {
value: &'a str,
ty: &'static str,
scope: Option<&'static str>,
attr: &'a str,
err: Box<::std::error::Error + 'a>,
},
#[doc =
r" This is an internal error that will only be returned as part of"]
#[doc = r" the `err` field on `Parsing`"]
ParsingChar,
#[doc =
r" This is an internal error that will only be returned as part of"]
#[doc = r" the `err` field on `Parsing`"]
ParsingByteStr,
}
#[automatically_derived]
#[allow(unused_qualifications)]
#[allow(dead_code)]
impl <'a> ::std::fmt::Debug for AFromAttributesError<'a> {
fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter)
-> ::std::fmt::Result {
match (&*self,) {
(&AFromAttributesError::LiteralTy {
value: ref __self_0,
ty: ref __self_1,
scope: ref __self_2,
attr: ref __self_3 },) => {
let mut __debug_trait_builder =
__arg_0.debug_struct("LiteralTy");
let _ =
__debug_trait_builder.field("value", &&(*__self_0));
let _ = __debug_trait_builder.field("ty", &&(*__self_1));
let _ =
__debug_trait_builder.field("scope", &&(*__self_2));
let _ =
__debug_trait_builder.field("attr", &&(*__self_3));
__debug_trait_builder.finish()
}
(&AFromAttributesError::Parsing {
value: ref __self_0,
ty: ref __self_1,
scope: ref __self_2,
attr: ref __self_3,
err: ref __self_4 },) => {
let mut __debug_trait_builder =
__arg_0.debug_struct("Parsing");
let _ =
__debug_trait_builder.field("value", &&(*__self_0));
let _ = __debug_trait_builder.field("ty", &&(*__self_1));
let _ =
__debug_trait_builder.field("scope", &&(*__self_2));
let _ =
__debug_trait_builder.field("attr", &&(*__self_3));
let _ = __debug_trait_builder.field("err", &&(*__self_4));
__debug_trait_builder.finish()
}
(&AFromAttributesError::ParsingChar,) => {
let mut __debug_trait_builder =
__arg_0.debug_tuple("ParsingChar");
__debug_trait_builder.finish()
}
(&AFromAttributesError::ParsingByteStr,) => {
let mut __debug_trait_builder =
__arg_0.debug_tuple("ParsingByteStr");
__debug_trait_builder.finish()
}
}
}
}
impl <'a> ::std::fmt::Display for AFromAttributesError<'a> {
fn fmt(&self, mut w: &mut ::std::fmt::Formatter)
-> ::std::fmt::Result {
match *self {
AFromAttributesError::LiteralTy {
ref value, ref ty, ref scope, ref attr } => {
w.write_fmt(::std::fmt::Arguments::new_v1_formatted(&["Unexpected attribute literal ",
" for ",
", expected a "],
&match (&value,
&scope.map(|s|
::fmt::format(::std::fmt::Arguments::new_v1_formatted(&["",
"(",
")"],
&match (&s,
&attr)
{
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Display::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]))).unwrap_or_else(||
attr.to_string()),
&ty)
{
(__arg0,
__arg1,
__arg2)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Debug::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg2,
::std::fmt::Display::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(2usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]))
}
AFromAttributesError::Parsing {
ref value, ref ty, ref scope, ref attr, ref err } => {
w.write_fmt(::std::fmt::Arguments::new_v1_formatted(&["Parsing attribute value ",
" into a ",
" for ",
" failed: "],
&match (&value,
&scope.map(|s|
::fmt::format(::std::fmt::Arguments::new_v1_formatted(&["",
"(",
")"],
&match (&s,
&attr)
{
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Display::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]))).unwrap_or_else(||
attr.to_string()),
&ty,
&err)
{
(__arg0,
__arg1,
__arg2,
__arg3)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Debug::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg2,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg3,
::std::fmt::Display::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(2usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(3usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]))
}
AFromAttributesError::ParsingChar => {
w.write_fmt(::std::fmt::Arguments::new_v1(&["expected one character"],
&match () {
() => [],
}))
}
AFromAttributesError::ParsingByteStr => {
w.write_fmt(::std::fmt::Arguments::new_v1(&["non-ascii character"],
&match () {
() => [],
}))
}
}
}
}
impl <'a> ::std::error::Error for AFromAttributesError<'a> {
fn description(&self) -> &str {
match *self {
AFromAttributesError::LiteralTy { .. } =>
"Unexpected attribute literal",
AFromAttributesError::Parsing { .. } =>
"Parsing attribute value failed",
AFromAttributesError::ParsingChar => "expected one character",
AFromAttributesError::ParsingByteStr => "non-ascii character",
}
}
fn cause(&self) -> Option<&::std::error::Error> {
match *self {
AFromAttributesError::LiteralTy { .. } => None,
AFromAttributesError::Parsing { ref err, .. } => Some(&**err),
AFromAttributesError::ParsingChar => None,
AFromAttributesError::ParsingByteStr => None,
}
}
}
impl A {
#[allow(unused_mut)]
fn try_from(attrs: &[::syn::Attribute])
-> ::std::result::Result<A, ::std::vec::Vec<AFromAttributesError>> {
let mut errors = <[_]>::into_vec(box []);
let mut c = None;
let mut d = None;
for attr in attrs {
match attr.value {
::syn::MetaItem::NameValue(ref ident, ref value) if
ident.as_ref() == "b" => {
let value =
match *value {
::syn::Lit::Str(ref value, _) => {
match <String as
::std::str::FromStr>::from_str(value)
{
Ok(value) => value,
Err(err) => {
errors.push(AFromAttributesError::Parsing{value:
value,
ty:
"String",
scope:
None,
attr:
ident.as_ref(),
err:
Box::new(err),});
continue ;
}
}
}
_ => {
errors.push(AFromAttributesError::LiteralTy{value:
value,
ty:
"String",
scope:
None,
attr:
ident.as_ref(),});
continue ;
}
};
c = Some(value.clone());
d = Some(value.clone());
}
::syn::MetaItem::List(ref ident, ref values) if
ident.as_ref() == "b" => {
for value in values {
if let ::syn::NestedMetaItem::MetaItem(ref item) =
*value {
match *item {
::syn::MetaItem::NameValue(ref ident,
ref value) if
ident.as_ref() == "c" => {
let value =
match *value {
::syn::Lit::Str(ref value, _)
=> {
match <String as
::std::str::FromStr>::from_str(value)
{
Ok(value) => value,
Err(err) => {
errors.push(AFromAttributesError::Parsing{value:
value,
ty:
"String",
scope:
None,
attr:
ident.as_ref(),
err:
Box::new(err),});
continue ;
}
}
}
_ => {
errors.push(AFromAttributesError::LiteralTy{value:
value,
ty:
"String",
scope:
None,
attr:
ident.as_ref(),});
continue ;
}
};
c = Some(value);
}
::syn::MetaItem::NameValue(ref ident,
ref value) if
ident.as_ref() == "d" => {
let value =
match *value {
::syn::Lit::Str(ref value, _)
=> {
match <String as
::std::str::FromStr>::from_str(value)
{
Ok(value) => value,
Err(err) => {
errors.push(AFromAttributesError::Parsing{value:
value,
ty:
"String",
scope:
None,
attr:
ident.as_ref(),
err:
Box::new(err),});
continue ;
}
}
}
_ => {
errors.push(AFromAttributesError::LiteralTy{value:
value,
ty:
"String",
scope:
None,
attr:
ident.as_ref(),});
continue ;
}
};
d = Some(value);
}
ref item => {
::io::_print(::std::fmt::Arguments::new_v1_formatted(&["Unexpected attribute under \'",
"\' (",
")\n"],
&match (&"b",
&item)
{
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Display::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]));
}
}
}
}
}
_ => { }
}
}
if errors.is_empty() { Ok(A{c: c, d: d,}) } else { Err(errors) }
}
}
impl <'a> From<&'a [::syn::Attribute]> for A {
fn from(attrs: &[::syn::Attribute]) -> A {
A::try_from(attrs).unwrap()
}
}
let input =
{
let mut _s = ::Tokens::new();
_s.append("#");
_s.append("[");
_s.append("b");
_s.append("=");
_s.append("\"b\"");
_s.append("]");
_s.append("struct");
_s.append("S");
_s.append("{");
_s.append("}");
_s
};
let ast = syn::parse_derive_input(input.as_str()).unwrap();
let attrs = A::from(ast.attrs.as_slice());
{
match (&attrs.c, &Some("b".to_owned())) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
{
::rt::begin_panic_fmt(&::std::fmt::Arguments::new_v1_formatted(&["assertion failed: `(left == right)`\n left: `",
"`,\n right: `",
"`"],
&match (&left_val,
&right_val)
{
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Debug::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]),
&("tests\\split_attribute_of.rs",
41u32, 5u32))
}
}
}
}
};
{
match (&attrs.d, &Some("b".to_owned())) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
{
::rt::begin_panic_fmt(&::std::fmt::Arguments::new_v1_formatted(&["assertion failed: `(left == right)`\n left: `",
"`,\n right: `",
"`"],
&match (&left_val,
&right_val)
{
(__arg0,
__arg1)
=>
[::std::fmt::ArgumentV1::new(__arg0,
::std::fmt::Debug::fmt),
::std::fmt::ArgumentV1::new(__arg1,
::std::fmt::Debug::fmt)],
},
&[::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(0usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},},
::std::fmt::rt::v1::Argument{position:
::std::fmt::rt::v1::Position::At(1usize),
format:
::std::fmt::rt::v1::FormatSpec{fill:
' ',
align:
::std::fmt::rt::v1::Alignment::Unknown,
flags:
0u32,
precision:
::std::fmt::rt::v1::Count::Implied,
width:
::std::fmt::rt::v1::Count::Implied,},}]),
&("tests\\split_attribute_of.rs",
42u32, 5u32))
}
}
}
}
};
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment