Add DepNode::TraitSelectSingle variant.

This avoids the need for a heap allocation in the common case where the
`TraitSelect` has a single `D`.

Author: nnethercote

src/librustc/dep_graph/dep_node.rs

@@ -127,6 +127,11 @@ pub enum DepNode<D: Clone + Debug> {
     TraitItems(D),
     ReprHints(D),
     TraitSelect(Vec<D>),
+
+    // An optional alternative to `TraitSelect` that avoids a heap allocation
+    // in the case where there is a single D. (Note that `TraitSelect` is still
+    // allowed to contain a Vec with a single D.)
+    TraitSelectSingle(D),
 }
 
 impl<D: Clone + Debug> DepNode<D> {
@@ -232,6 +237,7 @@ impl<D: Clone + Debug> DepNode<D> {
                 let type_ds = try_opt!(type_ds.iter().map(|d| op(d)).collect());
                 Some(TraitSelect(type_ds))
             }
+            TraitSelectSingle(ref d) => op(d).map(TraitSelectSingle),
         }
     }
 }

src/librustc/ty/mod.rs

@@ -873,18 +873,26 @@ impl<'tcx> TraitPredicate<'tcx> {
         // `Rc<u32>: SomeTrait`, and `(Vec<u32>, Rc<u32>): SomeTrait`.
         // Note that it's always sound to conflate dep-nodes, it just
         // leads to more recompilation.
-        let def_ids: Vec<_> =
+        //
+        // This code is hot enough that it's worth going to some effort (i.e.
+        // the peek()) to use `TraitSelectSingle` and avoid a heap allocation
+        // when possible.
+        let mut def_ids_base =
             self.input_types()
                 .flat_map(|t| t.walk())
                 .filter_map(|t| match t.sty {
-                    ty::TyAdt(adt_def, _) =>
-                        Some(adt_def.did),
-                    _ =>
-                        None
+                    ty::TyAdt(adt_def, _) => Some(adt_def.did),
+                    _ => None
                 })
-                .chain(iter::once(self.def_id()))
-                .collect();
-        DepNode::TraitSelect(def_ids)
+                .peekable();
+        if let Some(_) = def_ids_base.peek() {
+            let def_ids = def_ids_base
+                          .chain(iter::once(self.def_id()))
+                          .collect();
+            DepNode::TraitSelect(def_ids)
+        } else {
+            DepNode::TraitSelectSingle(self.def_id())
+        }
     }
 
     pub fn input_types<'a>(&'a self) -> impl DoubleEndedIterator<Item=Ty<'tcx>> + 'a {

src/librustc_trans/context.rs

@@ -209,6 +209,8 @@ impl<'gcx> DepTrackingMapConfig for ProjectionCache<'gcx> {
                    _ => None,
                })
                .collect();
+        // This code is not hot so it's not worth detecting if
+        // `TraitSelectSingle` could be used instead of `TraitSelect`.
         DepNode::TraitSelect(def_ids)
     }
 }