Auto merge of #76906 - Nicholas-Baron:shorten_typeck_check, r=oli-obk
Split rustc_typeck::check into separate files Contributing to #60302.
This commit is contained in:
commit
c113030f6b
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,78 @@
|
||||||
|
use rustc_span::source_map::DUMMY_SP;
|
||||||
|
use rustc_span::{self, Span};
|
||||||
|
use std::{cmp, ops};
|
||||||
|
|
||||||
|
/// Tracks whether executing a node may exit normally (versus
|
||||||
|
/// return/break/panic, which "diverge", leaving dead code in their
|
||||||
|
/// wake). Tracked semi-automatically (through type variables marked
|
||||||
|
/// as diverging), with some manual adjustments for control-flow
|
||||||
|
/// primitives (approximating a CFG).
|
||||||
|
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
|
||||||
|
pub enum Diverges {
|
||||||
|
/// Potentially unknown, some cases converge,
|
||||||
|
/// others require a CFG to determine them.
|
||||||
|
Maybe,
|
||||||
|
|
||||||
|
/// Definitely known to diverge and therefore
|
||||||
|
/// not reach the next sibling or its parent.
|
||||||
|
Always {
|
||||||
|
/// The `Span` points to the expression
|
||||||
|
/// that caused us to diverge
|
||||||
|
/// (e.g. `return`, `break`, etc).
|
||||||
|
span: Span,
|
||||||
|
/// In some cases (e.g. a `match` expression
|
||||||
|
/// where all arms diverge), we may be
|
||||||
|
/// able to provide a more informative
|
||||||
|
/// message to the user.
|
||||||
|
/// If this is `None`, a default message
|
||||||
|
/// will be generated, which is suitable
|
||||||
|
/// for most cases.
|
||||||
|
custom_note: Option<&'static str>,
|
||||||
|
},
|
||||||
|
|
||||||
|
/// Same as `Always` but with a reachability
|
||||||
|
/// warning already emitted.
|
||||||
|
WarnedAlways,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Convenience impls for combining `Diverges`.
|
||||||
|
|
||||||
|
impl ops::BitAnd for Diverges {
|
||||||
|
type Output = Self;
|
||||||
|
fn bitand(self, other: Self) -> Self {
|
||||||
|
cmp::min(self, other)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ops::BitOr for Diverges {
|
||||||
|
type Output = Self;
|
||||||
|
fn bitor(self, other: Self) -> Self {
|
||||||
|
cmp::max(self, other)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ops::BitAndAssign for Diverges {
|
||||||
|
fn bitand_assign(&mut self, other: Self) {
|
||||||
|
*self = *self & other;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ops::BitOrAssign for Diverges {
|
||||||
|
fn bitor_assign(&mut self, other: Self) {
|
||||||
|
*self = *self | other;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Diverges {
|
||||||
|
/// Creates a `Diverges::Always` with the provided `span` and the default note message.
|
||||||
|
pub(super) fn always(span: Span) -> Diverges {
|
||||||
|
Diverges::Always { span, custom_note: None }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn is_always(self) -> bool {
|
||||||
|
// Enum comparison ignores the
|
||||||
|
// contents of fields, so we just
|
||||||
|
// fill them in with garbage here.
|
||||||
|
self >= Diverges::Always { span: DUMMY_SP, custom_note: None }
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,117 @@
|
||||||
|
use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
|
||||||
|
use rustc_middle::ty::{self, Ty};
|
||||||
|
use rustc_span::{self, Span};
|
||||||
|
|
||||||
|
use super::Expectation::*;
|
||||||
|
use super::FnCtxt;
|
||||||
|
|
||||||
|
/// When type-checking an expression, we propagate downward
|
||||||
|
/// whatever type hint we are able in the form of an `Expectation`.
|
||||||
|
#[derive(Copy, Clone, Debug)]
|
||||||
|
pub enum Expectation<'tcx> {
|
||||||
|
/// We know nothing about what type this expression should have.
|
||||||
|
NoExpectation,
|
||||||
|
|
||||||
|
/// This expression should have the type given (or some subtype).
|
||||||
|
ExpectHasType(Ty<'tcx>),
|
||||||
|
|
||||||
|
/// This expression will be cast to the `Ty`.
|
||||||
|
ExpectCastableToType(Ty<'tcx>),
|
||||||
|
|
||||||
|
/// This rvalue expression will be wrapped in `&` or `Box` and coerced
|
||||||
|
/// to `&Ty` or `Box<Ty>`, respectively. `Ty` is `[A]` or `Trait`.
|
||||||
|
ExpectRvalueLikeUnsized(Ty<'tcx>),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'tcx> Expectation<'tcx> {
|
||||||
|
// Disregard "castable to" expectations because they
|
||||||
|
// can lead us astray. Consider for example `if cond
|
||||||
|
// {22} else {c} as u8` -- if we propagate the
|
||||||
|
// "castable to u8" constraint to 22, it will pick the
|
||||||
|
// type 22u8, which is overly constrained (c might not
|
||||||
|
// be a u8). In effect, the problem is that the
|
||||||
|
// "castable to" expectation is not the tightest thing
|
||||||
|
// we can say, so we want to drop it in this case.
|
||||||
|
// The tightest thing we can say is "must unify with
|
||||||
|
// else branch". Note that in the case of a "has type"
|
||||||
|
// constraint, this limitation does not hold.
|
||||||
|
|
||||||
|
// If the expected type is just a type variable, then don't use
|
||||||
|
// an expected type. Otherwise, we might write parts of the type
|
||||||
|
// when checking the 'then' block which are incompatible with the
|
||||||
|
// 'else' branch.
|
||||||
|
pub(super) fn adjust_for_branches(&self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
|
||||||
|
match *self {
|
||||||
|
ExpectHasType(ety) => {
|
||||||
|
let ety = fcx.shallow_resolve(ety);
|
||||||
|
if !ety.is_ty_var() { ExpectHasType(ety) } else { NoExpectation }
|
||||||
|
}
|
||||||
|
ExpectRvalueLikeUnsized(ety) => ExpectRvalueLikeUnsized(ety),
|
||||||
|
_ => NoExpectation,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Provides an expectation for an rvalue expression given an *optional*
|
||||||
|
/// hint, which is not required for type safety (the resulting type might
|
||||||
|
/// be checked higher up, as is the case with `&expr` and `box expr`), but
|
||||||
|
/// is useful in determining the concrete type.
|
||||||
|
///
|
||||||
|
/// The primary use case is where the expected type is a fat pointer,
|
||||||
|
/// like `&[isize]`. For example, consider the following statement:
|
||||||
|
///
|
||||||
|
/// let x: &[isize] = &[1, 2, 3];
|
||||||
|
///
|
||||||
|
/// In this case, the expected type for the `&[1, 2, 3]` expression is
|
||||||
|
/// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
|
||||||
|
/// expectation `ExpectHasType([isize])`, that would be too strong --
|
||||||
|
/// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
|
||||||
|
/// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
|
||||||
|
/// to the type `&[isize]`. Therefore, we propagate this more limited hint,
|
||||||
|
/// which still is useful, because it informs integer literals and the like.
|
||||||
|
/// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
|
||||||
|
/// for examples of where this comes up,.
|
||||||
|
pub(super) fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
|
||||||
|
match fcx.tcx.struct_tail_without_normalization(ty).kind() {
|
||||||
|
ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
|
||||||
|
_ => ExpectHasType(ty),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Resolves `expected` by a single level if it is a variable. If
|
||||||
|
// there is no expected type or resolution is not possible (e.g.,
|
||||||
|
// no constraints yet present), just returns `None`.
|
||||||
|
fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) -> Expectation<'tcx> {
|
||||||
|
match self {
|
||||||
|
NoExpectation => NoExpectation,
|
||||||
|
ExpectCastableToType(t) => ExpectCastableToType(fcx.resolve_vars_if_possible(&t)),
|
||||||
|
ExpectHasType(t) => ExpectHasType(fcx.resolve_vars_if_possible(&t)),
|
||||||
|
ExpectRvalueLikeUnsized(t) => ExpectRvalueLikeUnsized(fcx.resolve_vars_if_possible(&t)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn to_option(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
|
||||||
|
match self.resolve(fcx) {
|
||||||
|
NoExpectation => None,
|
||||||
|
ExpectCastableToType(ty) | ExpectHasType(ty) | ExpectRvalueLikeUnsized(ty) => Some(ty),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// It sometimes happens that we want to turn an expectation into
|
||||||
|
/// a **hard constraint** (i.e., something that must be satisfied
|
||||||
|
/// for the program to type-check). `only_has_type` will return
|
||||||
|
/// such a constraint, if it exists.
|
||||||
|
pub(super) fn only_has_type(self, fcx: &FnCtxt<'a, 'tcx>) -> Option<Ty<'tcx>> {
|
||||||
|
match self.resolve(fcx) {
|
||||||
|
ExpectHasType(ty) => Some(ty),
|
||||||
|
NoExpectation | ExpectCastableToType(_) | ExpectRvalueLikeUnsized(_) => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Like `only_has_type`, but instead of returning `None` if no
|
||||||
|
/// hard constraint exists, creates a fresh type variable.
|
||||||
|
pub(super) fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
|
||||||
|
self.only_has_type(fcx).unwrap_or_else(|| {
|
||||||
|
fcx.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::MiscVariable, span })
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,120 @@
|
||||||
|
use crate::check::{FnCtxt, LocalTy, UserType};
|
||||||
|
use rustc_hir as hir;
|
||||||
|
use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
|
||||||
|
use rustc_hir::PatKind;
|
||||||
|
use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
|
||||||
|
use rustc_middle::ty::Ty;
|
||||||
|
use rustc_span::Span;
|
||||||
|
use rustc_trait_selection::traits;
|
||||||
|
|
||||||
|
pub(super) struct GatherLocalsVisitor<'a, 'tcx> {
|
||||||
|
fcx: &'a FnCtxt<'a, 'tcx>,
|
||||||
|
parent_id: hir::HirId,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
|
||||||
|
pub(super) fn new(fcx: &'a FnCtxt<'a, 'tcx>, parent_id: hir::HirId) -> Self {
|
||||||
|
Self { fcx, parent_id }
|
||||||
|
}
|
||||||
|
|
||||||
|
fn assign(&mut self, span: Span, nid: hir::HirId, ty_opt: Option<LocalTy<'tcx>>) -> Ty<'tcx> {
|
||||||
|
match ty_opt {
|
||||||
|
None => {
|
||||||
|
// Infer the variable's type.
|
||||||
|
let var_ty = self.fcx.next_ty_var(TypeVariableOrigin {
|
||||||
|
kind: TypeVariableOriginKind::TypeInference,
|
||||||
|
span,
|
||||||
|
});
|
||||||
|
self.fcx
|
||||||
|
.locals
|
||||||
|
.borrow_mut()
|
||||||
|
.insert(nid, LocalTy { decl_ty: var_ty, revealed_ty: var_ty });
|
||||||
|
var_ty
|
||||||
|
}
|
||||||
|
Some(typ) => {
|
||||||
|
// Take type that the user specified.
|
||||||
|
self.fcx.locals.borrow_mut().insert(nid, typ);
|
||||||
|
typ.revealed_ty
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
|
||||||
|
type Map = intravisit::ErasedMap<'tcx>;
|
||||||
|
|
||||||
|
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
|
||||||
|
NestedVisitorMap::None
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add explicitly-declared locals.
|
||||||
|
fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
|
||||||
|
let local_ty = match local.ty {
|
||||||
|
Some(ref ty) => {
|
||||||
|
let o_ty = self.fcx.to_ty(&ty);
|
||||||
|
|
||||||
|
let revealed_ty = if self.fcx.tcx.features().impl_trait_in_bindings {
|
||||||
|
self.fcx.instantiate_opaque_types_from_value(self.parent_id, &o_ty, ty.span)
|
||||||
|
} else {
|
||||||
|
o_ty
|
||||||
|
};
|
||||||
|
|
||||||
|
let c_ty = self
|
||||||
|
.fcx
|
||||||
|
.inh
|
||||||
|
.infcx
|
||||||
|
.canonicalize_user_type_annotation(&UserType::Ty(revealed_ty));
|
||||||
|
debug!(
|
||||||
|
"visit_local: ty.hir_id={:?} o_ty={:?} revealed_ty={:?} c_ty={:?}",
|
||||||
|
ty.hir_id, o_ty, revealed_ty, c_ty
|
||||||
|
);
|
||||||
|
self.fcx
|
||||||
|
.typeck_results
|
||||||
|
.borrow_mut()
|
||||||
|
.user_provided_types_mut()
|
||||||
|
.insert(ty.hir_id, c_ty);
|
||||||
|
|
||||||
|
Some(LocalTy { decl_ty: o_ty, revealed_ty })
|
||||||
|
}
|
||||||
|
None => None,
|
||||||
|
};
|
||||||
|
self.assign(local.span, local.hir_id, local_ty);
|
||||||
|
|
||||||
|
debug!(
|
||||||
|
"local variable {:?} is assigned type {}",
|
||||||
|
local.pat,
|
||||||
|
self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&local.hir_id).unwrap().decl_ty)
|
||||||
|
);
|
||||||
|
intravisit::walk_local(self, local);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add pattern bindings.
|
||||||
|
fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
|
||||||
|
if let PatKind::Binding(_, _, ident, _) = p.kind {
|
||||||
|
let var_ty = self.assign(p.span, p.hir_id, None);
|
||||||
|
|
||||||
|
if !self.fcx.tcx.features().unsized_locals {
|
||||||
|
self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
|
||||||
|
}
|
||||||
|
|
||||||
|
debug!(
|
||||||
|
"pattern binding {} is assigned to {} with type {:?}",
|
||||||
|
ident,
|
||||||
|
self.fcx.ty_to_string(&*self.fcx.locals.borrow().get(&p.hir_id).unwrap().decl_ty),
|
||||||
|
var_ty
|
||||||
|
);
|
||||||
|
}
|
||||||
|
intravisit::walk_pat(self, p);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Don't descend into the bodies of nested closures.
|
||||||
|
fn visit_fn(
|
||||||
|
&mut self,
|
||||||
|
_: intravisit::FnKind<'tcx>,
|
||||||
|
_: &'tcx hir::FnDecl<'tcx>,
|
||||||
|
_: hir::BodyId,
|
||||||
|
_: Span,
|
||||||
|
_: hir::HirId,
|
||||||
|
) {
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,167 @@
|
||||||
|
use super::callee::DeferredCallResolution;
|
||||||
|
use super::MaybeInProgressTables;
|
||||||
|
|
||||||
|
use rustc_data_structures::fx::FxHashMap;
|
||||||
|
use rustc_hir as hir;
|
||||||
|
use rustc_hir::def_id::{DefIdMap, LocalDefId};
|
||||||
|
use rustc_hir::HirIdMap;
|
||||||
|
use rustc_infer::infer;
|
||||||
|
use rustc_infer::infer::{InferCtxt, InferOk, TyCtxtInferExt};
|
||||||
|
use rustc_middle::ty::fold::TypeFoldable;
|
||||||
|
use rustc_middle::ty::{self, Ty, TyCtxt};
|
||||||
|
use rustc_span::{self, Span};
|
||||||
|
use rustc_trait_selection::infer::InferCtxtExt as _;
|
||||||
|
use rustc_trait_selection::opaque_types::OpaqueTypeDecl;
|
||||||
|
use rustc_trait_selection::traits::{self, TraitEngine, TraitEngineExt};
|
||||||
|
|
||||||
|
use std::cell::RefCell;
|
||||||
|
use std::ops::Deref;
|
||||||
|
|
||||||
|
/// Closures defined within the function. For example:
|
||||||
|
///
|
||||||
|
/// fn foo() {
|
||||||
|
/// bar(move|| { ... })
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// Here, the function `foo()` and the closure passed to
|
||||||
|
/// `bar()` will each have their own `FnCtxt`, but they will
|
||||||
|
/// share the inherited fields.
|
||||||
|
pub struct Inherited<'a, 'tcx> {
|
||||||
|
pub(super) infcx: InferCtxt<'a, 'tcx>,
|
||||||
|
|
||||||
|
pub(super) typeck_results: super::MaybeInProgressTables<'a, 'tcx>,
|
||||||
|
|
||||||
|
pub(super) locals: RefCell<HirIdMap<super::LocalTy<'tcx>>>,
|
||||||
|
|
||||||
|
pub(super) fulfillment_cx: RefCell<Box<dyn TraitEngine<'tcx>>>,
|
||||||
|
|
||||||
|
// Some additional `Sized` obligations badly affect type inference.
|
||||||
|
// These obligations are added in a later stage of typeck.
|
||||||
|
pub(super) deferred_sized_obligations:
|
||||||
|
RefCell<Vec<(Ty<'tcx>, Span, traits::ObligationCauseCode<'tcx>)>>,
|
||||||
|
|
||||||
|
// When we process a call like `c()` where `c` is a closure type,
|
||||||
|
// we may not have decided yet whether `c` is a `Fn`, `FnMut`, or
|
||||||
|
// `FnOnce` closure. In that case, we defer full resolution of the
|
||||||
|
// call until upvar inference can kick in and make the
|
||||||
|
// decision. We keep these deferred resolutions grouped by the
|
||||||
|
// def-id of the closure, so that once we decide, we can easily go
|
||||||
|
// back and process them.
|
||||||
|
pub(super) deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'tcx>>>>,
|
||||||
|
|
||||||
|
pub(super) deferred_cast_checks: RefCell<Vec<super::cast::CastCheck<'tcx>>>,
|
||||||
|
|
||||||
|
pub(super) deferred_generator_interiors:
|
||||||
|
RefCell<Vec<(hir::BodyId, Ty<'tcx>, hir::GeneratorKind)>>,
|
||||||
|
|
||||||
|
// Opaque types found in explicit return types and their
|
||||||
|
// associated fresh inference variable. Writeback resolves these
|
||||||
|
// variables to get the concrete type, which can be used to
|
||||||
|
// 'de-opaque' OpaqueTypeDecl, after typeck is done with all functions.
|
||||||
|
pub(super) opaque_types: RefCell<DefIdMap<OpaqueTypeDecl<'tcx>>>,
|
||||||
|
|
||||||
|
/// A map from inference variables created from opaque
|
||||||
|
/// type instantiations (`ty::Infer`) to the actual opaque
|
||||||
|
/// type (`ty::Opaque`). Used during fallback to map unconstrained
|
||||||
|
/// opaque type inference variables to their corresponding
|
||||||
|
/// opaque type.
|
||||||
|
pub(super) opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
|
||||||
|
|
||||||
|
pub(super) body_id: Option<hir::BodyId>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'tcx> Deref for Inherited<'a, 'tcx> {
|
||||||
|
type Target = InferCtxt<'a, 'tcx>;
|
||||||
|
fn deref(&self) -> &Self::Target {
|
||||||
|
&self.infcx
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Helper type of a temporary returned by `Inherited::build(...)`.
|
||||||
|
/// Necessary because we can't write the following bound:
|
||||||
|
/// `F: for<'b, 'tcx> where 'tcx FnOnce(Inherited<'b, 'tcx>)`.
|
||||||
|
pub struct InheritedBuilder<'tcx> {
|
||||||
|
infcx: infer::InferCtxtBuilder<'tcx>,
|
||||||
|
def_id: LocalDefId,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Inherited<'_, 'tcx> {
|
||||||
|
pub fn build(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> InheritedBuilder<'tcx> {
|
||||||
|
let hir_owner = tcx.hir().local_def_id_to_hir_id(def_id).owner;
|
||||||
|
|
||||||
|
InheritedBuilder {
|
||||||
|
infcx: tcx.infer_ctxt().with_fresh_in_progress_typeck_results(hir_owner),
|
||||||
|
def_id,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'tcx> InheritedBuilder<'tcx> {
|
||||||
|
pub fn enter<F, R>(&mut self, f: F) -> R
|
||||||
|
where
|
||||||
|
F: for<'a> FnOnce(Inherited<'a, 'tcx>) -> R,
|
||||||
|
{
|
||||||
|
let def_id = self.def_id;
|
||||||
|
self.infcx.enter(|infcx| f(Inherited::new(infcx, def_id)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Inherited<'a, 'tcx> {
|
||||||
|
pub(super) fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
|
||||||
|
let tcx = infcx.tcx;
|
||||||
|
let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
|
||||||
|
let body_id = tcx.hir().maybe_body_owned_by(item_id);
|
||||||
|
|
||||||
|
Inherited {
|
||||||
|
typeck_results: MaybeInProgressTables {
|
||||||
|
maybe_typeck_results: infcx.in_progress_typeck_results,
|
||||||
|
},
|
||||||
|
infcx,
|
||||||
|
fulfillment_cx: RefCell::new(TraitEngine::new(tcx)),
|
||||||
|
locals: RefCell::new(Default::default()),
|
||||||
|
deferred_sized_obligations: RefCell::new(Vec::new()),
|
||||||
|
deferred_call_resolutions: RefCell::new(Default::default()),
|
||||||
|
deferred_cast_checks: RefCell::new(Vec::new()),
|
||||||
|
deferred_generator_interiors: RefCell::new(Vec::new()),
|
||||||
|
opaque_types: RefCell::new(Default::default()),
|
||||||
|
opaque_types_vars: RefCell::new(Default::default()),
|
||||||
|
body_id,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
|
||||||
|
debug!("register_predicate({:?})", obligation);
|
||||||
|
if obligation.has_escaping_bound_vars() {
|
||||||
|
span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
|
||||||
|
}
|
||||||
|
self.fulfillment_cx.borrow_mut().register_predicate_obligation(self, obligation);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn register_predicates<I>(&self, obligations: I)
|
||||||
|
where
|
||||||
|
I: IntoIterator<Item = traits::PredicateObligation<'tcx>>,
|
||||||
|
{
|
||||||
|
for obligation in obligations {
|
||||||
|
self.register_predicate(obligation);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn register_infer_ok_obligations<T>(&self, infer_ok: InferOk<'tcx, T>) -> T {
|
||||||
|
self.register_predicates(infer_ok.obligations);
|
||||||
|
infer_ok.value
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn normalize_associated_types_in<T>(
|
||||||
|
&self,
|
||||||
|
span: Span,
|
||||||
|
body_id: hir::HirId,
|
||||||
|
param_env: ty::ParamEnv<'tcx>,
|
||||||
|
value: &T,
|
||||||
|
) -> T
|
||||||
|
where
|
||||||
|
T: TypeFoldable<'tcx>,
|
||||||
|
{
|
||||||
|
let ok = self.partially_normalize_associated_types_in(span, body_id, param_env, value);
|
||||||
|
self.register_infer_ok_obligations(ok)
|
||||||
|
}
|
||||||
|
}
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue