Initial support for dynamically linked crates

Author: Bryanskiy

Cargo.lock

@@ -4033,6 +4033,7 @@ dependencies = [
  "rustc_fs_util",
  "rustc_hir",
  "rustc_hir_analysis",
+ "rustc_hir_pretty",
  "rustc_hir_typeck",
  "rustc_incremental",
  "rustc_lint",

compiler/rustc_ast/src/ast.rs

@@ -3192,6 +3192,7 @@ impl Item {
     pub fn opt_generics(&self) -> Option<&Generics> {
         match &self.kind {
             ItemKind::ExternCrate(_)
+            | ItemKind::ExternDynCrate(_)
             | ItemKind::Use(_)
             | ItemKind::Mod(_, _)
             | ItemKind::ForeignMod(_)
@@ -3407,6 +3408,10 @@ pub enum ItemKind {
     ///
     /// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
     ExternCrate(Option<Symbol>),
+    /// An extern crate with a stable interface.
+    ///
+    /// E.g., `extern dyn crate foo` or `extern dyn crate foo_bar as foo`.
+    ExternDynCrate(Option<Symbol>),
     /// A use declaration item (`use`).
     ///
     /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.
@@ -3488,13 +3493,19 @@ impl ItemKind {
             Use(..) | Static(..) | Const(..) | Fn(..) | Mod(..) | GlobalAsm(..) | TyAlias(..)
             | Struct(..) | Union(..) | Trait(..) | TraitAlias(..) | MacroDef(..)
             | Delegation(..) | DelegationMac(..) => "a",
-            ExternCrate(..) | ForeignMod(..) | MacCall(..) | Enum(..) | Impl { .. } => "an",
+            ExternCrate(..)
+            | ExternDynCrate(..)
+            | ForeignMod(..)
+            | MacCall(..)
+            | Enum(..)
+            | Impl { .. } => "an",
         }
     }
 
     pub fn descr(&self) -> &'static str {
         match self {
             ItemKind::ExternCrate(..) => "extern crate",
+            ItemKind::ExternDynCrate(..) => "extern dyn crate",
             ItemKind::Use(..) => "`use` import",
             ItemKind::Static(..) => "static item",
             ItemKind::Const(..) => "constant item",

compiler/rustc_ast/src/mut_visit.rs

@@ -1219,7 +1219,7 @@ impl WalkItemKind for ItemKind {
         vis: &mut impl MutVisitor,
     ) {
         match self {
-            ItemKind::ExternCrate(_orig_name) => {}
+            ItemKind::ExternCrate(_orig_name) | ItemKind::ExternDynCrate(_orig_name) => {}
             ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree),
             ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
                 vis.visit_ty(ty);

compiler/rustc_ast/src/visit.rs

@@ -366,7 +366,7 @@ impl WalkItemKind for ItemKind {
         visitor: &mut V,
     ) -> V::Result {
         match self {
-            ItemKind::ExternCrate(_rename) => {}
+            ItemKind::ExternCrate(_rename) | ItemKind::ExternDynCrate(_rename) => {}
             ItemKind::Use(use_tree) => try_visit!(visitor.visit_use_tree(use_tree, id, false)),
             ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
                 try_visit!(visitor.visit_ty(ty));

compiler/rustc_ast_lowering/src/item.rs

@@ -180,7 +180,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         i: &ItemKind,
     ) -> hir::ItemKind<'hir> {
         match i {
-            ItemKind::ExternCrate(orig_name) => hir::ItemKind::ExternCrate(*orig_name),
+            ItemKind::ExternCrate(orig_name) | ItemKind::ExternDynCrate(orig_name) => {
+                hir::ItemKind::ExternCrate(*orig_name)
+            }
             ItemKind::Use(use_tree) => {
                 // Start with an empty prefix.
                 let prefix = Path { segments: ThinVec::new(), span: use_tree.span, tokens: None };
@@ -1176,7 +1178,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             // create a fake body so that the entire rest of the compiler doesn't have to deal with
             // this as a special case.
             return self.lower_fn_body(decl, |this| {
-                if attrs.iter().any(|a| a.name_or_empty() == sym::rustc_intrinsic) {
+                if attrs.iter().any(|a| a.name_or_empty() == sym::rustc_intrinsic) || this.tcx.is_interface_build() {
                     let span = this.lower_span(span);
                     let empty_block = hir::Block {
                         hir_id: this.next_id(),

compiler/rustc_ast_passes/messages.ftl

@@ -273,3 +273,6 @@ ast_passes_where_clause_before_type_alias = where clauses are not allowed before
     .note = see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information
     .remove_suggestion = remove this `where`
     .move_suggestion = move it to the end of the type declaration
+
+ast_passes_wrong_mangling_scheme_for_extern_dyn =
+    `extern dyn` annotation is only allowed with `v0` mangling scheme

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -29,6 +29,7 @@ use rustc_errors::DiagCtxtHandle;
 use rustc_feature::Features;
 use rustc_parse::validate_attr;
 use rustc_session::Session;
+use rustc_session::config::SymbolManglingVersion;
 use rustc_session::lint::builtin::{
     DEPRECATED_WHERE_CLAUSE_LOCATION, MISSING_ABI, MISSING_UNSAFE_ON_EXTERN,
     PATTERNS_IN_FNS_WITHOUT_BODY,
@@ -82,6 +83,8 @@ struct AstValidator<'a> {
     /// Used to ban explicit safety on foreign items when the extern block is not marked as unsafe.
     extern_mod_safety: Option<Safety>,
 
+    is_interface: bool,
+
     lint_buffer: &'a mut LintBuffer,
 }
 
@@ -922,7 +925,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
                 let is_intrinsic =
                     item.attrs.iter().any(|a| a.name_or_empty() == sym::rustc_intrinsic);
-                if body.is_none() && !is_intrinsic {
+                if body.is_none() && !is_intrinsic && !self.is_interface {
                     self.dcx().emit_err(errors::FnWithoutBody {
                         span: item.span,
                         replace_span: self.ending_semi_or_hi(item.span),
@@ -1110,6 +1113,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     });
                 }
             }
+            ItemKind::ExternDynCrate(_) => {
+                if self.sess.opts.get_symbol_mangling_version() != SymbolManglingVersion::V0 {
+                    self.dcx()
+                        .emit_err(errors::WrongManglingSchemeForExternDyn { span: item.span });
+                }
+            }
             _ => {}
         }
 
@@ -1419,7 +1428,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     });
                 }
                 AssocItemKind::Fn(box Fn { body, .. }) => {
-                    if body.is_none() {
+                    if body.is_none() && !self.is_interface {
                         self.dcx().emit_err(errors::AssocFnWithoutBody {
                             span: item.span,
                             replace_span: self.ending_semi_or_hi(item.span),
@@ -1669,6 +1678,7 @@ pub fn check_crate(
     sess: &Session,
     features: &Features,
     krate: &Crate,
+    is_interface: bool,
     lints: &mut LintBuffer,
 ) -> bool {
     let mut validator = AstValidator {
@@ -1680,6 +1690,7 @@ pub fn check_crate(
         outer_impl_trait: None,
         disallow_tilde_const: Some(TildeConstReason::Item),
         extern_mod_safety: None,
+        is_interface,
         lint_buffer: lints,
     };
     visit::walk_crate(&mut validator, krate);

compiler/rustc_ast_passes/src/errors.rs

@@ -824,3 +824,10 @@ pub(crate) struct DuplicatePreciseCapturing {
     #[label]
     pub bound2: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(ast_passes_wrong_mangling_scheme_for_extern_dyn)]
+pub(crate) struct WrongManglingSchemeForExternDyn {
+    #[primary_span]
+    pub span: Span,
+}

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

@@ -3,7 +3,7 @@ use itertools::{Itertools, Position};
 use rustc_ast as ast;
 use rustc_ast::ModKind;
 use rustc_ast::ptr::P;
-use rustc_span::Ident;
+use rustc_span::{Ident, Symbol};
 
 use crate::pp::Breaks::Inconsistent;
 use crate::pprust::state::fixup::FixupContext;
@@ -148,6 +148,26 @@ impl<'a> State<'a> {
         self.end(); // end outer head-block
     }
 
+    fn print_extern_crate(
+        &mut self,
+        vis: &ast::Visibility,
+        head: &str,
+        ident: Ident,
+        orig_name: Option<Symbol>,
+    ) {
+        self.head(visibility_qualified(vis, head));
+        if let Some(orig_name) = orig_name {
+            self.print_name(orig_name);
+            self.space();
+            self.word("as");
+            self.space();
+        }
+        self.print_ident(ident);
+        self.word(";");
+        self.end(); // end inner head-block
+        self.end(); // end outer head-block
+    }
+
     /// Pretty-prints an item.
     pub(crate) fn print_item(&mut self, item: &ast::Item) {
         self.hardbreak_if_not_bol();
@@ -156,17 +176,10 @@ impl<'a> State<'a> {
         self.ann.pre(self, AnnNode::Item(item));
         match &item.kind {
             ast::ItemKind::ExternCrate(orig_name) => {
-                self.head(visibility_qualified(&item.vis, "extern crate"));
-                if let &Some(orig_name) = orig_name {
-                    self.print_name(orig_name);
-                    self.space();
-                    self.word("as");
-                    self.space();
-                }
-                self.print_ident(item.ident);
-                self.word(";");
-                self.end(); // end inner head-block
-                self.end(); // end outer head-block
+                self.print_extern_crate(&item.vis, "extern crate", item.ident, *orig_name);
+            }
+            ast::ItemKind::ExternDynCrate(orig_name) => {
+                self.print_extern_crate(&item.vis, "extern dyn crate", item.ident, *orig_name);
             }
             ast::ItemKind::Use(tree) => {
                 self.print_visibility(&item.vis);

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -40,7 +40,8 @@ fn crate_type_allows_lto(crate_type: CrateType) -> bool {
         | CrateType::Dylib
         | CrateType::Staticlib
         | CrateType::Cdylib
-        | CrateType::ProcMacro => true,
+        | CrateType::ProcMacro
+        | CrateType::Sdylib => true,
         CrateType::Rlib => false,
     }
 }