---

yaml
---
r: 160268
b: refs/heads/master
c: b64c7b8
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: fee71bd476720abc01422a4184badcb734fd4f35
+refs/heads/master: b64c7b83dd08c7c3afc643564d65975d57785172
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 96c8f2b0c1846756e617f1f1fc1372c506e24248
 refs/heads/try: 225de0d60f8ca8dcc62ab2fd8818ebbda4b58cfe

trunk/src/doc/reference.md

@@ -3557,14 +3557,17 @@ The machine types are the following:
 
 #### Machine-dependent integer types
 
-The `uint` type is an unsigned integer type with the same number of bits as the
-platform's pointer type. It can represent every memory address in the process.
-
-The `int` type is a signed integer type with the same number of bits as the
-platform's pointer type. The theoretical upper bound on object and array size
-is the maximum `int` value. This ensures that `int` can be used to calculate
-differences between pointers into an object or array and can address every byte
-within an object along with one byte past the end.
+The Rust type `uint` [^rustuint] is an
+unsigned integer type with target-machine-dependent size. Its size, in
+bits, is equal to the number of bits required to hold any memory address on
+the target machine.
+
+The Rust type `int` [^rustint]  is a two's complement signed integer type with
+target-machine-dependent size. Its size, in bits, is equal to the size of the
+rust type `uint` on the same target machine.
+
+[^rustuint]: A Rust `uint` is analogous to a C99 `uintptr_t`.
+[^rustint]: A Rust `int` is analogous to a C99 `intptr_t`.
 
 ### Textual types
 

trunk/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) => {

trunk/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 {

trunk/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>>;

trunk/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> {

trunk/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};
 
 ///////////////////////////////////////////////////////////////////////////

trunk/src/librustc/middle/ty.rs

@@ -3396,6 +3396,14 @@ pub fn deref<'tcx>(ty: Ty<'tcx>, explicit: bool) -> Option<mt<'tcx>> {
     }
 }
 
+pub fn deref_or_dont<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> {
+    match ty.sty {
+        ty_uniq(ty) => ty,
+        ty_rptr(_, mt) | ty_ptr(mt) => mt.ty,
+        _ => ty
+    }
+}
+
 pub fn close_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
     match ty.sty {
         ty_open(ty) => mk_rptr(cx, ReStatic, mt {ty: ty, mutbl:ast::MutImmutable}),
@@ -5981,59 +5989,3 @@ impl DebruijnIndex {
         DebruijnIndex { depth: self.depth + amount }
     }
 }
-
-impl<'tcx> Repr<'tcx> for AutoAdjustment<'tcx> {
-    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        match *self {
-            AdjustAddEnv(ref trait_store) => {
-                format!("AdjustAddEnv({})", trait_store)
-            }
-            AdjustDerefRef(ref data) => {
-                data.repr(tcx)
-            }
-        }
-    }
-}
-
-impl<'tcx> Repr<'tcx> for UnsizeKind<'tcx> {
-    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        match *self {
-            UnsizeLength(n) => format!("UnsizeLength({})", n),
-            UnsizeStruct(ref k, n) => format!("UnsizeStruct({},{})", k.repr(tcx), n),
-            UnsizeVtable(ref a, ref b) => format!("UnsizeVtable({},{})", a.repr(tcx), b.repr(tcx)),
-        }
-    }
-}
-
-impl<'tcx> Repr<'tcx> for AutoDerefRef<'tcx> {
-    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        format!("AutoDerefRef({}, {})", self.autoderefs, self.autoref.repr(tcx))
-    }
-}
-
-impl<'tcx> Repr<'tcx> for AutoRef<'tcx> {
-    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        match *self {
-            AutoPtr(a, b, ref c) => {
-                format!("AutoPtr({},{},{})", a.repr(tcx), b, c.repr(tcx))
-            }
-            AutoUnsize(ref a) => {
-                format!("AutoUnsize({})", a.repr(tcx))
-            }
-            AutoUnsizeUniq(ref a) => {
-                format!("AutoUnsizeUniq({})", a.repr(tcx))
-            }
-            AutoUnsafe(ref a, ref b) => {
-                format!("AutoUnsafe({},{})", a, b.repr(tcx))
-            }
-        }
-    }
-}
-
-impl<'tcx> Repr<'tcx> for TyTrait<'tcx> {
-    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        format!("TyTrait({},{})",
-                self.principal.repr(tcx),
-                self.bounds.repr(tcx))
-    }
-}