rustc_middle/traits/
mod.rs

1//! Trait Resolution. See the [rustc dev guide] for more information on how this works.
2//!
3//! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/resolution.html
4
5pub mod query;
6pub mod select;
7pub mod solve;
8pub mod specialization_graph;
9mod structural_impls;
10
11use std::borrow::Cow;
12use std::hash::{Hash, Hasher};
13use std::sync::Arc;
14
15use rustc_errors::{Applicability, Diag, EmissionGuarantee, ErrorGuaranteed};
16use rustc_hir as hir;
17use rustc_hir::HirId;
18use rustc_hir::def_id::DefId;
19use rustc_macros::{
20    Decodable, Encodable, HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable,
21};
22use rustc_span::def_id::{CRATE_DEF_ID, LocalDefId};
23use rustc_span::{DUMMY_SP, Span, Symbol};
24use smallvec::{SmallVec, smallvec};
25use thin_vec::ThinVec;
26
27pub use self::select::{EvaluationCache, EvaluationResult, OverflowError, SelectionCache};
28use crate::mir::ConstraintCategory;
29pub use crate::traits::solve::BuiltinImplSource;
30use crate::ty::abstract_const::NotConstEvaluatable;
31use crate::ty::{self, AdtKind, GenericArgsRef, Ty};
32
33/// The reason why we incurred this obligation; used for error reporting.
34///
35/// Non-misc `ObligationCauseCode`s are stored on the heap. This gives the
36/// best trade-off between keeping the type small (which makes copies cheaper)
37/// while not doing too many heap allocations.
38///
39/// We do not want to intern this as there are a lot of obligation causes which
40/// only live for a short period of time.
41#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
42#[derive(TypeVisitable, TypeFoldable)]
43pub struct ObligationCause<'tcx> {
44    pub span: Span,
45
46    /// The ID of the fn body that triggered this obligation. This is
47    /// used for region obligations to determine the precise
48    /// environment in which the region obligation should be evaluated
49    /// (in particular, closures can add new assumptions). See the
50    /// field `region_obligations` of the `FulfillmentContext` for more
51    /// information.
52    pub body_id: LocalDefId,
53
54    code: ObligationCauseCodeHandle<'tcx>,
55}
56
57// This custom hash function speeds up hashing for `Obligation` deduplication
58// greatly by skipping the `code` field, which can be large and complex. That
59// shouldn't affect hash quality much since there are several other fields in
60// `Obligation` which should be unique enough, especially the predicate itself
61// which is hashed as an interned pointer. See #90996.
62impl Hash for ObligationCause<'_> {
63    fn hash<H: Hasher>(&self, state: &mut H) {
64        self.body_id.hash(state);
65        self.span.hash(state);
66    }
67}
68
69impl<'tcx> ObligationCause<'tcx> {
70    #[inline]
71    pub fn new(
72        span: Span,
73        body_id: LocalDefId,
74        code: ObligationCauseCode<'tcx>,
75    ) -> ObligationCause<'tcx> {
76        ObligationCause { span, body_id, code: code.into() }
77    }
78
79    pub fn misc(span: Span, body_id: LocalDefId) -> ObligationCause<'tcx> {
80        ObligationCause::new(span, body_id, ObligationCauseCode::Misc)
81    }
82
83    #[inline(always)]
84    pub fn dummy() -> ObligationCause<'tcx> {
85        ObligationCause::dummy_with_span(DUMMY_SP)
86    }
87
88    #[inline(always)]
89    pub fn dummy_with_span(span: Span) -> ObligationCause<'tcx> {
90        ObligationCause { span, body_id: CRATE_DEF_ID, code: Default::default() }
91    }
92
93    #[inline]
94    pub fn code(&self) -> &ObligationCauseCode<'tcx> {
95        &self.code
96    }
97
98    pub fn map_code(
99        &mut self,
100        f: impl FnOnce(ObligationCauseCodeHandle<'tcx>) -> ObligationCauseCode<'tcx>,
101    ) {
102        self.code = f(std::mem::take(&mut self.code)).into();
103    }
104
105    pub fn derived_cause(
106        mut self,
107        parent_trait_pred: ty::PolyTraitPredicate<'tcx>,
108        variant: impl FnOnce(DerivedCause<'tcx>) -> ObligationCauseCode<'tcx>,
109    ) -> ObligationCause<'tcx> {
110        /*!
111         * Creates a cause for obligations that are derived from
112         * `obligation` by a recursive search (e.g., for a builtin
113         * bound, or eventually a `auto trait Foo`). If `obligation`
114         * is itself a derived obligation, this is just a clone, but
115         * otherwise we create a "derived obligation" cause so as to
116         * keep track of the original root obligation for error
117         * reporting.
118         */
119
120        // NOTE(flaper87): As of now, it keeps track of the whole error
121        // chain. Ideally, we should have a way to configure this either
122        // by using -Z verbose-internals or just a CLI argument.
123        self.code = variant(DerivedCause { parent_trait_pred, parent_code: self.code }).into();
124        self
125    }
126
127    pub fn derived_host_cause(
128        mut self,
129        parent_host_pred: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
130        variant: impl FnOnce(DerivedHostCause<'tcx>) -> ObligationCauseCode<'tcx>,
131    ) -> ObligationCause<'tcx> {
132        self.code = variant(DerivedHostCause { parent_host_pred, parent_code: self.code }).into();
133        self
134    }
135
136    pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx> {
137        match self.code() {
138            ObligationCauseCode::MatchImpl(cause, _) => cause.to_constraint_category(),
139            ObligationCauseCode::AscribeUserTypeProvePredicate(predicate_span) => {
140                ConstraintCategory::Predicate(*predicate_span)
141            }
142            _ => ConstraintCategory::BoringNoLocation,
143        }
144    }
145}
146
147/// A compact form of `ObligationCauseCode`.
148#[derive(Clone, PartialEq, Eq, Default, HashStable)]
149#[derive(TypeVisitable, TypeFoldable, TyEncodable, TyDecodable)]
150pub struct ObligationCauseCodeHandle<'tcx> {
151    /// `None` for `ObligationCauseCode::Misc` (a common case, occurs ~60% of
152    /// the time). `Some` otherwise.
153    code: Option<Arc<ObligationCauseCode<'tcx>>>,
154}
155
156impl<'tcx> std::fmt::Debug for ObligationCauseCodeHandle<'tcx> {
157    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158        let cause: &ObligationCauseCode<'_> = self;
159        cause.fmt(f)
160    }
161}
162
163impl<'tcx> ObligationCauseCode<'tcx> {
164    #[inline(always)]
165    fn into(self) -> ObligationCauseCodeHandle<'tcx> {
166        ObligationCauseCodeHandle {
167            code: if let ObligationCauseCode::Misc = self { None } else { Some(Arc::new(self)) },
168        }
169    }
170}
171
172impl<'tcx> std::ops::Deref for ObligationCauseCodeHandle<'tcx> {
173    type Target = ObligationCauseCode<'tcx>;
174
175    fn deref(&self) -> &Self::Target {
176        self.code.as_deref().unwrap_or(&ObligationCauseCode::Misc)
177    }
178}
179
180#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
181#[derive(TypeVisitable, TypeFoldable)]
182pub enum ObligationCauseCode<'tcx> {
183    /// Not well classified or should be obvious from the span.
184    Misc,
185
186    /// A slice or array is WF only if `T: Sized`.
187    SliceOrArrayElem,
188
189    /// An array `[T; N]` can only be indexed (and is only well-formed if) `N` has type usize.
190    ArrayLen(Ty<'tcx>),
191
192    /// A tuple is WF only if its middle elements are `Sized`.
193    TupleElem,
194
195    /// Represents a clause that comes from a specific item.
196    /// The span corresponds to the clause.
197    WhereClause(DefId, Span),
198
199    /// Represents a bound for an opaque we are checking the well-formedness of.
200    /// The def-id corresponds to a specific definition site that we found the
201    /// hidden type from, if any.
202    OpaqueTypeBound(Span, Option<LocalDefId>),
203
204    /// Like `WhereClause`, but also identifies the expression
205    /// which requires the `where` clause to be proven, and also
206    /// identifies the index of the predicate in the `predicates_of`
207    /// list of the item.
208    WhereClauseInExpr(DefId, Span, HirId, usize),
209
210    /// Like `WhereClauseinExpr`, but indexes into the `const_conditions`
211    /// rather than the `predicates_of`.
212    HostEffectInExpr(DefId, Span, HirId, usize),
213
214    /// A type like `&'a T` is WF only if `T: 'a`.
215    ReferenceOutlivesReferent(Ty<'tcx>),
216
217    /// A type like `Box<Foo<'a> + 'b>` is WF only if `'b: 'a`.
218    ObjectTypeBound(Ty<'tcx>, ty::Region<'tcx>),
219
220    /// Obligation incurred due to a coercion.
221    Coercion {
222        source: Ty<'tcx>,
223        target: Ty<'tcx>,
224    },
225
226    /// Various cases where expressions must be `Sized` / `Copy` / etc.
227    /// `L = X` implies that `L` is `Sized`.
228    AssignmentLhsSized,
229    /// `(x1, .., xn)` must be `Sized`.
230    TupleInitializerSized,
231    /// `S { ... }` must be `Sized`.
232    StructInitializerSized,
233    /// Type of each variable must be `Sized`.
234    VariableType(HirId),
235    /// Argument type must be `Sized`.
236    SizedArgumentType(Option<HirId>),
237    /// Return type must be `Sized`.
238    SizedReturnType,
239    /// Return type of a call expression must be `Sized`.
240    SizedCallReturnType,
241    /// Yield type must be `Sized`.
242    SizedYieldType,
243    /// Inline asm operand type must be `Sized`.
244    InlineAsmSized,
245    /// Captured closure type must be `Sized`.
246    SizedClosureCapture(LocalDefId),
247    /// Types live across coroutine yields must be `Sized`.
248    SizedCoroutineInterior(LocalDefId),
249    /// `[expr; N]` requires `type_of(expr): Copy`.
250    RepeatElementCopy {
251        /// If element is a `const fn` or const ctor we display a help message suggesting
252        /// to move it to a new `const` item while saying that `T` doesn't implement `Copy`.
253        is_constable: IsConstable,
254
255        /// Span of the repeat element.
256        ///
257        /// This is used to suggest wrapping it in a `const { ... }` block.
258        elt_span: Span,
259    },
260
261    /// Types of fields (other than the last, except for packed structs) in a struct must be sized.
262    FieldSized {
263        adt_kind: AdtKind,
264        span: Span,
265        last: bool,
266    },
267
268    /// Constant expressions must be sized.
269    SizedConstOrStatic,
270
271    /// `static` items must have `Sync` type.
272    SharedStatic,
273
274    /// Derived obligation (i.e. theoretical `where` clause) on a built-in
275    /// implementation like `Copy` or `Sized`.
276    BuiltinDerived(DerivedCause<'tcx>),
277
278    /// Derived obligation (i.e. `where` clause) on an user-provided impl
279    /// or a trait alias.
280    ImplDerived(Box<ImplDerivedCause<'tcx>>),
281
282    /// Derived obligation for WF goals.
283    WellFormedDerived(DerivedCause<'tcx>),
284
285    /// Derived obligation (i.e. `where` clause) on an user-provided impl
286    /// or a trait alias.
287    ImplDerivedHost(Box<ImplDerivedHostCause<'tcx>>),
288
289    /// Derived obligation (i.e. `where` clause) on an user-provided impl
290    /// or a trait alias.
291    BuiltinDerivedHost(DerivedHostCause<'tcx>),
292
293    /// Derived obligation refined to point at a specific argument in
294    /// a call or method expression.
295    FunctionArg {
296        /// The node of the relevant argument in the function call.
297        arg_hir_id: HirId,
298        /// The node of the function call.
299        call_hir_id: HirId,
300        /// The obligation introduced by this argument.
301        parent_code: ObligationCauseCodeHandle<'tcx>,
302    },
303
304    /// Error derived when checking an impl item is compatible with
305    /// its corresponding trait item's definition
306    CompareImplItem {
307        impl_item_def_id: LocalDefId,
308        trait_item_def_id: DefId,
309        kind: ty::AssocKind,
310    },
311
312    /// Checking that the bounds of a trait's associated type hold for a given impl
313    CheckAssociatedTypeBounds {
314        impl_item_def_id: LocalDefId,
315        trait_item_def_id: DefId,
316    },
317
318    /// Checking that this expression can be assigned to its target.
319    ExprAssignable,
320
321    /// Computing common supertype in the arms of a match expression
322    MatchExpressionArm(Box<MatchExpressionArmCause<'tcx>>),
323
324    /// Type error arising from type checking a pattern against an expected type.
325    Pattern {
326        /// The span of the scrutinee or type expression which caused the `root_ty` type.
327        span: Option<Span>,
328        /// The root expected type induced by a scrutinee or type expression.
329        root_ty: Ty<'tcx>,
330        /// Information about the `Span`, if it came from an expression, otherwise `None`.
331        origin_expr: Option<PatternOriginExpr>,
332    },
333
334    /// Computing common supertype in an if expression
335    IfExpression(Box<IfExpressionCause<'tcx>>),
336
337    /// Computing common supertype of an if expression with no else counter-part
338    IfExpressionWithNoElse,
339
340    /// `main` has wrong type
341    MainFunctionType,
342
343    /// language function has wrong type
344    LangFunctionType(Symbol),
345
346    /// Intrinsic has wrong type
347    IntrinsicType,
348
349    /// A let else block does not diverge
350    LetElse,
351
352    /// Method receiver
353    MethodReceiver,
354
355    /// `return` with no expression
356    ReturnNoExpression,
357
358    /// `return` with an expression
359    ReturnValue(HirId),
360
361    /// Opaque return type of this function
362    OpaqueReturnType(Option<(Ty<'tcx>, HirId)>),
363
364    /// Block implicit return
365    BlockTailExpression(HirId, hir::MatchSource),
366
367    /// #[feature(trivial_bounds)] is not enabled
368    TrivialBound,
369
370    AwaitableExpr(HirId),
371
372    ForLoopIterator,
373
374    QuestionMark,
375
376    /// Well-formed checking. If a `WellFormedLoc` is provided,
377    /// then it will be used to perform HIR-based wf checking
378    /// after an error occurs, in order to generate a more precise error span.
379    /// This is purely for diagnostic purposes - it is always
380    /// correct to use `Misc` instead, or to specify
381    /// `WellFormed(None)`.
382    WellFormed(Option<WellFormedLoc>),
383
384    /// From `match_impl`. The cause for us having to match an impl, and the DefId we are matching
385    /// against.
386    MatchImpl(ObligationCause<'tcx>, DefId),
387
388    BinOp {
389        lhs_hir_id: HirId,
390        rhs_hir_id: Option<HirId>,
391        rhs_span: Option<Span>,
392        rhs_is_lit: bool,
393        output_ty: Option<Ty<'tcx>>,
394    },
395
396    AscribeUserTypeProvePredicate(Span),
397
398    RustCall,
399
400    /// Obligations to prove that a `Drop` or negative auto trait impl is not stronger than
401    /// the ADT it's being implemented for.
402    AlwaysApplicableImpl,
403
404    /// Requirement for a `const N: Ty` to implement `Ty: ConstParamTy`
405    ConstParam(Ty<'tcx>),
406
407    /// Obligations emitted during the normalization of a weak type alias.
408    TypeAlias(ObligationCauseCodeHandle<'tcx>, Span, DefId),
409}
410
411/// Whether a value can be extracted into a const.
412/// Used for diagnostics around array repeat expressions.
413#[derive(Copy, Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
414pub enum IsConstable {
415    No,
416    /// Call to a const fn
417    Fn,
418    /// Use of a const ctor
419    Ctor,
420}
421
422/// The 'location' at which we try to perform HIR-based wf checking.
423/// This information is used to obtain an `hir::Ty`, which
424/// we can walk in order to obtain precise spans for any
425/// 'nested' types (e.g. `Foo` in `Option<Foo>`).
426#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable, Encodable, Decodable)]
427#[derive(TypeVisitable, TypeFoldable)]
428pub enum WellFormedLoc {
429    /// Use the type of the provided definition.
430    Ty(LocalDefId),
431    /// Use the type of the parameter of the provided function.
432    /// We cannot use `hir::Param`, since the function may
433    /// not have a body (e.g. a trait method definition)
434    Param {
435        /// The function to lookup the parameter in
436        function: LocalDefId,
437        /// The index of the parameter to use.
438        /// Parameters are indexed from 0, with the return type
439        /// being the last 'parameter'
440        param_idx: usize,
441    },
442}
443
444impl<'tcx> ObligationCauseCode<'tcx> {
445    /// Returns the base obligation, ignoring derived obligations.
446    pub fn peel_derives(&self) -> &Self {
447        let mut base_cause = self;
448        while let Some(parent_code) = base_cause.parent() {
449            base_cause = parent_code;
450        }
451        base_cause
452    }
453
454    pub fn parent(&self) -> Option<&Self> {
455        match self {
456            ObligationCauseCode::FunctionArg { parent_code, .. } => Some(parent_code),
457            ObligationCauseCode::BuiltinDerived(derived)
458            | ObligationCauseCode::WellFormedDerived(derived)
459            | ObligationCauseCode::ImplDerived(box ImplDerivedCause { derived, .. }) => {
460                Some(&derived.parent_code)
461            }
462            ObligationCauseCode::BuiltinDerivedHost(derived)
463            | ObligationCauseCode::ImplDerivedHost(box ImplDerivedHostCause { derived, .. }) => {
464                Some(&derived.parent_code)
465            }
466            _ => None,
467        }
468    }
469
470    /// Returns the base obligation and the base trait predicate, if any, ignoring
471    /// derived obligations.
472    pub fn peel_derives_with_predicate(&self) -> (&Self, Option<ty::PolyTraitPredicate<'tcx>>) {
473        let mut base_cause = self;
474        let mut base_trait_pred = None;
475        while let Some((parent_code, parent_pred)) = base_cause.parent_with_predicate() {
476            base_cause = parent_code;
477            if let Some(parent_pred) = parent_pred {
478                base_trait_pred = Some(parent_pred);
479            }
480        }
481
482        (base_cause, base_trait_pred)
483    }
484
485    pub fn parent_with_predicate(&self) -> Option<(&Self, Option<ty::PolyTraitPredicate<'tcx>>)> {
486        match self {
487            ObligationCauseCode::FunctionArg { parent_code, .. } => Some((parent_code, None)),
488            ObligationCauseCode::BuiltinDerived(derived)
489            | ObligationCauseCode::WellFormedDerived(derived)
490            | ObligationCauseCode::ImplDerived(box ImplDerivedCause { derived, .. }) => {
491                Some((&derived.parent_code, Some(derived.parent_trait_pred)))
492            }
493            _ => None,
494        }
495    }
496
497    pub fn peel_match_impls(&self) -> &Self {
498        match self {
499            ObligationCauseCode::MatchImpl(cause, _) => cause.code(),
500            _ => self,
501        }
502    }
503}
504
505// `ObligationCauseCode` is used a lot. Make sure it doesn't unintentionally get bigger.
506#[cfg(target_pointer_width = "64")]
507rustc_data_structures::static_assert_size!(ObligationCauseCode<'_>, 48);
508
509#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
510#[derive(TypeVisitable, TypeFoldable)]
511pub struct MatchExpressionArmCause<'tcx> {
512    pub arm_block_id: Option<HirId>,
513    pub arm_ty: Ty<'tcx>,
514    pub arm_span: Span,
515    pub prior_arm_block_id: Option<HirId>,
516    pub prior_arm_ty: Ty<'tcx>,
517    pub prior_arm_span: Span,
518    /// Span of the scrutinee of the match (the matched value).
519    pub scrut_span: Span,
520    /// Source of the match, i.e. `match` or a desugaring.
521    pub source: hir::MatchSource,
522    /// Span of the *whole* match expr.
523    pub expr_span: Span,
524    /// Spans of the previous arms except for those that diverge (i.e. evaluate to `!`).
525    ///
526    /// These are used for pointing out errors that may affect several arms.
527    pub prior_non_diverging_arms: Vec<Span>,
528    /// Is the expectation of this match expression an RPIT?
529    pub tail_defines_return_position_impl_trait: Option<LocalDefId>,
530}
531
532/// Information about the origin expression of a pattern, relevant to diagnostics.
533/// Fields here refer to the scrutinee of a pattern.
534/// If the scrutinee isn't given in the diagnostic, then this won't exist.
535#[derive(Copy, Clone, Debug, PartialEq, Eq)]
536#[derive(TypeFoldable, TypeVisitable, HashStable, TyEncodable, TyDecodable)]
537pub struct PatternOriginExpr {
538    /// A span representing the scrutinee expression, with all leading references
539    /// peeled from the expression.
540    /// Only references in the expression are peeled - if the expression refers to a variable
541    /// whose type is a reference, then that reference is kept because it wasn't created
542    /// in the expression.
543    pub peeled_span: Span,
544    /// The number of references that were peeled to produce `peeled_span`.
545    pub peeled_count: usize,
546    /// Does the peeled expression need to be wrapped in parentheses for
547    /// a prefix suggestion (i.e., dereference) to be valid.
548    pub peeled_prefix_suggestion_parentheses: bool,
549}
550
551#[derive(Copy, Clone, Debug, PartialEq, Eq)]
552#[derive(TypeFoldable, TypeVisitable, HashStable, TyEncodable, TyDecodable)]
553pub struct IfExpressionCause<'tcx> {
554    pub then_id: HirId,
555    pub else_id: HirId,
556    pub then_ty: Ty<'tcx>,
557    pub else_ty: Ty<'tcx>,
558    pub outer_span: Option<Span>,
559    // Is the expectation of this match expression an RPIT?
560    pub tail_defines_return_position_impl_trait: Option<LocalDefId>,
561}
562
563#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
564#[derive(TypeVisitable, TypeFoldable)]
565pub struct DerivedCause<'tcx> {
566    /// The trait predicate of the parent obligation that led to the
567    /// current obligation. Note that only trait obligations lead to
568    /// derived obligations, so we just store the trait predicate here
569    /// directly.
570    pub parent_trait_pred: ty::PolyTraitPredicate<'tcx>,
571
572    /// The parent trait had this cause.
573    pub parent_code: ObligationCauseCodeHandle<'tcx>,
574}
575
576#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
577#[derive(TypeVisitable, TypeFoldable)]
578pub struct ImplDerivedCause<'tcx> {
579    pub derived: DerivedCause<'tcx>,
580    /// The `DefId` of the `impl` that gave rise to the `derived` obligation.
581    /// If the `derived` obligation arose from a trait alias, which conceptually has a synthetic
582    /// impl, then this will be the `DefId` of that trait alias. Care should therefore be taken to
583    /// handle that exceptional case where appropriate.
584    pub impl_or_alias_def_id: DefId,
585    /// The index of the derived predicate in the parent impl's predicates.
586    pub impl_def_predicate_index: Option<usize>,
587    pub span: Span,
588}
589
590#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
591#[derive(TypeVisitable, TypeFoldable)]
592pub struct DerivedHostCause<'tcx> {
593    /// The trait predicate of the parent obligation that led to the
594    /// current obligation. Note that only trait obligations lead to
595    /// derived obligations, so we just store the trait predicate here
596    /// directly.
597    pub parent_host_pred: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
598
599    /// The parent trait had this cause.
600    pub parent_code: ObligationCauseCodeHandle<'tcx>,
601}
602
603#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
604#[derive(TypeVisitable, TypeFoldable)]
605pub struct ImplDerivedHostCause<'tcx> {
606    pub derived: DerivedHostCause<'tcx>,
607    /// The `DefId` of the `impl` that gave rise to the `derived` obligation.
608    pub impl_def_id: DefId,
609    pub span: Span,
610}
611
612#[derive(Clone, Debug, PartialEq, Eq, TypeVisitable)]
613pub enum SelectionError<'tcx> {
614    /// The trait is not implemented.
615    Unimplemented,
616    /// After a closure impl has selected, its "outputs" were evaluated
617    /// (which for closures includes the "input" type params) and they
618    /// didn't resolve. See `confirm_poly_trait_refs` for more.
619    SignatureMismatch(Box<SignatureMismatchData<'tcx>>),
620    /// The trait pointed by `DefId` is dyn-incompatible.
621    TraitDynIncompatible(DefId),
622    /// A given constant couldn't be evaluated.
623    NotConstEvaluatable(NotConstEvaluatable),
624    /// Exceeded the recursion depth during type projection.
625    Overflow(OverflowError),
626    /// Computing an opaque type's hidden type caused an error (e.g. a cycle error).
627    /// We can thus not know whether the hidden type implements an auto trait, so
628    /// we should not presume anything about it.
629    OpaqueTypeAutoTraitLeakageUnknown(DefId),
630    /// Error for a `ConstArgHasType` goal
631    ConstArgHasWrongType { ct: ty::Const<'tcx>, ct_ty: Ty<'tcx>, expected_ty: Ty<'tcx> },
632}
633
634#[derive(Clone, Debug, PartialEq, Eq, TypeVisitable)]
635pub struct SignatureMismatchData<'tcx> {
636    pub found_trait_ref: ty::TraitRef<'tcx>,
637    pub expected_trait_ref: ty::TraitRef<'tcx>,
638    pub terr: ty::error::TypeError<'tcx>,
639}
640
641/// When performing resolution, it is typically the case that there
642/// can be one of three outcomes:
643///
644/// - `Ok(Some(r))`: success occurred with result `r`
645/// - `Ok(None)`: could not definitely determine anything, usually due
646///   to inconclusive type inference.
647/// - `Err(e)`: error `e` occurred
648pub type SelectionResult<'tcx, T> = Result<Option<T>, SelectionError<'tcx>>;
649
650/// Given the successful resolution of an obligation, the `ImplSource`
651/// indicates where the impl comes from.
652///
653/// For example, the obligation may be satisfied by a specific impl (case A),
654/// or it may be relative to some bound that is in scope (case B).
655///
656/// ```ignore (illustrative)
657/// impl<T:Clone> Clone<T> for Option<T> { ... } // Impl_1
658/// impl<T:Clone> Clone<T> for Box<T> { ... }    // Impl_2
659/// impl Clone for i32 { ... }                   // Impl_3
660///
661/// fn foo<T: Clone>(concrete: Option<Box<i32>>, param: T, mixed: Option<T>) {
662///     // Case A: ImplSource points at a specific impl. Only possible when
663///     // type is concretely known. If the impl itself has bounded
664///     // type parameters, ImplSource will carry resolutions for those as well:
665///     concrete.clone(); // ImplSource(Impl_1, [ImplSource(Impl_2, [ImplSource(Impl_3)])])
666///
667///     // Case B: ImplSource must be provided by caller. This applies when
668///     // type is a type parameter.
669///     param.clone();    // ImplSource::Param
670///
671///     // Case C: A mix of cases A and B.
672///     mixed.clone();    // ImplSource(Impl_1, [ImplSource::Param])
673/// }
674/// ```
675///
676/// ### The type parameter `N`
677///
678/// See explanation on `ImplSourceUserDefinedData`.
679#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)]
680#[derive(TypeFoldable, TypeVisitable)]
681pub enum ImplSource<'tcx, N> {
682    /// ImplSource identifying a particular impl.
683    UserDefined(ImplSourceUserDefinedData<'tcx, N>),
684
685    /// Successful resolution to an obligation provided by the caller
686    /// for some type parameter. The `Vec<N>` represents the
687    /// obligations incurred from normalizing the where-clause (if
688    /// any).
689    Param(ThinVec<N>),
690
691    /// Successful resolution for a builtin impl.
692    Builtin(BuiltinImplSource, ThinVec<N>),
693}
694
695impl<'tcx, N> ImplSource<'tcx, N> {
696    pub fn nested_obligations(self) -> ThinVec<N> {
697        match self {
698            ImplSource::UserDefined(i) => i.nested,
699            ImplSource::Param(n) | ImplSource::Builtin(_, n) => n,
700        }
701    }
702
703    pub fn borrow_nested_obligations(&self) -> &[N] {
704        match self {
705            ImplSource::UserDefined(i) => &i.nested,
706            ImplSource::Param(n) | ImplSource::Builtin(_, n) => n,
707        }
708    }
709
710    pub fn borrow_nested_obligations_mut(&mut self) -> &mut [N] {
711        match self {
712            ImplSource::UserDefined(i) => &mut i.nested,
713            ImplSource::Param(n) | ImplSource::Builtin(_, n) => n,
714        }
715    }
716
717    pub fn map<M, F>(self, f: F) -> ImplSource<'tcx, M>
718    where
719        F: FnMut(N) -> M,
720    {
721        match self {
722            ImplSource::UserDefined(i) => ImplSource::UserDefined(ImplSourceUserDefinedData {
723                impl_def_id: i.impl_def_id,
724                args: i.args,
725                nested: i.nested.into_iter().map(f).collect(),
726            }),
727            ImplSource::Param(n) => ImplSource::Param(n.into_iter().map(f).collect()),
728            ImplSource::Builtin(source, n) => {
729                ImplSource::Builtin(source, n.into_iter().map(f).collect())
730            }
731        }
732    }
733}
734
735/// Identifies a particular impl in the source, along with a set of
736/// generic parameters from the impl's type/lifetime parameters. The
737/// `nested` vector corresponds to the nested obligations attached to
738/// the impl's type parameters.
739///
740/// The type parameter `N` indicates the type used for "nested
741/// obligations" that are required by the impl. During type-check, this
742/// is `Obligation`, as one might expect. During codegen, however, this
743/// is `()`, because codegen only requires a shallow resolution of an
744/// impl, and nested obligations are satisfied later.
745#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)]
746#[derive(TypeFoldable, TypeVisitable)]
747pub struct ImplSourceUserDefinedData<'tcx, N> {
748    pub impl_def_id: DefId,
749    pub args: GenericArgsRef<'tcx>,
750    pub nested: ThinVec<N>,
751}
752
753#[derive(Clone, Debug, PartialEq, Eq, Hash, HashStable, PartialOrd, Ord)]
754pub enum DynCompatibilityViolation {
755    /// `Self: Sized` declared on the trait.
756    SizedSelf(SmallVec<[Span; 1]>),
757
758    /// Supertrait reference references `Self` an in illegal location
759    /// (e.g., `trait Foo : Bar<Self>`).
760    SupertraitSelf(SmallVec<[Span; 1]>),
761
762    // Supertrait has a non-lifetime `for<T>` binder.
763    SupertraitNonLifetimeBinder(SmallVec<[Span; 1]>),
764
765    /// Method has something illegal.
766    Method(Symbol, MethodViolationCode, Span),
767
768    /// Associated const.
769    AssocConst(Symbol, Span),
770
771    /// GAT
772    GAT(Symbol, Span),
773}
774
775impl DynCompatibilityViolation {
776    pub fn error_msg(&self) -> Cow<'static, str> {
777        match self {
778            DynCompatibilityViolation::SizedSelf(_) => "it requires `Self: Sized`".into(),
779            DynCompatibilityViolation::SupertraitSelf(spans) => {
780                if spans.iter().any(|sp| *sp != DUMMY_SP) {
781                    "it uses `Self` as a type parameter".into()
782                } else {
783                    "it cannot use `Self` as a type parameter in a supertrait or `where`-clause"
784                        .into()
785                }
786            }
787            DynCompatibilityViolation::SupertraitNonLifetimeBinder(_) => {
788                "where clause cannot reference non-lifetime `for<...>` variables".into()
789            }
790            DynCompatibilityViolation::Method(name, MethodViolationCode::StaticMethod(_), _) => {
791                format!("associated function `{name}` has no `self` parameter").into()
792            }
793            DynCompatibilityViolation::Method(
794                name,
795                MethodViolationCode::ReferencesSelfInput(_),
796                DUMMY_SP,
797            ) => format!("method `{name}` references the `Self` type in its parameters").into(),
798            DynCompatibilityViolation::Method(
799                name,
800                MethodViolationCode::ReferencesSelfInput(_),
801                _,
802            ) => format!("method `{name}` references the `Self` type in this parameter").into(),
803            DynCompatibilityViolation::Method(
804                name,
805                MethodViolationCode::ReferencesSelfOutput,
806                _,
807            ) => format!("method `{name}` references the `Self` type in its return type").into(),
808            DynCompatibilityViolation::Method(
809                name,
810                MethodViolationCode::ReferencesImplTraitInTrait(_),
811                _,
812            ) => {
813                format!("method `{name}` references an `impl Trait` type in its return type").into()
814            }
815            DynCompatibilityViolation::Method(name, MethodViolationCode::AsyncFn, _) => {
816                format!("method `{name}` is `async`").into()
817            }
818            DynCompatibilityViolation::Method(
819                name,
820                MethodViolationCode::WhereClauseReferencesSelf,
821                _,
822            ) => format!("method `{name}` references the `Self` type in its `where` clause").into(),
823            DynCompatibilityViolation::Method(name, MethodViolationCode::Generic, _) => {
824                format!("method `{name}` has generic type parameters").into()
825            }
826            DynCompatibilityViolation::Method(
827                name,
828                MethodViolationCode::UndispatchableReceiver(_),
829                _,
830            ) => format!("method `{name}`'s `self` parameter cannot be dispatched on").into(),
831            DynCompatibilityViolation::AssocConst(name, DUMMY_SP) => {
832                format!("it contains associated `const` `{name}`").into()
833            }
834            DynCompatibilityViolation::AssocConst(..) => {
835                "it contains this associated `const`".into()
836            }
837            DynCompatibilityViolation::GAT(name, _) => {
838                format!("it contains the generic associated type `{name}`").into()
839            }
840        }
841    }
842
843    pub fn solution(&self) -> DynCompatibilityViolationSolution {
844        match self {
845            DynCompatibilityViolation::SizedSelf(_)
846            | DynCompatibilityViolation::SupertraitSelf(_)
847            | DynCompatibilityViolation::SupertraitNonLifetimeBinder(..) => {
848                DynCompatibilityViolationSolution::None
849            }
850            DynCompatibilityViolation::Method(
851                name,
852                MethodViolationCode::StaticMethod(Some((add_self_sugg, make_sized_sugg))),
853                _,
854            ) => DynCompatibilityViolationSolution::AddSelfOrMakeSized {
855                name: *name,
856                add_self_sugg: add_self_sugg.clone(),
857                make_sized_sugg: make_sized_sugg.clone(),
858            },
859            DynCompatibilityViolation::Method(
860                name,
861                MethodViolationCode::UndispatchableReceiver(Some(span)),
862                _,
863            ) => DynCompatibilityViolationSolution::ChangeToRefSelf(*name, *span),
864            DynCompatibilityViolation::AssocConst(name, _)
865            | DynCompatibilityViolation::GAT(name, _)
866            | DynCompatibilityViolation::Method(name, ..) => {
867                DynCompatibilityViolationSolution::MoveToAnotherTrait(*name)
868            }
869        }
870    }
871
872    pub fn spans(&self) -> SmallVec<[Span; 1]> {
873        // When `span` comes from a separate crate, it'll be `DUMMY_SP`. Treat it as `None` so
874        // diagnostics use a `note` instead of a `span_label`.
875        match self {
876            DynCompatibilityViolation::SupertraitSelf(spans)
877            | DynCompatibilityViolation::SizedSelf(spans)
878            | DynCompatibilityViolation::SupertraitNonLifetimeBinder(spans) => spans.clone(),
879            DynCompatibilityViolation::AssocConst(_, span)
880            | DynCompatibilityViolation::GAT(_, span)
881            | DynCompatibilityViolation::Method(_, _, span)
882                if *span != DUMMY_SP =>
883            {
884                smallvec![*span]
885            }
886            _ => smallvec![],
887        }
888    }
889}
890
891#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
892pub enum DynCompatibilityViolationSolution {
893    None,
894    AddSelfOrMakeSized {
895        name: Symbol,
896        add_self_sugg: (String, Span),
897        make_sized_sugg: (String, Span),
898    },
899    ChangeToRefSelf(Symbol, Span),
900    MoveToAnotherTrait(Symbol),
901}
902
903impl DynCompatibilityViolationSolution {
904    pub fn add_to<G: EmissionGuarantee>(self, err: &mut Diag<'_, G>) {
905        match self {
906            DynCompatibilityViolationSolution::None => {}
907            DynCompatibilityViolationSolution::AddSelfOrMakeSized {
908                name,
909                add_self_sugg,
910                make_sized_sugg,
911            } => {
912                err.span_suggestion(
913                    add_self_sugg.1,
914                    format!(
915                        "consider turning `{name}` into a method by giving it a `&self` argument"
916                    ),
917                    add_self_sugg.0,
918                    Applicability::MaybeIncorrect,
919                );
920                err.span_suggestion(
921                    make_sized_sugg.1,
922                    format!(
923                        "alternatively, consider constraining `{name}` so it does not apply to \
924                             trait objects"
925                    ),
926                    make_sized_sugg.0,
927                    Applicability::MaybeIncorrect,
928                );
929            }
930            DynCompatibilityViolationSolution::ChangeToRefSelf(name, span) => {
931                err.span_suggestion(
932                    span,
933                    format!("consider changing method `{name}`'s `self` parameter to be `&self`"),
934                    "&Self",
935                    Applicability::MachineApplicable,
936                );
937            }
938            DynCompatibilityViolationSolution::MoveToAnotherTrait(name) => {
939                err.help(format!("consider moving `{name}` to another trait"));
940            }
941        }
942    }
943}
944
945/// Reasons a method might not be dyn-compatible.
946#[derive(Clone, Debug, PartialEq, Eq, Hash, HashStable, PartialOrd, Ord)]
947pub enum MethodViolationCode {
948    /// e.g., `fn foo()`
949    StaticMethod(Option<(/* add &self */ (String, Span), /* add Self: Sized */ (String, Span))>),
950
951    /// e.g., `fn foo(&self, x: Self)`
952    ReferencesSelfInput(Option<Span>),
953
954    /// e.g., `fn foo(&self) -> Self`
955    ReferencesSelfOutput,
956
957    /// e.g., `fn foo(&self) -> impl Sized`
958    ReferencesImplTraitInTrait(Span),
959
960    /// e.g., `async fn foo(&self)`
961    AsyncFn,
962
963    /// e.g., `fn foo(&self) where Self: Clone`
964    WhereClauseReferencesSelf,
965
966    /// e.g., `fn foo<A>()`
967    Generic,
968
969    /// the method's receiver (`self` argument) can't be dispatched on
970    UndispatchableReceiver(Option<Span>),
971}
972
973/// These are the error cases for `codegen_select_candidate`.
974#[derive(Copy, Clone, Debug, Hash, HashStable, Encodable, Decodable)]
975pub enum CodegenObligationError {
976    /// Ambiguity can happen when monomorphizing during trans
977    /// expands to some humongous type that never occurred
978    /// statically -- this humongous type can then overflow,
979    /// leading to an ambiguous result. So report this as an
980    /// overflow bug, since I believe this is the only case
981    /// where ambiguity can result.
982    Ambiguity,
983    /// This can trigger when we have a global bound that is not actually satisfied
984    /// due to trivial bounds.
985    Unimplemented,
986    /// The selected impl has unconstrained generic parameters. This will emit an error
987    /// during impl WF checking.
988    UnconstrainedParam(ErrorGuaranteed),
989}