3 files changed, 10 insertions, 10 deletions
diff --git a/src/ir/analysis/derive_debug.rs b/src/ir/analysis/derive_debug.rs
index 4169485f..675317e9 100644
--- a/src/ir/analysis/derive_debug.rs
+++ b/src/ir/analysis/derive_debug.rs
@@ -34,7 +34,7 @@ use ir::comp::CompKind;
 ///   derived debug if any of the template arguments or template definition
 ///   cannot derive debug.
 #[derive(Debug, Clone)]
-pub struct CannotDeriveDebugAnalysis<'ctx, 'gen>
+pub struct CannotDeriveDebug<'ctx, 'gen>
     where 'gen: 'ctx
 {
     ctx: &'ctx BindgenContext<'gen>,
@@ -53,7 +53,7 @@ pub struct CannotDeriveDebugAnalysis<'ctx, 'gen>
     dependencies: HashMap<ItemId, Vec<ItemId>>,
 }
 
-impl<'ctx, 'gen> CannotDeriveDebugAnalysis<'ctx, 'gen> {
+impl<'ctx, 'gen> CannotDeriveDebug<'ctx, 'gen> {
     fn consider_edge(kind: EdgeKind) -> bool {
         match kind {
             // These are the only edges that can affect whether a type can derive
@@ -88,12 +88,12 @@ impl<'ctx, 'gen> CannotDeriveDebugAnalysis<'ctx, 'gen> {
     }
 }
 
-impl<'ctx, 'gen> MonotoneFramework for CannotDeriveDebugAnalysis<'ctx, 'gen> {
+impl<'ctx, 'gen> MonotoneFramework for CannotDeriveDebug<'ctx, 'gen> {
     type Node = ItemId;
     type Extra = &'ctx BindgenContext<'gen>;
     type Output = HashSet<ItemId>;
 
-    fn new(ctx: &'ctx BindgenContext<'gen>) -> CannotDeriveDebugAnalysis<'ctx, 'gen> {
+    fn new(ctx: &'ctx BindgenContext<'gen>) -> CannotDeriveDebug<'ctx, 'gen> {
         let cannot_derive_debug = HashSet::new();
         let mut dependencies = HashMap::new();
         let whitelisted_items: HashSet<_> = ctx.whitelisted_items().collect();
@@ -125,7 +125,7 @@ impl<'ctx, 'gen> MonotoneFramework for CannotDeriveDebugAnalysis<'ctx, 'gen> {
             }
         }
 
-        CannotDeriveDebugAnalysis {
+        CannotDeriveDebug {
             ctx: ctx,
             cannot_derive_debug: cannot_derive_debug,
             dependencies: dependencies,
@@ -297,8 +297,8 @@ impl<'ctx, 'gen> MonotoneFramework for CannotDeriveDebugAnalysis<'ctx, 'gen> {
     }
 }
 
-impl<'ctx, 'gen> From<CannotDeriveDebugAnalysis<'ctx, 'gen>> for HashSet<ItemId> {
-    fn from(analysis: CannotDeriveDebugAnalysis<'ctx, 'gen>) -> Self {
+impl<'ctx, 'gen> From<CannotDeriveDebug<'ctx, 'gen>> for HashSet<ItemId> {
+    fn from(analysis: CannotDeriveDebug<'ctx, 'gen>) -> Self {
         analysis.cannot_derive_debug
     }
 }
diff --git a/src/ir/analysis/mod.rs b/src/ir/analysis/mod.rs
index 589eb5f6..472b5dd3 100644
--- a/src/ir/analysis/mod.rs
+++ b/src/ir/analysis/mod.rs
@@ -41,7 +41,7 @@
 mod template_params;
 pub use self::template_params::UsedTemplateParameters;
 mod derive_debug;
-pub use self::derive_debug::CannotDeriveDebugAnalysis;
+pub use self::derive_debug::CannotDeriveDebug;
 
 use std::fmt;
 
diff --git a/src/ir/context.rs b/src/ir/context.rs
index 18c56ac9..2d69c16f 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -5,7 +5,7 @@ use super::int::IntKind;
 use super::item::{IsOpaque, Item, ItemAncestors, ItemCanonicalPath, ItemSet};
 use super::item_kind::ItemKind;
 use super::module::{Module, ModuleKind};
-use super::analysis::{analyze, UsedTemplateParameters, CannotDeriveDebugAnalysis};
+use super::analysis::{analyze, UsedTemplateParameters, CannotDeriveDebug};
 use super::template::{TemplateInstantiation, TemplateParameters};
 use super::traversal::{self, Edge, ItemTraversal};
 use super::ty::{FloatKind, Type, TypeKind};
@@ -1664,7 +1664,7 @@ impl<'ctx> BindgenContext<'ctx> {
     /// Compute whether we can derive debug.
     fn compute_cant_derive_debug(&mut self) {
         assert!(self.cant_derive_debug.is_none());
-        self.cant_derive_debug = Some(analyze::<CannotDeriveDebugAnalysis>(self));
+        self.cant_derive_debug = Some(analyze::<CannotDeriveDebug>(self));
     }
 
     /// Look up whether the item with `id` can