tests/testsuite/plugins.rs

   1 //! Tests for rustc plugins.
   2
   3 use cargo_test_support::rustc_host;
   4 use cargo_test_support::{basic_manifest, project};
   5
   6 #[cargo_test(nightly, reason = "plugins are unstable")]
   7 fn plugin_to_the_max() {
   8     let foo = project()
   9         .file(
  10             "Cargo.toml",
  11             r#"
  12                 [package]
  13                 name = "foo"
  14                 version = "0.0.1"
  15                 authors = []
  16
  17                 [lib]
  18                 name = "foo_lib"
  19
  20                 [dependencies.bar]
  21                 path = "../bar"
  22             "#,
  23         )
  24         .file(
  25             "src/main.rs",
  26             r#"
  27                 #![feature(plugin)]
  28                 #![plugin(bar)]
  29                 extern crate foo_lib;
  30
  31                 fn main() { foo_lib::foo(); }
  32             "#,
  33         )
  34         .file(
  35             "src/foo_lib.rs",
  36             r#"
  37                 #![feature(plugin)]
  38                 #![plugin(bar)]
  39
  40                 pub fn foo() {}
  41             "#,
  42         )
  43         .build();
  44     let _bar = project()
  45         .at("bar")
  46         .file(
  47             "Cargo.toml",
  48             r#"
  49                 [package]
  50                 name = "bar"
  51                 version = "0.0.1"
  52                 authors = []
  53
  54                 [lib]
  55                 name = "bar"
  56                 plugin = true
  57
  58                 [dependencies.baz]
  59                 path = "../baz"
  60             "#,
  61         )
  62         .file(
  63             "src/lib.rs",
  64             r#"
  65                 #![feature(rustc_private)]
  66
  67                 extern crate baz;
  68                 extern crate rustc_driver;
  69
  70                 use rustc_driver::plugin::Registry;
  71
  72                 #[no_mangle]
  73                 pub fn __rustc_plugin_registrar(_reg: &mut Registry) {
  74                     println!("{}", baz::baz());
  75                 }
  76             "#,
  77         )
  78         .build();
  79     let _baz = project()
  80         .at("baz")
  81         .file(
  82             "Cargo.toml",
  83             r#"
  84                 [package]
  85                 name = "baz"
  86                 version = "0.0.1"
  87                 authors = []
  88
  89                 [lib]
  90                 name = "baz"
  91                 crate_type = ["dylib"]
  92             "#,
  93         )
  94         .file("src/lib.rs", "pub fn baz() -> i32 { 1 }")
  95         .build();
  96
  97     foo.cargo("build").run();
  98     foo.cargo("doc").run();
  99 }
 100
 101 #[cargo_test(nightly, reason = "plugins are unstable")]
 102 fn plugin_with_dynamic_native_dependency() {
 103     let build = project()
 104         .at("builder")
 105         .file(
 106             "Cargo.toml",
 107             r#"
 108                 [package]
 109                 name = "builder"
 110                 version = "0.0.1"
 111                 authors = []
 112
 113                 [lib]
 114                 name = "builder"
 115                 crate-type = ["dylib"]
 116             "#,
 117         )
 118         .file("src/lib.rs", "#[no_mangle] pub extern fn foo() {}")
 119         .build();
 120
 121     let foo = project()
 122         .file(
 123             "Cargo.toml",
 124             r#"
 125                 [package]
 126                 name = "foo"
 127                 version = "0.0.1"
 128                 authors = []
 129
 130                 [dependencies.bar]
 131                 path = "bar"
 132             "#,
 133         )
 134         .file(
 135             "src/main.rs",
 136             r#"
 137                 #![feature(plugin)]
 138                 #![plugin(bar)]
 139
 140                 fn main() {}
 141             "#,
 142         )
 143         .file(
 144             "bar/Cargo.toml",
 145             r#"
 146                 [package]
 147                 name = "bar"
 148                 version = "0.0.1"
 149                 authors = []
 150                 build = 'build.rs'
 151
 152                 [lib]
 153                 name = "bar"
 154                 plugin = true
 155             "#,
 156         )
 157         .file(
 158             "bar/build.rs",
 159             r#"
 160                 use std::env;
 161                 use std::fs;
 162                 use std::path::PathBuf;
 163
 164                 fn main() {
 165                     let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
 166                     let root = PathBuf::from(env::var("BUILDER_ROOT").unwrap());
 167                     let file = format!("{}builder{}",
 168                         env::consts::DLL_PREFIX,
 169                         env::consts::DLL_SUFFIX);
 170                     let src = root.join(&file);
 171                     let dst = out_dir.join(&file);
 172                     fs::copy(src, dst).unwrap();
 173                     if cfg!(target_env = "msvc") {
 174                         fs::copy(root.join("builder.dll.lib"),
 175                                  out_dir.join("builder.dll.lib")).unwrap();
 176                     }
 177                     println!("cargo:rustc-flags=-L {}", out_dir.display());
 178                 }
 179             "#,
 180         )
 181         .file(
 182             "bar/src/lib.rs",
 183             r#"
 184                 #![feature(rustc_private)]
 185
 186                 extern crate rustc_driver;
 187                 use rustc_driver::plugin::Registry;
 188
 189                 #[cfg_attr(not(target_env = "msvc"), link(name = "builder"))]
 190                 #[cfg_attr(target_env = "msvc", link(name = "builder.dll"))]
 191                 extern { fn foo(); }
 192
 193                 #[no_mangle]
 194                 pub fn __rustc_plugin_registrar(_reg: &mut Registry) {
 195                     unsafe { foo() }
 196                 }
 197             "#,
 198         )
 199         .build();
 200
 201     build.cargo("build").run();
 202
 203     let root = build.root().join("target").join("debug");
 204     foo.cargo("build -v").env("BUILDER_ROOT", root).run();
 205 }
 206
 207 #[cargo_test]
 208 fn plugin_integration() {
 209     let p = project()
 210         .file(
 211             "Cargo.toml",
 212             r#"
 213                 [package]
 214                 name = "foo"
 215                 version = "0.0.1"
 216                 authors = []
 217                 build = "build.rs"
 218
 219                 [lib]
 220                 name = "foo"
 221                 plugin = true
 222                 doctest = false
 223             "#,
 224         )
 225         .file("build.rs", "fn main() {}")
 226         .file("src/lib.rs", "")
 227         .file("tests/it_works.rs", "")
 228         .build();
 229
 230     p.cargo("test -v").run();
 231 }
 232
 233 #[cargo_test]
 234 fn doctest_a_plugin() {
 235     let p = project()
 236         .file(
 237             "Cargo.toml",
 238             r#"
 239                 [package]
 240                 name = "foo"
 241                 version = "0.0.1"
 242                 authors = []
 243
 244                 [dependencies]
 245                 bar = { path = "bar" }
 246             "#,
 247         )
 248         .file("src/lib.rs", "#[macro_use] extern crate bar;")
 249         .file(
 250             "bar/Cargo.toml",
 251             r#"
 252                 [package]
 253                 name = "bar"
 254                 version = "0.0.1"
 255                 authors = []
 256
 257                 [lib]
 258                 name = "bar"
 259                 plugin = true
 260             "#,
 261         )
 262         .file("bar/src/lib.rs", "pub fn bar() {}")
 263         .build();
 264
 265     p.cargo("test -v").run();
 266 }
 267
 268 // See #1515
 269 #[cargo_test]
 270 fn native_plugin_dependency_with_custom_linker() {
 271     let target = rustc_host();
 272
 273     let _foo = project()
 274         .file(
 275             "Cargo.toml",
 276             r#"
 277                 [package]
 278                 name = "foo"
 279                 version = "0.0.1"
 280                 authors = []
 281
 282                 [lib]
 283                 plugin = true
 284             "#,
 285         )
 286         .file("src/lib.rs", "")
 287         .build();
 288
 289     let bar = project()
 290         .at("bar")
 291         .file(
 292             "Cargo.toml",
 293             r#"
 294                 [package]
 295                 name = "bar"
 296                 version = "0.0.1"
 297                 authors = []
 298
 299                 [dependencies.foo]
 300                 path = "../foo"
 301             "#,
 302         )
 303         .file("src/lib.rs", "")
 304         .file(
 305             ".cargo/config",
 306             &format!(
 307                 r#"
 308                     [target.{}]
 309                     linker = "nonexistent-linker"
 310                 "#,
 311                 target
 312             ),
 313         )
 314         .build();
 315
 316     bar.cargo("build --verbose")
 317         .with_status(101)
 318         .with_stderr_contains(
 319             "\
 320 [COMPILING] foo v0.0.1 ([..])
 321 [RUNNING] `rustc [..] -C linker=nonexistent-linker [..]`
 322 [ERROR] [..]linker[..]
 323 ",
 324         )
 325         .run();
 326 }
 327
 328 #[cargo_test(nightly, reason = "requires rustc_private")]
 329 fn panic_abort_plugins() {
 330     let p = project()
 331         .file(
 332             "Cargo.toml",
 333             r#"
 334                 [package]
 335                 name = "foo"
 336                 version = "0.0.1"
 337                 authors = []
 338
 339                 [profile.dev]
 340                 panic = 'abort'
 341
 342                 [dependencies]
 343                 bar = { path = "bar" }
 344             "#,
 345         )
 346         .file("src/lib.rs", "")
 347         .file(
 348             "bar/Cargo.toml",
 349             r#"
 350                 [package]
 351                 name = "bar"
 352                 version = "0.0.1"
 353                 authors = []
 354
 355                 [lib]
 356                 plugin = true
 357             "#,
 358         )
 359         .file(
 360             "bar/src/lib.rs",
 361             r#"
 362                 #![feature(rustc_private)]
 363                 extern crate rustc_ast;
 364             "#,
 365         )
 366         .build();
 367
 368     p.cargo("build").run();
 369 }
 370
 371 #[cargo_test(nightly, reason = "requires rustc_private")]
 372 fn shared_panic_abort_plugins() {
 373     let p = project()
 374         .file(
 375             "Cargo.toml",
 376             r#"
 377                 [package]
 378                 name = "foo"
 379                 version = "0.0.1"
 380                 authors = []
 381
 382                 [profile.dev]
 383                 panic = 'abort'
 384
 385                 [dependencies]
 386                 bar = { path = "bar" }
 387                 baz = { path = "baz" }
 388             "#,
 389         )
 390         .file("src/lib.rs", "extern crate baz;")
 391         .file(
 392             "bar/Cargo.toml",
 393             r#"
 394                 [package]
 395                 name = "bar"
 396                 version = "0.0.1"
 397                 authors = []
 398
 399                 [lib]
 400                 plugin = true
 401
 402                 [dependencies]
 403                 baz = { path = "../baz" }
 404             "#,
 405         )
 406         .file(
 407             "bar/src/lib.rs",
 408             r#"
 409                 #![feature(rustc_private)]
 410                 extern crate rustc_ast;
 411                 extern crate baz;
 412             "#,
 413         )
 414         .file("baz/Cargo.toml", &basic_manifest("baz", "0.0.1"))
 415         .file("baz/src/lib.rs", "")
 416         .build();
 417
 418     p.cargo("build -v").run();
 419 }