round 1

Author: Bryanskiy

compiler/rustc_ast/src/ast.rs

@@ -3003,10 +3003,11 @@ pub struct Fn {
 
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Delegation {
+    /// Path resolution id.
     pub id: NodeId,
-    pub path: (Option<P<QSelf>>, Path),
-    pub target_expr: Option<P<Expr>>,
-    pub span: Span,
+    pub qself: Option<P<QSelf>>,
+    pub path: Path,
+    pub body: Option<P<Block>>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]
@@ -3131,7 +3132,7 @@ impl ItemKind {
             ItemKind::MacCall(..) => "item macro invocation",
             ItemKind::MacroDef(..) => "macro definition",
             ItemKind::Impl { .. } => "implementation",
-            ItemKind::Delegation(..) => "delegation",
+            ItemKind::Delegation(..) => "delegated function",
         }
     }
 

compiler/rustc_ast/src/ast_traits.rs

@@ -5,7 +5,7 @@
 use crate::ptr::P;
 use crate::token::Nonterminal;
 use crate::tokenstream::LazyAttrTokenStream;
-use crate::{Arm, Crate, Delegation, ExprField, FieldDef, GenericParam, Param, PatField, Variant};
+use crate::{Arm, Crate, ExprField, FieldDef, GenericParam, Param, PatField, Variant};
 use crate::{AssocItem, Expr, ForeignItem, Item, NodeId};
 use crate::{AttrItem, AttrKind, Block, Pat, Path, Ty, Visibility};
 use crate::{AttrVec, Attribute, Stmt, StmtKind};
@@ -80,7 +80,6 @@ impl_has_node_id!(
     Stmt,
     Ty,
     Variant,
-    Delegation
 );
 
 impl<T: AstDeref<Target: HasNodeId>> HasNodeId for T {
@@ -109,19 +108,7 @@ macro_rules! impl_has_span {
     };
 }
 
-impl_has_span!(
-    AssocItem,
-    Block,
-    Expr,
-    ForeignItem,
-    Item,
-    Pat,
-    Path,
-    Stmt,
-    Ty,
-    Visibility,
-    Delegation
-);
+impl_has_span!(AssocItem, Block, Expr, ForeignItem, Item, Pat, Path, Stmt, Ty, Visibility);
 
 impl<T: AstDeref<Target: HasSpan>> HasSpan for T {
     fn span(&self) -> Span {
@@ -172,7 +159,7 @@ macro_rules! impl_has_tokens_none {
 }
 
 impl_has_tokens!(AssocItem, AttrItem, Block, Expr, ForeignItem, Item, Pat, Path, Ty, Visibility);
-impl_has_tokens_none!(Arm, ExprField, FieldDef, GenericParam, Param, PatField, Variant, Delegation);
+impl_has_tokens_none!(Arm, ExprField, FieldDef, GenericParam, Param, PatField, Variant);
 
 impl<T: AstDeref<Target: HasTokens>> HasTokens for T {
     fn tokens(&self) -> Option<&LazyAttrTokenStream> {

compiler/rustc_ast/src/mut_visit.rs

@@ -1119,10 +1119,10 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {
         ItemKind::MacroDef(def) => vis.visit_macro_def(def),
         ItemKind::Delegation(box delegation) => {
             vis.visit_id(&mut delegation.id);
-            vis.visit_qself(&mut delegation.path.0);
-            vis.visit_path(&mut delegation.path.1);
-            if let Some(target_expr) = &mut delegation.target_expr {
-                vis.visit_expr(target_expr);
+            vis.visit_qself(&mut delegation.qself);
+            vis.visit_path(&mut delegation.path);
+            if let Some(body) = &mut delegation.body {
+                vis.visit_block(body);
             }
         }
     }
@@ -1165,10 +1165,10 @@ pub fn noop_flat_map_assoc_item<T: MutVisitor>(
         AssocItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
         AssocItemKind::Delegation(box delegation) => {
             visitor.visit_id(&mut delegation.id);
-            visitor.visit_qself(&mut delegation.path.0);
-            visitor.visit_path(&mut delegation.path.1);
-            if let Some(target_expr) = &mut delegation.target_expr {
-                visitor.visit_expr(target_expr);
+            visitor.visit_qself(&mut delegation.qself);
+            visitor.visit_path(&mut delegation.path);
+            if let Some(body) = &mut delegation.body {
+                visitor.visit_block(body);
             }
         }
     }

compiler/rustc_ast/src/visit.rs

@@ -376,12 +376,12 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {
         ItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
         ItemKind::MacroDef(ts) => visitor.visit_mac_def(ts, item.id),
         ItemKind::Delegation(box delegation) => {
-            if let Some(qself) = &delegation.path.0 {
+            if let Some(qself) = &delegation.qself {
                 visitor.visit_ty(&qself.ty);
             }
-            walk_path(visitor, &delegation.path.1);
-            if let Some(target_expr) = &delegation.target_expr {
-                visitor.visit_expr(target_expr);
+            walk_path(visitor, &delegation.path);
+            if let Some(body) = &delegation.body {
+                visitor.visit_block(body);
             }
         }
     }
@@ -714,12 +714,12 @@ pub fn walk_assoc_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem,
             visitor.visit_mac_call(mac);
         }
         AssocItemKind::Delegation(box delegation) => {
-            if let Some(qself) = &delegation.path.0 {
+            if let Some(qself) = &delegation.qself {
                 visitor.visit_ty(&qself.ty);
             }
-            walk_path(visitor, &delegation.path.1);
-            if let Some(target_expr) = &delegation.target_expr {
-                visitor.visit_expr(target_expr);
+            walk_path(visitor, &delegation.path);
+            if let Some(body) = &delegation.body {
+                visitor.visit_block(body);
             }
         }
     }