---

yaml
---
r: 275927
b: refs/heads/master
c: 2b71219
h: refs/heads/master
i:
  275925: 09ac66a
  275923: 05f5151
  275919: 514f7e8

Author: Ryman

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 03bef4c43b2f51df6bfd558b57b492cb821dd5ec
+refs/heads/master: 2b71219a618a8c9ad65cdcf008c2a1c6377eb1cd
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
 refs/heads/try: 49312a405e14a449b98fe0056b12a40ac128be4a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/mk/tests.mk

@@ -623,7 +623,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
 	--lldb-python $$(CFG_LLDB_PYTHON) \
         --gdb-version="$(CFG_GDB_VERSION)" \
         --lldb-version="$(CFG_LLDB_VERSION)" \
-        --android-cross-path=$(CFG_ARM_LINUX_ANDROIDEABI_NDK) \
+        --android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
         --adb-path=$(CFG_ADB) \
         --adb-test-dir=$(CFG_ADB_TEST_DIR) \
         --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \

trunk/src/librustc/middle/region.rs

@@ -389,7 +389,7 @@ impl RegionMaps {
                            // but this isn't the only place
                 }
                 let idx = CodeExtent(self.code_extents.borrow().len() as u32);
-                debug!("CodeExtent({}) = {:?} [parent={}]", idx.0, e, parent.0);
+                info!("CodeExtent({}) = {:?} [parent={}]", idx.0, e, parent.0);
                 self.code_extents.borrow_mut().push(e);
                 self.scope_map.borrow_mut().push(parent);
                 *v.insert(idx)

trunk/src/librustc/traits/fulfill.rs

@@ -542,12 +542,12 @@ fn process_predicate1<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
             let trait_obligation = obligation.with(data.clone());
             match selcx.select(&trait_obligation) {
                 Ok(Some(vtable)) => {
-                    debug!("selecting trait `{:?}` at depth {} yielded Ok(Some)",
+                    info!("selecting trait `{:?}` at depth {} yielded Ok(Some)",
                           data, obligation.recursion_depth);
                     Ok(Some(vtable.nested_obligations()))
                 }
                 Ok(None) => {
-                    debug!("selecting trait `{:?}` at depth {} yielded Ok(None)",
+                    info!("selecting trait `{:?}` at depth {} yielded Ok(None)",
                           data, obligation.recursion_depth);
 
                     // This is a bit subtle: for the most part, the
@@ -781,6 +781,8 @@ impl<'tcx> GlobalFulfilledPredicates<'tcx> {
             self.dep_graph.read(data.dep_node());
             debug!("check_duplicate: global predicate `{:?}` already proved elsewhere", data);
 
+            info!("check_duplicate_trait hit: `{:?}`", data);
+
             true
         } else {
             false
@@ -796,6 +798,7 @@ impl<'tcx> GlobalFulfilledPredicates<'tcx> {
             if data.is_global() {
                 if self.set.insert(data.clone()) {
                     debug!("add_if_global: global predicate `{:?}` added", data);
+                    info!("check_duplicate_trait entry: `{:?}`", data);
                 }
             }
         }

trunk/src/librustc_back/target/arm_linux_androideabi.rs

@@ -12,7 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::android_base::opts();
-    base.features = "+v7,+vfp3,+d16".to_string();
+    base.features = "+v7".to_string();
 
     Target {
         llvm_target: "arm-linux-androideabi".to_string(),

trunk/src/librustc_trans/debuginfo/mod.rs

@@ -34,7 +34,6 @@ use rustc::hir;
 use abi::Abi;
 use common::{NodeIdAndSpan, CrateContext, FunctionContext, Block, BlockAndBuilder};
 use monomorphize::Instance;
-use rustc::infer::normalize_associated_type;
 use rustc::ty::{self, Ty};
 use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo};
 use util::nodemap::{DefIdMap, NodeMap, FnvHashMap, FnvHashSet};
@@ -369,7 +368,6 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
         name_to_append_suffix_to.push('<');
         for (i, &actual_type) in actual_types.iter().enumerate() {
-            let actual_type = normalize_associated_type(cx.tcx(), &actual_type);
             // Add actual type name to <...> clause of function name
             let actual_type_name = compute_debuginfo_type_name(cx,
                                                                actual_type,
@@ -385,7 +383,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         // Again, only create type information if full debuginfo is enabled
         let template_params: Vec<_> = if cx.sess().opts.debuginfo == FullDebugInfo {
             generics.types.as_slice().iter().enumerate().map(|(i, param)| {
-                let actual_type = normalize_associated_type(cx.tcx(), &actual_types[i]);
+                let actual_type = actual_types[i];
                 let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP);
                 let name = CString::new(param.name.as_str().as_bytes()).unwrap();
                 unsafe {

trunk/src/librustc_typeck/coherence/mod.rs

@@ -34,7 +34,9 @@ use CrateCtxt;
 use rustc::infer::{self, InferCtxt, TypeOrigin, new_infer_ctxt};
 use std::cell::RefCell;
 use std::rc::Rc;
+use syntax::ast;
 use syntax::codemap::Span;
+use syntax::errors::DiagnosticBuilder;
 use util::nodemap::{DefIdMap, FnvHashMap};
 use rustc::dep_graph::DepNode;
 use rustc::hir::map as hir_map;
@@ -515,6 +517,13 @@ fn enforce_trait_manually_implementable(tcx: &TyCtxt, sp: Span, trait_def_id: De
     err.emit();
 }
 
+// Factored out into helper because the error cannot be defined in multiple locations.
+pub fn report_duplicate_item<'tcx>(tcx: &TyCtxt<'tcx>, sp: Span, name: ast::Name)
+                                   -> DiagnosticBuilder<'tcx>
+{
+    struct_span_err!(tcx.sess, sp, E0201, "duplicate definitions with name `{}`:", name)
+}
+
 pub fn check_coherence(crate_context: &CrateCtxt) {
     let _task = crate_context.tcx.dep_graph.in_task(DepNode::Coherence);
     let infcx = new_infer_ctxt(crate_context.tcx,

trunk/src/librustc_typeck/collect.rs

@@ -63,6 +63,7 @@ use lint;
 use hir::def::Def;
 use hir::def_id::DefId;
 use constrained_type_params as ctp;
+use coherence;
 use middle::lang_items::SizedTraitLangItem;
 use middle::resolve_lifetime;
 use middle::const_val::ConstVal;
@@ -79,14 +80,13 @@ use rscope::*;
 use rustc::dep_graph::DepNode;
 use rustc::hir::map as hir_map;
 use util::common::{ErrorReported, MemoizationMap};
-use util::nodemap::FnvHashMap;
+use util::nodemap::{FnvHashMap, FnvHashSet};
 use write_ty_to_tcx;
 
 use rustc_const_math::ConstInt;
 
 use std::cell::RefCell;
 use std::collections::HashSet;
-use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::rc::Rc;
 
 use syntax::abi;
@@ -746,27 +746,16 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) {
 
             // Convert all the associated consts.
             // Also, check if there are any duplicate associated items
-            let mut seen_type_items = FnvHashMap();
-            let mut seen_value_items = FnvHashMap();
+            let mut seen_type_items = FnvHashSet();
+            let mut seen_value_items = FnvHashSet();
 
             for impl_item in impl_items {
                 let seen_items = match impl_item.node {
                     hir::ImplItemKind::Type(_) => &mut seen_type_items,
                     _                    => &mut seen_value_items,
                 };
-                match seen_items.entry(impl_item.name) {
-                    Occupied(entry) => {
-                        let mut err = struct_span_err!(tcx.sess, impl_item.span, E0201,
-                                                       "duplicate definitions with name `{}`:",
-                                                       impl_item.name);
-                        span_note!(&mut err, *entry.get(),
-                                   "previous definition of `{}` here",
-                                   impl_item.name);
-                        err.emit();
-                    }
-                    Vacant(entry) => {
-                        entry.insert(impl_item.span);
-                    }
+                if !seen_items.insert(impl_item.name) {
+                    coherence::report_duplicate_item(tcx, impl_item.span, impl_item.name).emit();
                 }
 
                 if let hir::ImplItemKind::Const(ref ty, _) = impl_item.node {

trunk/src/librustc_typeck/diagnostics.rs

@@ -3405,37 +3405,6 @@ parameters. You can read more about it in the API documentation:
 https://doc.rust-lang.org/std/marker/struct.PhantomData.html
 "##,
 
-E0393: r##"
-A type parameter which references `Self` in its default value was not specified.
-Example of erroneous code:
-
-```compile_fail
-trait A<T=Self> {}
-
-fn together_we_will_rule_the_galaxy(son: &A) {}
-// error: the type parameter `T` must be explicitly specified in an
-//        object type because its default value `Self` references the
-//        type `Self`
-```
-
-A trait object is defined over a single, fully-defined trait. With a regular
-default parameter, this parameter can just be substituted in. However, if the
-default parameter is `Self`, the trait changes for each concrete type; i.e.
-`i32` will be expected to implement `A<i32>`, `bool` will be expected to
-implement `A<bool>`, etc... These types will not share an implementation of a
-fully-defined trait; instead they share implementations of a trait with
-different parameters substituted in for each implementation. This is
-irreconcilable with what we need to make a trait object work, and is thus
-disallowed. Making the trait concrete by explicitly specifying the value of the
-defaulted parameter will fix this issue. Fixed example:
-
-```
-trait A<T=Self> {}
-
-fn together_we_will_rule_the_galaxy(son: &A<i32>) {} // Ok!
-```
-"##,
-
 E0439: r##"
 The length of the platform-intrinsic function `simd_shuffle`
 wasn't specified. Erroneous code example:
@@ -3786,6 +3755,8 @@ register_diagnostics! {
            // between structures
     E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
            // between structures with the same definition
+    E0393, // the type parameter `{}` must be explicitly specified in an object
+           // type because its default value `{}` references the type `Self`"
     E0399, // trait items need to be implemented because the associated
            // type `{}` was overridden
     E0436, // functional record update requires a struct

trunk/src/librustdoc/clean/inline.rs

@@ -76,7 +76,6 @@ fn try_inline_def(cx: &DocContext, tcx: &TyCtxt,
     let inner = match def {
         Def::Trait(did) => {
             record_extern_fqn(cx, did, clean::TypeTrait);
-            ret.extend(build_impls(cx, tcx, did));
             clean::TraitItem(build_external_trait(cx, tcx, did))
         }
         Def::Fn(did) => {
@@ -248,10 +247,12 @@ pub fn build_impls(cx: &DocContext,
     // Primarily, the impls will be used to populate the documentation for this
     // type being inlined, but impls can also be used when generating
     // documentation for primitives (no way to find those specifically).
-    if cx.populated_crate_impls.borrow_mut().insert(did.krate) {
+    if !cx.all_crate_impls.borrow_mut().contains_key(&did.krate) {
+        let mut impls = Vec::new();
         for item in tcx.sess.cstore.crate_top_level_items(did.krate) {
             populate_impls(cx, tcx, item.def, &mut impls);
         }
+        cx.all_crate_impls.borrow_mut().insert(did.krate, impls);
 
         fn populate_impls(cx: &DocContext, tcx: &TyCtxt,
                           def: cstore::DefLike,
@@ -268,7 +269,21 @@ pub fn build_impls(cx: &DocContext,
         }
     }
 
-    impls
+    let mut candidates = cx.all_crate_impls.borrow_mut();
+    let candidates = candidates.get_mut(&did.krate).unwrap();
+    for i in (0..candidates.len()).rev() {
+        let remove = match candidates[i].inner {
+            clean::ImplItem(ref i) => {
+                i.for_.def_id() == Some(did) || i.for_.primitive_type().is_some()
+            }
+            _ => continue,
+        };
+        if remove {
+            impls.push(candidates.swap_remove(i));
+        }
+    }
+
+    return impls;
 }
 
 pub fn build_impl(cx: &DocContext,

trunk/src/librustdoc/clean/mod.rs

@@ -38,7 +38,7 @@ use rustc_trans::back::link;
 use rustc::middle::cstore::{self, CrateStore};
 use rustc::middle::privacy::AccessLevels;
 use rustc::hir::def::Def;
-use rustc::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
+use rustc::hir::def_id::{DefId, DefIndex};
 use rustc::ty::subst::{self, ParamSpace, VecPerParamSpace};
 use rustc::ty;
 use rustc::middle::stability;
@@ -2388,7 +2388,7 @@ impl Clean<Item> for doctree::ExternCrate {
             name: None,
             attrs: self.attrs.clean(cx),
             source: self.whence.clean(cx),
-            def_id: DefId { krate: self.cnum, index: CRATE_DEF_INDEX },
+            def_id: cx.map.local_def_id(0),
             visibility: self.vis.clean(cx),
             stability: None,
             deprecation: None,

trunk/src/librustdoc/core.rs

@@ -30,7 +30,7 @@ use syntax::feature_gate::UnstableFeatures;
 use syntax::parse::token;
 
 use std::cell::{RefCell, Cell};
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::rc::Rc;
 
 use visit_ast::RustdocVisitor;
@@ -54,7 +54,7 @@ pub struct DocContext<'a, 'tcx: 'a> {
     pub map: &'a hir_map::Map<'tcx>,
     pub maybe_typed: MaybeTyped<'a, 'tcx>,
     pub input: Input,
-    pub populated_crate_impls: RefCell<HashSet<ast::CrateNum>>,
+    pub all_crate_impls: RefCell<HashMap<ast::CrateNum, Vec<clean::Item>>>,
     pub deref_trait_did: Cell<Option<DefId>>,
     // Note that external items for which `doc(hidden)` applies to are shown as
     // non-reachable while local items aren't. This is because we're reusing
@@ -189,7 +189,7 @@ pub fn run_core(search_paths: SearchPaths,
             map: &tcx.map,
             maybe_typed: Typed(tcx),
             input: input,
-            populated_crate_impls: RefCell::new(HashSet::new()),
+            all_crate_impls: RefCell::new(HashMap::new()),
             deref_trait_did: Cell::new(None),
             access_levels: RefCell::new(access_levels),
             external_traits: RefCell::new(HashMap::new()),

trunk/src/librustdoc/doctree.rs

@@ -232,7 +232,6 @@ pub struct Macro {
 
 pub struct ExternCrate {
     pub name: Name,
-    pub cnum: ast::CrateNum,
     pub path: Option<String>,
     pub vis: hir::Visibility,
     pub attrs: hir::HirVec<ast::Attribute>,

trunk/src/librustdoc/html/format.rs

@@ -57,11 +57,6 @@ pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]);
 pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
 pub struct AbiSpace(pub Abi);
 
-pub struct HRef<'a> {
-    pub did: DefId,
-    pub text: &'a str,
-}
-
 impl<'a> VisSpace<'a> {
     pub fn get(self) -> &'a Option<clean::Visibility> {
         let VisSpace(v) = self; v
@@ -296,19 +291,17 @@ impl fmt::Display for clean::Path {
 
 pub fn href(did: DefId) -> Option<(String, ItemType, Vec<String>)> {
     let cache = cache();
-    if !did.is_local() && !cache.access_levels.is_doc_reachable(did) {
-        return None
-    }
-
     let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
     let &(ref fqp, shortty) = match cache.paths.get(&did) {
         Some(p) => p,
         None => return None,
     };
-
     let mut url = if did.is_local() || cache.inlined.contains(&did) {
         repeat("../").take(loc.len()).collect::<String>()
     } else {
+        if !cache.access_levels.is_doc_reachable(did) {
+            return None
+        }
         match cache.extern_locations[&did.krate] {
             (_, render::Remote(ref s)) => s.to_string(),
             (_, render::Local) => repeat("../").take(loc.len()).collect(),
@@ -368,7 +361,15 @@ fn resolved_path(w: &mut fmt::Formatter, did: DefId, path: &clean::Path,
             }
         }
     }
-    write!(w, "{}{}", HRef::new(did, &last.name), last.params)?;
+
+    match href(did) {
+        Some((url, shortty, fqp)) => {
+            write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
+                   shortty, url, fqp.join("::"), last.name)?;
+        }
+        _ => write!(w, "{}", last.name)?,
+    }
+    write!(w, "{}", last.params)?;
     Ok(())
 }
 
@@ -434,24 +435,6 @@ fn tybounds(w: &mut fmt::Formatter,
     }
 }
 
-impl<'a> HRef<'a> {
-    pub fn new(did: DefId, text: &'a str) -> HRef<'a> {
-        HRef { did: did, text: text }
-    }
-}
-
-impl<'a> fmt::Display for HRef<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match href(self.did) {
-            Some((url, shortty, fqp)) => {
-                write!(f, "<a class='{}' href='{}' title='{}'>{}</a>",
-                       shortty, url, fqp.join("::"), self.text)
-            }
-            _ => write!(f, "{}", self.text),
-        }
-    }
-}
-
 impl fmt::Display for clean::Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {