1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! See the Book for more information.
13 pub use self::LateBoundRegionConversionTime
::*;
14 pub use self::RegionVariableOrigin
::*;
15 pub use self::SubregionOrigin
::*;
16 pub use self::ValuePairs
::*;
17 pub use ty
::IntVarValue
;
18 pub use self::freshen
::TypeFreshener
;
19 pub use self::region_inference
::{GenericKind, VerifyBound}
;
21 use hir
::def_id
::DefId
;
23 use middle
::free_region
::FreeRegionMap
;
24 use middle
::mem_categorization
as mc
;
25 use middle
::mem_categorization
::McResult
;
26 use middle
::region
::CodeExtent
;
27 use mir
::tcx
::LvalueTy
;
28 use ty
::subst
::{Kind, Subst, Substs}
;
30 use ty
::{TyVid, IntVid, FloatVid}
;
31 use ty
::{self, Ty, TyCtxt}
;
32 use ty
::error
::{ExpectedFound, TypeError, UnconstrainedNumeric}
;
33 use ty
::fold
::{TypeFoldable, TypeFolder, TypeVisitor}
;
34 use ty
::relate
::{Relate, RelateResult, TypeRelation}
;
35 use traits
::{self, PredicateObligations, Reveal}
;
36 use rustc_data_structures
::unify
::{self, UnificationTable}
;
37 use std
::cell
::{Cell, RefCell, Ref, RefMut}
;
40 use errors
::DiagnosticBuilder
;
41 use syntax_pos
::{self, Span, DUMMY_SP}
;
42 use util
::nodemap
::{FnvHashMap, FnvHashSet, NodeMap}
;
44 use self::combine
::CombineFields
;
45 use self::higher_ranked
::HrMatchResult
;
46 use self::region_inference
::{RegionVarBindings, RegionSnapshot}
;
47 use self::unify_key
::ToType
;
52 pub mod error_reporting
;
57 pub mod region_inference
;
61 pub mod type_variable
;
65 pub struct InferOk
<'tcx
, T
> {
67 pub obligations
: PredicateObligations
<'tcx
>,
69 pub type InferResult
<'tcx
, T
> = Result
<InferOk
<'tcx
, T
>, TypeError
<'tcx
>>;
71 pub type Bound
<T
> = Option
<T
>;
72 pub type UnitResult
<'tcx
> = RelateResult
<'tcx
, ()>; // "unify result"
73 pub type FixupResult
<T
> = Result
<T
, FixupError
>; // "fixup result"
75 /// A version of &ty::Tables which can be global or local.
76 /// Only the local version supports borrow_mut.
77 #[derive(Copy, Clone)]
78 pub enum InferTables
<'a
, 'gcx
: 'a
+'tcx
, 'tcx
: 'a
> {
79 Global(&'a RefCell
<ty
::Tables
<'gcx
>>),
80 Local(&'a RefCell
<ty
::Tables
<'tcx
>>)
83 impl<'a
, 'gcx
, 'tcx
> InferTables
<'a
, 'gcx
, 'tcx
> {
84 pub fn borrow(self) -> Ref
<'a
, ty
::Tables
<'tcx
>> {
86 InferTables
::Global(tables
) => tables
.borrow(),
87 InferTables
::Local(tables
) => tables
.borrow()
91 pub fn borrow_mut(self) -> RefMut
<'a
, ty
::Tables
<'tcx
>> {
93 InferTables
::Global(_
) => {
94 bug
!("InferTables: infcx.tables.borrow_mut() outside of type-checking");
96 InferTables
::Local(tables
) => tables
.borrow_mut()
101 pub struct InferCtxt
<'a
, 'gcx
: 'a
+'tcx
, 'tcx
: 'a
> {
102 pub tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
104 pub tables
: InferTables
<'a
, 'gcx
, 'tcx
>,
106 // Cache for projections. This cache is snapshotted along with the
109 // Public so that `traits::project` can use it.
110 pub projection_cache
: RefCell
<traits
::ProjectionCache
<'tcx
>>,
112 // We instantiate UnificationTable with bounds<Ty> because the
113 // types that might instantiate a general type variable have an
114 // order, represented by its upper and lower bounds.
115 type_variables
: RefCell
<type_variable
::TypeVariableTable
<'tcx
>>,
117 // Map from integral variable to the kind of integer it represents
118 int_unification_table
: RefCell
<UnificationTable
<ty
::IntVid
>>,
120 // Map from floating variable to the kind of float it represents
121 float_unification_table
: RefCell
<UnificationTable
<ty
::FloatVid
>>,
123 // For region variables.
124 region_vars
: RegionVarBindings
<'a
, 'gcx
, 'tcx
>,
126 pub parameter_environment
: ty
::ParameterEnvironment
<'gcx
>,
128 /// Caches the results of trait selection. This cache is used
129 /// for things that have to do with the parameters in scope.
130 pub selection_cache
: traits
::SelectionCache
<'tcx
>,
132 /// Caches the results of trait evaluation.
133 pub evaluation_cache
: traits
::EvaluationCache
<'tcx
>,
135 // the set of predicates on which errors have been reported, to
136 // avoid reporting the same error twice.
137 pub reported_trait_errors
: RefCell
<FnvHashSet
<traits
::TraitErrorKey
<'tcx
>>>,
139 // Sadly, the behavior of projection varies a bit depending on the
140 // stage of compilation. The specifics are given in the
141 // documentation for `Reveal`.
142 projection_mode
: Reveal
,
144 // When an error occurs, we want to avoid reporting "derived"
145 // errors that are due to this original failure. Normally, we
146 // handle this with the `err_count_on_creation` count, which
147 // basically just tracks how many errors were reported when we
148 // started type-checking a fn and checks to see if any new errors
149 // have been reported since then. Not great, but it works.
151 // However, when errors originated in other passes -- notably
152 // resolve -- this heuristic breaks down. Therefore, we have this
153 // auxiliary flag that one can set whenever one creates a
154 // type-error that is due to an error in a prior pass.
156 // Don't read this flag directly, call `is_tainted_by_errors()`
157 // and `set_tainted_by_errors()`.
158 tainted_by_errors_flag
: Cell
<bool
>,
160 // Track how many errors were reported when this infcx is created.
161 // If the number of errors increases, that's also a sign (line
162 // `tained_by_errors`) to avoid reporting certain kinds of errors.
163 err_count_on_creation
: usize,
165 // This flag is used for debugging, and is set to true if there are
166 // any obligations set during the current snapshot. In that case, the
167 // snapshot can't be rolled back.
168 pub obligations_in_snapshot
: Cell
<bool
>,
171 /// A map returned by `skolemize_late_bound_regions()` indicating the skolemized
172 /// region that each late-bound region was replaced with.
173 pub type SkolemizationMap
<'tcx
> = FnvHashMap
<ty
::BoundRegion
, &'tcx ty
::Region
>;
175 /// Why did we require that the two types be related?
177 /// See `error_reporting.rs` for more details
178 #[derive(Clone, Copy, Debug)]
179 pub enum TypeOrigin
{
180 // Not yet categorized in a better way
183 // Checking that method of impl is compatible with trait
184 MethodCompatCheck(Span
),
186 // Checking that this expression can be assigned where it needs to be
187 // FIXME(eddyb) #11161 is the original Expr required?
188 ExprAssignable(Span
),
190 // Relating trait type parameters to those found in impl etc
191 RelateOutputImplTypes(Span
),
193 // Computing common supertype in the arms of a match expression
194 MatchExpressionArm(Span
, Span
, hir
::MatchSource
),
196 // Computing common supertype in an if expression
199 // Computing common supertype of an if expression with no else counter-part
200 IfExpressionWithNoElse(Span
),
203 EquatePredicate(Span
),
205 // `main` has wrong type
206 MainFunctionType(Span
),
208 // `start` has wrong type
209 StartFunctionType(Span
),
211 // intrinsic has wrong type
215 MethodReceiver(Span
),
219 fn as_failure_str(&self) -> &'
static str {
221 &TypeOrigin
::Misc(_
) |
222 &TypeOrigin
::RelateOutputImplTypes(_
) |
223 &TypeOrigin
::ExprAssignable(_
) => "mismatched types",
224 &TypeOrigin
::MethodCompatCheck(_
) => "method not compatible with trait",
225 &TypeOrigin
::MatchExpressionArm(.., source
) => match source
{
226 hir
::MatchSource
::IfLetDesugar{..}
=> "`if let` arms have incompatible types",
227 _
=> "match arms have incompatible types",
229 &TypeOrigin
::IfExpression(_
) => "if and else have incompatible types",
230 &TypeOrigin
::IfExpressionWithNoElse(_
) => "if may be missing an else clause",
231 &TypeOrigin
::EquatePredicate(_
) => "equality predicate not satisfied",
232 &TypeOrigin
::MainFunctionType(_
) => "main function has wrong type",
233 &TypeOrigin
::StartFunctionType(_
) => "start function has wrong type",
234 &TypeOrigin
::IntrinsicType(_
) => "intrinsic has wrong type",
235 &TypeOrigin
::MethodReceiver(_
) => "mismatched method receiver",
239 fn as_requirement_str(&self) -> &'
static str {
241 &TypeOrigin
::Misc(_
) => "types are compatible",
242 &TypeOrigin
::MethodCompatCheck(_
) => "method type is compatible with trait",
243 &TypeOrigin
::ExprAssignable(_
) => "expression is assignable",
244 &TypeOrigin
::RelateOutputImplTypes(_
) => {
245 "trait type parameters matches those specified on the impl"
247 &TypeOrigin
::MatchExpressionArm(..) => "match arms have compatible types",
248 &TypeOrigin
::IfExpression(_
) => "if and else have compatible types",
249 &TypeOrigin
::IfExpressionWithNoElse(_
) => "if missing an else returns ()",
250 &TypeOrigin
::EquatePredicate(_
) => "equality where clause is satisfied",
251 &TypeOrigin
::MainFunctionType(_
) => "`main` function has the correct type",
252 &TypeOrigin
::StartFunctionType(_
) => "`start` function has the correct type",
253 &TypeOrigin
::IntrinsicType(_
) => "intrinsic has the correct type",
254 &TypeOrigin
::MethodReceiver(_
) => "method receiver has the correct type",
259 /// See `error_reporting.rs` for more details
260 #[derive(Clone, Debug)]
261 pub enum ValuePairs
<'tcx
> {
262 Types(ExpectedFound
<Ty
<'tcx
>>),
263 TraitRefs(ExpectedFound
<ty
::TraitRef
<'tcx
>>),
264 PolyTraitRefs(ExpectedFound
<ty
::PolyTraitRef
<'tcx
>>),
267 /// The trace designates the path through inference that we took to
268 /// encounter an error or subtyping constraint.
270 /// See `error_reporting.rs` for more details.
272 pub struct TypeTrace
<'tcx
> {
274 values
: ValuePairs
<'tcx
>,
277 /// The origin of a `r1 <= r2` constraint.
279 /// See `error_reporting.rs` for more details
280 #[derive(Clone, Debug)]
281 pub enum SubregionOrigin
<'tcx
> {
282 // Arose from a subtyping relation
283 Subtype(TypeTrace
<'tcx
>),
285 // Stack-allocated closures cannot outlive innermost loop
286 // or function so as to ensure we only require finite stack
287 InfStackClosure(Span
),
289 // Invocation of closure must be within its lifetime
292 // Dereference of reference must be within its lifetime
295 // Closure bound must not outlive captured free variables
296 FreeVariable(Span
, ast
::NodeId
),
298 // Index into slice must be within its lifetime
301 // When casting `&'a T` to an `&'b Trait` object,
302 // relating `'a` to `'b`
303 RelateObjectBound(Span
),
305 // Some type parameter was instantiated with the given type,
306 // and that type must outlive some region.
307 RelateParamBound(Span
, Ty
<'tcx
>),
309 // The given region parameter was instantiated with a region
310 // that must outlive some other region.
311 RelateRegionParamBound(Span
),
313 // A bound placed on type parameters that states that must outlive
314 // the moment of their instantiation.
315 RelateDefaultParamBound(Span
, Ty
<'tcx
>),
317 // Creating a pointer `b` to contents of another reference
320 // Creating a pointer `b` to contents of an upvar
321 ReborrowUpvar(Span
, ty
::UpvarId
),
323 // Data with type `Ty<'tcx>` was borrowed
324 DataBorrowed(Ty
<'tcx
>, Span
),
326 // (&'a &'b T) where a >= b
327 ReferenceOutlivesReferent(Ty
<'tcx
>, Span
),
329 // Type or region parameters must be in scope.
330 ParameterInScope(ParameterOrigin
, Span
),
332 // The type T of an expression E must outlive the lifetime for E.
333 ExprTypeIsNotInScope(Ty
<'tcx
>, Span
),
335 // A `ref b` whose region does not enclose the decl site
336 BindingTypeIsNotValidAtDecl(Span
),
338 // Regions appearing in a method receiver must outlive method call
341 // Regions appearing in a function argument must outlive func call
344 // Region in return type of invoked fn must enclose call
347 // Operands must be in scope
350 // Region resulting from a `&` expr must enclose the `&` expr
353 // An auto-borrow that does not enclose the expr where it occurs
356 // Region constraint arriving from destructor safety
357 SafeDestructor(Span
),
359 // Comparing the signature and requirements of an impl method against
360 // the containing trait.
361 CompareImplMethodObligation
{
363 item_name
: ast
::Name
,
364 impl_item_def_id
: DefId
,
365 trait_item_def_id
: DefId
,
367 // this is `Some(_)` if this error arises from the bug fix for
368 // #18937. This is a temporary measure.
369 lint_id
: Option
<ast
::NodeId
>,
373 /// Places that type/region parameters can appear.
374 #[derive(Clone, Copy, Debug)]
375 pub enum ParameterOrigin
{
377 MethodCall
, // foo.bar() <-- parameters on impl providing bar()
378 OverloadedOperator
, // a + b when overloaded
379 OverloadedDeref
, // *a when overloaded
382 /// Times when we replace late-bound regions with variables:
383 #[derive(Clone, Copy, Debug)]
384 pub enum LateBoundRegionConversionTime
{
385 /// when a fn is called
388 /// when two higher-ranked types are compared
391 /// when projecting an associated type
392 AssocTypeProjection(ast
::Name
),
395 /// Reasons to create a region inference variable
397 /// See `error_reporting.rs` for more details
398 #[derive(Clone, Debug)]
399 pub enum RegionVariableOrigin
{
400 // Region variables created for ill-categorized reasons,
401 // mostly indicates places in need of refactoring
404 // Regions created by a `&P` or `[...]` pattern
407 // Regions created by `&` operator
410 // Regions created as part of an autoref of a method receiver
413 // Regions created as part of an automatic coercion
416 // Region variables created as the values for early-bound regions
417 EarlyBoundRegion(Span
, ast
::Name
),
419 // Region variables created for bound regions
420 // in a function or method that is called
421 LateBoundRegion(Span
, ty
::BoundRegion
, LateBoundRegionConversionTime
),
423 UpvarRegion(ty
::UpvarId
, Span
),
425 BoundRegionInCoherence(ast
::Name
),
428 #[derive(Copy, Clone, Debug)]
429 pub enum FixupError
{
430 UnresolvedIntTy(IntVid
),
431 UnresolvedFloatTy(FloatVid
),
435 impl fmt
::Display
for FixupError
{
436 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
437 use self::FixupError
::*;
440 UnresolvedIntTy(_
) => {
441 write
!(f
, "cannot determine the type of this integer; \
442 add a suffix to specify the type explicitly")
444 UnresolvedFloatTy(_
) => {
445 write
!(f
, "cannot determine the type of this number; \
446 add a suffix to specify the type explicitly")
448 UnresolvedTy(_
) => write
!(f
, "unconstrained type")
453 /// Helper type of a temporary returned by tcx.infer_ctxt(...).
454 /// Necessary because we can't write the following bound:
455 /// F: for<'b, 'tcx> where 'gcx: 'tcx FnOnce(InferCtxt<'b, 'gcx, 'tcx>).
456 pub struct InferCtxtBuilder
<'a
, 'gcx
: 'a
+'tcx
, 'tcx
: 'a
> {
457 global_tcx
: TyCtxt
<'a
, 'gcx
, 'gcx
>,
458 arenas
: ty
::CtxtArenas
<'tcx
>,
459 tables
: Option
<RefCell
<ty
::Tables
<'tcx
>>>,
460 param_env
: Option
<ty
::ParameterEnvironment
<'gcx
>>,
461 projection_mode
: Reveal
,
464 impl<'a
, 'gcx
, 'tcx
> TyCtxt
<'a
, 'gcx
, 'gcx
> {
465 pub fn infer_ctxt(self,
466 tables
: Option
<ty
::Tables
<'tcx
>>,
467 param_env
: Option
<ty
::ParameterEnvironment
<'gcx
>>,
468 projection_mode
: Reveal
)
469 -> InferCtxtBuilder
<'a
, 'gcx
, 'tcx
> {
472 arenas
: ty
::CtxtArenas
::new(),
473 tables
: tables
.map(RefCell
::new
),
474 param_env
: param_env
,
475 projection_mode
: projection_mode
,
479 /// Fake InferCtxt with the global tcx. Used by pre-MIR borrowck
480 /// for MemCategorizationContext/ExprUseVisitor.
481 /// If any inference functionality is used, ICEs will occur.
482 pub fn borrowck_fake_infer_ctxt(self, param_env
: ty
::ParameterEnvironment
<'gcx
>)
483 -> InferCtxt
<'a
, 'gcx
, 'gcx
> {
486 tables
: InferTables
::Global(&self.tables
),
487 type_variables
: RefCell
::new(type_variable
::TypeVariableTable
::new()),
488 int_unification_table
: RefCell
::new(UnificationTable
::new()),
489 float_unification_table
: RefCell
::new(UnificationTable
::new()),
490 region_vars
: RegionVarBindings
::new(self),
491 parameter_environment
: param_env
,
492 selection_cache
: traits
::SelectionCache
::new(),
493 evaluation_cache
: traits
::EvaluationCache
::new(),
494 projection_cache
: RefCell
::new(traits
::ProjectionCache
::new()),
495 reported_trait_errors
: RefCell
::new(FnvHashSet()),
496 projection_mode
: Reveal
::NotSpecializable
,
497 tainted_by_errors_flag
: Cell
::new(false),
498 err_count_on_creation
: self.sess
.err_count(),
499 obligations_in_snapshot
: Cell
::new(false),
504 impl<'a
, 'gcx
, 'tcx
> InferCtxtBuilder
<'a
, 'gcx
, 'tcx
> {
505 pub fn enter
<F
, R
>(&'tcx
mut self, f
: F
) -> R
506 where F
: for<'b
> FnOnce(InferCtxt
<'b
, 'gcx
, 'tcx
>) -> R
508 let InferCtxtBuilder
{
515 let tables
= if let Some(ref tables
) = *tables
{
516 InferTables
::Local(tables
)
518 InferTables
::Global(&global_tcx
.tables
)
520 let param_env
= param_env
.take().unwrap_or_else(|| {
521 global_tcx
.empty_parameter_environment()
523 global_tcx
.enter_local(arenas
, |tcx
| f(InferCtxt
{
526 projection_cache
: RefCell
::new(traits
::ProjectionCache
::new()),
527 type_variables
: RefCell
::new(type_variable
::TypeVariableTable
::new()),
528 int_unification_table
: RefCell
::new(UnificationTable
::new()),
529 float_unification_table
: RefCell
::new(UnificationTable
::new()),
530 region_vars
: RegionVarBindings
::new(tcx
),
531 parameter_environment
: param_env
,
532 selection_cache
: traits
::SelectionCache
::new(),
533 evaluation_cache
: traits
::EvaluationCache
::new(),
534 reported_trait_errors
: RefCell
::new(FnvHashSet()),
535 projection_mode
: projection_mode
,
536 tainted_by_errors_flag
: Cell
::new(false),
537 err_count_on_creation
: tcx
.sess
.err_count(),
538 obligations_in_snapshot
: Cell
::new(false),
543 impl<T
> ExpectedFound
<T
> {
544 fn new(a_is_expected
: bool
, a
: T
, b
: T
) -> Self {
546 ExpectedFound {expected: a, found: b}
548 ExpectedFound {expected: b, found: a}
553 impl<'tcx
, T
> InferOk
<'tcx
, T
> {
554 pub fn unit(self) -> InferOk
<'tcx
, ()> {
555 InferOk { value: (), obligations: self.obligations }
559 #[must_use = "once you start a snapshot, you should always consume it"]
560 pub struct CombinedSnapshot
{
561 projection_cache_snapshot
: traits
::ProjectionCacheSnapshot
,
562 type_snapshot
: type_variable
::Snapshot
,
563 int_snapshot
: unify
::Snapshot
<ty
::IntVid
>,
564 float_snapshot
: unify
::Snapshot
<ty
::FloatVid
>,
565 region_vars_snapshot
: RegionSnapshot
,
566 obligations_in_snapshot
: bool
,
569 /// Helper trait for shortening the lifetimes inside a
570 /// value for post-type-checking normalization.
571 pub trait TransNormalize
<'gcx
>: TypeFoldable
<'gcx
> {
572 fn trans_normalize
<'a
, 'tcx
>(&self, infcx
: &InferCtxt
<'a
, 'gcx
, 'tcx
>) -> Self;
575 macro_rules
! items { ($($item:item)+) => ($($item)+) }
576 macro_rules
! impl_trans_normalize
{
577 ($lt_gcx
:tt
, $
($ty
:ty
),+) => {
578 items
!($
(impl<$lt_gcx
> TransNormalize
<$lt_gcx
> for $ty
{
579 fn trans_normalize
<'a
, 'tcx
>(&self,
580 infcx
: &InferCtxt
<'a
, $lt_gcx
, 'tcx
>)
582 infcx
.normalize_projections_in(self)
588 impl_trans_normalize
!('gcx
,
592 &'gcx ty
::BareFnTy
<'gcx
>,
593 ty
::ClosureSubsts
<'gcx
>,
594 ty
::PolyTraitRef
<'gcx
>,
595 ty
::ExistentialTraitRef
<'gcx
>
598 impl<'gcx
> TransNormalize
<'gcx
> for LvalueTy
<'gcx
> {
599 fn trans_normalize
<'a
, 'tcx
>(&self, infcx
: &InferCtxt
<'a
, 'gcx
, 'tcx
>) -> Self {
601 LvalueTy
::Ty { ty }
=> LvalueTy
::Ty { ty: ty.trans_normalize(infcx) }
,
602 LvalueTy
::Downcast { adt_def, substs, variant_index }
=> {
605 substs
: substs
.trans_normalize(infcx
),
606 variant_index
: variant_index
613 // NOTE: Callable from trans only!
614 impl<'a
, 'tcx
> TyCtxt
<'a
, 'tcx
, 'tcx
> {
615 /// Currently, higher-ranked type bounds inhibit normalization. Therefore,
616 /// each time we erase them in translation, we need to normalize
618 pub fn erase_late_bound_regions_and_normalize
<T
>(self, value
: &ty
::Binder
<T
>)
620 where T
: TransNormalize
<'tcx
>
622 assert
!(!value
.needs_subst());
623 let value
= self.erase_late_bound_regions(value
);
624 self.normalize_associated_type(&value
)
627 pub fn normalize_associated_type
<T
>(self, value
: &T
) -> T
628 where T
: TransNormalize
<'tcx
>
630 debug
!("normalize_associated_type(t={:?})", value
);
632 let value
= self.erase_regions(value
);
634 if !value
.has_projection_types() {
638 self.infer_ctxt(None
, None
, Reveal
::All
).enter(|infcx
| {
639 value
.trans_normalize(&infcx
)
643 pub fn normalize_associated_type_in_env
<T
>(
644 self, value
: &T
, env
: &'a ty
::ParameterEnvironment
<'tcx
>
646 where T
: TransNormalize
<'tcx
>
648 debug
!("normalize_associated_type_in_env(t={:?})", value
);
650 let value
= self.erase_regions(value
);
652 if !value
.has_projection_types() {
656 self.infer_ctxt(None
, Some(env
.clone()), Reveal
::All
).enter(|infcx
| {
657 value
.trans_normalize(&infcx
)
662 impl<'a
, 'gcx
, 'tcx
> InferCtxt
<'a
, 'gcx
, 'tcx
> {
663 fn normalize_projections_in
<T
>(&self, value
: &T
) -> T
::Lifted
664 where T
: TypeFoldable
<'tcx
> + ty
::Lift
<'gcx
>
666 let mut selcx
= traits
::SelectionContext
::new(self);
667 let cause
= traits
::ObligationCause
::dummy();
668 let traits
::Normalized { value: result, obligations }
=
669 traits
::normalize(&mut selcx
, cause
, value
);
671 debug
!("normalize_projections_in: result={:?} obligations={:?}",
672 result
, obligations
);
674 let mut fulfill_cx
= traits
::FulfillmentContext
::new();
676 for obligation
in obligations
{
677 fulfill_cx
.register_predicate_obligation(self, obligation
);
680 self.drain_fulfillment_cx_or_panic(DUMMY_SP
, &mut fulfill_cx
, &result
)
683 /// Finishes processes any obligations that remain in the
684 /// fulfillment context, and then returns the result with all type
685 /// variables removed and regions erased. Because this is intended
686 /// for use after type-check has completed, if any errors occur,
687 /// it will panic. It is used during normalization and other cases
688 /// where processing the obligations in `fulfill_cx` may cause
689 /// type inference variables that appear in `result` to be
690 /// unified, and hence we need to process those obligations to get
691 /// the complete picture of the type.
692 pub fn drain_fulfillment_cx_or_panic
<T
>(&self,
694 fulfill_cx
: &mut traits
::FulfillmentContext
<'tcx
>,
697 where T
: TypeFoldable
<'tcx
> + ty
::Lift
<'gcx
>
699 debug
!("drain_fulfillment_cx_or_panic()");
701 // In principle, we only need to do this so long as `result`
702 // contains unbound type parameters. It could be a slight
703 // optimization to stop iterating early.
704 match fulfill_cx
.select_all_or_error(self) {
707 span_bug
!(span
, "Encountered errors `{:?}` resolving bounds after type-checking",
712 let result
= self.resolve_type_vars_if_possible(result
);
713 let result
= self.tcx
.erase_regions(&result
);
715 match self.tcx
.lift_to_global(&result
) {
716 Some(result
) => result
,
718 span_bug
!(span
, "Uninferred types/regions in `{:?}`", result
);
723 pub fn projection_mode(&self) -> Reveal
{
727 pub fn freshen
<T
:TypeFoldable
<'tcx
>>(&self, t
: T
) -> T
{
728 t
.fold_with(&mut self.freshener())
731 pub fn type_var_diverges(&'a
self, ty
: Ty
) -> bool
{
733 ty
::TyInfer(ty
::TyVar(vid
)) => self.type_variables
.borrow().var_diverges(vid
),
738 pub fn freshener
<'b
>(&'b
self) -> TypeFreshener
<'b
, 'gcx
, 'tcx
> {
739 freshen
::TypeFreshener
::new(self)
742 pub fn type_is_unconstrained_numeric(&'a
self, ty
: Ty
) -> UnconstrainedNumeric
{
743 use ty
::error
::UnconstrainedNumeric
::Neither
;
744 use ty
::error
::UnconstrainedNumeric
::{UnconstrainedInt, UnconstrainedFloat}
;
746 ty
::TyInfer(ty
::IntVar(vid
)) => {
747 if self.int_unification_table
.borrow_mut().has_value(vid
) {
753 ty
::TyInfer(ty
::FloatVar(vid
)) => {
754 if self.float_unification_table
.borrow_mut().has_value(vid
) {
764 /// Returns a type variable's default fallback if any exists. A default
765 /// must be attached to the variable when created, if it is created
766 /// without a default, this will return None.
768 /// This code does not apply to integral or floating point variables,
769 /// only to use declared defaults.
771 /// See `new_ty_var_with_default` to create a type variable with a default.
772 /// See `type_variable::Default` for details about what a default entails.
773 pub fn default(&self, ty
: Ty
<'tcx
>) -> Option
<type_variable
::Default
<'tcx
>> {
775 ty
::TyInfer(ty
::TyVar(vid
)) => self.type_variables
.borrow().default(vid
),
780 pub fn unsolved_variables(&self) -> Vec
<ty
::Ty
<'tcx
>> {
781 let mut variables
= Vec
::new();
783 let unbound_ty_vars
= self.type_variables
785 .unsolved_variables()
787 .map(|t
| self.tcx
.mk_var(t
));
789 let unbound_int_vars
= self.int_unification_table
791 .unsolved_variables()
793 .map(|v
| self.tcx
.mk_int_var(v
));
795 let unbound_float_vars
= self.float_unification_table
797 .unsolved_variables()
799 .map(|v
| self.tcx
.mk_float_var(v
));
801 variables
.extend(unbound_ty_vars
);
802 variables
.extend(unbound_int_vars
);
803 variables
.extend(unbound_float_vars
);
808 fn combine_fields(&'a
self, trace
: TypeTrace
<'tcx
>)
809 -> CombineFields
<'a
, 'gcx
, 'tcx
> {
814 obligations
: PredicateObligations
::new(),
818 pub fn equate
<T
>(&'a
self, a_is_expected
: bool
, trace
: TypeTrace
<'tcx
>, a
: &T
, b
: &T
)
819 -> InferResult
<'tcx
, T
>
820 where T
: Relate
<'tcx
>
822 let mut fields
= self.combine_fields(trace
);
823 let result
= fields
.equate(a_is_expected
).relate(a
, b
);
824 result
.map(move |t
| InferOk { value: t, obligations: fields.obligations }
)
827 pub fn sub
<T
>(&'a
self, a_is_expected
: bool
, trace
: TypeTrace
<'tcx
>, a
: &T
, b
: &T
)
828 -> InferResult
<'tcx
, T
>
829 where T
: Relate
<'tcx
>
831 let mut fields
= self.combine_fields(trace
);
832 let result
= fields
.sub(a_is_expected
).relate(a
, b
);
833 result
.map(move |t
| InferOk { value: t, obligations: fields.obligations }
)
836 pub fn lub
<T
>(&'a
self, a_is_expected
: bool
, trace
: TypeTrace
<'tcx
>, a
: &T
, b
: &T
)
837 -> InferResult
<'tcx
, T
>
838 where T
: Relate
<'tcx
>
840 let mut fields
= self.combine_fields(trace
);
841 let result
= fields
.lub(a_is_expected
).relate(a
, b
);
842 result
.map(move |t
| InferOk { value: t, obligations: fields.obligations }
)
845 pub fn glb
<T
>(&'a
self, a_is_expected
: bool
, trace
: TypeTrace
<'tcx
>, a
: &T
, b
: &T
)
846 -> InferResult
<'tcx
, T
>
847 where T
: Relate
<'tcx
>
849 let mut fields
= self.combine_fields(trace
);
850 let result
= fields
.glb(a_is_expected
).relate(a
, b
);
851 result
.map(move |t
| InferOk { value: t, obligations: fields.obligations }
)
854 // Clear the "obligations in snapshot" flag, invoke the closure,
855 // then restore the flag to its original value. This flag is a
856 // debugging measure designed to detect cases where we start a
857 // snapshot, create type variables, register obligations involving
858 // those type variables in the fulfillment cx, and then have to
859 // unroll the snapshot, leaving "dangling type variables" behind.
860 // In such cases, the flag will be set by the fulfillment cx, and
861 // an assertion will fail when rolling the snapshot back. Very
862 // useful, much better than grovelling through megabytes of
865 // HOWEVER, in some cases the flag is wrong. In particular, we
866 // sometimes create a "mini-fulfilment-cx" in which we enroll
867 // obligations. As long as this fulfillment cx is fully drained
868 // before we return, this is not a problem, as there won't be any
869 // escaping obligations in the main cx. In those cases, you can
870 // use this function.
871 pub fn save_and_restore_obligations_in_snapshot_flag
<F
, R
>(&self, func
: F
) -> R
872 where F
: FnOnce(&Self) -> R
874 let flag
= self.obligations_in_snapshot
.get();
875 self.obligations_in_snapshot
.set(false);
876 let result
= func(self);
877 self.obligations_in_snapshot
.set(flag
);
881 fn start_snapshot(&self) -> CombinedSnapshot
{
882 debug
!("start_snapshot()");
884 let obligations_in_snapshot
= self.obligations_in_snapshot
.get();
885 self.obligations_in_snapshot
.set(false);
888 projection_cache_snapshot
: self.projection_cache
.borrow_mut().snapshot(),
889 type_snapshot
: self.type_variables
.borrow_mut().snapshot(),
890 int_snapshot
: self.int_unification_table
.borrow_mut().snapshot(),
891 float_snapshot
: self.float_unification_table
.borrow_mut().snapshot(),
892 region_vars_snapshot
: self.region_vars
.start_snapshot(),
893 obligations_in_snapshot
: obligations_in_snapshot
,
897 fn rollback_to(&self, cause
: &str, snapshot
: CombinedSnapshot
) {
898 debug
!("rollback_to(cause={})", cause
);
899 let CombinedSnapshot
{ projection_cache_snapshot
,
903 region_vars_snapshot
,
904 obligations_in_snapshot
} = snapshot
;
906 assert
!(!self.obligations_in_snapshot
.get());
907 self.obligations_in_snapshot
.set(obligations_in_snapshot
);
909 self.projection_cache
911 .rollback_to(projection_cache_snapshot
);
914 .rollback_to(type_snapshot
);
915 self.int_unification_table
917 .rollback_to(int_snapshot
);
918 self.float_unification_table
920 .rollback_to(float_snapshot
);
922 .rollback_to(region_vars_snapshot
);
925 fn commit_from(&self, snapshot
: CombinedSnapshot
) {
926 debug
!("commit_from()");
927 let CombinedSnapshot
{ projection_cache_snapshot
,
931 region_vars_snapshot
,
932 obligations_in_snapshot
} = snapshot
;
934 self.obligations_in_snapshot
.set(obligations_in_snapshot
);
936 self.projection_cache
938 .commit(projection_cache_snapshot
);
941 .commit(type_snapshot
);
942 self.int_unification_table
944 .commit(int_snapshot
);
945 self.float_unification_table
947 .commit(float_snapshot
);
949 .commit(region_vars_snapshot
);
952 /// Execute `f` and commit the bindings
953 pub fn commit_unconditionally
<R
, F
>(&self, f
: F
) -> R
where
957 let snapshot
= self.start_snapshot();
959 self.commit_from(snapshot
);
963 /// Execute `f` and commit the bindings if closure `f` returns `Ok(_)`
964 pub fn commit_if_ok
<T
, E
, F
>(&self, f
: F
) -> Result
<T
, E
> where
965 F
: FnOnce(&CombinedSnapshot
) -> Result
<T
, E
>
967 debug
!("commit_if_ok()");
968 let snapshot
= self.start_snapshot();
969 let r
= f(&snapshot
);
970 debug
!("commit_if_ok() -- r.is_ok() = {}", r
.is_ok());
972 Ok(_
) => { self.commit_from(snapshot); }
973 Err(_
) => { self.rollback_to("commit_if_ok -- error", snapshot); }
978 // Execute `f` in a snapshot, and commit the bindings it creates
979 pub fn in_snapshot
<T
, F
>(&self, f
: F
) -> T
where
980 F
: FnOnce(&CombinedSnapshot
) -> T
982 debug
!("in_snapshot()");
983 let snapshot
= self.start_snapshot();
984 let r
= f(&snapshot
);
985 self.commit_from(snapshot
);
989 /// Execute `f` and commit only the region bindings if successful.
990 /// The function f must be very careful not to leak any non-region
991 /// variables that get created.
992 pub fn commit_regions_if_ok
<T
, E
, F
>(&self, f
: F
) -> Result
<T
, E
> where
993 F
: FnOnce() -> Result
<T
, E
>
995 debug
!("commit_regions_if_ok()");
996 let CombinedSnapshot
{ projection_cache_snapshot
,
1000 region_vars_snapshot
,
1001 obligations_in_snapshot
} = self.start_snapshot();
1003 let r
= self.commit_if_ok(|_
| f());
1005 debug
!("commit_regions_if_ok: rolling back everything but regions");
1007 assert
!(!self.obligations_in_snapshot
.get());
1008 self.obligations_in_snapshot
.set(obligations_in_snapshot
);
1010 // Roll back any non-region bindings - they should be resolved
1011 // inside `f`, with, e.g. `resolve_type_vars_if_possible`.
1012 self.projection_cache
1014 .rollback_to(projection_cache_snapshot
);
1017 .rollback_to(type_snapshot
);
1018 self.int_unification_table
1020 .rollback_to(int_snapshot
);
1021 self.float_unification_table
1023 .rollback_to(float_snapshot
);
1025 // Commit region vars that may escape through resolved types.
1027 .commit(region_vars_snapshot
);
1032 /// Execute `f` then unroll any bindings it creates
1033 pub fn probe
<R
, F
>(&self, f
: F
) -> R
where
1034 F
: FnOnce(&CombinedSnapshot
) -> R
,
1037 let snapshot
= self.start_snapshot();
1038 let r
= f(&snapshot
);
1039 self.rollback_to("probe", snapshot
);
1043 pub fn add_given(&self,
1044 sub
: ty
::FreeRegion
,
1047 self.region_vars
.add_given(sub
, sup
);
1050 pub fn sub_types(&self,
1051 a_is_expected
: bool
,
1055 -> InferResult
<'tcx
, ()>
1057 debug
!("sub_types({:?} <: {:?})", a
, b
);
1058 self.commit_if_ok(|_
| {
1059 let trace
= TypeTrace
::types(origin
, a_is_expected
, a
, b
);
1060 self.sub(a_is_expected
, trace
, &a
, &b
).map(|ok
| ok
.unit())
1064 pub fn can_sub_types(&self,
1070 let origin
= TypeOrigin
::Misc(syntax_pos
::DUMMY_SP
);
1071 let trace
= TypeTrace
::types(origin
, true, a
, b
);
1072 self.sub(true, trace
, &a
, &b
).map(|InferOk { obligations, .. }
| {
1073 // FIXME(#32730) propagate obligations
1074 assert
!(obligations
.is_empty());
1079 pub fn eq_types(&self,
1080 a_is_expected
: bool
,
1084 -> InferResult
<'tcx
, ()>
1086 self.commit_if_ok(|_
| {
1087 let trace
= TypeTrace
::types(origin
, a_is_expected
, a
, b
);
1088 self.equate(a_is_expected
, trace
, &a
, &b
).map(|ok
| ok
.unit())
1092 pub fn eq_trait_refs(&self,
1093 a_is_expected
: bool
,
1095 a
: ty
::TraitRef
<'tcx
>,
1096 b
: ty
::TraitRef
<'tcx
>)
1097 -> InferResult
<'tcx
, ()>
1099 debug
!("eq_trait_refs({:?} = {:?})", a
, b
);
1100 self.commit_if_ok(|_
| {
1101 let trace
= TypeTrace
{
1103 values
: TraitRefs(ExpectedFound
::new(a_is_expected
, a
, b
))
1105 self.equate(a_is_expected
, trace
, &a
, &b
).map(|ok
| ok
.unit())
1109 pub fn eq_impl_headers(&self,
1110 a_is_expected
: bool
,
1112 a
: &ty
::ImplHeader
<'tcx
>,
1113 b
: &ty
::ImplHeader
<'tcx
>)
1114 -> InferResult
<'tcx
, ()>
1116 debug
!("eq_impl_header({:?} = {:?})", a
, b
);
1117 match (a
.trait_ref
, b
.trait_ref
) {
1118 (Some(a_ref
), Some(b_ref
)) => self.eq_trait_refs(a_is_expected
, origin
, a_ref
, b_ref
),
1119 (None
, None
) => self.eq_types(a_is_expected
, origin
, a
.self_ty
, b
.self_ty
),
1120 _
=> bug
!("mk_eq_impl_headers given mismatched impl kinds"),
1124 pub fn sub_poly_trait_refs(&self,
1125 a_is_expected
: bool
,
1127 a
: ty
::PolyTraitRef
<'tcx
>,
1128 b
: ty
::PolyTraitRef
<'tcx
>)
1129 -> InferResult
<'tcx
, ()>
1131 debug
!("sub_poly_trait_refs({:?} <: {:?})", a
, b
);
1132 self.commit_if_ok(|_
| {
1133 let trace
= TypeTrace
{
1135 values
: PolyTraitRefs(ExpectedFound
::new(a_is_expected
, a
, b
))
1137 self.sub(a_is_expected
, trace
, &a
, &b
).map(|ok
| ok
.unit())
1141 pub fn sub_regions(&self,
1142 origin
: SubregionOrigin
<'tcx
>,
1143 a
: &'tcx ty
::Region
,
1144 b
: &'tcx ty
::Region
) {
1145 debug
!("sub_regions({:?} <: {:?})", a
, b
);
1146 self.region_vars
.make_subregion(origin
, a
, b
);
1149 pub fn equality_predicate(&self,
1151 predicate
: &ty
::PolyEquatePredicate
<'tcx
>)
1152 -> InferResult
<'tcx
, ()>
1154 self.commit_if_ok(|snapshot
| {
1155 let (ty
::EquatePredicate(a
, b
), skol_map
) =
1156 self.skolemize_late_bound_regions(predicate
, snapshot
);
1157 let origin
= TypeOrigin
::EquatePredicate(span
);
1158 let eqty_ok
= self.eq_types(false, origin
, a
, b
)?
;
1159 self.leak_check(false, span
, &skol_map
, snapshot
)?
;
1160 self.pop_skolemized(skol_map
, snapshot
);
1165 pub fn region_outlives_predicate(&self,
1166 cause
: &traits
::ObligationCause
<'tcx
>,
1167 predicate
: &ty
::PolyRegionOutlivesPredicate
<'tcx
>)
1170 self.commit_if_ok(|snapshot
| {
1171 let (ty
::OutlivesPredicate(r_a
, r_b
), skol_map
) =
1172 self.skolemize_late_bound_regions(predicate
, snapshot
);
1174 SubregionOrigin
::from_obligation_cause(cause
,
1175 || RelateRegionParamBound(cause
.span
));
1176 self.sub_regions(origin
, r_b
, r_a
); // `b : a` ==> `a <= b`
1177 self.leak_check(false, cause
.span
, &skol_map
, snapshot
)?
;
1178 Ok(self.pop_skolemized(skol_map
, snapshot
))
1182 pub fn next_ty_var_id(&self, diverging
: bool
) -> TyVid
{
1185 .new_var(diverging
, None
)
1188 pub fn next_ty_var(&self) -> Ty
<'tcx
> {
1189 self.tcx
.mk_var(self.next_ty_var_id(false))
1192 pub fn next_diverging_ty_var(&self) -> Ty
<'tcx
> {
1193 self.tcx
.mk_var(self.next_ty_var_id(true))
1196 pub fn next_ty_vars(&self, n
: usize) -> Vec
<Ty
<'tcx
>> {
1197 (0..n
).map(|_i
| self.next_ty_var()).collect()
1200 pub fn next_int_var_id(&self) -> IntVid
{
1201 self.int_unification_table
1206 pub fn next_float_var_id(&self) -> FloatVid
{
1207 self.float_unification_table
1212 pub fn next_region_var(&self, origin
: RegionVariableOrigin
)
1213 -> &'tcx ty
::Region
{
1214 self.tcx
.mk_region(ty
::ReVar(self.region_vars
.new_region_var(origin
)))
1217 /// Create a region inference variable for the given
1218 /// region parameter definition.
1219 pub fn region_var_for_def(&self,
1221 def
: &ty
::RegionParameterDef
)
1222 -> &'tcx ty
::Region
{
1223 self.next_region_var(EarlyBoundRegion(span
, def
.name
))
1226 /// Create a type inference variable for the given
1227 /// type parameter definition. The substitutions are
1228 /// for actual parameters that may be referred to by
1229 /// the default of this type parameter, if it exists.
1230 /// E.g. `struct Foo<A, B, C = (A, B)>(...);` when
1231 /// used in a path such as `Foo::<T, U>::new()` will
1232 /// use an inference variable for `C` with `[T, U]`
1233 /// as the substitutions for the default, `(T, U)`.
1234 pub fn type_var_for_def(&self,
1236 def
: &ty
::TypeParameterDef
<'tcx
>,
1237 substs
: &[Kind
<'tcx
>])
1239 let default = def
.default.map(|default| {
1240 type_variable
::Default
{
1241 ty
: default.subst_spanned(self.tcx
, substs
, Some(span
)),
1243 def_id
: def
.default_def_id
1248 let ty_var_id
= self.type_variables
1250 .new_var(false, default);
1252 self.tcx
.mk_var(ty_var_id
)
1255 /// Given a set of generics defined on a type or impl, returns a substitution mapping each
1256 /// type/region parameter to a fresh inference variable.
1257 pub fn fresh_substs_for_item(&self,
1260 -> &'tcx Substs
<'tcx
> {
1261 Substs
::for_item(self.tcx
, def_id
, |def
, _
| {
1262 self.region_var_for_def(span
, def
)
1264 self.type_var_for_def(span
, def
, substs
)
1268 pub fn fresh_bound_region(&self, debruijn
: ty
::DebruijnIndex
) -> &'tcx ty
::Region
{
1269 self.region_vars
.new_bound(debruijn
)
1272 /// True if errors have been reported since this infcx was
1273 /// created. This is sometimes used as a heuristic to skip
1274 /// reporting errors that often occur as a result of earlier
1275 /// errors, but where it's hard to be 100% sure (e.g., unresolved
1276 /// inference variables, regionck errors).
1277 pub fn is_tainted_by_errors(&self) -> bool
{
1278 debug
!("is_tainted_by_errors(err_count={}, err_count_on_creation={}, \
1279 tainted_by_errors_flag={})",
1280 self.tcx
.sess
.err_count(),
1281 self.err_count_on_creation
,
1282 self.tainted_by_errors_flag
.get());
1284 if self.tcx
.sess
.err_count() > self.err_count_on_creation
{
1285 return true; // errors reported since this infcx was made
1287 self.tainted_by_errors_flag
.get()
1290 /// Set the "tainted by errors" flag to true. We call this when we
1291 /// observe an error from a prior pass.
1292 pub fn set_tainted_by_errors(&self) {
1293 debug
!("set_tainted_by_errors()");
1294 self.tainted_by_errors_flag
.set(true)
1297 pub fn node_type(&self, id
: ast
::NodeId
) -> Ty
<'tcx
> {
1298 match self.tables
.borrow().node_types
.get(&id
) {
1301 None
if self.is_tainted_by_errors() =>
1304 bug
!("no type for node {}: {} in fcx",
1305 id
, self.tcx
.map
.node_to_string(id
));
1310 pub fn expr_ty(&self, ex
: &hir
::Expr
) -> Ty
<'tcx
> {
1311 match self.tables
.borrow().node_types
.get(&ex
.id
) {
1314 bug
!("no type for expr in fcx");
1319 pub fn resolve_regions_and_report_errors(&self,
1320 free_regions
: &FreeRegionMap
,
1321 subject_node_id
: ast
::NodeId
) {
1322 let errors
= self.region_vars
.resolve_regions(free_regions
, subject_node_id
);
1323 if !self.is_tainted_by_errors() {
1324 // As a heuristic, just skip reporting region errors
1325 // altogether if other errors have been reported while
1326 // this infcx was in use. This is totally hokey but
1327 // otherwise we have a hard time separating legit region
1328 // errors from silly ones.
1329 self.report_region_errors(&errors
); // see error_reporting.rs
1333 pub fn ty_to_string(&self, t
: Ty
<'tcx
>) -> String
{
1334 self.resolve_type_vars_if_possible(&t
).to_string()
1337 pub fn tys_to_string(&self, ts
: &[Ty
<'tcx
>]) -> String
{
1338 let tstrs
: Vec
<String
> = ts
.iter().map(|t
| self.ty_to_string(*t
)).collect();
1339 format
!("({})", tstrs
.join(", "))
1342 pub fn trait_ref_to_string(&self, t
: &ty
::TraitRef
<'tcx
>) -> String
{
1343 self.resolve_type_vars_if_possible(t
).to_string()
1346 pub fn shallow_resolve(&self, typ
: Ty
<'tcx
>) -> Ty
<'tcx
> {
1348 ty
::TyInfer(ty
::TyVar(v
)) => {
1349 // Not entirely obvious: if `typ` is a type variable,
1350 // it can be resolved to an int/float variable, which
1351 // can then be recursively resolved, hence the
1352 // recursion. Note though that we prevent type
1353 // variables from unifying to other type variables
1354 // directly (though they may be embedded
1355 // structurally), and we prevent cycles in any case,
1356 // so this recursion should always be of very limited
1358 self.type_variables
.borrow_mut()
1360 .map(|t
| self.shallow_resolve(t
))
1364 ty
::TyInfer(ty
::IntVar(v
)) => {
1365 self.int_unification_table
1368 .map(|v
| v
.to_type(self.tcx
))
1372 ty
::TyInfer(ty
::FloatVar(v
)) => {
1373 self.float_unification_table
1376 .map(|v
| v
.to_type(self.tcx
))
1386 pub fn resolve_type_vars_if_possible
<T
>(&self, value
: &T
) -> T
1387 where T
: TypeFoldable
<'tcx
>
1390 * Where possible, replaces type/int/float variables in
1391 * `value` with their final value. Note that region variables
1392 * are unaffected. If a type variable has not been unified, it
1393 * is left as is. This is an idempotent operation that does
1394 * not affect inference state in any way and so you can do it
1398 if !value
.needs_infer() {
1399 return value
.clone(); // avoid duplicated subst-folding
1401 let mut r
= resolve
::OpportunisticTypeResolver
::new(self);
1402 value
.fold_with(&mut r
)
1405 pub fn resolve_type_and_region_vars_if_possible
<T
>(&self, value
: &T
) -> T
1406 where T
: TypeFoldable
<'tcx
>
1408 let mut r
= resolve
::OpportunisticTypeAndRegionResolver
::new(self);
1409 value
.fold_with(&mut r
)
1412 /// Resolves all type variables in `t` and then, if any were left
1413 /// unresolved, substitutes an error type. This is used after the
1414 /// main checking when doing a second pass before writeback. The
1415 /// justification is that writeback will produce an error for
1416 /// these unconstrained type variables.
1417 fn resolve_type_vars_or_error(&self, t
: &Ty
<'tcx
>) -> mc
::McResult
<Ty
<'tcx
>> {
1418 let ty
= self.resolve_type_vars_if_possible(t
);
1419 if ty
.references_error() || ty
.is_ty_var() {
1420 debug
!("resolve_type_vars_or_error: error from {:?}", ty
);
1427 pub fn fully_resolve
<T
:TypeFoldable
<'tcx
>>(&self, value
: &T
) -> FixupResult
<T
> {
1429 * Attempts to resolve all type/region variables in
1430 * `value`. Region inference must have been run already (e.g.,
1431 * by calling `resolve_regions_and_report_errors`). If some
1432 * variable was never unified, an `Err` results.
1434 * This method is idempotent, but it not typically not invoked
1435 * except during the writeback phase.
1438 resolve
::fully_resolve(self, value
)
1441 // [Note-Type-error-reporting]
1442 // An invariant is that anytime the expected or actual type is TyError (the special
1443 // error type, meaning that an error occurred when typechecking this expression),
1444 // this is a derived error. The error cascaded from another error (that was already
1445 // reported), so it's not useful to display it to the user.
1446 // The following methods implement this logic.
1447 // They check if either the actual or expected type is TyError, and don't print the error
1448 // in this case. The typechecker should only ever report type errors involving mismatched
1449 // types using one of these methods, and should not call span_err directly for such
1452 pub fn type_error_message
<M
>(&self,
1455 actual_ty
: Ty
<'tcx
>)
1456 where M
: FnOnce(String
) -> String
,
1458 self.type_error_struct(sp
, mk_msg
, actual_ty
).emit();
1461 // FIXME: this results in errors without an error code. Deprecate?
1462 pub fn type_error_struct
<M
>(&self,
1465 actual_ty
: Ty
<'tcx
>)
1466 -> DiagnosticBuilder
<'tcx
>
1467 where M
: FnOnce(String
) -> String
,
1469 self.type_error_struct_with_diag(sp
, |actual_ty
| {
1470 self.tcx
.sess
.struct_span_err(sp
, &mk_msg(actual_ty
))
1474 pub fn type_error_struct_with_diag
<M
>(&self,
1477 actual_ty
: Ty
<'tcx
>)
1478 -> DiagnosticBuilder
<'tcx
>
1479 where M
: FnOnce(String
) -> DiagnosticBuilder
<'tcx
>,
1481 let actual_ty
= self.resolve_type_vars_if_possible(&actual_ty
);
1482 debug
!("type_error_struct_with_diag({:?}, {:?})", sp
, actual_ty
);
1484 // Don't report an error if actual type is TyError.
1485 if actual_ty
.references_error() {
1486 return self.tcx
.sess
.diagnostic().struct_dummy();
1489 mk_diag(self.ty_to_string(actual_ty
))
1492 pub fn report_mismatched_types(&self,
1496 err
: TypeError
<'tcx
>) {
1497 let trace
= TypeTrace
{
1499 values
: Types(ExpectedFound
{
1504 self.report_and_explain_type_error(trace
, &err
).emit();
1507 pub fn report_conflicting_default_types(&self,
1509 expected
: type_variable
::Default
<'tcx
>,
1510 actual
: type_variable
::Default
<'tcx
>) {
1511 let trace
= TypeTrace
{
1512 origin
: TypeOrigin
::Misc(span
),
1513 values
: Types(ExpectedFound
{
1514 expected
: expected
.ty
,
1519 self.report_and_explain_type_error(
1521 &TypeError
::TyParamDefaultMismatch(ExpectedFound
{
1528 pub fn replace_late_bound_regions_with_fresh_var
<T
>(
1531 lbrct
: LateBoundRegionConversionTime
,
1532 value
: &ty
::Binder
<T
>)
1533 -> (T
, FnvHashMap
<ty
::BoundRegion
, &'tcx ty
::Region
>)
1534 where T
: TypeFoldable
<'tcx
>
1536 self.tcx
.replace_late_bound_regions(
1538 |br
| self.next_region_var(LateBoundRegion(span
, br
, lbrct
)))
1541 /// Given a higher-ranked projection predicate like:
1543 /// for<'a> <T as Fn<&'a u32>>::Output = &'a u32
1545 /// and a target trait-ref like:
1547 /// <T as Fn<&'x u32>>
1549 /// find a substitution `S` for the higher-ranked regions (here,
1550 /// `['a => 'x]`) such that the predicate matches the trait-ref,
1551 /// and then return the value (here, `&'a u32`) but with the
1552 /// substitution applied (hence, `&'x u32`).
1554 /// See `higher_ranked_match` in `higher_ranked/mod.rs` for more
1556 pub fn match_poly_projection_predicate(&self,
1558 match_a
: ty
::PolyProjectionPredicate
<'tcx
>,
1559 match_b
: ty
::TraitRef
<'tcx
>)
1560 -> InferResult
<'tcx
, HrMatchResult
<Ty
<'tcx
>>>
1562 let span
= origin
.span();
1563 let match_trait_ref
= match_a
.skip_binder().projection_ty
.trait_ref
;
1564 let trace
= TypeTrace
{
1566 values
: TraitRefs(ExpectedFound
::new(true, match_trait_ref
, match_b
))
1569 let match_pair
= match_a
.map_bound(|p
| (p
.projection_ty
.trait_ref
, p
.ty
));
1570 let mut combine
= self.combine_fields(trace
);
1571 let result
= combine
.higher_ranked_match(span
, &match_pair
, &match_b
, true)?
;
1572 Ok(InferOk { value: result, obligations: combine.obligations }
)
1575 /// See `verify_generic_bound` method in `region_inference`
1576 pub fn verify_generic_bound(&self,
1577 origin
: SubregionOrigin
<'tcx
>,
1578 kind
: GenericKind
<'tcx
>,
1579 a
: &'tcx ty
::Region
,
1580 bound
: VerifyBound
<'tcx
>) {
1581 debug
!("verify_generic_bound({:?}, {:?} <: {:?})",
1586 self.region_vars
.verify_generic_bound(origin
, kind
, a
, bound
);
1589 pub fn can_equate
<T
>(&self, a
: &T
, b
: &T
) -> UnitResult
<'tcx
>
1590 where T
: Relate
<'tcx
> + fmt
::Debug
1592 debug
!("can_equate({:?}, {:?})", a
, b
);
1594 // Gin up a dummy trace, since this won't be committed
1595 // anyhow. We should make this typetrace stuff more
1596 // generic so we don't have to do anything quite this
1598 let trace
= TypeTrace
::dummy(self.tcx
);
1599 self.equate(true, trace
, a
, b
).map(|InferOk { obligations, .. }
| {
1600 // FIXME(#32730) propagate obligations
1601 assert
!(obligations
.is_empty());
1606 pub fn node_ty(&self, id
: ast
::NodeId
) -> McResult
<Ty
<'tcx
>> {
1607 let ty
= self.node_type(id
);
1608 self.resolve_type_vars_or_error(&ty
)
1611 pub fn expr_ty_adjusted(&self, expr
: &hir
::Expr
) -> McResult
<Ty
<'tcx
>> {
1612 let ty
= self.tables
.borrow().expr_ty_adjusted(expr
);
1613 self.resolve_type_vars_or_error(&ty
)
1616 pub fn type_moves_by_default(&self, ty
: Ty
<'tcx
>, span
: Span
) -> bool
{
1617 let ty
= self.resolve_type_vars_if_possible(&ty
);
1618 if let Some(ty
) = self.tcx
.lift_to_global(&ty
) {
1619 // Even if the type may have no inference variables, during
1620 // type-checking closure types are in local tables only.
1621 let local_closures
= match self.tables
{
1622 InferTables
::Local(_
) => ty
.has_closure_types(),
1623 InferTables
::Global(_
) => false
1625 if !local_closures
{
1626 return ty
.moves_by_default(self.tcx
.global_tcx(), self.param_env(), span
);
1630 // this can get called from typeck (by euv), and moves_by_default
1631 // rightly refuses to work with inference variables, but
1632 // moves_by_default has a cache, which we want to use in other
1634 !traits
::type_known_to_meet_builtin_bound(self, ty
, ty
::BoundCopy
, span
)
1637 pub fn node_method_ty(&self, method_call
: ty
::MethodCall
)
1638 -> Option
<Ty
<'tcx
>> {
1643 .map(|method
| method
.ty
)
1644 .map(|ty
| self.resolve_type_vars_if_possible(&ty
))
1647 pub fn node_method_id(&self, method_call
: ty
::MethodCall
)
1653 .map(|method
| method
.def_id
)
1656 pub fn adjustments(&self) -> Ref
<NodeMap
<adjustment
::Adjustment
<'tcx
>>> {
1657 fn project_adjustments
<'a
, 'tcx
>(tables
: &'a ty
::Tables
<'tcx
>)
1658 -> &'a NodeMap
<adjustment
::Adjustment
<'tcx
>> {
1662 Ref
::map(self.tables
.borrow(), project_adjustments
)
1665 pub fn is_method_call(&self, id
: ast
::NodeId
) -> bool
{
1666 self.tables
.borrow().method_map
.contains_key(&ty
::MethodCall
::expr(id
))
1669 pub fn temporary_scope(&self, rvalue_id
: ast
::NodeId
) -> Option
<CodeExtent
> {
1670 self.tcx
.region_maps
.temporary_scope(rvalue_id
)
1673 pub fn upvar_capture(&self, upvar_id
: ty
::UpvarId
) -> Option
<ty
::UpvarCapture
<'tcx
>> {
1674 self.tables
.borrow().upvar_capture_map
.get(&upvar_id
).cloned()
1677 pub fn param_env(&self) -> &ty
::ParameterEnvironment
<'gcx
> {
1678 &self.parameter_environment
1681 pub fn closure_kind(&self,
1683 -> Option
<ty
::ClosureKind
>
1685 if def_id
.is_local() {
1686 self.tables
.borrow().closure_kinds
.get(&def_id
).cloned()
1688 // During typeck, ALL closures are local. But afterwards,
1689 // during trans, we see closure ids from other traits.
1690 // That may require loading the closure data out of the
1692 Some(self.tcx
.closure_kind(def_id
))
1696 pub fn closure_type(&self,
1698 substs
: ty
::ClosureSubsts
<'tcx
>)
1699 -> ty
::ClosureTy
<'tcx
>
1701 if let InferTables
::Local(tables
) = self.tables
{
1702 if let Some(ty
) = tables
.borrow().closure_tys
.get(&def_id
) {
1703 return ty
.subst(self.tcx
, substs
.func_substs
);
1707 let closure_ty
= self.tcx
.closure_type(def_id
, substs
);
1712 impl<'a
, 'gcx
, 'tcx
> TypeTrace
<'tcx
> {
1713 pub fn span(&self) -> Span
{
1717 pub fn types(origin
: TypeOrigin
,
1718 a_is_expected
: bool
,
1721 -> TypeTrace
<'tcx
> {
1724 values
: Types(ExpectedFound
::new(a_is_expected
, a
, b
))
1728 pub fn dummy(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>) -> TypeTrace
<'tcx
> {
1730 origin
: TypeOrigin
::Misc(syntax_pos
::DUMMY_SP
),
1731 values
: Types(ExpectedFound
{
1732 expected
: tcx
.types
.err
,
1733 found
: tcx
.types
.err
,
1739 impl<'tcx
> fmt
::Debug
for TypeTrace
<'tcx
> {
1740 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
1741 write
!(f
, "TypeTrace({:?})", self.origin
)
1746 pub fn span(&self) -> Span
{
1748 TypeOrigin
::MethodCompatCheck(span
) => span
,
1749 TypeOrigin
::ExprAssignable(span
) => span
,
1750 TypeOrigin
::Misc(span
) => span
,
1751 TypeOrigin
::RelateOutputImplTypes(span
) => span
,
1752 TypeOrigin
::MatchExpressionArm(match_span
, ..) => match_span
,
1753 TypeOrigin
::IfExpression(span
) => span
,
1754 TypeOrigin
::IfExpressionWithNoElse(span
) => span
,
1755 TypeOrigin
::EquatePredicate(span
) => span
,
1756 TypeOrigin
::MainFunctionType(span
) => span
,
1757 TypeOrigin
::StartFunctionType(span
) => span
,
1758 TypeOrigin
::IntrinsicType(span
) => span
,
1759 TypeOrigin
::MethodReceiver(span
) => span
,
1764 impl<'tcx
> SubregionOrigin
<'tcx
> {
1765 pub fn span(&self) -> Span
{
1767 Subtype(ref a
) => a
.span(),
1768 InfStackClosure(a
) => a
,
1769 InvokeClosure(a
) => a
,
1770 DerefPointer(a
) => a
,
1771 FreeVariable(a
, _
) => a
,
1773 RelateObjectBound(a
) => a
,
1774 RelateParamBound(a
, _
) => a
,
1775 RelateRegionParamBound(a
) => a
,
1776 RelateDefaultParamBound(a
, _
) => a
,
1778 ReborrowUpvar(a
, _
) => a
,
1779 DataBorrowed(_
, a
) => a
,
1780 ReferenceOutlivesReferent(_
, a
) => a
,
1781 ParameterInScope(_
, a
) => a
,
1782 ExprTypeIsNotInScope(_
, a
) => a
,
1783 BindingTypeIsNotValidAtDecl(a
) => a
,
1790 SafeDestructor(a
) => a
,
1791 CompareImplMethodObligation { span, .. }
=> span
,
1795 pub fn from_obligation_cause
<F
>(cause
: &traits
::ObligationCause
<'tcx
>,
1798 where F
: FnOnce() -> Self
1801 traits
::ObligationCauseCode
::ReferenceOutlivesReferent(ref_type
) =>
1802 SubregionOrigin
::ReferenceOutlivesReferent(ref_type
, cause
.span
),
1804 traits
::ObligationCauseCode
::CompareImplMethodObligation
{ item_name
,
1808 SubregionOrigin
::CompareImplMethodObligation
{
1810 item_name
: item_name
,
1811 impl_item_def_id
: impl_item_def_id
,
1812 trait_item_def_id
: trait_item_def_id
,
1821 impl RegionVariableOrigin
{
1822 pub fn span(&self) -> Span
{
1824 MiscVariable(a
) => a
,
1825 PatternRegion(a
) => a
,
1826 AddrOfRegion(a
) => a
,
1829 EarlyBoundRegion(a
, _
) => a
,
1830 LateBoundRegion(a
, ..) => a
,
1831 BoundRegionInCoherence(_
) => syntax_pos
::DUMMY_SP
,
1832 UpvarRegion(_
, a
) => a
1837 impl<'tcx
> TypeFoldable
<'tcx
> for TypeOrigin
{
1838 fn super_fold_with
<'gcx
: 'tcx
, F
: TypeFolder
<'gcx
, 'tcx
>>(&self, _folder
: &mut F
) -> Self {
1842 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, _visitor
: &mut V
) -> bool
{
1847 impl<'tcx
> TypeFoldable
<'tcx
> for ValuePairs
<'tcx
> {
1848 fn super_fold_with
<'gcx
: 'tcx
, F
: TypeFolder
<'gcx
, 'tcx
>>(&self, folder
: &mut F
) -> Self {
1850 ValuePairs
::Types(ref ef
) => {
1851 ValuePairs
::Types(ef
.fold_with(folder
))
1853 ValuePairs
::TraitRefs(ref ef
) => {
1854 ValuePairs
::TraitRefs(ef
.fold_with(folder
))
1856 ValuePairs
::PolyTraitRefs(ref ef
) => {
1857 ValuePairs
::PolyTraitRefs(ef
.fold_with(folder
))
1862 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
1864 ValuePairs
::Types(ref ef
) => ef
.visit_with(visitor
),
1865 ValuePairs
::TraitRefs(ref ef
) => ef
.visit_with(visitor
),
1866 ValuePairs
::PolyTraitRefs(ref ef
) => ef
.visit_with(visitor
),
1871 impl<'tcx
> TypeFoldable
<'tcx
> for TypeTrace
<'tcx
> {
1872 fn super_fold_with
<'gcx
: 'tcx
, F
: TypeFolder
<'gcx
, 'tcx
>>(&self, folder
: &mut F
) -> Self {
1874 origin
: self.origin
.fold_with(folder
),
1875 values
: self.values
.fold_with(folder
)
1879 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
1880 self.origin
.visit_with(visitor
) || self.values
.visit_with(visitor
)