10

11 #![crate_name = "foo"]

12

97 pub struct CratePreludeData {

98 pub crate_name: String,

99 pub crate_root: String,

108 CratePreludeData {

109 crate_name: self.crate_name,

110 crate_root: self.crate_root,

34 impl<'a> MacroLoader<'a> {

35 fn new(sess: &'a Session, cstore: &'a CStore, crate_name: &str) -> MacroLoader<'a> {

36 MacroLoader {

38 span_whitelist: HashSet::new(),

39 reader: CrateReader::new(sess, cstore, crate_name),

40 macros: vec![],

52 krate: &ast::Crate,

53 crate_name: &str)

54 -> Vec<ast::MacroDef>

55 {

56 let mut loader = MacroLoader::new(sess, cstore, crate_name);

57

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

19 #![crate_name = "syntax"]

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

41 expected_json,

42 expected_crate_name,

43 expected_files,

50 expected_json: &str,

51 expected_crate_name: &str,

52 expected_files: &[&str],

101 ///

102 /// - `expected_crate_name` should be something like `foo-0.0.1.crate`.

103 /// - `expected_files` should be a complete list of files in the crate

116 rdr.header().unwrap().filename().unwrap(),

117 expected_crate_name.as_bytes()

118 );

133 assert!(expected_crate_name.ends_with(".crate"));

134 let base_crate_name = Path::new(&expected_crate_name[..expected_crate_name.len() - 6]);

135 let actual_files: HashSet<PathBuf> = files.keys().cloned().collect();

10

11 #![crate_name = "alloc_jemalloc"]

12 #![crate_type = "rlib"]

55 // The name to use in `extern crate name as std;`

56 let actual_crate_name = match self.alt_std_name {

57 Some(ref s) => token::intern(&s),

66 InternedString::new("macro_use")))),

67 node: ast::ItemExternCrate(Some(actual_crate_name)),

68 vis: ast::Inherited,

58 {

59 "extern_crate_name": "b",

60 "index": 1,

103 {

104 "extern_crate_name": "c",

105 "index": 2,

186 {

187 "extern_crate_name": "a",

188 "index": 0,

10

11 #![crate_name = "rustc_platform_intrinsics"]

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

9 // except according to those terms.

10 #![crate_name="lint_stability"]

11 #![crate_type = "lib"]

10

11 #![crate_name = "alloc_system"]

12 #![crate_type = "rlib"]

110 {

111 write!(fmt, "{}", target.crate_name())?;

112 }

110 format!("rust_metadata_{}_{}",

111 tcx.original_crate_name(LOCAL_CRATE),

112 tcx.crate_disambiguator(LOCAL_CRATE).to_fingerprint().to_hex())

63

64 pub fn git_encode(&self, crate_name: &str) -> git::Dependency {

65 let Dependency { id: _, version_id: _, crate_id: _, ref req,

68 git::Dependency {

69 name: crate_name.to_string(),

70 req: req.to_string(),

78

79 pub fn encodable(self, crate_name: &str) -> EncodableDependency {

80 let Dependency { id, version_id, crate_id: _, req, optional,

84 version_id: version_id,

85 crate_id: crate_name.to_string(),

86 req: req.to_string(),

16

17 #![crate_name = "rustc_passes"]

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

4

5 #![crate_name = "test_docs"]

6 #![feature(rustdoc_internals)]

10

11 #![crate_name = "rustc_metadata"]

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

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

12 #![crate_name = "alloc_system"]

13 #![crate_type = "rlib"]

10 let patch = env!("CARGO_PKG_VERSION_PATCH").parse::<u16>().unwrap();

11 let crate_name = String::from(env!("CARGO_PKG_NAME"));

12

23 commit_date,

24 crate_name,

25 }

36 pub commit_date: Option<String>,

37 pub crate_name: String,

38 }

51 "{} {}.{}.{} ({} {})",

52 self.crate_name, self.major, self.minor, self.patch, hash_trimmed, date_trimmed,

53 )?;

54 } else {

55 write!(f, "{} {}.{}.{}", self.crate_name, self.major, self.minor, self.patch)?;

56 }

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

19 #![crate_name = "serialize"]

20 #![unstable(feature = "rustc_private",

41 "duplicate diagnostic item in crate `{}`: `{}`.",

42 tcx.crate_name(item_def_id.krate),

43 name

50 "the diagnostic item is first defined in crate `{}`.",

51 tcx.crate_name(original_def_id.krate)

52 ));

68 "rust_metadata_{}_{:08x}",

69 tcx.crate_name(LOCAL_CRATE),

70 tcx.sess.local_stable_crate_id().to_u64(),

54 pub fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str {

55 &cx.link_meta().crate_name

56 }

61 let krate = if def_id.is_local() {

62 let crate_namespace_name = token::intern(crate_root_namespace(cx));

63 Some(hir_map::PathMod(crate_namespace_name))

8 #![feature(const_trait_impl)]

9 #![crate_name = "foo"]

10

20 let args = clap_app!(

21 (crate_name!()) =>

22 (version: (crate_version!()))

52 fn run(args: ArgMatches) -> Result<()> {

53 info!("Running {} {}", crate_name!(), crate_version!());

54 File::open(args.value_of("file").unwrap())

47 item_name: token::str_to_ident(name),

48 crate_name: token::intern(&alt_std_name.unwrap_or(name.to_string())),

49 };

80 item_name: ast::Ident,

81 crate_name: ast::Name,

82 }

91 InternedString::new("macro_use")))),

92 node: ast::ItemExternCrate(Some(self.crate_name)),

93 vis: ast::Inherited,

12 #![deny(unused_attributes)]

13 #![crate_name = "unused_attr_duplicate"]

14 #![crate_name = "unused_attr_duplicate2"] //~ ERROR unused attribute

1 #![crate_name = "aCrate"]

2

23 if target.is_lib() {

24 assert!(lib_names.insert(target.crate_name()));

25 } else {

26 assert!(bin_names.insert(target.crate_name()));

27 }

15

16 #![crate_name = "a"]

17

49

50 Box::new(tcx.crate_name(LOCAL_CRATE) as Symbol)

51 }

62 use rustc_codegen_utils::link::out_filename;

63 let crate_name = ongoing_codegen.downcast::<Symbol>()

64 .expect("in join_codegen_and_link: ongoing_codegen is not a Symbol");

69 let output_name =

70 out_filename(sess, crate_type, &outputs, &*crate_name.as_str());

71 let mut out_file = ::std::fs::File::create(output_name).unwrap();

18 #[test]

19 fn make_test_crate_name_no_use() {

20 // If you give a crate name but *don't* use it within the test, it won't bother inserting

33 #[test]

34 fn make_test_crate_name() {

35 // If you give a crate name and use it within the test, it will insert an `extern crate`

1 #![crate_name = "myrmecophagous"]

2 #![feature(doc_cfg, associated_type_defaults)]

10

11 #![crate_name="lint_output_format"]

12 #![crate_type = "lib"]

12

13 #![crate_name = "syntax_ext"]

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

16

17 #![crate_name = "serialize"]

18 #![unstable(feature = "rustc_private",

23 //! ```rust,ignore

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

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

52

53 #![crate_name = "rustc_plugin"]

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

1 #![crate_name = "globuliferous"]

2 #![feature(doc_cfg)]

22 /// The name the parent uses to refer to this dependency.

23 pub extern_crate_name: InternedString,

24 /// If `Some`, the name of the dependency if renamed in toml.

25 /// It's particularly interesting to artifact dependencies which rely on it

26 /// for naming their environment variables. Note that the `extern_crate_name`

27 /// cannot be used for this as it also may be the build target itself,

60 index: usize,

61 extern_crate_name: InternedString,

62 // This is only set on nightly since it is unstable.

99 index: indices[&unit_dep.unit],

100 extern_crate_name: unit_dep.extern_crate_name,

101 public,

9 // except according to those terms.

10 #![crate_name="inherited_stability"]

11 #![crate_type = "lib"]

16

17 #![crate_name = "syntax"]

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

11 // @has foo/index.html

12 #![crate_name = "foo"]

13

10

11 #![crate_name="foo"]

12

10

11 #![crate_name="a#0.1"]

12 #![crate_type = "lib"]

22

23 #![crate_name = "rustc_unicode"]

24 #![unstable(feature = "unicode", issue = "27783")]

10

11 #![crate_name = "rustc_borrowck"]

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

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

19 #![crate_name = "rustc_trans"]

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

1 #![crate_name = "foo"]

2 #![feature(doc_cfg)]

23 //! ```rust,ignore

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

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

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

26 #![crate_name = "rustc_back"]

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

12 let repo_url = format!("https://github.com/{}", repo_name);

13 let crate_name = repo_name

14 .split('/')

18 let mut repo_dir = tempfile::tempdir().expect("couldn't create temp dir").into_path();

19 repo_dir.push(crate_name);

20

14

15 #![crate_name = "bar"]

16

18

19 #![crate_name = "b"]

20

10

11 #![crate_name="crateresolve5#0.2"]

12

23 //! ```no_run

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

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

48 let namespace_name = match def_key.disambiguated_data.data {

49 DefPathData::CrateRoot => cx.tcx.crate_name(def_id.krate).as_str(),

50 data => data.as_interned_str().as_str()

37 let name = match def_key.disambiguated_data.data {

38 DefPathData::CrateRoot => ccx.tcx().crate_name(def_id.krate),

39 data => data.as_interned_str()

66 let namespace_name = match def_key.disambiguated_data.data {

67 DefPathData::CrateRoot => ccx.tcx().crate_name(def_id.krate),

68 data => data.as_interned_str()

10

11 #![crate_name="anonexternmod"]

12 #![feature(libc)]

17

18 #![crate_name = "uta"]

19

16

17 #![crate_name = "rustc_const_eval"]

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

10

11 #![crate_name="foreign_lib"]

12

10

11 #![crate_name="static_methods_crate"]

12 #![crate_type = "lib"]

18

19 #![crate_name = "rustc_data_structures"]

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

10

11 #![crate_name="numeric"]

12 #![crate_type = "lib"]

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

6 #![crate_name="some_macros"]

7

1 #![crate_name="lint_stability"]

2 #![crate_type = "lib"]

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

25 #![crate_name = "rustc_unicode"]

26 #![unstable(feature = "unicode", issue = "27783")]

22

23 #![crate_name="mathx"]

24 #![crate_type="dylib"]

7

8 #![crate_name = "gfx_traits"]

9 #![crate_type = "rlib"]

10

11 #![crate_name="crateresolve5#0.1"]

12

10

11 #![crate_name="externcallback"]

12 #![crate_type = "lib"]

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

25 #![crate_name = "unicode"]

26 #![unstable(feature = "unicode")]

23 let name = &compilation

24 .root_crate_names

25 .get(0)

3 // FIXME(eddyb) shorten the name so windows doesn't choke on it.

4 #![crate_name = "trait_test"]

5

16

17 #![crate_name = "rustc_mir"]

18 #![crate_type = "rlib"]

10

11 #![crate_name="issue_2526"]

12 #![crate_type = "lib"]

10

11 #![crate_name="cci_iter_lib"]

12

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

13 #![crate_name = "rustc_borrowck"]

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

10

11 #![crate_name="req"]

12 #![crate_type = "lib"]

12 // aux-build:crateresolve4a-2.rs

13 #![crate_name="crateresolve4b#0.2"]

14 #![crate_type = "lib"]

12 // aux-build:crateresolve4a-2.rs

13 #![crate_name="crateresolve4b#0.1"]

14 #![crate_type = "lib"]

48 //! `crypto::shorthash`

49 #![crate_name = "sodiumoxide"]

50 #![crate_type = "lib"]

1 #![feature(generic_associated_types)]

2 #![crate_name = "foo"]

3

1 #![crate_name = "foo"]

2 #![feature(rustdoc_internals)]

64 use std::io::Write;

65 let crate_name = codegen_results.crate_info.local_crate_name;

66 for &crate_type in sess.opts.crate_types.iter() {

69 }

70 let output_name = out_filename(sess, crate_type, &outputs, &*crate_name.as_str());

71 let mut out_file = ::std::fs::File::create(output_name).unwrap();

16

17 #![crate_name = "rustc_trans"]

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

13 pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {

14 let local_name = cx.tcx.crate_name(LOCAL_CRATE);

15 let mut packages = metadata.packages.clone();

6 #![feature(decl_macro, no_core, rustc_attrs)]

7 #![crate_name = "krate"]

8 #![no_core]

2 // aux-build: extern_crate.rs

3 #![crate_name = "foo"]

4

1 #![crate_name = "foo"]

2 #![feature(intra_doc_pointers)]

10

11 #![crate_name="issue_3979_traits"]

12

10

11 #![crate_name="a"]

12 #![crate_type = "lib"]

43 if display {

44 println!("[{:<30}: {}] start", tcx.crate_name(LOCAL_CRATE), name);

45 let before = std::time::Instant::now();

47 let after = std::time::Instant::now();

48 println!("[{:<30}: {}] end time: {:?}", tcx.crate_name(LOCAL_CRATE), name, after - before);

49 res

9 // except according to those terms.

10 #![crate_name="macros"]

11

13

14 #![crate_name="host"]

15

10

11 #![crate_name = "rustdoc_test"]

12

17

18 #![crate_name = "utb"]

19

10

11 #![crate_name="cci_no_inline_lib"]

12

3

4 #![crate_name = "dependent"]

5 // edition:2021

1 // test for `doc(hidden)` with impl parameters in the same crate.

2 #![crate_name = "foo"]

3

45

46 pub(crate) fn get_file_name(crate_name: &str, crate_type: &str) -> String {

47 let file_name = Command::new("rustc")

50 "--crate-name",

51 crate_name,

52 "--crate-type",

62 assert!(!file_name.contains('\n'));

63 assert!(file_name.contains(crate_name));

64 file_name

22

23 #![crate_name = "lua"]

24 #![crate_type = "lib"]

4 #![feature(macro_test)]

5 #![crate_name = "foo"]

6

11 #![feature(optin_builtin_traits)]

12 #![crate_name = "foo"]

13

15

16 #![crate_name = "a"]

17 #![feature(core)]

23

24 #![crate_name = "rustc_back"]

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

1 #![crate_name="system"]

2 #![crate_type="lib"]

1 //! A crate for parsing Markdown in Rust

2 #![crate_name = "markdown"]

3 #![deny(missing_docs)]

16

17 #![crate_name = "rustc_const_math"]

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

10

11 #![crate_name="socketlib"]

12 #![crate_type = "lib"]

1 #![crate_name = "foo"]

2 #![feature(generic_associated_types)]

1 #![crate_name = "oud"]

2 #![feature(doc_auto_cfg, doc_cfg, doc_cfg_hide)]

10

11 #![crate_name="foreign_lib"]

12 #![feature(libc)]