Change:
<ins> mod _impl; mod checks; mod suggestions; pub use _impl::*; pub use checks::*; pub use suggestions::*; use crate::astconv::AstConv; use crate::check::coercion::DynamicCoerceMany; use crate::check::{Diverges, EnclosingBreakables, Inherited, UnsafetyState}; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_infer::infer; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc_infer::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind}; use rustc_middle::hir::map::blocks::FnLikeNode; use rustc_middle::ty::fold::TypeFoldable; use rustc_middle::ty::subst::GenericArgKind; use rustc_middle::ty::{self, Const, Ty, TyCtxt}; use rustc_session::Session; use rustc_span::{self, Span}; use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode}; use std::cell::{Cell, RefCell}; use std::ops::Deref; pub struct FnCtxt<'a, 'tcx> { pub(super) body_id: hir::HirId, /// The parameter environment used for proving trait obligations /// in this function. This can change when we descend into /// closures (as they bring new things into scope), hence it is /// not part of `Inherited` (as of the time of this writing, /// closures do not yet change the environment, but they will /// eventually). pub(super) param_env: ty::ParamEnv<'tcx>, /// Number of errors that had been reported when we started /// checking this function. On exit, if we find that *more* errors /// have been reported, we will skip regionck and other work that /// expects the types within the function to be consistent. // FIXME(matthewjasper) This should not exist, and it's not correct // if type checking is run in parallel. err_count_on_creation: usize, /// If `Some`, this stores coercion information for returned /// expressions. If `None`, this is in a context where return is /// inappropriate, such as a const expression. /// /// This is a `RefCell<DynamicCoerceMany>`, which means that we /// can track all the return expressions and then use them to /// compute a useful coercion from the set, similar to a match /// expression or other branching context. You can use methods /// like `expected_ty` to access the declared return type (if /// any). pub(super) ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>, pub(super) ret_coercion_impl_trait: Option<Ty<'tcx>>, pub(super) ret_type_span: Option<Span>, /// Used exclusively to reduce cost of advanced evaluation used for /// more helpful diagnostics. pub(super) in_tail_expr: bool, /// First span of a return site that we find. Used in error messages. pub(super) ret_coercion_span: RefCell<Option<Span>>, pub(super) resume_yield_tys: Option<(Ty<'tcx>, Ty<'tcx>)>, pub(super) ps: RefCell<UnsafetyState>, /// Whether the last checked node generates a divergence (e.g., /// `return` will set this to `Always`). In general, when entering /// an expression or other node in the tree, the initial value /// indicates whether prior parts of the containing expression may /// have diverged. It is then typically set to `Maybe` (and the /// old value remembered) for processing the subparts of the /// current expression. As each subpart is processed, they may set /// the flag to `Always`, etc. Finally, at the end, we take the /// result and "union" it with the original value, so that when we /// return the flag indicates if any subpart of the parent /// expression (up to and including this part) has diverged. So, /// if you read it after evaluating a subexpression `X`, the value /// you get indicates whether any subexpression that was /// evaluating up to and including `X` diverged. /// /// We currently use this flag only for diagnostic purposes: /// /// - To warn about unreachable code: if, after processing a ///   sub-expression but before we have applied the effects of the ///   current node, we see that the flag is set to `Always`, we ///   can issue a warning. This corresponds to something like ///   `foo(return)`; we warn on the `foo()` expression. (We then ///   update the flag to `WarnedAlways` to suppress duplicate ///   reports.) Similarly, if we traverse to a fresh statement (or ///   tail expression) from a `Always` setting, we will issue a ///   warning. This corresponds to something like `{return; ///   foo();}` or `{return; 22}`, where we would warn on the ///   `foo()` or `22`. /// /// An expression represents dead code if, after checking it, /// the diverges flag is set to something other than `Maybe`. pub(super) diverges: Cell<Diverges>, /// Whether any child nodes have any type errors. pub(super) has_errors: Cell<bool>, pub(super) enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>, pub(super) inh: &'a Inherited<'a, 'tcx>, } impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn new( inh: &'a Inherited<'a, 'tcx>, param_env: ty::ParamEnv<'tcx>, body_id: hir::HirId, ) -> FnCtxt<'a, 'tcx> { FnCtxt { body_id, param_env, err_count_on_creation: inh.tcx.sess.err_count(), ret_coercion: None, ret_coercion_impl_trait: None, ret_type_span: None, in_tail_expr: false, ret_coercion_span: RefCell::new(None), resume_yield_tys: None, ps: RefCell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)), diverges: Cell::new(Diverges::Maybe), has_errors: Cell::new(false), enclosing_breakables: RefCell::new(EnclosingBreakables { stack: Vec::new(), by_id: Default::default(), }), inh, } } pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> { ObligationCause::new(span, self.body_id, code) } pub fn misc(&self, span: Span) -> ObligationCause<'tcx> { self.cause(span, ObligationCauseCode::MiscObligation) } pub fn sess(&self) -> &Session { &self.tcx.sess } pub fn errors_reported_since_creation(&self) -> bool { self.tcx.sess.err_count() > self.err_count_on_creation } } impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> { type Target = Inherited<'a, 'tcx>; fn deref(&self) -> &Self::Target { &self.inh } } impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> { fn tcx<'b>(&'b self) -> TyCtxt<'tcx> { self.tcx } fn item_def_id(&self) -> Option<DefId> { None } fn default_constness_for_trait_bounds(&self) -> hir::Constness { // FIXME: refactor this into a method let node = self.tcx.hir().get(self.body_id); if let Some(fn_like) = FnLikeNode::from_node(node) { fn_like.constness() } else { hir::Constness::NotConst } } fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> { let tcx = self.tcx; let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_id = tcx.hir().ty_param_owner(hir_id); let item_def_id = tcx.hir().local_def_id(item_id); let generics = tcx.generics_of(item_def_id); let index = generics.param_def_id_to_index[&def_id]; ty::GenericPredicates { parent: None, predicates: tcx.arena.alloc_from_iter( self.param_env.caller_bounds().iter().filter_map(|predicate| { match predicate.skip_binders() { ty::PredicateAtom::Trait(data, _) if data.self_ty().is_param(index) => { // HACK(eddyb) should get the original `Span`. let span = tcx.def_span(def_id); Some((predicate, span)) } _ => None, } }), ), } } fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> { let v = match def { Some(def) => infer::EarlyBoundRegion(span, def.name), None => infer::MiscVariable(span), }; Some(self.next_region_var(v)) } fn allow_ty_infer(&self) -> bool { true } fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> { if let Some(param) = param { if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() { return ty; } unreachable!() } else { self.next_ty_var(TypeVariableOrigin { kind: TypeVariableOriginKind::TypeInference, span, }) } } fn ct_infer( &self, ty: Ty<'tcx>, param: Option<&ty::GenericParamDef>, span: Span, ) -> &'tcx Const<'tcx> { if let Some(param) = param { if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() { return ct; } unreachable!() } else { self.next_const_var( ty, ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span }, ) } } fn projected_ty_from_poly_trait_ref( &self, span: Span, item_def_id: DefId, item_segment: &hir::PathSegment<'_>, poly_trait_ref: ty::PolyTraitRef<'tcx>, ) -> Ty<'tcx> { let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars( span, infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id), &poly_trait_ref, ); let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item( self, self.tcx, span, item_def_id, item_segment, trait_ref.substs, ); self.tcx().mk_projection(item_def_id, item_substs) } fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> { if ty.has_escaping_bound_vars() { ty // FIXME: normalization and escaping regions } else { self.normalize_associated_types_in(span, &ty) } } fn set_tainted_by_errors(&self) { self.infcx.set_tainted_by_errors() } fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) { self.write_ty(hir_id, ty) } } </ins>

Discussion:
Branching this from . Originally, for was over 6,000 lines. I was able to push that to around 1,100 lines (PR ). However, in the process, I found that was rather long, with 13 fields in the struct and some rather long s attached. The sum total is 3,200 lines, which effectively means that the comment was moved from to . The goal of this issue is to smaller, at minimum less than 3,000 lines by some of its functionality into "sub-structs" that will be in separate files Unknowns to solve: [ ] How do the 13 fields group into nice sub-structs [ ] What to name the above mentioned sub-structs [X] How to achieve this refactoring without changing the interface of Solution: Cannot do
modify labels to +T-compiler and +C-cleanup.
The third unknown is probably impossible. All fields (except ) can be accessed from outside the file (). So the interface must change.
modify labels to +E-needs-mentor.