diff --git a/serde/src/export.rs b/serde/src/export.rs
index 61c9ba67..9c635457 100644
--- a/serde/src/export.rs
+++ b/serde/src/export.rs
@@ -9,7 +9,8 @@ use collections::borrow::Cow;
 pub use core::default::Default;
 pub use core::fmt;
 pub use core::marker::PhantomData;
-pub use core::result::Result;
+pub use core::option::Option::{self, None, Some};
+pub use core::result::Result::{self, Ok, Err};
 
 #[cfg(any(feature = "collections", feature = "std"))]
 pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
diff --git a/serde/src/lib.rs b/serde/src/lib.rs
index 62424061..bfcbeb3f 100644
--- a/serde/src/lib.rs
+++ b/serde/src/lib.rs
@@ -79,7 +79,7 @@ extern crate core as actual_core;
 #[cfg(feature = "std")]
 mod core {
     pub use std::{ops, hash, fmt, cmp, marker, mem, i8, i16, i32, i64, u8, u16, u32, u64, isize,
-            usize, f32, f64, char, str, num, slice, iter, cell, default, result};
+            usize, f32, f64, char, str, num, slice, iter, cell, default, result, option};
     #[cfg(feature = "unstable")]
     pub use actual_core::nonzero;
 }
diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index f371680e..3d7b5d1f 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -209,21 +209,21 @@ fn deserialize_unit_struct(
             type Value = #type_ident;
 
             fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
-                formatter.write_str(#expecting)
+                _serde::export::fmt::Formatter::write_str(formatter, #expecting)
             }
 
             #[inline]
             fn visit_unit<__E>(self) -> _serde::export::Result<#type_ident, __E>
                 where __E: _serde::de::Error,
             {
-                Ok(#type_ident)
+                _serde::export::Ok(#type_ident)
             }
 
             #[inline]
             fn visit_seq<__V>(self, _: __V) -> _serde::export::Result<#type_ident, __V::Error>
                 where __V: _serde::de::SeqVisitor,
             {
-                Ok(#type_ident)
+                _serde::export::Ok(#type_ident)
             }
         }
 
@@ -278,10 +278,10 @@ fn deserialize_tuple(
         quote!(_serde::de::VariantVisitor::visit_tuple(visitor, #nfields, #visitor_expr))
     } else if nfields == 1 {
         let type_name = item_attrs.name().deserialize_name();
-        quote!(deserializer.deserialize_newtype_struct(#type_name, #visitor_expr))
+        quote!(_serde::Deserializer::deserialize_newtype_struct(deserializer, #type_name, #visitor_expr))
     } else {
         let type_name = item_attrs.name().deserialize_name();
-        quote!(deserializer.deserialize_tuple_struct(#type_name, #nfields, #visitor_expr))
+        quote!(_serde::Deserializer::deserialize_tuple_struct(deserializer, #type_name, #nfields, #visitor_expr))
     };
 
     let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
@@ -298,7 +298,7 @@ fn deserialize_tuple(
             type Value = #ty;
 
             fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
-                formatter.write_str(#expecting)
+                _serde::export::fmt::Formatter::write_str(formatter, #expecting)
             }
 
             #visit_newtype_struct
@@ -341,7 +341,7 @@ fn deserialize_seq(
                 let visit = match field.attrs.deserialize_with() {
                     None => {
                         let field_ty = &field.ty;
-                        quote!(try!(visitor.visit::<#field_ty>()))
+                        quote!(try!(_serde::de::SeqVisitor::visit::<#field_ty>(&mut visitor)))
                     }
                     Some(path) => {
                         let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with(
@@ -349,7 +349,8 @@ fn deserialize_seq(
                         quote!({
                             #wrapper
                             #wrapper_impl
-                            try!(visitor.visit::<#wrapper_ty>()).map(|wrap| wrap.value)
+                            try!(_serde::de::SeqVisitor::visit::<#wrapper_ty>(&mut visitor))
+                                .map(|wrap| wrap.value)
                         })
                     }
                 };
@@ -357,7 +358,7 @@ fn deserialize_seq(
                     let #var = match #visit {
                         Some(value) => { value },
                         None => {
-                            return Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+                            return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
                         }
                     };
                 };
@@ -379,7 +380,7 @@ fn deserialize_seq(
 
     quote! {
         #(#let_values)*
-        Ok(#result)
+        _serde::export::Ok(#result)
     }
 }
 
@@ -411,7 +412,7 @@ fn deserialize_newtype_struct(
         fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
             where __E: _serde::Deserializer,
         {
-            Ok(#type_path(#value))
+            _serde::export::Ok(#type_path(#value))
         }
     }
 }
@@ -461,7 +462,7 @@ fn deserialize_struct(
     } else {
         let type_name = item_attrs.name().deserialize_name();
         quote! {
-            deserializer.deserialize_struct(#type_name, FIELDS, #visitor_expr)
+            _serde::Deserializer::deserialize_struct(deserializer, #type_name, FIELDS, #visitor_expr)
         }
     };
 
@@ -481,7 +482,7 @@ fn deserialize_struct(
             type Value = #ty;
 
             fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
-                formatter.write_str(#expecting)
+                _serde::export::fmt::Formatter::write_str(formatter, #expecting)
             }
 
             #[inline]
@@ -563,13 +564,14 @@ fn deserialize_item_enum(
         // all variants have `#[serde(skip_deserializing)]`.
         quote! {
             // FIXME: Once we drop support for Rust 1.15:
-            // let Err(err) = visitor.visit_variant::<__Field>();
-            // Err(err)
-            visitor.visit_variant::<__Field>().map(|(impossible, _)| match impossible {})
+            // let _serde::export::Err(err) = _serde::de::EnumVisitor::visit_variant::<__Field>(visitor);
+            // _serde::export::Err(err)
+            _serde::de::EnumVisitor::visit_variant::<__Field>(visitor)
+                .map(|(impossible, _)| match impossible {})
         }
     } else {
         quote! {
-            match try!(visitor.visit_variant()) {
+            match try!(_serde::de::EnumVisitor::visit_variant(visitor)) {
                 #(#variant_arms)*
             }
         }
@@ -586,7 +588,7 @@ fn deserialize_item_enum(
             type Value = #ty;
 
             fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
-                formatter.write_str(#expecting)
+                _serde::export::fmt::Formatter::write_str(formatter, #expecting)
             }
 
             fn visit_enum<__V>(self, visitor: __V) -> _serde::export::Result<#ty, __V::Error>
@@ -598,7 +600,7 @@ fn deserialize_item_enum(
 
         #variants_stmt
 
-        deserializer.deserialize_enum(#type_name, VARIANTS, #visitor_expr)
+        _serde::Deserializer::deserialize_enum(deserializer, #type_name, VARIANTS, #visitor_expr)
     })
 }
 
@@ -615,7 +617,7 @@ fn deserialize_variant(
         Style::Unit => {
             quote!({
                 try!(_serde::de::VariantVisitor::visit_unit(visitor));
-                Ok(#type_ident::#variant_ident)
+                _serde::export::Ok(#type_ident::#variant_ident)
             })
         }
         Style::Newtype => {
@@ -673,7 +675,7 @@ fn deserialize_newtype_variant(
         }
     };
     quote! {
-        Ok(#type_ident::#variant_ident(#visit)),
+        _serde::export::Ok(#type_ident::#variant_ident(#visit)),
     }
 }
 
@@ -701,9 +703,9 @@ fn deserialize_field_visitor(
             {
                 match value {
                     #(
-                        #variant_indices => Ok(__Field::#field_idents),
+                        #variant_indices => _serde::export::Ok(__Field::#field_idents),
                     )*
-                    _ => Err(_serde::de::Error::invalid_value(
+                    _ => _serde::export::Err(_serde::de::Error::invalid_value(
                                 _serde::de::Unexpected::Unsigned(value as u64),
                                 &#fallthrough_msg))
                 }
@@ -715,15 +717,15 @@ fn deserialize_field_visitor(
 
     let fallthrough_arm = if is_variant {
         quote! {
-            Err(_serde::de::Error::unknown_variant(value, VARIANTS))
+            _serde::export::Err(_serde::de::Error::unknown_variant(value, VARIANTS))
         }
     } else if item_attrs.deny_unknown_fields() {
         quote! {
-            Err(_serde::de::Error::unknown_field(value, FIELDS))
+            _serde::export::Err(_serde::de::Error::unknown_field(value, FIELDS))
         }
     } else {
         quote! {
-            Ok(__Field::__ignore)
+            _serde::export::Ok(__Field::__ignore)
         }
     };
 
@@ -755,7 +757,7 @@ fn deserialize_field_visitor(
                     type Value = __Field;
 
                     fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
-                        formatter.write_str("field name")
+                        _serde::export::fmt::Formatter::write_str(formatter, "field name")
                     }
 
                     #visit_index
@@ -765,7 +767,7 @@ fn deserialize_field_visitor(
                     {
                         match value {
                             #(
-                                #field_strs => Ok(__Field::#field_idents),
+                                #field_strs => _serde::export::Ok(__Field::#field_idents),
                             )*
                             _ => #fallthrough_arm
                         }
@@ -776,7 +778,7 @@ fn deserialize_field_visitor(
                     {
                         match value {
                             #(
-                                #field_bytes => Ok(__Field::#field_idents),
+                                #field_bytes => _serde::export::Ok(__Field::#field_idents),
                             )*
                             _ => {
                                 #bytes_to_str
@@ -786,7 +788,7 @@ fn deserialize_field_visitor(
                     }
                 }
 
-                deserializer.deserialize_struct_field(__FieldVisitor)
+                _serde::Deserializer::deserialize_struct_field(deserializer, __FieldVisitor)
             }
         }
     }
@@ -848,7 +850,7 @@ fn deserialize_map(
         .map(|&(field, ref name)| {
             let field_ty = &field.ty;
             quote! {
-                let mut #name: Option<#field_ty> = None;
+                let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
             }
         });
 
@@ -862,7 +864,7 @@ fn deserialize_map(
                 None => {
                     let field_ty = &field.ty;
                     quote! {
-                        try!(visitor.visit_value::<#field_ty>())
+                        try!(_serde::de::MapVisitor::visit_value::<#field_ty>(&mut visitor))
                     }
                 }
                 Some(path) => {
@@ -871,16 +873,16 @@ fn deserialize_map(
                     quote!({
                         #wrapper
                         #wrapper_impl
-                        try!(visitor.visit_value::<#wrapper_ty>()).value
+                        try!(_serde::de::MapVisitor::visit_value::<#wrapper_ty>(&mut visitor)).value
                     })
                 }
             };
             quote! {
                 __Field::#name => {
-                    if #name.is_some() {
-                        return Err(<__V::Error as _serde::de::Error>::duplicate_field(#deser_name));
+                    if _serde::export::Option::is_some(&#name) {
+                        return _serde::export::Err(<__V::Error as _serde::de::Error>::duplicate_field(#deser_name));
                     }
-                    #name = Some(#visit);
+                    #name = _serde::export::Some(#visit);
                 }
             }
         });
@@ -890,7 +892,7 @@ fn deserialize_map(
         None
     } else {
         Some(quote! {
-            _ => { let _ = try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>()); }
+            _ => { let _ = try!(_serde::de::MapVisitor::visit_value::<_serde::de::impls::IgnoredAny>(&mut visitor)); }
         })
     };
 
@@ -898,12 +900,13 @@ fn deserialize_map(
     let match_keys = if item_attrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once we drop support for Rust 1.15:
-            // let None::<__Field> = try!(visitor.visit_key());
-            try!(visitor.visit_key::<__Field>()).map(|impossible| match impossible {});
+            // let _serde::export::None::<__Field> = try!(_serde::de::MapVisitor::visit_key(&mut visitor));
+            try!(_serde::de::MapVisitor::visit_key::<__Field>(&mut visitor))
+                .map(|impossible| match impossible {});
         }
     } else {
         quote! {
-            while let Some(key) = try!(visitor.visit_key::<__Field>()) {
+            while let _serde::export::Some(key) = try!(_serde::de::MapVisitor::visit_key::<__Field>(&mut visitor)) {
                 match key {
                     #(#value_arms)*
                     #ignored_arm
@@ -919,8 +922,8 @@ fn deserialize_map(
 
             quote! {
                 let #name = match #name {
-                    Some(#name) => #name,
-                    None => #missing_expr
+                    _serde::export::Some(#name) => #name,
+                    _serde::export::None => #missing_expr
                 };
             }
         });
@@ -943,7 +946,7 @@ fn deserialize_map(
 
         #(#extract_values)*
 
-        Ok(#struct_path { #(#result),* })
+        _serde::export::Ok(#struct_path { #(#result),* })
     }
 }
 
@@ -990,7 +993,7 @@ fn wrap_deserialize_with(
                     where __D: _serde::Deserializer
                 {
                     let value = try!(#deserialize_with(__d));
-                    Ok(__SerdeDeserializeWithStruct {
+                    _serde::export::Ok(__SerdeDeserializeWithStruct {
                         value: value,
                         phantom: _serde::export::PhantomData,
                     })
@@ -1021,7 +1024,7 @@ fn expr_is_missing(attrs: &attr::Field) -> Tokens {
         }
         Some(_) => {
             quote! {
-                return Err(<__V::Error as _serde::de::Error>::missing_field(#name))
+                return _serde::export::Err(<__V::Error as _serde::de::Error>::missing_field(#name))
             }
         }
     }
diff --git a/serde_derive/src/ser.rs b/serde_derive/src/ser.rs
index f85839e5..6478de41 100644
--- a/serde_derive/src/ser.rs
+++ b/serde_derive/src/ser.rs
@@ -125,7 +125,7 @@ fn serialize_unit_struct(item_attrs: &attr::Item) -> Tokens {
     let type_name = item_attrs.name().serialize_name();
 
     quote! {
-        _serializer.serialize_unit_struct(#type_name)
+        _serde::Serializer::serialize_unit_struct(_serializer, #type_name)
     }
 }
 
@@ -144,7 +144,7 @@ fn serialize_newtype_struct(
     }
 
     quote! {
-        _serializer.serialize_newtype_struct(#type_name, #field_expr)
+        _serde::Serializer::serialize_newtype_struct(_serializer, #type_name, #field_expr)
     }
 }
 
@@ -167,7 +167,7 @@ fn serialize_tuple_struct(
     let let_mut = mut_if(len > 0);
 
     quote! {
-        let #let_mut __serde_state = try!(_serializer.serialize_tuple_struct(#type_name, #len));
+        let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(_serializer, #type_name, #len));
         #(#serialize_stmts)*
         _serde::ser::SerializeTupleStruct::end(__serde_state)
     }
@@ -208,7 +208,7 @@ fn serialize_struct(
         .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
     quote! {
-        let #let_mut __serde_state = try!(_serializer.serialize_struct(#type_name, #len));
+        let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(_serializer, #type_name, #len));
         #(#serialize_fields)*
         _serde::ser::SerializeStruct::end(__serde_state)
     }
@@ -260,7 +260,7 @@ fn serialize_variant(
         let skipped_msg = format!("the enum variant {}::{} cannot be serialized",
                                 type_ident, variant_ident);
         let skipped_err = quote! {
-            Err(_serde::ser::Error::custom(#skipped_msg))
+            _serde::export::Err(_serde::ser::Error::custom(#skipped_msg))
         };
         let fields_pat = match variant.style {
             Style::Unit => quote!(),
@@ -380,7 +380,8 @@ fn serialize_tuple_variant(
     let let_mut = mut_if(len > 0);
 
     quote! {
-        let #let_mut __serde_state = try!(_serializer.serialize_tuple_variant(
+        let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
+            _serializer,
             #type_name,
             #variant_index,
             #variant_name,
@@ -426,7 +427,8 @@ fn serialize_struct_variant(
         .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
     quote! {
-        let #let_mut __serde_state = try!(_serializer.serialize_struct_variant(
+        let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
+            _serializer,
             #item_name,
             #variant_index,
             #variant_name,
@@ -537,7 +539,7 @@ fn wrap_serialize_with(
     quote!({
         struct __SerializeWith #wrapper_generics #where_clause {
             value: &'__a #field_ty,
-            phantom: ::std::marker::PhantomData<#item_ty>,
+            phantom: _serde::export::PhantomData<#item_ty>,
         }
 
         impl #wrapper_generics _serde::Serialize for #wrapper_ty #where_clause {
@@ -550,7 +552,7 @@ fn wrap_serialize_with(
 
         &__SerializeWith {
             value: #value,
-            phantom: ::std::marker::PhantomData::<#item_ty>,
+            phantom: _serde::export::PhantomData::<#item_ty>,
         }
     })
 }
diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs
index 34b5c469..2f53a00e 100644
--- a/test_suite/tests/test_gen.rs
+++ b/test_suite/tests/test_gen.rs
@@ -8,11 +8,15 @@ use self::serde::de::{Deserialize, Deserializer};
 
 use std::borrow::Cow;
 use std::marker::PhantomData;
+use std::result::Result as StdResult;
 
 // Try to trip up the generated code if it fails to use fully qualified paths.
 #[allow(dead_code)]
 struct Result;
-use std::result::Result as StdResult;
+#[allow(dead_code)]
+struct Ok;
+#[allow(dead_code)]
+struct Err;
 
 //////////////////////////////////////////////////////////////////////////