Introduce a global counter for inference variables. This *really

helps* for tracing an individual inference variable when debugging.

Author: nikomatsakis

src/librustc/middle/ty.rs

@@ -1111,7 +1111,8 @@ impl CLike for BuiltinBound {
 
 #[deriving(Clone, PartialEq, Eq, Hash)]
 pub struct TyVid {
-    pub index: uint
+    pub index: uint,
+    pub counter: uint,
 }
 
 #[deriving(Clone, PartialEq, Eq, Hash)]
@@ -1167,7 +1168,7 @@ impl cmp::PartialEq for InferRegion {
 
 impl fmt::Show for TyVid {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{
-        write!(f, "_#{}t", self.index)
+        write!(f, "_#{}/{}t", self.index, self.counter)
     }
 }
 

src/librustc/middle/typeck/infer/type_variable.rs

@@ -10,8 +10,15 @@
 
 use middle::ty;
 use std::mem;
+use std::sync::atomic;
 use util::snapshot_vec as sv;
 
+// Give each inference variable a unique stamp in addition to their
+// index into the array. This is really helpful for debugging, since
+// otherwise variable numbers get reused across functions and even
+// within functions, when transactions are in play.
+static GLOBAL_COUNTER: atomic::AtomicUint = atomic::INIT_ATOMIC_UINT;
+
 pub struct TypeVariableTable {
     values: sv::SnapshotVec<TypeVariableData,UndoEntry,Delegate>,
 }
@@ -114,11 +121,14 @@ impl TypeVariableTable {
     }
 
     pub fn new_var(&mut self, diverging: bool) -> ty::TyVid {
+        let counter = GLOBAL_COUNTER.fetch_add(1, atomic::SeqCst);
         let index = self.values.push(TypeVariableData {
             value: Bounded(vec![]),
             diverging: diverging
         });
-        ty::TyVid { index: index }
+        let vid = ty::TyVid { index: index, counter: counter };
+        debug!("Created new type variable: {}", vid);
+        vid
     }
 
     pub fn probe(&self, vid: ty::TyVid) -> Option<ty::t> {