.chalk file syntax writer

Cargo.toml

@@ -32,5 +32,8 @@ chalk-integration = { version = "0.16.0-dev.0", path = "chalk-integration" }
 [workspace]
 
 [dev-dependencies]
+# used for program_writer test errors
+diff = "0.1"
 pretty_assertions = "0.6.1"
+regex = "1"
 tracing = "0.1"

chalk-integration/src/db.rs

@@ -197,4 +197,24 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
             .unwrap()
             .closure_fn_substitution(closure_id, substs)
     }
+
+    fn trait_name(&self, trait_id: TraitId<ChalkIr>) -> String {
+        self.program_ir().unwrap().trait_name(trait_id)
+    }
+
+    fn adt_name(&self, struct_id: AdtId<ChalkIr>) -> String {
+        self.program_ir().unwrap().adt_name(struct_id)
+    }
+
+    fn assoc_type_name(&self, assoc_ty_id: AssocTypeId<ChalkIr>) -> String {
+        self.program_ir().unwrap().assoc_type_name(assoc_ty_id)
+    }
+
+    fn opaque_type_name(&self, opaque_ty_id: OpaqueTyId<ChalkIr>) -> String {
+        self.program_ir().unwrap().opaque_type_name(opaque_ty_id)
+    }
+
+    fn fn_def_name(&self, fn_def_id: FnDefId<ChalkIr>) -> String {
+        self.program_ir().unwrap().fn_def_name(fn_def_id)
+    }
 }

chalk-integration/src/program.rs

@@ -468,4 +468,32 @@ impl RustIrDatabase<ChalkIr> for Program {
     ) -> Substitution<ChalkIr> {
         substs.clone()
     }
+
+    fn trait_name(&self, trait_id: TraitId<ChalkIr>) -> String {
+        self.trait_kinds.get(&trait_id).unwrap().name.to_string()
+    }
+
+    fn adt_name(&self, struct_id: AdtId<ChalkIr>) -> String {
+        self.adt_kinds.get(&struct_id).unwrap().name.to_string()
+    }
+
+    fn assoc_type_name(&self, assoc_type_id: AssocTypeId<ChalkIr>) -> String {
+        self.associated_ty_data
+            .get(&assoc_type_id)
+            .unwrap()
+            .name
+            .to_string()
+    }
+
+    fn opaque_type_name(&self, opaque_ty_id: OpaqueTyId<ChalkIr>) -> String {
+        self.opaque_ty_kinds
+            .get(&opaque_ty_id)
+            .unwrap()
+            .name
+            .to_string()
+    }
+
+    fn fn_def_name(&self, fn_def_id: FnDefId<ChalkIr>) -> String {
+        self.fn_def_kinds.get(&fn_def_id).unwrap().name.to_string()
+    }
 }

chalk-ir/src/lib.rs

@@ -455,7 +455,7 @@ pub enum TyData<I: Interner> {
     /// an empty list).
     Apply(ApplicationTy<I>),
 
-    /// instantiated form a universally quantified type, e.g., from
+    /// instantiated from a universally quantified type, e.g., from
     /// `forall<T> { .. }`. Stands in as a representative of "some
     /// unknown type".
     Placeholder(PlaceholderIndex),

chalk-solve/src/display.rs

@@ -0,0 +1,213 @@
+use std::{
+    fmt::{Display, Result},
+    sync::Arc,
+};
+
+use crate::rust_ir::*;
+use chalk_ir::{interner::Interner, *};
+use itertools::Itertools;
+
+use crate::{logging_db::RecordedItemId, split::Split, RustIrDatabase};
+
+#[macro_use]
+mod utils;
+
+mod bounds;
+mod identifiers;
+mod items;
+mod render_trait;
+mod state;
+mod stub;
+mod ty;
+
+pub use self::render_trait::*;
+pub use self::state::*;
+
+use self::utils::as_display;
+
+pub fn write_item<F, I, T>(f: &mut F, ws: &WriterState<'_, I>, v: &T) -> Result
+where
+    F: std::fmt::Write + ?Sized,
+    I: Interner,
+    T: RenderAsRust<I>,
+{
+    write!(f, "{}\n", v.display(ws))
+}
+
+/// Writes stubs for items which were referenced by name, but for which we
+/// didn't directly access. For instance, traits mentioned in where bounds which
+/// are only usually checked during well-formedness, when we weren't recording
+/// well-formedness.
+///
+/// The "stub" nature of this means it writes output with the right names and
+/// the right number of generics, but nothing else. Where clauses, bounds, and
+/// fields are skipped. Associated types are ???? skipped.
+///
+/// `RecordedItemId::Impl` is not supported.
+pub fn write_stub_items<F, I, DB, T>(f: &mut F, db: &DB, ids: T) -> Result
+where
+    F: std::fmt::Write + ?Sized,
+    I: Interner,
+    DB: RustIrDatabase<I>,
+    T: IntoIterator<Item = RecordedItemId<I>>,
+{
+    write_items(f, &stub::StubWrapper::new(db), ids)
+}
+
+/// Writes out each item recorded by a [`LoggingRustIrDatabase`].
+///
+/// [`LoggingRustIrDatabase`]: crate::logging_db::LoggingRustIrDatabase
+pub fn write_items<F, I, DB, T>(f: &mut F, db: &DB, ids: T) -> Result
+where
+    F: std::fmt::Write + ?Sized,
+    I: Interner,
+    DB: RustIrDatabase<I>,
+    T: IntoIterator<Item = RecordedItemId<I>>,
+{
+    let ws = &WriterState::new(db);
+    for id in ids {
+        match id {
+            RecordedItemId::Impl(id) => {
+                let v = db.impl_datum(id);
+                write_item(f, ws, &*v)?;
+            }
+            RecordedItemId::Adt(id) => {
+                let v = db.adt_datum(id);
+                write_item(f, ws, &*v)?;
+            }
+            RecordedItemId::Trait(id) => {
+                let v = db.trait_datum(id);
+                write_item(f, ws, &*v)?;
+            }
+            RecordedItemId::OpaqueTy(id) => {
+                let v = db.opaque_ty_data(id);
+                write_item(f, ws, &*v)?;
+            }
+            RecordedItemId::FnDef(id) => {
+                let v = db.fn_def_datum(id);
+                write_item(f, ws, &*v)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Displays a set of bounds, all targeting `Self`, as just the trait names,
+/// separated by `+`.
+///
+/// For example, a list of quantified where clauses which would normally be
+/// displayed as:
+///
+/// ```notrust
+/// Self: A, Self: B, Self: C
+/// ```
+///
+/// Is instead displayed by this function as:
+///
+/// ```notrust
+/// A + B + C
+/// ```
+///
+/// Shared between the `Trait` in `dyn Trait` and [`OpaqueTyDatum`] bounds.
+fn display_self_where_clauses_as_bounds<'a, I: Interner>(
+    s: &'a WriterState<'a, I>,
+    bounds: &'a [QuantifiedWhereClause<I>],
+) -> impl Display + 'a {
+    as_display(move |f| {
+        let interner = s.db.interner();
+        write!(
+            f,
+            "{}",
+            bounds
+                .iter()
+                .map(|bound| {
+                    as_display(|f| {
+                        // each individual trait can have a forall
+                        let s = &s.add_debrujin_index(None);
+                        if !bound.binders.is_empty(interner) {
+                            write!(
+                                f,
+                                "forall<{}> ",
+                                s.binder_var_display(&bound.binders)
+                                    .collect::<Vec<_>>()
+                                    .join(", ")
+                            )?;
+                        }
+                        match &bound.skip_binders() {
+                            WhereClause::Implemented(trait_ref) => display_type_with_generics(
+                                s,
+                                trait_ref.trait_id,
+                                &trait_ref.substitution.parameters(interner)[1..],
+                            )
+                            .fmt(f),
+                            WhereClause::AliasEq(alias_eq) => match &alias_eq.alias {
+                                AliasTy::Projection(projection_ty) => {
+                                    let (assoc_ty_datum, trait_params, assoc_type_params) =
+                                        s.db.split_projection(&projection_ty);
+                                    display_trait_with_assoc_ty_value(
+                                        s,
+                                        assoc_ty_datum,
+                                        &trait_params[1..],
+                                        assoc_type_params,
+                                        &alias_eq.ty,
+                                    )
+                                    .fmt(f)
+                                }
+                                AliasTy::Opaque(_opaque) => todo!("opaque type AliasTy"),
+                            },
+                            WhereClause::LifetimeOutlives(lifetime) => lifetime.display(s).fmt(f),
+                        }
+                    })
+                    .to_string()
+                })
+                .format(" + ")
+        )
+    })
+}
+
+/// Displays a type with its parameters - something like `AsRef<T>`,
+/// OpaqueTyName<U>, or `AdtName<Value>`.
+///
+/// This is shared between where bounds, OpaqueTy, & dyn Trait.
+fn display_type_with_generics<'a, I: Interner>(
+    s: &'a WriterState<'a, I>,
+    trait_name: impl RenderAsRust<I> + 'a,
+    trait_params: impl IntoIterator<Item = &'a GenericArg<I>> + 'a,
+) -> impl Display + 'a {
+    use std::fmt::Write;
+    let trait_params = trait_params.into_iter().map(|param| param.display(s));
+    let mut trait_params_str = String::new();
+    write_joined_non_empty_list!(trait_params_str, "<{}>", trait_params, ", ").unwrap();
+    as_display(move |f| write!(f, "{}{}", trait_name.display(s), trait_params_str))
+}
+
+/// Displays a trait with its parameters and a single associated type -
+/// something like `IntoIterator<Item=T>`.
+///
+/// This is shared between where bounds & dyn Trait.
+fn display_trait_with_assoc_ty_value<'a, I: Interner>(
+    s: &'a WriterState<'a, I>,
+    assoc_ty_datum: Arc<AssociatedTyDatum<I>>,
+    trait_params: &'a [GenericArg<I>],
+    assoc_ty_params: &'a [GenericArg<I>],
+    assoc_ty_value: &'a Ty<I>,
+) -> impl Display + 'a {
+    as_display(move |f| {
+        write!(f, "{}<", assoc_ty_datum.trait_id.display(s))?;
+        write_joined_non_empty_list!(
+            f,
+            "{}, ",
+            trait_params.iter().map(|param| param.display(s)),
+            ", "
+        )?;
+        write!(f, "{}", assoc_ty_datum.id.display(s))?;
+        write_joined_non_empty_list!(
+            f,
+            "<{}>",
+            assoc_ty_params.iter().map(|param| param.display(s)),
+            ", "
+        )?;
+        write!(f, "={}>", assoc_ty_value.display(s))?;
+        Ok(())
+    })
+}