Implement Chalk's debug methods using TLS

Chalk now panics if we don't implement these methods and run with CHALK_DEBUG,
so I thought I'd try to implement them 'properly'. Sadly, it seems impossible to
do without transmuting lifetimes somewhere. The problem is that we need a `&dyn
HirDatabase` to get names etc., which we can't just put into TLS. I thought I
could just use `scoped-tls`, but that doesn't support references to unsized
types. So I put the `&dyn` into another struct and put the reference to *that*
into the TLS, but I have to transmute the lifetime to 'static for that to work.
I think this is sound, but I still don't really want to do it this way...

Author: flodiebold

Cargo.lock

@@ -21,6 +21,8 @@ ra_prof = { path = "../ra_prof" }
 ra_syntax = { path = "../ra_syntax" }
 test_utils = { path = "../test_utils" }
 
+scoped-tls = "1"
+
 chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "d383af7333cc6014e9d9e3e77668b5d5b0a5b40e" }
 chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "d383af7333cc6014e9d9e3e77668b5d5b0a5b40e" }
 chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "d383af7333cc6014e9d9e3e77668b5d5b0a5b40e" }

crates/ra_hir_ty/Cargo.toml

@@ -107,6 +107,78 @@ impl HirDisplay for &Ty {
     }
 }
 
+impl HirDisplay for TypeCtor {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
+        match *self {
+            TypeCtor::Bool => write!(f, "bool")?,
+            TypeCtor::Char => write!(f, "char")?,
+            TypeCtor::Int(t) => write!(f, "{}", t)?,
+            TypeCtor::Float(t) => write!(f, "{}", t)?,
+            TypeCtor::Str => write!(f, "str")?,
+            TypeCtor::Slice => write!(f, "[?]")?,
+            TypeCtor::Array => write!(f, "[?; _]")?,
+            TypeCtor::RawPtr(m) => write!(f, "*{} ?", m.as_keyword_for_ptr())?,
+            TypeCtor::Ref(m) => write!(f, "&{} ?", m.as_keyword_for_ref())?,
+            TypeCtor::Never => write!(f, "!")?,
+            TypeCtor::Tuple { cardinality } => {
+                if cardinality == 1 {
+                    write!(f, "(?,)")?;
+                } else {
+                    write!(f, "(")?;
+                    for _ in 0..cardinality {
+                        write!(f, "?,")?;
+                    }
+                    write!(f, ")")?;
+                }
+            }
+            TypeCtor::FnPtr { num_args } => {
+                write!(f, "fn(")?;
+                for _ in 0..num_args {
+                    write!(f, "?,")?;
+                }
+                write!(f, ") -> ?")?;
+            }
+            TypeCtor::FnDef(def) => {
+                let name = match def {
+                    CallableDef::FunctionId(ff) => f.db.function_data(ff).name.clone(),
+                    CallableDef::StructId(s) => f.db.struct_data(s).name.clone(),
+                    CallableDef::EnumVariantId(e) => {
+                        let enum_data = f.db.enum_data(e.parent);
+                        enum_data.variants[e.local_id].name.clone()
+                    }
+                };
+                match def {
+                    CallableDef::FunctionId(_) => write!(f, "fn {}", name)?,
+                    CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {
+                        write!(f, "{}", name)?
+                    }
+                }
+            }
+            TypeCtor::Adt(def_id) => {
+                let name = match def_id {
+                    AdtId::StructId(it) => f.db.struct_data(it).name.clone(),
+                    AdtId::UnionId(it) => f.db.union_data(it).name.clone(),
+                    AdtId::EnumId(it) => f.db.enum_data(it).name.clone(),
+                };
+                write!(f, "{}", name)?;
+            }
+            TypeCtor::AssociatedType(type_alias) => {
+                let trait_ = match type_alias.lookup(f.db.upcast()).container {
+                    AssocContainerId::TraitId(it) => it,
+                    _ => panic!("not an associated type"),
+                };
+                let trait_name = f.db.trait_data(trait_).name.clone();
+                let name = f.db.type_alias_data(type_alias).name.clone();
+                write!(f, "{}::{}", trait_name, name)?;
+            }
+            TypeCtor::Closure { def, expr } => {
+                write!(f, "{{closure {:?} in {:?}}}", expr, def)?;
+            }
+        }
+        Ok(())
+    }
+}
+
 impl HirDisplay for ApplicationTy {
     fn hir_fmt(&self, f: &mut HirFormatter) -> fmt::Result {
         if f.should_truncate() {
@@ -249,18 +321,21 @@ impl HirDisplay for ApplicationTy {
             }
             TypeCtor::Closure { .. } => {
                 let sig = self.parameters[0]
-                    .callable_sig(f.db)
-                    .expect("first closure parameter should contain signature");
-                let return_type_hint = sig.ret().display(f.db);
-                if sig.params().is_empty() {
-                    write!(f, "|| -> {}", return_type_hint)?;
-                } else if f.omit_verbose_types() {
-                    write!(f, "|{}| -> {}", TYPE_HINT_TRUNCATION, return_type_hint)?;
+                    .callable_sig(f.db);
+                if let Some(sig) = sig {
+                    let return_type_hint = sig.ret().display(f.db);
+                    if sig.params().is_empty() {
+                        write!(f, "|| -> {}", return_type_hint)?;
+                    } else if f.omit_verbose_types() {
+                        write!(f, "|{}| -> {}", TYPE_HINT_TRUNCATION, return_type_hint)?;
+                    } else {
+                        write!(f, "|")?;
+                        f.write_joined(sig.params(), ", ")?;
+                        write!(f, "| -> {}", return_type_hint)?;
+                    };
                 } else {
-                    write!(f, "|")?;
-                    f.write_joined(sig.params(), ", ")?;
-                    write!(f, "| -> {}", return_type_hint)?;
-                };
+                    self.ctor.hir_fmt(f)?;
+                }
             }
         }
         Ok(())

crates/ra_hir_ty/src/display.rs

@@ -173,14 +173,17 @@ fn solve(
 
     let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL);
 
-    let solution = solver.solve_limited(&context, goal, || {
+    let should_continue = || {
         context.db.check_canceled();
         let remaining = fuel.get();
         fuel.set(remaining - 1);
         if remaining == 0 {
             log::debug!("fuel exhausted");
         }
         remaining > 0
+    };
+    let solution = chalk::tls::set_current_program(db, || {
+        solver.solve_limited(&context, goal, should_continue)
     });
 
     log::debug!("solve({:?}) => {:?}", goal, solution);

crates/ra_hir_ty/src/traits.rs

@@ -17,6 +17,8 @@ use crate::{
     ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
 };
 
+pub(super) mod tls;
+
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
 
@@ -30,90 +32,85 @@ impl chalk_ir::interner::Interner for Interner {
     type Identifier = TypeAliasId;
     type DefId = InternId;
 
-    // FIXME: implement these
     fn debug_struct_id(
-        _type_kind_id: chalk_ir::StructId<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        type_kind_id: StructId,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))
     }
 
     fn debug_trait_id(
-        _type_kind_id: chalk_ir::TraitId<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        type_kind_id: TraitId,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt)))
     }
 
     fn debug_assoc_type_id(
-        _id: chalk_ir::AssocTypeId<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        id: AssocTypeId,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
     }
 
-    fn debug_alias(
-        _projection: &chalk_ir::AliasTy<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result> {
-        None
+    fn debug_alias(alias: &chalk_ir::AliasTy<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        tls::with_current_program(|prog| Some(prog?.debug_alias(alias, fmt)))
     }
 
-    fn debug_ty(_ty: &chalk_ir::Ty<Self>, _fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
-        None
+    fn debug_ty(ty: &chalk_ir::Ty<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        tls::with_current_program(|prog| Some(prog?.debug_ty(ty, fmt)))
     }
 
     fn debug_lifetime(
-        _lifetime: &chalk_ir::Lifetime<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        lifetime: &chalk_ir::Lifetime<Interner>,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_lifetime(lifetime, fmt)))
     }
 
     fn debug_parameter(
-        _parameter: &Parameter<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        parameter: &Parameter<Interner>,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_parameter(parameter, fmt)))
     }
 
-    fn debug_goal(_goal: &Goal<Self>, _fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
-        None
+    fn debug_goal(goal: &Goal<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        tls::with_current_program(|prog| Some(prog?.debug_goal(goal, fmt)))
     }
 
-    fn debug_goals(
-        _goals: &chalk_ir::Goals<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
-    ) -> Option<fmt::Result> {
-        None
+    fn debug_goals(goals: &chalk_ir::Goals<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+        tls::with_current_program(|prog| Some(prog?.debug_goals(goals, fmt)))
     }
 
     fn debug_program_clause_implication(
-        _pci: &chalk_ir::ProgramClauseImplication<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        pci: &chalk_ir::ProgramClauseImplication<Interner>,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_program_clause_implication(pci, fmt)))
     }
 
     fn debug_application_ty(
-        _application_ty: &chalk_ir::ApplicationTy<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        application_ty: &chalk_ir::ApplicationTy<Interner>,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_application_ty(application_ty, fmt)))
     }
 
     fn debug_substitution(
-        _substitution: &chalk_ir::Substitution<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        substitution: &chalk_ir::Substitution<Interner>,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| Some(prog?.debug_substitution(substitution, fmt)))
     }
 
     fn debug_separator_trait_ref(
-        _separator_trait_ref: &chalk_ir::SeparatorTraitRef<Self>,
-        _fmt: &mut fmt::Formatter<'_>,
+        separator_trait_ref: &chalk_ir::SeparatorTraitRef<Interner>,
+        fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
-        None
+        tls::with_current_program(|prog| {
+            Some(prog?.debug_separator_trait_ref(separator_trait_ref, fmt))
+        })
     }
 
     fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Box<chalk_ir::TyData<Self>> {