28 #![allow(warnings)]

29 #![feature(rustc_attrs)]

30 #![crate_type="rlib"]

31 #![feature(associated_type_defaults)]

32 #![feature(intrinsics)]

29 #![allow(warnings)]

30 #![feature(rustc_attrs)]

31 #![crate_type="rlib"]

32

33 // Layout ----------------------------------------------------------------------

5

6 #![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_sym)]

7 #![crate_type = "rlib"]

8 #![no_core]

9 #![allow(asm_sub_register, non_camel_case_types)]

26 #![feature(linkage)]

27 #![feature(rustc_attrs)]

28 #![crate_type = "rlib"]

29

30

23 #![allow(warnings)]

24 #![feature(rustc_attrs)]

25 #![crate_type="rlib"]

26

27

243 });

244

245 test!(bad_crate_type {

246 let foo = project("foo")

247 .file("Cargo.toml", r#"

9 // except according to those terms.

10 #![crate_name="lint_stability"]

11 #![crate_type = "lib"]

12 #![feature(staged_api)]

13 #![stable(feature = "lint_stability", since = "1.0.0")]

1 // build-pass

2 // ignore-tidy-filelength

3 #![crate_type = "rlib"]

4

5 fn banana(v: &str) -> u32 {

19 #![feature(rustc_attrs)]

20 #![feature(specialization)]

21 #![crate_type="rlib"]

22

23 struct Foo;

23 #![allow(warnings)]

24 #![feature(rustc_attrs)]

25 #![crate_type="rlib"]

26 #![feature(associated_type_defaults)]

27

19 #![allow(warnings)]

20 #![feature(rustc_attrs)]

21 #![crate_type="rlib"]

22

23 pub struct Foo;

24 #![feature(rustc_attrs)]

25 #![feature(stmt_expr_attributes)]

26 #![crate_type="rlib"]

27

28

2 //

3

4 #![crate_type = "lib"]

5

6 #![feature(repr_simd, platform_intrinsics)]

136

137 #[cargo_test]

138 fn fails_with_crate_type_and_without_unstable_options() {

139 let p = project().file("src/lib.rs", r#" "#).build();

140

150

151 #[cargo_test]

152 fn fails_with_crate_type_to_multi_binaries() {

153 let p = project()

154 .file("src/bin/foo.rs", "fn main() {}")

169

170 #[cargo_test]

171 fn fails_with_crate_type_to_multi_examples() {

172 let p = project()

173 .file(

48 "bin"

49 ],

50 "crate_types": [

51 "bin"

52 ],

99

100 #[cargo_test]

101 fn library_with_several_crate_types() {

102 let p = project()

103 .file("src/lib.rs", "")

146 "staticlib"

147 ],

148 "crate_types": [

149 "lib",

150 "staticlib"

73 [lib]

74 name = "baz"

75 crate_type = ["dylib"]

76 "#)

77 .file("src/lib.rs", "pub fn baz() -> i32 { 1 }");

9

10 #![feature(rustc_private)]

11 #![crate_type = "lib"]

12

13 extern crate rustc_errors;

18 #![allow(warnings)]

19 #![feature(rustc_attrs)]

20 #![crate_type="rlib"]

21

22 // Change condition (if)

24 #![allow(warnings)]

25 #![feature(rustc_attrs)]

26 #![crate_type="rlib"]

27

28 // Add Arm ---------------------------------------------------------------------

24 #![allow(warnings)]

25 #![feature(rustc_attrs)]

26 #![crate_type="rlib"]

27

28 // Change Name -----------------------------------------------------------------

30 "targets":[{{

31 "kind":["bin"],

32 "crate_types":["bin"],

33 "doc": true,

34 "doctest": false,

10

11 #![crate_name = "alloc_system"]

12 #![crate_type = "rlib"]

13 #![no_std]

14 #![allocator]

10

11 #![crate_name = "alloc_jemalloc"]

12 #![crate_type = "rlib"]

13 #![no_std]

14 #![allocator]

52 let _task = ast_map.dep_graph.in_task(DepNode::EntryPoint);

53

54 let any_exe = session.crate_types.borrow().iter().any(|ty| {

55 *ty == config::CrateTypeExecutable

56 });

55 // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<u32>, core::ops::function::FnOnce<tuple$<> > >::vtable$

56

57 #![crate_type = "lib"]

58

59 // Force emission for debuginfo for usize and *const() early..

49

50 pub fn find_entry_point(session: &Session, ast_map: &ast_map::Map) {

51 let any_exe = session.crate_types.borrow().iter().any(|ty| {

52 *ty == config::CrateTypeExecutable

53 });

11 #![crate_name = "rustc_platform_intrinsics"]

12 #![unstable(feature = "rustc_private", issue = "27812")]

13 #![crate_type = "dylib"]

14 #![crate_type = "rlib"]

2 // needs-llvm-components: riscv

3

4 #![crate_type = "lib"]

5 #![no_core]

6 #![feature(no_core, lang_items)]

1 #![crate_type = "lib"]

2 #![feature(staged_api)]

3 #![stable(feature = "stable_test_feature", since = "1.0.0")]

85 },

86 "target": {

87 "crate_types": [

88 "lib"

89 ],

130 },

131 "target": {

132 "crate_types": [

133 "lib"

134 ],

168 },

169 "target": {

170 "crate_types": [

171 "lib"

172 ],

10

11 #![feature(no_core, lang_items, rustc_attrs)]

12 #![crate_type = "rlib"]

13 #![no_core]

14 #![allow(asm_sub_register)]

9 // except according to those terms.

10 #![crate_name="lint_stability"]

11 #![crate_type = "lib"]

12 #![feature(staged_api)]

13 #![staged_api]

90

91 declare_lint! {

92 pub UNKNOWN_CRATE_TYPES,

93 Deny,

94 "unknown crate type found in #[crate_type] directive"

162 UNUSED_FEATURES,

163 STABLE_FEATURES,

164 UNKNOWN_CRATE_TYPES,

165 VARIANT_SIZE_DIFFERENCES,

166 FAT_PTR_TRANSMUTES,

11 // force-host

12

13 #![crate_type="dylib"]

14 #![feature(plugin_registrar, quote, rustc_private)]

15

20 #![unstable(feature = "rustc_private")]

21 #![staged_api]

22 #![crate_type = "dylib"]

23 #![crate_type = "rlib"]

19 #![feature(stmt_expr_attributes)]

20 #![allow(dead_code)]

21 #![crate_type = "rlib"]

22

23 #![rustc_partition_codegened(module="struct_point-point", cfg="cfail2")]

3 // only-riscv64

4 // only-linux

5 #![crate_type = "lib"]

6

7 // CHECK: define void @f_fpr_tracking(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, i8 zeroext %i)

1 // compile-flags:-Zpolymorphize=on -Zprint-mono-items=lazy -Copt-level=1

2

3 #![crate_type = "rlib"]

4

5 // This test checks that the polymorphization analysis correctly reduces the

18 #![allow(warnings)]

19 #![feature(rustc_attrs)]

20 #![crate_type="rlib"]

21

22 // Change simple index

17 #![feature(core)]

18

19 #![crate_type="lib"]

20

21 extern crate core;

94 [lib]

95 name = "baz"

96 crate_type = ["dylib"]

97 "#,

98 )

19 #![feature(linkage)]

20 #![feature(rustc_attrs)]

21 #![crate_type = "rlib"]

22

23 // Add Parameter ---------------------------------------------------------------

24 #![allow(warnings)]

25 #![feature(rustc_attrs)]

26 #![crate_type="rlib"]

27

28 // Change condition (if) -------------------------------------------------------

15 // compile-pass

16

17 #![crate_type = "rlib"]

18 #![feature(rustc_attrs)]

19 #![feature(stmt_expr_attributes)]

68 // We only need to check for the presence of weak lang items if we're

69 // emitting something that's not an rlib.

70 let needs_check = sess.crate_types.borrow().iter().any(|kind| {

71 match *kind {

72 config::CrateTypeDylib |

1 #![feature(lang_items,core_intrinsics,asm,start)]

2 #![no_std]

3 #![crate_type="staticlib"]

4

5 use core::intrinsics::volatile_store;

14 #![feature(transparent_unions)]

15

16 #![crate_type="lib"]

17

18

13

14 #![feature(proc_macro)]

15 #![crate_type = "proc-macro"]

16

17 extern crate proc_macro;

5

6 #![feature(no_core, lang_items, rustc_attrs, asm_sym, asm_experimental_arch, asm_const)]

7 #![crate_type = "rlib"]

8 #![no_core]

9 #![allow(non_camel_case_types)]

2 // compile-flags: -O -C no-prepopulate-passes

3

4 #![crate_type = "lib"]

5

6 #[repr(packed)]

8

9 #![feature(no_core, lang_items, rustc_attrs, asm_sym)]

10 #![crate_type = "rlib"]

11 #![no_core]

12 #![allow(asm_sub_register)]

11 // compile-flags: -C no-prepopulate-passes

12

13 #![crate_type = "lib"]

14 #![feature(repr_packed)]

15

2 // no-prefer-dynamic

3

4 #![crate_type = "proc-macro"]

5 #![feature(repr128, proc_macro_hygiene, proc_macro_quote, box_patterns)]

6 #![allow(incomplete_features)]

37 let my_block = quote_spanned!( brace.span => {

38 // Should not trigger `empty_line_after_outer_attr`

39 #[crate_type = "lib"]

40 #sig #block

41 Vec::new()

19 #![allow(warnings)]

20 #![feature(rustc_attrs)]

21 #![crate_type="rlib"]

22

23 use std::arch::asm;

1 // compile-flags: -O -C no-prepopulate-passes

2

3 #![crate_type = "lib"]

4 #![feature(rustc_attrs)]

5

5

6 #![feature(no_core, lang_items, rustc_attrs, asm_sym, asm_experimental_arch)]

7 #![crate_type = "rlib"]

8 #![no_core]

9 #![allow(non_camel_case_types)]

15 #![deny(dead_code)]

16

17 #![crate_type="lib"]

18

19 pub use foo2::Bar2;

1 #![crate_type = "rlib"]

2 #![feature(generic_arg_infer)]

3

16

17 #![crate_id = "flate#0.10-pre"]

18 #![crate_type = "rlib"]

19 #![crate_type = "dylib"]

11 // compile-flags: -C no-prepopulate-passes

12

13 #![crate_type = "lib"]

14 #![feature(allocator)]

15

11 // compile-flags: -C no-prepopulate-passes

12

13 #![crate_type = "lib"]

14 #![feature(core_intrinsics)]

15

180

181 #[cargo_test]

182 fn proc_macro_crate_type() {

183 let p = project()

184 .file(

2 //

3

4 #![crate_type = "lib"]

5

6 #[repr(align(64))]

24 #![feature(rustc_attrs)]

25 #![feature(asm)]

26 #![crate_type="rlib"]

27

28

1 // compile-flags: -C no-prepopulate-passes

2

3 #![crate_type = "lib"]

4

5 #![feature(repr_simd, platform_intrinsics)]

192

193 #[cargo_test]

194 fn changing_spec_relearns_crate_types() {

195 // Changing the .json file will invalidate the cache of crate types.

196 if !is_nightly() {

15

16 #![allow(dead_code)]

17 #![crate_type="lib"]

18

19 //~ MONO_ITEM fn regular_modules::foo[0] @@ regular_modules[Internal]

17 #![crate_name = "rustc_const_eval"]

18 #![unstable(feature = "rustc_private", issue = "27812")]

19 #![crate_type = "dylib"]

20 #![crate_type = "rlib"]

48

49

50 #![crate_type = "lib"]

51 use std::future::Future;

52

16

17 #![allow(dead_code)]

18 #![crate_type="rlib"]

19

20 //~ MONO_ITEM fn core::ptr[0]::drop_in_place[0]<local_drop_glue::Struct[0]> @@ local_drop_glue[Internal] local_drop_glue-mod1[Internal]

6

7 #![feature(no_core, lang_items, rustc_attrs, repr_simd)]

8 #![crate_type = "rlib"]

9 #![no_core]

10 #![allow(asm_sub_register, non_camel_case_types)]

11 // no-prefer-dynamic

12 #![feature(proc_macro)]

13 #![crate_type = "proc-macro"]

14

15 extern crate proc_macro;

76 cx.tcx

77 .sess

78 .crate_types()

79 .iter()

80 .any(|t: &CrateType| matches!(t, CrateType::Executable | CrateType::ProcMacro))

9 // except according to those terms.

10 #![crate_name="lint_stability"]

11 #![crate_type = "lib"]

12 #![feature(staged_api)]

13 #![feature(associated_type_defaults)]

23 //! ```rust,ignore

24 //! #![crate_name = "myplugin"]

25 //! #![crate_type = "dylib"]

26 //! #![feature(plugin_registrar)]

27 //!

23 //! ```no_run

24 //! #![crate_name = "myplugin"]

25 //! #![crate_type = "dylib"]

26 //! #![feature(plugin_registrar)]

27 //! #![feature(rustc_private)]

16

17 #![allow(dead_code)]

18 #![crate_type="lib"]

19

20 mod inline {

3 // only-riscv64

4 // only-linux

5 #![crate_type = "lib"]

6

7 // CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 zeroext %i)

21 reason = "deprecated in favor of rustc-serialize on crates.io")]

22 #![staged_api]

23 #![crate_type = "rlib"]

24 #![crate_type = "dylib"]

19 #![allow(warnings)]

20 #![feature(rustc_attrs)]

21 #![crate_type="rlib"]

22

23 fn callee1(_x: u32, _y: i64) {}

9 // except according to those terms.

10

11 #![crate_type="lib"]

12 #![deny(warnings)]

13 #![allow(dead_code)]

25 #![feature(unboxed_closures)]

26 #![feature(link_args)]

27 #![crate_type="rlib"]

28

29

23 // of other runtime components (registered via yet another special image section).

24

25 #![crate_type="rlib"]

26 #![no_std]

27 #![allow(non_camel_case_types)]

21 #![feature(stmt_expr_attributes)]

22 #![allow(dead_code)]

23 #![crate_type = "rlib"]

24

25 // These are expected to require codegen.

11 #![crate_name = "rustc_metadata"]

12 #![unstable(feature = "rustc_private", issue = "27812")]

13 #![crate_type = "dylib"]

14 #![crate_type = "rlib"]

2

3 #![feature(rustc_private)]

4 #![crate_type = "lib"]

5

6 extern crate rustc_macros;

3 #![feature(core_intrinsics)]

4 #![allow(warnings)]

5 #![crate_type = "rlib"]

6

7 use std::intrinsics;

2 //

3 // compile-flags: -O

4 #![crate_type = "lib"]

5

6 use std::sync::atomic::{AtomicI32, Ordering::*};

11 // compile-flags: -C no-prepopulate-passes

12

13 #![crate_type = "lib"]

14

15 // CHECK: @VAR1 = constant <{ [4 x i8] }> <{ [4 x i8] c"\01\00\00\00" }>, section ".test_one"

1 // compile-flags: -C opt-level=3

2

3 #![crate_type = "lib"]

4

5 // #71602 reported a simple array comparison just generating a loop.

8

9 #![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_sym, asm_experimental_arch)]

10 #![crate_type = "rlib"]

11 #![no_core]

12 #![allow(asm_sub_register, non_camel_case_types)]

1 // compile-flags: -Cpanic=abort

2 #![feature(core_intrinsics)]

3 #![crate_type = "lib"]

4

5 // EMIT_MIR lower_intrinsics.wrapping.LowerIntrinsics.diff

17 #![crate_name = "syntax"]

18 #![unstable(feature = "rustc_private", issue = "27812")]

19 #![crate_type = "dylib"]

20 #![crate_type = "rlib"]

19 #![crate_name = "rustc_data_structures"]

20 #![unstable(feature = "rustc_private", issue = "27812")]

21 #![crate_type = "dylib"]

22 #![crate_type = "rlib"]

1 // edition:2018

2 #![crate_type = "lib"]

3 #![feature(type_ascription)]

4 use std::future::Future;

13 #![feature(allocator, core_intrinsics, libc)]

14 #![allocator]

15 #![crate_type = "rlib"]

16 #![no_std]

17

2 // no-prefer-dynamic

3

4 #![crate_type = "proc-macro"]

5

6 extern crate proc_macro;

1 // compile-flags: -C no-prepopulate-passes

2

3 #![crate_type = "lib"]

4

5 // CHECK-LABEL: @zero_sized_elem

3 // ignore-debug: the debug assertions get in the way

4

5 #![crate_type = "lib"]

6 #![feature(portable_simd)]

7

11 // force-host

12

13 #![crate_type="dylib"]

14 #![feature(plugin_registrar, rustc_private)]

15 #![feature(slice_patterns)]

9 // except according to those terms.

10 #![crate_name="inherited_stability"]

11 #![crate_type = "lib"]

12 #![unstable(feature = "test_feature")]

13 #![feature(staged_api)]

14 // See repr-transparent.rs

15

16 #![crate_type="lib"]

17 #![feature(repr_transparent)]

18

2

3 #![forbid(bad_style, exceeding_bitshifts, mutable_transmutes, no_mangle_const_items,

4 unknown_crate_types, warnings)]

5 #![deny(deprecated, drop_with_repr_extern, improper_ctypes, non_shorthand_field_patterns,

6 overflowing_literals, plugin_as_library, private_no_mangle_fns, private_no_mangle_statics,

179 // compile-flags: -C opt-level=2

180

181 #![crate_type = "lib"]

182

183 #![feature(no_core, lang_items)]

184 #![crate_type = "lib"]

185 #![no_core]

186

20 #![feature(linkage)]

21 #![feature(thread_local)]

22 #![crate_type="rlib"]

23

24

11 #![cfg_attr(stage0, feature(custom_attribute))]

12 #![crate_name = "alloc_system"]

13 #![crate_type = "rlib"]

14 #![staged_api]

15 #![no_std]

7

8 #![feature(rustc_attrs)]

9 #![crate_type="rlib"]

10

11 #![rustc_expected_cgu_reuse(module="independent_cgus_dont_affect_each_other-foo",

1 // ensures that public symbols are not removed completely

2 #![crate_type = "lib"]

3 // we can compile to a variety of platforms, because we don't need

4 // cross-compiled standard libraries.

1 #![forbid(bad_style, exceeding_bitshifts, mutable_transmutes, no_mangle_const_items,

2 unknown_crate_types, warnings)]

3 #![deny(deprecated, drop_with_repr_extern, improper_ctypes, missing_docs,

4 non_shorthand_field_patterns, overflowing_literals, plugin_as_library,

11 // compile-flags: -C no-prepopulate-passes

12

13 #![crate_type = "lib"]

14

15 #[no_mangle]

18 // compile-flags: -C no-prepopulate-passes

19

20 #![crate_type = "lib"]

21 #![feature(abi_x86_interrupt)]

22

9 // except according to those terms.

10

11 #![crate_type="rlib"]

12

13 pub trait Foo {

23 #![allow(warnings)]

24 #![feature(rustc_attrs)]

25 #![crate_type="rlib"]

26

27 // Change simple index ---------------------------------------------------------

28 #![feature(staged_api)]

29 #![staged_api]

30 #![crate_type = "rlib"]

31 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",

32 html_favicon_url = "http://www.rust-lang.org/favicon.ico",

51

52 #![feature(global_asm)]

53 #![crate_type = "lib"]

54 #[no_std]

55

15

16 #![allow(dead_code)]

17 #![crate_type="lib"]

18

19 //~ TRANS_ITEM fn regular_modules::foo[0] @@ regular_modules[WeakODR]

11 // no-prefer-dynamic

12

13 #![crate_type = "proc-macro"]

14 #![feature(proc_macro)]

15

13 #![recursion_limit = "20"]

14 #![type_length_limit = "20000000"]

15 #![crate_type = "rlib"]

16

17 #[derive(Clone)]

10 // lossy string reparse hack (https://github.com/rust-lang/rust/issues/43081).

11

12 #![crate_type = "proc-macro"]

13 #![feature(proc_macro_span)]

14

7 // normalize-stderr-test "shift left by `(64|32)_usize`, which" -> "shift left by `%BITS%`, which"

8

9 #![crate_type="lib"]

10 #![warn(arithmetic_overflow, const_err)]

11

14

15 #![crate_id = "collections#0.10-pre"]

16 #![crate_type = "rlib"]

17 #![crate_type = "dylib"]

14 // compile-flags:-Zprint-mono-items=lazy -Zincremental=tmp/partitioning-tests/statics

15

16 #![crate_type="rlib"]

17

18 //~ MONO_ITEM static statics::FOO[0] @@ statics[Internal]

13 #![deny(dead_code)]

14

15 #![crate_type="lib"]

16

17

11 // no-prefer-dynamic

12

13 #![crate_type = "proc-macro"]

14 #![feature(proc_macro, proc_macro_non_items)]

15

14

15 #![feature(rustc_attrs)]

16 #![crate_type = "rlib"]

17

18 #![rustc_partition_codegened(module="issue_49595-tests", cfg="cfail2")]

16

17 #![allow(dead_code)]

18 #![crate_type="lib"]

19

20 // aux-build:cgu_extern_drop_glue.rs

12 // compile-flags:-Zprint-trans-items=eager

13

14 #![crate_type="lib"]

15 #![deny(dead_code)]

16

11 // compile-flags: -C no-prepopulate-passes

12

13 #![crate_type = "lib"]

14 #![feature(rustc_attrs)]

15

1 #![crate_type = "lib"]

2 #![warn(clippy::return_self_not_must_use)]

3

11 //[MSAN-2-LTO] compile-flags: -Zsanitizer=memory -Zsanitizer-memory-track-origins -C lto=fat

12

13 #![crate_type="lib"]

14

15 // MSAN-0-NOT: @__msan_track_origins

19 #![feature(rustc_attrs)]

20 #![feature(unboxed_closures)]

21 #![crate_type = "rlib"]

22

23 // Change function name --------------------------------------------------------

19 reason = "deprecated in favor of rustc-serialize on crates.io",

20 issue = "27812")]

21 #![crate_type = "rlib"]

22 #![crate_type = "dylib"]

9 // except according to those terms.

10

11 #![crate_type="rlib"]

12 #![no_core]

13

4

5 const PRINT_ARG_NAME: &str = "print";

6 const CRATE_TYPE_ARG_NAME: &str = "crate-type";

7

8 pub fn cli() -> App {

38 )

39 .arg(multi_opt(

40 CRATE_TYPE_ARG_NAME,

41 "CRATE-TYPE",

42 "Comma separated list of types of crates for the compiler to emit (unstable)",

85 return Ok(());

86 }

87 let crate_types = values(args, CRATE_TYPE_ARG_NAME);

88 compile_opts.target_rustc_crate_types = if crate_types.is_empty() {

91 config

92 .cli_unstable()

93 .fail_if_stable_opt(CRATE_TYPE_ARG_NAME, 10083)?;

94 Some(crate_types)

72 [lib]

73 name = "foo"

74 crate_type = ["dylib", "rlib"]

75 "#)

76 .file("foo/src/lib.rs", "");

9 // except according to those terms.

10

11 #![crate_type = "rlib"]

12 // no-prefer-dynamic

13

9 // except according to those terms.

10

11 #![crate_type = "lib"]

12

13 static private: isize = 0;

11 #![crate_name = "rustc_borrowck"]

12 #![unstable(feature = "rustc_private", issue = "27812")]

13 #![crate_type = "dylib"]

14 #![crate_type = "rlib"]

14 #![feature(libc)]

15

16 #![crate_type="lib"]

17

18 extern crate libc;