use rustc_data_structures::sync::Lrc;
use rustc_errors::{ColorConfig, ErrorReported};
use rustc_hir as hir;
-use rustc_hir::intravisit;
use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_hir::intravisit;
use rustc_hir::{HirId, CRATE_HIR_ID};
use rustc_interface::interface;
use rustc_middle::hir::map::Map;
use rustc_span::edition::Edition;
use rustc_span::source_map::SourceMap;
use rustc_span::symbol::sym;
+use rustc_span::Symbol;
use rustc_span::{BytePos, FileName, Pos, Span, DUMMY_SP};
use rustc_target::spec::TargetTriple;
use tempfile::Builder as TempFileBuilder;
let res = interface::run_compiler(config, |compiler| {
compiler.enter(|queries| {
- let _lower_to_hir = queries.lower_to_hir()?;
let mut global_ctxt = queries.global_ctxt()?.take();
let collector = global_ctxt.enter(|tcx| {
opts.display_warnings |= options.display_warnings;
let enable_per_target_ignores = options.enable_per_target_ignores;
let mut collector = Collector::new(
- tcx.crate_name(LOCAL_CRATE).to_string(),
+ tcx.crate_name(LOCAL_CRATE),
options,
false,
opts,
fn run_test(
test: &str,
- cratename: &str,
+ crate_name: &str,
line: usize,
options: Options,
should_panic: bool,
report_unused_externs: impl Fn(UnusedExterns),
) -> Result<(), TestFailure> {
let (test, line_offset, supports_color) =
- make_test(test, Some(cratename), as_test_harness, opts, edition, Some(test_id));
+ make_test(test, Some(crate_name), as_test_harness, opts, edition, Some(test_id));
let output_file = outdir.path().join("rust_out");
/// lines before the test code begins as well as if the output stream supports colors or not.
crate fn make_test(
s: &str,
- cratename: Option<&str>,
+ crate_name: Option<&str>,
dont_insert_main: bool,
opts: &TestOptions,
edition: Edition,
let sess = ParseSess::with_span_handler(handler, sm);
let mut found_main = false;
- let mut found_extern_crate = cratename.is_none();
+ let mut found_extern_crate = crate_name.is_none();
let mut found_macro = false;
let mut parser = match maybe_new_parser_from_source_str(&sess, filename, source) {
if !found_extern_crate {
if let ast::ItemKind::ExternCrate(original) = item.kind {
- // This code will never be reached if `cratename` is none because
+ // This code will never be reached if `crate_name` is none because
// `found_extern_crate` is initialized to `true` if it is none.
- let cratename = cratename.unwrap();
+ let crate_name = crate_name.unwrap();
match original {
- Some(name) => found_extern_crate = name.as_str() == cratename,
- None => found_extern_crate = item.ident.as_str() == cratename,
+ Some(name) => found_extern_crate = name.as_str() == crate_name,
+ None => found_extern_crate = item.ident.as_str() == crate_name,
}
}
}
// Don't inject `extern crate std` because it's already injected by the
// compiler.
- if !already_has_extern_crate && !opts.no_crate_inject && cratename != Some("std") {
- if let Some(cratename) = cratename {
+ if !already_has_extern_crate && !opts.no_crate_inject && crate_name != Some("std") {
+ if let Some(crate_name) = crate_name {
// Don't inject `extern crate` if the crate is never used.
// NOTE: this is terribly inaccurate because it doesn't actually
// parse the source, but only has false positives, not false
// negatives.
- if s.contains(cratename) {
- prog.push_str(&format!("extern crate r#{};\n", cratename));
+ if s.contains(crate_name) {
+ prog.push_str(&format!("extern crate r#{};\n", crate_name));
line_offset += 1;
}
}
options: Options,
use_headers: bool,
enable_per_target_ignores: bool,
- cratename: String,
+ crate_name: Symbol,
opts: TestOptions,
position: Span,
source_map: Option<Lrc<SourceMap>>,
impl Collector {
crate fn new(
- cratename: String,
+ crate_name: Symbol,
options: Options,
use_headers: bool,
opts: TestOptions,
options,
use_headers,
enable_per_target_ignores,
- cratename,
+ crate_name,
opts,
position: DUMMY_SP,
source_map,
fn add_test(&mut self, test: String, config: LangString, line: usize) {
let filename = self.get_filename();
let name = self.generate_name(line, &filename);
- let cratename = self.cratename.to_string();
+ let crate_name = self.crate_name.to_string();
let opts = self.opts.clone();
let edition = config.edition.unwrap_or(self.options.edition);
let options = self.options.clone();
// compiler failures are test failures
should_panic: testing::ShouldPanic::No,
allow_fail: config.allow_fail,
- #[cfg(not(bootstrap))]
compile_fail: config.compile_fail,
- #[cfg(not(bootstrap))]
no_run,
test_type: testing::TestType::DocTest,
},
};
let res = run_test(
&test,
- &cratename,
+ &crate_name,
line,
options,
config.should_panic,