Merge pull request #366 from jackh726/debug

Use fallback debug impls instead of unimplemented

Author: nikomatsakis

chalk-ir/src/debug.rs

@@ -23,78 +23,63 @@ impl<I: Interner> Debug for AssocTypeId<I> {
 
 impl<I: Interner> Debug for Ty<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_ty(self, fmt)
-            .unwrap_or_else(|| unimplemented!("cannot format Ty without setting Program in tls"))
+        I::debug_ty(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
     }
 }
 
 impl<I: Interner> Debug for Lifetime<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_lifetime(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format Lifetime without setting Program in tls")
-        })
+        I::debug_lifetime(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
     }
 }
 
 impl<I: Interner> Debug for Parameter<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_parameter(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format Parameter without setting Program in tls")
-        })
+        I::debug_parameter(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.0))
     }
 }
 
 impl<I: Interner> Debug for Goal<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_goal(self, fmt)
-            .unwrap_or_else(|| unimplemented!("cannot format Goal without setting Program in tls"))
+        I::debug_goal(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
     }
 }
 
 impl<I: Interner> Debug for Goals<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_goals(self, fmt)
-            .unwrap_or_else(|| unimplemented!("cannot format Goals without setting Program in tls"))
+        I::debug_goals(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.goals))
     }
 }
 
 impl<I: Interner> Debug for ProgramClauseImplication<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_program_clause_implication(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format ProgramClauseImplication without setting Program in tls")
-        })
+        I::debug_program_clause_implication(self, fmt)
+            .unwrap_or_else(|| write!(fmt, "ProgramClauseImplication(?)"))
     }
 }
 
 impl<I: Interner> Debug for ApplicationTy<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_application_ty(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format ApplicationTy without setting Program in tls")
-        })
+        I::debug_application_ty(self, fmt).unwrap_or_else(|| write!(fmt, "ApplicationTy(?)"))
     }
 }
 
 impl<I: Interner> Debug for SeparatorTraitRef<'_, I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_separator_trait_ref(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format Substitution without setting Program in tls")
-        })
+        I::debug_separator_trait_ref(self, fmt)
+            .unwrap_or_else(|| write!(fmt, "SeparatorTraitRef(?)"))
     }
 }
 
 impl<I: Interner> Debug for AliasTy<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_alias(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format AliasTy without setting Program in tls")
-        })
+        I::debug_alias(self, fmt).unwrap_or_else(|| write!(fmt, "AliasTy(?)"))
     }
 }
 
 impl<I: Interner> Display for Substitution<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_substitution(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format Substitution without setting Program in tls")
-        })
+        I::debug_substitution(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.parameters))
     }
 }
 

chalk-ir/src/interner.rs

@@ -106,10 +106,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_struct_id(
         struct_id: StructId<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of a type-kind-id. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -118,17 +121,25 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
-    fn debug_trait_id(trait_id: TraitId<Self>, fmt: &mut fmt::Formatter<'_>)
-        -> Option<fmt::Result>;
+    #[allow(unused_variables)]
+    fn debug_trait_id(
+        trait_id: TraitId<Self>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of a type-kind-id. To get good
     /// results, this requires inspecting TLS, and is difficult to
     /// code without reference to a specific interner (and hence
     /// fully known types).
+    #[allow(unused_variables)]
     fn debug_assoc_type_id(
         type_id: AssocTypeId<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of an alias. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -137,7 +148,10 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
-    fn debug_alias(alias: &AliasTy<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
+    #[allow(unused_variables)]
+    fn debug_alias(alias: &AliasTy<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of an type. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -146,7 +160,10 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
-    fn debug_ty(ty: &Ty<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
+    #[allow(unused_variables)]
+    fn debug_ty(ty: &Ty<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of an lifetime. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -155,10 +172,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_lifetime(
         lifetime: &Lifetime<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of an parameter. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -167,10 +187,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_parameter(
         parameter: &Parameter<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of an goal. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -179,7 +202,10 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
-    fn debug_goal(goal: &Goal<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
+    #[allow(unused_variables)]
+    fn debug_goal(goal: &Goal<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of a list of goals. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -188,7 +214,10 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
-    fn debug_goals(goals: &Goals<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
+    #[allow(unused_variables)]
+    fn debug_goals(goals: &Goals<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of a ProgramClauseImplication. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -197,10 +226,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_program_clause_implication(
         pci: &ProgramClauseImplication<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of an ApplicationTy. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -209,10 +241,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_application_ty(
         application_ty: &ApplicationTy<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of a Substitution. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -221,10 +256,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_substitution(
         substitution: &Substitution<Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Prints the debug representation of a SeparatorTraitRef. To get good
     /// results, this requires inspecting TLS, and is difficult to
@@ -233,10 +271,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     ///
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
+    #[allow(unused_variables)]
     fn debug_separator_trait_ref(
-        separator_trait_ref: &SeparatorTraitRef<Self>,
+        separator_trait_ref: &SeparatorTraitRef<'_, Self>,
         fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result>;
+    ) -> Option<fmt::Result> {
+        None
+    }
 
     /// Create an "interned" type from `ty`. This is not normally
     /// invoked directly; instead, you invoke `TyData::intern` (which
@@ -433,7 +474,7 @@ mod default {
         }
 
         fn debug_separator_trait_ref(
-            separator_trait_ref: &SeparatorTraitRef<ChalkIr>,
+            separator_trait_ref: &SeparatorTraitRef<'_, ChalkIr>,
             fmt: &mut fmt::Formatter<'_>,
         ) -> Option<fmt::Result> {
             tls::with_current_program(|prog| {

chalk-ir/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(rust_2018_idioms)]
+
 use crate::cast::{Cast, CastTo};
 use crate::fold::shift::Shift;
 use crate::fold::{Fold, Folder, Subst, SuperFold};
@@ -178,6 +180,10 @@ impl<I: Interner> Ty<I> {
         }
     }
 
+    pub fn interned(&self) -> &I::InternedType {
+        &self.interned
+    }
+
     pub fn data(&self, interner: &I) -> &TyData<I> {
         I::ty_data(interner, &self.interned)
     }
@@ -577,6 +583,10 @@ impl<I: Interner> Lifetime<I> {
         }
     }
 
+    pub fn interned(&self) -> &I::InternedLifetime {
+        &self.interned
+    }
+
     pub fn data(&self, interner: &I) -> &LifetimeData<I> {
         I::lifetime_data(interner, &self.interned)
     }
@@ -749,6 +759,10 @@ impl<I: Interner> Parameter<I> {
         Parameter(interned)
     }
 
+    pub fn interned(&self) -> &I::InternedParameter {
+        &self.0
+    }
+
     pub fn data(&self, interner: &I) -> &ParameterData<I> {
         I::parameter_data(interner, &self.0)
     }
@@ -1277,6 +1291,10 @@ impl<I: Interner> Goals<I> {
         Self::from(interner, None::<Goal<I>>)
     }
 
+    pub fn interned(&self) -> &I::InternedGoals {
+        &self.goals
+    }
+
     pub fn from(interner: &I, goals: impl IntoIterator<Item = impl CastTo<Goal<I>>>) -> Self {
         use crate::cast::Caster;
         Goals {
@@ -1325,6 +1343,10 @@ impl<I: Interner> Goal<I> {
         Self { interned }
     }
 
+    pub fn interned(&self) -> &I::InternedGoal {
+        &self.interned
+    }
+
     pub fn data(&self, interner: &I) -> &GoalData<I> {
         interner.goal_data(&self.interned)
     }
@@ -1497,6 +1519,10 @@ impl<I: Interner> Substitution<I> {
         })
     }
 
+    pub fn interned(&self) -> &I::InternedSubstitution {
+        &self.parameters
+    }
+
     /// Index into the list of parameters
     pub fn at(&self, interner: &I, index: usize) -> &Parameter<I> {
         &self.parameters(interner)[index]

chalk-ir/src/tls.rs

@@ -82,7 +82,7 @@ pub trait DebugContext {
 
     fn debug_separator_trait_ref(
         &self,
-        separator_trait_ref: &SeparatorTraitRef<ChalkIr>,
+        separator_trait_ref: &SeparatorTraitRef<'_, ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 }

chalk-rust-ir/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(rust_2018_idioms)]
+
 //! Contains the definition for the "Rust IR" -- this is basically a "lowered"
 //! version of the AST, roughly corresponding to [the HIR] in the Rust
 //! compiler.

chalk-solve/src/clauses/builtin_traits.rs

@@ -7,7 +7,7 @@ use crate::{TraitRef, WellKnownTrait};
 pub fn add_builtin_program_clauses<I: Interner>(
     well_known: WellKnownTrait,
     _trait_ref: &TraitRef<I>,
-    _builder: &mut ClauseBuilder<I>,
+    _builder: &mut ClauseBuilder<'_, I>,
 ) {
     match well_known {
         WellKnownTrait::SizedTrait => { /* TODO */ }

chalk-solve/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(rust_2018_idioms)]
+
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use chalk_rust_ir::*;