nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-14 21:16:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #48849 - Manishearth:rollup, r=Manishearth

Browse Source 
Rollup of 7 pull requests

- Successful merges: #48292, #48682, #48699, #48738, #48752, #48789, #48808
- Failed merges:
This commit is contained in:
bors 2018-03-08 22:08:21 +00:00
commit 604d4ce757
46 changed files with 1451 additions and 1008 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/libcore/num/mod.rs
View File

@ -3900,6 +3900,13 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
/// This error is used as the error type for the `from_str_radix()` functions
/// on the primitive integer types, such as [`i8::from_str_radix`].
///
/// # Potential causes
///
/// Among other causes, `ParseIntError` can be thrown because of leading or trailing whitespace
/// in the string e.g. when it is obtained from the standard input.
/// Using the [`str.trim()`] method ensures that no whitespace remains before parsing.
///
/// [`str.trim()`]: ../../std/primitive.str.html#method.trim
/// [`i8::from_str_radix`]: ../../std/primitive.i8.html#method.from_str_radix
#[derive(Debug, Clone, PartialEq, Eq)]
#[stable(feature = "rust1", since = "1.0.0")]

8
src/librustc/hir/check_attr.rs
View File

@ -47,7 +47,13 @@ struct CheckAttrVisitor<'a, 'tcx: 'a> {
impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> {
/// Check any attribute.
fn check_attributes(&self, item: &hir::Item, target: Target) {
self.tcx.trans_fn_attrs(self.tcx.hir.local_def_id(item.id));
if target == Target::Fn {
self.tcx.trans_fn_attrs(self.tcx.hir.local_def_id(item.id));
} else if let Some(a) = item.attrs.iter().find(|a| a.check_name("target_feature")) {
self.tcx.sess.struct_span_err(a.span, "attribute should be applied to a function")
.span_label(item.span, "not a function")
.emit();
}
for attr in &item.attrs {
if let Some(name) = attr.name() {

19
src/librustc/infer/error_reporting/mod.rs
View File

@ -138,9 +138,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
self.explain_span(scope_decorated_tag, span)
}
ty::ReEarlyBound(_) | ty::ReFree(_) => self.msg_span_from_free_region(region),
ty::ReStatic => ("the static lifetime".to_owned(), None),
ty::ReEarlyBound(_) | ty::ReFree(_) | ty::ReStatic => {
self.msg_span_from_free_region(region)
}
ty::ReEmpty => ("the empty lifetime".to_owned(), None),
@ -175,6 +175,19 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
}
fn msg_span_from_free_region(self, region: ty::Region<'tcx>) -> (String, Option<Span>) {
match *region {
ty::ReEarlyBound(_) | ty::ReFree(_) => {
self.msg_span_from_early_bound_and_free_regions(region)
},
ty::ReStatic => ("the static lifetime".to_owned(), None),
_ => bug!(),
}
}
fn msg_span_from_early_bound_and_free_regions(
self,
region: ty::Region<'tcx>,
) -> (String, Option<Span>) {
let scope = region.free_region_binding_scope(self);
let node = self.hir.as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID);
let unknown;

1042
src/librustc/session/config.rs
View File

File diff suppressed because it is too large Load Diff

636
src/librustc/session/mod.rs
View File

@ -20,7 +20,7 @@ use lint::builtin::BuiltinLintDiagnostics;
use middle::allocator::AllocatorKind;
use middle::dependency_format;
use session::search_paths::PathKind;
use session::config::{DebugInfoLevel, OutputType, Epoch};
use session::config::{DebugInfoLevel, Epoch, OutputType};
use ty::tls;
use util::nodemap::{FxHashMap, FxHashSet};
use util::common::{duration_to_secs_str, ErrorReported};
@ -37,7 +37,7 @@ use syntax::parse;
use syntax::parse::ParseSess;
use syntax::{ast, codemap};
use syntax::feature_gate::AttributeType;
use syntax_pos::{Span, MultiSpan};
use syntax_pos::{MultiSpan, Span};
use rustc_back::{LinkerFlavor, PanicStrategy};
use rustc_back::target::Target;
@ -87,7 +87,7 @@ pub struct Session {
pub plugin_attributes: RefCell<Vec<(String, AttributeType)>>,
pub crate_types: RefCell<Vec<config::CrateType>>,
pub dependency_formats: RefCell<dependency_format::Dependencies>,
/// The crate_disambiguator is constructed out of all the `-C metadata`
/// The crate_disambiguator is constructed out of all the `-C metadata`
/// arguments passed to the compiler. Its value together with the crate-name
/// forms a unique global identifier for the crate. It is used to allow
/// multiple crates with the same name to coexist. See the
@ -141,7 +141,6 @@ pub struct Session {
out_of_fuel: Cell<bool>,
// The next two are public because the driver needs to read them.
/// If -zprint-fuel=crate, Some(crate).
pub print_fuel_crate: Option<String>,
/// Always set to zero and incremented so that we can print fuel expended by a crate.
@ -175,7 +174,7 @@ enum DiagnosticBuilderMethod {
Note,
SpanNote,
SpanSuggestion(String), // suggestion
// add more variants as needed to support one-time diagnostics
// add more variants as needed to support one-time diagnostics
}
/// Diagnostic message ID—used by `Session.one_time_diagnostics` to avoid
@ -184,7 +183,7 @@ enum DiagnosticBuilderMethod {
pub enum DiagnosticMessageId {
ErrorId(u16), // EXXXX error code as integer
LintId(lint::LintId),
StabilityId(u32) // issue number
StabilityId(u32), // issue number
}
impl From<&'static lint::Lint> for DiagnosticMessageId {
@ -201,33 +200,37 @@ impl Session {
}
}
pub fn struct_span_warn<'a, S: Into<MultiSpan>>(&'a self,
sp: S,
msg: &str)
-> DiagnosticBuilder<'a> {
pub fn struct_span_warn<'a, S: Into<MultiSpan>>(
&'a self,
sp: S,
msg: &str,
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_span_warn(sp, msg)
}
pub fn struct_span_warn_with_code<'a, S: Into<MultiSpan>>(&'a self,
sp: S,
msg: &str,
code: DiagnosticId)
-> DiagnosticBuilder<'a> {
pub fn struct_span_warn_with_code<'a, S: Into<MultiSpan>>(
&'a self,
sp: S,
msg: &str,
code: DiagnosticId,
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_span_warn_with_code(sp, msg, code)
}
pub fn struct_warn<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
pub fn struct_warn<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_warn(msg)
}
pub fn struct_span_err<'a, S: Into<MultiSpan>>(&'a self,
sp: S,
msg: &str)
-> DiagnosticBuilder<'a> {
pub fn struct_span_err<'a, S: Into<MultiSpan>>(
&'a self,
sp: S,
msg: &str,
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_span_err(sp, msg)
}
pub fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(&'a self,
sp: S,
msg: &str,
code: DiagnosticId)
-> DiagnosticBuilder<'a> {
pub fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(
&'a self,
sp: S,
msg: &str,
code: DiagnosticId,
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_span_err_with_code(sp, msg, code)
}
// FIXME: This method should be removed (every error should have an associated error code).
@ -241,20 +244,22 @@ impl Session {
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_err_with_code(msg, code)
}
pub fn struct_span_fatal<'a, S: Into<MultiSpan>>(&'a self,
sp: S,
msg: &str)
-> DiagnosticBuilder<'a> {
pub fn struct_span_fatal<'a, S: Into<MultiSpan>>(
&'a self,
sp: S,
msg: &str,
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_span_fatal(sp, msg)
}
pub fn struct_span_fatal_with_code<'a, S: Into<MultiSpan>>(&'a self,
sp: S,
msg: &str,
code: DiagnosticId)
-> DiagnosticBuilder<'a> {
pub fn struct_span_fatal_with_code<'a, S: Into<MultiSpan>>(
&'a self,
sp: S,
msg: &str,
code: DiagnosticId,
) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_span_fatal_with_code(sp, msg, code)
}
pub fn struct_fatal<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
pub fn struct_fatal<'a>(&'a self, msg: &str) -> DiagnosticBuilder<'a> {
self.diagnostic().struct_fatal(msg)
}
@ -267,7 +272,9 @@ impl Session {
msg: &str,
code: DiagnosticId,
) -> ! {
self.diagnostic().span_fatal_with_code(sp, msg, code).raise()
self.diagnostic()
.span_fatal_with_code(sp, msg, code)
.raise()
}
pub fn fatal(&self, msg: &str) -> ! {
self.diagnostic().fatal(msg).raise()
@ -301,7 +308,8 @@ impl Session {
compile_result_from_err_count(self.err_count())
}
pub fn track_errors<F, T>(&self, f: F) -> Result<T, ErrorReported>
where F: FnOnce() -> T
where
F: FnOnce() -> T,
{
let old_count = self.err_count();
let result = f();
@ -344,24 +352,31 @@ impl Session {
self.diagnostic().unimpl(msg)
}
pub fn buffer_lint<S: Into<MultiSpan>>(&self,
lint: &'static lint::Lint,
id: ast::NodeId,
sp: S,
msg: &str) {
pub fn buffer_lint<S: Into<MultiSpan>>(
&self,
lint: &'static lint::Lint,
id: ast::NodeId,
sp: S,
msg: &str,
) {
match *self.buffered_lints.borrow_mut() {
Some(ref mut buffer) => buffer.add_lint(lint, id, sp.into(),
msg, BuiltinLintDiagnostics::Normal),
Some(ref mut buffer) => {
buffer.add_lint(lint, id, sp.into(), msg, BuiltinLintDiagnostics::Normal)
}
None => bug!("can't buffer lints after HIR lowering"),
}
}
pub fn buffer_lint_with_diagnostic<S: Into<MultiSpan>>(&self,
lint: &'static lint::Lint, id: ast::NodeId, sp: S,
msg: &str, diagnostic: BuiltinLintDiagnostics) {
pub fn buffer_lint_with_diagnostic<S: Into<MultiSpan>>(
&self,
lint: &'static lint::Lint,
id: ast::NodeId,
sp: S,
msg: &str,
diagnostic: BuiltinLintDiagnostics,
) {
match *self.buffered_lints.borrow_mut() {
Some(ref mut buffer) => buffer.add_lint(lint, id, sp.into(),
msg, diagnostic),
Some(ref mut buffer) => buffer.add_lint(lint, id, sp.into(), msg, diagnostic),
None => bug!("can't buffer lints after HIR lowering"),
}
}
@ -373,7 +388,7 @@ impl Session {
Some(next) => {
self.next_node_id.set(ast::NodeId::new(next));
}
None => bug!("Input too large, ran out of node ids!")
None => bug!("Input too large, ran out of node ids!"),
}
id
@ -387,24 +402,27 @@ impl Session {
/// Analogous to calling methods on the given `DiagnosticBuilder`, but
/// deduplicates on lint ID, span (if any), and message for this `Session`
fn diag_once<'a, 'b>(&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
method: DiagnosticBuilderMethod,
msg_id: DiagnosticMessageId,
message: &str,
span_maybe: Option<Span>) {
fn diag_once<'a, 'b>(
&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
method: DiagnosticBuilderMethod,
msg_id: DiagnosticMessageId,
message: &str,
span_maybe: Option<Span>,
) {
let id_span_message = (msg_id, span_maybe, message.to_owned());
let fresh = self.one_time_diagnostics.borrow_mut().insert(id_span_message);
let fresh = self.one_time_diagnostics
.borrow_mut()
.insert(id_span_message);
if fresh {
match method {
DiagnosticBuilderMethod::Note => {
diag_builder.note(message);
},
}
DiagnosticBuilderMethod::SpanNote => {
let span = span_maybe.expect("span_note needs a span");
diag_builder.span_note(span, message);
},
}
DiagnosticBuilderMethod::SpanSuggestion(suggestion) => {
let span = span_maybe.expect("span_suggestion needs a span");
diag_builder.span_suggestion(span, message, suggestion);
@ -413,37 +431,66 @@ impl Session {
}
}
pub fn diag_span_note_once<'a, 'b>(&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
msg_id: DiagnosticMessageId, span: Span, message: &str) {
self.diag_once(diag_builder, DiagnosticBuilderMethod::SpanNote,
msg_id, message, Some(span));
pub fn diag_span_note_once<'a, 'b>(
&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
msg_id: DiagnosticMessageId,
span: Span,
message: &str,
) {
self.diag_once(
diag_builder,
DiagnosticBuilderMethod::SpanNote,
msg_id,
message,
Some(span),
);
}
pub fn diag_note_once<'a, 'b>(&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
msg_id: DiagnosticMessageId, message: &str) {
self.diag_once(diag_builder, DiagnosticBuilderMethod::Note, msg_id, message, None);
pub fn diag_note_once<'a, 'b>(
&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
msg_id: DiagnosticMessageId,
message: &str,
) {
self.diag_once(
diag_builder,
DiagnosticBuilderMethod::Note,
msg_id,
message,
None,
);
}
pub fn diag_span_suggestion_once<'a, 'b>(&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
msg_id: DiagnosticMessageId,
span: Span,
message: &str,
suggestion: String) {
self.diag_once(diag_builder, DiagnosticBuilderMethod::SpanSuggestion(suggestion),
msg_id, message, Some(span));
pub fn diag_span_suggestion_once<'a, 'b>(
&'a self,
diag_builder: &'b mut DiagnosticBuilder<'a>,
msg_id: DiagnosticMessageId,
span: Span,
message: &str,
suggestion: String,
) {
self.diag_once(
diag_builder,
DiagnosticBuilderMethod::SpanSuggestion(suggestion),
msg_id,
message,
Some(span),
);
}
pub fn codemap<'a>(&'a self) -> &'a codemap::CodeMap {
self.parse_sess.codemap()
}
pub fn verbose(&self) -> bool { self.opts.debugging_opts.verbose }
pub fn time_passes(&self) -> bool { self.opts.debugging_opts.time_passes }
pub fn verbose(&self) -> bool {
self.opts.debugging_opts.verbose
}
pub fn time_passes(&self) -> bool {
self.opts.debugging_opts.time_passes
}
pub fn profile_queries(&self) -> bool {
self.opts.debugging_opts.profile_queries ||
self.opts.debugging_opts.profile_queries_and_keys
self.opts.debugging_opts.profile_queries
|| self.opts.debugging_opts.profile_queries_and_keys
}
pub fn profile_queries_and_keys(&self) -> bool {
self.opts.debugging_opts.profile_queries_and_keys
@ -454,11 +501,21 @@ impl Session {
pub fn time_llvm_passes(&self) -> bool {
self.opts.debugging_opts.time_llvm_passes
}
pub fn trans_stats(&self) -> bool { self.opts.debugging_opts.trans_stats }
pub fn meta_stats(&self) -> bool { self.opts.debugging_opts.meta_stats }
pub fn asm_comments(&self) -> bool { self.opts.debugging_opts.asm_comments }
pub fn no_verify(&self) -> bool { self.opts.debugging_opts.no_verify }
pub fn borrowck_stats(&self) -> bool { self.opts.debugging_opts.borrowck_stats }
pub fn trans_stats(&self) -> bool {
self.opts.debugging_opts.trans_stats
}
pub fn meta_stats(&self) -> bool {
self.opts.debugging_opts.meta_stats
}
pub fn asm_comments(&self) -> bool {
self.opts.debugging_opts.asm_comments
}
pub fn no_verify(&self) -> bool {
self.opts.debugging_opts.no_verify
}
pub fn borrowck_stats(&self) -> bool {
self.opts.debugging_opts.borrowck_stats
}
pub fn print_llvm_passes(&self) -> bool {
self.opts.debugging_opts.print_llvm_passes
}
@ -481,18 +538,11 @@ impl Session {
*(self.features.borrow_mut()) = Some(features);
}
/// If true, we should gather causal information during NLL
/// checking. This will eventually be the normal thing, but right
/// now it is too unoptimized.
pub fn nll_dump_cause(&self) -> bool {
self.opts.debugging_opts.nll_dump_cause
}
/// Calculates the flavor of LTO to use for this compilation.
pub fn lto(&self) -> config::Lto {
// If our target has codegen requirements ignore the command line
if self.target.target.options.requires_lto {
return config::Lto::Fat
return config::Lto::Fat;
}
// If the user specified something, return that. If they only said `-C
@ -500,9 +550,7 @@ impl Session {
// then ensure we can't use a ThinLTO.
match self.opts.cg.lto {
config::Lto::No => {}
config::Lto::Yes if self.opts.cli_forced_thinlto_off => {
return config::Lto::Fat
}
config::Lto::Yes if self.opts.cli_forced_thinlto_off => return config::Lto::Fat,
other => return other,
}
@ -515,28 +563,28 @@ impl Session {
// If processing command line options determined that we're incompatible
// with ThinLTO (e.g. `-C lto --emit llvm-ir`) then return that option.
if self.opts.cli_forced_thinlto_off {
return config::Lto::No
return config::Lto::No;
}
// If `-Z thinlto` specified process that, but note that this is mostly
// a deprecated option now that `-C lto=thin` exists.
if let Some(enabled) = self.opts.debugging_opts.thinlto {
if enabled {
return config::Lto::ThinLocal
return config::Lto::ThinLocal;
} else {
return config::Lto::No
return config::Lto::No;
}
}
// If there's only one codegen unit and LTO isn't enabled then there's
// no need for ThinLTO so just return false.
if self.codegen_units() == 1 {
return config::Lto::No
return config::Lto::No;
}
// Right now ThinLTO isn't compatible with incremental compilation.
if self.opts.incremental.is_some() {
return config::Lto::No
return config::Lto::No;
}
// Now we're in "defaults" territory. By default we enable ThinLTO for
@ -550,15 +598,23 @@ impl Session {
/// Returns the panic strategy for this compile session. If the user explicitly selected one
/// using '-C panic', use that, otherwise use the panic strategy defined by the target.
pub fn panic_strategy(&self) -> PanicStrategy {
self.opts.cg.panic.unwrap_or(self.target.target.options.panic_strategy)
self.opts
.cg
.panic
.unwrap_or(self.target.target.options.panic_strategy)
}
pub fn linker_flavor(&self) -> LinkerFlavor {
self.opts.debugging_opts.linker_flavor.unwrap_or(self.target.target.linker_flavor)
self.opts
.debugging_opts
.linker_flavor
.unwrap_or(self.target.target.linker_flavor)
}
pub fn fewer_names(&self) -> bool {
let more_names = self.opts.output_types.contains_key(&OutputType::LlvmAssembly) ||
self.opts.output_types.contains_key(&OutputType::Bitcode);
let more_names = self.opts
.output_types
.contains_key(&OutputType::LlvmAssembly)
|| self.opts.output_types.contains_key(&OutputType::Bitcode);
self.opts.debugging_opts.fewer_names || !more_names
}
@ -572,7 +628,9 @@ impl Session {
self.opts.debugging_opts.enable_nonzeroing_move_hints
}
pub fn overflow_checks(&self) -> bool {
self.opts.cg.overflow_checks
self.opts
.cg
.overflow_checks
.or(self.opts.debugging_opts.force_overflow_checks)
.unwrap_or(self.opts.debug_assertions)
}
@ -603,50 +661,59 @@ impl Session {
}
pub fn must_not_eliminate_frame_pointers(&self) -> bool {
self.opts.debuginfo != DebugInfoLevel::NoDebugInfo ||
!self.target.target.options.eliminate_frame_pointer
self.opts.debuginfo != DebugInfoLevel::NoDebugInfo
|| !self.target.target.options.eliminate_frame_pointer
}
/// Returns the symbol name for the registrar function,
/// given the crate Svh and the function DefIndex.
pub fn generate_plugin_registrar_symbol(&self,
disambiguator: CrateDisambiguator)
-> String {
format!("__rustc_plugin_registrar_{}__", disambiguator.to_fingerprint().to_hex())
pub fn generate_plugin_registrar_symbol(&self, disambiguator: CrateDisambiguator) -> String {
format!(
"__rustc_plugin_registrar_{}__",
disambiguator.to_fingerprint().to_hex()
)
}
pub fn generate_derive_registrar_symbol(&self,
disambiguator: CrateDisambiguator)
-> String {
format!("__rustc_derive_registrar_{}__", disambiguator.to_fingerprint().to_hex())
pub fn generate_derive_registrar_symbol(&self, disambiguator: CrateDisambiguator) -> String {
format!(
"__rustc_derive_registrar_{}__",
disambiguator.to_fingerprint().to_hex()
)
}
pub fn sysroot<'a>(&'a self) -> &'a Path {
match self.opts.maybe_sysroot {
Some (ref sysroot) => sysroot,
None => self.default_sysroot.as_ref()
.expect("missing sysroot and default_sysroot in Session")
Some(ref sysroot) => sysroot,
None => self.default_sysroot
.as_ref()
.expect("missing sysroot and default_sysroot in Session"),
}
}
pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch {
filesearch::FileSearch::new(self.sysroot(),
&self.opts.target_triple,
&self.opts.search_paths,
kind)
filesearch::FileSearch::new(
self.sysroot(),
&self.opts.target_triple,
&self.opts.search_paths,
kind,
)
}
pub fn host_filesearch(&self, kind: PathKind) -> filesearch::FileSearch {
filesearch::FileSearch::new(
self.sysroot(),
config::host_triple(),
&self.opts.search_paths,
kind)
kind,
)
}
pub fn set_incr_session_load_dep_graph(&self, load: bool) {
let mut incr_comp_session = self.incr_comp_session.borrow_mut();
match *incr_comp_session {
IncrCompSession::Active { ref mut load_dep_graph, .. } => {
IncrCompSession::Active {
ref mut load_dep_graph,
..
} => {
*load_dep_graph = load;
}
_ => {}
@ -661,14 +728,20 @@ impl Session {
}
}
pub fn init_incr_comp_session(&self,
session_dir: PathBuf,
lock_file: flock::Lock,
load_dep_graph: bool) {
pub fn init_incr_comp_session(
&self,
session_dir: PathBuf,
lock_file: flock::Lock,
load_dep_graph: bool,
) {
let mut incr_comp_session = self.incr_comp_session.borrow_mut();
if let IncrCompSession::NotInitialized = *incr_comp_session { } else {
bug!("Trying to initialize IncrCompSession `{:?}`", *incr_comp_session)
if let IncrCompSession::NotInitialized = *incr_comp_session {
} else {
bug!(
"Trying to initialize IncrCompSession `{:?}`",
*incr_comp_session
)
}
*incr_comp_session = IncrCompSession::Active {
@ -681,8 +754,12 @@ impl Session {
pub fn finalize_incr_comp_session(&self, new_directory_path: PathBuf) {
let mut incr_comp_session = self.incr_comp_session.borrow_mut();
if let IncrCompSession::Active { .. } = *incr_comp_session { } else {
bug!("Trying to finalize IncrCompSession `{:?}`", *incr_comp_session)
if let IncrCompSession::Active { .. } = *incr_comp_session {
} else {
bug!(
"Trying to finalize IncrCompSession `{:?}`",
*incr_comp_session
)
}
// Note: This will also drop the lock file, thus unlocking the directory
@ -695,35 +772,42 @@ impl Session {
let mut incr_comp_session = self.incr_comp_session.borrow_mut();
let session_directory = match *incr_comp_session {
IncrCompSession::Active { ref session_directory, .. } => {
session_directory.clone()
}
IncrCompSession::Active {
ref session_directory,
..
} => session_directory.clone(),
IncrCompSession::InvalidBecauseOfErrors { .. } => return,
_ => bug!("Trying to invalidate IncrCompSession `{:?}`",
*incr_comp_session),
_ => bug!(
"Trying to invalidate IncrCompSession `{:?}`",
*incr_comp_session
),
};
// Note: This will also drop the lock file, thus unlocking the directory
*incr_comp_session = IncrCompSession::InvalidBecauseOfErrors {
session_directory,
};
*incr_comp_session = IncrCompSession::InvalidBecauseOfErrors { session_directory };
}
pub fn incr_comp_session_dir(&self) -> cell::Ref<PathBuf> {
let incr_comp_session = self.incr_comp_session.borrow();
cell::Ref::map(incr_comp_session, |incr_comp_session| {
match *incr_comp_session {
IncrCompSession::NotInitialized => {
bug!("Trying to get session directory from IncrCompSession `{:?}`",
*incr_comp_session)
cell::Ref::map(
incr_comp_session,
|incr_comp_session| match *incr_comp_session {
IncrCompSession::NotInitialized => bug!(
"Trying to get session directory from IncrCompSession `{:?}`",
*incr_comp_session
),
IncrCompSession::Active {
ref session_directory,
..
}
IncrCompSession::Active { ref session_directory, .. } |
IncrCompSession::Finalized { ref session_directory } |
IncrCompSession::InvalidBecauseOfErrors { ref session_directory } => {
session_directory
| IncrCompSession::Finalized {
ref session_directory,
}
}
})
| IncrCompSession::InvalidBecauseOfErrors {
ref session_directory,
} => session_directory,
},
)
}
pub fn incr_comp_session_dir_opt(&self) -> Option<cell::Ref<PathBuf>> {
@ -735,25 +819,39 @@ impl Session {
}
pub fn print_perf_stats(&self) {
println!("Total time spent computing SVHs: {}",
duration_to_secs_str(self.perf_stats.svh_time.get()));
println!("Total time spent computing incr. comp. hashes: {}",
duration_to_secs_str(self.perf_stats.incr_comp_hashes_time.get()));
println!("Total number of incr. comp. hashes computed: {}",
self.perf_stats.incr_comp_hashes_count.get());
println!("Total number of bytes hashed for incr. comp.: {}",
self.perf_stats.incr_comp_bytes_hashed.get());
println!(
"Total time spent computing SVHs: {}",
duration_to_secs_str(self.perf_stats.svh_time.get())
);
println!(
"Total time spent computing incr. comp. hashes: {}",
duration_to_secs_str(self.perf_stats.incr_comp_hashes_time.get())
);
println!(
"Total number of incr. comp. hashes computed: {}",
self.perf_stats.incr_comp_hashes_count.get()
);
println!(
"Total number of bytes hashed for incr. comp.: {}",
self.perf_stats.incr_comp_bytes_hashed.get()
);
if self.perf_stats.incr_comp_hashes_count.get() != 0 {
println!("Average bytes hashed per incr. comp. HIR node: {}",
self.perf_stats.incr_comp_bytes_hashed.get() /
self.perf_stats.incr_comp_hashes_count.get());
println!(
"Average bytes hashed per incr. comp. HIR node: {}",
self.perf_stats.incr_comp_bytes_hashed.get()
/ self.perf_stats.incr_comp_hashes_count.get()
);
} else {
println!("Average bytes hashed per incr. comp. HIR node: N/A");
}
println!("Total time spent computing symbol hashes: {}",
duration_to_secs_str(self.perf_stats.symbol_hash_time.get()));
println!("Total time spent decoding DefPath tables: {}",
duration_to_secs_str(self.perf_stats.decode_def_path_tables_time.get()));
println!(
"Total time spent computing symbol hashes: {}",
duration_to_secs_str(self.perf_stats.symbol_hash_time.get())
);
println!(
"Total time spent decoding DefPath tables: {}",
duration_to_secs_str(self.perf_stats.decode_def_path_tables_time.get())
);
}
/// We want to know if we're allowed to do an optimization for crate foo from -z fuel=foo=n.
@ -768,15 +866,15 @@ impl Session {
println!("optimization-fuel-exhausted: {}", msg());
self.out_of_fuel.set(true);
} else if fuel > 0 {
self.optimization_fuel_limit.set(fuel-1);
self.optimization_fuel_limit.set(fuel - 1);
}
}
_ => {}
}
match self.print_fuel_crate {
Some(ref c) if c == crate_name=> {
self.print_fuel.set(self.print_fuel.get()+1);
},
Some(ref c) if c == crate_name => {
self.print_fuel.set(self.print_fuel.get() + 1);
}
_ => {}
}
ret
@ -792,10 +890,10 @@ impl Session {
/// compilation
pub fn codegen_units(&self) -> usize {
if let Some(n) = self.opts.cli_forced_codegen_units {
return n
return n;
}
if let Some(n) = self.target.target.options.default_codegen_units {
return n as usize
return n as usize;
}
// Why is 16 codegen units the default all the time?
@ -865,29 +963,34 @@ impl Session {
}
}
pub fn build_session(sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
registry: errors::registry::Registry)
-> Session {
pub fn build_session(
sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
registry: errors::registry::Registry,
) -> Session {
let file_path_mapping = sopts.file_path_mapping();
build_session_with_codemap(sopts,
local_crate_source_file,
registry,
Lrc::new(codemap::CodeMap::new(file_path_mapping)),
None)
build_session_with_codemap(
sopts,
local_crate_source_file,
registry,
Lrc::new(codemap::CodeMap::new(file_path_mapping)),
None,
)
}
pub fn build_session_with_codemap(sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
registry: errors::registry::Registry,
codemap: Lrc<codemap::CodeMap>,
emitter_dest: Option<Box<dyn Write + Send>>)
-> Session {
pub fn build_session_with_codemap(
sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
registry: errors::registry::Registry,
codemap: Lrc<codemap::CodeMap>,
emitter_dest: Option<Box<dyn Write + Send>>,
) -> Session {
// FIXME: This is not general enough to make the warning lint completely override
// normal diagnostic warnings, since the warning lint can also be denied and changed
// later via the source code.
let warnings_allow = sopts.lint_opts
let warnings_allow = sopts
.lint_opts
.iter()
.filter(|&&(ref key, _)| *key == "warnings")
.map(|&(_, ref level)| *level == lint::Allow)
@ -901,60 +1004,70 @@ pub fn build_session_with_codemap(sopts: config::Options,
let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace;
let emitter: Box<dyn Emitter> = match (sopts.error_format, emitter_dest) {
(config::ErrorOutputType::HumanReadable(color_config), None) => {
Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()),
false, sopts.debugging_opts.teach)
.ui_testing(sopts.debugging_opts.ui_testing))
}
(config::ErrorOutputType::HumanReadable(_), Some(dst)) => {
Box::new(EmitterWriter::new(dst, Some(codemap.clone()),
false, false)
.ui_testing(sopts.debugging_opts.ui_testing))
}
(config::ErrorOutputType::Json(pretty), None) => {
Box::new(JsonEmitter::stderr(Some(registry), codemap.clone(),
pretty, sopts.debugging_opts.approximate_suggestions)
.ui_testing(sopts.debugging_opts.ui_testing))
}
(config::ErrorOutputType::Json(pretty), Some(dst)) => {
Box::new(JsonEmitter::new(dst, Some(registry), codemap.clone(),
pretty, sopts.debugging_opts.approximate_suggestions)
.ui_testing(sopts.debugging_opts.ui_testing))
}
(config::ErrorOutputType::Short(color_config), None) => {
Box::new(EmitterWriter::stderr(color_config, Some(codemap.clone()), true, false))
}
(config::ErrorOutputType::Short(_), Some(dst)) => {
Box::new(EmitterWriter::new(dst, Some(codemap.clone()), true, false))
}
};
let emitter: Box<dyn Emitter> =
match (sopts.error_format, emitter_dest) {
(config::ErrorOutputType::HumanReadable(color_config), None) => Box::new(
EmitterWriter::stderr(
color_config,
Some(codemap.clone()),
false,
sopts.debugging_opts.teach,
).ui_testing(sopts.debugging_opts.ui_testing),
),
(config::ErrorOutputType::HumanReadable(_), Some(dst)) => Box::new(
EmitterWriter::new(dst, Some(codemap.clone()), false, false)
.ui_testing(sopts.debugging_opts.ui_testing),
),
(config::ErrorOutputType::Json(pretty), None) => Box::new(
JsonEmitter::stderr(
Some(registry),
codemap.clone(),
pretty,
sopts.debugging_opts.approximate_suggestions,
).ui_testing(sopts.debugging_opts.ui_testing),
),
(config::ErrorOutputType::Json(pretty), Some(dst)) => Box::new(
JsonEmitter::new(
dst,
Some(registry),
codemap.clone(),
pretty,
sopts.debugging_opts.approximate_suggestions,
).ui_testing(sopts.debugging_opts.ui_testing),
),
(config::ErrorOutputType::Short(color_config), None) => Box::new(
EmitterWriter::stderr(color_config, Some(codemap.clone()), true, false),
),
(config::ErrorOutputType::Short(_), Some(dst)) => {
Box::new(EmitterWriter::new(dst, Some(codemap.clone()), true, false))
}
};
let diagnostic_handler =
errors::Handler::with_emitter_and_flags(
emitter,
errors::HandlerFlags {
can_emit_warnings,
treat_err_as_bug,
external_macro_backtrace,
.. Default::default()
});
let diagnostic_handler = errors::Handler::with_emitter_and_flags(
emitter,
errors::HandlerFlags {
can_emit_warnings,
treat_err_as_bug,
external_macro_backtrace,
..Default::default()
},
);
build_session_(sopts,
local_crate_source_file,
diagnostic_handler,
codemap)
build_session_(sopts, local_crate_source_file, diagnostic_handler, codemap)
}
pub fn build_session_(sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
span_diagnostic: errors::Handler,
codemap: Lrc<codemap::CodeMap>)
-> Session {
pub fn build_session_(
sopts: config::Options,
local_crate_source_file: Option<PathBuf>,
span_diagnostic: errors::Handler,
codemap: Lrc<codemap::CodeMap>,
) -> Session {
let host = match Target::search(config::host_triple()) {
Ok(t) => t,
Err(e) => {
span_diagnostic.fatal(&format!("Error loading host specification: {}", e)).raise();
span_diagnostic
.fatal(&format!("Error loading host specification: {}", e))
.raise();
}
};
let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
@ -962,26 +1075,25 @@ pub fn build_session_(sopts: config::Options,
let p_s = parse::ParseSess::with_span_handler(span_diagnostic, codemap);
let default_sysroot = match sopts.maybe_sysroot {
Some(_) => None,
None => Some(filesearch::get_or_default_sysroot())
None => Some(filesearch::get_or_default_sysroot()),
};
let file_path_mapping = sopts.file_path_mapping();
let local_crate_source_file = local_crate_source_file.map(|path| {
file_path_mapping.map_prefix(path).0
});
let local_crate_source_file =
local_crate_source_file.map(|path| file_path_mapping.map_prefix(path).0);
let optimization_fuel_crate = sopts.debugging_opts.fuel.as_ref().map(|i| i.0.clone());
let optimization_fuel_limit = Cell::new(sopts.debugging_opts.fuel.as_ref()
.map(|i| i.1).unwrap_or(0));
let optimization_fuel_limit =
Cell::new(sopts.debugging_opts.fuel.as_ref().map(|i| i.1).unwrap_or(0));
let print_fuel_crate = sopts.debugging_opts.print_fuel.clone();
let print_fuel = Cell::new(0);
let working_dir = match env::current_dir() {
Ok(dir) => dir,
Err(e) => {
p_s.span_diagnostic.fatal(&format!("Current directory is invalid: {}", e)).raise()
}
Err(e) => p_s.span_diagnostic
.fatal(&format!("Current directory is invalid: {}", e))
.raise(),
};
let working_dir = file_path_mapping.map_prefix(working_dir);
@ -1090,15 +1202,11 @@ pub enum IncrCompSession {
},
/// This is the state after the session directory has been finalized. In this
/// state, the contents of the directory must not be modified any more.
Finalized {
session_directory: PathBuf,
},
Finalized { session_directory: PathBuf },
/// This is an error state that is reached when some compilation error has
/// occurred. It indicates that the contents of the session directory must
/// not be used, since they might be invalid.
InvalidBecauseOfErrors {
session_directory: PathBuf,
}
InvalidBecauseOfErrors { session_directory: PathBuf },
}
pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! {
@ -1133,7 +1241,7 @@ pub fn early_warn(output: config::ErrorOutputType, msg: &str) {
#[derive(Copy, Clone, Debug)]
pub enum CompileIncomplete {
Stopped,
Errored(ErrorReported)
Errored(ErrorReported),
}
impl From<ErrorReported> for CompileIncomplete {
fn from(err: ErrorReported) -> CompileIncomplete {
@ -1160,23 +1268,27 @@ pub fn bug_fmt(file: &'static str, line: u32, args: fmt::Arguments) -> ! {
#[cold]
#[inline(never)]
pub fn span_bug_fmt<S: Into<MultiSpan>>(file: &'static str,
line: u32,
span: S,
args: fmt::Arguments) -> ! {
pub fn span_bug_fmt<S: Into<MultiSpan>>(
file: &'static str,
line: u32,
span: S,
args: fmt::Arguments,
) -> ! {
opt_span_bug_fmt(file, line, Some(span), args);
}
fn opt_span_bug_fmt<S: Into<MultiSpan>>(file: &'static str,
line: u32,
span: Option<S>,
args: fmt::Arguments) -> ! {
fn opt_span_bug_fmt<S: Into<MultiSpan>>(
file: &'static str,
line: u32,
span: Option<S>,
args: fmt::Arguments,
) -> ! {
tls::with_opt(move |tcx| {
let msg = format!("{}:{}: {}", file, line, args);
match (tcx, span) {
(Some(tcx), Some(span)) => tcx.sess.diagnostic().span_bug(span, &msg),
(Some(tcx), None) => tcx.sess.diagnostic().bug(&msg),
(None, _) => panic!(msg)
(None, _) => panic!(msg),
}
});
unreachable!();

151
src/librustc_data_structures/graph/mod.rs
View File

@ -196,30 +196,30 @@ impl<N: Debug, E: Debug> Graph<N, E> {
// # Iterating over nodes, edges
pub fn enumerated_nodes(&self) -> EnumeratedNodes<N> {
EnumeratedNodes {
iter: self.nodes.iter().enumerate()
}
pub fn enumerated_nodes(&self) -> impl Iterator<Item = (NodeIndex, &Node<N>)> {
self.nodes
.iter()
.enumerate()
.map(|(idx, n)| (NodeIndex(idx), n))
}
pub fn enumerated_edges(&self) -> EnumeratedEdges<E> {
EnumeratedEdges {
iter: self.edges.iter().enumerate()
}
pub fn enumerated_edges(&self) -> impl Iterator<Item = (EdgeIndex, &Edge<E>)> {
self.edges
.iter()
.enumerate()
.map(|(idx, e)| (EdgeIndex(idx), e))
}
pub fn each_node<'a, F>(&'a self, mut f: F) -> bool
where F: FnMut(NodeIndex, &'a Node<N>) -> bool
{
pub fn each_node<'a>(&'a self, mut f: impl FnMut(NodeIndex, &'a Node<N>) -> bool) -> bool {
//! Iterates over all edges defined in the graph.
self.enumerated_nodes().all(|(node_idx, node)| f(node_idx, node))
self.enumerated_nodes()
.all(|(node_idx, node)| f(node_idx, node))
}
pub fn each_edge<'a, F>(&'a self, mut f: F) -> bool
where F: FnMut(EdgeIndex, &'a Edge<E>) -> bool
{
pub fn each_edge<'a>(&'a self, mut f: impl FnMut(EdgeIndex, &'a Edge<E>) -> bool) -> bool {
//! Iterates over all edges defined in the graph
self.enumerated_edges().all(|(edge_idx, edge)| f(edge_idx, edge))
self.enumerated_edges()
.all(|(edge_idx, edge)| f(edge_idx, edge))
}
pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges<N, E> {
@ -239,26 +239,33 @@ impl<N: Debug, E: Debug> Graph<N, E> {
}
}
pub fn successor_nodes(&self, source: NodeIndex) -> AdjacentTargets<N, E> {
pub fn successor_nodes<'a>(
&'a self,
source: NodeIndex,
) -> impl Iterator<Item = NodeIndex> + 'a {
self.outgoing_edges(source).targets()
}
pub fn predecessor_nodes(&self, target: NodeIndex) -> AdjacentSources<N, E> {
pub fn predecessor_nodes<'a>(
&'a self,
target: NodeIndex,
) -> impl Iterator<Item = NodeIndex> + 'a {
self.incoming_edges(target).sources()
}
pub fn depth_traverse<'a>(&'a self,
start: NodeIndex,
direction: Direction)
-> DepthFirstTraversal<'a, N, E> {
pub fn depth_traverse<'a>(
&'a self,
start: NodeIndex,
direction: Direction,
) -> DepthFirstTraversal<'a, N, E> {
DepthFirstTraversal::with_start_node(self, start, direction)
}
pub fn nodes_in_postorder<'a>(&'a self,
direction: Direction,
entry_node: NodeIndex)
-> Vec<NodeIndex>
{
pub fn nodes_in_postorder<'a>(
&'a self,
direction: Direction,
entry_node: NodeIndex,
) -> Vec<NodeIndex> {
let mut visited = BitVector::new(self.len_nodes());
let mut stack = vec![];
let mut result = Vec::with_capacity(self.len_nodes());
@ -268,7 +275,8 @@ impl<N: Debug, E: Debug> Graph<N, E> {
}
};
for node in Some(entry_node).into_iter()
for node in Some(entry_node)
.into_iter()
.chain(self.enumerated_nodes().map(|(node, _)| node))
{
push_node(&mut stack, node);
@ -293,50 +301,23 @@ impl<N: Debug, E: Debug> Graph<N, E> {
// # Iterators
pub struct EnumeratedNodes<'g, N>
where N: 'g,
{
iter: ::std::iter::Enumerate<::std::slice::Iter<'g, Node<N>>>
}
impl<'g, N: Debug> Iterator for EnumeratedNodes<'g, N> {
type Item = (NodeIndex, &'g Node<N>);
fn next(&mut self) -> Option<(NodeIndex, &'g Node<N>)> {
self.iter.next().map(|(idx, n)| (NodeIndex(idx), n))
}
}
pub struct EnumeratedEdges<'g, E>
where E: 'g,
{
iter: ::std::iter::Enumerate<::std::slice::Iter<'g, Edge<E>>>
}
impl<'g, E: Debug> Iterator for EnumeratedEdges<'g, E> {
type Item = (EdgeIndex, &'g Edge<E>);
fn next(&mut self) -> Option<(EdgeIndex, &'g Edge<E>)> {
self.iter.next().map(|(idx, e)| (EdgeIndex(idx), e))
}
}
pub struct AdjacentEdges<'g, N, E>
where N: 'g,
E: 'g
where
N: 'g,
E: 'g,
{
graph: &'g Graph<N, E>,
direction: Direction,
next: EdgeIndex,
}
impl<'g, N, E> AdjacentEdges<'g, N, E> {
fn targets(self) -> AdjacentTargets<'g, N, E> {
AdjacentTargets { edges: self }
impl<'g, N: Debug, E: Debug> AdjacentEdges<'g, N, E> {
fn targets(self) -> impl Iterator<Item = NodeIndex> + 'g {
self.into_iter().map(|(_, edge)| edge.target)
}
fn sources(self) -> AdjacentSources<'g, N, E> {
AdjacentSources { edges: self }
fn sources(self) -> impl Iterator<Item = NodeIndex> + 'g {
self.into_iter().map(|(_, edge)| edge.source)
}
}
@ -355,39 +336,10 @@ impl<'g, N: Debug, E: Debug> Iterator for AdjacentEdges<'g, N, E> {
}
}
pub struct AdjacentTargets<'g, N, E>
where N: 'g,
E: 'g
{
edges: AdjacentEdges<'g, N, E>,
}
impl<'g, N: Debug, E: Debug> Iterator for AdjacentTargets<'g, N, E> {
type Item = NodeIndex;
fn next(&mut self) -> Option<NodeIndex> {
self.edges.next().map(|(_, edge)| edge.target)
}
}
pub struct AdjacentSources<'g, N, E>
where N: 'g,
E: 'g
{
edges: AdjacentEdges<'g, N, E>,
}
impl<'g, N: Debug, E: Debug> Iterator for AdjacentSources<'g, N, E> {
type Item = NodeIndex;
fn next(&mut self) -> Option<NodeIndex> {
self.edges.next().map(|(_, edge)| edge.source)
}
}
pub struct DepthFirstTraversal<'g, N, E>
where N: 'g,
E: 'g
where
N: 'g,
E: 'g,
{
graph: &'g Graph<N, E>,
stack: Vec<NodeIndex>,
@ -396,10 +348,11 @@ pub struct DepthFirstTraversal<'g, N, E>
}
impl<'g, N: Debug, E: Debug> DepthFirstTraversal<'g, N, E> {
pub fn with_start_node(graph: &'g Graph<N, E>,
start_node: NodeIndex,
direction: Direction)
-> Self {
pub fn with_start_node(
graph: &'g Graph<N, E>,
start_node: NodeIndex,
direction: Direction,
) -> Self {
let mut visited = BitVector::new(graph.len_nodes());
visited.insert(start_node.node_id());
DepthFirstTraversal {

1
src/librustc_data_structures/lib.rs
View File

@ -34,6 +34,7 @@
#![feature(underscore_lifetimes)]
#![feature(macro_vis_matcher)]
#![feature(allow_internal_unstable)]
#![feature(universal_impl_trait)]
#![cfg_attr(unix, feature(libc))]
#![cfg_attr(test, feature(test))]

126
src/librustc_data_structures/sync.rs
View File

@ -62,7 +62,7 @@ cfg_if! {
pub use std::cell::RefMut as WriteGuard;
pub use std::cell::RefMut as LockGuard;
pub use std::cell::RefCell as RwLock;
use std::cell::RefCell as InnerRwLock;
use std::cell::RefCell as InnerLock;
use std::cell::Cell;
@ -159,13 +159,12 @@ cfg_if! {
pub use parking_lot::MutexGuard as LockGuard;
use parking_lot;
pub use std::sync::Arc as Lrc;
pub use self::Lock as MTLock;
use parking_lot::Mutex as InnerLock;
use parking_lot::RwLock as InnerRwLock;
pub type MetadataRef = OwningRef<Box<Erased + Send + Sync>, [u8]>;
@ -222,42 +221,6 @@ cfg_if! {
self.0.lock().take()
}
}
#[derive(Debug)]
pub struct RwLock<T>(parking_lot::RwLock<T>);
impl<T> RwLock<T> {
#[inline(always)]
pub fn new(inner: T) -> Self {
RwLock(parking_lot::RwLock::new(inner))
}
#[inline(always)]
pub fn borrow(&self) -> ReadGuard<T> {
if ERROR_CHECKING {
self.0.try_read().expect("lock was already held")
} else {
self.0.read()
}
}
#[inline(always)]
pub fn borrow_mut(&self) -> WriteGuard<T> {
if ERROR_CHECKING {
self.0.try_write().expect("lock was already held")
} else {
self.0.write()
}
}
}
// FIXME: Probably a bad idea
impl<T: Clone> Clone for RwLock<T> {
#[inline]
fn clone(&self) -> Self {
RwLock::new(self.borrow().clone())
}
}
}
}
@ -384,6 +347,11 @@ impl<T> Lock<T> {
self.0.borrow_mut()
}
#[inline(always)]
pub fn with_lock<F: FnOnce(&mut T) -> R, R>(&self, f: F) -> R {
f(&mut *self.lock())
}
#[inline(always)]
pub fn borrow(&self) -> LockGuard<T> {
self.lock()
@ -402,3 +370,83 @@ impl<T: Clone> Clone for Lock<T> {
Lock::new(self.borrow().clone())
}
}
#[derive(Debug)]
pub struct RwLock<T>(InnerRwLock<T>);
impl<T> RwLock<T> {
#[inline(always)]
pub fn new(inner: T) -> Self {
RwLock(InnerRwLock::new(inner))
}
#[inline(always)]
pub fn into_inner(self) -> T {
self.0.into_inner()
}
#[inline(always)]
pub fn get_mut(&mut self) -> &mut T {
self.0.get_mut()
}
#[cfg(not(parallel_queries))]
#[inline(always)]
pub fn read(&self) -> ReadGuard<T> {
self.0.borrow()
}
#[cfg(parallel_queries)]
#[inline(always)]
pub fn read(&self) -> ReadGuard<T> {
if ERROR_CHECKING {
self.0.try_read().expect("lock was already held")
} else {
self.0.read()
}
}
#[inline(always)]
pub fn with_read_lock<F: FnOnce(&T) -> R, R>(&self, f: F) -> R {
f(&*self.read())
}
#[cfg(not(parallel_queries))]
#[inline(always)]
pub fn write(&self) -> WriteGuard<T> {
self.0.borrow_mut()
}
#[cfg(parallel_queries)]
#[inline(always)]
pub fn write(&self) -> WriteGuard<T> {
if ERROR_CHECKING {
self.0.try_write().expect("lock was already held")
} else {
self.0.write()
}
}
#[inline(always)]
pub fn with_write_lock<F: FnOnce(&mut T) -> R, R>(&self, f: F) -> R {
f(&mut *self.write())
}
#[inline(always)]
pub fn borrow(&self) -> ReadGuard<T> {
self.read()
}
#[inline(always)]
pub fn borrow_mut(&self) -> WriteGuard<T> {
self.write()
}
}
// FIXME: Probably a bad idea
impl<T: Clone> Clone for RwLock<T> {
#[inline]
fn clone(&self) -> Self {
RwLock::new(self.borrow().clone())
}
}

79
src/librustc_mir/borrow_check/error_reporting.rs
View File

@ -124,6 +124,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
(place, span): (&Place<'tcx>, Span),
borrow: &BorrowData<'tcx>,
) {
let tcx = self.tcx;
let value_msg = match self.describe_place(place) {
Some(name) => format!("`{}`", name),
None => "value".to_owned(),
@ -132,7 +133,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
Some(name) => format!("`{}`", name),
None => "value".to_owned(),
};
let mut err = self.tcx.cannot_move_when_borrowed(
let mut err = tcx.cannot_move_when_borrowed(
span,
&self.describe_place(place).unwrap_or("_".to_owned()),
Origin::Mir,
@ -152,7 +153,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
(place, span): (&Place<'tcx>, Span),
borrow: &BorrowData<'tcx>,
) {
let mut err = self.tcx.cannot_use_when_mutably_borrowed(
let tcx = self.tcx;
let mut err = tcx.cannot_use_when_mutably_borrowed(
span,
&self.describe_place(place).unwrap_or("_".to_owned()),
self.retrieve_borrow_span(borrow),
@ -254,6 +256,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
.unwrap_or(issued_span);
let desc_place = self.describe_place(place).unwrap_or("_".to_owned());
let tcx = self.tcx;
// FIXME: supply non-"" `opt_via` when appropriate
let mut err = match (
@ -265,8 +268,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
"mutable",
) {
(BorrowKind::Shared, lft, _, BorrowKind::Mut { .. }, _, rgt)
| (BorrowKind::Mut { .. }, _, lft, BorrowKind::Shared, rgt, _) => self.tcx
.cannot_reborrow_already_borrowed(
| (BorrowKind::Mut { .. }, _, lft, BorrowKind::Shared, rgt, _) => {
tcx.cannot_reborrow_already_borrowed(
span,
&desc_place,
"",
@ -277,10 +280,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
"",
end_issued_loan_span,
Origin::Mir,
),
)
}
(BorrowKind::Mut { .. }, _, _, BorrowKind::Mut { .. }, _, _) => self.tcx
.cannot_mutably_borrow_multiply(
(BorrowKind::Mut { .. }, _, _, BorrowKind::Mut { .. }, _, _) => {
tcx.cannot_mutably_borrow_multiply(
span,
&desc_place,
"",
@ -288,18 +292,20 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
"",
end_issued_loan_span,
Origin::Mir,
),
)
}
(BorrowKind::Unique, _, _, BorrowKind::Unique, _, _) => self.tcx
.cannot_uniquely_borrow_by_two_closures(
(BorrowKind::Unique, _, _, BorrowKind::Unique, _, _) => {
tcx.cannot_uniquely_borrow_by_two_closures(
span,
&desc_place,
issued_span,
end_issued_loan_span,
Origin::Mir,
),
)
}
(BorrowKind::Unique, _, _, _, _, _) => self.tcx.cannot_uniquely_borrow_by_one_closure(
(BorrowKind::Unique, _, _, _, _, _) => tcx.cannot_uniquely_borrow_by_one_closure(
span,
&desc_place,
"",
@ -310,8 +316,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
Origin::Mir,
),
(BorrowKind::Shared, lft, _, BorrowKind::Unique, _, _) => self.tcx
.cannot_reborrow_already_uniquely_borrowed(
(BorrowKind::Shared, lft, _, BorrowKind::Unique, _, _) => {
tcx.cannot_reborrow_already_uniquely_borrowed(
span,
&desc_place,
"",
@ -320,10 +326,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
"",
end_issued_loan_span,
Origin::Mir,
),
)
}
(BorrowKind::Mut { .. }, _, lft, BorrowKind::Unique, _, _) => self.tcx
.cannot_reborrow_already_uniquely_borrowed(
(BorrowKind::Mut { .. }, _, lft, BorrowKind::Unique, _, _) => {
tcx.cannot_reborrow_already_uniquely_borrowed(
span,
&desc_place,
"",
@ -332,7 +339,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
"",
end_issued_loan_span,
Origin::Mir,
),
)
}
(BorrowKind::Shared, _, _, BorrowKind::Shared, _, _) => unreachable!(),
};
@ -466,11 +474,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
_proper_span: Span,
end_span: Option<Span>,
) {
let mut err = self.tcx.path_does_not_live_long_enough(
borrow_span,
&format!("`{}`", name),
Origin::Mir,
);
let tcx = self.tcx;
let mut err =
tcx.path_does_not_live_long_enough(borrow_span, &format!("`{}`", name), Origin::Mir);
err.span_label(borrow_span, "borrowed value does not live long enough");
err.span_label(
drop_span,
@ -493,9 +499,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
proper_span: Span,
end_span: Option<Span>,
) {
let tcx = self.tcx;
let mut err =
self.tcx
.path_does_not_live_long_enough(proper_span, "borrowed value", Origin::Mir);
tcx.path_does_not_live_long_enough(proper_span, "borrowed value", Origin::Mir);
err.span_label(proper_span, "temporary value does not live long enough");
err.span_label(
drop_span,
@ -527,16 +533,14 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
context, name, scope_tree, borrow, drop_span, borrow_span
);
let mut err = self.tcx.path_does_not_live_long_enough(
borrow_span,
&format!("`{}`", name),
Origin::Mir,
);
let tcx = self.tcx;
let mut err =
tcx.path_does_not_live_long_enough(borrow_span, &format!("`{}`", name), Origin::Mir);
err.span_label(borrow_span, "borrowed value does not live long enough");
err.span_label(drop_span, "borrowed value only lives until here");
if !self.tcx.nll() {
self.tcx.note_and_explain_region(
if !tcx.nll() {
tcx.note_and_explain_region(
scope_tree,
&mut err,
"borrowed value must be valid for ",
@ -566,14 +570,14 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
context, scope_tree, borrow, drop_span, proper_span
);
let tcx = self.tcx;
let mut err =
self.tcx
.path_does_not_live_long_enough(proper_span, "borrowed value", Origin::Mir);
tcx.path_does_not_live_long_enough(proper_span, "borrowed value", Origin::Mir);
err.span_label(proper_span, "temporary value does not live long enough");
err.span_label(drop_span, "temporary value only lives until here");
if !self.tcx.nll() {
self.tcx.note_and_explain_region(
if !tcx.nll() {
tcx.note_and_explain_region(
scope_tree,
&mut err,
"borrowed value must be valid for ",
@ -592,7 +596,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
(place, span): (&Place<'tcx>, Span),
loan: &BorrowData<'tcx>,
) {
let mut err = self.tcx.cannot_assign_to_borrowed(
let tcx = self.tcx;
let mut err = tcx.cannot_assign_to_borrowed(
span,
self.retrieve_borrow_span(loan),
&self.describe_place(place).unwrap_or("_".to_owned()),

132
src/librustc_mir/borrow_check/mod.rs
View File

@ -10,7 +10,7 @@
//! This query borrow-checks the MIR to (further) ensure it is not broken.
use borrow_check::nll::region_infer::RegionInferenceContext;
use borrow_check::nll::region_infer::{RegionCausalInfo, RegionInferenceContext};
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::hir::map::definitions::DefPathData;
@ -231,6 +231,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(
access_place_error_reported: FxHashSet(),
reservation_error_reported: FxHashSet(),
nonlexical_regioncx: opt_regioncx.clone(),
nonlexical_cause_info: None,
};
let borrows = Borrows::new(tcx, mir, opt_regioncx, def_id, body_id);
@ -311,6 +312,7 @@ pub struct MirBorrowckCtxt<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
/// contains the results from region inference and lets us e.g.
/// find out which CFG points are contained in each borrow region.
nonlexical_regioncx: Option<Rc<RegionInferenceContext<'tcx>>>,
nonlexical_cause_info: Option<RegionCausalInfo>,
}
// Check that:
@ -337,9 +339,7 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx
) {
debug!(
"MirBorrowckCtxt::process_statement({:?}, {:?}): {}",
location,
stmt,
flow_state
location, stmt, flow_state
);
let span = stmt.source_info.span;
@ -441,9 +441,7 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx
let loc = location;
debug!(
"MirBorrowckCtxt::process_terminator({:?}, {:?}): {}",
location,
term,
flow_state
location, term, flow_state
);
let span = term.source_info.span;
@ -582,8 +580,14 @@ impl<'cx, 'gcx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx
TerminatorKind::Goto { target: _ }
| TerminatorKind::Abort
| TerminatorKind::Unreachable
| TerminatorKind::FalseEdges { real_target: _, imaginary_targets: _ }
| TerminatorKind::FalseUnwind { real_target: _, unwind: _ } => {
| TerminatorKind::FalseEdges {
real_target: _,
imaginary_targets: _,
}
| TerminatorKind::FalseUnwind {
real_target: _,
unwind: _,
} => {
// no data used, thus irrelevant to borrowck
}
}
@ -683,7 +687,8 @@ enum LocalMutationIsAllowed {
struct AccessErrorsReported {
mutability_error: bool,
#[allow(dead_code)] conflict_error: bool,
#[allow(dead_code)]
conflict_error: bool,
}
#[derive(Copy, Clone)]
@ -719,9 +724,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
/// allowed to be split into separate Reservation and
/// Activation phases.
fn allow_two_phase_borrow(&self, kind: BorrowKind) -> bool {
self.tcx.two_phase_borrows() &&
(kind.allows_two_phase_borrow() ||
self.tcx.sess.opts.debugging_opts.two_phase_beyond_autoref)
self.tcx.two_phase_borrows()
&& (kind.allows_two_phase_borrow()
|| self.tcx.sess.opts.debugging_opts.two_phase_beyond_autoref)
}
/// Invokes `access_place` as appropriate for dropping the value
@ -753,16 +758,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
let field_ty = gcx.normalize_associated_type_in_env(&field_ty, self.param_env);
let place = drop_place.clone().field(Field::new(index), field_ty);
self.visit_terminator_drop(
loc,
term,
flow_state,
&place,
field_ty,
span,
);
self.visit_terminator_drop(loc, term, flow_state, &place, field_ty, span);
}
},
}
_ => {
// We have now refined the type of the value being
// dropped (potentially) to just the type of a
@ -779,7 +777,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
flow_state,
);
}
},
}
}
}
@ -801,8 +799,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
if let Activation(_, borrow_index) = rw {
if self.reservation_error_reported.contains(&place_span.0) {
debug!("skipping access_place for activation of invalid reservation \
place: {:?} borrow_index: {:?}", place_span.0, borrow_index);
debug!(
"skipping access_place for activation of invalid reservation \
place: {:?} borrow_index: {:?}",
place_span.0, borrow_index
);
return AccessErrorsReported {
mutability_error: false,
conflict_error: true,
@ -810,9 +811,13 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
}
}
if self.access_place_error_reported.contains(&(place_span.0.clone(), place_span.1)) {
debug!("access_place: suppressing error place_span=`{:?}` kind=`{:?}`",
place_span, kind);
if self.access_place_error_reported
.contains(&(place_span.0.clone(), place_span.1))
{
debug!(
"access_place: suppressing error place_span=`{:?}` kind=`{:?}`",
place_span, kind
);
return AccessErrorsReported {
mutability_error: false,
conflict_error: true,
@ -825,9 +830,12 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
self.check_access_for_conflict(context, place_span, sd, rw, flow_state);
if conflict_error || mutability_error {
debug!("access_place: logging error place_span=`{:?}` kind=`{:?}`",
place_span, kind);
self.access_place_error_reported.insert((place_span.0.clone(), place_span.1));
debug!(
"access_place: logging error place_span=`{:?}` kind=`{:?}`",
place_span, kind
);
self.access_place_error_reported
.insert((place_span.0.clone(), place_span.1));
}
AccessErrorsReported {
@ -875,8 +883,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
(Read(kind), BorrowKind::Unique) | (Read(kind), BorrowKind::Mut { .. }) => {
// Reading from mere reservations of mutable-borrows is OK.
if this.allow_two_phase_borrow(borrow.kind) && index.is_reservation()
{
if this.allow_two_phase_borrow(borrow.kind) && index.is_reservation() {
return Control::Continue;
}
@ -915,15 +922,15 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
place_span.0
);
this.reservation_error_reported.insert(place_span.0.clone());
},
}
Activation(_, activating) => {
debug!(
"observing check_place for activation of \
borrow_index: {:?}",
activating
);
},
Read(..) | Write(..) => {},
}
Read(..) | Write(..) => {}
}
match kind {
@ -1210,11 +1217,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
/// Reports an error if this is a borrow of local data.
/// This is called for all Yield statements on movable generators
fn check_for_local_borrow(
&mut self,
borrow: &BorrowData<'tcx>,
yield_span: Span)
{
fn check_for_local_borrow(&mut self, borrow: &BorrowData<'tcx>, yield_span: Span) {
fn borrow_of_local_data<'tcx>(place: &Place<'tcx>) -> bool {
match place {
Place::Static(..) => false,
@ -1226,13 +1229,11 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
ProjectionElem::Deref => false,
// For interior references and downcasts, find out if the base is local
ProjectionElem::Field(..) |
ProjectionElem::Index(..) |
ProjectionElem::ConstantIndex { .. } |
ProjectionElem::Subslice { .. } |
ProjectionElem::Downcast(..) => {
borrow_of_local_data(&proj.base)
}
ProjectionElem::Field(..)
| ProjectionElem::Index(..)
| ProjectionElem::ConstantIndex { .. }
| ProjectionElem::Subslice { .. }
| ProjectionElem::Downcast(..) => borrow_of_local_data(&proj.base),
}
}
}
@ -1241,9 +1242,13 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
debug!("check_for_local_borrow({:?})", borrow);
if borrow_of_local_data(&borrow.borrowed_place) {
self.tcx.cannot_borrow_across_generator_yield(self.retrieve_borrow_span(borrow),
yield_span,
Origin::Mir).emit();
self.tcx
.cannot_borrow_across_generator_yield(
self.retrieve_borrow_span(borrow),
yield_span,
Origin::Mir,
)
.emit();
}
}
@ -1531,9 +1536,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
) -> bool {
debug!(
"check_access_permissions({:?}, {:?}, {:?})",
place,
kind,
is_local_mutation_allowed
place, kind, is_local_mutation_allowed
);
let mut error_reported = false;
match kind {
@ -1598,8 +1601,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
span,
&format!(
"Accessing `{:?}` with the kind `{:?}` shouldn't be possible",
place,
kind
place, kind
),
);
}
@ -1699,9 +1701,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
let decl = &self.mir.upvar_decls[field.index()];
debug!(
"decl.mutability={:?} local_mutation_is_allowed={:?} place={:?}",
decl,
is_local_mutation_allowed,
place
decl, is_local_mutation_allowed, place
);
match (decl.mutability, is_local_mutation_allowed) {
(Mutability::Not, LocalMutationIsAllowed::No)
@ -1722,7 +1722,6 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
}
}
/// If this is a field projection, and the field is being projected from a closure type,
/// then returns the index of the field being projected. Note that this closure will always
/// be `self` in the current MIR, because that is the only time we directly access the fields
@ -1926,9 +1925,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
) -> bool {
debug!(
"places_conflict({:?},{:?},{:?})",
borrow_place,
access_place,
access
borrow_place, access_place, access
);
// Return all the prefixes of `place` in reverse order, including
@ -1954,8 +1951,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
let access_components = place_elements(access_place);
debug!(
"places_conflict: components {:?} / {:?}",
borrow_components,
access_components
borrow_components, access_components
);
let borrow_components = borrow_components
@ -2161,8 +2157,10 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
let borrowed = &data[i.borrow_index()];
if self.places_conflict(&borrowed.borrowed_place, place, access) {
debug!("each_borrow_involving_path: {:?} @ {:?} vs. {:?}/{:?}",
i, borrowed, place, access);
debug!(
"each_borrow_involving_path: {:?} @ {:?} vs. {:?}/{:?}",
i, borrowed, place, access
);
let ctrl = op(self, i, borrowed);
if ctrl == Control::Break {
return;

22
src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs
View File

@ -18,19 +18,29 @@ use rustc_errors::DiagnosticBuilder;
use util::liveness::{self, DefUse, LivenessMode};
impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
/// Adds annotations to `err` explaining *why* the borrow contains the
/// point from `context`. This is key for the "3-point errors"
/// [described in the NLL RFC][d].
///
/// [d]: https://rust-lang.github.io/rfcs/2094-nll.html#leveraging-intuition-framing-errors-in-terms-of-points
pub(in borrow_check) fn explain_why_borrow_contains_point(
&self,
&mut self,
context: Context,
borrow: &BorrowData<'tcx>,
err: &mut DiagnosticBuilder<'_>,
) {
if let Some(regioncx) = &self.nonlexical_regioncx {
if let Some(cause) = regioncx.why_region_contains_point(borrow.region, context.loc) {
let mir = self.mir;
let mir = self.mir;
if self.nonlexical_cause_info.is_none() {
self.nonlexical_cause_info = Some(regioncx.compute_causal_info(mir));
}
let cause_info = self.nonlexical_cause_info.as_ref().unwrap();
if let Some(cause) = cause_info.why_region_contains_point(borrow.region, context.loc) {
match *cause.root_cause() {
Cause::LiveVar(local, location) => {
match find_regular_use(&mir, regioncx, borrow, location, local) {
match find_regular_use(mir, regioncx, borrow, location, local) {
Some(p) => {
err.span_label(
mir.source_info(p).span,
@ -48,9 +58,9 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
}
Cause::DropVar(local, location) => {
match find_drop_use(&mir, regioncx, borrow, location, local) {
match find_drop_use(mir, regioncx, borrow, location, local) {
Some(p) => {
let local_name = &mir.local_decls[local].name.unwrap();
let local_name = mir.local_decls[local].name.unwrap();
err.span_label(
mir.source_info(p).span,

53
src/librustc_mir/borrow_check/nll/region_infer/mod.rs
View File

@ -124,6 +124,10 @@ pub(crate) enum Cause {
},
}
pub(crate) struct RegionCausalInfo {
inferred_values: RegionValues,
}
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Constraint {
// NB. The ordering here is not significant for correctness, but
@ -250,16 +254,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
.map(|origin| RegionDefinition::new(origin))
.collect();
let nll_dump_cause = ty::tls::with(|tcx| tcx.sess.nll_dump_cause());
let mut result = Self {
definitions,
elements: elements.clone(),
liveness_constraints: RegionValues::new(
elements,
num_region_variables,
TrackCauses(nll_dump_cause),
),
liveness_constraints: RegionValues::new(elements, num_region_variables),
inferred_values: None,
constraints: Vec::new(),
type_tests: Vec::new(),
@ -348,17 +346,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
inferred_values.contains(r.to_region_vid(), p)
}
/// Returns the *reason* that the region `r` contains the given point.
pub(crate) fn why_region_contains_point<R>(&self, r: R, p: Location) -> Option<Rc<Cause>>
where
R: ToRegionVid,
{
let inferred_values = self.inferred_values
.as_ref()
.expect("region values not yet inferred");
inferred_values.cause(r.to_region_vid(), p)
}
/// Returns access to the value of `r` for debugging purposes.
pub(super) fn region_value_str(&self, r: RegionVid) -> String {
let inferred_values = self.inferred_values
@ -449,13 +436,25 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
}
/// Re-execute the region inference, this time tracking causal information.
/// This is significantly slower, so it is done only when an error is being reported.
pub(super) fn compute_causal_info(&self, mir: &Mir<'tcx>) -> RegionCausalInfo {
let inferred_values = self.compute_region_values(mir, TrackCauses(true));
RegionCausalInfo { inferred_values }
}
/// Propagate the region constraints: this will grow the values
/// for each region variable until all the constraints are
/// satisfied. Note that some values may grow **too** large to be
/// feasible, but we check this later.
fn propagate_constraints(&mut self, mir: &Mir<'tcx>) {
debug!("propagate_constraints()");
debug!("propagate_constraints: constraints={:#?}", {
let inferred_values = self.compute_region_values(mir, TrackCauses(false));
self.inferred_values = Some(inferred_values);
}
fn compute_region_values(&self, mir: &Mir<'tcx>, track_causes: TrackCauses) -> RegionValues {
debug!("compute_region_values()");
debug!("compute_region_values: constraints={:#?}", {
let mut constraints: Vec<_> = self.constraints.iter().collect();
constraints.sort();
constraints
@ -463,7 +462,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
// The initial values for each region are derived from the liveness
// constraints we have accumulated.
let mut inferred_values = self.liveness_constraints.clone();
let mut inferred_values = self.liveness_constraints.duplicate(track_causes);
let dependency_map = self.build_dependency_map();
@ -507,7 +506,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
debug!("\n");
}
self.inferred_values = Some(inferred_values);
inferred_values
}
/// Builds up a map from each region variable X to a vector with the
@ -1097,6 +1096,16 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
}
impl RegionCausalInfo {
/// Returns the *reason* that the region `r` contains the given point.
pub(super) fn why_region_contains_point<R>(&self, r: R, p: Location) -> Option<Rc<Cause>>
where
R: ToRegionVid,
{
self.inferred_values.cause(r.to_region_vid(), p)
}
}
impl<'tcx> RegionDefinition<'tcx> {
fn new(origin: RegionVariableOrigin) -> Self {
// Create a new region definition. Note that, for free

26
src/librustc_mir/borrow_check/nll/region_infer/values.rs
View File

@ -184,7 +184,6 @@ impl ToElementIndex for RegionElementIndex {
/// compact `SparseBitMatrix` representation, with one row per region
/// variable. The columns consist of either universal regions or
/// points in the CFG.
#[derive(Clone)]
pub(super) struct RegionValues {
elements: Rc<RegionValueElements>,
matrix: SparseBitMatrix<RegionVid, RegionElementIndex>,
@ -199,11 +198,10 @@ pub(super) struct RegionValues {
type CauseMap = FxHashMap<(RegionVid, RegionElementIndex), Rc<Cause>>;
impl RegionValues {
pub(super) fn new(
elements: &Rc<RegionValueElements>,
num_region_variables: usize,
track_causes: TrackCauses,
) -> Self {
/// Creates a new set of "region values" that tracks causal information.
/// Each of the regions in num_region_variables will be initialized with an
/// empty set of points and no causal information.
pub(super) fn new(elements: &Rc<RegionValueElements>, num_region_variables: usize) -> Self {
assert!(
elements.num_universal_regions <= num_region_variables,
"universal regions are a subset of the region variables"
@ -215,8 +213,22 @@ impl RegionValues {
RegionVid::new(num_region_variables),
RegionElementIndex::new(elements.num_elements()),
),
causes: Some(CauseMap::default()),
}
}
/// Duplicates the region values. If track_causes is false, then the
/// resulting value will not track causal information (and any existing
/// causal information is dropped). Otherwise, the causal information is
/// preserved and maintained. Tracking the causal information makes region
/// propagation significantly slower, so we prefer not to do it until an
/// error is reported.
pub(super) fn duplicate(&self, track_causes: TrackCauses) -> Self {
Self {
elements: self.elements.clone(),
matrix: self.matrix.clone(),
causes: if track_causes.0 {
Some(CauseMap::default())
self.causes.clone()
} else {
None
},

1
src/librustc_typeck/collect.rs
View File

@ -1866,6 +1866,7 @@ fn trans_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> TransFnAt
.emit();
}
} else if attr.check_name("target_feature") {
// handle deprecated #[target_feature = "..."]
if let Some(val) = attr.value_str() {
for feat in val.as_str().split(",").map(|f| f.trim()) {
if !feat.is_empty() && !feat.contains('\0') {

2
src/librustdoc/html/static/rustdoc.css
View File

@ -183,7 +183,7 @@ nav.sub {
}
.sidebar .block > ul > li {
margin-right: -20px;
margin-right: -10px;
}
.content, nav {

27
src/libstd/path.rs
View File

@ -87,6 +87,7 @@ use io;
use iter::{self, FusedIterator};
use ops::{self, Deref};
use rc::Rc;
use str::FromStr;
use sync::Arc;
use ffi::{OsStr, OsString};
@ -1441,6 +1442,32 @@ impl From<String> for PathBuf {
}
}
/// Error returned from [`PathBuf::from_str`][`from_str`].
///
/// Note that parsing a path will never fail. This error is just a placeholder
/// for implementing `FromStr` for `PathBuf`.
///
/// [`from_str`]: struct.PathBuf.html#method.from_str
#[derive(Debug, Clone, PartialEq, Eq)]
#[stable(feature = "path_from_str", since = "1.26.0")]
pub enum ParsePathError {}
#[stable(feature = "path_from_str", since = "1.26.0")]
impl fmt::Display for ParsePathError {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
#[stable(feature = "path_from_str", since = "1.26.0")]
impl FromStr for PathBuf {
type Err = ParsePathError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(PathBuf::from(s))
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<P: AsRef<Path>> iter::FromIterator<P> for PathBuf {
fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf {

23
src/libsyntax/diagnostics/plugin.rs
View File

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::env;
@ -31,12 +30,6 @@ pub use errors::*;
// Maximum width of any line in an extended error description (inclusive).
const MAX_DESCRIPTION_WIDTH: usize = 80;
thread_local! {
static REGISTERED_DIAGNOSTICS: RefCell<ErrorMap> = {
RefCell::new(BTreeMap::new())
}
}
/// Error information type.
pub struct ErrorInfo {
pub description: Option<Name>,
@ -46,14 +39,6 @@ pub struct ErrorInfo {
/// Mapping from error codes to metadata.
pub type ErrorMap = BTreeMap<Name, ErrorInfo>;
fn with_registered_diagnostics<T, F>(f: F) -> T where
F: FnOnce(&mut ErrorMap) -> T,
{
REGISTERED_DIAGNOSTICS.with(move |slot| {
f(&mut *slot.borrow_mut())
})
}
pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt,
span: Span,
token_tree: &[TokenTree])
@ -63,7 +48,7 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt,
_ => unreachable!()
};
with_registered_diagnostics(|diagnostics| {
ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| {
match diagnostics.get_mut(&code.name) {
// Previously used errors.
Some(&mut ErrorInfo { description: _, use_site: Some(previous_span) }) => {
@ -132,7 +117,7 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt,
}
});
// Add the error to the map.
with_registered_diagnostics(|diagnostics| {
ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| {
let info = ErrorInfo {
description,
use_site: None
@ -174,7 +159,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
// Output error metadata to `tmp/extended-errors/<target arch>/<crate name>.json`
if let Ok(target_triple) = env::var("CFG_COMPILER_HOST_TRIPLE") {
with_registered_diagnostics(|diagnostics| {
ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| {
if let Err(e) = output_metadata(ecx,
&target_triple,
&crate_name.name.as_str(),
@ -194,7 +179,7 @@ pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
// Construct the output expression.
let (count, expr) =
with_registered_diagnostics(|diagnostics| {
ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| {
let descriptions: Vec<P<ast::Expr>> =
diagnostics.iter().filter_map(|(&code, info)| {
info.description.map(|description| {

3
src/libsyntax/parse/lexer/mod.rs
View File

@ -1764,6 +1764,8 @@ mod tests {
use std::collections::HashSet;
use std::io;
use std::path::PathBuf;
use diagnostics::plugin::ErrorMap;
use rustc_data_structures::sync::Lock;
fn mk_sess(cm: Lrc<CodeMap>) -> ParseSess {
let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()),
Some(cm.clone()),
@ -1776,6 +1778,7 @@ mod tests {
included_mod_stack: RefCell::new(Vec::new()),
code_map: cm,
missing_fragment_specifiers: RefCell::new(HashSet::new()),
registered_diagnostics: Lock::new(ErrorMap::new()),
non_modrs_mods: RefCell::new(vec![]),
}
}

6
src/libsyntax/parse/mod.rs
View File

@ -10,7 +10,7 @@
//! The main parser interface
use rustc_data_structures::sync::Lrc;
use rustc_data_structures::sync::{Lrc, Lock};
use ast::{self, CrateConfig};
use codemap::{CodeMap, FilePathMapping};
use syntax_pos::{self, Span, FileMap, NO_EXPANSION, FileName};
@ -21,6 +21,7 @@ use ptr::P;
use str::char_at;
use symbol::Symbol;
use tokenstream::{TokenStream, TokenTree};
use diagnostics::plugin::ErrorMap;
use std::cell::RefCell;
use std::collections::HashSet;
@ -47,6 +48,8 @@ pub struct ParseSess {
pub unstable_features: UnstableFeatures,
pub config: CrateConfig,
pub missing_fragment_specifiers: RefCell<HashSet<Span>>,
/// The registered diagnostics codes
pub registered_diagnostics: Lock<ErrorMap>,
// Spans where a `mod foo;` statement was included in a non-mod.rs file.
// These are used to issue errors if the non_modrs_mods feature is not enabled.
pub non_modrs_mods: RefCell<Vec<(ast::Ident, Span)>>,
@ -71,6 +74,7 @@ impl ParseSess {
unstable_features: UnstableFeatures::from_environment(),
config: HashSet::new(),
missing_fragment_specifiers: RefCell::new(HashSet::new()),
registered_diagnostics: Lock::new(ErrorMap::new()),
included_mod_stack: RefCell::new(vec![]),
code_map,
non_modrs_mods: RefCell::new(vec![]),

7
src/test/ui/issue-45157.stderr
View File

@ -6,6 +6,9 @@ LL | let mref = &mut u.s.a;
...
LL | let nref = &u.z.c;
| ^^^^^^ immutable borrow occurs here
LL | //~^ ERROR cannot borrow `u.z.c` as immutable because it is also borrowed as mutable [E0502]
LL | println!("{} {}", mref, nref)
| ---- borrow later used here
error[E0502]: cannot borrow `u.s.a` as mutable because it is also borrowed as immutable
--> $DIR/issue-45157.rs:39:27
@ -14,7 +17,9 @@ LL | let nref = &u.z.c;
| ------ immutable borrow occurs here
LL | //~^ ERROR cannot borrow `u.z.c` as immutable because it is also borrowed as mutable [E0502]
LL | println!("{} {}", mref, nref)
| ^^^^ mutable borrow occurs here
| ^^^^ ---- borrow later used here
| |
| mutable borrow occurs here
error: aborting due to 2 previous errors

2
src/test/ui/nll/borrowed-local-error.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// compile-flags: -Znll-dump-cause
#![feature(nll)]
fn gimme(x: &(u32,)) -> &u32 {

2
src/test/ui/nll/borrowed-local-error.stderr
View File

@ -1,5 +1,5 @@
error[E0597]: `v` does not live long enough
--> $DIR/borrowed-local-error.rs:22:9
--> $DIR/borrowed-local-error.rs:20:9
|
LL | let x = gimme({
| _____________-

5
src/test/ui/nll/borrowed-match-issue-45045.stderr
View File

@ -10,6 +10,8 @@ LL | | //~^ cannot use `e` because it was mutably borrowed [E0503]
LL | | Xyz::B => println!("b"),
LL | | };
| |_____^ use of borrowed `e`
LL | *g = Xyz::B;
| ----------- borrow later used here
error[E0503]: cannot use `e` because it was mutably borrowed
--> $DIR/borrowed-match-issue-45045.rs:25:9
@ -19,6 +21,9 @@ LL | let f = &mut e;
...
LL | Xyz::A => println!("a"),
| ^^^^^^ use of borrowed `e`
...
LL | *g = Xyz::B;
| ----------- borrow later used here
error: aborting due to 2 previous errors

3
src/test/ui/nll/borrowed-referent-issue-38899.stderr
View File

@ -6,6 +6,9 @@ LL | let x = &mut block;
LL | println!("{}", x.current);
LL | let p: &'a u8 = &*block.current;
| ^^^^^^^^^^^^^^^ immutable borrow occurs here
LL | //~^ ERROR cannot borrow `*block.current` as immutable because it is also borrowed as mutable
LL | drop(x);
| - borrow later used here
error: aborting due to previous error

2
src/test/ui/nll/borrowed-temporary-error.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// compile-flags: -Znll-dump-cause
#![feature(nll)]
fn gimme(x: &(u32,)) -> &u32 {

2
src/test/ui/nll/borrowed-temporary-error.stderr
View File

@ -1,5 +1,5 @@
error[E0597]: borrowed value does not live long enough
--> $DIR/borrowed-temporary-error.rs:22:10
--> $DIR/borrowed-temporary-error.rs:20:10
|
LL | &(v,)
| ^^^^ temporary value does not live long enough

2
src/test/ui/nll/borrowed-universal-error-2.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// compile-flags: -Znll-dump-cause
#![feature(nll)]
#![allow(warnings)]

6
src/test/ui/nll/borrowed-universal-error-2.stderr
View File

@ -1,5 +1,5 @@
error[E0597]: `v` does not live long enough
--> $DIR/borrowed-universal-error-2.rs:18:5
--> $DIR/borrowed-universal-error-2.rs:16:5
|
LL | &v
| ^^ borrowed value does not live long enough
@ -7,8 +7,8 @@ LL | //~^ ERROR `v` does not live long enough [E0597]
LL | }
| - borrowed value only lives until here
|
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 16:1...
--> $DIR/borrowed-universal-error-2.rs:16:1
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 14:1...
--> $DIR/borrowed-universal-error-2.rs:14:1
|
LL | fn foo<'a>(x: &'a (u32,)) -> &'a u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/nll/borrowed-universal-error.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// compile-flags: -Znll-dump-cause
#![feature(nll)]
#![allow(warnings)]

6
src/test/ui/nll/borrowed-universal-error.stderr
View File

@ -1,5 +1,5 @@
error[E0597]: borrowed value does not live long enough
--> $DIR/borrowed-universal-error.rs:22:12
--> $DIR/borrowed-universal-error.rs:20:12
|
LL | gimme(&(v,))
| ^^^^ temporary value does not live long enough
@ -7,8 +7,8 @@ LL | //~^ ERROR borrowed value does not live long enough [E0597]
LL | }
| - temporary value only lives until here
|
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 20:1...
--> $DIR/borrowed-universal-error.rs:20:1
note: borrowed value must be valid for the lifetime 'a as defined on the function body at 18:1...
--> $DIR/borrowed-universal-error.rs:18:1
|
LL | fn foo<'a>(x: &'a (u32,)) -> &'a u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
src/test/ui/nll/capture-ref-in-struct.rs
View File

@ -8,8 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// compile-flags:-Znll-dump-cause
// Test that a structure which tries to store a pointer to `y` into
// `p` (indirectly) fails to compile.

2
src/test/ui/nll/capture-ref-in-struct.stderr
View File

@ -1,5 +1,5 @@
error[E0597]: `y` does not live long enough
--> $DIR/capture-ref-in-struct.rs:33:16
--> $DIR/capture-ref-in-struct.rs:31:16
|
LL | y: &y,
| ^^ borrowed value does not live long enough

2
src/test/ui/nll/closure-requirements/escape-argument.rs
View File

@ -22,7 +22,7 @@
// basically checking that the MIR type checker correctly enforces the
// closure signature.
// compile-flags:-Znll -Zborrowck=mir -Znll-dump-cause -Zverbose
// compile-flags:-Znll -Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]

2
src/test/ui/nll/closure-requirements/escape-upvar-nested.rs
View File

@ -15,7 +15,7 @@
//
// except that the closure does so via a second closure.
// compile-flags:-Znll -Zborrowck=mir -Znll-dump-cause -Zverbose
// compile-flags:-Znll -Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]

2
src/test/ui/nll/closure-requirements/escape-upvar-ref.rs
View File

@ -19,7 +19,7 @@
// `'b`. This relationship is propagated to the closure creator,
// which reports an error.
// compile-flags:-Znll -Zborrowck=mir -Znll-dump-cause -Zverbose
// compile-flags:-Znll -Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]

2
src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
View File

@ -78,6 +78,8 @@ LL | let cell = Cell::new(&a);
...
LL | }
| - borrowed value only lives until here
|
= note: borrowed value must be valid for the static lifetime...
error: aborting due to 2 previous errors

2
src/test/ui/nll/drop-no-may-dangle.rs
View File

@ -13,7 +13,7 @@
// because of destructor. (Note that the stderr also identifies this
// destructor in the error message.)
// compile-flags:-Znll -Zborrowck=mir -Znll-dump-cause
// compile-flags:-Znll -Zborrowck=mir
#![allow(warnings)]
#![feature(dropck_eyepatch)]

2
src/test/ui/nll/get_default.rs
View File

@ -13,7 +13,7 @@
// a variety of errors from the older, AST-based machinery (notably
// borrowck), and then we get the NLL error at the end.
// compile-flags:-Znll -Zborrowck=compare -Znll-dump-cause
// compile-flags:-Znll -Zborrowck=compare
struct Map {
}

2
src/test/ui/nll/guarantor-issue-46974.stderr
View File

@ -6,6 +6,8 @@ LL | let t = &mut *s; // this borrow should last for the entire function
LL | let x = &t.0;
LL | *s = (2,); //~ ERROR cannot assign to `*s`
| ^^^^^^^^^ assignment to borrowed `*s` occurs here
LL | *x
| -- borrow later used here
error[E0621]: explicit lifetime required in the type of `s`
--> $DIR/guarantor-issue-46974.rs:25:5

2
src/test/ui/nll/maybe-initialized-drop-implicit-fragment-drop.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Z nll -Znll-dump-cause
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
#![allow(warnings)]

2
src/test/ui/nll/maybe-initialized-drop-with-fragment.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll -Znll-dump-cause
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
#![allow(warnings)]

2
src/test/ui/nll/maybe-initialized-drop-with-uninitialized-fragments.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll -Znll-dump-cause
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
#![allow(warnings)]

2
src/test/ui/nll/maybe-initialized-drop.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll -Znll-dump-cause
//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
#![allow(warnings)]

15
src/test/ui/nll/return-ref-mut-issue-46557.stderr
View File

@ -1,11 +1,16 @@
error[E0597]: borrowed value does not live long enough
--> $DIR/return-ref-mut-issue-46557.rs:17:21
|
LL | let ref mut x = 1234543; //~ ERROR borrowed value does not live long enough [E0597]
| ^^^^^^^ temporary value does not live long enough
LL | x
LL | }
| - temporary value only lives until here
LL | fn gimme_static_mut() -> &'static mut u32 {
| ___________________________________________-
LL | | let ref mut x = 1234543; //~ ERROR borrowed value does not live long enough [E0597]
| | ^^^^^^^ temporary value does not live long enough
LL | | x
LL | | }
| | -
| | |
| |_temporary value only lives until here
| borrow later used here
error: aborting due to previous error

4
src/test/ui/target-feature-wrong.rs
View File

@ -29,6 +29,10 @@ unsafe fn foo() {}
//~^ ERROR: can only be applied to `unsafe` function
fn bar() {}
#[target_feature(enable = "sse2")]
//~^ ERROR: should be applied to a function
mod another {}
fn main() {
unsafe {
foo();

11
src/test/ui/target-feature-wrong.stderr
View File

@ -28,5 +28,14 @@ error: #[target_feature(..)] can only be applied to `unsafe` function
LL | #[target_feature(enable = "sse2")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 4 previous errors
error: attribute should be applied to a function
--> $DIR/target-feature-wrong.rs:32:1
|
LL | #[target_feature(enable = "sse2")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | //~^ ERROR: should be applied to a function
LL | mod another {}
| -------------- not a function
error: aborting due to 5 previous errors