Rename ir::traversal::TypeCollector to ir::traversal::Trace

And its `collect_types` method to `trace`.

Author: fitzgen

src/ir/comp.rs

@@ -6,7 +6,7 @@ use super::derive::{CanDeriveCopy, CanDeriveDebug, CanDeriveDefault};
 use super::item::{Item, ItemSet};
 use super::layout::Layout;
 use super::ty::{TemplateDeclaration, Type};
-use super::traversal::TypeCollector;
+use super::traversal::Trace;
 use clang;
 use parse::{ClangItemParser, ParseError};
 use std::cell::Cell;
@@ -1075,10 +1075,10 @@ impl<'a> CanDeriveCopy<'a> for CompInfo {
     }
 }
 
-impl TypeCollector for CompInfo {
+impl Trace for CompInfo {
     type Extra = Item;
 
-    fn collect_types(&self,
+    fn trace(&self,
                      context: &BindgenContext,
                      types: &mut ItemSet,
                      item: &Item) {

src/ir/context.rs

@@ -5,7 +5,7 @@ use super::int::IntKind;
 use super::item::{Item, ItemSet, ItemCanonicalPath};
 use super::item_kind::ItemKind;
 use super::module::{Module, ModuleKind};
-use super::traversal::{ItemTraversal, TypeCollector};
+use super::traversal::{ItemTraversal, Trace};
 use super::ty::{FloatKind, TemplateDeclaration, Type, TypeKind};
 use BindgenOptions;
 use cexpr;
@@ -1393,7 +1393,7 @@ impl<'ctx, 'gen> Iterator for AssertNoDanglingItemIter<'ctx, 'gen>
         };
 
         let mut sub_types = ItemSet::new();
-        id.collect_types(self.ctx, &mut sub_types, &());
+        id.trace(self.ctx, &mut sub_types, &());
 
         if self.ctx.resolve_item_fallible(id).is_none() {
             let mut path = vec![];

src/ir/function.rs

@@ -3,7 +3,7 @@
 use super::context::{BindgenContext, ItemId};
 use super::item::{Item, ItemSet};
 use super::ty::TypeKind;
-use super::traversal::TypeCollector;
+use super::traversal::Trace;
 use clang;
 use clang_sys::CXCallingConv;
 use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
@@ -316,10 +316,10 @@ impl ClangSubItemParser for Function {
     }
 }
 
-impl TypeCollector for FunctionSig {
+impl Trace for FunctionSig {
     type Extra = Item;
 
-    fn collect_types(&self,
+    fn trace(&self,
                      _context: &BindgenContext,
                      types: &mut ItemSet,
                      _item: &Item) {

src/ir/item.rs

@@ -7,7 +7,7 @@ use super::function::Function;
 use super::item_kind::ItemKind;
 use super::module::Module;
 use super::ty::{TemplateDeclaration, Type, TypeKind};
-use super::traversal::TypeCollector;
+use super::traversal::Trace;
 use clang;
 use clang_sys;
 use parse::{ClangItemParser, ClangSubItemParser, ParseError, ParseResult};
@@ -167,21 +167,21 @@ impl ItemAncestors for Item {
     }
 }
 
-impl TypeCollector for ItemId {
+impl Trace for ItemId {
     type Extra = ();
 
-    fn collect_types(&self,
+    fn trace(&self,
                      ctx: &BindgenContext,
                      types: &mut ItemSet,
                      extra: &()) {
-        ctx.resolve_item(*self).collect_types(ctx, types, extra);
+        ctx.resolve_item(*self).trace(ctx, types, extra);
     }
 }
 
-impl TypeCollector for Item {
+impl Trace for Item {
     type Extra = ();
 
-    fn collect_types(&self,
+    fn trace(&self,
                      ctx: &BindgenContext,
                      types: &mut ItemSet,
                      _extra: &()) {
@@ -196,7 +196,7 @@ impl TypeCollector for Item {
                 // opaque.
                 if ty.should_be_traced_unconditionally() ||
                    !self.is_opaque(ctx) {
-                    ty.collect_types(ctx, types, self);
+                    ty.trace(ctx, types, self);
                 }
             }
             ItemKind::Function(ref fun) => {

src/ir/traversal.rs

@@ -4,15 +4,15 @@ use super::context::{BindgenContext, ItemId};
 use super::item::ItemSet;
 
 /// Collect all the type items referenced by this item.
-pub trait TypeCollector {
+pub trait Trace {
     /// If a particular type needs extra information beyond what it has in
     /// `self` and `context` to find its referenced type items, its
     /// implementation can define this associated type, forcing callers to pass
     /// the needed information through.
     type Extra;
 
     /// Add each type item referenced by `self` into the `types` set.
-    fn collect_types(&self,
+    fn trace(&self,
                      context: &BindgenContext,
                      types: &mut ItemSet,
                      extra: &Self::Extra);
@@ -78,7 +78,7 @@ impl<'ctx, 'gen> Iterator for ItemTraversal<'ctx, 'gen>
 
         if self.ctx.options().whitelist_recursively {
             let mut sub_types = ItemSet::new();
-            id.collect_types(self.ctx, &mut sub_types, &());
+            id.trace(self.ctx, &mut sub_types, &());
 
             for id in sub_types {
                 if self.seen.insert(id) {

src/ir/ty.rs

@@ -9,7 +9,7 @@ use super::int::IntKind;
 use super::item::{Item, ItemSet};
 use super::layout::Layout;
 use super::objc::ObjCInterface;
-use super::traversal::TypeCollector;
+use super::traversal::Trace;
 use clang::{self, Cursor};
 use parse::{ClangItemParser, ParseError, ParseResult};
 use std::mem;
@@ -1125,10 +1125,10 @@ impl Type {
     }
 }
 
-impl TypeCollector for Type {
+impl Trace for Type {
     type Extra = Item;
 
-    fn collect_types(&self,
+    fn trace(&self,
                      context: &BindgenContext,
                      types: &mut ItemSet,
                      item: &Item) {
@@ -1148,9 +1148,9 @@ impl TypeCollector for Type {
                     types.insert(item);
                 }
             }
-            TypeKind::Comp(ref ci) => ci.collect_types(context, types, item),
+            TypeKind::Comp(ref ci) => ci.trace(context, types, item),
             TypeKind::Function(ref sig) => {
-                sig.collect_types(context, types, item)
+                sig.trace(context, types, item)
             }
             TypeKind::Enum(ref en) => {
                 if let Some(repr) = en.repr() {