Refactor QPath to take an ast::TraitRef

src/librustc/middle/resolve.rs

@@ -633,6 +633,7 @@ enum TraitReferenceType {
     TraitDerivation,                 // trait T : SomeTrait { ... }
     TraitBoundingTypeParameter,      // fn f<T:SomeTrait>() { ... }
     TraitObject,                     // Box<for<'a> SomeTrait>
+    TraitQPath,                      // <T as SomeTrait>::
 }
 
 impl NameBindings {
@@ -4532,6 +4533,7 @@ impl<'a> Resolver<'a> {
                     TraitImplementation        => "implement",
                     TraitDerivation            => "derive",
                     TraitObject                => "reference",
+                    TraitQPath                 => "extract an associated type from",
                 };
 
                 let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str);
@@ -4969,65 +4971,8 @@ impl<'a> Resolver<'a> {
             }
 
             TyQPath(ref qpath) => {
-                self.resolve_type(&*qpath.for_type);
-
-                let current_module = self.current_module.clone();
-                let module_path: Vec<_> =
-                    qpath.trait_name
-                         .segments
-                         .iter()
-                         .map(|ps| ps.identifier.name)
-                         .collect();
-                match self.resolve_module_path(
-                        current_module,
-                        module_path.as_slice(),
-                        UseLexicalScope,
-                        qpath.trait_name.span,
-                        PathSearch) {
-                    Success((ref module, _)) if module.kind.get() ==
-                            TraitModuleKind => {
-                        match self.resolve_definition_of_name_in_module(
-                                (*module).clone(),
-                                qpath.item_name.name,
-                                TypeNS) {
-                            ChildNameDefinition(def, lp) |
-                            ImportNameDefinition(def, lp) => {
-                                match def {
-                                    DefAssociatedTy(trait_type_id) => {
-                                        let def = DefAssociatedTy(
-                                            trait_type_id);
-                                        self.record_def(ty.id, (def, lp));
-                                    }
-                                    _ => {
-                                        self.resolve_error(
-                                            ty.span,
-                                            "not an associated type");
-                                    }
-                                }
-                            }
-                            NoNameDefinition => {
-                                self.resolve_error(ty.span,
-                                                   "unresolved associated \
-                                                    type");
-                            }
-                        }
-                    }
-                    Success(..) => self.resolve_error(ty.span, "not a trait"),
-                    Indeterminate => {
-                        self.session.span_bug(ty.span,
-                                              "indeterminate result when \
-                                               resolving associated type")
-                    }
-                    Failed(error) => {
-                        let (span, help) = match error {
-                            Some((span, msg)) => (span, format!("; {}", msg)),
-                            None => (ty.span, String::new()),
-                        };
-                        self.resolve_error(span,
-                                           format!("unresolved trait: {}",
-                                                   help).as_slice())
-                    }
-                }
+                self.resolve_type(&*qpath.self_type);
+                self.resolve_trait_reference(ty.id, &*qpath.trait_ref, TraitQPath);
             }
 
             TyClosure(ref c) | TyProc(ref c) => {

src/librustc/middle/subst.rs

@@ -100,6 +100,10 @@ impl<'tcx> Substs<'tcx> {
         regions_is_noop && self.types.is_empty()
     }
 
+    pub fn type_for_def(&self, ty_param_def: &ty::TypeParameterDef) -> Ty<'tcx> {
+        *self.types.get(ty_param_def.space, ty_param_def.index)
+    }
+
     pub fn has_regions_escaping_depth(&self, depth: uint) -> bool {
         self.types.iter().any(|&t| ty::type_escapes_depth(t, depth)) || {
             match self.regions {

src/librustc/middle/traits/mod.rs

@@ -25,6 +25,7 @@ use std::rc::Rc;
 use std::slice::Items;
 use syntax::ast;
 use syntax::codemap::{Span, DUMMY_SP};
+use util::common::ErrorReported;
 
 pub use self::fulfill::FulfillmentContext;
 pub use self::select::SelectionContext;
@@ -95,10 +96,6 @@ pub enum ObligationCauseCode<'tcx> {
     FieldSized,
 }
 
-// An error has already been reported to the user, so no need to continue checking.
-#[deriving(Clone,Show)]
-pub struct ErrorReported;
-
 pub type Obligations<'tcx> = subst::VecPerParamSpace<Obligation<'tcx>>;
 
 pub type Selection<'tcx> = Vtable<'tcx, Obligation<'tcx>>;

src/librustc/middle/traits/select.rs

@@ -17,7 +17,6 @@ use self::Candidate::*;
 use self::BuiltinBoundConditions::*;
 use self::EvaluationResult::*;
 
-use super::{ErrorReported};
 use super::{Obligation, ObligationCause};
 use super::{SelectionError, Unimplemented, Overflow,
             OutputTypeParameterMismatch};
@@ -38,6 +37,7 @@ use std::cell::RefCell;
 use std::collections::hash_map::HashMap;
 use std::rc::Rc;
 use syntax::ast;
+use util::common::ErrorReported;
 use util::ppaux::Repr;
 
 pub struct SelectionContext<'cx, 'tcx:'cx> {

src/librustc/middle/traits/util.rs

@@ -18,9 +18,10 @@ use std::fmt;
 use std::rc::Rc;
 use syntax::ast;
 use syntax::codemap::Span;
+use util::common::ErrorReported;
 use util::ppaux::Repr;
 
-use super::{ErrorReported, Obligation, ObligationCause, VtableImpl,
+use super::{Obligation, ObligationCause, VtableImpl,
             VtableParam, VtableParamData, VtableImplData};
 
 ///////////////////////////////////////////////////////////////////////////

src/librustc/middle/typeck/astconv.rs

@@ -207,7 +207,6 @@ fn ast_path_substs_for_ty<'tcx,AC,RS>(
     decl_def_id: ast::DefId,
     decl_generics: &ty::Generics<'tcx>,
     self_ty: Option<Ty<'tcx>>,
-    associated_ty: Option<Ty<'tcx>>,
     path: &ast::Path)
     -> Substs<'tcx>
     where AC: AstConv<'tcx>, RS: RegionScope
@@ -243,7 +242,7 @@ fn ast_path_substs_for_ty<'tcx,AC,RS>(
     };
 
     create_substs_for_ast_path(this, rscope, path.span, decl_def_id,
-                               decl_generics, self_ty, types, regions, associated_ty)
+                               decl_generics, self_ty, types, regions)
 }
 
 fn create_substs_for_ast_path<'tcx,AC,RS>(
@@ -254,8 +253,7 @@ fn create_substs_for_ast_path<'tcx,AC,RS>(
     decl_generics: &ty::Generics<'tcx>,
     self_ty: Option<Ty<'tcx>>,
     types: Vec<Ty<'tcx>>,
-    regions: Vec<ty::Region>,
-    associated_ty: Option<Ty<'tcx>>)
+    regions: Vec<ty::Region>)
     -> Substs<'tcx>
     where AC: AstConv<'tcx>, RS: RegionScope
 {
@@ -366,9 +364,9 @@ fn create_substs_for_ast_path<'tcx,AC,RS>(
         substs.types.push(
             AssocSpace,
             this.associated_type_binding(span,
-                                         associated_ty,
+                                         self_ty,
                                          decl_def_id,
-                                         param.def_id))
+                                         param.def_id));
     }
 
     return substs;
@@ -417,19 +415,17 @@ pub fn instantiate_poly_trait_ref<'tcx,AC,RS>(
     this: &AC,
     rscope: &RS,
     ast_trait_ref: &ast::PolyTraitRef,
-    self_ty: Option<Ty<'tcx>>,
-    associated_type: Option<Ty<'tcx>>)
+    self_ty: Option<Ty<'tcx>>)
     -> Rc<ty::TraitRef<'tcx>>
     where AC: AstConv<'tcx>, RS: RegionScope
 {
-    instantiate_trait_ref(this, rscope, &ast_trait_ref.trait_ref, self_ty, associated_type)
+    instantiate_trait_ref(this, rscope, &ast_trait_ref.trait_ref, self_ty)
 }
 
 pub fn instantiate_trait_ref<'tcx,AC,RS>(this: &AC,
                                          rscope: &RS,
                                          ast_trait_ref: &ast::TraitRef,
-                                         self_ty: Option<Ty<'tcx>>,
-                                         associated_type: Option<Ty<'tcx>>)
+                                         self_ty: Option<Ty<'tcx>>)
                                          -> Rc<ty::TraitRef<'tcx>>
                                          where AC: AstConv<'tcx>,
                                                RS: RegionScope
@@ -444,8 +440,8 @@ pub fn instantiate_trait_ref<'tcx,AC,RS>(this: &AC,
                          ast_trait_ref.path.span,
                          ast_trait_ref.ref_id) {
         def::DefTrait(trait_def_id) => {
-            let trait_ref = Rc::new(ast_path_to_trait_ref(this, rscope, trait_def_id, self_ty,
-                                                          associated_type, &ast_trait_ref.path));
+            let trait_ref = Rc::new(ast_path_to_trait_ref(this, rscope, trait_def_id,
+                                                          self_ty, &ast_trait_ref.path));
             this.tcx().trait_refs.borrow_mut().insert(ast_trait_ref.ref_id,
                                                       trait_ref.clone());
             trait_ref
@@ -463,7 +459,6 @@ fn ast_path_to_trait_ref<'tcx,AC,RS>(
     rscope: &RS,
     trait_def_id: ast::DefId,
     self_ty: Option<Ty<'tcx>>,
-    associated_type: Option<Ty<'tcx>>,
     path: &ast::Path)
     -> ty::TraitRef<'tcx>
     where AC: AstConv<'tcx>, RS: RegionScope
@@ -493,8 +488,7 @@ fn ast_path_to_trait_ref<'tcx,AC,RS>(
                                             &trait_def.generics,
                                             self_ty,
                                             types,
-                                            regions,
-                                            associated_type);
+                                            regions);
 
     ty::TraitRef::new(trait_def_id, substs)
 }
@@ -517,7 +511,6 @@ pub fn ast_path_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                                         did,
                                         &generics,
                                         None,
-                                        None,
                                         path);
     let ty = decl_ty.subst(tcx, &substs);
     TypeAndSubsts { substs: substs, ty: ty }
@@ -558,7 +551,7 @@ pub fn ast_path_to_ty_relaxed<'tcx,AC,RS>(
         Substs::new(VecPerParamSpace::params_from_type(type_params),
                     VecPerParamSpace::params_from_type(region_params))
     } else {
-        ast_path_substs_for_ty(this, rscope, did, &generics, None, None, path)
+        ast_path_substs_for_ty(this, rscope, did, &generics, None, path)
     };
 
     let ty = decl_ty.subst(tcx, &substs);
@@ -726,7 +719,6 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                                                        rscope,
                                                        trait_def_id,
                                                        None,
-                                                       None,
                                                        path);
                     let empty_vec = [];
                     let bounds = match *opt_bounds { None => empty_vec.as_slice(),
@@ -750,61 +742,37 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
     constr(ast_ty_to_ty(this, rscope, a_seq_ty))
 }
 
-fn associated_ty_to_ty<'tcx,AC,RS>(this: &AC,
-                                   rscope: &RS,
-                                   trait_path: &ast::Path,
-                                   for_ast_type: &ast::Ty,
-                                   trait_type_id: ast::DefId,
-                                   span: Span)
-                                   -> Ty<'tcx>
-                                   where AC: AstConv<'tcx>, RS: RegionScope
+fn qpath_to_ty<'tcx,AC,RS>(this: &AC,
+                           rscope: &RS,
+                           ast_ty: &ast::Ty, // the TyQPath
+                           qpath: &ast::QPath)
+                           -> Ty<'tcx>
+    where AC: AstConv<'tcx>, RS: RegionScope
 {
-    debug!("associated_ty_to_ty(trait_path={}, for_ast_type={}, trait_type_id={})",
-           trait_path.repr(this.tcx()),
-           for_ast_type.repr(this.tcx()),
-           trait_type_id.repr(this.tcx()));
-
-    // Find the trait that this associated type belongs to.
-    let trait_did = match ty::impl_or_trait_item(this.tcx(),
-                                                 trait_type_id).container() {
-        ty::ImplContainer(_) => {
-            this.tcx().sess.span_bug(span,
-                                     "associated_ty_to_ty(): impl associated \
-                                      types shouldn't go through this \
-                                      function")
-        }
-        ty::TraitContainer(trait_id) => trait_id,
-    };
+    debug!("qpath_to_ty(ast_ty={})",
+           ast_ty.repr(this.tcx()));
 
-    let for_type = ast_ty_to_ty(this, rscope, for_ast_type);
-    if !this.associated_types_of_trait_are_valid(for_type, trait_did) {
-        this.tcx().sess.span_err(span,
-                                 "this associated type is not \
-                                  allowed in this context");
-        return ty::mk_err()
-    }
+    let self_type = ast_ty_to_ty(this, rscope, &*qpath.self_type);
+
+    debug!("qpath_to_ty: self_type={}", self_type.repr(this.tcx()));
 
-    let trait_ref = ast_path_to_trait_ref(this,
+    let trait_ref = instantiate_trait_ref(this,
                                           rscope,
-                                          trait_did,
-                                          None,
-                                          Some(for_type),
-                                          trait_path);
-
-    debug!("associated_ty_to_ty(trait_ref={})",
-           trait_ref.repr(this.tcx()));
-
-    let trait_def = this.get_trait_def(trait_did);
-    for type_parameter in trait_def.generics.types.iter() {
-        if type_parameter.def_id == trait_type_id {
-            debug!("associated_ty_to_ty(type_parameter={} substs={})",
-                   type_parameter.repr(this.tcx()),
-                   trait_ref.substs.repr(this.tcx()));
-            return *trait_ref.substs.types.get(type_parameter.space,
-                                               type_parameter.index)
+                                          &*qpath.trait_ref,
+                                          Some(self_type));
+
+    debug!("qpath_to_ty: trait_ref={}", trait_ref.repr(this.tcx()));
+
+    let trait_def = this.get_trait_def(trait_ref.def_id);
+
+    for ty_param_def in trait_def.generics.types.get_slice(AssocSpace).iter() {
+        if ty_param_def.name == qpath.item_name.name {
+            debug!("qpath_to_ty: corresponding ty_param_def={}", ty_param_def);
+            return trait_ref.substs.type_for_def(ty_param_def);
         }
     }
-    this.tcx().sess.span_bug(span,
+
+    this.tcx().sess.span_bug(ast_ty.span,
                              "this associated type didn't get added \
                               as a parameter for some reason")
 }
@@ -931,7 +899,6 @@ pub fn ast_ty_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                                                            rscope,
                                                            trait_def_id,
                                                            None,
-                                                           None,
                                                            path);
                         let empty_bounds: &[ast::TyParamBound] = &[];
                         let ast_bounds = match *bounds {
@@ -996,26 +963,7 @@ pub fn ast_ty_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                 }
             }
             ast::TyQPath(ref qpath) => {
-                match tcx.def_map.borrow().get(&ast_ty.id) {
-                    None => {
-                        tcx.sess.span_bug(ast_ty.span,
-                                          "unbound qualified path")
-                    }
-                    Some(&def::DefAssociatedTy(trait_type_id)) => {
-                        associated_ty_to_ty(this,
-                                            rscope,
-                                            &qpath.trait_name,
-                                            &*qpath.for_type,
-                                            trait_type_id,
-                                            ast_ty.span)
-                    }
-                    Some(_) => {
-                        tcx.sess.span_err(ast_ty.span,
-                                          "this qualified path does not name \
-                                           an associated type");
-                        ty::mk_err()
-                    }
-                }
+                qpath_to_ty(this, rscope, ast_ty, &**qpath)
             }
             ast::TyFixedLengthVec(ref ty, ref e) => {
                 match const_eval::eval_const_expr_partial(tcx, &**e) {
@@ -1411,7 +1359,7 @@ fn conv_ty_poly_trait_ref<'tcx, AC, RS>(
 
     let main_trait_bound = match partitioned_bounds.trait_bounds.remove(0) {
         Some(trait_bound) => {
-            Some(instantiate_poly_trait_ref(this, rscope, trait_bound, None, None))
+            Some(instantiate_poly_trait_ref(this, rscope, trait_bound, None))
         }
         None => {
             this.tcx().sess.span_err(