---

yaml
---
r: 187724
b: refs/heads/tmp
c: ffb8092
h: refs/heads/master
v: v3

Author: eddyb

[refs]

@@ -34,5 +34,5 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 326711e9bdee2e8f467ad716109b5a270b61478d
+refs/heads/tmp: ffb8092ccf8dd186a9a03e6808d04a7276206793
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/tmp/src/librustc/lint/context.rs

@@ -717,11 +717,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
         visit::walk_path(self, p);
     }
 
-    fn visit_qpath(&mut self, p: &ast::QPath, id: ast::NodeId) {
-        run_lints!(self, check_qpath, p, id);
-        visit::walk_qpath(self, p);
-    }
-
     fn visit_attribute(&mut self, attr: &ast::Attribute) {
         run_lints!(self, check_attribute, attr);
     }

branches/tmp/src/librustc/lint/mod.rs

@@ -157,7 +157,6 @@ pub trait LintPass {
     fn check_explicit_self(&mut self, _: &Context, _: &ast::ExplicitSelf) { }
     fn check_mac(&mut self, _: &Context, _: &ast::Mac) { }
     fn check_path(&mut self, _: &Context, _: &ast::Path, _: ast::NodeId) { }
-    fn check_qpath(&mut self, _: &Context, _: &ast::QPath, _: ast::NodeId) { }
     fn check_attribute(&mut self, _: &Context, _: &ast::Attribute) { }
 
     /// Called when entering a syntax node that can have lint attributes such

branches/tmp/src/librustc/middle/dead.rs

@@ -306,11 +306,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
         visit::walk_path(self, path);
     }
 
-    fn visit_qpath(&mut self, qpath: &ast::QPath, id: ast::NodeId) {
-        self.lookup_and_handle_definition(&id);
-        visit::walk_qpath(self, qpath);
-    }
-
     fn visit_item(&mut self, _: &ast::Item) {
         // Do not recurse into items. These items will be added to the
         // worklist and recursed into manually if necessary.

branches/tmp/src/librustc_back/svh.rs

@@ -194,7 +194,6 @@ mod svh_visitor {
         SawVariant,
         SawExplicitSelf,
         SawPath,
-        SawQPath,
         SawOptLifetimeRef,
         SawBlock,
         SawPat,
@@ -486,10 +485,6 @@ mod svh_visitor {
             SawPath.hash(self.st); visit::walk_path(self, path)
         }
 
-        fn visit_qpath(&mut self, qpath: &QPath, _: ast::NodeId) {
-            SawQPath.hash(self.st); visit::walk_qpath(self, qpath)
-        }
-
         fn visit_block(&mut self, b: &Block) {
             SawBlock.hash(self.st); visit::walk_block(self, b)
         }

branches/tmp/src/librustc_privacy/lib.rs

@@ -1021,11 +1021,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
         self.check_path(path.span, id, path.segments.last().unwrap().identifier);
         visit::walk_path(self, path);
     }
-
-    fn visit_qpath(&mut self, qpath: &ast::QPath, id: ast::NodeId) {
-        self.check_path(qpath.trait_path.span, id, qpath.item_path.identifier);
-        visit::walk_qpath(self, qpath);
-    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

branches/tmp/src/librustc_resolve/lib.rs

@@ -1334,16 +1334,10 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                 // Don't need to do anything for function calls,
                 // because just walking the callee path does what we want.
                 visit::walk_expr(self, ex);
-            },
-            ast::ExprPath(ref path) => {
-                self.process_path(ex.id, path.span, path, None);
-                visit::walk_path(self, path);
             }
-            ast::ExprQPath(ref qpath) => {
-                let mut path = qpath.trait_path.clone();
-                path.segments.push(qpath.item_path.clone());
-                self.process_path(ex.id, ex.span, &path, None);
-                visit::walk_qpath(self, &**qpath);
+            ast::ExprPath(ref path) | ast::ExprQPath(ast::QPath { ref path, .. }) => {
+                self.process_path(ex.id, path.span, path, None);
+                visit::walk_expr(self, ex);
             }
             ast::ExprStruct(ref path, ref fields, ref base) =>
                 self.process_struct_lit(ex, path, fields, base),

branches/tmp/src/librustc_trans/save/mod.rs

@@ -575,8 +575,7 @@ pub fn instantiate_poly_trait_ref<'tcx>(
     let shifted_rscope = ShiftedRscope::new(rscope);
 
     let trait_ref = instantiate_trait_ref(this, &shifted_rscope,
-                                          &ast_trait_ref.trait_ref.path,
-                                          ast_trait_ref.trait_ref.ref_id,
+                                          &ast_trait_ref.trait_ref,
                                           None, self_ty, Some(&mut projections));
 
     for projection in projections {
@@ -595,14 +594,14 @@ pub fn instantiate_poly_trait_ref<'tcx>(
 pub fn instantiate_trait_ref<'tcx>(
     this: &AstConv<'tcx>,
     rscope: &RegionScope,
-    path: &ast::Path,
-    path_id: ast::NodeId,
+    trait_ref: &ast::TraitRef,
     impl_id: Option<ast::NodeId>,
     self_ty: Option<Ty<'tcx>>,
     projections: Option<&mut Vec<ty::ProjectionPredicate<'tcx>>>)
     -> Rc<ty::TraitRef<'tcx>>
 {
-    match ::lookup_def_tcx(this.tcx(), path.span, path_id) {
+    let path = &trait_ref.path;
+    match ::lookup_def_tcx(this.tcx(), path.span, trait_ref.ref_id) {
         def::DefTrait(trait_def_id) => {
             let trait_ref = ast_path_to_trait_ref(this,
                                                   rscope,
@@ -1201,11 +1200,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
             ast::TyPolyTraitRef(ref bounds) => {
                 conv_ty_poly_trait_ref(this, rscope, ast_ty.span, &bounds[..])
             }
-            ast::TyPath(_) | ast::TyQPath(_) => {
-                let simple_path = |&:| match ast_ty.node {
-                    ast::TyPath(ref path) => path,
-                    _ => tcx.sess.span_bug(ast_ty.span, "expected non-qualified path")
-                };
+            ast::TyPath(ref path) | ast::TyQPath(ast::QPath { ref path, .. }) => {
                 let a_def = match tcx.def_map.borrow().get(&ast_ty.id) {
                     None => {
                         tcx.sess
@@ -1224,24 +1219,24 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
                         let trait_ref = object_path_to_poly_trait_ref(this,
                                                                       rscope,
                                                                       trait_def_id,
-                                                                      simple_path(),
+                                                                      path,
                                                                       &mut projection_bounds);
 
                         trait_ref_to_object_type(this, rscope, ast_ty.span,
                                                  trait_ref, projection_bounds, &[])
                     }
                     def::DefTy(did, _) | def::DefStruct(did) => {
-                        ast_path_to_ty(this, rscope, did, simple_path()).ty
+                        ast_path_to_ty(this, rscope, did, path).ty
                     }
                     def::DefTyParam(space, index, _, name) => {
-                        check_path_args(tcx, simple_path(), NO_TPS | NO_REGIONS);
+                        check_path_args(tcx, path, NO_TPS | NO_REGIONS);
                         ty::mk_param(tcx, space, index, name)
                     }
                     def::DefSelfTy(_) => {
                         // n.b.: resolve guarantees that the this type only appears in a
                         // trait, which we rely upon in various places when creating
                         // substs
-                        check_path_args(tcx, simple_path(), NO_TPS | NO_REGIONS);
+                        check_path_args(tcx, path, NO_TPS | NO_REGIONS);
                         ty::mk_self_type(tcx)
                     }
                     def::DefMod(id) => {
@@ -1253,19 +1248,14 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
                         panic!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call");
                     }
                     def::DefAssociatedTy(trait_did, _) => {
-                        let (opt_self_ty, trait_segment, item_segment) = match ast_ty.node {
-                            ast::TyQPath(ref qpath) => {
-                                (Some(&*qpath.self_type), qpath.trait_path.segments.last().unwrap(),
-                                 &qpath.item_path)
-                            }
-                            ast::TyPath(ref path) => {
-                                (None, &path.segments[path.segments.len()-2],
-                                 path.segments.last().unwrap())
-                            }
-                            _ => unreachable!()
+                        let opt_self_ty = if let ast::TyQPath(ref qpath) = ast_ty.node {
+                            Some(&*qpath.self_type)
+                        } else {
+                            None
                         };
-                        qpath_to_ty(this, rscope, ast_ty.span, opt_self_ty,
-                                    trait_did, trait_segment, item_segment)
+                        qpath_to_ty(this, rscope, ast_ty.span, opt_self_ty, trait_did,
+                                    &path.segments[path.segments.len()-2],
+                                    path.segments.last().unwrap())
                     }
                     def::DefAssociatedPath(provenance, assoc_ident) => {
                         associated_path_def_to_ty(this, ast_ty, provenance, assoc_ident.name)

branches/tmp/src/librustc_typeck/astconv.rs

@@ -3614,9 +3614,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
           let self_ty = fcx.to_ty(&*qpath.self_type);
           let defn = lookup_def(fcx, expr.span, id);
           let (scheme, predicates) = type_scheme_and_predicates_for_def(fcx, expr.span, defn);
-          let mut path = qpath.trait_path.clone();
-          path.segments.push(qpath.item_path.clone());
-          instantiate_path(fcx, &path, scheme, &predicates, Some(self_ty),
+          instantiate_path(fcx, &qpath.path, scheme, &predicates, Some(self_ty),
                            defn, expr.span, expr.id);
 
           // We always require that the type provided as the value for

branches/tmp/src/librustc_typeck/check/mod.rs

@@ -740,8 +740,7 @@ fn convert_item(ccx: &CollectCtxt, it: &ast::Item) {
             if let Some(ref trait_ref) = *opt_trait_ref {
                 astconv::instantiate_trait_ref(ccx,
                                                &ExplicitRscope,
-                                               &trait_ref.path,
-                                               trait_ref.ref_id,
+                                               trait_ref,
                                                Some(it.id),
                                                Some(selfty),
                                                None);

branches/tmp/src/librustc_typeck/collect.rs

@@ -1500,10 +1500,12 @@ impl Clean<Type> for ast::Ty {
                 resolve_type(cx, p.clean(cx), self.id)
             }
             TyQPath(ref qp) => {
+                let mut trait_path = qp.path.clone();
+                trait_path.segments.pop();
                 Type::QPath {
-                    name: qp.item_path.identifier.clean(cx),
+                    name: qp.path.segments.last().unwrap().identifier.clean(cx),
                     self_type: box qp.self_type.clean(cx),
-                    trait_: box resolve_type(cx, qp.trait_path.clean(cx), self.id)
+                    trait_: box resolve_type(cx, trait_path.clean(cx), self.id)
                 }
             }
             TyObjectSum(ref lhs, ref bounds) => {

branches/tmp/src/librustdoc/clean/mod.rs

@@ -757,7 +757,7 @@ pub enum Expr_ {
     /// type parameters, e.g. foo::bar::<baz>
     ExprPath(Path),
     /// A "qualified path", e.g. `<Vec<T> as SomeTrait>::SomeType`
-    ExprQPath(P<QPath>),
+    ExprQPath(QPath),
 
     ExprAddrOf(Mutability, P<Expr>),
     ExprBreak(Option<Ident>),
@@ -781,13 +781,12 @@ pub enum Expr_ {
 /// A "qualified path":
 ///
 ///     <Vec<T> as SomeTrait>::SomeAssociatedItem
-///      ^~~~~     ^~~~~~~~~   ^~~~~~~~~~~~~~~~~~
-///      self_type  trait_path  item_path
+///      ^~~~~     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+///      self_type  path
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct QPath {
     pub self_type: P<Ty>,
-    pub trait_path: Path,
-    pub item_path: PathSegment,
+    pub path: Path,
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
@@ -1259,7 +1258,7 @@ pub enum Ty_ {
     /// Type parameters are stored in the Path itself
     TyPath(Path),
     /// A "qualified path", e.g. `<Vec<T> as SomeTrait>::SomeType`
-    TyQPath(P<QPath>),
+    TyQPath(QPath),
     /// Something like `A+B`. Note that `B` must always be a path.
     TyObjectSum(P<Ty>, TyParamBounds),
     /// A type like `for<'a> Foo<&'a Bar>`

branches/tmp/src/libsyntax/ast.rs

@@ -41,16 +41,16 @@ pub trait AstBuilder {
         -> ast::Path;
 
     fn qpath(&self, self_type: P<ast::Ty>,
-             trait_ref: P<ast::TraitRef>,
-             ident: ast::Ident )
-        -> P<ast::QPath>;
+             trait_path: ast::Path,
+             ident: ast::Ident)
+             -> ast::QPath;
     fn qpath_all(&self, self_type: P<ast::Ty>,
-                trait_ref: P<ast::TraitRef>,
+                trait_path: ast::Path,
                 ident: ast::Ident,
                 lifetimes: Vec<ast::Lifetime>,
                 types: Vec<P<ast::Ty>>,
-                bindings: Vec<P<ast::TypeBinding>> )
-        -> P<ast::QPath>;
+                bindings: Vec<P<ast::TypeBinding>>)
+                -> ast::QPath;
 
     // types
     fn ty_mt(&self, ty: P<ast::Ty>, mutbl: ast::Mutability) -> ast::MutTy;
@@ -114,7 +114,7 @@ pub trait AstBuilder {
     // expressions
     fn expr(&self, span: Span, node: ast::Expr_) -> P<ast::Expr>;
     fn expr_path(&self, path: ast::Path) -> P<ast::Expr>;
-    fn expr_qpath(&self, span: Span, qpath: P<ast::QPath>) -> P<ast::Expr>;
+    fn expr_qpath(&self, span: Span, qpath: ast::QPath) -> P<ast::Expr>;
     fn expr_ident(&self, span: Span, id: ast::Ident) -> P<ast::Expr>;
 
     fn expr_self(&self, span: Span) -> P<ast::Expr>;
@@ -346,40 +346,40 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
 
     /// Constructs a qualified path.
     ///
-    /// Constructs a path like `<self_type as trait_ref>::ident`.
+    /// Constructs a path like `<self_type as trait_path>::ident`.
     fn qpath(&self,
              self_type: P<ast::Ty>,
-             trait_ref: P<ast::TraitRef>,
+             trait_path: ast::Path,
              ident: ast::Ident)
-             -> P<ast::QPath> {
-        self.qpath_all(self_type, trait_ref, ident, Vec::new(), Vec::new(), Vec::new())
+             -> ast::QPath {
+        self.qpath_all(self_type, trait_path, ident, vec![], vec![], vec![])
     }
 
     /// Constructs a qualified path.
     ///
-    /// Constructs a path like `<self_type as trait_ref>::ident<a, T, A=Bar>`.
+    /// Constructs a path like `<self_type as trait_path>::ident<'a, T, A=Bar>`.
     fn qpath_all(&self,
                  self_type: P<ast::Ty>,
-                 trait_ref: P<ast::TraitRef>,
+                 trait_path: ast::Path,
                  ident: ast::Ident,
                  lifetimes: Vec<ast::Lifetime>,
                  types: Vec<P<ast::Ty>>,
-                 bindings: Vec<P<ast::TypeBinding>> )
-                 -> P<ast::QPath> {
-        let segment = ast::PathSegment {
+                 bindings: Vec<P<ast::TypeBinding>>)
+                 -> ast::QPath {
+        let mut path = trait_path;
+        path.segments.push(ast::PathSegment {
             identifier: ident,
             parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
                 lifetimes: lifetimes,
                 types: OwnedSlice::from_vec(types),
                 bindings: OwnedSlice::from_vec(bindings),
             })
-        };
+        });
 
-        P(ast::QPath {
+        ast::QPath {
             self_type: self_type,
-            trait_ref: trait_ref,
-            item_path: segment,
-        })
+            path: path
+        }
     }
 
     fn ty_mt(&self, ty: P<ast::Ty>, mutbl: ast::Mutability) -> ast::MutTy {
@@ -607,7 +607,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
     /// Constructs a QPath expression.
-    fn expr_qpath(&self, span: Span, qpath: P<ast::QPath>) -> P<ast::Expr> {
+    fn expr_qpath(&self, span: Span, qpath: ast::QPath) -> P<ast::Expr> {
         self.expr(span, ast::ExprQPath(qpath))
     }