bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #133551 - matthiaskrgr:rollup-m0rr5oz, r=matthiaskrgr

Browse source 
Rollup of 5 pull requests

Successful merges:

 - #132410 (Some more refactorings towards removing driver queries)
 - #133418 (coverage: Store coverage source regions as `Span` until codegen)
 - #133498 (Add missing code examples on `LocalKey`)
 - #133518 (Structurally resolve before checking `!` in HIR typeck)
 - #133521 (Structurally resolve before matching on type of projection)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-11-28 00:51:37 +00:00
commit eddb717281
64 changed files with 653 additions and 526 deletions
Download patch file Download diff file Expand all files Collapse all files

36
compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
View file

@ -1,6 +1,4 @@
use rustc_middle::mir::coverage::{CounterId, CovTerm, ExpressionId, SourceRegion}; use rustc_middle::mir::coverage::{CounterId, CovTerm, ExpressionId};
use crate::coverageinfo::mapgen::LocalFileId;
/// Must match the layout of `LLVMRustCounterKind`. /// Must match the layout of `LLVMRustCounterKind`.
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
@ -126,37 +124,23 @@ pub(crate) struct CoverageSpan {
/// Local index into the function's local-to-global file ID table. /// Local index into the function's local-to-global file ID table.
/// The value at that index is itself an index into the coverage filename /// The value at that index is itself an index into the coverage filename
/// table in the CGU's `__llvm_covmap` section. /// table in the CGU's `__llvm_covmap` section.
file_id: u32, pub(crate) file_id: u32,
/// 1-based starting line of the source code span. /// 1-based starting line of the source code span.
start_line: u32, pub(crate) start_line: u32,
/// 1-based starting column of the source code span. /// 1-based starting column of the source code span.
start_col: u32, pub(crate) start_col: u32,
/// 1-based ending line of the source code span. /// 1-based ending line of the source code span.
end_line: u32, pub(crate) end_line: u32,
/// 1-based ending column of the source code span. High bit must be unset. /// 1-based ending column of the source code span. High bit must be unset.
end_col: u32, pub(crate) end_col: u32,
}
impl CoverageSpan {
pub(crate) fn from_source_region(
local_file_id: LocalFileId,
code_region: &SourceRegion,
) -> Self {
let file_id = local_file_id.as_u32();
let &SourceRegion { start_line, start_col, end_line, end_col } = code_region;
// Internally, LLVM uses the high bit of `end_col` to distinguish between
// code regions and gap regions, so it can't be used by the column number.
assert!(end_col & (1u32 << 31) == 0, "high bit of `end_col` must be unset: {end_col:#X}");
Self { file_id, start_line, start_col, end_line, end_col }
}
} }
/// Must match the layout of `LLVMRustCoverageCodeRegion`. /// Must match the layout of `LLVMRustCoverageCodeRegion`.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
#[repr(C)] #[repr(C)]
pub(crate) struct CodeRegion { pub(crate) struct CodeRegion {
pub(crate) span: CoverageSpan, pub(crate) cov_span: CoverageSpan,
pub(crate) counter: Counter, pub(crate) counter: Counter,
} }
@ -164,7 +148,7 @@ pub(crate) struct CodeRegion {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
#[repr(C)] #[repr(C)]
pub(crate) struct BranchRegion { pub(crate) struct BranchRegion {
pub(crate) span: CoverageSpan, pub(crate) cov_span: CoverageSpan,
pub(crate) true_counter: Counter, pub(crate) true_counter: Counter,
pub(crate) false_counter: Counter, pub(crate) false_counter: Counter,
} }
@ -173,7 +157,7 @@ pub(crate) struct BranchRegion {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
#[repr(C)] #[repr(C)]
pub(crate) struct MCDCBranchRegion { pub(crate) struct MCDCBranchRegion {
pub(crate) span: CoverageSpan, pub(crate) cov_span: CoverageSpan,
pub(crate) true_counter: Counter, pub(crate) true_counter: Counter,
pub(crate) false_counter: Counter, pub(crate) false_counter: Counter,
pub(crate) mcdc_branch_params: mcdc::BranchParameters, pub(crate) mcdc_branch_params: mcdc::BranchParameters,
@ -183,6 +167,6 @@ pub(crate) struct MCDCBranchRegion {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
#[repr(C)] #[repr(C)]
pub(crate) struct MCDCDecisionRegion { pub(crate) struct MCDCDecisionRegion {
pub(crate) span: CoverageSpan, pub(crate) cov_span: CoverageSpan,
pub(crate) mcdc_decision_params: mcdc::DecisionParameters, pub(crate) mcdc_decision_params: mcdc::DecisionParameters,
} }

14
compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
View file

@ -3,9 +3,9 @@ use rustc_data_structures::fx::FxIndexSet;
use rustc_index::bit_set::BitSet; use rustc_index::bit_set::BitSet;
use rustc_middle::mir::coverage::{ use rustc_middle::mir::coverage::{
CounterId, CovTerm, Expression, ExpressionId, FunctionCoverageInfo, Mapping, MappingKind, Op, CounterId, CovTerm, Expression, ExpressionId, FunctionCoverageInfo, Mapping, MappingKind, Op,
SourceRegion,
}; };
use rustc_middle::ty::Instance; use rustc_middle::ty::Instance;
use rustc_span::Span;
use tracing::{debug, instrument}; use tracing::{debug, instrument};
use crate::coverageinfo::ffi::{Counter, CounterExpression, ExprKind}; use crate::coverageinfo::ffi::{Counter, CounterExpression, ExprKind};
@ -220,16 +220,16 @@ impl<'tcx> FunctionCoverage<'tcx> {
}) })
} }
/// Converts this function's coverage mappings into an intermediate form /// Yields all this function's coverage mappings, after simplifying away
/// that will be used by `mapgen` when preparing for FFI. /// unused counters and counter expressions.
pub(crate) fn counter_regions( pub(crate) fn mapping_spans(
&self, &self,
) -> impl Iterator<Item = (MappingKind, &SourceRegion)> + ExactSizeIterator { ) -> impl Iterator<Item = (MappingKind, Span)> + ExactSizeIterator + Captures<'_> {
self.function_coverage_info.mappings.iter().map(move |mapping| { self.function_coverage_info.mappings.iter().map(move |mapping| {
let Mapping { kind, source_region } = mapping; let &Mapping { ref kind, span } = mapping;
let kind = let kind =
kind.map_terms(|term| if self.is_zero_term(term) { CovTerm::Zero } else { term }); kind.map_terms(|term| if self.is_zero_term(term) { CovTerm::Zero } else { term });
(kind, source_region) (kind, span)
}) })
} }

127
compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
View file

@ -1,12 +1,14 @@
mod spans;
use std::ffi::CString; use std::ffi::CString;
use std::iter; use std::sync::Arc;
use itertools::Itertools as _; use itertools::Itertools as _;
use rustc_abi::Align; use rustc_abi::Align;
use rustc_codegen_ssa::traits::{ use rustc_codegen_ssa::traits::{
BaseTypeCodegenMethods, ConstCodegenMethods, StaticCodegenMethods, BaseTypeCodegenMethods, ConstCodegenMethods, StaticCodegenMethods,
}; };
use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet}; use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_index::IndexVec; use rustc_index::IndexVec;
use rustc_middle::mir::coverage::MappingKind; use rustc_middle::mir::coverage::MappingKind;
@ -15,7 +17,7 @@ use rustc_middle::{bug, mir};
use rustc_session::RemapFileNameExt; use rustc_session::RemapFileNameExt;
use rustc_session::config::RemapPathScopeComponents; use rustc_session::config::RemapPathScopeComponents;
use rustc_span::def_id::DefIdSet; use rustc_span::def_id::DefIdSet;
use rustc_span::{Span, Symbol}; use rustc_span::{SourceFile, StableSourceFileId};
use rustc_target::spec::HasTargetSpec; use rustc_target::spec::HasTargetSpec;
use tracing::debug; use tracing::debug;
@ -72,11 +74,11 @@ pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
.map(|(instance, function_coverage)| (instance, function_coverage.into_finished())) .map(|(instance, function_coverage)| (instance, function_coverage.into_finished()))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let all_file_names = function_coverage_entries let all_files = function_coverage_entries
.iter() .iter()
.map(|(_, fn_cov)| fn_cov.function_coverage_info.body_span) .map(|(_, fn_cov)| fn_cov.function_coverage_info.body_span)
.map(|span| span_file_name(tcx, span)); .map(|span| tcx.sess.source_map().lookup_source_file(span.lo()));
let global_file_table = GlobalFileTable::new(all_file_names); let global_file_table = GlobalFileTable::new(all_files);
// Encode all filenames referenced by coverage mappings in this CGU. // Encode all filenames referenced by coverage mappings in this CGU.
let filenames_buffer = global_file_table.make_filenames_buffer(tcx); let filenames_buffer = global_file_table.make_filenames_buffer(tcx);
@ -103,15 +105,8 @@ pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
encode_mappings_for_function(tcx, &global_file_table, &function_coverage); encode_mappings_for_function(tcx, &global_file_table, &function_coverage);
if coverage_mapping_buffer.is_empty() { if coverage_mapping_buffer.is_empty() {
if function_coverage.is_used() { debug!("function has no mappings to embed; skipping");
bug!( continue;
"A used function should have had coverage mapping data but did not: {}",
mangled_function_name
);
} else {
debug!("unused function had no coverage mapping data: {}", mangled_function_name);
continue;
}
} }
if !is_used { if !is_used {
@ -148,29 +143,34 @@ pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
} }
} }
/// Maps "global" (per-CGU) file ID numbers to their underlying filenames. /// Maps "global" (per-CGU) file ID numbers to their underlying source files.
struct GlobalFileTable { struct GlobalFileTable {
/// This "raw" table doesn't include the working dir, so a filename's /// This "raw" table doesn't include the working dir, so a file's
/// global ID is its index in this set **plus one**. /// global ID is its index in this set **plus one**.
raw_file_table: FxIndexSet<Symbol>, raw_file_table: FxIndexMap<StableSourceFileId, Arc<SourceFile>>,
} }
impl GlobalFileTable { impl GlobalFileTable {
fn new(all_file_names: impl IntoIterator<Item = Symbol>) -> Self { fn new(all_files: impl IntoIterator<Item = Arc<SourceFile>>) -> Self {
// Collect all of the filenames into a set. Filenames usually come in // Collect all of the files into a set. Files usually come in contiguous
// contiguous runs, so we can dedup adjacent ones to save work. // runs, so we can dedup adjacent ones to save work.
let mut raw_file_table = all_file_names.into_iter().dedup().collect::<FxIndexSet<Symbol>>(); let mut raw_file_table = all_files
.into_iter()
.dedup_by(|a, b| a.stable_id == b.stable_id)
.map(|f| (f.stable_id, f))
.collect::<FxIndexMap<StableSourceFileId, Arc<SourceFile>>>();
// Sort the file table by its actual string values, not the arbitrary // Sort the file table by its underlying filenames.
// ordering of its symbols. raw_file_table.sort_unstable_by(|_, a, _, b| {
raw_file_table.sort_unstable_by(|a, b| a.as_str().cmp(b.as_str())); Ord::cmp(&a.name, &b.name).then_with(|| Ord::cmp(&a.stable_id, &b.stable_id))
});
Self { raw_file_table } Self { raw_file_table }
} }
fn global_file_id_for_file_name(&self, file_name: Symbol) -> GlobalFileId { fn global_file_id_for_file(&self, file: &SourceFile) -> GlobalFileId {
let raw_id = self.raw_file_table.get_index_of(&file_name).unwrap_or_else(|| { let raw_id = self.raw_file_table.get_index_of(&file.stable_id).unwrap_or_else(|| {
bug!("file name not found in prepared global file table: {file_name}"); bug!("file not found in prepared global file table: {:?}", file.name);
}); });
// The raw file table doesn't include an entry for the working dir // The raw file table doesn't include an entry for the working dir
// (which has ID 0), so add 1 to get the correct ID. // (which has ID 0), so add 1 to get the correct ID.
@ -178,24 +178,27 @@ impl GlobalFileTable {
} }
fn make_filenames_buffer(&self, tcx: TyCtxt<'_>) -> Vec<u8> { fn make_filenames_buffer(&self, tcx: TyCtxt<'_>) -> Vec<u8> {
let mut table = Vec::with_capacity(self.raw_file_table.len() + 1);
// LLVM Coverage Mapping Format version 6 (zero-based encoded as 5) // LLVM Coverage Mapping Format version 6 (zero-based encoded as 5)
// requires setting the first filename to the compilation directory. // requires setting the first filename to the compilation directory.
// Since rustc generates coverage maps with relative paths, the // Since rustc generates coverage maps with relative paths, the
// compilation directory can be combined with the relative paths // compilation directory can be combined with the relative paths
// to get absolute paths, if needed. // to get absolute paths, if needed.
use rustc_session::RemapFileNameExt; table.push(
use rustc_session::config::RemapPathScopeComponents; tcx.sess
let working_dir: &str = &tcx .opts
.sess .working_dir
.opts .for_scope(tcx.sess, RemapPathScopeComponents::MACRO)
.working_dir .to_string_lossy(),
.for_scope(tcx.sess, RemapPathScopeComponents::MACRO) );
.to_string_lossy();
// Insert the working dir at index 0, before the other filenames. // Add the regular entries after the base directory.
let filenames = table.extend(self.raw_file_table.values().map(|file| {
iter::once(working_dir).chain(self.raw_file_table.iter().map(Symbol::as_str)); file.name.for_scope(tcx.sess, RemapPathScopeComponents::MACRO).to_string_lossy()
llvm_cov::write_filenames_to_buffer(filenames) }));
llvm_cov::write_filenames_to_buffer(table.iter().map(|f| f.as_ref()))
} }
} }
@ -208,7 +211,7 @@ rustc_index::newtype_index! {
/// An index into a function's list of global file IDs. That underlying list /// An index into a function's list of global file IDs. That underlying list
/// of local-to-global mappings will be embedded in the function's record in /// of local-to-global mappings will be embedded in the function's record in
/// the `__llvm_covfun` linker section. /// the `__llvm_covfun` linker section.
pub(crate) struct LocalFileId {} struct LocalFileId {}
} }
/// Holds a mapping from "local" (per-function) file IDs to "global" (per-CGU) /// Holds a mapping from "local" (per-function) file IDs to "global" (per-CGU)
@ -234,13 +237,6 @@ impl VirtualFileMapping {
} }
} }
fn span_file_name(tcx: TyCtxt<'_>, span: Span) -> Symbol {
let source_file = tcx.sess.source_map().lookup_source_file(span.lo());
let name =
source_file.name.for_scope(tcx.sess, RemapPathScopeComponents::MACRO).to_string_lossy();
Symbol::intern(&name)
}
/// Using the expressions and counter regions collected for a single function, /// Using the expressions and counter regions collected for a single function,
/// generate the variable-sized payload of its corresponding `__llvm_covfun` /// generate the variable-sized payload of its corresponding `__llvm_covfun`
/// entry. The payload is returned as a vector of bytes. /// entry. The payload is returned as a vector of bytes.
@ -251,11 +247,13 @@ fn encode_mappings_for_function(
global_file_table: &GlobalFileTable, global_file_table: &GlobalFileTable,
function_coverage: &FunctionCoverage<'_>, function_coverage: &FunctionCoverage<'_>,
) -> Vec<u8> { ) -> Vec<u8> {
let counter_regions = function_coverage.counter_regions(); let mapping_spans = function_coverage.mapping_spans();
if counter_regions.is_empty() { if mapping_spans.is_empty() {
return Vec::new(); return Vec::new();
} }
let fn_cov_info = function_coverage.function_coverage_info;
let expressions = function_coverage.counter_expressions().collect::<Vec<_>>(); let expressions = function_coverage.counter_expressions().collect::<Vec<_>>();
let mut virtual_file_mapping = VirtualFileMapping::default(); let mut virtual_file_mapping = VirtualFileMapping::default();
@ -265,34 +263,39 @@ fn encode_mappings_for_function(
let mut mcdc_decision_regions = vec![]; let mut mcdc_decision_regions = vec![];
// Currently a function's mappings must all be in the same file as its body span. // Currently a function's mappings must all be in the same file as its body span.
let file_name = span_file_name(tcx, function_coverage.function_coverage_info.body_span); let source_map = tcx.sess.source_map();
let source_file = source_map.lookup_source_file(fn_cov_info.body_span.lo());
// Look up the global file ID for that filename. // Look up the global file ID for that file.
let global_file_id = global_file_table.global_file_id_for_file_name(file_name); let global_file_id = global_file_table.global_file_id_for_file(&source_file);
// Associate that global file ID with a local file ID for this function. // Associate that global file ID with a local file ID for this function.
let local_file_id = virtual_file_mapping.local_id_for_global(global_file_id); let local_file_id = virtual_file_mapping.local_id_for_global(global_file_id);
debug!(" file id: {local_file_id:?} => {global_file_id:?} = '{file_name:?}'");
// For each counter/region pair in this function+file, convert it to a let make_cov_span = |span| {
spans::make_coverage_span(local_file_id, source_map, fn_cov_info, &source_file, span)
};
// For each coverage mapping span in this function+file, convert it to a
// form suitable for FFI. // form suitable for FFI.
for (mapping_kind, region) in counter_regions { for (mapping_kind, span) in mapping_spans {
debug!("Adding counter {mapping_kind:?} to map for {region:?}"); debug!("Adding counter {mapping_kind:?} to map for {span:?}");
let span = ffi::CoverageSpan::from_source_region(local_file_id, region); let Some(cov_span) = make_cov_span(span) else { continue };
match mapping_kind { match mapping_kind {
MappingKind::Code(term) => { MappingKind::Code(term) => {
code_regions.push(ffi::CodeRegion { span, counter: ffi::Counter::from_term(term) }); code_regions
.push(ffi::CodeRegion { cov_span, counter: ffi::Counter::from_term(term) });
} }
MappingKind::Branch { true_term, false_term } => { MappingKind::Branch { true_term, false_term } => {
branch_regions.push(ffi::BranchRegion { branch_regions.push(ffi::BranchRegion {
span, cov_span,
true_counter: ffi::Counter::from_term(true_term), true_counter: ffi::Counter::from_term(true_term),
false_counter: ffi::Counter::from_term(false_term), false_counter: ffi::Counter::from_term(false_term),
}); });
} }
MappingKind::MCDCBranch { true_term, false_term, mcdc_params } => { MappingKind::MCDCBranch { true_term, false_term, mcdc_params } => {
mcdc_branch_regions.push(ffi::MCDCBranchRegion { mcdc_branch_regions.push(ffi::MCDCBranchRegion {
span, cov_span,
true_counter: ffi::Counter::from_term(true_term), true_counter: ffi::Counter::from_term(true_term),
false_counter: ffi::Counter::from_term(false_term), false_counter: ffi::Counter::from_term(false_term),
mcdc_branch_params: ffi::mcdc::BranchParameters::from(mcdc_params), mcdc_branch_params: ffi::mcdc::BranchParameters::from(mcdc_params),
@ -300,7 +303,7 @@ fn encode_mappings_for_function(
} }
MappingKind::MCDCDecision(mcdc_decision_params) => { MappingKind::MCDCDecision(mcdc_decision_params) => {
mcdc_decision_regions.push(ffi::MCDCDecisionRegion { mcdc_decision_regions.push(ffi::MCDCDecisionRegion {
span, cov_span,
mcdc_decision_params: ffi::mcdc::DecisionParameters::from(mcdc_decision_params), mcdc_decision_params: ffi::mcdc::DecisionParameters::from(mcdc_decision_params),
}); });
} }

124
compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/spans.rs Normal file
View file

@ -0,0 +1,124 @@
use rustc_middle::mir::coverage::FunctionCoverageInfo;
use rustc_span::source_map::SourceMap;
use rustc_span::{BytePos, Pos, SourceFile, Span};
use tracing::debug;
use crate::coverageinfo::ffi;
use crate::coverageinfo::mapgen::LocalFileId;
/// Converts the span into its start line and column, and end line and column.
///
/// Line numbers and column numbers are 1-based. Unlike most column numbers emitted by
/// the compiler, these column numbers are denoted in **bytes**, because that's what
/// LLVM's `llvm-cov` tool expects to see in coverage maps.
///
/// Returns `None` if the conversion failed for some reason. This shouldn't happen,
/// but it's hard to rule out entirely (especially in the presence of complex macros
/// or other expansions), and if it does happen then skipping a span or function is
/// better than an ICE or `llvm-cov` failure that the user might have no way to avoid.
pub(crate) fn make_coverage_span(
file_id: LocalFileId,
source_map: &SourceMap,
fn_cov_info: &FunctionCoverageInfo,
file: &SourceFile,
span: Span,
) -> Option<ffi::CoverageSpan> {
let span = ensure_non_empty_span(source_map, fn_cov_info, span)?;
let lo = span.lo();
let hi = span.hi();
// Column numbers need to be in bytes, so we can't use the more convenient
// `SourceMap` methods for looking up file coordinates.
let line_and_byte_column = |pos: BytePos| -> Option<(usize, usize)> {
let rpos = file.relative_position(pos);
let line_index = file.lookup_line(rpos)?;
let line_start = file.lines()[line_index];
// Line numbers and column numbers are 1-based, so add 1 to each.
Some((line_index + 1, (rpos - line_start).to_usize() + 1))
};
let (mut start_line, start_col) = line_and_byte_column(lo)?;
let (mut end_line, end_col) = line_and_byte_column(hi)?;
// Apply an offset so that code in doctests has correct line numbers.
// FIXME(#79417): Currently we have no way to offset doctest _columns_.
start_line = source_map.doctest_offset_line(&file.name, start_line);
end_line = source_map.doctest_offset_line(&file.name, end_line);
check_coverage_span(ffi::CoverageSpan {
file_id: file_id.as_u32(),
start_line: start_line as u32,
start_col: start_col as u32,
end_line: end_line as u32,
end_col: end_col as u32,
})
}
fn ensure_non_empty_span(
source_map: &SourceMap,
fn_cov_info: &FunctionCoverageInfo,
span: Span,
) -> Option<Span> {
if !span.is_empty() {
return Some(span);
}
let lo = span.lo();
let hi = span.hi();
// The span is empty, so try to expand it to cover an adjacent '{' or '}',
// but only within the bounds of the body span.
let try_next = hi < fn_cov_info.body_span.hi();
let try_prev = fn_cov_info.body_span.lo() < lo;
if !(try_next || try_prev) {
return None;
}
source_map
.span_to_source(span, |src, start, end| try {
// We're only checking for specific ASCII characters, so we don't
// have to worry about multi-byte code points.
if try_next && src.as_bytes()[end] == b'{' {
Some(span.with_hi(hi + BytePos(1)))
} else if try_prev && src.as_bytes()[start - 1] == b'}' {
Some(span.with_lo(lo - BytePos(1)))
} else {
None
}
})
.ok()?
}
/// If `llvm-cov` sees a source region that is improperly ordered (end < start),
/// it will immediately exit with a fatal error. To prevent that from happening,
/// discard regions that are improperly ordered, or might be interpreted in a
/// way that makes them improperly ordered.
fn check_coverage_span(cov_span: ffi::CoverageSpan) -> Option<ffi::CoverageSpan> {
let ffi::CoverageSpan { file_id: _, start_line, start_col, end_line, end_col } = cov_span;
// Line/column coordinates are supposed to be 1-based. If we ever emit
// coordinates of 0, `llvm-cov` might misinterpret them.
let all_nonzero = [start_line, start_col, end_line, end_col].into_iter().all(|x| x != 0);
// Coverage mappings use the high bit of `end_col` to indicate that a
// region is actually a "gap" region, so make sure it's unset.
let end_col_has_high_bit_unset = (end_col & (1 << 31)) == 0;
// If a region is improperly ordered (end < start), `llvm-cov` will exit
// with a fatal error, which is inconvenient for users and hard to debug.
let is_ordered = (start_line, start_col) <= (end_line, end_col);
if all_nonzero && end_col_has_high_bit_unset && is_ordered {
Some(cov_span)
} else {
debug!(
?cov_span,
?all_nonzero,
?end_col_has_high_bit_unset,
?is_ordered,
"Skipping source region that would be misinterpreted or rejected by LLVM"
);
// If this happens in a debug build, ICE to make it easier to notice.
debug_assert!(false, "Improper source region: {cov_span:?}");
None
}
}

1
compiler/rustc_codegen_llvm/src/lib.rs
View file

@ -17,6 +17,7 @@
#![feature(iter_intersperse)] #![feature(iter_intersperse)]
#![feature(let_chains)] #![feature(let_chains)]
#![feature(rustdoc_internals)] #![feature(rustdoc_internals)]
#![feature(try_blocks)]
#![warn(unreachable_pub)] #![warn(unreachable_pub)]
// tidy-alphabetical-end // tidy-alphabetical-end

108
compiler/rustc_driver_impl/src/lib.rs
View file

@ -160,6 +160,9 @@ pub trait Callbacks {
/// Called after parsing the crate root. Submodules are not yet parsed when /// Called after parsing the crate root. Submodules are not yet parsed when
/// this callback is called. Return value instructs the compiler whether to /// this callback is called. Return value instructs the compiler whether to
/// continue the compilation afterwards (defaults to `Compilation::Continue`) /// continue the compilation afterwards (defaults to `Compilation::Continue`)
#[deprecated = "This callback will likely be removed or stop giving access \
to the TyCtxt in the future. Use either the after_expansion \
or the after_analysis callback instead."]
fn after_crate_root_parsing<'tcx>( fn after_crate_root_parsing<'tcx>(
&mut self, &mut self,
_compiler: &interface::Compiler, _compiler: &interface::Compiler,
@ -181,7 +184,7 @@ pub trait Callbacks {
fn after_analysis<'tcx>( fn after_analysis<'tcx>(
&mut self, &mut self,
_compiler: &interface::Compiler, _compiler: &interface::Compiler,
_queries: &'tcx Queries<'tcx>, _tcx: TyCtxt<'tcx>,
) -> Compilation { ) -> Compilation {
Compilation::Continue Compilation::Continue
} }
@ -335,19 +338,12 @@ fn run_compiler(
expanded_args: args, expanded_args: args,
}; };
let has_input = match make_input(&default_early_dcx, &matches.free) { let has_input = match make_input(&default_early_dcx, &matches.free)? {
Err(reported) => return Err(reported), Some(input) => {
Ok(Some(input)) => {
config.input = input; config.input = input;
true // has input: normal compilation true // has input: normal compilation
} }
Ok(None) => match matches.free.as_slice() { None => false, // no input: we will exit early
[] => false, // no input: we will exit early
[_] => panic!("make_input should have provided valid inputs"),
[fst, snd, ..] => default_early_dcx.early_fatal(format!(
"multiple input filenames provided (first two filenames are `{fst}` and `{snd}`)"
)),
},
}; };
drop(default_early_dcx); drop(default_early_dcx);
@ -405,10 +401,6 @@ fn run_compiler(
queries.global_ctxt()?.enter(|tcx| { queries.global_ctxt()?.enter(|tcx| {
tcx.ensure().early_lint_checks(()); tcx.ensure().early_lint_checks(());
pretty::print(sess, pp_mode, pretty::PrintExtra::NeedsAstMap { tcx }); pretty::print(sess, pp_mode, pretty::PrintExtra::NeedsAstMap { tcx });
Ok(())
})?;
queries.global_ctxt()?.enter(|tcx| {
passes::write_dep_info(tcx); passes::write_dep_info(tcx);
}); });
} else { } else {
@ -421,6 +413,7 @@ fn run_compiler(
return early_exit(); return early_exit();
} }
#[allow(deprecated)]
if callbacks.after_crate_root_parsing(compiler, queries) == Compilation::Stop { if callbacks.after_crate_root_parsing(compiler, queries) == Compilation::Stop {
return early_exit(); return early_exit();
} }
@ -442,25 +435,23 @@ fn run_compiler(
queries.global_ctxt()?.enter(|tcx| { queries.global_ctxt()?.enter(|tcx| {
passes::write_dep_info(tcx); passes::write_dep_info(tcx);
});
if sess.opts.output_types.contains_key(&OutputType::DepInfo) if sess.opts.output_types.contains_key(&OutputType::DepInfo)
&& sess.opts.output_types.len() == 1 && sess.opts.output_types.len() == 1
{ {
return early_exit(); return early_exit();
} }
if sess.opts.unstable_opts.no_analysis { if sess.opts.unstable_opts.no_analysis {
return early_exit(); return early_exit();
} }
queries.global_ctxt()?.enter(|tcx| tcx.analysis(()))?; tcx.analysis(())?;
if callbacks.after_analysis(compiler, queries) == Compilation::Stop { if callbacks.after_analysis(compiler, tcx) == Compilation::Stop {
return early_exit(); return early_exit();
} }
queries.global_ctxt()?.enter(|tcx| {
Ok(Some(Linker::codegen_and_build_linker(tcx, &*compiler.codegen_backend)?)) Ok(Some(Linker::codegen_and_build_linker(tcx, &*compiler.codegen_backend)?))
}) })
})?; })?;
@ -509,37 +500,40 @@ fn make_input(
early_dcx: &EarlyDiagCtxt, early_dcx: &EarlyDiagCtxt,
free_matches: &[String], free_matches: &[String],
) -> Result<Option<Input>, ErrorGuaranteed> { ) -> Result<Option<Input>, ErrorGuaranteed> {
let [input_file] = free_matches else { return Ok(None) }; match free_matches {
[] => Ok(None), // no input: we will exit early,
[ifile] if ifile == "-" => {
// read from stdin as `Input::Str`
let mut input = String::new();
if io::stdin().read_to_string(&mut input).is_err() {
// Immediately stop compilation if there was an issue reading
// the input (for example if the input stream is not UTF-8).
let reported = early_dcx
.early_err("couldn't read from stdin, as it did not contain valid UTF-8");
return Err(reported);
}
if input_file != "-" { let name = match env::var("UNSTABLE_RUSTDOC_TEST_PATH") {
// Normal `Input::File` Ok(path) => {
return Ok(Some(Input::File(PathBuf::from(input_file)))); let line = env::var("UNSTABLE_RUSTDOC_TEST_LINE").expect(
} "when UNSTABLE_RUSTDOC_TEST_PATH is set \
// read from stdin as `Input::Str`
let mut input = String::new();
if io::stdin().read_to_string(&mut input).is_err() {
// Immediately stop compilation if there was an issue reading
// the input (for example if the input stream is not UTF-8).
let reported =
early_dcx.early_err("couldn't read from stdin, as it did not contain valid UTF-8");
return Err(reported);
}
let name = match env::var("UNSTABLE_RUSTDOC_TEST_PATH") {
Ok(path) => {
let line = env::var("UNSTABLE_RUSTDOC_TEST_LINE").expect(
"when UNSTABLE_RUSTDOC_TEST_PATH is set \
UNSTABLE_RUSTDOC_TEST_LINE also needs to be set", UNSTABLE_RUSTDOC_TEST_LINE also needs to be set",
); );
let line = isize::from_str_radix(&line, 10) let line = isize::from_str_radix(&line, 10)
.expect("UNSTABLE_RUSTDOC_TEST_LINE needs to be an number"); .expect("UNSTABLE_RUSTDOC_TEST_LINE needs to be an number");
FileName::doc_test_source_code(PathBuf::from(path), line) FileName::doc_test_source_code(PathBuf::from(path), line)
} }
Err(_) => FileName::anon_source_code(&input), Err(_) => FileName::anon_source_code(&input),
}; };
Ok(Some(Input::Str { name, input })) Ok(Some(Input::Str { name, input }))
}
[ifile] => Ok(Some(Input::File(PathBuf::from(ifile)))),
[ifile1, ifile2, ..] => early_dcx.early_fatal(format!(
"multiple input filenames provided (first two filenames are `{}` and `{}`)",
ifile1, ifile2
)),
}
} }
/// Whether to stop or continue compilation. /// Whether to stop or continue compilation.

8
compiler/rustc_hir_typeck/src/expr.rs
View file

@ -68,7 +68,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// While we don't allow *arbitrary* coercions here, we *do* allow // While we don't allow *arbitrary* coercions here, we *do* allow
// coercions from ! to `expected`. // coercions from ! to `expected`.
if ty.is_never() && self.expr_guaranteed_to_constitute_read_for_never(expr) { if self.try_structurally_resolve_type(expr.span, ty).is_never()
&& self.expr_guaranteed_to_constitute_read_for_never(expr)
{
if let Some(_) = self.typeck_results.borrow().adjustments().get(expr.hir_id) { if let Some(_) = self.typeck_results.borrow().adjustments().get(expr.hir_id) {
let reported = self.dcx().span_delayed_bug( let reported = self.dcx().span_delayed_bug(
expr.span, expr.span,
@ -274,7 +276,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// unless it's a place expression that isn't being read from, in which case // unless it's a place expression that isn't being read from, in which case
// diverging would be unsound since we may never actually read the `!`. // diverging would be unsound since we may never actually read the `!`.
// e.g. `let _ = *never_ptr;` with `never_ptr: *const !`. // e.g. `let _ = *never_ptr;` with `never_ptr: *const !`.
if ty.is_never() && self.expr_guaranteed_to_constitute_read_for_never(expr) { if self.try_structurally_resolve_type(expr.span, ty).is_never()
&& self.expr_guaranteed_to_constitute_read_for_never(expr)
{
self.diverges.set(self.diverges.get() | Diverges::always(expr.span)); self.diverges.set(self.diverges.get() | Diverges::always(expr.span));
} }

9
compiler/rustc_hir_typeck/src/upvar.rs
View file

@ -1802,7 +1802,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let mut is_mutbl = bm.1; let mut is_mutbl = bm.1;
for pointer_ty in place.deref_tys() { for pointer_ty in place.deref_tys() {
match pointer_ty.kind() { match self.structurally_resolve_type(self.tcx.hir().span(var_hir_id), pointer_ty).kind()
{
// We don't capture derefs of raw ptrs // We don't capture derefs of raw ptrs
ty::RawPtr(_, _) => unreachable!(), ty::RawPtr(_, _) => unreachable!(),
@ -1816,7 +1817,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Dereferencing a box doesn't change mutability // Dereferencing a box doesn't change mutability
ty::Adt(def, ..) if def.is_box() => {} ty::Adt(def, ..) if def.is_box() => {}
unexpected_ty => bug!("deref of unexpected pointer type {:?}", unexpected_ty), unexpected_ty => span_bug!(
self.tcx.hir().span(var_hir_id),
"deref of unexpected pointer type {:?}",
unexpected_ty
),
} }
} }

11
compiler/rustc_incremental/src/lib.rs
View file

@ -16,8 +16,15 @@ mod persist;
pub use persist::{ pub use persist::{
LoadResult, copy_cgu_workproduct_to_incr_comp_cache_dir, finalize_session_directory, LoadResult, copy_cgu_workproduct_to_incr_comp_cache_dir, finalize_session_directory,
in_incr_comp_dir, in_incr_comp_dir_sess, load_query_result_cache, save_dep_graph, in_incr_comp_dir, in_incr_comp_dir_sess, load_query_result_cache, save_work_product_index,
save_work_product_index, setup_dep_graph, setup_dep_graph,
}; };
use rustc_middle::util::Providers;
#[allow(missing_docs)]
pub fn provide(providers: &mut Providers) {
providers.hooks.save_dep_graph =
|tcx| tcx.sess.time("serialize_dep_graph", || persist::save_dep_graph(tcx.tcx));
}
rustc_fluent_macro::fluent_messages! { "../messages.ftl" } rustc_fluent_macro::fluent_messages! { "../messages.ftl" }

3
compiler/rustc_incremental/src/persist/mod.rs
View file

@ -12,5 +12,6 @@ mod work_product;
pub use fs::{finalize_session_directory, in_incr_comp_dir, in_incr_comp_dir_sess}; pub use fs::{finalize_session_directory, in_incr_comp_dir, in_incr_comp_dir_sess};
pub use load::{LoadResult, load_query_result_cache, setup_dep_graph}; pub use load::{LoadResult, load_query_result_cache, setup_dep_graph};
pub use save::{save_dep_graph, save_work_product_index}; pub(crate) use save::save_dep_graph;
pub use save::save_work_product_index;
pub use work_product::copy_cgu_workproduct_to_incr_comp_cache_dir; pub use work_product::copy_cgu_workproduct_to_incr_comp_cache_dir;

2
compiler/rustc_incremental/src/persist/save.rs
View file

@ -25,7 +25,7 @@ use crate::errors;
/// ///
/// This function should only run after all queries have completed. /// This function should only run after all queries have completed.
/// Trying to execute a query afterwards would attempt to read the result cache we just dropped. /// Trying to execute a query afterwards would attempt to read the result cache we just dropped.
pub fn save_dep_graph(tcx: TyCtxt<'_>) { pub(crate) fn save_dep_graph(tcx: TyCtxt<'_>) {
debug!("save_dep_graph()"); debug!("save_dep_graph()");
tcx.dep_graph.with_ignore(|| { tcx.dep_graph.with_ignore(|| {
let sess = tcx.sess; let sess = tcx.sess;

2
compiler/rustc_interface/src/passes.rs
View file

@ -689,10 +689,12 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
rustc_const_eval::provide(providers); rustc_const_eval::provide(providers);
rustc_middle::hir::provide(providers); rustc_middle::hir::provide(providers);
rustc_borrowck::provide(providers); rustc_borrowck::provide(providers);
rustc_incremental::provide(providers);
rustc_mir_build::provide(providers); rustc_mir_build::provide(providers);
rustc_mir_transform::provide(providers); rustc_mir_transform::provide(providers);
rustc_monomorphize::provide(providers); rustc_monomorphize::provide(providers);
rustc_privacy::provide(providers); rustc_privacy::provide(providers);
rustc_query_impl::provide(providers);
rustc_resolve::provide(providers); rustc_resolve::provide(providers);
rustc_hir_analysis::provide(providers); rustc_hir_analysis::provide(providers);
rustc_hir_typeck::provide(providers); rustc_hir_typeck::provide(providers);

32
compiler/rustc_interface/src/queries.rs
View file

@ -12,13 +12,12 @@ use rustc_hir::def_id::LOCAL_CRATE;
use rustc_middle::arena::Arena; use rustc_middle::arena::Arena;
use rustc_middle::dep_graph::DepGraph; use rustc_middle::dep_graph::DepGraph;
use rustc_middle::ty::{GlobalCtxt, TyCtxt}; use rustc_middle::ty::{GlobalCtxt, TyCtxt};
use rustc_serialize::opaque::FileEncodeResult;
use rustc_session::Session; use rustc_session::Session;
use rustc_session::config::{self, OutputFilenames, OutputType}; use rustc_session::config::{self, OutputFilenames, OutputType};
use crate::errors::FailedWritingFile; use crate::errors::FailedWritingFile;
use crate::interface::{Compiler, Result}; use crate::interface::{Compiler, Result};
use crate::{errors, passes}; use crate::passes;
/// Represent the result of a query. /// Represent the result of a query.
/// ///
@ -62,7 +61,7 @@ impl<'a, T> std::ops::DerefMut for QueryResult<'a, T> {
impl<'a, 'tcx> QueryResult<'a, &'tcx GlobalCtxt<'tcx>> { impl<'a, 'tcx> QueryResult<'a, &'tcx GlobalCtxt<'tcx>> {
pub fn enter<T>(&mut self, f: impl FnOnce(TyCtxt<'tcx>) -> T) -> T { pub fn enter<T>(&mut self, f: impl FnOnce(TyCtxt<'tcx>) -> T) -> T {
(*self.0).get_mut().enter(f) (*self.0).borrow().enter(f)
} }
} }
@ -90,8 +89,10 @@ impl<'tcx> Queries<'tcx> {
} }
} }
pub fn finish(&self) -> FileEncodeResult { pub fn finish(&'tcx self) {
if let Some(gcx) = self.gcx_cell.get() { gcx.finish() } else { Ok(0) } if let Some(gcx) = self.gcx_cell.get() {
gcx.finish();
}
} }
pub fn parse(&self) -> Result<QueryResult<'_, ast::Crate>> { pub fn parse(&self) -> Result<QueryResult<'_, ast::Crate>> {
@ -209,29 +210,10 @@ impl Compiler {
let queries = Queries::new(self); let queries = Queries::new(self);
let ret = f(&queries); let ret = f(&queries);
// NOTE: intentionally does not compute the global context if it hasn't been built yet,
// since that likely means there was a parse error.
if let Some(Ok(gcx)) = &mut *queries.gcx.result.borrow_mut() {
let gcx = gcx.get_mut();
// We assume that no queries are run past here. If there are new queries
// after this point, they'll show up as "<unknown>" in self-profiling data.
{
let _prof_timer =
queries.compiler.sess.prof.generic_activity("self_profile_alloc_query_strings");
gcx.enter(rustc_query_impl::alloc_self_profile_query_strings);
}
self.sess.time("serialize_dep_graph", || gcx.enter(rustc_incremental::save_dep_graph));
gcx.enter(rustc_query_impl::query_key_hash_verify_all);
}
// The timer's lifetime spans the dropping of `queries`, which contains // The timer's lifetime spans the dropping of `queries`, which contains
// the global context. // the global context.
_timer = self.sess.timer("free_global_ctxt"); _timer = self.sess.timer("free_global_ctxt");
if let Err((path, error)) = queries.finish() { queries.finish();
self.sess.dcx().emit_fatal(errors::FailedWritingFile { path: &path, error });
}
ret ret
} }

3
compiler/rustc_middle/messages.ftl
View file

@ -73,6 +73,9 @@ middle_drop_check_overflow =
middle_erroneous_constant = erroneous constant encountered middle_erroneous_constant = erroneous constant encountered
middle_failed_writing_file =
failed to write file {$path}: {$error}"
middle_layout_references_error = middle_layout_references_error =
the type has an unknown layout the type has an unknown layout

11
compiler/rustc_middle/src/error.rs
View file

@ -1,5 +1,5 @@
use std::fmt; use std::path::{Path, PathBuf};
use std::path::PathBuf; use std::{fmt, io};
use rustc_errors::codes::*; use rustc_errors::codes::*;
use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage}; use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage};
@ -18,6 +18,13 @@ pub struct DropCheckOverflow<'tcx> {
pub overflow_ty: Ty<'tcx>, pub overflow_ty: Ty<'tcx>,
} }
#[derive(Diagnostic)]
#[diag(middle_failed_writing_file)]
pub struct FailedWritingFile<'a> {
pub path: &'a Path,
pub error: io::Error,
}
#[derive(Diagnostic)] #[derive(Diagnostic)]
#[diag(middle_opaque_hidden_type_mismatch)] #[diag(middle_opaque_hidden_type_mismatch)]
pub struct OpaqueHiddenTypeMismatch<'tcx> { pub struct OpaqueHiddenTypeMismatch<'tcx> {

13
compiler/rustc_middle/src/hooks/mod.rs
View file

@ -108,6 +108,19 @@ declare_hooks! {
/// Returns `true` if we should codegen an instance in the local crate, or returns `false` if we /// Returns `true` if we should codegen an instance in the local crate, or returns `false` if we
/// can just link to the upstream crate and therefore don't need a mono item. /// can just link to the upstream crate and therefore don't need a mono item.
hook should_codegen_locally(instance: crate::ty::Instance<'tcx>) -> bool; hook should_codegen_locally(instance: crate::ty::Instance<'tcx>) -> bool;
hook alloc_self_profile_query_strings() -> ();
/// Saves and writes the DepGraph to the file system.
///
/// This function saves both the dep-graph and the query result cache,
/// and drops the result cache.
///
/// This function should only run after all queries have completed.
/// Trying to execute a query afterwards would attempt to read the result cache we just dropped.
hook save_dep_graph() -> ();
hook query_key_hash_verify_all() -> ();
} }
#[cold] #[cold]

18
compiler/rustc_middle/src/mir/coverage.rs
View file

@ -155,22 +155,6 @@ impl Debug for CoverageKind {
} }
} }
#[derive(Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq, Eq, PartialOrd, Ord)]
#[derive(TypeFoldable, TypeVisitable)]
pub struct SourceRegion {
pub start_line: u32,
pub start_col: u32,
pub end_line: u32,
pub end_col: u32,
}
impl Debug for SourceRegion {
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
let &Self { start_line, start_col, end_line, end_col } = self;
write!(fmt, "{start_line}:{start_col} - {end_line}:{end_col}")
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)] #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)]
#[derive(TyEncodable, TyDecodable, TypeFoldable, TypeVisitable)] #[derive(TyEncodable, TyDecodable, TypeFoldable, TypeVisitable)]
pub enum Op { pub enum Op {
@ -232,7 +216,7 @@ impl MappingKind {
#[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)] #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
pub struct Mapping { pub struct Mapping {
pub kind: MappingKind, pub kind: MappingKind,
pub source_region: SourceRegion, pub span: Span,
} }
/// Stores per-function coverage information attached to a `mir::Body`, /// Stores per-function coverage information attached to a `mir::Body`,

4
compiler/rustc_middle/src/mir/pretty.rs
View file

@ -603,8 +603,8 @@ fn write_function_coverage_info(
for (id, expression) in expressions.iter_enumerated() { for (id, expression) in expressions.iter_enumerated() {
writeln!(w, "{INDENT}coverage {id:?} => {expression:?};")?; writeln!(w, "{INDENT}coverage {id:?} => {expression:?};")?;
} }
for coverage::Mapping { kind, source_region } in mappings { for coverage::Mapping { kind, span } in mappings {
writeln!(w, "{INDENT}coverage {kind:?} => {source_region:?};")?; writeln!(w, "{INDENT}coverage {kind:?} => {span:?};")?;
} }
writeln!(w)?; writeln!(w)?;

13
compiler/rustc_middle/src/ty/context.rs
View file

@ -1371,8 +1371,17 @@ impl<'tcx> GlobalCtxt<'tcx> {
tls::enter_context(&icx, || f(icx.tcx)) tls::enter_context(&icx, || f(icx.tcx))
} }
pub fn finish(&self) -> FileEncodeResult { pub fn finish(&'tcx self) {
self.dep_graph.finish_encoding() // We assume that no queries are run past here. If there are new queries
// after this point, they'll show up as "<unknown>" in self-profiling data.
self.enter(|tcx| tcx.alloc_self_profile_query_strings());
self.enter(|tcx| tcx.save_dep_graph());
self.enter(|tcx| tcx.query_key_hash_verify_all());
if let Err((path, error)) = self.dep_graph.finish_encoding() {
self.sess.dcx().emit_fatal(crate::error::FailedWritingFile { path: &path, error });
}
} }
} }

166
compiler/rustc_mir_transform/src/coverage/mod.rs
View file

@ -13,16 +13,15 @@ use rustc_hir::intravisit::{Visitor, walk_expr};
use rustc_middle::hir::map::Map; use rustc_middle::hir::map::Map;
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
use rustc_middle::mir::coverage::{ use rustc_middle::mir::coverage::{
CoverageKind, DecisionInfo, FunctionCoverageInfo, Mapping, MappingKind, SourceRegion, CoverageKind, DecisionInfo, FunctionCoverageInfo, Mapping, MappingKind,
}; };
use rustc_middle::mir::{ use rustc_middle::mir::{
self, BasicBlock, BasicBlockData, SourceInfo, Statement, StatementKind, Terminator, self, BasicBlock, BasicBlockData, SourceInfo, Statement, StatementKind, Terminator,
TerminatorKind, TerminatorKind,
}; };
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_span::Span;
use rustc_span::def_id::LocalDefId; use rustc_span::def_id::LocalDefId;
use rustc_span::source_map::SourceMap;
use rustc_span::{BytePos, Pos, SourceFile, Span};
use tracing::{debug, debug_span, trace}; use tracing::{debug, debug_span, trace};
use crate::coverage::counters::{CounterIncrementSite, CoverageCounters}; use crate::coverage::counters::{CounterIncrementSite, CoverageCounters};
@ -97,7 +96,7 @@ fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir:
let coverage_counters = let coverage_counters =
CoverageCounters::make_bcb_counters(&basic_coverage_blocks, &bcbs_with_counter_mappings); CoverageCounters::make_bcb_counters(&basic_coverage_blocks, &bcbs_with_counter_mappings);
let mappings = create_mappings(tcx, &hir_info, &extracted_mappings, &coverage_counters); let mappings = create_mappings(&extracted_mappings, &coverage_counters);
if mappings.is_empty() { if mappings.is_empty() {
// No spans could be converted into valid mappings, so skip this function. // No spans could be converted into valid mappings, so skip this function.
debug!("no spans could be converted into valid mappings; skipping"); debug!("no spans could be converted into valid mappings; skipping");
@ -136,18 +135,12 @@ fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir:
/// ///
/// Precondition: All BCBs corresponding to those spans have been given /// Precondition: All BCBs corresponding to those spans have been given
/// coverage counters. /// coverage counters.
fn create_mappings<'tcx>( fn create_mappings(
tcx: TyCtxt<'tcx>,
hir_info: &ExtractedHirInfo,
extracted_mappings: &ExtractedMappings, extracted_mappings: &ExtractedMappings,
coverage_counters: &CoverageCounters, coverage_counters: &CoverageCounters,
) -> Vec<Mapping> { ) -> Vec<Mapping> {
let source_map = tcx.sess.source_map();
let file = source_map.lookup_source_file(hir_info.body_span.lo());
let term_for_bcb = let term_for_bcb =
|bcb| coverage_counters.term_for_bcb(bcb).expect("all BCBs with spans were given counters"); |bcb| coverage_counters.term_for_bcb(bcb).expect("all BCBs with spans were given counters");
let region_for_span = |span: Span| make_source_region(source_map, hir_info, &file, span);
// Fully destructure the mappings struct to make sure we don't miss any kinds. // Fully destructure the mappings struct to make sure we don't miss any kinds.
let ExtractedMappings { let ExtractedMappings {
@ -160,22 +153,20 @@ fn create_mappings<'tcx>(
} = extracted_mappings; } = extracted_mappings;
let mut mappings = Vec::new(); let mut mappings = Vec::new();
mappings.extend(code_mappings.iter().filter_map( mappings.extend(code_mappings.iter().map(
// Ordinary code mappings are the simplest kind. // Ordinary code mappings are the simplest kind.
|&mappings::CodeMapping { span, bcb }| { |&mappings::CodeMapping { span, bcb }| {
let source_region = region_for_span(span)?;
let kind = MappingKind::Code(term_for_bcb(bcb)); let kind = MappingKind::Code(term_for_bcb(bcb));
Some(Mapping { kind, source_region }) Mapping { kind, span }
}, },
)); ));
mappings.extend(branch_pairs.iter().filter_map( mappings.extend(branch_pairs.iter().map(
|&mappings::BranchPair { span, true_bcb, false_bcb }| { |&mappings::BranchPair { span, true_bcb, false_bcb }| {
let true_term = term_for_bcb(true_bcb); let true_term = term_for_bcb(true_bcb);
let false_term = term_for_bcb(false_bcb); let false_term = term_for_bcb(false_bcb);
let kind = MappingKind::Branch { true_term, false_term }; let kind = MappingKind::Branch { true_term, false_term };
let source_region = region_for_span(span)?; Mapping { kind, span }
Some(Mapping { kind, source_region })
}, },
)); ));
@ -183,7 +174,7 @@ fn create_mappings<'tcx>(
|bcb| coverage_counters.term_for_bcb(bcb).expect("all BCBs with spans were given counters"); |bcb| coverage_counters.term_for_bcb(bcb).expect("all BCBs with spans were given counters");
// MCDC branch mappings are appended with their decisions in case decisions were ignored. // MCDC branch mappings are appended with their decisions in case decisions were ignored.
mappings.extend(mcdc_degraded_branches.iter().filter_map( mappings.extend(mcdc_degraded_branches.iter().map(
|&mappings::MCDCBranch { |&mappings::MCDCBranch {
span, span,
true_bcb, true_bcb,
@ -192,10 +183,9 @@ fn create_mappings<'tcx>(
true_index: _, true_index: _,
false_index: _, false_index: _,
}| { }| {
let source_region = region_for_span(span)?;
let true_term = term_for_bcb(true_bcb); let true_term = term_for_bcb(true_bcb);
let false_term = term_for_bcb(false_bcb); let false_term = term_for_bcb(false_bcb);
Some(Mapping { kind: MappingKind::Branch { true_term, false_term }, source_region }) Mapping { kind: MappingKind::Branch { true_term, false_term }, span }
}, },
)); ));
@ -203,7 +193,7 @@ fn create_mappings<'tcx>(
let num_conditions = branches.len() as u16; let num_conditions = branches.len() as u16;
let conditions = branches let conditions = branches
.into_iter() .into_iter()
.filter_map( .map(
|&mappings::MCDCBranch { |&mappings::MCDCBranch {
span, span,
true_bcb, true_bcb,
@ -212,31 +202,29 @@ fn create_mappings<'tcx>(
true_index: _, true_index: _,
false_index: _, false_index: _,
}| { }| {
let source_region = region_for_span(span)?;
let true_term = term_for_bcb(true_bcb); let true_term = term_for_bcb(true_bcb);
let false_term = term_for_bcb(false_bcb); let false_term = term_for_bcb(false_bcb);
Some(Mapping { Mapping {
kind: MappingKind::MCDCBranch { kind: MappingKind::MCDCBranch {
true_term, true_term,
false_term, false_term,
mcdc_params: condition_info, mcdc_params: condition_info,
}, },
source_region, span,
}) }
}, },
) )
.collect::<Vec<_>>(); .collect::<Vec<_>>();
if conditions.len() == num_conditions as usize if conditions.len() == num_conditions as usize {
&& let Some(source_region) = region_for_span(decision.span)
{
// LLVM requires end index for counter mapping regions. // LLVM requires end index for counter mapping regions.
let kind = MappingKind::MCDCDecision(DecisionInfo { let kind = MappingKind::MCDCDecision(DecisionInfo {
bitmap_idx: (decision.bitmap_idx + decision.num_test_vectors) as u32, bitmap_idx: (decision.bitmap_idx + decision.num_test_vectors) as u32,
num_conditions, num_conditions,
}); });
mappings.extend( mappings.extend(
std::iter::once(Mapping { kind, source_region }).chain(conditions.into_iter()), std::iter::once(Mapping { kind, span: decision.span })
.chain(conditions.into_iter()),
); );
} else { } else {
mappings.extend(conditions.into_iter().map(|mapping| { mappings.extend(conditions.into_iter().map(|mapping| {
@ -245,10 +233,7 @@ fn create_mappings<'tcx>(
else { else {
unreachable!("all mappings here are MCDCBranch as shown above"); unreachable!("all mappings here are MCDCBranch as shown above");
}; };
Mapping { Mapping { kind: MappingKind::Branch { true_term, false_term }, span: mapping.span }
kind: MappingKind::Branch { true_term, false_term },
source_region: mapping.source_region,
}
})) }))
} }
} }
@ -391,121 +376,6 @@ fn inject_statement(mir_body: &mut mir::Body<'_>, counter_kind: CoverageKind, bb
data.statements.insert(0, statement); data.statements.insert(0, statement);
} }
fn ensure_non_empty_span(
source_map: &SourceMap,
hir_info: &ExtractedHirInfo,
span: Span,
) -> Option<Span> {
if !span.is_empty() {
return Some(span);
}
let lo = span.lo();
let hi = span.hi();
// The span is empty, so try to expand it to cover an adjacent '{' or '}',
// but only within the bounds of the body span.
let try_next = hi < hir_info.body_span.hi();
let try_prev = hir_info.body_span.lo() < lo;
if !(try_next || try_prev) {
return None;
}
source_map
.span_to_source(span, |src, start, end| try {
// We're only checking for specific ASCII characters, so we don't
// have to worry about multi-byte code points.
if try_next && src.as_bytes()[end] == b'{' {
Some(span.with_hi(hi + BytePos(1)))
} else if try_prev && src.as_bytes()[start - 1] == b'}' {
Some(span.with_lo(lo - BytePos(1)))
} else {
None
}
})
.ok()?
}
/// Converts the span into its start line and column, and end line and column.
///
/// Line numbers and column numbers are 1-based. Unlike most column numbers emitted by
/// the compiler, these column numbers are denoted in **bytes**, because that's what
/// LLVM's `llvm-cov` tool expects to see in coverage maps.
///
/// Returns `None` if the conversion failed for some reason. This shouldn't happen,
/// but it's hard to rule out entirely (especially in the presence of complex macros
/// or other expansions), and if it does happen then skipping a span or function is
/// better than an ICE or `llvm-cov` failure that the user might have no way to avoid.
fn make_source_region(
source_map: &SourceMap,
hir_info: &ExtractedHirInfo,
file: &SourceFile,
span: Span,
) -> Option<SourceRegion> {
let span = ensure_non_empty_span(source_map, hir_info, span)?;
let lo = span.lo();
let hi = span.hi();
// Column numbers need to be in bytes, so we can't use the more convenient
// `SourceMap` methods for looking up file coordinates.
let line_and_byte_column = |pos: BytePos| -> Option<(usize, usize)> {
let rpos = file.relative_position(pos);
let line_index = file.lookup_line(rpos)?;
let line_start = file.lines()[line_index];
// Line numbers and column numbers are 1-based, so add 1 to each.
Some((line_index + 1, (rpos - line_start).to_usize() + 1))
};
let (mut start_line, start_col) = line_and_byte_column(lo)?;
let (mut end_line, end_col) = line_and_byte_column(hi)?;
// Apply an offset so that code in doctests has correct line numbers.
// FIXME(#79417): Currently we have no way to offset doctest _columns_.
start_line = source_map.doctest_offset_line(&file.name, start_line);
end_line = source_map.doctest_offset_line(&file.name, end_line);
check_source_region(SourceRegion {
start_line: start_line as u32,
start_col: start_col as u32,
end_line: end_line as u32,
end_col: end_col as u32,
})
}
/// If `llvm-cov` sees a source region that is improperly ordered (end < start),
/// it will immediately exit with a fatal error. To prevent that from happening,
/// discard regions that are improperly ordered, or might be interpreted in a
/// way that makes them improperly ordered.
fn check_source_region(source_region: SourceRegion) -> Option<SourceRegion> {
let SourceRegion { start_line, start_col, end_line, end_col } = source_region;
// Line/column coordinates are supposed to be 1-based. If we ever emit
// coordinates of 0, `llvm-cov` might misinterpret them.
let all_nonzero = [start_line, start_col, end_line, end_col].into_iter().all(|x| x != 0);
// Coverage mappings use the high bit of `end_col` to indicate that a
// region is actually a "gap" region, so make sure it's unset.
let end_col_has_high_bit_unset = (end_col & (1 << 31)) == 0;
// If a region is improperly ordered (end < start), `llvm-cov` will exit
// with a fatal error, which is inconvenient for users and hard to debug.
let is_ordered = (start_line, start_col) <= (end_line, end_col);
if all_nonzero && end_col_has_high_bit_unset && is_ordered {
Some(source_region)
} else {
debug!(
?source_region,
?all_nonzero,
?end_col_has_high_bit_unset,
?is_ordered,
"Skipping source region that would be misinterpreted or rejected by LLVM"
);
// If this happens in a debug build, ICE to make it easier to notice.
debug_assert!(false, "Improper source region: {source_region:?}");
None
}
}
/// Function information extracted from HIR by the coverage instrumentor. /// Function information extracted from HIR by the coverage instrumentor.
#[derive(Debug)] #[derive(Debug)]
struct ExtractedHirInfo { struct ExtractedHirInfo {

6
compiler/rustc_query_impl/src/lib.rs
View file

@ -222,3 +222,9 @@ pub fn query_system<'tcx>(
} }
rustc_middle::rustc_query_append! { define_queries! } rustc_middle::rustc_query_append! { define_queries! }
pub fn provide(providers: &mut rustc_middle::util::Providers) {
providers.hooks.alloc_self_profile_query_strings =
|tcx| alloc_self_profile_query_strings(tcx.tcx);
providers.hooks.query_key_hash_verify_all = |tcx| query_key_hash_verify_all(tcx.tcx);
}

2
compiler/rustc_query_impl/src/profiling_support.rs
View file

@ -252,6 +252,8 @@ pub fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
return; return;
} }
let _prof_timer = tcx.sess.prof.generic_activity("self_profile_alloc_query_strings");
let mut string_cache = QueryKeyStringCache::new(); let mut string_cache = QueryKeyStringCache::new();
for alloc in super::ALLOC_SELF_PROFILE_QUERY_STRINGS.iter() { for alloc in super::ALLOC_SELF_PROFILE_QUERY_STRINGS.iter() {

27
compiler/rustc_smir/src/rustc_internal/mod.rs
View file

@ -313,6 +313,7 @@ macro_rules! optional {
macro_rules! run_driver { macro_rules! run_driver {
($args:expr, $callback:expr $(, $with_tcx:ident)?) => {{ ($args:expr, $callback:expr $(, $with_tcx:ident)?) => {{
use rustc_driver::{Callbacks, Compilation, RunCompiler}; use rustc_driver::{Callbacks, Compilation, RunCompiler};
use rustc_middle::ty::TyCtxt;
use rustc_interface::{interface, Queries}; use rustc_interface::{interface, Queries};
use stable_mir::CompilerError; use stable_mir::CompilerError;
use std::ops::ControlFlow; use std::ops::ControlFlow;
@ -373,23 +374,21 @@ macro_rules! run_driver {
fn after_analysis<'tcx>( fn after_analysis<'tcx>(
&mut self, &mut self,
_compiler: &interface::Compiler, _compiler: &interface::Compiler,
queries: &'tcx Queries<'tcx>, tcx: TyCtxt<'tcx>,
) -> Compilation { ) -> Compilation {
queries.global_ctxt().unwrap().enter(|tcx| { if let Some(callback) = self.callback.take() {
if let Some(callback) = self.callback.take() { rustc_internal::run(tcx, || {
rustc_internal::run(tcx, || { self.result = Some(callback($(optional!($with_tcx tcx))?));
self.result = Some(callback($(optional!($with_tcx tcx))?)); })
}) .unwrap();
.unwrap(); if self.result.as_ref().is_some_and(|val| val.is_continue()) {
if self.result.as_ref().is_some_and(|val| val.is_continue()) {
Compilation::Continue
} else {
Compilation::Stop
}
} else {
Compilation::Continue Compilation::Continue
} else {
Compilation::Stop
} }
}) } else {
Compilation::Continue
}
} }
} }

30
library/std/src/thread/local.rs
View file

@ -252,6 +252,19 @@ impl<T: 'static> LocalKey<T> {
/// This function will `panic!()` if the key currently has its /// This function will `panic!()` if the key currently has its
/// destructor running, and it **may** panic if the destructor has /// destructor running, and it **may** panic if the destructor has
/// previously been run for this thread. /// previously been run for this thread.
///
/// # Examples
///
/// ```
/// thread_local! {
/// pub static STATIC: String = String::from("I am");
/// }
///
/// assert_eq!(
/// STATIC.with(|original_value| format!("{original_value} initialized")),
/// "I am initialized",
/// );
/// ```
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn with<F, R>(&'static self, f: F) -> R pub fn with<F, R>(&'static self, f: F) -> R
where where
@ -273,6 +286,19 @@ impl<T: 'static> LocalKey<T> {
/// ///
/// This function will still `panic!()` if the key is uninitialized and the /// This function will still `panic!()` if the key is uninitialized and the
/// key's initializer panics. /// key's initializer panics.
///
/// # Examples
///
/// ```
/// thread_local! {
/// pub static STATIC: String = String::from("I am");
/// }
///
/// assert_eq!(
/// STATIC.try_with(|original_value| format!("{original_value} initialized")),
/// Ok(String::from("I am initialized")),
/// );
/// ```
#[stable(feature = "thread_local_try_with", since = "1.26.0")] #[stable(feature = "thread_local_try_with", since = "1.26.0")]
#[inline] #[inline]
pub fn try_with<F, R>(&'static self, f: F) -> Result<R, AccessError> pub fn try_with<F, R>(&'static self, f: F) -> Result<R, AccessError>
@ -452,7 +478,7 @@ impl<T: 'static> LocalKey<RefCell<T>> {
/// Panics if the key currently has its destructor running, /// Panics if the key currently has its destructor running,
/// and it **may** panic if the destructor has previously been run for this thread. /// and it **may** panic if the destructor has previously been run for this thread.
/// ///
/// # Example /// # Examples
/// ///
/// ``` /// ```
/// use std::cell::RefCell; /// use std::cell::RefCell;
@ -483,7 +509,7 @@ impl<T: 'static> LocalKey<RefCell<T>> {
/// Panics if the key currently has its destructor running, /// Panics if the key currently has its destructor running,
/// and it **may** panic if the destructor has previously been run for this thread. /// and it **may** panic if the destructor has previously been run for this thread.
/// ///
/// # Example /// # Examples
/// ///
/// ``` /// ```
/// use std::cell::RefCell; /// use std::cell::RefCell;

82
src/tools/miri/src/bin/miri.rs
View file

@ -73,51 +73,47 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
fn after_analysis<'tcx>( fn after_analysis<'tcx>(
&mut self, &mut self,
_: &rustc_interface::interface::Compiler, _: &rustc_interface::interface::Compiler,
queries: &'tcx rustc_interface::Queries<'tcx>, tcx: TyCtxt<'tcx>,
) -> Compilation { ) -> Compilation {
queries.global_ctxt().unwrap().enter(|tcx| { if tcx.sess.dcx().has_errors_or_delayed_bugs().is_some() {
if tcx.sess.dcx().has_errors_or_delayed_bugs().is_some() { tcx.dcx().fatal("miri cannot be run on programs that fail compilation");
tcx.dcx().fatal("miri cannot be run on programs that fail compilation"); }
}
let early_dcx = EarlyDiagCtxt::new(tcx.sess.opts.error_format); let early_dcx = EarlyDiagCtxt::new(tcx.sess.opts.error_format);
init_late_loggers(&early_dcx, tcx); init_late_loggers(&early_dcx, tcx);
if !tcx.crate_types().contains(&CrateType::Executable) { if !tcx.crate_types().contains(&CrateType::Executable) {
tcx.dcx().fatal("miri only makes sense on bin crates"); tcx.dcx().fatal("miri only makes sense on bin crates");
} }
let (entry_def_id, entry_type) = entry_fn(tcx); let (entry_def_id, entry_type) = entry_fn(tcx);
let mut config = self.miri_config.clone(); let mut config = self.miri_config.clone();
// Add filename to `miri` arguments. // Add filename to `miri` arguments.
config.args.insert(0, tcx.sess.io.input.filestem().to_string()); config.args.insert(0, tcx.sess.io.input.filestem().to_string());
// Adjust working directory for interpretation. // Adjust working directory for interpretation.
if let Some(cwd) = env::var_os("MIRI_CWD") { if let Some(cwd) = env::var_os("MIRI_CWD") {
env::set_current_dir(cwd).unwrap(); env::set_current_dir(cwd).unwrap();
} }
if tcx.sess.opts.optimize != OptLevel::No { if tcx.sess.opts.optimize != OptLevel::No {
tcx.dcx().warn("Miri does not support optimizations: the opt-level is ignored. The only effect \ tcx.dcx().warn("Miri does not support optimizations: the opt-level is ignored. The only effect \
of selecting a Cargo profile that enables optimizations (such as --release) is to apply \ of selecting a Cargo profile that enables optimizations (such as --release) is to apply \
its remaining settings, such as whether debug assertions and overflow checks are enabled."); its remaining settings, such as whether debug assertions and overflow checks are enabled.");
} }
if tcx.sess.mir_opt_level() > 0 { if tcx.sess.mir_opt_level() > 0 {
tcx.dcx().warn("You have explicitly enabled MIR optimizations, overriding Miri's default \ tcx.dcx().warn("You have explicitly enabled MIR optimizations, overriding Miri's default \
which is to completely disable them. Any optimizations may hide UB that Miri would \ which is to completely disable them. Any optimizations may hide UB that Miri would \
otherwise detect, and it is not necessarily possible to predict what kind of UB will \ otherwise detect, and it is not necessarily possible to predict what kind of UB will \
be missed. If you are enabling optimizations to make Miri run faster, we advise using \ be missed. If you are enabling optimizations to make Miri run faster, we advise using \
cfg(miri) to shrink your workload instead. The performance benefit of enabling MIR \ cfg(miri) to shrink your workload instead. The performance benefit of enabling MIR \
optimizations is usually marginal at best."); optimizations is usually marginal at best.");
} }
if let Some(return_code) = miri::eval_entry(tcx, entry_def_id, entry_type, config) { if let Some(return_code) = miri::eval_entry(tcx, entry_def_id, entry_type, config) {
std::process::exit( std::process::exit(i32::try_from(return_code).expect("Return value was too large!"));
i32::try_from(return_code).expect("Return value was too large!"), }
); tcx.dcx().abort_if_errors();
}
tcx.dcx().abort_if_errors();
});
Compilation::Stop Compilation::Stop
} }
@ -193,20 +189,18 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
fn after_analysis<'tcx>( fn after_analysis<'tcx>(
&mut self, &mut self,
_: &rustc_interface::interface::Compiler, _: &rustc_interface::interface::Compiler,
queries: &'tcx rustc_interface::Queries<'tcx>, tcx: TyCtxt<'tcx>,
) -> Compilation { ) -> Compilation {
queries.global_ctxt().unwrap().enter(|tcx| { if self.target_crate {
if self.target_crate { // cargo-miri has patched the compiler flags to make these into check-only builds,
// cargo-miri has patched the compiler flags to make these into check-only builds, // but we are still emulating regular rustc builds, which would perform post-mono
// but we are still emulating regular rustc builds, which would perform post-mono // const-eval during collection. So let's also do that here, even if we might be
// const-eval during collection. So let's also do that here, even if we might be // running with `--emit=metadata`. In particular this is needed to make
// running with `--emit=metadata`. In particular this is needed to make // `compile_fail` doc tests trigger post-mono errors.
// `compile_fail` doc tests trigger post-mono errors. // In general `collect_and_partition_mono_items` is not safe to call in check-only
// In general `collect_and_partition_mono_items` is not safe to call in check-only // builds, but we are setting `-Zalways-encode-mir` which avoids those issues.
// builds, but we are setting `-Zalways-encode-mir` which avoids those issues. let _ = tcx.collect_and_partition_mono_items(());
let _ = tcx.collect_and_partition_mono_items(()); }
}
});
Compilation::Continue Compilation::Continue
} }
} }

12
tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
View file

@ -33,12 +33,12 @@
+ coverage ExpressionId(3) => Expression { lhs: Counter(3), op: Add, rhs: Counter(2) }; + coverage ExpressionId(3) => Expression { lhs: Counter(3), op: Add, rhs: Counter(2) };
+ coverage ExpressionId(4) => Expression { lhs: Expression(3), op: Add, rhs: Counter(1) }; + coverage ExpressionId(4) => Expression { lhs: Expression(3), op: Add, rhs: Counter(1) };
+ coverage ExpressionId(5) => Expression { lhs: Expression(4), op: Add, rhs: Expression(2) }; + coverage ExpressionId(5) => Expression { lhs: Expression(4), op: Add, rhs: Expression(2) };
+ coverage Code(Counter(0)) => 14:1 - 15:21; + coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:14:1: 15:21 (#0);
+ coverage Code(Counter(3)) => 16:17 - 16:33; + coverage Code(Counter(3)) => $DIR/branch_match_arms.rs:16:17: 16:33 (#0);
+ coverage Code(Counter(2)) => 17:17 - 17:33; + coverage Code(Counter(2)) => $DIR/branch_match_arms.rs:17:17: 17:33 (#0);
+ coverage Code(Counter(1)) => 18:17 - 18:33; + coverage Code(Counter(1)) => $DIR/branch_match_arms.rs:18:17: 18:33 (#0);
+ coverage Code(Expression(2)) => 19:17 - 19:33; + coverage Code(Expression(2)) => $DIR/branch_match_arms.rs:19:17: 19:33 (#0);
+ coverage Code(Expression(5)) => 21:1 - 21:2; + coverage Code(Expression(5)) => $DIR/branch_match_arms.rs:21:2: 21:2 (#0);
+ +
bb0: { bb0: {
+ Coverage::CounterIncrement(0); + Coverage::CounterIncrement(0);

2
tests/mir-opt/coverage/instrument_coverage.bar.InstrumentCoverage.diff
View file

@ -5,7 +5,7 @@
let mut _0: bool; let mut _0: bool;
+ coverage body span: $DIR/instrument_coverage.rs:19:18: 21:2 (#0) + coverage body span: $DIR/instrument_coverage.rs:19:18: 21:2 (#0)
+ coverage Code(Counter(0)) => 19:1 - 21:2; + coverage Code(Counter(0)) => $DIR/instrument_coverage.rs:19:1: 21:2 (#0);
+ +
bb0: { bb0: {
+ Coverage::CounterIncrement(0); + Coverage::CounterIncrement(0);

10
tests/mir-opt/coverage/instrument_coverage.main.InstrumentCoverage.diff
View file

@ -9,11 +9,11 @@
+ coverage body span: $DIR/instrument_coverage.rs:10:11: 16:2 (#0) + coverage body span: $DIR/instrument_coverage.rs:10:11: 16:2 (#0)
+ coverage ExpressionId(0) => Expression { lhs: Counter(0), op: Add, rhs: Counter(1) }; + coverage ExpressionId(0) => Expression { lhs: Counter(0), op: Add, rhs: Counter(1) };
+ coverage Code(Counter(0)) => 10:1 - 10:11; + coverage Code(Counter(0)) => $DIR/instrument_coverage.rs:10:1: 10:11 (#0);
+ coverage Code(Expression(0)) => 12:12 - 12:17; + coverage Code(Expression(0)) => $DIR/instrument_coverage.rs:12:12: 12:17 (#0);
+ coverage Code(Counter(0)) => 13:13 - 13:18; + coverage Code(Counter(0)) => $DIR/instrument_coverage.rs:13:13: 13:18 (#0);
+ coverage Code(Counter(1)) => 14:9 - 14:10; + coverage Code(Counter(1)) => $DIR/instrument_coverage.rs:14:10: 14:10 (#0);
+ coverage Code(Counter(0)) => 16:1 - 16:2; + coverage Code(Counter(0)) => $DIR/instrument_coverage.rs:16:2: 16:2 (#0);
+ +
bb0: { bb0: {
+ Coverage::CounterIncrement(0); + Coverage::CounterIncrement(0);

10
tests/mir-opt/coverage/instrument_coverage_cleanup.main.CleanupPostBorrowck.diff
View file

@ -9,11 +9,11 @@
coverage body span: $DIR/instrument_coverage_cleanup.rs:13:11: 15:2 (#0) coverage body span: $DIR/instrument_coverage_cleanup.rs:13:11: 15:2 (#0)
coverage ExpressionId(0) => Expression { lhs: Counter(0), op: Subtract, rhs: Counter(1) }; coverage ExpressionId(0) => Expression { lhs: Counter(0), op: Subtract, rhs: Counter(1) };
coverage Code(Counter(0)) => 13:1 - 14:36; coverage Code(Counter(0)) => $DIR/instrument_coverage_cleanup.rs:13:1: 14:36 (#0);
coverage Code(Expression(0)) => 14:37 - 14:39; coverage Code(Expression(0)) => $DIR/instrument_coverage_cleanup.rs:14:37: 14:39 (#0);
coverage Code(Counter(1)) => 14:38 - 14:39; coverage Code(Counter(1)) => $DIR/instrument_coverage_cleanup.rs:14:39: 14:39 (#0);
coverage Code(Counter(0)) => 15:1 - 15:2; coverage Code(Counter(0)) => $DIR/instrument_coverage_cleanup.rs:15:2: 15:2 (#0);
coverage Branch { true_term: Expression(0), false_term: Counter(1) } => 14:8 - 14:36; coverage Branch { true_term: Expression(0), false_term: Counter(1) } => $DIR/instrument_coverage_cleanup.rs:14:8: 14:36 (#0);
bb0: { bb0: {
Coverage::CounterIncrement(0); Coverage::CounterIncrement(0);

10
tests/mir-opt/coverage/instrument_coverage_cleanup.main.InstrumentCoverage.diff
View file

@ -9,11 +9,11 @@
+ coverage body span: $DIR/instrument_coverage_cleanup.rs:13:11: 15:2 (#0) + coverage body span: $DIR/instrument_coverage_cleanup.rs:13:11: 15:2 (#0)
+ coverage ExpressionId(0) => Expression { lhs: Counter(0), op: Subtract, rhs: Counter(1) }; + coverage ExpressionId(0) => Expression { lhs: Counter(0), op: Subtract, rhs: Counter(1) };
+ coverage Code(Counter(0)) => 13:1 - 14:36; + coverage Code(Counter(0)) => $DIR/instrument_coverage_cleanup.rs:13:1: 14:36 (#0);
+ coverage Code(Expression(0)) => 14:37 - 14:39; + coverage Code(Expression(0)) => $DIR/instrument_coverage_cleanup.rs:14:37: 14:39 (#0);
+ coverage Code(Counter(1)) => 14:38 - 14:39; + coverage Code(Counter(1)) => $DIR/instrument_coverage_cleanup.rs:14:39: 14:39 (#0);
+ coverage Code(Counter(0)) => 15:1 - 15:2; + coverage Code(Counter(0)) => $DIR/instrument_coverage_cleanup.rs:15:2: 15:2 (#0);
+ coverage Branch { true_term: Expression(0), false_term: Counter(1) } => 14:8 - 14:36; + coverage Branch { true_term: Expression(0), false_term: Counter(1) } => $DIR/instrument_coverage_cleanup.rs:14:8: 14:36 (#0);
+ +
bb0: { bb0: {
+ Coverage::CounterIncrement(0); + Coverage::CounterIncrement(0);

81
tests/ui-fulldeps/obtain-borrowck.rs
View file

@ -25,19 +25,20 @@ extern crate rustc_interface;
extern crate rustc_middle; extern crate rustc_middle;
extern crate rustc_session; extern crate rustc_session;
use std::cell::RefCell;
use std::collections::HashMap;
use std::thread_local;
use rustc_borrowck::consumers::{self, BodyWithBorrowckFacts, ConsumerOptions}; use rustc_borrowck::consumers::{self, BodyWithBorrowckFacts, ConsumerOptions};
use rustc_driver::Compilation; use rustc_driver::Compilation;
use rustc_hir::def::DefKind; use rustc_hir::def::DefKind;
use rustc_hir::def_id::LocalDefId; use rustc_hir::def_id::LocalDefId;
use rustc_interface::Config;
use rustc_interface::interface::Compiler; use rustc_interface::interface::Compiler;
use rustc_interface::{Config, Queries};
use rustc_middle::query::queries::mir_borrowck::ProvidedValue; use rustc_middle::query::queries::mir_borrowck::ProvidedValue;
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_middle::util::Providers; use rustc_middle::util::Providers;
use rustc_session::Session; use rustc_session::Session;
use std::cell::RefCell;
use std::collections::HashMap;
use std::thread_local;
fn main() { fn main() {
let exit_code = rustc_driver::catch_with_exit_code(move || { let exit_code = rustc_driver::catch_with_exit_code(move || {
@ -63,55 +64,49 @@ impl rustc_driver::Callbacks for CompilerCalls {
// In this callback we trigger borrow checking of all functions and obtain // In this callback we trigger borrow checking of all functions and obtain
// the result. // the result.
fn after_analysis<'tcx>( fn after_analysis<'tcx>(&mut self, _compiler: &Compiler, tcx: TyCtxt<'tcx>) -> Compilation {
&mut self, tcx.sess.dcx().abort_if_errors();
compiler: &Compiler, // Collect definition ids of MIR bodies.
queries: &'tcx Queries<'tcx>, let hir = tcx.hir();
) -> Compilation { let mut bodies = Vec::new();
compiler.sess.dcx().abort_if_errors();
queries.global_ctxt().unwrap().enter(|tcx| {
// Collect definition ids of MIR bodies.
let hir = tcx.hir();
let mut bodies = Vec::new();
let crate_items = tcx.hir_crate_items(()); let crate_items = tcx.hir_crate_items(());
for id in crate_items.free_items() { for id in crate_items.free_items() {
if matches!(tcx.def_kind(id.owner_id), DefKind::Fn) { if matches!(tcx.def_kind(id.owner_id), DefKind::Fn) {
bodies.push(id.owner_id); bodies.push(id.owner_id);
}
} }
}
for id in crate_items.trait_items() { for id in crate_items.trait_items() {
if matches!(tcx.def_kind(id.owner_id), DefKind::AssocFn) { if matches!(tcx.def_kind(id.owner_id), DefKind::AssocFn) {
let trait_item = hir.trait_item(id); let trait_item = hir.trait_item(id);
if let rustc_hir::TraitItemKind::Fn(_, trait_fn) = &trait_item.kind { if let rustc_hir::TraitItemKind::Fn(_, trait_fn) = &trait_item.kind {
if let rustc_hir::TraitFn::Provided(_) = trait_fn { if let rustc_hir::TraitFn::Provided(_) = trait_fn {
bodies.push(trait_item.owner_id); bodies.push(trait_item.owner_id);
}
} }
} }
} }
}
for id in crate_items.impl_items() { for id in crate_items.impl_items() {
if matches!(tcx.def_kind(id.owner_id), DefKind::AssocFn) { if matches!(tcx.def_kind(id.owner_id), DefKind::AssocFn) {
bodies.push(id.owner_id); bodies.push(id.owner_id);
}
} }
}
// Trigger borrow checking of all bodies. // Trigger borrow checking of all bodies.
for def_id in bodies { for def_id in bodies {
let _ = tcx.optimized_mir(def_id); let _ = tcx.optimized_mir(def_id);
} }
// See what bodies were borrow checked. // See what bodies were borrow checked.
let mut bodies = get_bodies(tcx); let mut bodies = get_bodies(tcx);
bodies.sort_by(|(def_id1, _), (def_id2, _)| def_id1.cmp(def_id2)); bodies.sort_by(|(def_id1, _), (def_id2, _)| def_id1.cmp(def_id2));
println!("Bodies retrieved for:"); println!("Bodies retrieved for:");
for (def_id, body) in bodies { for (def_id, body) in bodies {
println!("{}", def_id); println!("{}", def_id);
assert!(body.input_facts.unwrap().cfg_edge.len() > 0); assert!(body.input_facts.unwrap().cfg_edge.len() > 0);
} }
});
Compilation::Continue Compilation::Continue
} }

1
tests/ui-fulldeps/stable-mir/check_abi.rs
View file

@ -11,6 +11,7 @@
#![feature(ascii_char, ascii_char_variants)] #![feature(ascii_char, ascii_char_variants)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_allocation.rs
View file

@ -13,6 +13,7 @@
#![feature(ascii_char, ascii_char_variants)] #![feature(ascii_char, ascii_char_variants)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_attribute.rs
View file

@ -9,6 +9,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_binop.rs
View file

@ -9,6 +9,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_crate_defs.rs
View file

@ -10,6 +10,7 @@
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_def_ty.rs
View file

@ -11,6 +11,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_defs.rs
View file

@ -10,6 +10,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_instance.rs
View file

@ -10,6 +10,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_intrinsics.rs
View file

@ -13,6 +13,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
extern crate rustc_hir; extern crate rustc_hir;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;

1
tests/ui-fulldeps/stable-mir/check_item_kind.rs
View file

@ -10,6 +10,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_normalization.rs
View file

@ -9,6 +9,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_trait_queries.rs
View file

@ -10,6 +10,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_transform.rs
View file

@ -11,6 +11,7 @@
#![feature(ascii_char, ascii_char_variants)] #![feature(ascii_char, ascii_char_variants)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/check_ty_fold.rs
View file

@ -11,6 +11,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/compilation-result.rs
View file

@ -10,6 +10,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/crate-info.rs
View file

@ -11,6 +11,7 @@
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/projections.rs
View file

@ -11,6 +11,7 @@
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_hir; extern crate rustc_hir;
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui-fulldeps/stable-mir/smir_visitor.rs
View file

@ -10,6 +10,7 @@
#![feature(rustc_private)] #![feature(rustc_private)]
#![feature(assert_matches)] #![feature(assert_matches)]
extern crate rustc_middle;
#[macro_use] #[macro_use]
extern crate rustc_smir; extern crate rustc_smir;
extern crate rustc_driver; extern crate rustc_driver;

1
tests/ui/associated-consts/associated-const-type-parameter-arrays-2.rs
View file

@ -15,6 +15,7 @@ impl Foo for Def {
pub fn test<A: Foo, B: Foo>() { pub fn test<A: Foo, B: Foo>() {
let _array = [4; <A as Foo>::Y]; let _array = [4; <A as Foo>::Y];
//~^ ERROR constant expression depends on a generic parameter //~^ ERROR constant expression depends on a generic parameter
//~| ERROR constant expression depends on a generic parameter
} }
fn main() { fn main() {

10
tests/ui/associated-consts/associated-const-type-parameter-arrays-2.stderr
View file

@ -6,5 +6,13 @@ LL | let _array = [4; <A as Foo>::Y];
| |
= note: this may fail depending on what value the parameter takes = note: this may fail depending on what value the parameter takes
error: aborting due to 1 previous error error: constant expression depends on a generic parameter
--> $DIR/associated-const-type-parameter-arrays-2.rs:16:18
|
LL | let _array = [4; <A as Foo>::Y];
| ^^^^^^^^^^^^^^^^^^
|
= note: this may fail depending on what value the parameter takes
error: aborting due to 2 previous errors

62
tests/ui/const-generics/const-arg-in-const-arg.min.stderr
View file

@ -53,7 +53,7 @@ LL | let _: [u8; baz::<'b>(&())];
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:26:23 --> $DIR/const-arg-in-const-arg.rs:27:23
| |
LL | let _ = [0; bar::<N>()]; LL | let _ = [0; bar::<N>()];
| ^ cannot perform const operation using `N` | ^ cannot perform const operation using `N`
@ -62,7 +62,7 @@ LL | let _ = [0; bar::<N>()];
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:28:23 --> $DIR/const-arg-in-const-arg.rs:29:23
| |
LL | let _ = [0; faz::<'a>(&())]; LL | let _ = [0; faz::<'a>(&())];
| ^^ cannot perform const operation using `'a` | ^^ cannot perform const operation using `'a`
@ -71,7 +71,7 @@ LL | let _ = [0; faz::<'a>(&())];
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:30:23 --> $DIR/const-arg-in-const-arg.rs:31:23
| |
LL | let _ = [0; baz::<'a>(&())]; LL | let _ = [0; baz::<'a>(&())];
| ^^ cannot perform const operation using `'a` | ^^ cannot perform const operation using `'a`
@ -80,7 +80,7 @@ LL | let _ = [0; baz::<'a>(&())];
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:31:23 --> $DIR/const-arg-in-const-arg.rs:32:23
| |
LL | let _ = [0; faz::<'b>(&())]; LL | let _ = [0; faz::<'b>(&())];
| ^^ cannot perform const operation using `'b` | ^^ cannot perform const operation using `'b`
@ -89,7 +89,7 @@ LL | let _ = [0; faz::<'b>(&())];
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:33:23 --> $DIR/const-arg-in-const-arg.rs:34:23
| |
LL | let _ = [0; baz::<'b>(&())]; LL | let _ = [0; baz::<'b>(&())];
| ^^ cannot perform const operation using `'b` | ^^ cannot perform const operation using `'b`
@ -98,7 +98,7 @@ LL | let _ = [0; baz::<'b>(&())];
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:34:24 --> $DIR/const-arg-in-const-arg.rs:35:24
| |
LL | let _: Foo<{ foo::<T>() }>; LL | let _: Foo<{ foo::<T>() }>;
| ^ cannot perform const operation using `T` | ^ cannot perform const operation using `T`
@ -107,7 +107,7 @@ LL | let _: Foo<{ foo::<T>() }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:35:24 --> $DIR/const-arg-in-const-arg.rs:36:24
| |
LL | let _: Foo<{ bar::<N>() }>; LL | let _: Foo<{ bar::<N>() }>;
| ^ cannot perform const operation using `N` | ^ cannot perform const operation using `N`
@ -116,7 +116,7 @@ LL | let _: Foo<{ bar::<N>() }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:37:24 --> $DIR/const-arg-in-const-arg.rs:38:24
| |
LL | let _: Foo<{ faz::<'a>(&()) }>; LL | let _: Foo<{ faz::<'a>(&()) }>;
| ^^ cannot perform const operation using `'a` | ^^ cannot perform const operation using `'a`
@ -125,7 +125,7 @@ LL | let _: Foo<{ faz::<'a>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:39:24 --> $DIR/const-arg-in-const-arg.rs:40:24
| |
LL | let _: Foo<{ baz::<'a>(&()) }>; LL | let _: Foo<{ baz::<'a>(&()) }>;
| ^^ cannot perform const operation using `'a` | ^^ cannot perform const operation using `'a`
@ -134,7 +134,7 @@ LL | let _: Foo<{ baz::<'a>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:40:24 --> $DIR/const-arg-in-const-arg.rs:41:24
| |
LL | let _: Foo<{ faz::<'b>(&()) }>; LL | let _: Foo<{ faz::<'b>(&()) }>;
| ^^ cannot perform const operation using `'b` | ^^ cannot perform const operation using `'b`
@ -143,7 +143,7 @@ LL | let _: Foo<{ faz::<'b>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:42:24 --> $DIR/const-arg-in-const-arg.rs:43:24
| |
LL | let _: Foo<{ baz::<'b>(&()) }>; LL | let _: Foo<{ baz::<'b>(&()) }>;
| ^^ cannot perform const operation using `'b` | ^^ cannot perform const operation using `'b`
@ -152,7 +152,7 @@ LL | let _: Foo<{ baz::<'b>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:43:27 --> $DIR/const-arg-in-const-arg.rs:44:27
| |
LL | let _ = Foo::<{ foo::<T>() }>; LL | let _ = Foo::<{ foo::<T>() }>;
| ^ cannot perform const operation using `T` | ^ cannot perform const operation using `T`
@ -161,7 +161,7 @@ LL | let _ = Foo::<{ foo::<T>() }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:44:27 --> $DIR/const-arg-in-const-arg.rs:45:27
| |
LL | let _ = Foo::<{ bar::<N>() }>; LL | let _ = Foo::<{ bar::<N>() }>;
| ^ cannot perform const operation using `N` | ^ cannot perform const operation using `N`
@ -170,7 +170,7 @@ LL | let _ = Foo::<{ bar::<N>() }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:46:27 --> $DIR/const-arg-in-const-arg.rs:47:27
| |
LL | let _ = Foo::<{ faz::<'a>(&()) }>; LL | let _ = Foo::<{ faz::<'a>(&()) }>;
| ^^ cannot perform const operation using `'a` | ^^ cannot perform const operation using `'a`
@ -179,7 +179,7 @@ LL | let _ = Foo::<{ faz::<'a>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:48:27 --> $DIR/const-arg-in-const-arg.rs:49:27
| |
LL | let _ = Foo::<{ baz::<'a>(&()) }>; LL | let _ = Foo::<{ baz::<'a>(&()) }>;
| ^^ cannot perform const operation using `'a` | ^^ cannot perform const operation using `'a`
@ -188,7 +188,7 @@ LL | let _ = Foo::<{ baz::<'a>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:49:27 --> $DIR/const-arg-in-const-arg.rs:50:27
| |
LL | let _ = Foo::<{ faz::<'b>(&()) }>; LL | let _ = Foo::<{ faz::<'b>(&()) }>;
| ^^ cannot perform const operation using `'b` | ^^ cannot perform const operation using `'b`
@ -197,7 +197,7 @@ LL | let _ = Foo::<{ faz::<'b>(&()) }>;
= help: add `#![feature(generic_const_exprs)]` to allow generic const expressions = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:51:27 --> $DIR/const-arg-in-const-arg.rs:52:27
| |
LL | let _ = Foo::<{ baz::<'b>(&()) }>; LL | let _ = Foo::<{ baz::<'b>(&()) }>;
| ^^ cannot perform const operation using `'b` | ^^ cannot perform const operation using `'b`
@ -241,7 +241,7 @@ LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
| ^^ | ^^
error[E0747]: unresolved item provided when a constant was expected error[E0747]: unresolved item provided when a constant was expected
--> $DIR/const-arg-in-const-arg.rs:35:24 --> $DIR/const-arg-in-const-arg.rs:36:24
| |
LL | let _: Foo<{ bar::<N>() }>; LL | let _: Foo<{ bar::<N>() }>;
| ^ | ^
@ -252,7 +252,7 @@ LL | let _: Foo<{ bar::<{ N }>() }>;
| + + | + +
error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/const-arg-in-const-arg.rs:37:24 --> $DIR/const-arg-in-const-arg.rs:38:24
| |
LL | let _: Foo<{ faz::<'a>(&()) }>; LL | let _: Foo<{ faz::<'a>(&()) }>;
| ^^ | ^^
@ -264,7 +264,7 @@ LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
| ^^ | ^^
error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/const-arg-in-const-arg.rs:40:24 --> $DIR/const-arg-in-const-arg.rs:41:24
| |
LL | let _: Foo<{ faz::<'b>(&()) }>; LL | let _: Foo<{ faz::<'b>(&()) }>;
| ^^ | ^^
@ -283,8 +283,16 @@ LL | let _ = [0; foo::<T>()];
| |
= note: this may fail depending on what value the parameter takes = note: this may fail depending on what value the parameter takes
error: constant expression depends on a generic parameter
--> $DIR/const-arg-in-const-arg.rs:25:13
|
LL | let _ = [0; foo::<T>()];
| ^^^^^^^^^^^^^^^
|
= note: this may fail depending on what value the parameter takes
error[E0747]: unresolved item provided when a constant was expected error[E0747]: unresolved item provided when a constant was expected
--> $DIR/const-arg-in-const-arg.rs:26:23 --> $DIR/const-arg-in-const-arg.rs:27:23
| |
LL | let _ = [0; bar::<N>()]; LL | let _ = [0; bar::<N>()];
| ^ | ^
@ -295,7 +303,7 @@ LL | let _ = [0; bar::<{ N }>()];
| + + | + +
error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/const-arg-in-const-arg.rs:28:23 --> $DIR/const-arg-in-const-arg.rs:29:23
| |
LL | let _ = [0; faz::<'a>(&())]; LL | let _ = [0; faz::<'a>(&())];
| ^^ | ^^
@ -307,7 +315,7 @@ LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
| ^^ | ^^
error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/const-arg-in-const-arg.rs:31:23 --> $DIR/const-arg-in-const-arg.rs:32:23
| |
LL | let _ = [0; faz::<'b>(&())]; LL | let _ = [0; faz::<'b>(&())];
| ^^ | ^^
@ -319,7 +327,7 @@ LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
| ^^ | ^^
error[E0747]: unresolved item provided when a constant was expected error[E0747]: unresolved item provided when a constant was expected
--> $DIR/const-arg-in-const-arg.rs:44:27 --> $DIR/const-arg-in-const-arg.rs:45:27
| |
LL | let _ = Foo::<{ bar::<N>() }>; LL | let _ = Foo::<{ bar::<N>() }>;
| ^ | ^
@ -330,7 +338,7 @@ LL | let _ = Foo::<{ bar::<{ N }>() }>;
| + + | + +
error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/const-arg-in-const-arg.rs:46:27 --> $DIR/const-arg-in-const-arg.rs:47:27
| |
LL | let _ = Foo::<{ faz::<'a>(&()) }>; LL | let _ = Foo::<{ faz::<'a>(&()) }>;
| ^^ | ^^
@ -342,7 +350,7 @@ LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
| ^^ | ^^
error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/const-arg-in-const-arg.rs:49:27 --> $DIR/const-arg-in-const-arg.rs:50:27
| |
LL | let _ = Foo::<{ faz::<'b>(&()) }>; LL | let _ = Foo::<{ faz::<'b>(&()) }>;
| ^^ | ^^
@ -353,7 +361,7 @@ note: the late bound lifetime parameter is introduced here
LL | const fn faz<'a>(_: &'a ()) -> usize { 13 } LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
| ^^ | ^^
error: aborting due to 36 previous errors error: aborting due to 37 previous errors
Some errors have detailed explanations: E0747, E0794. Some errors have detailed explanations: E0747, E0794.
For more information about an error, try `rustc --explain E0747`. For more information about an error, try `rustc --explain E0747`.

1
tests/ui/const-generics/const-arg-in-const-arg.rs
View file

@ -23,6 +23,7 @@ fn test<'a, 'b, T, const N: usize>() where &'b (): Sized {
let _: [u8; baz::<'b>(&())]; //[min]~ ERROR generic parameters may not let _: [u8; baz::<'b>(&())]; //[min]~ ERROR generic parameters may not
let _ = [0; foo::<T>()]; //[min]~ ERROR constant expression depends on a generic parameter let _ = [0; foo::<T>()]; //[min]~ ERROR constant expression depends on a generic parameter
//[min]~^ ERROR constant expression depends on a generic parameter
let _ = [0; bar::<N>()]; //[min]~ ERROR generic parameters may not let _ = [0; bar::<N>()]; //[min]~ ERROR generic parameters may not
//[min]~^ ERROR unresolved item provided when a constant was expected //[min]~^ ERROR unresolved item provided when a constant was expected
let _ = [0; faz::<'a>(&())]; //[min]~ ERROR generic parameters may not let _ = [0; faz::<'a>(&())]; //[min]~ ERROR generic parameters may not

16
tests/ui/const-generics/generic_const_exprs/dependence_lint.gce.stderr
View file

@ -1,11 +1,3 @@
error: overly complex generic constant
--> $DIR/dependence_lint.rs:17:9
|
LL | [0; if false { size_of::<T>() } else { 3 }]; // lint on stable, error with gce
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ control flow is not supported in generic constants
|
= help: consider moving this anonymous constant into a `const` function
error: overly complex generic constant error: overly complex generic constant
--> $DIR/dependence_lint.rs:21:17 --> $DIR/dependence_lint.rs:21:17
| |
@ -36,5 +28,13 @@ help: try adding a `where` bound
LL | fn foo<T>() where [(); size_of::<*mut T>()]: { LL | fn foo<T>() where [(); size_of::<*mut T>()]: {
| ++++++++++++++++++++++++++++++++ | ++++++++++++++++++++++++++++++++
error: overly complex generic constant
--> $DIR/dependence_lint.rs:17:9
|
LL | [0; if false { size_of::<T>() } else { 3 }]; // lint on stable, error with gce
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ control flow is not supported in generic constants
|
= help: consider moving this anonymous constant into a `const` function
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

1
tests/ui/consts/too_generic_eval_ice.rs
View file

@ -7,6 +7,7 @@ impl<A, B> Foo<A, B> {
[5; Self::HOST_SIZE] == [6; 0] [5; Self::HOST_SIZE] == [6; 0]
//~^ ERROR constant expression depends on a generic parameter //~^ ERROR constant expression depends on a generic parameter
//~| ERROR constant expression depends on a generic parameter //~| ERROR constant expression depends on a generic parameter
//~| ERROR constant expression depends on a generic parameter
//~| ERROR can't compare `[{integer}; Self::HOST_SIZE]` with `[{integer}; 0]` //~| ERROR can't compare `[{integer}; Self::HOST_SIZE]` with `[{integer}; 0]`
} }
} }

10
tests/ui/consts/too_generic_eval_ice.stderr
View file

@ -6,6 +6,14 @@ LL | [5; Self::HOST_SIZE] == [6; 0]
| |
= note: this may fail depending on what value the parameter takes = note: this may fail depending on what value the parameter takes
error: constant expression depends on a generic parameter
--> $DIR/too_generic_eval_ice.rs:7:9
|
LL | [5; Self::HOST_SIZE] == [6; 0]
| ^^^^^^^^^^^^^^^^^^^^
|
= note: this may fail depending on what value the parameter takes
error: constant expression depends on a generic parameter error: constant expression depends on a generic parameter
--> $DIR/too_generic_eval_ice.rs:7:30 --> $DIR/too_generic_eval_ice.rs:7:30
| |
@ -32,6 +40,6 @@ LL | [5; Self::HOST_SIZE] == [6; 0]
`[T; N]` implements `PartialEq<[U]>` `[T; N]` implements `PartialEq<[U]>`
and 3 others and 3 others
error: aborting due to 3 previous errors error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0277`. For more information about this error, try `rustc --explain E0277`.

7
tests/ui/error-codes/E0746.stderr
View file

@ -19,8 +19,11 @@ error[E0746]: return type cannot have an unboxed trait object
LL | fn bar() -> dyn Trait { LL | fn bar() -> dyn Trait {
| ^^^^^^^^^ doesn't have a size known at compile-time | ^^^^^^^^^ doesn't have a size known at compile-time
| |
= help: if there were a single returned type, you could use `impl Trait` instead help: consider returning an `impl Trait` instead of a `dyn Trait`
help: box the return type, and wrap all of the returned values in `Box::new` |
LL | fn bar() -> impl Trait {
| ~~~~
help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
| |
LL ~ fn bar() -> Box<dyn Trait> { LL ~ fn bar() -> Box<dyn Trait> {
LL | if true { LL | if true {

14
tests/ui/impl-trait/dyn-trait-return-should-be-impl-trait.stderr
View file

@ -261,8 +261,11 @@ error[E0746]: return type cannot have an unboxed trait object
LL | fn bat() -> dyn Trait { LL | fn bat() -> dyn Trait {
| ^^^^^^^^^ doesn't have a size known at compile-time | ^^^^^^^^^ doesn't have a size known at compile-time
| |
= help: if there were a single returned type, you could use `impl Trait` instead help: consider returning an `impl Trait` instead of a `dyn Trait`
help: box the return type, and wrap all of the returned values in `Box::new` |
LL | fn bat() -> impl Trait {
| ~~~~
help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
| |
LL ~ fn bat() -> Box<dyn Trait> { LL ~ fn bat() -> Box<dyn Trait> {
LL | if true { LL | if true {
@ -277,8 +280,11 @@ error[E0746]: return type cannot have an unboxed trait object
LL | fn bay() -> dyn Trait { LL | fn bay() -> dyn Trait {
| ^^^^^^^^^ doesn't have a size known at compile-time | ^^^^^^^^^ doesn't have a size known at compile-time
| |
= help: if there were a single returned type, you could use `impl Trait` instead help: consider returning an `impl Trait` instead of a `dyn Trait`
help: box the return type, and wrap all of the returned values in `Box::new` |
LL | fn bay() -> impl Trait {
| ~~~~
help: alternatively, box the return type, and wrap all of the returned values in `Box::new`
| |
LL ~ fn bay() -> Box<dyn Trait> { LL ~ fn bay() -> Box<dyn Trait> {
LL | if true { LL | if true {

1
tests/ui/issues/issue-39211.rs
View file

@ -8,6 +8,7 @@ trait Mat {
fn m<M: Mat>() { fn m<M: Mat>() {
let a = [3; M::Row::DIM]; let a = [3; M::Row::DIM];
//~^ ERROR constant expression depends on a generic parameter //~^ ERROR constant expression depends on a generic parameter
//~| ERROR constant expression depends on a generic parameter
} }
fn main() { fn main() {
} }

10
tests/ui/issues/issue-39211.stderr
View file

@ -6,5 +6,13 @@ LL | let a = [3; M::Row::DIM];
| |
= note: this may fail depending on what value the parameter takes = note: this may fail depending on what value the parameter takes
error: aborting due to 1 previous error error: constant expression depends on a generic parameter
--> $DIR/issue-39211.rs:9:13
|
LL | let a = [3; M::Row::DIM];
| ^^^^^^^^^^^^^^^^
|
= note: this may fail depending on what value the parameter takes
error: aborting due to 2 previous errors

1
tests/ui/traits/next-solver/alias-bound-unsound.rs
View file

@ -28,5 +28,6 @@ fn main() {
//~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _` //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
//~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _` //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
//~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _` //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
//~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
println!("{x}"); println!("{x}");
} }

10
tests/ui/traits/next-solver/alias-bound-unsound.stderr
View file

@ -24,6 +24,14 @@ error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
LL | drop(<() as Foo>::copy_me(&x)); LL | drop(<() as Foo>::copy_me(&x));
| ^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
--> $DIR/alias-bound-unsound.rs:24:10
|
LL | drop(<() as Foo>::copy_me(&x));
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0275]: overflow evaluating the requirement `&<() as Foo>::Item well-formed` error[E0275]: overflow evaluating the requirement `&<() as Foo>::Item well-formed`
--> $DIR/alias-bound-unsound.rs:24:31 --> $DIR/alias-bound-unsound.rs:24:31
| |
@ -50,6 +58,6 @@ error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
LL | drop(<() as Foo>::copy_me(&x)); LL | drop(<() as Foo>::copy_me(&x));
| ^^ | ^^
error: aborting due to 7 previous errors error: aborting due to 8 previous errors
For more information about this error, try `rustc --explain E0275`. For more information about this error, try `rustc --explain E0275`.

20
tests/ui/traits/next-solver/typeck/resolve-before-checking-builtin-ptr.rs Normal file
View file

@ -0,0 +1,20 @@
//@ check-pass
//@ compile-flags: -Znext-solver
trait Mirror {
type Assoc;
}
impl<T> Mirror for T {
type Assoc = T;
}
struct Place {
field: <&'static [u8] as Mirror>::Assoc,
}
fn main() {
let local = Place { field: &[] };
let z = || {
let y = &local.field[0];
};
}

20
tests/ui/traits/next-solver/typeck/resolve-before-checking-never.rs Normal file
View file

@ -0,0 +1,20 @@
//@ check-pass
//@ compile-flags: -Znext-solver
#![feature(never_type)]
trait Mirror {
type Assoc;
}
impl<T> Mirror for T {
type Assoc = T;
}
fn diverge() -> <! as Mirror>::Assoc { todo!() }
fn main() {
let close = || {
diverge();
};
let x: u32 = close();
}