hir::ItemKind::Fn: use hir::MethodSig

Author: Centril

src/librustc/hir/intravisit.rs

@@ -481,13 +481,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
  visitor.visit_ty(typ);
  visitor.visit_nested_body(body);
  }
- ItemKind::Fn(ref declaration, header, ref generics, body_id) => {
+ ItemKind::Fn(ref sig, ref generics, body_id) => {
  visitor.visit_fn(FnKind::ItemFn(item.ident,
  generics,
- header,
+ sig.header,
  &item.vis,
  &item.attrs),
- declaration,
+ &sig.decl,
  body_id,
  item.span,
  item.hir_id)

src/librustc/hir/lowering/item.rs

@@ -317,7 +317,7 @@ impl LoweringContext<'_> {
  // declaration (decl), not the return types.
  let body_id = this.lower_maybe_async_body(&decl, header.asyncness.node, body);
 
- let (generics, fn_decl) = this.add_in_band_defs(
+ let (generics, decl) = this.add_in_band_defs(
  generics,
  fn_def_id,
  AnonymousLifetimeMode::PassThrough,
@@ -328,13 +328,8 @@ impl LoweringContext<'_> {
  header.asyncness.node.opt_return_id()
  ),
  );
-
- hir::ItemKind::Fn(
- fn_decl,
- this.lower_fn_header(header),
- generics,
- body_id,
- )
+ let sig = hir::MethodSig { decl, header: this.lower_fn_header(header) };
+ hir::ItemKind::Fn(sig, generics, body_id)
  })
  }
  ItemKind::Mod(ref m) => hir::ItemKind::Mod(self.lower_mod(m)),

src/librustc/hir/map/blocks.rs

@@ -219,16 +219,16 @@ impl<'a> FnLikeNode<'a> {
  {
  match self.node {
  map::Node::Item(i) => match i.kind {
- ast::ItemKind::Fn(ref decl, header, ref generics, block) =>
+ ast::ItemKind::Fn(ref sig, ref generics, block) =>
  item_fn(ItemFnParts {
  id: i.hir_id,
  ident: i.ident,
- decl: &decl,
+ decl: &sig.decl,
  body: block,
  vis: &i.vis,
  span: i.span,
  attrs: &i.attrs,
- header,
+ header: sig.header,
  generics,
  }),
  _ => bug!("item FnLikeNode that is not fn-like"),

src/librustc/hir/map/mod.rs

@@ -49,21 +49,21 @@ impl<'hir> Entry<'hir> {
  match self.node {
  Node::Item(ref item) => {
  match item.kind {
- ItemKind::Fn(ref fn_decl, _, _, _) => Some(fn_decl),
+ ItemKind::Fn(ref sig, _, _) => Some(&sig.decl),
  _ => None,
  }
  }
 
  Node::TraitItem(ref item) => {
  match item.kind {
- TraitItemKind::Method(ref method_sig, _) => Some(&method_sig.decl),
+ TraitItemKind::Method(ref sig, _) => Some(&sig.decl),
  _ => None
  }
  }
 
  Node::ImplItem(ref item) => {
  match item.kind {
- ImplItemKind::Method(ref method_sig, _) => Some(&method_sig.decl),
+ ImplItemKind::Method(ref sig, _) => Some(&sig.decl),
  _ => None,
  }
  }
@@ -85,7 +85,7 @@ impl<'hir> Entry<'hir> {
  match item.kind {
  ItemKind::Const(_, body) |
  ItemKind::Static(.., body) |
- ItemKind::Fn(_, _, _, body) => Some(body),
+ ItemKind::Fn(.., body) => Some(body),
  _ => None,
  }
  }
@@ -605,7 +605,7 @@ impl<'hir> Map<'hir> {
  Node::TraitItem(ref trait_item) => Some(&trait_item.generics),
  Node::Item(ref item) => {
  match item.kind {
- ItemKind::Fn(_, _, ref generics, _) |
+ ItemKind::Fn(_, ref generics, _) |
  ItemKind::TyAlias(_, ref generics) |
  ItemKind::Enum(_, ref generics) |
  ItemKind::Struct(_, ref generics) |
@@ -702,9 +702,9 @@ impl<'hir> Map<'hir> {
  ..
  }) => true,
  Node::Item(&Item {
- kind: ItemKind::Fn(_, header, ..),
+ kind: ItemKind::Fn(ref sig, ..),
  ..
- }) => header.constness == Constness::Const,
+ }) => sig.header.constness == Constness::Const,
  _ => false,
  }
  }

src/librustc/hir/mod.rs

@@ -2534,7 +2534,7 @@ pub enum ItemKind {
  /// A `const` item.
  Const(P<Ty>, BodyId),
  /// A function declaration.
- Fn(P<FnDecl>, FnHeader, Generics, BodyId),
+ Fn(MethodSig, Generics, BodyId),
  /// A module.
  Mod(Mod),
  /// An external module, e.g. `extern { .. }`.
@@ -2599,7 +2599,7 @@ impl ItemKind {
 
  pub fn generics(&self) -> Option<&Generics> {
  Some(match *self {
- ItemKind::Fn(_, _, ref generics, _) |
+ ItemKind::Fn(_, ref generics, _) |
  ItemKind::TyAlias(_, ref generics) |
  ItemKind::OpaqueTy(OpaqueTy { ref generics, impl_trait_fn: None, .. }) |
  ItemKind::Enum(_, ref generics) |

src/librustc/hir/print.rs

@@ -533,10 +533,10 @@ impl<'a> State<'a> {
  self.s.word(";");
  self.end(); // end the outer cbox
  }
- hir::ItemKind::Fn(ref decl, header, ref param_names, body) => {
+ hir::ItemKind::Fn(ref sig, ref param_names, body) => {
  self.head("");
- self.print_fn(decl,
- header,
+ self.print_fn(&sig.decl,
+ sig.header,
  Some(item.ident.name),
  param_names,
  &item.vis,

src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs

@@ -31,10 +31,10 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
  if let Some(hir_id) = self.tcx().hir().as_local_hir_id(def_id) {
  let fndecl = match self.tcx().hir().get(hir_id) {
  Node::Item(&hir::Item {
- kind: hir::ItemKind::Fn(ref fndecl, ..),
+ kind: hir::ItemKind::Fn(ref m, ..),
  ..
- }) => &fndecl,
- Node::TraitItem(&hir::TraitItem {
+ })
+ | Node::TraitItem(&hir::TraitItem {
  kind: hir::TraitItemKind::Method(ref m, ..),
  ..
  })

src/librustc/middle/reachable.rs

@@ -33,7 +33,7 @@ fn item_might_be_inlined(tcx: TyCtxt<'tcx>, item: &hir::Item, attrs: CodegenFnAt
  }
 
  match item.kind {
- hir::ItemKind::Fn(_, header, ..) if header.is_const() => {
+ hir::ItemKind::Fn(ref sig, ..) if sig.header.is_const() => {
  return true;
  }
  hir::ItemKind::Impl(..) |
@@ -225,8 +225,8 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
  // If we are building an executable, only explicitly extern
  // types need to be exported.
  if let Node::Item(item) = *node {
- let reachable = if let hir::ItemKind::Fn(_, header, ..) = item.kind {
- header.abi != Abi::Rust
+ let reachable = if let hir::ItemKind::Fn(ref sig, ..) = item.kind {
+ sig.header.abi != Abi::Rust
  } else {
  false
  };

src/librustc/middle/resolve_lifetime.rs

@@ -460,8 +460,8 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
 
  fn visit_item(&mut self, item: &'tcx hir::Item) {
  match item.kind {
- hir::ItemKind::Fn(ref decl, _, ref generics, _) => {
- self.visit_early_late(None, decl, generics, |this| {
+ hir::ItemKind::Fn(ref sig, ref generics, _) => {
+ self.visit_early_late(None, &sig.decl, generics, |this| {
  intravisit::walk_item(this, item);
  });
  }
@@ -1524,8 +1524,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
  {
  match parent {
  Node::Item(item) => {
- if let hir::ItemKind::Fn(decl, _, _, _) = &item.kind {
- find_arg_use_span(&decl.inputs);
+ if let hir::ItemKind::Fn(sig, _, _) = &item.kind {
+ find_arg_use_span(&sig.decl.inputs);
  }
  },
  Node::ImplItem(impl_item) => {

src/librustc/traits/error_reporting.rs

@@ -383,9 +383,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  let hir = &self.tcx.hir();
  let node = hir.find(hir_id)?;
  if let hir::Node::Item(
- hir::Item{kind: hir::ItemKind::Fn(_ ,fn_header ,_ , body_id), .. }) = &node {
+ hir::Item{kind: hir::ItemKind::Fn(sig, _, body_id), .. }) = &node {
  self.describe_generator(*body_id).or_else(||
- Some(if let hir::FnHeader{ asyncness: hir::IsAsync::Async, .. } = fn_header {
+ Some(if let hir::FnHeader{ asyncness: hir::IsAsync::Async, .. } = sig.header {
  "an async function"
  } else {
  "a function"
@@ -1081,7 +1081,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  }
 
  hir::Node::Item(hir::Item {
- kind: hir::ItemKind::Fn(_, _, generics, _), ..
+ kind: hir::ItemKind::Fn(_, generics, _), ..
  }) |
  hir::Node::TraitItem(hir::TraitItem {
  generics,
@@ -1112,7 +1112,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  kind: hir::ItemKind::Impl(_, _, _, generics, ..), span, ..
  }) |
  hir::Node::Item(hir::Item {
- kind: hir::ItemKind::Fn(_, _, generics, _), span, ..
+ kind: hir::ItemKind::Fn(_, generics, _), span, ..
  }) |
  hir::Node::Item(hir::Item {
  kind: hir::ItemKind::TyAlias(_, generics), span, ..
@@ -1436,12 +1436,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  let parent_node = hir.get_parent_node(obligation.cause.body_id);
  let node = hir.find(parent_node);
  if let Some(hir::Node::Item(hir::Item {
- kind: hir::ItemKind::Fn(decl, _, _, body_id),
+ kind: hir::ItemKind::Fn(sig, _, body_id),
  ..
  })) = node {
  let body = hir.body(*body_id);
  if let hir::ExprKind::Block(blk, _) = &body.value.kind {
- if decl.output.span().overlaps(span) && blk.expr.is_none() &&
+ if sig.decl.output.span().overlaps(span) && blk.expr.is_none() &&
  "()" == &trait_ref.self_ty().to_string()
  {
  // FIXME(estebank): When encountering a method with a trait
@@ -1493,20 +1493,20 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  }
  Node::Item(&hir::Item {
  span,
- kind: hir::ItemKind::Fn(ref decl, ..),
+ kind: hir::ItemKind::Fn(ref sig, ..),
  ..
  }) |
  Node::ImplItem(&hir::ImplItem {
  span,
- kind: hir::ImplItemKind::Method(hir::MethodSig { ref decl, .. }, _),
+ kind: hir::ImplItemKind::Method(ref sig, _),
  ..
  }) |
  Node::TraitItem(&hir::TraitItem {
  span,
- kind: hir::TraitItemKind::Method(hir::MethodSig { ref decl, .. }, _),
+ kind: hir::TraitItemKind::Method(ref sig, _),
  ..
  }) => {
- (self.tcx.sess.source_map().def_span(span), decl.inputs.iter()
+ (self.tcx.sess.source_map().def_span(span), sig.decl.inputs.iter()
  .map(|arg| match arg.clone().kind {
  hir::TyKind::Tup(ref tys) => ArgKind::Tuple(
  Some(arg.span),
@@ -2040,11 +2040,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  .and_then(|parent_did| self.tcx.hir().get_if_local(parent_did));
  debug!("note_obligation_cause_for_async_await: parent_node={:?}", parent_node);
  if let Some(hir::Node::Item(hir::Item {
- kind: hir::ItemKind::Fn(_, header, _, _),
+ kind: hir::ItemKind::Fn(sig, _, _),
  ..
  })) = parent_node {
- debug!("note_obligation_cause_for_async_await: header={:?}", header);
- if header.asyncness != hir::IsAsync::Async {
+ debug!("note_obligation_cause_for_async_await: header={:?}", sig.header);
+ if sig.header.asyncness != hir::IsAsync::Async {
  return false;
  }
  }