Merge #57

bors[bot] · cuviper · web-flow · commit 38d08c85869f · 2023-07-05T23:15:32.000Z
57: Emit full paths for `Option` and `Result` r=cuviper a=cuviper This drops any assumption about having `Option` and `Result` through the normal prelude. This also fixes #51 hygiene, as weird local types by the same name won't affect the derived code. Co-authored-by: Josh Stone <cuviper@gmail.com>
diff --git a/src/lib.rs b/src/lib.rs
@@ -257,59 +257,59 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {
         quote! {
             impl #import::FromPrimitive for #name {
                 #[inline]
-                fn from_i64(n: i64) -> Option<Self> {
+                fn from_i64(n: i64) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_i64(n).map(#name)
                 }
                 #[inline]
-                fn from_u64(n: u64) -> Option<Self> {
+                fn from_u64(n: u64) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_u64(n).map(#name)
                 }
                 #[inline]
-                fn from_isize(n: isize) -> Option<Self> {
+                fn from_isize(n: isize) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_isize(n).map(#name)
                 }
                 #[inline]
-                fn from_i8(n: i8) -> Option<Self> {
+                fn from_i8(n: i8) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_i8(n).map(#name)
                 }
                 #[inline]
-                fn from_i16(n: i16) -> Option<Self> {
+                fn from_i16(n: i16) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_i16(n).map(#name)
                 }
                 #[inline]
-                fn from_i32(n: i32) -> Option<Self> {
+                fn from_i32(n: i32) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_i32(n).map(#name)
                 }
                 #[inline]
-                fn from_i128(n: i128) -> Option<Self> {
+                fn from_i128(n: i128) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_i128(n).map(#name)
                 }
                 #[inline]
-                fn from_usize(n: usize) -> Option<Self> {
+                fn from_usize(n: usize) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_usize(n).map(#name)
                 }
                 #[inline]
-                fn from_u8(n: u8) -> Option<Self> {
+                fn from_u8(n: u8) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_u8(n).map(#name)
                 }
                 #[inline]
-                fn from_u16(n: u16) -> Option<Self> {
+                fn from_u16(n: u16) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_u16(n).map(#name)
                 }
                 #[inline]
-                fn from_u32(n: u32) -> Option<Self> {
+                fn from_u32(n: u32) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_u32(n).map(#name)
                 }
                 #[inline]
-                fn from_u128(n: u128) -> Option<Self> {
+                fn from_u128(n: u128) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_u128(n).map(#name)
                 }
                 #[inline]
-                fn from_f32(n: f32) -> Option<Self> {
+                fn from_f32(n: f32) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_f32(n).map(#name)
                 }
                 #[inline]
-                fn from_f64(n: f64) -> Option<Self> {
+                fn from_f64(n: f64) -> ::core::option::Option<Self> {
                     <#inner_ty as #import::FromPrimitive>::from_f64(n).map(#name)
                 }
             }
@@ -339,7 +339,7 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {
 
                 quote! {
                     if #from_i64_var == #name::#ident as i64 {
-                        Some(#name::#ident)
+                        ::core::option::Option::Some(#name::#ident)
                     }
                 }
             })
@@ -355,14 +355,14 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {
             impl #import::FromPrimitive for #name {
                 #[allow(trivial_numeric_casts)]
                 #[inline]
-                fn from_i64(#from_i64_var: i64) -> Option<Self> {
+                fn from_i64(#from_i64_var: i64) -> ::core::option::Option<Self> {
                     #(#clauses else)* {
-                        None
+                        ::core::option::Option::None
                     }
                 }
 
                 #[inline]
-                fn from_u64(n: u64) -> Option<Self> {
+                fn from_u64(n: u64) -> ::core::option::Option<Self> {
                     Self::from_i64(n as i64)
                 }
             }
@@ -431,59 +431,59 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {
         quote! {
             impl #import::ToPrimitive for #name {
                 #[inline]
-                fn to_i64(&self) -> Option<i64> {
+                fn to_i64(&self) -> ::core::option::Option<i64> {
                     <#inner_ty as #import::ToPrimitive>::to_i64(&self.0)
                 }
                 #[inline]
-                fn to_u64(&self) -> Option<u64> {
+                fn to_u64(&self) -> ::core::option::Option<u64> {
                     <#inner_ty as #import::ToPrimitive>::to_u64(&self.0)
                 }
                 #[inline]
-                fn to_isize(&self) -> Option<isize> {
+                fn to_isize(&self) -> ::core::option::Option<isize> {
                     <#inner_ty as #import::ToPrimitive>::to_isize(&self.0)
                 }
                 #[inline]
-                fn to_i8(&self) -> Option<i8> {
+                fn to_i8(&self) -> ::core::option::Option<i8> {
                     <#inner_ty as #import::ToPrimitive>::to_i8(&self.0)
                 }
                 #[inline]
-                fn to_i16(&self) -> Option<i16> {
+                fn to_i16(&self) -> ::core::option::Option<i16> {
                     <#inner_ty as #import::ToPrimitive>::to_i16(&self.0)
                 }
                 #[inline]
-                fn to_i32(&self) -> Option<i32> {
+                fn to_i32(&self) -> ::core::option::Option<i32> {
                     <#inner_ty as #import::ToPrimitive>::to_i32(&self.0)
                 }
                 #[inline]
-                fn to_i128(&self) -> Option<i128> {
+                fn to_i128(&self) -> ::core::option::Option<i128> {
                     <#inner_ty as #import::ToPrimitive>::to_i128(&self.0)
                 }
                 #[inline]
-                fn to_usize(&self) -> Option<usize> {
+                fn to_usize(&self) -> ::core::option::Option<usize> {
                     <#inner_ty as #import::ToPrimitive>::to_usize(&self.0)
                 }
                 #[inline]
-                fn to_u8(&self) -> Option<u8> {
+                fn to_u8(&self) -> ::core::option::Option<u8> {
                     <#inner_ty as #import::ToPrimitive>::to_u8(&self.0)
                 }
                 #[inline]
-                fn to_u16(&self) -> Option<u16> {
+                fn to_u16(&self) -> ::core::option::Option<u16> {
                     <#inner_ty as #import::ToPrimitive>::to_u16(&self.0)
                 }
                 #[inline]
-                fn to_u32(&self) -> Option<u32> {
+                fn to_u32(&self) -> ::core::option::Option<u32> {
                     <#inner_ty as #import::ToPrimitive>::to_u32(&self.0)
                 }
                 #[inline]
-                fn to_u128(&self) -> Option<u128> {
+                fn to_u128(&self) -> ::core::option::Option<u128> {
                     <#inner_ty as #import::ToPrimitive>::to_u128(&self.0)
                 }
                 #[inline]
-                fn to_f32(&self) -> Option<f32> {
+                fn to_f32(&self) -> ::core::option::Option<f32> {
                     <#inner_ty as #import::ToPrimitive>::to_f32(&self.0)
                 }
                 #[inline]
-                fn to_f64(&self) -> Option<f64> {
+                fn to_f64(&self) -> ::core::option::Option<f64> {
                     <#inner_ty as #import::ToPrimitive>::to_f64(&self.0)
                 }
             }
@@ -522,7 +522,7 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {
             }
         } else {
             quote! {
-                Some(match *self {
+                ::core::option::Option::Some(match *self {
                     #(#variants,)*
                 })
             }
@@ -532,12 +532,12 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {
             impl #import::ToPrimitive for #name {
                 #[inline]
                 #[allow(trivial_numeric_casts)]
-                fn to_i64(&self) -> Option<i64> {
+                fn to_i64(&self) -> ::core::option::Option<i64> {
                     #match_expr
                 }
 
                 #[inline]
-                fn to_u64(&self) -> Option<u64> {
+                fn to_u64(&self) -> ::core::option::Option<u64> {
                     self.to_i64().map(|x| x as u64)
                 }
             }
@@ -617,7 +617,7 @@ pub fn num_cast(input: TokenStream) -> TokenStream {
     let impl_ = quote! {
         impl #import::NumCast for #name {
             #[inline]
-            fn from<T: #import::ToPrimitive>(n: T) -> Option<Self> {
+            fn from<T: #import::ToPrimitive>(n: T) -> ::core::option::Option<Self> {
                 <#inner_ty as #import::NumCast>::from(n).map(#name)
             }
         }
@@ -695,7 +695,7 @@ pub fn num(input: TokenStream) -> TokenStream {
         impl #import::Num for #name {
             type FromStrRadixErr = <#inner_ty as #import::Num>::FromStrRadixErr;
             #[inline]
-            fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
+            fn from_str_radix(s: &str, radix: u32) -> ::core::result::Result<Self, Self::FromStrRadixErr> {
                 <#inner_ty as #import::Num>::from_str_radix(s, radix).map(#name)
             }
         }
diff --git a/tests/no_implicit_prelude.rs b/tests/no_implicit_prelude.rs
@@ -0,0 +1,13 @@
+#![no_implicit_prelude]
+
+use ::num_derive::*;
+
+#[derive(FromPrimitive, ToPrimitive)]
+enum Color {
+    Red,
+    Blue,
+    Green,
+}
+
+#[derive(FromPrimitive, ToPrimitive, NumCast, PartialEq, Zero, One, NumOps, Num)]
+struct NewI32(i32);

Original file line number	Diff line number	Diff line change
`@@ -257,59 +257,59 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {`
`257`	`257`	`quote! {`
`258`	`258`	`impl #import::FromPrimitive for #name {`
`259`	`259`	`#[inline]`
`260`		`- fn from_i64(n: i64) -> Option<Self> {`
	`260`	`+ fn from_i64(n: i64) -> ::core::option::Option<Self> {`
`261`	`261`	`<#inner_ty as #import::FromPrimitive>::from_i64(n).map(#name)`
`262`	`262`	`}`
`263`	`263`	`#[inline]`
`264`		`- fn from_u64(n: u64) -> Option<Self> {`
	`264`	`+ fn from_u64(n: u64) -> ::core::option::Option<Self> {`
`265`	`265`	`<#inner_ty as #import::FromPrimitive>::from_u64(n).map(#name)`
`266`	`266`	`}`
`267`	`267`	`#[inline]`
`268`		`- fn from_isize(n: isize) -> Option<Self> {`
	`268`	`+ fn from_isize(n: isize) -> ::core::option::Option<Self> {`
`269`	`269`	`<#inner_ty as #import::FromPrimitive>::from_isize(n).map(#name)`
`270`	`270`	`}`
`271`	`271`	`#[inline]`
`272`		`- fn from_i8(n: i8) -> Option<Self> {`
	`272`	`+ fn from_i8(n: i8) -> ::core::option::Option<Self> {`
`273`	`273`	`<#inner_ty as #import::FromPrimitive>::from_i8(n).map(#name)`
`274`	`274`	`}`
`275`	`275`	`#[inline]`
`276`		`- fn from_i16(n: i16) -> Option<Self> {`
	`276`	`+ fn from_i16(n: i16) -> ::core::option::Option<Self> {`
`277`	`277`	`<#inner_ty as #import::FromPrimitive>::from_i16(n).map(#name)`
`278`	`278`	`}`
`279`	`279`	`#[inline]`
`280`		`- fn from_i32(n: i32) -> Option<Self> {`
	`280`	`+ fn from_i32(n: i32) -> ::core::option::Option<Self> {`
`281`	`281`	`<#inner_ty as #import::FromPrimitive>::from_i32(n).map(#name)`
`282`	`282`	`}`
`283`	`283`	`#[inline]`
`284`		`- fn from_i128(n: i128) -> Option<Self> {`
	`284`	`+ fn from_i128(n: i128) -> ::core::option::Option<Self> {`
`285`	`285`	`<#inner_ty as #import::FromPrimitive>::from_i128(n).map(#name)`
`286`	`286`	`}`
`287`	`287`	`#[inline]`
`288`		`- fn from_usize(n: usize) -> Option<Self> {`
	`288`	`+ fn from_usize(n: usize) -> ::core::option::Option<Self> {`
`289`	`289`	`<#inner_ty as #import::FromPrimitive>::from_usize(n).map(#name)`
`290`	`290`	`}`
`291`	`291`	`#[inline]`
`292`		`- fn from_u8(n: u8) -> Option<Self> {`
	`292`	`+ fn from_u8(n: u8) -> ::core::option::Option<Self> {`
`293`	`293`	`<#inner_ty as #import::FromPrimitive>::from_u8(n).map(#name)`
`294`	`294`	`}`
`295`	`295`	`#[inline]`
`296`		`- fn from_u16(n: u16) -> Option<Self> {`
	`296`	`+ fn from_u16(n: u16) -> ::core::option::Option<Self> {`
`297`	`297`	`<#inner_ty as #import::FromPrimitive>::from_u16(n).map(#name)`
`298`	`298`	`}`
`299`	`299`	`#[inline]`
`300`		`- fn from_u32(n: u32) -> Option<Self> {`
	`300`	`+ fn from_u32(n: u32) -> ::core::option::Option<Self> {`
`301`	`301`	`<#inner_ty as #import::FromPrimitive>::from_u32(n).map(#name)`
`302`	`302`	`}`
`303`	`303`	`#[inline]`
`304`		`- fn from_u128(n: u128) -> Option<Self> {`
	`304`	`+ fn from_u128(n: u128) -> ::core::option::Option<Self> {`
`305`	`305`	`<#inner_ty as #import::FromPrimitive>::from_u128(n).map(#name)`
`306`	`306`	`}`
`307`	`307`	`#[inline]`
`308`		`- fn from_f32(n: f32) -> Option<Self> {`
	`308`	`+ fn from_f32(n: f32) -> ::core::option::Option<Self> {`
`309`	`309`	`<#inner_ty as #import::FromPrimitive>::from_f32(n).map(#name)`
`310`	`310`	`}`
`311`	`311`	`#[inline]`
`312`		`- fn from_f64(n: f64) -> Option<Self> {`
	`312`	`+ fn from_f64(n: f64) -> ::core::option::Option<Self> {`
`313`	`313`	`<#inner_ty as #import::FromPrimitive>::from_f64(n).map(#name)`
`314`	`314`	`}`
`315`	`315`	`}`
`@@ -339,7 +339,7 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {`
`339`	`339`
`340`	`340`	`quote! {`
`341`	`341`	`if #from_i64_var == #name::#ident as i64 {`
`342`		`- Some(#name::#ident)`
	`342`	`+ ::core::option::Option::Some(#name::#ident)`
`343`	`343`	`}`
`344`	`344`	`}`
`345`	`345`	`})`
`@@ -355,14 +355,14 @@ pub fn from_primitive(input: TokenStream) -> TokenStream {`
`355`	`355`	`impl #import::FromPrimitive for #name {`
`356`	`356`	`#[allow(trivial_numeric_casts)]`
`357`	`357`	`#[inline]`
`358`		`- fn from_i64(#from_i64_var: i64) -> Option<Self> {`
	`358`	`+ fn from_i64(#from_i64_var: i64) -> ::core::option::Option<Self> {`
`359`	`359`	`#(#clauses else)* {`
`360`		`- None`
	`360`	`+ ::core::option::Option::None`
`361`	`361`	`}`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`#[inline]`
`365`		`- fn from_u64(n: u64) -> Option<Self> {`
	`365`	`+ fn from_u64(n: u64) -> ::core::option::Option<Self> {`
`366`	`366`	`Self::from_i64(n as i64)`
`367`	`367`	`}`
`368`	`368`	`}`
`@@ -431,59 +431,59 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {`
`431`	`431`	`quote! {`
`432`	`432`	`impl #import::ToPrimitive for #name {`
`433`	`433`	`#[inline]`
`434`		`- fn to_i64(&self) -> Option<i64> {`
	`434`	`+ fn to_i64(&self) -> ::core::option::Option<i64> {`
`435`	`435`	`<#inner_ty as #import::ToPrimitive>::to_i64(&self.0)`
`436`	`436`	`}`
`437`	`437`	`#[inline]`
`438`		`- fn to_u64(&self) -> Option<u64> {`
	`438`	`+ fn to_u64(&self) -> ::core::option::Option<u64> {`
`439`	`439`	`<#inner_ty as #import::ToPrimitive>::to_u64(&self.0)`
`440`	`440`	`}`
`441`	`441`	`#[inline]`
`442`		`- fn to_isize(&self) -> Option<isize> {`
	`442`	`+ fn to_isize(&self) -> ::core::option::Option<isize> {`
`443`	`443`	`<#inner_ty as #import::ToPrimitive>::to_isize(&self.0)`
`444`	`444`	`}`
`445`	`445`	`#[inline]`
`446`		`- fn to_i8(&self) -> Option<i8> {`
	`446`	`+ fn to_i8(&self) -> ::core::option::Option<i8> {`
`447`	`447`	`<#inner_ty as #import::ToPrimitive>::to_i8(&self.0)`
`448`	`448`	`}`
`449`	`449`	`#[inline]`
`450`		`- fn to_i16(&self) -> Option<i16> {`
	`450`	`+ fn to_i16(&self) -> ::core::option::Option<i16> {`
`451`	`451`	`<#inner_ty as #import::ToPrimitive>::to_i16(&self.0)`
`452`	`452`	`}`
`453`	`453`	`#[inline]`
`454`		`- fn to_i32(&self) -> Option<i32> {`
	`454`	`+ fn to_i32(&self) -> ::core::option::Option<i32> {`
`455`	`455`	`<#inner_ty as #import::ToPrimitive>::to_i32(&self.0)`
`456`	`456`	`}`
`457`	`457`	`#[inline]`
`458`		`- fn to_i128(&self) -> Option<i128> {`
	`458`	`+ fn to_i128(&self) -> ::core::option::Option<i128> {`
`459`	`459`	`<#inner_ty as #import::ToPrimitive>::to_i128(&self.0)`
`460`	`460`	`}`
`461`	`461`	`#[inline]`
`462`		`- fn to_usize(&self) -> Option<usize> {`
	`462`	`+ fn to_usize(&self) -> ::core::option::Option<usize> {`
`463`	`463`	`<#inner_ty as #import::ToPrimitive>::to_usize(&self.0)`
`464`	`464`	`}`
`465`	`465`	`#[inline]`
`466`		`- fn to_u8(&self) -> Option<u8> {`
	`466`	`+ fn to_u8(&self) -> ::core::option::Option<u8> {`
`467`	`467`	`<#inner_ty as #import::ToPrimitive>::to_u8(&self.0)`
`468`	`468`	`}`
`469`	`469`	`#[inline]`
`470`		`- fn to_u16(&self) -> Option<u16> {`
	`470`	`+ fn to_u16(&self) -> ::core::option::Option<u16> {`
`471`	`471`	`<#inner_ty as #import::ToPrimitive>::to_u16(&self.0)`
`472`	`472`	`}`
`473`	`473`	`#[inline]`
`474`		`- fn to_u32(&self) -> Option<u32> {`
	`474`	`+ fn to_u32(&self) -> ::core::option::Option<u32> {`
`475`	`475`	`<#inner_ty as #import::ToPrimitive>::to_u32(&self.0)`
`476`	`476`	`}`
`477`	`477`	`#[inline]`
`478`		`- fn to_u128(&self) -> Option<u128> {`
	`478`	`+ fn to_u128(&self) -> ::core::option::Option<u128> {`
`479`	`479`	`<#inner_ty as #import::ToPrimitive>::to_u128(&self.0)`
`480`	`480`	`}`
`481`	`481`	`#[inline]`
`482`		`- fn to_f32(&self) -> Option<f32> {`
	`482`	`+ fn to_f32(&self) -> ::core::option::Option<f32> {`
`483`	`483`	`<#inner_ty as #import::ToPrimitive>::to_f32(&self.0)`
`484`	`484`	`}`
`485`	`485`	`#[inline]`
`486`		`- fn to_f64(&self) -> Option<f64> {`
	`486`	`+ fn to_f64(&self) -> ::core::option::Option<f64> {`
`487`	`487`	`<#inner_ty as #import::ToPrimitive>::to_f64(&self.0)`
`488`	`488`	`}`
`489`	`489`	`}`
`@@ -522,7 +522,7 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {`
`522`	`522`	`}`
`523`	`523`	`} else {`
`524`	`524`	`quote! {`
`525`		`- Some(match *self {`
	`525`	`+ ::core::option::Option::Some(match *self {`
`526`	`526`	`#(#variants,)*`
`527`	`527`	`})`
`528`	`528`	`}`
`@@ -532,12 +532,12 @@ pub fn to_primitive(input: TokenStream) -> TokenStream {`
`532`	`532`	`impl #import::ToPrimitive for #name {`
`533`	`533`	`#[inline]`
`534`	`534`	`#[allow(trivial_numeric_casts)]`
`535`		`- fn to_i64(&self) -> Option<i64> {`
	`535`	`+ fn to_i64(&self) -> ::core::option::Option<i64> {`
`536`	`536`	`#match_expr`
`537`	`537`	`}`
`538`	`538`
`539`	`539`	`#[inline]`
`540`		`- fn to_u64(&self) -> Option<u64> {`
	`540`	`+ fn to_u64(&self) -> ::core::option::Option<u64> {`
`541`	`541`	`self.to_i64().map(\|x\| x as u64)`
`542`	`542`	`}`
`543`	`543`	`}`
`@@ -617,7 +617,7 @@ pub fn num_cast(input: TokenStream) -> TokenStream {`
`617`	`617`	`let impl_ = quote! {`
`618`	`618`	`impl #import::NumCast for #name {`
`619`	`619`	`#[inline]`
`620`		`- fn from<T: #import::ToPrimitive>(n: T) -> Option<Self> {`
	`620`	`+ fn from<T: #import::ToPrimitive>(n: T) -> ::core::option::Option<Self> {`
`621`	`621`	`<#inner_ty as #import::NumCast>::from(n).map(#name)`
`622`	`622`	`}`
`623`	`623`	`}`
`@@ -695,7 +695,7 @@ pub fn num(input: TokenStream) -> TokenStream {`
`695`	`695`	`impl #import::Num for #name {`
`696`	`696`	`type FromStrRadixErr = <#inner_ty as #import::Num>::FromStrRadixErr;`
`697`	`697`	`#[inline]`
`698`		`- fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {`
	`698`	`+ fn from_str_radix(s: &str, radix: u32) -> ::core::result::Result<Self, Self::FromStrRadixErr> {`
`699`	`699`	`<#inner_ty as #import::Num>::from_str_radix(s, radix).map(#name)`
`700`	`700`	`}`
`701`	`701`	`}`