Auto merge of #52438 - ljedrz:rustc_vec_capacity, r=<try>

Calculate Vec capacities in librustc

Calculate the required capacity of a few vectors in rustc based on the number of elements they are populated with.

Author: bors

src/librustc/infer/mod.rs

@@ -562,13 +562,16 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     }
 
     pub fn unsolved_variables(&self) -> Vec<Ty<'tcx>> {
-        let mut variables = Vec::new();
+        let unsolved_type_variables = self.type_variables.borrow_mut().unsolved_variables();
+        let mut variables = Vec::with_capacity(
+            unsolved_type_variables.len() +
+            self.int_unification_table.borrow().len() +
+            self.float_unification_table.borrow().len()
+        );
 
         {
-            let mut type_variables = self.type_variables.borrow_mut();
             variables.extend(
-                type_variables
-                    .unsolved_variables()
+                unsolved_type_variables
                     .into_iter()
                     .map(|t| self.tcx.mk_var(t)));
         }

src/librustc/middle/dead.rs

@@ -396,8 +396,12 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> {
 fn create_and_seed_worklist<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                       access_levels: &privacy::AccessLevels,
                                       krate: &hir::Crate)
-                                      -> Vec<ast::NodeId> {
-    let mut worklist = Vec::new();
+                                      -> Vec<ast::NodeId>
+{
+    let mut worklist = Vec::with_capacity(access_levels.map.len() +
+        if tcx.sess.entry_fn.borrow().is_some() { 1 } else { 0 }
+    );
+
     for (id, _) in &access_levels.map {
         worklist.push(*id);
     }

src/librustc_codegen_llvm/abi.rs

@@ -565,7 +565,13 @@ impl<'a, 'tcx> FnTypeExt<'a, 'tcx> for FnType<'tcx, Ty<'tcx>> {
     }
 
     fn llvm_type(&self, cx: &CodegenCx<'a, 'tcx>) -> Type {
-        let mut llargument_tys = Vec::new();
+        let args_capacity = self.args.iter().fold(0, |acc, a| acc +
+            if arg.pad.is_some() { 1 } else { 0 } +
+            if let PassMode::Pair(_) = arg.mode { 2 } else { 1 }
+        );
+        let mut llargument_tys = Vec::with_capacity(
+            if let PassMode::Indirect(_) = self.ret.mode { 1 } else { 0 } + args_capacity
+        );
 
         let llreturn_ty = match self.ret.mode {
             PassMode::Ignore => Type::void(cx),

src/librustc_driver/driver.rs

@@ -1353,8 +1353,18 @@ fn generated_output_paths(
     exact_name: bool,
     crate_name: &str,
 ) -> Vec<PathBuf> {
-    let mut out_filenames = Vec::new();
-    for output_type in sess.opts.output_types.keys() {
+    let output_types = sess.opts.output_types.keys();
+    let mut out_filenames = Vec::with_capacity(
+        output_types.iter().fold(0, |acc, ot| acc +
+            if ot == OutputType::DepInfo && sess.opts.debugging_opts.dep_info_omit_d_target {
+                0
+            } else {
+                1
+            }
+        )
+    );
+
+    for output_type in output_types {
         let file = outputs.path(*output_type);
         match *output_type {
             // If the filename has been overridden using `-o`, it will not be modified

src/librustc_typeck/astconv.rs

@@ -1464,7 +1464,12 @@ impl<'a, 'gcx, 'tcx> Bounds<'tcx> {
     pub fn predicates(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, param_ty: Ty<'tcx>)
                       -> Vec<ty::Predicate<'tcx>>
     {
-        let mut vec = Vec::new();
+        let mut vec = Vec::with_capacity(
+            if self.implicitly_sized && tcx.lang_items().sized_trait().is_some() { 1 } else { 0 } +
+            self.region_bounds.len() +
+            self.trait_bounds.len() +
+            self.projection_bounds.len()
+        );
 
         // If it could be sized, and is, add the sized predicate
         if self.implicitly_sized {