]>
Commit | Line | Data |
---|---|---|
f9f354fc XL |
1 | #![deny(rust_2018_idioms)] |
2 | ||
3dfed10e | 3 | use crate::display::sanitize_debug_name; |
f035d41b | 4 | use crate::rust_ir::*; |
f9f354fc | 5 | use chalk_ir::interner::Interner; |
f035d41b | 6 | |
f9f354fc | 7 | use chalk_ir::*; |
f9f354fc XL |
8 | use std::fmt::Debug; |
9 | use std::sync::Arc; | |
10 | ||
f9f354fc XL |
11 | pub mod clauses; |
12 | pub mod coherence; | |
3dfed10e XL |
13 | pub mod coinductive_goal; |
14 | pub mod display; | |
f9f354fc XL |
15 | pub mod ext; |
16 | pub mod goal_builder; | |
3dfed10e | 17 | pub mod infer; |
f035d41b | 18 | pub mod logging; |
3dfed10e | 19 | pub mod logging_db; |
f035d41b | 20 | pub mod rust_ir; |
3dfed10e | 21 | pub mod solve; |
f9f354fc XL |
22 | pub mod split; |
23 | pub mod wf; | |
24 | ||
3dfed10e XL |
25 | /// Trait representing access to a database of rust types. |
26 | /// | |
27 | /// # `*_name` methods | |
28 | /// | |
29 | /// This trait has a number of `*_name` methods with default implementations. | |
30 | /// These are used in the implementation for [`LoggingRustIrDatabase`], so that | |
31 | /// when printing `.chalk` files equivalent to the data used, we can use real | |
32 | /// names. | |
33 | /// | |
34 | /// The default implementations simply fall back to calling [`Interner`] debug | |
35 | /// methods, and printing `"UnknownN"` (where `N` is the demultiplexing integer) | |
36 | /// if those methods return `None`. | |
37 | /// | |
38 | /// The [`display::sanitize_debug_name`] utility is used in the default | |
39 | /// implementations, and might be useful when providing custom implementations. | |
40 | /// | |
41 | /// [`LoggingRustIrDatabase`]: crate::logging_db::LoggingRustIrDatabase | |
42 | /// [`display::sanitize_debug_name`]: crate::display::sanitize_debug_name | |
43 | /// [`Interner`]: Interner | |
f9f354fc XL |
44 | pub trait RustIrDatabase<I: Interner>: Debug { |
45 | /// Returns any "custom program clauses" that do not derive from | |
46 | /// Rust IR. Used only in testing the underlying solver. | |
47 | fn custom_clauses(&self) -> Vec<ProgramClause<I>>; | |
48 | ||
49 | /// Returns the datum for the associated type with the given id. | |
50 | fn associated_ty_data(&self, ty: AssocTypeId<I>) -> Arc<AssociatedTyDatum<I>>; | |
51 | ||
52 | /// Returns the datum for the definition with the given id. | |
53 | fn trait_datum(&self, trait_id: TraitId<I>) -> Arc<TraitDatum<I>>; | |
54 | ||
3dfed10e | 55 | /// Returns the datum for the ADT with the given id. |
f035d41b XL |
56 | fn adt_datum(&self, adt_id: AdtId<I>) -> Arc<AdtDatum<I>>; |
57 | ||
29967ef6 XL |
58 | /// Returns the generator datum for the generator with the given id. |
59 | fn generator_datum(&self, generator_id: GeneratorId<I>) -> Arc<GeneratorDatum<I>>; | |
60 | ||
61 | /// Returns the generator witness datum for the generator with the given id. | |
62 | fn generator_witness_datum( | |
63 | &self, | |
64 | generator_id: GeneratorId<I>, | |
65 | ) -> Arc<GeneratorWitnessDatum<I>>; | |
66 | ||
f035d41b XL |
67 | /// Returns the representation for the ADT definition with the given id. |
68 | fn adt_repr(&self, id: AdtId<I>) -> AdtRepr; | |
69 | ||
3dfed10e | 70 | /// Returns the datum for the fn definition with the given id. |
f035d41b | 71 | fn fn_def_datum(&self, fn_def_id: FnDefId<I>) -> Arc<FnDefDatum<I>>; |
f9f354fc XL |
72 | |
73 | /// Returns the datum for the impl with the given id. | |
74 | fn impl_datum(&self, impl_id: ImplId<I>) -> Arc<ImplDatum<I>>; | |
75 | ||
76 | /// Returns the `AssociatedTyValue` with the given id. | |
77 | fn associated_ty_value(&self, id: AssociatedTyValueId<I>) -> Arc<AssociatedTyValue<I>>; | |
78 | ||
79 | /// Returns the `OpaqueTyDatum` with the given id. | |
80 | fn opaque_ty_data(&self, id: OpaqueTyId<I>) -> Arc<OpaqueTyDatum<I>>; | |
81 | ||
f035d41b XL |
82 | /// Returns the "hidden type" corresponding with the opaque type. |
83 | fn hidden_opaque_type(&self, id: OpaqueTyId<I>) -> Ty<I>; | |
84 | ||
f9f354fc XL |
85 | /// Returns a list of potentially relevant impls for a given |
86 | /// trait-id; we also supply the type parameters that we are | |
87 | /// trying to match (if known: these parameters may contain | |
88 | /// inference variables, for example). The implementor is | |
89 | /// permitted to return any superset of the applicable impls; | |
90 | /// chalk will narrow down the list to only those that truly | |
91 | /// apply. The parameters are provided as a "hint" to help the | |
92 | /// implementor do less work, but can be completely ignored if | |
93 | /// desired. | |
3dfed10e XL |
94 | /// |
95 | /// The `binders` are for the `parameters`; if the recursive solver is used, | |
96 | /// the parameters can contain bound variables referring to these binders. | |
97 | fn impls_for_trait( | |
98 | &self, | |
99 | trait_id: TraitId<I>, | |
100 | parameters: &[GenericArg<I>], | |
101 | binders: &CanonicalVarKinds<I>, | |
102 | ) -> Vec<ImplId<I>>; | |
f9f354fc XL |
103 | |
104 | /// Returns the impls that require coherence checking. This is not the | |
105 | /// full set of impls that exist: | |
106 | /// | |
107 | /// - It can exclude impls not defined in the current crate. | |
108 | /// - It can exclude "built-in" impls, like those for closures; only the | |
109 | /// impls actually written by users need to be checked. | |
110 | fn local_impls_to_coherence_check(&self, trait_id: TraitId<I>) -> Vec<ImplId<I>>; | |
111 | ||
112 | /// Returns true if there is an explicit impl of the auto trait | |
29967ef6 | 113 | /// `auto_trait_id` for the type `ty`. This is part of |
f9f354fc | 114 | /// the auto trait handling -- if there is no explicit impl given |
29967ef6 | 115 | /// by the user for `ty`, then we provide default impls |
1b1a35ee | 116 | /// (otherwise, we rely on the impls the user gave). |
29967ef6 | 117 | fn impl_provided_for(&self, auto_trait_id: TraitId<I>, ty: &TyKind<I>) -> bool; |
f9f354fc | 118 | |
f9f354fc XL |
119 | /// Returns id of a trait lang item, if found |
120 | fn well_known_trait_id(&self, well_known_trait: WellKnownTrait) -> Option<TraitId<I>>; | |
121 | ||
122 | /// Calculates program clauses from an env. This is intended to call the | |
123 | /// `program_clauses_for_env` function and then possibly cache the clauses. | |
124 | fn program_clauses_for_env(&self, environment: &Environment<I>) -> ProgramClauses<I>; | |
125 | ||
126 | fn interner(&self) -> &I; | |
f035d41b XL |
127 | |
128 | /// Check if a trait is object safe | |
129 | fn is_object_safe(&self, trait_id: TraitId<I>) -> bool; | |
130 | ||
131 | /// Gets the `ClosureKind` for a given closure and substitution. | |
132 | fn closure_kind(&self, closure_id: ClosureId<I>, substs: &Substitution<I>) -> ClosureKind; | |
133 | ||
134 | /// Gets the inputs and output for a given closure id and substitution. We | |
135 | /// pass both the `ClosureId` and it's `Substituion` to give implementors | |
136 | /// the freedom to store associated data in the substitution (like rustc) or | |
137 | /// separately (like chalk-integration). | |
138 | fn closure_inputs_and_output( | |
139 | &self, | |
140 | closure_id: ClosureId<I>, | |
141 | substs: &Substitution<I>, | |
142 | ) -> Binders<FnDefInputsAndOutputDatum<I>>; | |
143 | ||
144 | /// Gets the upvars as a `Ty` for a given closure id and substitution. There | |
145 | /// are no restrictions on the type of upvars. | |
146 | fn closure_upvars(&self, closure_id: ClosureId<I>, substs: &Substitution<I>) -> Binders<Ty<I>>; | |
147 | ||
148 | /// Gets the substitution for the closure when used as a function. | |
149 | /// For example, for the following (not-quite-)rust code: | |
150 | /// ```ignore | |
151 | /// let foo = |a: &mut u32| { a += 1; }; | |
152 | /// let c: &'a u32 = &0; | |
153 | /// foo(c); | |
154 | /// ``` | |
155 | /// | |
156 | /// This would return a `Substitution` of `[&'a]`. This could either be | |
157 | /// substituted into the inputs and output, or into the upvars. | |
158 | fn closure_fn_substitution( | |
159 | &self, | |
160 | closure_id: ClosureId<I>, | |
161 | substs: &Substitution<I>, | |
162 | ) -> Substitution<I>; | |
3dfed10e XL |
163 | |
164 | /// Retrieves a trait's original name. No uniqueness guarantees, but must | |
165 | /// a valid Rust identifier. | |
166 | fn trait_name(&self, trait_id: TraitId<I>) -> String { | |
167 | sanitize_debug_name(|f| I::debug_trait_id(trait_id, f)) | |
168 | } | |
169 | ||
170 | /// Retrieves a struct's original name. No uniqueness guarantees, but must | |
171 | /// a valid Rust identifier. | |
172 | fn adt_name(&self, adt_id: AdtId<I>) -> String { | |
173 | sanitize_debug_name(|f| I::debug_adt_id(adt_id, f)) | |
174 | } | |
175 | ||
176 | /// Retrieves the name of an associated type. No uniqueness guarantees, but must | |
177 | /// a valid Rust identifier. | |
178 | fn assoc_type_name(&self, assoc_ty_id: AssocTypeId<I>) -> String { | |
179 | sanitize_debug_name(|f| I::debug_assoc_type_id(assoc_ty_id, f)) | |
180 | } | |
181 | ||
182 | /// Retrieves the name of an opaque type. No uniqueness guarantees, but must | |
183 | /// a valid Rust identifier. | |
184 | fn opaque_type_name(&self, opaque_ty_id: OpaqueTyId<I>) -> String { | |
185 | sanitize_debug_name(|f| I::debug_opaque_ty_id(opaque_ty_id, f)) | |
186 | } | |
187 | ||
188 | /// Retrieves the name of a function definition. No uniqueness guarantees, but must | |
189 | /// a valid Rust identifier. | |
190 | fn fn_def_name(&self, fn_def_id: FnDefId<I>) -> String { | |
191 | sanitize_debug_name(|f| I::debug_fn_def_id(fn_def_id, f)) | |
192 | } | |
f9f354fc XL |
193 | } |
194 | ||
195 | pub use clauses::program_clauses_for_env; | |
196 | ||
197 | pub use solve::Guidance; | |
198 | pub use solve::Solution; | |
199 | pub use solve::Solver; | |
f035d41b XL |
200 | pub use solve::SubstitutionResult; |
201 | ||
202 | #[macro_use] | |
203 | mod debug_macros { | |
204 | #[macro_export] | |
205 | macro_rules! debug_span { | |
206 | ($($t: tt)*) => { | |
207 | let __span = tracing::debug_span!($($t)*); | |
208 | let __span = __span.enter(); | |
209 | }; | |
210 | } | |
211 | } |