Support impl in foreign modules for macro use

Allow `impl` blocks in foreign modules for more ergonomic use in macros.
`impl` blocks still have no meaning in foreign modules and will cause an
error if still present during lowering.

Also adds explicit tests for the previous similar foreign module macro
extensions to ensure that neither this nor those are accepted or crash
the compiler when *not* fed to a macro.

Author: maurer

compiler/rustc_ast/src/ast.rs

@@ -3005,6 +3005,9 @@ pub enum ForeignItemKind {
     TyAlias(Box<TyAlias>),
     /// A macro expanding to foreign items.
     MacCall(P<MacCall>),
+    /// An impl declaration - parseable for proc_macro purposes, but currently has no meaning in
+    /// real Rust code.
+    Impl(Box<Impl>),
 }
 
 impl From<ForeignItemKind> for ItemKind {
@@ -3014,6 +3017,7 @@ impl From<ForeignItemKind> for ItemKind {
             ForeignItemKind::Fn(fn_kind) => ItemKind::Fn(fn_kind),
             ForeignItemKind::TyAlias(ty_alias_kind) => ItemKind::TyAlias(ty_alias_kind),
             ForeignItemKind::MacCall(a) => ItemKind::MacCall(a),
+            ForeignItemKind::Impl(i) => ItemKind::Impl(i),
         }
     }
 }
@@ -3027,6 +3031,7 @@ impl TryFrom<ItemKind> for ForeignItemKind {
             ItemKind::Fn(fn_kind) => ForeignItemKind::Fn(fn_kind),
             ItemKind::TyAlias(ty_alias_kind) => ForeignItemKind::TyAlias(ty_alias_kind),
             ItemKind::MacCall(a) => ForeignItemKind::MacCall(a),
+            ItemKind::Impl(i) => ForeignItemKind::Impl(i),
             _ => return Err(item_kind),
         })
     }

compiler/rustc_ast/src/mut_visit.rs

@@ -1198,6 +1198,25 @@ pub fn noop_flat_map_foreign_item<T: MutVisitor>(
             visit_opt(ty, |ty| visitor.visit_ty(ty));
         }
         ForeignItemKind::MacCall(mac) => visitor.visit_mac_call(mac),
+        ForeignItemKind::Impl(box Impl {
+            defaultness,
+            unsafety,
+            generics,
+            constness,
+            polarity,
+            of_trait,
+            self_ty,
+            items,
+        }) => {
+            visit_defaultness(defaultness, visitor);
+            visit_unsafety(unsafety, visitor);
+            visitor.visit_generics(generics);
+            visit_constness(constness, visitor);
+            visit_polarity(polarity, visitor);
+            visit_opt(of_trait, |trait_ref| visitor.visit_trait_ref(trait_ref));
+            visitor.visit_ty(self_ty);
+            items.flat_map_in_place(|item| visitor.flat_map_impl_item(item));
+        }
     }
     visitor.visit_span(span);
     visit_lazy_tts(tokens, visitor);

compiler/rustc_ast/src/visit.rs

@@ -575,6 +575,21 @@ pub fn walk_foreign_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a ForeignI
         ForeignItemKind::MacCall(mac) => {
             visitor.visit_mac_call(mac);
         }
+        ForeignItemKind::Impl(box Impl {
+            defaultness: _,
+            unsafety: _,
+            ref generics,
+            constness: _,
+            polarity: _,
+            ref of_trait,
+            ref self_ty,
+            ref items,
+        }) => {
+            visitor.visit_generics(generics);
+            walk_list!(visitor, visit_trait_ref, of_trait);
+            visitor.visit_ty(self_ty);
+            walk_list!(visitor, visit_assoc_item, items, AssocCtxt::Impl);
+        }
     }
 }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -142,8 +142,11 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
             // Evaluate with the lifetimes in `params` in-scope.
             // This is used to track which lifetimes have already been defined,
             // and which need to be replicated when lowering an async fn.
-            match parent_hir.node().expect_item().kind {
-                hir::ItemKind::Impl(hir::Impl { ref of_trait, .. }) => {
+            match parent_hir.node() {
+                hir::OwnerNode::Item(hir::Item {
+                    kind: hir::ItemKind::Impl(hir::Impl { ref of_trait, .. }),
+                    ..
+                }) => {
                     lctx.is_in_trait_impl = of_trait.is_some();
                 }
                 _ => {}
@@ -685,6 +688,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ForeignItemKind::TyAlias(..) => hir::ForeignItemKind::Type,
                 ForeignItemKind::MacCall(_) => panic!("macro shouldn't exist here"),
+                // This is not a type, but we will have emitted an error earlier and want the
+                // compiler to finish its work cleanly.
+                ForeignItemKind::Impl(_) => hir::ForeignItemKind::Type,
             },
             vis_span: self.lower_span(i.vis.span),
             span: self.lower_span(i.span),

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1285,6 +1285,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 self.check_foreign_item_ascii_only(fi.ident);
             }
             ForeignItemKind::MacCall(..) => {}
+            ForeignItemKind::Impl(..) => {
+                self.err_handler()
+                    .struct_span_err(fi.span, "`impl` blocks are not allowed in `extern` blocks")
+                    .emit();
+                return;
+            }
         }
 
         visit::walk_foreign_item(self, fi)

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -356,6 +356,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 gate_feature_post!(&self, extern_types, i.span, "extern types are experimental");
             }
             ast::ForeignItemKind::MacCall(..) => {}
+            ast::ForeignItemKind::Impl(..) => {}
         }
 
         visit::walk_foreign_item(self, i)

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -58,6 +58,53 @@ impl<'a> State<'a> {
                     self.word(";");
                 }
             }
+            ast::ForeignItemKind::Impl(box ast::Impl {
+                unsafety,
+                polarity,
+                defaultness,
+                constness,
+                ref generics,
+                ref of_trait,
+                ref self_ty,
+                ref items,
+            }) => {
+                self.head("");
+                self.print_visibility(&item.vis);
+                self.print_defaultness(*defaultness);
+                self.print_unsafety(*unsafety);
+                self.word("impl");
+
+                if generics.params.is_empty() {
+                    self.nbsp();
+                } else {
+                    self.print_generic_params(&generics.params);
+                    self.space();
+                }
+
+                self.print_constness(*constness);
+
+                if let ast::ImplPolarity::Negative(_) = polarity {
+                    self.word("!");
+                }
+
+                if let Some(ref t) = *of_trait {
+                    self.print_trait_ref(t);
+                    self.space();
+                    self.word_space("for");
+                }
+
+                self.print_type(self_ty);
+                self.print_where_clause(&generics.where_clause);
+
+                self.space();
+                self.bopen();
+                self.print_inner_attributes(&item.attrs);
+                for impl_item in items {
+                    self.print_assoc_item(impl_item);
+                }
+                let empty = item.attrs.is_empty() && items.is_empty();
+                self.bclose(item.span, empty);
+            }
         }
         self.ann.post(self, AnnNode::SubItem(id))
     }

compiler/rustc_hir/src/hir.rs

@@ -3186,6 +3186,8 @@ pub enum ForeignItemKind<'hir> {
     Static(&'hir Ty<'hir>, Mutability),
     /// A foreign type.
     Type,
+    /// A foreign impl (currently meaningless)
+    Impl(&'hir Impl<'hir>),
 }
 
 /// A variable captured by a closure.

compiler/rustc_hir/src/intravisit.rs

@@ -564,22 +564,9 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
             // `visit_enum_def()` takes care of visiting the `Item`'s `HirId`.
             visitor.visit_enum_def(enum_definition, item.hir_id())
         }
-        ItemKind::Impl(Impl {
-            unsafety: _,
-            defaultness: _,
-            polarity: _,
-            constness: _,
-            defaultness_span: _,
-            ref generics,
-            ref of_trait,
-            ref self_ty,
-            items,
-        }) => {
+        ItemKind::Impl(impl_) => {
             visitor.visit_id(item.hir_id());
-            visitor.visit_generics(generics);
-            walk_list!(visitor, visit_trait_ref, of_trait);
-            visitor.visit_ty(self_ty);
-            walk_list!(visitor, visit_impl_item_ref, *items);
+            walk_impl(visitor, impl_);
         }
         ItemKind::Struct(ref struct_definition, ref generics)
         | ItemKind::Union(ref struct_definition, ref generics) => {
@@ -798,6 +785,7 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v
         }
         ForeignItemKind::Static(ref typ, _) => visitor.visit_ty(typ),
         ForeignItemKind::Type => (),
+        ForeignItemKind::Impl(ref impl_) => walk_impl(visitor, impl_),
     }
 }
 
@@ -978,6 +966,13 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt
     }
 }
 
+pub fn walk_impl<'v, V: Visitor<'v>>(visitor: &mut V, impl_: &'v Impl<'v>) {
+    visitor.visit_generics(impl_.generics);
+    walk_list!(visitor, visit_trait_ref, &impl_.of_trait);
+    visitor.visit_ty(impl_.self_ty);
+    walk_list!(visitor, visit_impl_item_ref, impl_.items);
+}
+
 pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(
     visitor: &mut V,
     foreign_item_ref: &'v ForeignItemRef,

compiler/rustc_hir/src/target.rs

@@ -139,6 +139,7 @@ impl Target {
             hir::ForeignItemKind::Fn(..) => Target::ForeignFn,
             hir::ForeignItemKind::Static(..) => Target::ForeignStatic,
             hir::ForeignItemKind::Type => Target::ForeignTy,
+            hir::ForeignItemKind::Impl(..) => Target::Impl,
         }
     }