diff --git a/src/Cargo.lock b/src/Cargo.lock index a5ad7d6ff697e2d66b87dddd4710ad0617a05b12..693bf5b2619fffde28747a3490c1f6b012d06872 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -1575,6 +1575,7 @@ dependencies = [ "rustc_resolve 0.0.0", "rustc_save_analysis 0.0.0", "rustc_trans 0.0.0", + "rustc_trans_traits 0.0.0", "rustc_trans_utils 0.0.0", "rustc_typeck 0.0.0", "serialize 0.0.0", @@ -1769,12 +1770,23 @@ dependencies = [ "rustc_incremental 0.0.0", "rustc_llvm 0.0.0", "rustc_platform_intrinsics 0.0.0", + "rustc_trans_traits 0.0.0", "rustc_trans_utils 0.0.0", "serialize 0.0.0", "syntax 0.0.0", "syntax_pos 0.0.0", ] +[[package]] +name = "rustc_trans_traits" +version = "0.0.0" +dependencies = [ + "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", + "rustc 0.0.0", + "rustc_back 0.0.0", + "rustc_incremental 0.0.0", +] + [[package]] name = "rustc_trans_utils" version = "0.0.0" diff --git a/src/librustc_driver/Cargo.toml b/src/librustc_driver/Cargo.toml index 2aac1b085e95a935265642b4d42456ff1df797e5..6399f3ad2687e87c762b993851cb19065345ac07 100644 --- a/src/librustc_driver/Cargo.toml +++ b/src/librustc_driver/Cargo.toml @@ -33,6 +33,7 @@ rustc_resolve = { path = "../librustc_resolve" } rustc_save_analysis = { path = "../librustc_save_analysis" } rustc_trans = { path = "../librustc_trans", optional = true } rustc_trans_utils = { path = "../librustc_trans_utils" } +rustc_trans_traits = { path = "../librustc_trans_traits" } rustc_typeck = { path = "../librustc_typeck" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 457c9357336b386ad99ceb8368f05b74a868d81b..9aab169023c95370a4e014547e68a7fb2d857d24 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -34,8 +34,8 @@ use rustc_resolve::{MakeGlobMap, Resolver}; use rustc_metadata::creader::CrateLoader; use rustc_metadata::cstore::{self, CStore}; -use rustc_trans::back::write; use rustc_trans as trans; +use rustc_trans_traits::TransCrate; use rustc_typeck as typeck; use rustc_privacy; use rustc_plugin::registry::Registry; @@ -43,6 +43,7 @@ use rustc_passes::{ast_validation, no_asm, loops, consts, static_recursion, hir_stats}; use rustc_const_eval::{self, check_match}; use super::Compilation; +use ::DefaultTransCrate; use serialize::json; @@ -76,7 +77,6 @@ pub fn compile_input(sess: &Session, output: &Option, addl_plugins: Option>, control: &CompileController) -> CompileResult { - use rustc_trans::back::write::OngoingCrateTranslation; use rustc::session::config::CrateType; macro_rules! controller_entry_point { @@ -122,7 +122,7 @@ pub fn compile_input(sess: &Session, // We need nested scopes here, because the intermediate results can keep // large chunks of memory alive and we want to free them as soon as // possible to keep the peak memory usage low - let (outputs, trans, dep_graph): (OutputFilenames, OngoingCrateTranslation, DepGraph) = { + let (outputs, trans, dep_graph) = { let krate = match phase_1_parse_input(control, sess, input) { Ok(krate) => krate, Err(mut parse_error) => { @@ -251,7 +251,7 @@ pub fn compile_input(sess: &Session, tcx.print_debug_stats(); } - let trans = phase_4_translate_to_llvm(tcx, rx); + let trans = phase_4_translate_to_llvm::(tcx, rx); if log_enabled!(::log::LogLevel::Info) { println!("Post-trans"); @@ -285,7 +285,7 @@ pub fn compile_input(sess: &Session, sess.code_stats.borrow().print_type_sizes(); } - let (phase5_result, trans) = phase_5_run_llvm_passes(sess, &dep_graph, trans); + let (phase5_result, trans) = phase_5_run_llvm_passes::(sess, &dep_graph, trans); controller_entry_point!(after_llvm, sess, @@ -293,7 +293,7 @@ pub fn compile_input(sess: &Session, phase5_result); phase5_result?; - phase_6_link_output(sess, &trans, &outputs); + phase_6_link_output::(sess, &trans, &outputs); // Now that we won't touch anything in the incremental compilation directory // any more, we can finalize it (which involves renaming it) @@ -972,7 +972,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, mir::provide(&mut local_providers); reachable::provide(&mut local_providers); rustc_privacy::provide(&mut local_providers); - trans::provide_local(&mut local_providers); + DefaultTransCrate::provide_local(&mut local_providers); typeck::provide(&mut local_providers); ty::provide(&mut local_providers); traits::provide(&mut local_providers); @@ -984,7 +984,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, let mut extern_providers = ty::maps::Providers::default(); cstore::provide(&mut extern_providers); - trans::provide_extern(&mut extern_providers); + DefaultTransCrate::provide_extern(&mut extern_providers); ty::provide_extern(&mut extern_providers); traits::provide_extern(&mut extern_providers); // FIXME(eddyb) get rid of this once we replace const_eval with miri. @@ -1130,9 +1130,9 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, /// Run the translation phase to LLVM, after which the AST and analysis can /// be discarded. -pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, +pub fn phase_4_translate_to_llvm<'a, 'tcx, T: TransCrate>(tcx: TyCtxt<'a, 'tcx, 'tcx>, rx: mpsc::Receiver>) - -> write::OngoingCrateTranslation { + -> ::OngoingCrateTranslation { let time_passes = tcx.sess.time_passes(); time(time_passes, @@ -1141,9 +1141,8 @@ pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let translation = time(time_passes, "translation", move || { - trans::trans_crate(tcx, rx) + T::trans_crate(tcx, rx) }); - if tcx.sess.profile_queries() { profile::dump("profile_queries".to_string()) } @@ -1153,15 +1152,14 @@ pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, /// Run LLVM itself, producing a bitcode file, assembly file or object file /// as a side effect. -#[cfg(feature="llvm")] -pub fn phase_5_run_llvm_passes(sess: &Session, +pub fn phase_5_run_llvm_passes(sess: &Session, dep_graph: &DepGraph, - trans: write::OngoingCrateTranslation) - -> (CompileResult, trans::CrateTranslation) { - let trans = trans.join(sess, dep_graph); + trans: ::OngoingCrateTranslation) + -> (CompileResult, ::TranslatedCrate) { + let trans = T::join_trans(trans, sess, dep_graph); if sess.opts.debugging_opts.incremental_info { - write::dump_incremental_data(&trans); + T::dump_incremental_data(&trans); } time(sess.time_passes(), @@ -1174,14 +1172,11 @@ pub fn phase_5_run_llvm_passes(sess: &Session, /// Run the linker on any artifacts that resulted from the LLVM run. /// This should produce either a finished executable or library. #[cfg(feature="llvm")] -pub fn phase_6_link_output(sess: &Session, - trans: &trans::CrateTranslation, +pub fn phase_6_link_output(sess: &Session, + trans: &::TranslatedCrate, outputs: &OutputFilenames) { time(sess.time_passes(), "linking", || { - ::rustc_trans::back::link::link_binary(sess, - trans, - outputs, - &trans.crate_name.as_str()) + T::link_binary(sess, trans, outputs) }); } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 7af5ad3410fce08f06ebb5566e9011d603d7ff11..fda738db85fd81d42995ff2a3ae4da3b40c1bc8b 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -25,9 +25,7 @@ #![feature(rustc_diagnostic_macros)] #![feature(set_stdio)] -#[cfg(not(feature="llvm"))] extern crate ar; -#[cfg(not(feature="llvm"))] extern crate flate2; extern crate arena; extern crate getopts; @@ -54,6 +52,7 @@ #[cfg(feature="llvm")] extern crate rustc_trans; extern crate rustc_trans_utils; +extern crate rustc_trans_traits; extern crate rustc_typeck; extern crate serialize; #[macro_use] @@ -79,6 +78,7 @@ use rustc_metadata::locator; use rustc_metadata::cstore::CStore; use rustc::util::common::{time, ErrorReported}; +use rustc_trans_traits::TransCrate; use serialize::json::ToJson; @@ -155,11 +155,10 @@ pub fn run(run_compiler: F) -> isize } #[cfg(not(feature="llvm"))] -pub use no_llvm_metadata_loader::NoLLvmMetadataLoader as MetadataLoader; +pub use trans_metadata_only::MetadataOnlyTransCrate as DefaultTransCrate; #[cfg(feature="llvm")] -pub use rustc_trans::LlvmMetadataLoader as MetadataLoader; +pub use rustc_trans::LlvmTransCrate as DefaultTransCrate; -#[cfg(not(feature="llvm"))] mod no_llvm_metadata_loader { extern crate owning_ref; @@ -172,9 +171,9 @@ mod no_llvm_metadata_loader { use ar::Archive; use self::owning_ref::{OwningRef, ErasedBoxRef}; - pub struct NoLLvmMetadataLoader; + pub struct NoLlvmMetadataLoader; - impl MetadataLoaderTrait for NoLLvmMetadataLoader { + impl MetadataLoaderTrait for NoLlvmMetadataLoader { fn get_rlib_metadata( &self, _: &Target, @@ -210,40 +209,131 @@ fn get_dylib_metadata(&self, } } -#[cfg(not(feature="llvm"))] -mod rustc_trans { - use syntax_pos::symbol::Symbol; +mod trans_metadata_only { + use std::io::prelude::*; + use std::io::Cursor; + use std::fs::File; + + use ar::{Builder, Header}; + use flate2::Compression; + use flate2::write::DeflateEncoder; + + use syntax::symbol::Symbol; + use rustc::hir::def_id::LOCAL_CRATE; use rustc::session::Session; - use rustc::session::config::{PrintRequest, OutputFilenames}; + use rustc::session::config::{OutputFilenames, CrateType}; use rustc::ty::{TyCtxt, CrateAnalysis}; use rustc::ty::maps::Providers; + use rustc::middle::cstore::{MetadataLoader, EncodedMetadata}; + use rustc::dep_graph::DepGraph; use rustc_incremental::IncrementalHashesMap; + use rustc_trans_utils::find_exported_symbols; + use rustc_trans_utils::link::{out_filename, build_link_meta}; + use rustc_trans_traits::TransCrate; + + #[allow(dead_code)] + pub struct MetadataOnlyTransCrate; + pub struct OngoingCrateTranslation { + metadata: EncodedMetadata, + metadata_version: Vec, + crate_name: Symbol, + } + pub struct TranslatedCrate(OngoingCrateTranslation); + + impl MetadataOnlyTransCrate { + #[allow(dead_code)] + pub fn new(/*_sess: &Session*/) -> Self { + MetadataOnlyTransCrate + } + } + + impl TransCrate for MetadataOnlyTransCrate { + type MetadataLoader = ::no_llvm_metadata_loader::NoLlvmMetadataLoader; + type OngoingCrateTranslation = OngoingCrateTranslation; + type TranslatedCrate = TranslatedCrate; + + fn metadata_loader() -> Box { + box ::no_llvm_metadata_loader::NoLlvmMetadataLoader + } + + fn provide(_providers: &mut Providers) {} + + fn trans_crate<'a, 'tcx>( + tcx: TyCtxt<'a, 'tcx, 'tcx>, + analysis: CrateAnalysis, + incr_hashes_map: IncrementalHashesMap, + _output_filenames: &OutputFilenames + ) -> Self::OngoingCrateTranslation { + let link_meta = build_link_meta(&incr_hashes_map); + let exported_symbols = find_exported_symbols(tcx, &analysis.reachable); + let (metadata, _hashes) = tcx.encode_metadata(&link_meta, &exported_symbols); + + OngoingCrateTranslation { + metadata: metadata, + metadata_version: tcx.metadata_encoding_version().to_vec(), + crate_name: tcx.crate_name(LOCAL_CRATE), + } + } - use self::back::write::OngoingCrateTranslation; + fn join_trans( + trans: Self::OngoingCrateTranslation, + _sess: &Session, + _dep_graph: &DepGraph, + ) -> Self::TranslatedCrate { + TranslatedCrate(trans) + } + + fn link_binary(sess: &Session, + trans: &Self::TranslatedCrate, + outputs: &OutputFilenames) { + for &crate_type in sess.opts.crate_types.iter() { + if crate_type != CrateType::CrateTypeRlib && + crate_type != CrateType::CrateTypeDylib { + continue; + } + let output_name = + out_filename(sess, crate_type, &outputs, &trans.0.crate_name.as_str()); + let mut compressed = trans.0.metadata_version.clone(); + let metadata = if crate_type == CrateType::CrateTypeDylib { + DeflateEncoder::new(&mut compressed, Compression::Fast) + .write_all(&trans.0.metadata.raw_data).unwrap(); + &compressed + } else { + &trans.0.metadata.raw_data + }; + let mut builder = Builder::new(File::create(&output_name).unwrap()); + let header = Header::new( + "rust.metadata.bin".to_string(), + metadata.len() as u64 + ); + builder + .append(&header, Cursor::new(metadata)) + .unwrap(); + } + } + + fn dump_incremental_data(_trans: &Self::TranslatedCrate) {} + } +} + +#[cfg(not(feature="llvm"))] +mod rustc_trans { + use syntax_pos::symbol::Symbol; + use rustc::session::Session; + use rustc::session::config::PrintRequest; + pub use trans_metadata_only::MetadataOnlyTransCrate as LlvmTransCrate; pub fn init(_sess: &Session) {} pub fn enable_llvm_debug() {} - pub fn provide(_providers: &mut Providers) {} pub fn print_version() {} pub fn print_passes() {} pub fn print(_req: PrintRequest, _sess: &Session) {} pub fn target_features(_sess: &Session) -> Vec { vec![] } - pub fn trans_crate<'a, 'tcx>( - _tcx: TyCtxt<'a, 'tcx, 'tcx>, - _analysis: CrateAnalysis, - _incr_hashes_map: IncrementalHashesMap, - _output_filenames: &OutputFilenames - ) -> OngoingCrateTranslation { - OngoingCrateTranslation(()) - } - pub struct CrateTranslation(()); pub mod back { pub mod write { - pub struct OngoingCrateTranslation(pub (in ::rustc_trans) ()); - pub const RELOC_MODEL_ARGS: [(&'static str, ()); 0] = []; pub const CODE_GEN_MODEL_ARGS: [(&'static str, ()); 0] = []; } @@ -297,7 +387,7 @@ pub fn run_compiler<'a>(args: &[String], }, }; - let cstore = Rc::new(CStore::new(box ::MetadataLoader)); + let cstore = Rc::new(CStore::new(DefaultTransCrate::metadata_loader())); let loader = file_loader.unwrap_or(box RealFileLoader); let codemap = Rc::new(CodeMap::with_file_loader(loader, sopts.file_path_mapping())); diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index fad24e6a0f2b60a597e19d4efe99e8dba3abf390..cadd63f31f5b45323e0eb56c13ad47ab49bf0dbc 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -105,7 +105,7 @@ fn test_env(source_string: &str, options.unstable_features = UnstableFeatures::Allow; let diagnostic_handler = errors::Handler::with_emitter(true, false, emitter); - let cstore = Rc::new(CStore::new(box ::MetadataLoader)); + let cstore = Rc::new(CStore::new(DefaultTransCrate::metadata_loader())); let sess = session::build_session_(options, None, diagnostic_handler, diff --git a/src/librustc_trans/Cargo.toml b/src/librustc_trans/Cargo.toml index 6f1f5b4a123d8bc885fc664c26ad122a1e94dda9..479d12b7440d2cd364db3dd0c9f12969a283fcfe 100644 --- a/src/librustc_trans/Cargo.toml +++ b/src/librustc_trans/Cargo.toml @@ -27,6 +27,7 @@ rustc_incremental = { path = "../librustc_incremental" } rustc_llvm = { path = "../librustc_llvm" } rustc_platform_intrinsics = { path = "../librustc_platform_intrinsics" } rustc_trans_utils = { path = "../librustc_trans_utils" } +rustc_trans_traits = { path = "../librustc_trans_traits" } serialize = { path = "../libserialize" } syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index f45a011e94d8df322ae368b134e90ebe0dab4f31..9023f5c3e61698f2f98c264e688d299bd883860d 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -50,6 +50,7 @@ extern crate rustc_llvm as llvm; extern crate rustc_platform_intrinsics as intrinsics; extern crate rustc_const_math; +extern crate rustc_trans_traits; extern crate rustc_trans_utils; extern crate rustc_demangle; extern crate jobserver; @@ -138,6 +139,60 @@ pub mod back { mod type_of; mod value; +use rustc::ty::{self, TyCtxt, CrateAnalysis}; +use rustc::session::Session; +use rustc::session::config::OutputFilenames; +use rustc::middle::cstore::MetadataLoader; +use rustc::dep_graph::DepGraph; +use rustc_incremental::IncrementalHashesMap; + +pub struct LlvmTransCrate(()); + +impl LlvmTransCrate { + pub fn new() -> Self { + LlvmTransCrate(()) + } +} + +impl rustc_trans_traits::TransCrate for LlvmTransCrate { + type MetadataLoader = metadata::LlvmMetadataLoader; + type OngoingCrateTranslation = back::write::OngoingCrateTranslation; + type TranslatedCrate = CrateTranslation; + + fn metadata_loader() -> Box { + box metadata::LlvmMetadataLoader + } + + fn provide(providers: &mut ty::maps::Providers) { + back::symbol_names::provide(providers); + } + + fn trans_crate<'a, 'tcx>( + tcx: TyCtxt<'a, 'tcx, 'tcx>, + analysis: CrateAnalysis, + incr_hashes_map: IncrementalHashesMap, + output_filenames: &OutputFilenames + ) -> Self::OngoingCrateTranslation { + base::trans_crate(tcx, analysis, incr_hashes_map, output_filenames) + } + + fn join_trans( + trans: Self::OngoingCrateTranslation, + sess: &Session, + dep_graph: &DepGraph + ) -> Self::TranslatedCrate { + trans.join(sess, dep_graph) + } + + fn link_binary(sess: &Session, trans: &Self::TranslatedCrate, outputs: &OutputFilenames) { + back::link::link_binary(sess, trans, outputs, &trans.crate_name.as_str()); + } + + fn dump_incremental_data(trans: &Self::TranslatedCrate) { + back::write::dump_incremental_data(trans); + } +} + pub struct ModuleTranslation { /// The name of the module. When the crate may be saved between /// compilations, incremental compilation requires that name be diff --git a/src/librustc_trans_traits/Cargo.toml b/src/librustc_trans_traits/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..418de173fd14a1c7983e3345611ea891b927bcfb --- /dev/null +++ b/src/librustc_trans_traits/Cargo.toml @@ -0,0 +1,17 @@ +[package] +authors = ["The Rust Project Developers"] +name = "rustc_trans_traits" +version = "0.0.0" + +[lib] +name = "rustc_trans_traits" +path = "lib.rs" +crate-type = ["dylib"] +test = false + +[dependencies] +owning_ref = "0.3.3" + +rustc = { path = "../librustc" } +rustc_back = { path = "../librustc_back" } +rustc_incremental = { path = "../librustc_incremental" } diff --git a/src/librustc_trans_traits/lib.rs b/src/librustc_trans_traits/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..340d54c1029fc3fe739a0798640acfe1b057a1e2 --- /dev/null +++ b/src/librustc_trans_traits/lib.rs @@ -0,0 +1,116 @@ +// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! The Rust compiler. +//! +//! # Note +//! +//! This API is completely unstable and subject to change. + +#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", + html_favicon_url = "https://doc.rust-lang.org/favicon.ico", + html_root_url = "https://doc.rust-lang.org/nightly/")] +#![deny(warnings)] + +#![feature(box_syntax)] + +extern crate owning_ref; + +#[macro_use] +extern crate rustc; +extern crate rustc_back; +extern crate rustc_incremental; + +use std::path::Path; +use owning_ref::ErasedBoxRef; + +use rustc::session::Session; +use rustc::session::config::OutputFilenames; +use rustc::ty::{TyCtxt, CrateAnalysis}; +use rustc::ty::maps::Providers; +use rustc::middle::cstore::MetadataLoader as MetadataLoaderTrait; +use rustc::dep_graph::DepGraph; +use rustc_back::target::Target; +use rustc_incremental::IncrementalHashesMap; + +pub trait TransCrate { + type MetadataLoader: MetadataLoaderTrait; + type OngoingCrateTranslation; + type TranslatedCrate; + + fn metadata_loader() -> Box; + fn provide(_providers: &mut Providers); + fn trans_crate<'a, 'tcx>( + tcx: TyCtxt<'a, 'tcx, 'tcx>, + analysis: CrateAnalysis, + incr_hashes_map: IncrementalHashesMap, + output_filenames: &OutputFilenames + ) -> Self::OngoingCrateTranslation; + fn join_trans( + trans: Self::OngoingCrateTranslation, + sess: &Session, + dep_graph: &DepGraph + ) -> Self::TranslatedCrate; + fn link_binary(sess: &Session, trans: &Self::TranslatedCrate, outputs: &OutputFilenames); + fn dump_incremental_data(trans: &Self::TranslatedCrate); +} + +pub struct DummyTransCrate; + +impl TransCrate for DummyTransCrate { + type MetadataLoader = DummyMetadataLoader; + type OngoingCrateTranslation = (); + type TranslatedCrate = (); + + fn metadata_loader() -> Box { + box DummyMetadataLoader(()) + } + + fn provide(_providers: &mut Providers) { + bug!("DummyTransCrate::provide"); + } + + fn trans_crate<'a, 'tcx>( + _tcx: TyCtxt<'a, 'tcx, 'tcx>, + _analysis: CrateAnalysis, + _incr_hashes_map: IncrementalHashesMap, + _output_filenames: &OutputFilenames + ) -> Self::OngoingCrateTranslation { + bug!("DummyTransCrate::trans_crate"); + } + + fn join_trans( + _trans: Self::OngoingCrateTranslation, + _sess: &Session, + _dep_graph: &DepGraph + ) -> Self::TranslatedCrate { + bug!("DummyTransCrate::join_trans"); + } + + fn link_binary(_sess: &Session, _trans: &Self::TranslatedCrate, _outputs: &OutputFilenames) { + bug!("DummyTransCrate::link_binary"); + } + + fn dump_incremental_data(_trans: &Self::TranslatedCrate) { + bug!("DummyTransCrate::dump_incremental_data"); + } +} + +pub struct DummyMetadataLoader(()); + +impl MetadataLoaderTrait for DummyMetadataLoader { + fn get_rlib_metadata(&self, _target: &Target, _filename: &Path) -> Result, String> { + bug!("DummyMetadataLoader::get_rlib_metadata"); + } + + fn get_dylib_metadata(&self, _target: &Target, _filename: &Path) -> Result, String> { + bug!("DummyMetadataLoader::get_dylib_metadata"); + } +}