rest of huge changes from before

Author: pierwill

compiler/rustc_borrowck/src/region_infer/dump_mir.rs

@@ -71,8 +71,8 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             }
         }
 
-        let mut constraints: Vec<_> = self.constraints.outlives().iter().collect();
-        constraints.sort();
+        let constraints: Vec<_> = self.constraints.outlives().iter().collect();
+        // constraints.sort();
         for constraint in &constraints {
             let OutlivesConstraint { sup, sub, locations, category, variance_info: _ } = constraint;
             let (name, arg) = match locations {

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -611,8 +611,8 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     #[instrument(skip(self, _body), level = "debug")]
     fn propagate_constraints(&mut self, _body: &Body<'tcx>) {
         debug!("constraints={:#?}", {
-            let mut constraints: Vec<_> = self.constraints.outlives().iter().collect();
-            constraints.sort();
+            let constraints: Vec<_> = self.constraints.outlives().iter().collect();
+            // constraints.sort();
             constraints
                 .into_iter()
                 .map(|c| (c, self.constraint_sccs.scc(c.sup), self.constraint_sccs.scc(c.sub)))

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs

@@ -319,7 +319,64 @@ fn add_unused_functions<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) {
             continue;
         }
 
-        debug!("generating unused fn: {:?}", non_codegenned_def_id);
-        cx.define_unused_fn(non_codegenned_def_id);
+        if unused_def_ids_by_file.is_empty() {
+            // There are no unused functions with file names to add (in any CGU)
+            return;
+        }
+
+        // Each `CodegenUnit` (CGU) has its own function_coverage_map, and generates a specific binary
+        // with its own coverage map.
+        //
+        // Each covered function `Instance` can be included in only one coverage map, produced from a
+        // specific function_coverage_map, from a specific CGU.
+        //
+        // Since unused functions did not generate code, they are not associated with any CGU yet.
+        //
+        // To avoid injecting the unused functions in multiple coverage maps (for multiple CGUs)
+        // determine which function_coverage_map has the responsibility for publishing unreachable
+        // coverage, based on file name: For each unused function, find the CGU that generates the
+        // first function (based on sorted `DefId`) from the same file.
+        //
+        // Add a new `FunctionCoverage` to the `function_coverage_map`, with unreachable code regions
+        // for each region in it's MIR.
+
+        let mut first_covered_def_id_by_file: FxHashMap<Symbol, DefId> = FxHashMap::default();
+        for &def_id in codegenned_def_ids.iter() {
+            if let Some(covered_file_name) = tcx.covered_file_name(def_id) {
+                // Only add files known to have unused functions
+                if unused_def_ids_by_file.contains_key(covered_file_name) {
+                    first_covered_def_id_by_file.entry(*covered_file_name).or_insert(def_id);
+                }
+            }
+        }
+
+        // Get the set of def_ids with coverage regions, known by *this* CoverageContext.
+        let cgu_covered_def_ids: DefIdSet = match cx.coverage_context() {
+            Some(ctx) => ctx
+                .function_coverage_map
+                .borrow()
+                .keys()
+                .map(|&instance| instance.def.def_id())
+                .collect(),
+            None => return,
+        };
+
+        let cgu_covered_files: FxHashSet<Symbol> =
+            first_covered_def_id_by_file
+                .iter()
+                .filter_map(|(&file_name, def_id)| {
+                    if cgu_covered_def_ids.contains(def_id) { Some(file_name) } else { None }
+                })
+                .collect();
+
+        // For each file for which this CGU is responsible for adding unused function coverage,
+        // get the `def_id`s for each unused function (if any), define a synthetic function with a
+        // single LLVM coverage counter, and add the function's coverage `CodeRegion`s. to the
+        // function_coverage_map.
+        for covered_file_name in cgu_covered_files {
+            for def_id in unused_def_ids_by_file.remove(&covered_file_name).into_iter().flatten() {
+                cx.define_unused_fn(def_id);
+            }
+        }
     }
 }

compiler/rustc_const_eval/src/transform/validate.rs

@@ -446,7 +446,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     }
                 }
                 let all_len = self.place_cache.len();
-                self.place_cache.sort_unstable();
+                self.place_cache.sort_by_key(|b| b.local);
                 self.place_cache.dedup();
                 let has_duplicates = all_len != self.place_cache.len();
                 if has_duplicates {

compiler/rustc_infer/src/infer/mod.rs

@@ -35,7 +35,6 @@ use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 
 use std::cell::{Cell, Ref, RefCell};
-use std::collections::BTreeMap;
 use std::fmt;
 
 use self::combine::CombineFields;
@@ -1500,7 +1499,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         span: Span,
         lbrct: LateBoundRegionConversionTime,
         value: ty::Binder<'tcx, T>,
-    ) -> (T, BTreeMap<ty::BoundRegion, ty::Region<'tcx>>)
+    ) -> (T, FxHashMap<ty::BoundRegion, ty::Region<'tcx>>)
     where
         T: TypeFoldable<'tcx>,
     {

compiler/rustc_infer/src/infer/region_constraints/mod.rs

@@ -20,7 +20,6 @@ use rustc_middle::ty::{ReLateBound, ReVar};
 use rustc_middle::ty::{Region, RegionVid};
 use rustc_span::Span;
 
-use std::collections::BTreeMap;
 use std::ops::Range;
 use std::{cmp, fmt, mem};
 
@@ -90,7 +89,7 @@ pub type VarInfos = IndexVec<RegionVid, RegionVariableInfo>;
 pub struct RegionConstraintData<'tcx> {
     /// Constraints of the form `A <= B`, where either `A` or `B` can
     /// be a region variable (or neither, as it happens).
-    pub constraints: BTreeMap<Constraint<'tcx>, SubregionOrigin<'tcx>>,
+    pub constraints: FxHashMap<Constraint<'tcx>, SubregionOrigin<'tcx>>,
 
     /// Constraints of the form `R0 member of [R1, ..., Rn]`, meaning that
     /// `R0` must be equal to one of the regions `R1..Rn`. These occur
@@ -127,7 +126,7 @@ pub struct RegionConstraintData<'tcx> {
 }
 
 /// Represents a constraint that influences the inference process.
-#[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub enum Constraint<'tcx> {
     /// A region variable is a subregion of another.
     VarSubVar(RegionVid, RegionVid),

compiler/rustc_middle/Cargo.toml

@@ -29,7 +29,7 @@ rustc_index = { path = "../rustc_index" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_span = { path = "../rustc_span" }
-chalk-ir = "0.75.0"
+chalk-ir = "0.76.0"
 smallvec = { version = "1.6.1", features = ["union", "may_dangle"] }
 rustc_session = { path = "../rustc_session" }
 rustc_type_ir = { path = "../rustc_type_ir" }

compiler/rustc_middle/src/lib.rs

@@ -36,6 +36,7 @@
 #![feature(get_mut_unchecked)]
 #![feature(if_let_guard)]
 #![feature(map_first_last)]
+#![feature(negative_impls)]
 #![feature(never_type)]
 #![feature(extern_types)]
 #![feature(new_uninit)]

compiler/rustc_middle/src/mir/mod.rs

@@ -1841,7 +1841,7 @@ rustc_index::newtype_index! {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct PlaceRef<'tcx> {
     pub local: Local,
     pub projection: &'tcx [PlaceElem<'tcx>],

compiler/rustc_middle/src/query/mod.rs

@@ -1089,7 +1089,7 @@ rustc_queries! {
     }
 
     /// Return all `impl` blocks in the current crate.
-    query all_local_trait_impls(_: ()) -> &'tcx BTreeMap<DefId, Vec<LocalDefId>> {
+    query all_local_trait_impls(_: ()) -> &'tcx FxHashMap<DefId, Vec<LocalDefId>> {
         desc { "local trait impls" }
     }