compiler/rustc_typeck/src/check/fn_ctxt/mod.rs

   1 mod _impl;
   2 mod checks;
   3 mod suggestions;
   4
   5 pub use _impl::*;
   6 pub use checks::*;
   7 pub use suggestions::*;
   8
   9 use crate::astconv::AstConv;
  10 use crate::check::coercion::DynamicCoerceMany;
  11 use crate::check::{Diverges, EnclosingBreakables, Inherited, UnsafetyState};
  12
  13 use rustc_hir as hir;
  14 use rustc_hir::def_id::DefId;
  15 use rustc_infer::infer;
  16 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
  17 use rustc_infer::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
  18 use rustc_middle::ty::fold::TypeFoldable;
  19 use rustc_middle::ty::subst::GenericArgKind;
  20 use rustc_middle::ty::{self, Const, Ty, TyCtxt};
  21 use rustc_session::Session;
  22 use rustc_span::symbol::Ident;
  23 use rustc_span::{self, Span};
  24 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
  25
  26 use std::cell::{Cell, RefCell};
  27 use std::ops::Deref;
  28
  29 pub struct FnCtxt<'a, 'tcx> {
  30     pub(super) body_id: hir::HirId,
  31
  32     /// The parameter environment used for proving trait obligations
  33     /// in this function. This can change when we descend into
  34     /// closures (as they bring new things into scope), hence it is
  35     /// not part of `Inherited` (as of the time of this writing,
  36     /// closures do not yet change the environment, but they will
  37     /// eventually).
  38     pub(super) param_env: ty::ParamEnv<'tcx>,
  39
  40     /// Number of errors that had been reported when we started
  41     /// checking this function. On exit, if we find that *more* errors
  42     /// have been reported, we will skip regionck and other work that
  43     /// expects the types within the function to be consistent.
  44     // FIXME(matthewjasper) This should not exist, and it's not correct
  45     // if type checking is run in parallel.
  46     err_count_on_creation: usize,
  47
  48     /// If `Some`, this stores coercion information for returned
  49     /// expressions. If `None`, this is in a context where return is
  50     /// inappropriate, such as a const expression.
  51     ///
  52     /// This is a `RefCell<DynamicCoerceMany>`, which means that we
  53     /// can track all the return expressions and then use them to
  54     /// compute a useful coercion from the set, similar to a match
  55     /// expression or other branching context. You can use methods
  56     /// like `expected_ty` to access the declared return type (if
  57     /// any).
  58     pub(super) ret_coercion: Option<RefCell<DynamicCoerceMany<'tcx>>>,
  59
  60     pub(super) ret_coercion_impl_trait: Option<Ty<'tcx>>,
  61
  62     pub(super) ret_type_span: Option<Span>,
  63
  64     /// Used exclusively to reduce cost of advanced evaluation used for
  65     /// more helpful diagnostics.
  66     pub(super) in_tail_expr: bool,
  67
  68     /// First span of a return site that we find. Used in error messages.
  69     pub(super) ret_coercion_span: Cell<Option<Span>>,
  70
  71     pub(super) resume_yield_tys: Option<(Ty<'tcx>, Ty<'tcx>)>,
  72
  73     pub(super) ps: Cell<UnsafetyState>,
  74
  75     /// Whether the last checked node generates a divergence (e.g.,
  76     /// `return` will set this to `Always`). In general, when entering
  77     /// an expression or other node in the tree, the initial value
  78     /// indicates whether prior parts of the containing expression may
  79     /// have diverged. It is then typically set to `Maybe` (and the
  80     /// old value remembered) for processing the subparts of the
  81     /// current expression. As each subpart is processed, they may set
  82     /// the flag to `Always`, etc. Finally, at the end, we take the
  83     /// result and "union" it with the original value, so that when we
  84     /// return the flag indicates if any subpart of the parent
  85     /// expression (up to and including this part) has diverged. So,
  86     /// if you read it after evaluating a subexpression `X`, the value
  87     /// you get indicates whether any subexpression that was
  88     /// evaluating up to and including `X` diverged.
  89     ///
  90     /// We currently use this flag only for diagnostic purposes:
  91     ///
  92     /// - To warn about unreachable code: if, after processing a
  93     ///   sub-expression but before we have applied the effects of the
  94     ///   current node, we see that the flag is set to `Always`, we
  95     ///   can issue a warning. This corresponds to something like
  96     ///   `foo(return)`; we warn on the `foo()` expression. (We then
  97     ///   update the flag to `WarnedAlways` to suppress duplicate
  98     ///   reports.) Similarly, if we traverse to a fresh statement (or
  99     ///   tail expression) from a `Always` setting, we will issue a
 100     ///   warning. This corresponds to something like `{return;
 101     ///   foo();}` or `{return; 22}`, where we would warn on the
 102     ///   `foo()` or `22`.
 103     ///
 104     /// An expression represents dead code if, after checking it,
 105     /// the diverges flag is set to something other than `Maybe`.
 106     pub(super) diverges: Cell<Diverges>,
 107
 108     /// Whether any child nodes have any type errors.
 109     pub(super) has_errors: Cell<bool>,
 110
 111     pub(super) enclosing_breakables: RefCell<EnclosingBreakables<'tcx>>,
 112
 113     pub(super) inh: &'a Inherited<'a, 'tcx>,
 114 }
 115
 116 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 117     pub fn new(
 118         inh: &'a Inherited<'a, 'tcx>,
 119         param_env: ty::ParamEnv<'tcx>,
 120         body_id: hir::HirId,
 121     ) -> FnCtxt<'a, 'tcx> {
 122         FnCtxt {
 123             body_id,
 124             param_env,
 125             err_count_on_creation: inh.tcx.sess.err_count(),
 126             ret_coercion: None,
 127             ret_coercion_impl_trait: None,
 128             ret_type_span: None,
 129             in_tail_expr: false,
 130             ret_coercion_span: Cell::new(None),
 131             resume_yield_tys: None,
 132             ps: Cell::new(UnsafetyState::function(hir::Unsafety::Normal, hir::CRATE_HIR_ID)),
 133             diverges: Cell::new(Diverges::Maybe),
 134             has_errors: Cell::new(false),
 135             enclosing_breakables: RefCell::new(EnclosingBreakables {
 136                 stack: Vec::new(),
 137                 by_id: Default::default(),
 138             }),
 139             inh,
 140         }
 141     }
 142
 143     pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
 144         ObligationCause::new(span, self.body_id, code)
 145     }
 146
 147     pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
 148         self.cause(span, ObligationCauseCode::MiscObligation)
 149     }
 150
 151     pub fn sess(&self) -> &Session {
 152         &self.tcx.sess
 153     }
 154
 155     pub fn errors_reported_since_creation(&self) -> bool {
 156         self.tcx.sess.err_count() > self.err_count_on_creation
 157     }
 158 }
 159
 160 impl<'a, 'tcx> Deref for FnCtxt<'a, 'tcx> {
 161     type Target = Inherited<'a, 'tcx>;
 162     fn deref(&self) -> &Self::Target {
 163         &self.inh
 164     }
 165 }
 166
 167 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
 168     fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
 169         self.tcx
 170     }
 171
 172     fn item_def_id(&self) -> Option<DefId> {
 173         None
 174     }
 175
 176     fn default_constness_for_trait_bounds(&self) -> hir::Constness {
 177         self.tcx.hir().get(self.body_id).constness()
 178     }
 179
 180     fn get_type_parameter_bounds(
 181         &self,
 182         _: Span,
 183         def_id: DefId,
 184         _: Ident,
 185     ) -> ty::GenericPredicates<'tcx> {
 186         let tcx = self.tcx;
 187         let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 188         let item_id = tcx.hir().ty_param_owner(hir_id);
 189         let item_def_id = tcx.hir().local_def_id(item_id);
 190         let generics = tcx.generics_of(item_def_id);
 191         let index = generics.param_def_id_to_index[&def_id];
 192         ty::GenericPredicates {
 193             parent: None,
 194             predicates: tcx.arena.alloc_from_iter(
 195                 self.param_env.caller_bounds().iter().filter_map(|predicate| {
 196                     match predicate.kind().skip_binder() {
 197                         ty::PredicateKind::Trait(data, _) if data.self_ty().is_param(index) => {
 198                             // HACK(eddyb) should get the original `Span`.
 199                             let span = tcx.def_span(def_id);
 200                             Some((predicate, span))
 201                         }
 202                         _ => None,
 203                     }
 204                 }),
 205             ),
 206         }
 207     }
 208
 209     fn re_infer(&self, def: Option<&ty::GenericParamDef>, span: Span) -> Option<ty::Region<'tcx>> {
 210         let v = match def {
 211             Some(def) => infer::EarlyBoundRegion(span, def.name),
 212             None => infer::MiscVariable(span),
 213         };
 214         Some(self.next_region_var(v))
 215     }
 216
 217     fn allow_ty_infer(&self) -> bool {
 218         true
 219     }
 220
 221     fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
 222         if let Some(param) = param {
 223             if let GenericArgKind::Type(ty) = self.var_for_def(span, param).unpack() {
 224                 return ty;
 225             }
 226             unreachable!()
 227         } else {
 228             self.next_ty_var(TypeVariableOrigin {
 229                 kind: TypeVariableOriginKind::TypeInference,
 230                 span,
 231             })
 232         }
 233     }
 234
 235     fn ct_infer(
 236         &self,
 237         ty: Ty<'tcx>,
 238         param: Option<&ty::GenericParamDef>,
 239         span: Span,
 240     ) -> &'tcx Const<'tcx> {
 241         if let Some(param) = param {
 242             if let GenericArgKind::Const(ct) = self.var_for_def(span, param).unpack() {
 243                 return ct;
 244             }
 245             unreachable!()
 246         } else {
 247             self.next_const_var(
 248                 ty,
 249                 ConstVariableOrigin { kind: ConstVariableOriginKind::ConstInference, span },
 250             )
 251         }
 252     }
 253
 254     fn projected_ty_from_poly_trait_ref(
 255         &self,
 256         span: Span,
 257         item_def_id: DefId,
 258         item_segment: &hir::PathSegment<'_>,
 259         poly_trait_ref: ty::PolyTraitRef<'tcx>,
 260     ) -> Ty<'tcx> {
 261         let (trait_ref, _) = self.replace_bound_vars_with_fresh_vars(
 262             span,
 263             infer::LateBoundRegionConversionTime::AssocTypeProjection(item_def_id),
 264             poly_trait_ref,
 265         );
 266
 267         let item_substs = <dyn AstConv<'tcx>>::create_substs_for_associated_item(
 268             self,
 269             self.tcx,
 270             span,
 271             item_def_id,
 272             item_segment,
 273             trait_ref.substs,
 274         );
 275
 276         self.tcx().mk_projection(item_def_id, item_substs)
 277     }
 278
 279     fn normalize_ty(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
 280         if ty.has_escaping_bound_vars() {
 281             ty // FIXME: normalization and escaping regions
 282         } else {
 283             self.normalize_associated_types_in(span, &ty)
 284         }
 285     }
 286
 287     fn set_tainted_by_errors(&self) {
 288         self.infcx.set_tainted_by_errors()
 289     }
 290
 291     fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, _span: Span) {
 292         self.write_ty(hir_id, ty)
 293     }
 294 }