---

yaml
---
r: 172655
b: refs/heads/auto
c: ee1ca88
h: refs/heads/master
i:
  172653: d9e68f0
  172651: 631a030
  172647: ecf6832
  172639: 58a3bf1
v: v3

Author: retep998

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: e94a9f033eb79b3b4fb037722366644650e8e16c
+refs/heads/auto: ee1ca88213133a58f0a9d234f03babbebeb7c5d8
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/metadata/filesearch.rs

@@ -54,7 +54,7 @@ impl<'a> FileSearch<'a> {
 
         debug!("filesearch: searching lib path");
         let tlib_path = make_target_lib_path(self.sysroot,
-                                             self.triple);
+                                    self.triple);
         if !visited_dirs.contains(tlib_path.as_vec()) {
             match f(&tlib_path) {
                 FileMatches => found = true,

branches/auto/src/librustc/middle/traits/select.rs

@@ -1186,14 +1186,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         .is_ok()
                 })
             }
-            (&BuiltinCandidate(_), &ParamCandidate(_)) => {
-                // If we have a where-clause like `Option<K> : Send`,
-                // then we wind up in a situation where there is a
-                // default rule (`Option<K>:Send if K:Send) and the
-                // where-clause that both seem applicable. Just take
-                // the where-clause in that case.
-                true
-            }
             (&ProjectionCandidate, &ParamCandidate(_)) => {
                 // FIXME(#20297) -- this gives where clauses precedent
                 // over projections. Really these are just two means

branches/auto/src/librustc/session/search_paths.rs

@@ -10,7 +10,7 @@
 
 use std::slice;
 
-#[derive(Clone, Show)]
+#[derive(Clone)]
 pub struct SearchPaths {
     paths: Vec<(PathKind, Path)>,
 }
@@ -20,7 +20,7 @@ pub struct Iter<'a> {
     iter: slice::Iter<'a, (PathKind, Path)>,
 }
 
-#[derive(Eq, PartialEq, Clone, Copy, Show)]
+#[derive(Eq, PartialEq, Clone, Copy)]
 pub enum PathKind {
     Native,
     Crate,

branches/auto/src/librustc_driver/lib.rs

@@ -186,7 +186,7 @@ fn run_compiler(args: &[String]) {
                 list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
             }
             Input::Str(_) => {
-                early_error("cannot list metadata for stdin");
+                early_error("can not list metadata for stdin");
             }
         }
         return;

branches/auto/src/librustc_trans/trans/base.rs

@@ -702,8 +702,9 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
         let mut cx = cx;
 
         for (i, &arg) in variant.args.iter().enumerate() {
-            let arg = monomorphize::apply_param_substs(tcx, substs, &arg);
-            cx = f(cx, adt::trans_field_ptr(cx, repr, av, variant.disr_val, i), arg);
+            cx = (*f)(cx,
+                   adt::trans_field_ptr(cx, repr, av, variant.disr_val, i),
+                   arg.subst(tcx, substs));
         }
         return cx;
     }

branches/auto/src/librustc_trans/trans/debuginfo.rs

@@ -323,28 +323,26 @@ impl<'tcx> TypeMap<'tcx> {
     fn get_unique_type_id_of_type<'a>(&mut self, cx: &CrateContext<'a, 'tcx>,
                                       type_: Ty<'tcx>) -> UniqueTypeId {
 
-        // basic type               -> {:name of the type:}
-        // tuple                    -> {tuple_(:param-uid:)*}
-        // struct                   -> {struct_:svh: / :node-id:_<(:param-uid:),*> }
-        // enum                     -> {enum_:svh: / :node-id:_<(:param-uid:),*> }
-        // enum variant             -> {variant_:variant-name:_:enum-uid:}
-        // reference (&)            -> {& :pointee-uid:}
-        // mut reference (&mut)     -> {&mut :pointee-uid:}
-        // ptr (*)                  -> {* :pointee-uid:}
-        // mut ptr (*mut)           -> {*mut :pointee-uid:}
-        // unique ptr (~)           -> {~ :pointee-uid:}
-        // @-ptr (@)                -> {@ :pointee-uid:}
-        // sized vec ([T; x])       -> {[:size:] :element-uid:}
-        // unsized vec ([T])        -> {[] :element-uid:}
-        // trait (T)                -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
-        // closure                  -> {<unsafe_> <once_> :store-sigil:
-        //                                  |(:param-uid:),* <,_...>| -> \
-        //                                  :return-type-uid: : (:bounds:)*}
-        // function                 -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \
-        //                                  :return-type-uid:}
-        // unique vec box (~[])     -> {HEAP_VEC_BOX<:pointee-uid:>}
-        // gc box                   -> {GC_BOX<:pointee-uid:>}
-        // projection (<T as U>::V) -> {<:ty-uid: as :trait-uid:> :: :name-uid: }
+        // basic type           -> {:name of the type:}
+        // tuple                -> {tuple_(:param-uid:)*}
+        // struct               -> {struct_:svh: / :node-id:_<(:param-uid:),*> }
+        // enum                 -> {enum_:svh: / :node-id:_<(:param-uid:),*> }
+        // enum variant         -> {variant_:variant-name:_:enum-uid:}
+        // reference (&)        -> {& :pointee-uid:}
+        // mut reference (&mut) -> {&mut :pointee-uid:}
+        // ptr (*)              -> {* :pointee-uid:}
+        // mut ptr (*mut)       -> {*mut :pointee-uid:}
+        // unique ptr (~)       -> {~ :pointee-uid:}
+        // @-ptr (@)            -> {@ :pointee-uid:}
+        // sized vec ([T; x])   -> {[:size:] :element-uid:}
+        // unsized vec ([T])    -> {[] :element-uid:}
+        // trait (T)            -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
+        // closure              -> {<unsafe_> <once_> :store-sigil: |(:param-uid:),* <,_...>| -> \
+        //                             :return-type-uid: : (:bounds:)*}
+        // function             -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \
+        //                             :return-type-uid:}
+        // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>}
+        // gc box               -> {GC_BOX<:pointee-uid:>}
 
         match self.type_to_unique_id.get(&type_).cloned() {
             Some(unique_type_id) => return unique_type_id,
@@ -437,25 +435,6 @@ impl<'tcx> TypeMap<'tcx> {
                                        principal.substs,
                                        &mut unique_type_id);
             },
-            ty::ty_projection(ref projection) => {
-                unique_type_id.push_str("<");
-
-                let self_ty = projection.trait_ref.self_ty();
-                let self_type_id = self.get_unique_type_id_of_type(cx, self_ty);
-                let self_type_id = self.get_unique_type_id_as_string(self_type_id);
-                unique_type_id.push_str(&self_type_id[]);
-
-                unique_type_id.push_str(" as ");
-
-                from_def_id_and_substs(self,
-                                       cx,
-                                       projection.trait_ref.def_id,
-                                       projection.trait_ref.substs,
-                                       &mut unique_type_id);
-
-                unique_type_id.push_str(">::");
-                unique_type_id.push_str(token::get_name(projection.item_name).get());
-            },
             ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => {
                 if unsafety == ast::Unsafety::Unsafe {
                     unique_type_id.push_str("unsafe ");
@@ -499,10 +478,7 @@ impl<'tcx> TypeMap<'tcx> {
                                                         closure_ty,
                                                         &mut unique_type_id);
             },
-            ty::ty_err |
-            ty::ty_infer(_) |
-            ty::ty_open(_) |
-            ty::ty_param(_) => {
+            _ => {
                 cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
                                       &ppaux::ty_to_string(cx.tcx(), type_)[],
                                       type_.sty)[])
@@ -3879,22 +3855,10 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::ty_unboxed_closure(..) => {
             output.push_str("closure");
         }
-        ty::ty_projection(ref projection) => {
-            output.push_str("<");
-            let self_ty = projection.trait_ref.self_ty();
-            push_debuginfo_type_name(cx, self_ty, true, output);
-
-            output.push_str(" as ");
-
-            push_item_name(cx, projection.trait_ref.def_id, false, output);
-            push_type_params(cx, projection.trait_ref.substs, output);
-
-            output.push_str(">::");
-            output.push_str(token::get_name(projection.item_name).get());
-        }
         ty::ty_err |
         ty::ty_infer(_) |
         ty::ty_open(_) |
+        ty::ty_projection(..) |
         ty::ty_param(_) => {
             cx.sess().bug(&format!("debuginfo: Trying to create type name for \
                 unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))[]);

branches/auto/src/librustc_trans/trans/monomorphize.rs

@@ -274,7 +274,6 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         ast_map::NodeArg(..) |
         ast_map::NodeBlock(..) |
         ast_map::NodePat(..) |
-        ast_map::NodeViewItem(..) |
         ast_map::NodeLocal(..) => {
             ccx.sess().bug(&format!("can't monomorphize a {:?}",
                                    map_node)[])

branches/auto/src/librustc_typeck/check/_match.rs

@@ -619,8 +619,6 @@ pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
             }
         };
 
-        let field_type = pcx.fcx.normalize_associated_types_in(span, &field_type);
-
         check_pat(pcx, &*field.pat, field_type);
     }
 

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

@@ -2289,34 +2289,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         obligations.map_move(|o| self.register_predicate(o));
     }
-
-    // Only for fields! Returns <none> for methods>
-    // Indifferent to privacy flags
-    pub fn lookup_field_ty(&self,
-                           span: Span,
-                           class_id: ast::DefId,
-                           items: &[ty::field_ty],
-                           fieldname: ast::Name,
-                           substs: &subst::Substs<'tcx>)
-                           -> Option<Ty<'tcx>>
-    {
-        let o_field = items.iter().find(|f| f.name == fieldname);
-        o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs))
-               .map(|t| self.normalize_associated_types_in(span, &t))
-    }
-
-    pub fn lookup_tup_field_ty(&self,
-                               span: Span,
-                               class_id: ast::DefId,
-                               items: &[ty::field_ty],
-                               idx: uint,
-                               substs: &subst::Substs<'tcx>)
-                               -> Option<Ty<'tcx>>
-    {
-        let o_field = if idx < items.len() { Some(&items[idx]) } else { None };
-        o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs))
-               .map(|t| self.normalize_associated_types_in(span, &t))
-    }
 }
 
 impl<'a, 'tcx> RegionScope for FnCtxt<'a, 'tcx> {
@@ -3071,6 +3043,30 @@ pub fn impl_self_ty<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
     TypeAndSubsts { substs: substs, ty: substd_ty }
 }
 
+// Only for fields! Returns <none> for methods>
+// Indifferent to privacy flags
+pub fn lookup_field_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
+                             class_id: ast::DefId,
+                             items: &[ty::field_ty],
+                             fieldname: ast::Name,
+                             substs: &subst::Substs<'tcx>)
+                             -> Option<Ty<'tcx>> {
+
+    let o_field = items.iter().find(|f| f.name == fieldname);
+    o_field.map(|f| ty::lookup_field_type(tcx, class_id, f.id, substs))
+}
+
+pub fn lookup_tup_field_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
+                                 class_id: ast::DefId,
+                                 items: &[ty::field_ty],
+                                 idx: uint,
+                                 substs: &subst::Substs<'tcx>)
+                                 -> Option<Ty<'tcx>> {
+
+    let o_field = if idx < items.len() { Some(&items[idx]) } else { None };
+    o_field.map(|f| ty::lookup_field_type(tcx, class_id, f.id, substs))
+}
+
 // Controls whether the arguments are automatically referenced. This is useful
 // for overloaded binary and unary operators.
 #[derive(Copy, PartialEq)]
@@ -3534,8 +3530,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                     ty::ty_struct(base_id, substs) => {
                         debug!("struct named {}", ppaux::ty_to_string(tcx, base_t));
                         let fields = ty::lookup_struct_fields(tcx, base_id);
-                        fcx.lookup_field_ty(expr.span, base_id, &fields[],
-                                            field.node.name, &(*substs))
+                        lookup_field_ty(tcx, base_id, &fields[],
+                                        field.node.name, &(*substs))
                     }
                     _ => None
                 }
@@ -3597,8 +3593,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                         if tuple_like {
                             debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t));
                             let fields = ty::lookup_struct_fields(tcx, base_id);
-                            fcx.lookup_tup_field_ty(expr.span, base_id, &fields[],
-                                                    idx.node, &(*substs))
+                            lookup_tup_field_ty(tcx, base_id, &fields[],
+                                                idx.node, &(*substs))
                         } else {
                             None
                         }

branches/auto/src/libstd/rt/util.rs

@@ -144,6 +144,56 @@ pub fn abort(args: fmt::Arguments) -> ! {
     let _ = write!(&mut w, "{}", args);
     let msg = str::from_utf8(&w.buf[0..w.pos]).unwrap_or("aborted");
     let msg = if msg.is_empty() {"aborted"} else {msg};
+
+    // Give some context to the message
+    let hash = msg.bytes().fold(0, |accum, val| accum + (val as uint) );
+    let quote = match hash % 10 {
+        0 => "
+It was from the artists and poets that the pertinent answers came, and I
+know that panic would have broken loose had they been able to compare notes.
+As it was, lacking their original letters, I half suspected the compiler of
+having asked leading questions, or of having edited the correspondence in
+corroboration of what he had latently resolved to see.",
+        1 => "
+There are not many persons who know what wonders are opened to them in the
+stories and visions of their youth; for when as children we listen and dream,
+we think but half-formed thoughts, and when as men we try to remember, we are
+dulled and prosaic with the poison of life. But some of us awake in the night
+with strange phantasms of enchanted hills and gardens, of fountains that sing
+in the sun, of golden cliffs overhanging murmuring seas, of plains that stretch
+down to sleeping cities of bronze and stone, and of shadowy companies of heroes
+that ride caparisoned white horses along the edges of thick forests; and then
+we know that we have looked back through the ivory gates into that world of
+wonder which was ours before we were wise and unhappy.",
+        2 => "
+Instead of the poems I had hoped for, there came only a shuddering blackness
+and ineffable loneliness; and I saw at last a fearful truth which no one had
+ever dared to breathe before — the unwhisperable secret of secrets — The fact
+that this city of stone and stridor is not a sentient perpetuation of Old New
+York as London is of Old London and Paris of Old Paris, but that it is in fact
+quite dead, its sprawling body imperfectly embalmed and infested with queer
+animate things which have nothing to do with it as it was in life.",
+        3 => "
+The ocean ate the last of the land and poured into the smoking gulf, thereby
+giving up all it had ever conquered. From the new-flooded lands it flowed
+again, uncovering death and decay; and from its ancient and immemorial bed it
+trickled loathsomely, uncovering nighted secrets of the years when Time was
+young and the gods unborn. Above the waves rose weedy remembered spires. The
+moon laid pale lilies of light on dead London, and Paris stood up from its damp
+grave to be sanctified with star-dust. Then rose spires and monoliths that were
+weedy but not remembered; terrible spires and monoliths of lands that men never
+knew were lands...",
+        4 => "
+There was a night when winds from unknown spaces whirled us irresistibly into
+limitless vacuum beyond all thought and entity. Perceptions of the most
+maddeningly untransmissible sort thronged upon us; perceptions of infinity
+which at the time convulsed us with joy, yet which are now partly lost to my
+memory and partly incapable of presentation to others.",
+        _ => "You've met with a terrible fate, haven't you?"
+    };
+    rterrln!("{}", "");
+    rterrln!("{}", quote);
+    rterrln!("{}", "");
     rterrln!("fatal runtime error: {}", msg);
     unsafe { intrinsics::abort(); }
 }

branches/auto/src/libstd/sys/windows/condvar.rs

@@ -27,16 +27,18 @@ impl Condvar {
 
     #[inline]
     pub unsafe fn wait(&self, mutex: &Mutex) {
-        let r = ffi::SleepConditionVariableCS(self.inner.get(),
-                                              mutex::raw(mutex),
-                                              libc::INFINITE);
+        let r = ffi::SleepConditionVariableSRW(self.inner.get(),
+                                               mutex::raw(mutex),
+                                               libc::INFINITE,
+                                               0);
         debug_assert!(r != 0);
     }
 
     pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
-        let r = ffi::SleepConditionVariableCS(self.inner.get(),
-                                              mutex::raw(mutex),
-                                              dur.num_milliseconds() as DWORD);
+        let r = ffi::SleepConditionVariableSRW(self.inner.get(),
+                                               mutex::raw(mutex),
+                                               dur.num_milliseconds() as DWORD,
+                                               0);
         if r == 0 {
             const ERROR_TIMEOUT: DWORD = 0x5B4;
             debug_assert_eq!(os::errno() as uint, ERROR_TIMEOUT as uint);