delegation: Implement multi-item delegation

```rust
reuse prefix::{a, b, c}
```

Author: petrochenkov

compiler/rustc_ast/src/ast.rs

@@ -3108,12 +3108,19 @@ pub struct Fn {
     pub body: Option<P<Block>>,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub enum DelegationKind {
+    Single,
+    List(ThinVec<Ident>),
+}
+
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Delegation {
     /// Path resolution id.
     pub id: NodeId,
     pub qself: Option<P<QSelf>>,
     pub path: Path,
+    pub kind: DelegationKind,
     pub body: Option<P<Block>>,
 }
 

compiler/rustc_ast/src/mut_visit.rs

@@ -1149,10 +1149,18 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {
         }
         ItemKind::MacCall(m) => vis.visit_mac_call(m),
         ItemKind::MacroDef(def) => vis.visit_macro_def(def),
-        ItemKind::Delegation(box Delegation { id, qself, path, body }) => {
+        ItemKind::Delegation(box Delegation { id, qself, path, kind, body }) => {
             vis.visit_id(id);
             vis.visit_qself(qself);
             vis.visit_path(path);
+            match kind {
+                DelegationKind::Single => {}
+                DelegationKind::List(suffixes) => {
+                    for ident in suffixes {
+                        vis.visit_ident(ident);
+                    }
+                }
+            }
             if let Some(body) = body {
                 vis.visit_block(body);
             }
@@ -1205,10 +1213,18 @@ pub fn noop_flat_map_assoc_item<T: MutVisitor>(
             visit_opt(ty, |ty| visitor.visit_ty(ty));
         }
         AssocItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
-        AssocItemKind::Delegation(box Delegation { id, qself, path, body }) => {
+        AssocItemKind::Delegation(box Delegation { id, qself, path, kind, body }) => {
             visitor.visit_id(id);
             visitor.visit_qself(qself);
             visitor.visit_path(path);
+            match kind {
+                DelegationKind::Single => {}
+                DelegationKind::List(suffixes) => {
+                    for ident in suffixes {
+                        visitor.visit_ident(ident);
+                    }
+                }
+            }
             if let Some(body) = body {
                 visitor.visit_block(body);
             }

compiler/rustc_ast/src/visit.rs

@@ -382,11 +382,19 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) -> V::Resu
         }
         ItemKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
         ItemKind::MacroDef(ts) => try_visit!(visitor.visit_mac_def(ts, item.id)),
-        ItemKind::Delegation(box Delegation { id, qself, path, body }) => {
+        ItemKind::Delegation(box Delegation { id, qself, path, kind, body }) => {
             if let Some(qself) = qself {
                 try_visit!(visitor.visit_ty(&qself.ty));
             }
             try_visit!(visitor.visit_path(path, *id));
+            match kind {
+                DelegationKind::Single => {}
+                DelegationKind::List(suffixes) => {
+                    for ident in suffixes {
+                        visitor.visit_ident(*ident);
+                    }
+                }
+            }
             visit_opt!(visitor, visit_block, body);
         }
         ItemKind::DelegationList(box DelegationList { qself, prefix, suffixes, body }) => {
@@ -792,11 +800,19 @@ pub fn walk_assoc_item<'a, V: Visitor<'a>>(
         AssocItemKind::MacCall(mac) => {
             try_visit!(visitor.visit_mac_call(mac));
         }
-        AssocItemKind::Delegation(box Delegation { id, qself, path, body }) => {
+        AssocItemKind::Delegation(box Delegation { id, qself, path, kind, body }) => {
             if let Some(qself) = qself {
                 try_visit!(visitor.visit_ty(&qself.ty));
             }
             try_visit!(visitor.visit_path(path, *id));
+            match kind {
+                DelegationKind::Single => {}
+                DelegationKind::List(suffixes) => {
+                    for ident in suffixes {
+                        visitor.visit_ident(*ident);
+                    }
+                }
+            }
             visit_opt!(visitor, visit_block, body);
         }
         AssocItemKind::DelegationList(box DelegationList { qself, prefix, suffixes, body }) => {

tests/ui/delegation/multiple-names-body-identity.rs

@@ -0,0 +1,32 @@
+//@ check-pass
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+trait Trait {
+    fn foo(&self) {}
+    fn bar(&self) {}
+}
+
+impl Trait for u8 {}
+
+struct S(u8);
+
+mod to_import {
+    pub fn check(arg: &u8) -> &u8 { arg }
+}
+
+impl Trait for S {
+    reuse Trait::{foo, bar} {
+        use to_import::check;
+
+        let _arr = Some(self.0).map(|x| [x * 2; 3]);
+        check(&self.0)
+    }
+}
+
+fn main() {
+    let s = S(0);
+    s.foo();
+    s.bar();
+}

tests/ui/delegation/multiple-names-empty.rs

@@ -0,0 +1,8 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod m {}
+
+reuse m::{}; //~ ERROR empty list delegation is not supported
+
+fn main() {}

tests/ui/delegation/multiple-names-empty.stderr

@@ -0,0 +1,8 @@
+error: empty list delegation is not supported
+  --> $DIR/multiple-names-empty.rs:6:1
+   |
+LL | reuse m::{};
+   | ^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/delegation/multiple-names.rs

@@ -0,0 +1,46 @@
+//@ check-pass
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+trait Trait {
+    fn foo(&self) -> u8 { 0 }
+    fn bar(&self) -> u8 { 1 }
+}
+
+impl Trait for u8 {}
+
+struct S(u8);
+struct Z(u8);
+
+impl Trait for S {
+    reuse Trait::{foo, bar} { &self.0 }
+}
+
+impl Trait for Z {
+    reuse <u8 as Trait>::{foo, bar} { &self.0 }
+}
+
+trait Trait2 where Self: Trait {
+    reuse Trait::{foo, bar};
+}
+
+mod to_reuse {
+    pub fn a() {}
+    pub fn b() {}
+}
+
+reuse to_reuse::{a, b};
+
+fn main() {
+    let s = S(2);
+    s.foo();
+    s.bar();
+
+    let z = Z(3);
+    z.foo();
+    z.bar();
+
+    a();
+    b();
+}