fix: Don't panic when formatting without Program

chalk-integration/src/lowering/program_lowerer.rs

@@ -152,6 +152,7 @@ impl ProgramLowerer {
         let mut closure_upvars = BTreeMap::new();
         let mut trait_data = BTreeMap::new();
         let mut well_known_traits = BTreeMap::new();
+        let mut well_known_assoc_types = BTreeMap::new();
         let mut impl_data = BTreeMap::new();
         let mut associated_ty_data = BTreeMap::new();
         let mut associated_ty_values = BTreeMap::new();
@@ -272,6 +273,15 @@ impl ProgramLowerer {
                         let lookup = &self.associated_ty_lookups
                             [&(trait_id, assoc_ty_defn.name.str.clone())];
 
+                        if let Some(well_known) = assoc_ty_defn.well_known {
+                            let well_known = match well_known {
+                                chalk_parse::ast::WellKnownAssocType::AsyncFnOnceOutput => {
+                                    chalk_solve::rust_ir::WellKnownAssocType::AsyncFnOnceOutput
+                                }
+                            };
+                            well_known_assoc_types.insert(well_known, lookup.id);
+                        }
+
                         // The parameters in scope for the associated
                         // type definitions are *both* those from the
                         // trait *and* those from the associated type
@@ -494,6 +504,7 @@ impl ProgramLowerer {
             coroutine_witness_data,
             trait_data,
             well_known_traits,
+            well_known_assoc_types,
             impl_data,
             associated_ty_values,
             associated_ty_data,

chalk-integration/src/program.rs

@@ -11,7 +11,7 @@ use chalk_ir::{
 use chalk_solve::rust_ir::{
     AdtDatum, AdtRepr, AdtSizeAlign, AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId,
     ClosureKind, CoroutineDatum, CoroutineWitnessDatum, FnDefDatum, FnDefInputsAndOutputDatum,
-    ImplDatum, ImplType, OpaqueTyDatum, TraitDatum, WellKnownTrait,
+    ImplDatum, ImplType, OpaqueTyDatum, TraitDatum, WellKnownAssocType, WellKnownTrait,
 };
 use chalk_solve::split::Split;
 use chalk_solve::RustIrDatabase;
@@ -96,6 +96,9 @@ pub struct Program {
     /// For each trait lang item
     pub well_known_traits: BTreeMap<WellKnownTrait, TraitId<ChalkIr>>,
 
+    /// For each assoc type lang item
+    pub well_known_assoc_types: BTreeMap<WellKnownAssocType, AssocTypeId<ChalkIr>>,
+
     /// For each associated ty declaration `type Foo` found in a trait:
     pub associated_ty_data: BTreeMap<AssocTypeId<ChalkIr>, Arc<AssociatedTyDatum<ChalkIr>>>,
 
@@ -539,10 +542,9 @@ impl RustIrDatabase<ChalkIr> for Program {
 
     fn well_known_assoc_type_id(
         &self,
-        _assoc_type: chalk_solve::rust_ir::WellKnownAssocType,
+        assoc_type: WellKnownAssocType,
     ) -> Option<AssocTypeId<ChalkIr>> {
-        // FIXME
-        None
+        self.well_known_assoc_types.get(&assoc_type).copied()
     }
 
     fn program_clauses_for_env(

chalk-ir/src/debug.rs

@@ -152,17 +152,13 @@ impl<I: Interner> Debug for QuantifiedWhereClauses<I> {
 
 impl<I: Interner> Debug for ProjectionTy<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_projection_ty(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format ProjectionTy without setting Program in tls")
-        })
+        I::debug_projection_ty(self, fmt).unwrap_or_else(|| fmt.write_str("<ProjectionTy>"))
     }
 }
 
 impl<I: Interner> Debug for OpaqueTy<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_opaque_ty(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format OpaqueTy without setting Program in tls")
-        })
+        I::debug_opaque_ty(self, fmt).unwrap_or_else(|| fmt.write_str("<OpaqueTy>"))
     }
 }
 

chalk-parse/src/ast.rs

@@ -187,6 +187,12 @@ pub struct AssocTyDefn {
     pub variable_kinds: Vec<VariableKind>,
     pub bounds: Vec<QuantifiedInlineBound>,
     pub where_clauses: Vec<QuantifiedWhereClause>,
+    pub well_known: Option<WellKnownAssocType>,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum WellKnownAssocType {
+    AsyncFnOnceOutput,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -283,7 +283,12 @@ TraitDefn: TraitDefn = {
     }
 };
 
+WellKnownAssocType: WellKnownAssocType = {
+     "#" "[" "lang" "(" "async_fn_once_output" ")" "]" => WellKnownAssocType::AsyncFnOnceOutput,
+};
+
 AssocTyDefn: AssocTyDefn = {
+    <well_known:WellKnownAssocType?> 
     "type" <name:Id> <p:Angle<VariableKind>> <b:(":" <Plus<QuantifiedInlineBound>>)?>
         <w:QuantifiedWhereClauses> ";" =>
     {
@@ -292,6 +297,7 @@ AssocTyDefn: AssocTyDefn = {
             variable_kinds: p,
             where_clauses: w,
             bounds: b.unwrap_or(vec![]),
+            well_known,
         }
     }
 };

tests/test/closures.rs

@@ -170,6 +170,7 @@ fn closure_implements_fn_traits() {
             #[lang(async_fn_once)]
             trait AsyncFnOnce<Args> {
                 type CallOnceFuture: Future<Output = <Self as AsyncFnOnce<Args>>::Output>;
+                #[lang(async_fn_once_output)]
                 type Output;
             }
 

tests/test/fn_def.rs

@@ -88,6 +88,7 @@ fn fn_def_implements_fn_traits() {
             #[lang(async_fn_once)]
             trait AsyncFnOnce<Args> {
                 type CallOnceFuture: Future<Output = <Self as AsyncFnOnce<Args>>::Output>;
+                #[lang(async_fn_once_output)]
                 type Output;
             }
 
@@ -209,6 +210,7 @@ fn generic_fn_implements_fn_traits() {
             #[lang(async_fn_once)]
             trait AsyncFnOnce<Args> {
                 type CallOnceFuture: Future<Output = <Self as AsyncFnOnce<Args>>::Output>;
+                #[lang(async_fn_once_output)]
                 type Output;
             }
 

tests/test/functions.rs

@@ -67,6 +67,7 @@ fn function_implement_fn_traits() {
             #[lang(async_fn_once)]
             trait AsyncFnOnce<Args> {
                 type CallOnceFuture: Future<Output = <Self as AsyncFnOnce<Args>>::Output>;
+                #[lang(async_fn_once_output)]
                 type Output;
             }