Move FnCtxt::get_fn_decl to TyCtxt

Author: estebank

compiler/rustc_hir_typeck/src/_match.rs

@@ -388,7 +388,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 // check that the `if` expr without `else` is the fn body's expr
                 if expr.span == sp {
-                    return self.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
+                    return self.tcx.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
                         let (ty, span) = match fn_decl.output {
                             hir::FnRetTy::DefaultReturn(span) => ("()".to_string(), span),
                             hir::FnRetTy::Return(ty) => (ty_to_string(&self.tcx, ty), ty.span),

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1861,7 +1861,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
         };
 
         // If this is due to an explicit `return`, suggest adding a return type.
-        if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(parent_id)
+        if let Some((fn_id, fn_decl, can_suggest)) = fcx.tcx.get_fn_decl(parent_id)
             && !due_to_block
         {
             fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id);

compiler/rustc_hir_typeck/src/expr.rs

@@ -773,7 +773,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.ret_coercion_span.set(Some(expr.span));
             }
             let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
-            if let Some((_, fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
+            if let Some((_, fn_decl, _)) = self.tcx.get_fn_decl(expr.hir_id) {
                 coercion.coerce_forced_unit(
                     self,
                     &cause,

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -9,7 +9,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
-use rustc_hir::{ExprKind, GenericArg, HirId, Node, QPath};
+use rustc_hir::{ExprKind, GenericArg, HirId, QPath};
 use rustc_hir_analysis::hir_ty_lowering::errors::GenericsArgsErrExtend;
 use rustc_hir_analysis::hir_ty_lowering::generics::{
     check_generic_arg_count_for_call, lower_generic_args,
@@ -34,7 +34,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::DesugaringKind;
-use rustc_span::symbol::{kw, sym};
+use rustc_span::symbol::kw;
 use rustc_span::Span;
 use rustc_target::abi::FieldIdx;
 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
@@ -870,84 +870,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         )
     }
 
-    /// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
-    /// suggestion can be made, `None` otherwise.
-    pub fn get_fn_decl(
-        &self,
-        blk_id: HirId,
-    ) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
-        // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
-        // `while` before reaching it, as block tail returns are not available in them.
-        self.tcx.hir().get_fn_id_for_return_block(blk_id).and_then(|item_id| {
-            match self.tcx.hir_node(item_id) {
-                Node::Item(&hir::Item {
-                    ident,
-                    kind: hir::ItemKind::Fn(ref sig, ..),
-                    owner_id,
-                    ..
-                }) => {
-                    // This is less than ideal, it will not suggest a return type span on any
-                    // method called `main`, regardless of whether it is actually the entry point,
-                    // but it will still present it as the reason for the expected type.
-                    Some((owner_id.def_id, sig.decl, ident.name != sym::main))
-                }
-                Node::TraitItem(&hir::TraitItem {
-                    kind: hir::TraitItemKind::Fn(ref sig, ..),
-                    owner_id,
-                    ..
-                }) => Some((owner_id.def_id, sig.decl, true)),
-                // FIXME: Suggestable if this is not a trait implementation
-                Node::ImplItem(&hir::ImplItem {
-                    kind: hir::ImplItemKind::Fn(ref sig, ..),
-                    owner_id,
-                    ..
-                }) => Some((owner_id.def_id, sig.decl, false)),
-                Node::Expr(&hir::Expr {
-                    hir_id,
-                    kind: hir::ExprKind::Closure(&hir::Closure { def_id, kind, fn_decl, .. }),
-                    ..
-                }) => {
-                    match kind {
-                        hir::ClosureKind::CoroutineClosure(_) => {
-                            // FIXME(async_closures): Implement this.
-                            return None;
-                        }
-                        hir::ClosureKind::Closure => Some((def_id, fn_decl, true)),
-                        hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
-                            _,
-                            hir::CoroutineSource::Fn,
-                        )) => {
-                            let (ident, sig, owner_id) = match self.tcx.parent_hir_node(hir_id) {
-                                Node::Item(&hir::Item {
-                                    ident,
-                                    kind: hir::ItemKind::Fn(ref sig, ..),
-                                    owner_id,
-                                    ..
-                                }) => (ident, sig, owner_id),
-                                Node::TraitItem(&hir::TraitItem {
-                                    ident,
-                                    kind: hir::TraitItemKind::Fn(ref sig, ..),
-                                    owner_id,
-                                    ..
-                                }) => (ident, sig, owner_id),
-                                Node::ImplItem(&hir::ImplItem {
-                                    ident,
-                                    kind: hir::ImplItemKind::Fn(ref sig, ..),
-                                    owner_id,
-                                    ..
-                                }) => (ident, sig, owner_id),
-                                _ => return None,
-                            };
-                            Some((owner_id.def_id, sig.decl, ident.name != sym::main))
-                        }
-                        _ => None,
-                    }
-                }
-                _ => None,
-            }
-        })
-    }
-
     pub(crate) fn note_internal_mutation_in_method(
         &self,
         err: &mut Diag<'_>,

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -1774,7 +1774,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // that highlight errors inline.
                     let mut sp = blk.span;
                     let mut fn_span = None;
-                    if let Some((fn_def_id, decl, _)) = self.get_fn_decl(blk.hir_id) {
+                    if let Some((fn_def_id, decl, _)) = self.tcx.get_fn_decl(blk.hir_id) {
                         let ret_sp = decl.output.span();
                         if let Some(block_sp) = self.parent_item_span(blk.hir_id) {
                             // HACK: on some cases (`ui/liveness/liveness-issue-2163.rs`) the

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -79,7 +79,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // `break` type mismatches provide better context for tail `loop` expressions.
             return false;
         }
-        if let Some((fn_id, fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
+        if let Some((fn_id, fn_decl, can_suggest)) = self.tcx.get_fn_decl(blk_id) {
             pointing_at_return_type =
                 self.suggest_missing_return_type(err, fn_decl, expected, found, can_suggest, fn_id);
             self.suggest_missing_break_or_return_expr(

compiler/rustc_middle/src/ty/error.rs

@@ -3,9 +3,9 @@ use crate::ty::{self, BoundRegionKind, Region, Ty, TyCtxt};
 use rustc_errors::pluralize;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_macros::{TypeFoldable, TypeVisitable};
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{sym, Symbol};
 use rustc_target::spec::abi;
 use std::borrow::Cow;
 use std::hash::{DefaultHasher, Hash, Hasher};
@@ -378,4 +378,82 @@ impl<'tcx> TyCtxt<'tcx> {
             Err(_) => regular,
         }
     }
+
+    /// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
+    /// suggestion can be made, `None` otherwise.
+    pub fn get_fn_decl(
+        self,
+        blk_id: hir::HirId,
+    ) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
+        // Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
+        // `while` before reaching it, as block tail returns are not available in them.
+        self.hir().get_fn_id_for_return_block(blk_id).and_then(|item_id| {
+            match self.hir_node(item_id) {
+                hir::Node::Item(&hir::Item {
+                    ident,
+                    kind: hir::ItemKind::Fn(ref sig, ..),
+                    owner_id,
+                    ..
+                }) => {
+                    // This is less than ideal, it will not suggest a return type span on any
+                    // method called `main`, regardless of whether it is actually the entry point,
+                    // but it will still present it as the reason for the expected type.
+                    Some((owner_id.def_id, sig.decl, ident.name != sym::main))
+                }
+                hir::Node::TraitItem(&hir::TraitItem {
+                    kind: hir::TraitItemKind::Fn(ref sig, ..),
+                    owner_id,
+                    ..
+                }) => Some((owner_id.def_id, sig.decl, true)),
+                // FIXME: Suggestable if this is not a trait implementation
+                hir::Node::ImplItem(&hir::ImplItem {
+                    kind: hir::ImplItemKind::Fn(ref sig, ..),
+                    owner_id,
+                    ..
+                }) => Some((owner_id.def_id, sig.decl, false)),
+                hir::Node::Expr(&hir::Expr {
+                    hir_id,
+                    kind: hir::ExprKind::Closure(&hir::Closure { def_id, kind, fn_decl, .. }),
+                    ..
+                }) => {
+                    match kind {
+                        hir::ClosureKind::CoroutineClosure(_) => {
+                            // FIXME(async_closures): Implement this.
+                            return None;
+                        }
+                        hir::ClosureKind::Closure => Some((def_id, fn_decl, true)),
+                        hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
+                            _,
+                            hir::CoroutineSource::Fn,
+                        )) => {
+                            let (ident, sig, owner_id) = match self.parent_hir_node(hir_id) {
+                                hir::Node::Item(&hir::Item {
+                                    ident,
+                                    kind: hir::ItemKind::Fn(ref sig, ..),
+                                    owner_id,
+                                    ..
+                                }) => (ident, sig, owner_id),
+                                hir::Node::TraitItem(&hir::TraitItem {
+                                    ident,
+                                    kind: hir::TraitItemKind::Fn(ref sig, ..),
+                                    owner_id,
+                                    ..
+                                }) => (ident, sig, owner_id),
+                                hir::Node::ImplItem(&hir::ImplItem {
+                                    ident,
+                                    kind: hir::ImplItemKind::Fn(ref sig, ..),
+                                    owner_id,
+                                    ..
+                                }) => (ident, sig, owner_id),
+                                _ => return None,
+                            };
+                            Some((owner_id.def_id, sig.decl, ident.name != sym::main))
+                        }
+                        _ => None,
+                    }
+                }
+                _ => None,
+            }
+        })
+    }
 }