Switch to purely namespaced enums

This breaks code that referred to variant names in the same namespace as
their enum. Reexport the variants in the old location or alter code to
refer to the new locations:

```
pub enum Foo {
    A,
    B
}

fn main() {
    let a = A;
}
```
=>
```
pub use self::Foo::{A, B};

pub enum Foo {
    A,
    B
}

fn main() {
    let a = A;
}
```
or
```
pub enum Foo {
    A,
    B
}

fn main() {
    let a = Foo::A;
}
```

[breaking-change]

7 files changed, 59 insertions, 46 deletions

diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs
index e653c8aebf4..fccc67bf220 100644
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@@ -52,7 +52,7 @@ fn cs_clone(
     name: &str,
     cx: &mut ExtCtxt, trait_span: Span,
     substr: &Substructure) -> P<Expr> {
-    let ctor_ident;
+    let ctor_path;
     let all_fields;
     let fn_path = vec![
         cx.ident_of("std"),
@@ -68,11 +68,11 @@ fn cs_clone(
 
     match *substr.fields {
         Struct(ref af) => {
-            ctor_ident = substr.type_ident;
+            ctor_path = cx.path(trait_span, vec![substr.type_ident]);
             all_fields = af;
         }
         EnumMatching(_, variant, ref af) => {
-            ctor_ident = variant.node.name;
+            ctor_path = cx.path(trait_span, vec![substr.type_ident, variant.node.name]);
             all_fields = af;
         },
         EnumNonMatchingCollapsed (..) => {
@@ -91,7 +91,8 @@ fn cs_clone(
     if all_fields.len() >= 1 && all_fields[0].name.is_none() {
         // enum-like
         let subcalls = all_fields.iter().map(subcall).collect();
-        cx.expr_call_ident(trait_span, ctor_ident, subcalls)
+        let path = cx.expr_path(ctor_path);
+        cx.expr_call(trait_span, path, subcalls)
     } else {
         // struct-like
         let fields = all_fields.iter().map(|field| {
@@ -109,9 +110,9 @@ fn cs_clone(
 
         if fields.is_empty() {
             // no fields, so construct like `None`
-            cx.expr_ident(trait_span, ctor_ident)
+            cx.expr_path(ctor_path)
         } else {
-            cx.expr_struct_ident(trait_span, ctor_ident, fields)
+            cx.expr_struct(trait_span, ctor_path, fields)
         }
     }
 }
diff --git a/src/libsyntax/ext/deriving/cmp/ord.rs b/src/libsyntax/ext/deriving/cmp/ord.rs
index cd44dde7004..98345e1dd67 100644
--- a/src/libsyntax/ext/deriving/cmp/ord.rs
+++ b/src/libsyntax/ext/deriving/cmp/ord.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+pub use self::OrderingOp::*;
+
 use ast;
 use ast::{MetaItem, Item, Expr};
 use codemap::Span;
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index 9e4dbf930db..d0a03658386 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -13,7 +13,8 @@ The compiler code necessary for `#[deriving(Decodable)]`. See
 encodable.rs for more.
 */
 
-use ast::{MetaItem, Item, Expr, MutMutable, Ident};
+use ast;
+use ast::{MetaItem, Item, Expr, MutMutable};
 use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
@@ -82,9 +83,10 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
             };
             let read_struct_field = cx.ident_of("read_struct_field");
 
+            let path = cx.path_ident(trait_span, substr.type_ident);
             let result = decode_static_fields(cx,
                                               trait_span,
-                                              substr.type_ident,
+                                              path,
                                               summary,
                                               |cx, span, name, field| {
                 cx.expr_try(span,
@@ -113,9 +115,10 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
             for (i, &(name, v_span, ref parts)) in fields.iter().enumerate() {
                 variants.push(cx.expr_str(v_span, token::get_ident(name)));
 
+                let path = cx.path(trait_span, vec![substr.type_ident, name]);
                 let decoded = decode_static_fields(cx,
                                                    v_span,
-                                                   name,
+                                                   path,
                                                    parts,
                                                    |cx, span, _, field| {
                     let idx = cx.expr_uint(span, field);
@@ -153,18 +156,19 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
 }
 
 /// Create a decoder for a single enum variant/struct:
-/// - `outer_pat_ident` is the name of this enum variant/struct
+/// - `outer_pat_path` is the path to this enum variant/struct
 /// - `getarg` should retrieve the `uint`-th field with name `@str`.
 fn decode_static_fields(cx: &mut ExtCtxt,
                         trait_span: Span,
-                        outer_pat_ident: Ident,
+                        outer_pat_path: ast::Path,
                         fields: &StaticFields,
                         getarg: |&mut ExtCtxt, Span, InternedString, uint| -> P<Expr>)
                         -> P<Expr> {
     match *fields {
         Unnamed(ref fields) => {
+            let path_expr = cx.expr_path(outer_pat_path);
             if fields.is_empty() {
-                cx.expr_ident(trait_span, outer_pat_ident)
+                path_expr
             } else {
                 let fields = fields.iter().enumerate().map(|(i, &span)| {
                     getarg(cx, span,
@@ -173,7 +177,7 @@ fn decode_static_fields(cx: &mut ExtCtxt,
                            i)
                 }).collect();
 
-                cx.expr_call_ident(trait_span, outer_pat_ident, fields)
+                cx.expr_call(trait_span, path_expr, fields)
             }
         }
         Named(ref fields) => {
@@ -182,7 +186,7 @@ fn decode_static_fields(cx: &mut ExtCtxt,
                 let arg = getarg(cx, span, token::get_ident(name), i);
                 cx.field_imm(span, name, arg)
             }).collect();
-            cx.expr_struct_ident(trait_span, outer_pat_ident, fields)
+            cx.expr_struct(trait_span, outer_pat_path, fields)
         }
     }
 }
diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs
index 4be299994fd..dccc12e406b 100644
--- a/src/libsyntax/ext/deriving/generic/mod.rs
+++ b/src/libsyntax/ext/deriving/generic/mod.rs
@@ -180,6 +180,10 @@
 //!                                    Named(~[(<ident of x>, <span of x>)]))])
 //! ```
 
+pub use self::StaticFields::*;
+pub use self::SubstructureFields::*;
+use self::StructType::*;
+
 use std::cell::RefCell;
 use std::vec;
 
@@ -192,7 +196,7 @@ use attr;
 use attr::AttrMetaMethods;
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
-use codemap;
+use codemap::{mod, DUMMY_SP};
 use codemap::Span;
 use fold::MoveMap;
 use owned_slice::OwnedSlice;
@@ -543,12 +547,12 @@ impl<'a> TraitDef<'a> {
     }
 }
 
-fn variant_to_pat(cx: &mut ExtCtxt, sp: Span, variant: &ast::Variant)
+fn variant_to_pat(cx: &mut ExtCtxt, sp: Span, enum_ident: ast::Ident, variant: &ast::Variant)
                   -> P<ast::Pat> {
-    let ident = cx.path_ident(sp, variant.node.name);
+    let path = cx.path(sp, vec![enum_ident, variant.node.name]);
     cx.pat(sp, match variant.node.kind {
-        ast::TupleVariantKind(..) => ast::PatEnum(ident, None),
-        ast::StructVariantKind(..) => ast::PatStruct(ident, Vec::new(), true),
+        ast::TupleVariantKind(..) => ast::PatEnum(path, None),
+        ast::StructVariantKind(..) => ast::PatStruct(path, Vec::new(), true),
     })
 }
 
@@ -714,9 +718,10 @@ impl<'a> MethodDef<'a> {
                                  // [fields of next Self arg], [etc]]
         let mut patterns = Vec::new();
         for i in range(0u, self_args.len()) {
+            let struct_path= cx.path(DUMMY_SP, vec!( type_ident ));
             let (pat, ident_expr) =
                 trait_.create_struct_pattern(cx,
-                                             type_ident,
+                                             struct_path,
                                              struct_def,
                                              format!("__self_{}",
                                                      i).as_slice(),
@@ -900,7 +905,8 @@ impl<'a> MethodDef<'a> {
         let mut match_arms: Vec<ast::Arm> = variants.iter().enumerate()
             .map(|(index, variant)| {
                 let mk_self_pat = |cx: &mut ExtCtxt, self_arg_name: &str| {
-                    let (p, idents) = trait_.create_enum_variant_pattern(cx, &**variant,
+                    let (p, idents) = trait_.create_enum_variant_pattern(cx, type_ident,
+                                                                         &**variant,
                                                                          self_arg_name,
                                                                          ast::MutImmutable);
                     (cx.pat(sp, ast::PatRegion(p)), idents)
@@ -996,7 +1002,7 @@ impl<'a> MethodDef<'a> {
         if variants.len() > 1 && self_args.len() > 1 {
             let arms: Vec<ast::Arm> = variants.iter().enumerate()
                 .map(|(index, variant)| {
-                    let pat = variant_to_pat(cx, sp, &**variant);
+                    let pat = variant_to_pat(cx, sp, type_ident, &**variant);
                     let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyU));
                     cx.arm(sp, vec![pat], cx.expr_lit(sp, lit))
                 }).collect();
@@ -1199,20 +1205,15 @@ impl<'a> TraitDef<'a> {
 
     fn create_struct_pattern(&self,
                              cx: &mut ExtCtxt,
-                             struct_ident: Ident,
+                             struct_path: ast::Path,
                              struct_def: &StructDef,
                              prefix: &str,
                              mutbl: ast::Mutability)
                              -> (P<ast::Pat>, Vec<(Span, Option<Ident>, P<Expr>)>) {
         if struct_def.fields.is_empty() {
-            return (
-                cx.pat_ident_binding_mode(
-                    self.span, struct_ident, ast::BindByValue(ast::MutImmutable)),
-                Vec::new());
+            return (cx.pat_enum(self.span, struct_path, vec![]), vec![]);
         }
 
-        let matching_path = cx.path(self.span, vec!( struct_ident ));
-
         let mut paths = Vec::new();
         let mut ident_expr = Vec::new();
         let mut struct_type = Unknown;
@@ -1253,9 +1254,9 @@ impl<'a> TraitDef<'a> {
                     node: ast::FieldPat { ident: id.unwrap(), pat: pat, is_shorthand: false },
                 }
             }).collect();
-            cx.pat_struct(self.span, matching_path, field_pats)
+            cx.pat_struct(self.span, struct_path, field_pats)
         } else {
-            cx.pat_enum(self.span, matching_path, subpats)
+            cx.pat_enum(self.span, struct_path, subpats)
         };
 
         (pattern, ident_expr)
@@ -1263,21 +1264,19 @@ impl<'a> TraitDef<'a> {
 
     fn create_enum_variant_pattern(&self,
                                    cx: &mut ExtCtxt,
+                                   enum_ident: ast::Ident,
                                    variant: &ast::Variant,
                                    prefix: &str,
                                    mutbl: ast::Mutability)
         -> (P<ast::Pat>, Vec<(Span, Option<Ident>, P<Expr>)>) {
         let variant_ident = variant.node.name;
+        let variant_path = cx.path(variant.span, vec![enum_ident, variant_ident]);
         match variant.node.kind {
             ast::TupleVariantKind(ref variant_args) => {
                 if variant_args.is_empty() {
-                    return (cx.pat_ident_binding_mode(variant.span, variant_ident,
-                                                          ast::BindByValue(ast::MutImmutable)),
-                            Vec::new());
+                    return (cx.pat_enum(variant.span, variant_path, vec![]), vec![]);
                 }
 
-                let matching_path = cx.path_ident(variant.span, variant_ident);
-
                 let mut paths = Vec::new();
                 let mut ident_expr = Vec::new();
                 for (i, va) in variant_args.iter().enumerate() {
@@ -1292,11 +1291,11 @@ impl<'a> TraitDef<'a> {
 
                 let subpats = self.create_subpatterns(cx, paths, mutbl);
 
-                (cx.pat_enum(variant.span, matching_path, subpats),
+                (cx.pat_enum(variant.span, variant_path, subpats),
                  ident_expr)
             }
             ast::StructVariantKind(ref struct_def) => {
-                self.create_struct_pattern(cx, variant_ident, &**struct_def,
+                self.create_struct_pattern(cx, variant_path, &**struct_def,
                                            prefix, mutbl)
             }
         }
diff --git a/src/libsyntax/ext/deriving/generic/ty.rs b/src/libsyntax/ext/deriving/generic/ty.rs
index 8b46769d633..700ada8b4ad 100644
--- a/src/libsyntax/ext/deriving/generic/ty.rs
+++ b/src/libsyntax/ext/deriving/generic/ty.rs
@@ -13,6 +13,9 @@ A mini version of ast::Ty, which is easier to use, and features an
 explicit `Self` type to use when specifying impls to be derived.
 */
 
+pub use self::PtrTy::*;
+pub use self::Ty::*;
+
 use ast;
 use ast::{Expr,Generics,Ident};
 use ext::base::ExtCtxt;
diff --git a/src/libsyntax/ext/deriving/primitive.rs b/src/libsyntax/ext/deriving/primitive.rs
index 044a2812c00..cd2d98b70f1 100644
--- a/src/libsyntax/ext/deriving/primitive.rs
+++ b/src/libsyntax/ext/deriving/primitive.rs
@@ -102,7 +102,8 @@ fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure
                         let span = variant.span;
 
                         // expr for `$n == $variant as $name`
-                        let variant = cx.expr_ident(span, variant.node.name);
+                        let path = cx.path(span, vec![substr.type_ident, variant.node.name]);
+                        let variant = cx.expr_path(path);
                         let ty = cx.ty_ident(span, cx.ident_of(name));
                         let cast = cx.expr_cast(span, variant.clone(), ty);
                         let guard = cx.expr_binary(span, ast::BiEq, n.clone(), cast);
diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs
index 584645bb306..8ad8436906b 100644
--- a/src/libsyntax/ext/deriving/rand.rs
+++ b/src/libsyntax/ext/deriving/rand.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use ast;
-use ast::{MetaItem, Item, Expr, Ident};
+use ast::{MetaItem, Item, Expr};
 use codemap::Span;
 use ext::base::ExtCtxt;
 use ext::build::{AstBuilder};
@@ -72,7 +72,8 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
 
     return match *substr.fields {
         StaticStruct(_, ref summary) => {
-            rand_thing(cx, trait_span, substr.type_ident, summary, rand_call)
+            let path = cx.path_ident(trait_span, substr.type_ident);
+            rand_thing(cx, trait_span, path, summary, rand_call)
         }
         StaticEnum(_, ref variants) => {
             if variants.is_empty() {
@@ -115,7 +116,8 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
                 let i_expr = cx.expr_uint(v_span, i);
                 let pat = cx.pat_lit(v_span, i_expr);
 
-                let thing = rand_thing(cx, v_span, ident, summary, |cx, sp| rand_call(cx, sp));
+                let path = cx.path(v_span, vec![substr.type_ident, ident]);
+                let thing = rand_thing(cx, v_span, path, summary, |cx, sp| rand_call(cx, sp));
                 cx.arm(v_span, vec!( pat ), thing)
             }).collect::<Vec<ast::Arm> >();
 
@@ -132,17 +134,18 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
 
     fn rand_thing(cx: &mut ExtCtxt,
                   trait_span: Span,
-                  ctor_ident: Ident,
+                  ctor_path: ast::Path,
                   summary: &StaticFields,
                   rand_call: |&mut ExtCtxt, Span| -> P<Expr>)
                   -> P<Expr> {
+        let path = cx.expr_path(ctor_path.clone());
         match *summary {
             Unnamed(ref fields) => {
                 if fields.is_empty() {
-                    cx.expr_ident(trait_span, ctor_ident)
+                    path
                 } else {
                     let exprs = fields.iter().map(|span| rand_call(cx, *span)).collect();
-                    cx.expr_call_ident(trait_span, ctor_ident, exprs)
+                    cx.expr_call(trait_span, path, exprs)
                 }
             }
             Named(ref fields) => {
@@ -150,7 +153,7 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
                     let e = rand_call(cx, span);
                     cx.field_imm(span, ident, e)
                 }).collect();
-                cx.expr_struct_ident(trait_span, ctor_ident, rand_fields)
+                cx.expr_struct(trait_span, ctor_path, rand_fields)
             }
         }
     }