incr.comp.: Use the awesome new '_ in a few places.

src/librustc/dep_graph/graph.rs

@@ -461,10 +461,10 @@ impl DepGraph {
         self.data.as_ref().and_then(|data| data.colors.borrow().get(dep_node).cloned())
     }
 
-    pub fn try_mark_green<'a, 'tcx>(&self,
+    pub fn try_mark_green<'tcx>(&self,
-                                    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                tcx: TyCtxt<'_, 'tcx, 'tcx>,
-                                    dep_node: &DepNode)
+                                dep_node: &DepNode)
-                                    -> Option<DepNodeIndex> {
+                                -> Option<DepNodeIndex> {
         debug!("try_mark_green({:?}) - BEGIN", dep_node);
         let data = self.data.as_ref().unwrap();
 

src/librustc/ty/maps/config.rs

@@ -31,9 +31,9 @@ pub(super) trait QueryDescription<'tcx>: QueryConfig {
         false
     }
 
-    fn try_load_from_disk<'a>(_: TyCtxt<'a, 'tcx, 'tcx>,
+    fn try_load_from_disk(_: TyCtxt<'_, 'tcx, 'tcx>,
-                              _: SerializedDepNodeIndex)
+                          _: SerializedDepNodeIndex)
-                              -> Option<Self::Value> {
+                          -> Option<Self::Value> {
         bug!("QueryDescription::load_from_disk() called for unsupport query.")
     }
 }
@@ -556,9 +556,9 @@ impl<'tcx> QueryDescription<'tcx> for queries::typeck_tables_of<'tcx> {
         def_id.is_local()
     }
 
-    fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    fn try_load_from_disk(tcx: TyCtxt<'_, 'tcx, 'tcx>,
-                              id: SerializedDepNodeIndex)
+                          id: SerializedDepNodeIndex)
-                              -> Option<Self::Value> {
+                          -> Option<Self::Value> {
         let typeck_tables: Option<ty::TypeckTables<'tcx>> = tcx
             .on_disk_query_result_cache
             .try_load_query_result(tcx, id);

src/librustc/ty/maps/on_disk_cache.rs

@@ -291,10 +291,10 @@ impl<'sess> OnDiskCache<'sess> {
 
     /// Returns the cached query result if there is something in the cache for
     /// the given SerializedDepNodeIndex. Otherwise returns None.
-    pub fn try_load_query_result<'a, 'tcx, T>(&self,
+    pub fn try_load_query_result<'tcx, T>(&self,
-                                              tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                          tcx: TyCtxt<'_, 'tcx, 'tcx>,
-                                              dep_node_index: SerializedDepNodeIndex)
+                                          dep_node_index: SerializedDepNodeIndex)
-                                              -> Option<T>
+                                          -> Option<T>
         where T: Decodable
     {
         self.load_indexed(tcx,
@@ -319,13 +319,13 @@ impl<'sess> OnDiskCache<'sess> {
         x.extend(diagnostics.into_iter());
     }
 
-    fn load_indexed<'a, 'tcx, T>(&self,
+    fn load_indexed<'tcx, T>(&self,
-                                 tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                             tcx: TyCtxt<'_, 'tcx, 'tcx>,
-                                 dep_node_index: SerializedDepNodeIndex,
+                             dep_node_index: SerializedDepNodeIndex,
-                                 index: &FxHashMap<SerializedDepNodeIndex,
+                             index: &FxHashMap<SerializedDepNodeIndex,
-                                                   AbsoluteBytePos>,
+                                               AbsoluteBytePos>,
-                                 debug_tag: &'static str)
+                             debug_tag: &'static str)
-                                 -> Option<T>
+                             -> Option<T>
         where T: Decodable
     {
         let pos = if let Some(&pos) = index.get(&dep_node_index) {