Initial support for dynamically linked crates

Author: Bryanskiy

Diff for: Cargo.lock

@@ -4219,6 +4219,7 @@ name = "rustc_monomorphize"
 version = "0.0.0"
 dependencies = [
  "rustc_abi",
+ "rustc_ast",
  "rustc_attr_parsing",
  "rustc_data_structures",
  "rustc_errors",

Diff for: compiler/rustc_ast/src/ast.rs

@@ -3172,7 +3172,7 @@ impl Item {
 
     pub fn opt_generics(&self) -> Option<&Generics> {
         match &self.kind {
-            ItemKind::ExternCrate(_)
+            ItemKind::ExternCrate(_, _)
             | ItemKind::Use(_)
             | ItemKind::Mod(_, _)
             | ItemKind::ForeignMod(_)
@@ -3374,13 +3374,19 @@ pub struct ConstItem {
     pub expr: Option<P<Expr>>,
 }
 
+#[derive(PartialEq, Eq, Clone, Copy, Encodable, Decodable, Debug, HashStable_Generic)]
+pub enum ExternCrateKind {
+    Stable,
+    Default,
+}
+
 // Adding a new variant? Please update `test_item` in `tests/ui/macros/stringify.rs`.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ItemKind {
     /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
     ///
     /// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
-    ExternCrate(Option<Symbol>),
+    ExternCrate(ExternCrateKind, Option<Symbol>),
     /// A use declaration item (`use`).
     ///
     /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.

Diff for: compiler/rustc_ast/src/mut_visit.rs

@@ -1196,7 +1196,7 @@ impl WalkItemKind for ItemKind {
         vis: &mut impl MutVisitor,
     ) {
         match self {
-            ItemKind::ExternCrate(_orig_name) => {}
+            ItemKind::ExternCrate(_kind, _orig_name) => {}
             ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree),
             ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
                 vis.visit_ty(ty);
@@ -1898,7 +1898,7 @@ impl DummyAstNode for Item {
                 tokens: Default::default(),
             },
             ident: Ident::empty(),
-            kind: ItemKind::ExternCrate(None),
+            kind: ItemKind::ExternCrate(ExternCrateKind::Default, None),
             tokens: Default::default(),
         }
     }

Diff for: compiler/rustc_ast/src/visit.rs

@@ -363,7 +363,7 @@ impl WalkItemKind for ItemKind {
         visitor: &mut V,
     ) -> V::Result {
         match self {
-            ItemKind::ExternCrate(_rename) => {}
+            ItemKind::ExternCrate(_kind, _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));

Diff for: compiler/rustc_ast_lowering/src/item.rs

@@ -180,7 +180,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         i: &ItemKind,
     ) -> hir::ItemKind<'hir> {
         match i {
-            ItemKind::ExternCrate(orig_name) => hir::ItemKind::ExternCrate(*orig_name),
+            ItemKind::ExternCrate(_, 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 };

Diff for: 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

Diff for: 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,
@@ -1108,6 +1109,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     });
                 }
             }
+            ItemKind::ExternCrate(ast::ExternCrateKind::Stable, _) => {
+                if self.sess.opts.get_symbol_mangling_version() != SymbolManglingVersion::V0 {
+                    self.dcx()
+                        .emit_err(errors::WrongManglingSchemeForExternDyn { span: item.span });
+                }
+            }
             _ => {}
         }
 

Diff for: 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,
+}

Diff for: compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -49,10 +49,38 @@ pub enum AnnNode<'a> {
 }
 
 pub trait PpAnn {
+    fn nested(&self, state: &mut State<'_>, node: AnnNode<'_>) {
+        print_default_nested_ann(state, node);
+    }
     fn pre(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {}
     fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {}
 }
 
+pub fn print_default_nested_ann(state: &mut State<'_>, node: AnnNode<'_>) {
+    match node {
+        AnnNode::Block(blk) => {
+            for (i, st) in blk.stmts.iter().enumerate() {
+                match &st.kind {
+                    ast::StmtKind::Expr(expr) if i == blk.stmts.len() - 1 => {
+                        state.maybe_print_comment(st.span.lo());
+                        state.space_if_not_bol();
+                        state.print_expr_outer_attr_style(expr, false, FixupContext::new_stmt());
+                        state.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));
+                    }
+                    _ => state.print_stmt(st),
+                }
+            }
+        }
+        AnnNode::Crate(_)
+        | AnnNode::Expr(_)
+        | AnnNode::Ident(_)
+        | AnnNode::Item(_)
+        | AnnNode::Name(_)
+        | AnnNode::Pat(_)
+        | AnnNode::SubItem(_) => unimplemented!(),
+    }
+}
+
 struct NoAnn;
 
 impl PpAnn for NoAnn {}
@@ -240,9 +268,29 @@ pub fn print_crate<'a>(
     edition: Edition,
     g: &AttrIdGenerator,
 ) -> String {
-    let mut s =
+    let s =
         State { s: pp::Printer::new(), comments: Some(Comments::new(sm, filename, input)), ann };
+    print_crate_with_state(s, krate, is_expanded, edition, g)
+}
 
+pub fn print_crate_with_erased_comments<'a>(
+    krate: &ast::Crate,
+    ann: &'a dyn PpAnn,
+    is_expanded: bool,
+    edition: Edition,
+    g: &AttrIdGenerator,
+) -> String {
+    let s = State { s: pp::Printer::new(), comments: None, ann };
+    print_crate_with_state(s, krate, is_expanded, edition, g)
+}
+
+fn print_crate_with_state<'a>(
+    mut s: State<'a>,
+    krate: &ast::Crate,
+    is_expanded: bool,
+    edition: Edition,
+    g: &AttrIdGenerator,
+) -> String {
     if is_expanded && !krate.attrs.iter().any(|attr| attr.has_name(sym::no_core)) {
         // We need to print `#![no_std]` (and its feature gate) so that
         // compiling pretty-printed source won't inject libstd again.
@@ -1383,17 +1431,7 @@ impl<'a> State<'a> {
 
         let has_attrs = self.print_inner_attributes(attrs);
 
-        for (i, st) in blk.stmts.iter().enumerate() {
-            match &st.kind {
-                ast::StmtKind::Expr(expr) if i == blk.stmts.len() - 1 => {
-                    self.maybe_print_comment(st.span.lo());
-                    self.space_if_not_bol();
-                    self.print_expr_outer_attr_style(expr, false, FixupContext::new_stmt());
-                    self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));
-                }
-                _ => self.print_stmt(st),
-            }
-        }
+        self.ann.nested(self, AnnNode::Block(blk));
 
         let empty = !has_attrs && blk.stmts.is_empty();
         self.bclose_maybe_open(blk.span, empty, close_box);

Diff for: compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -155,8 +155,12 @@ impl<'a> State<'a> {
         self.print_outer_attributes(&item.attrs);
         self.ann.pre(self, AnnNode::Item(item));
         match &item.kind {
-            ast::ItemKind::ExternCrate(orig_name) => {
-                self.head(visibility_qualified(&item.vis, "extern crate"));
+            ast::ItemKind::ExternCrate(kind, orig_name) => {
+                let head = match kind {
+                    ast::ExternCrateKind::Default => "extern crate",
+                    ast::ExternCrateKind::Stable => "extern dyn crate",
+                };
+                self.head(visibility_qualified(&item.vis, head));
                 if let &Some(orig_name) = orig_name {
                     self.print_name(orig_name);
                     self.space();

Diff for: compiler/rustc_builtin_macros/src/proc_macro_harness.rs

@@ -278,7 +278,12 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> P<ast::Item> {
     let span = DUMMY_SP.with_def_site_ctxt(expn_id.to_expn_id());
 
     let proc_macro = Ident::new(sym::proc_macro, span);
-    let krate = cx.item(span, proc_macro, ast::AttrVec::new(), ast::ItemKind::ExternCrate(None));
+    let krate = cx.item(
+        span,
+        proc_macro,
+        ast::AttrVec::new(),
+        ast::ItemKind::ExternCrate(ast::ExternCrateKind::Default, None),
+    );
 
     let bridge = Ident::new(sym::bridge, span);
     let client = Ident::new(sym::client, span);

Diff for: compiler/rustc_builtin_macros/src/standard_library_imports.rs

@@ -57,14 +57,14 @@ pub fn inject(
                 span,
                 Ident::new(kw::Underscore, ident_span),
                 thin_vec![],
-                ast::ItemKind::ExternCrate(Some(name)),
+                ast::ItemKind::ExternCrate(ast::ExternCrateKind::Default, Some(name)),
             )
         } else {
             cx.item(
                 span,
                 Ident::new(name, ident_span),
                 thin_vec![cx.attr_word(sym::macro_use, span)],
-                ast::ItemKind::ExternCrate(None),
+                ast::ItemKind::ExternCrate(ast::ExternCrateKind::Default, None),
             )
         };
         krate.items.insert(0, item);

Diff for: compiler/rustc_builtin_macros/src/test.rs

@@ -352,7 +352,12 @@ pub(crate) fn expand_test_or_bench(
     });
 
     // extern crate test
-    let test_extern = cx.item(sp, test_id, ast::AttrVec::new(), ast::ItemKind::ExternCrate(None));
+    let test_extern = cx.item(
+        sp,
+        test_id,
+        ast::AttrVec::new(),
+        ast::ItemKind::ExternCrate(ast::ExternCrateKind::Default, None),
+    );
 
     debug!("synthetic test item:\n{}\n", pprust::item_to_string(&test_const));
 

Diff for: compiler/rustc_builtin_macros/src/test_harness.rs

@@ -318,7 +318,12 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
     // extern crate test
     let test_extern_stmt = ecx.stmt_item(
         sp,
-        ecx.item(sp, test_id, ast::AttrVec::new(), ast::ItemKind::ExternCrate(None)),
+        ecx.item(
+            sp,
+            test_id,
+            ast::AttrVec::new(),
+            ast::ItemKind::ExternCrate(ast::ExternCrateKind::Default, None),
+        ),
     );
 
     // #[rustc_main]

Diff for: compiler/rustc_codegen_ssa/src/back/write.rs

@@ -626,7 +626,11 @@ fn produce_final_output_artifacts(
                 user_wants_objects = true;
                 copy_if_one_unit(OutputType::Object, true);
             }
-            OutputType::Mir | OutputType::Metadata | OutputType::Exe | OutputType::DepInfo => {}
+            OutputType::Mir
+            | OutputType::Metadata
+            | OutputType::Exe
+            | OutputType::DepInfo
+            | OutputType::Interface => {}
         }
     }
 

Diff for: compiler/rustc_driver_impl/src/lib.rs

@@ -439,6 +439,14 @@ fn run_compiler(
                 return early_exit();
             }
 
+            rustc_interface::export::write_interface(tcx);
+
+            if sess.opts.output_types.contains_key(&OutputType::Interface)
+                && sess.opts.output_types.len() == 1
+            {
+                return early_exit();
+            }
+
             if sess.opts.unstable_opts.no_analysis {
                 return early_exit();
             }

Diff for: compiler/rustc_feature/src/builtin_attrs.rs

@@ -511,6 +511,11 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         naked_functions, experimental!(naked)
     ),
 
+    gated!(
+        export, Normal, template!(Word), WarnFollowing,
+        EncodeCrossCrate::Yes, experimental!(export)
+    ),
+
     // Testing:
     gated!(
         test_runner, CrateLevel, template!(List: "path"), ErrorFollowing,

Diff for: compiler/rustc_feature/src/unstable.rs

@@ -479,6 +479,8 @@ declare_features! (
     (unstable, exhaustive_patterns, "1.13.0", Some(51085)),
     /// Allows explicit tail calls via `become` expression.
     (incomplete, explicit_tail_calls, "1.72.0", Some(112788)),
+    /// Allows using `#[export]` which indicates that an item is exportable.
+    (unstable, export, "CURRENT_RUSTC_VERSION", None),
     /// Allows defining `extern type`s.
     (unstable, extern_types, "1.23.0", Some(43467)),
     /// Allow using 128-bit (quad precision) floating point numbers.

Diff for: compiler/rustc_interface/src/export.rs

@@ -0,0 +1,50 @@
+use std::fs::File;
+use std::io::{self, BufWriter, Write};
+
+use rustc_ast_pretty::pprust::{self, AnnNode, PpAnn, State};
+use rustc_middle::ty::TyCtxt;
+use rustc_session::config::{OutFileName, OutputType};
+
+struct InterfaceAnn;
+
+impl PpAnn for InterfaceAnn {
+    fn nested(&self, state: &mut State<'_>, node: AnnNode<'_>) {
+        // Insert empty fn bodies.
+        if let AnnNode::Block(_) = node {
+            state.nbsp();
+            state.word_nbsp("loop {}");
+            return;
+        }
+
+        pprust::state::print_default_nested_ann(state, node);
+    }
+}
+
+pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
+    let sess = tcx.sess;
+    if !sess.opts.output_types.contains_key(&OutputType::Interface) {
+        return;
+    }
+    let _timer = sess.timer("write_interface");
+
+    let krate = &tcx.resolver_for_lowering().borrow().1;
+    let krate = pprust::state::print_crate_with_erased_comments(
+        &krate,
+        &InterfaceAnn,
+        true,
+        sess.edition(),
+        &sess.psess.attr_id_generator,
+    );
+    let outputs = tcx.output_filenames(());
+    let export_output = outputs.path(OutputType::Interface);
+    match export_output {
+        OutFileName::Stdout => {
+            let mut file = BufWriter::new(io::stdout());
+            let _ = write!(file, "{}", krate);
+        }
+        OutFileName::Real(ref path) => {
+            let mut file = File::create_buffered(path).unwrap();
+            let _ = write!(file, "{}", krate);
+        }
+    }
+}

Diff for: compiler/rustc_interface/src/lib.rs

@@ -9,6 +9,7 @@
 
 mod callbacks;
 pub mod errors;
+pub mod export;
 pub mod interface;
 pub mod passes;
 mod proc_macro_decls;

Diff for: compiler/rustc_interface/src/passes.rs

@@ -861,6 +861,7 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
                 // as used, and ensures that their values are valid.
                 tcx.ensure().limits(());
                 tcx.ensure().stability_index(());
+                tcx.ensure().exportable_items(LOCAL_CRATE);
             }
         );
     });