Auto merge of #123886 - scottmcm:more-rvalue-operands, r=matthewjasper
Avoid `alloca`s in codegen for simple `mir::Aggregate` statements
The core idea here is to remove the abstraction penalty of simple newtypes in codegen.
Even something simple like constructing a
```rust
#[repr(transparent)] struct Foo(u32);
```
forces an `alloca` to be generated in nightly right now.
Certainly LLVM can optimize that away, but it would be nice if it didn't have to.
Quick example:
```rust
#[repr(transparent)]
pub struct Transparent32(u32);
#[no_mangle]
pub fn make_transparent(x: u32) -> Transparent32 {
let a = Transparent32(x);
a
}
```
on nightly we produce <https://rust.godbolt.org/z/zcvoM79ae>
```llvm
define noundef i32 `@make_transparent(i32` noundef %x) unnamed_addr #0 {
%a = alloca i32, align 4
store i32 %x, ptr %a, align 4
%0 = load i32, ptr %a, align 4, !noundef !3
ret i32 %0
}
```
but after this PR we produce
```llvm
define noundef i32 `@make_transparent(i32` noundef %x) unnamed_addr #0 {
start:
ret i32 %x
}
```
(even before the optimizer runs).
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a2769a2..5364c1e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -52,6 +52,8 @@
- name: Checkout the source code
uses: actions/checkout@v4
- name: Calculate the CI job matrix
+ env:
+ COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
run: python3 src/ci/github-actions/calculate-job-matrix.py >> $GITHUB_OUTPUT
id: jobs
job:
@@ -75,14 +77,6 @@
matrix:
# Check the `calculate_matrix` job to see how is the matrix defined.
include: ${{ fromJSON(needs.calculate_matrix.outputs.jobs) }}
- # GitHub Actions fails the workflow if an empty list of jobs is provided to
- # the workflow, so we need to skip this job if nothing was produced by
- # the Python script.
- #
- # Unfortunately checking whether a list is empty is not possible in a nice
- # way due to GitHub Actions expressions limits.
- # This hack is taken from https://github.com/ferrocene/ferrocene/blob/d43edc6b7697cf1719ec1c17c54904ab94825763/.github/workflows/release.yml#L75-L82
- if: fromJSON(needs.calculate_matrix.outputs.jobs)[0] != null
steps:
- if: contains(matrix.os, 'windows')
uses: msys2/setup-msys2@v2.22.0
diff --git a/Cargo.lock b/Cargo.lock
index f2c65c7..aa73df5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2760,7 +2760,7 @@
"tabled",
"tar",
"tempfile",
- "xz",
+ "xz2",
"zip",
]
@@ -6589,15 +6589,6 @@
]
[[package]]
-name = "xz"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c887690ff2a2e233e8e49633461521f98ec57fbff9d59a884c9a4f04ec1da34"
-dependencies = [
- "xz2",
-]
-
-[[package]]
name = "xz2"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index ef5f58b..a8d019c 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -926,6 +926,41 @@
}
}
+/// Floating-point types.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
+pub enum Float {
+ F16,
+ F32,
+ F64,
+ F128,
+}
+
+impl Float {
+ pub fn size(self) -> Size {
+ use Float::*;
+
+ match self {
+ F16 => Size::from_bits(16),
+ F32 => Size::from_bits(32),
+ F64 => Size::from_bits(64),
+ F128 => Size::from_bits(128),
+ }
+ }
+
+ pub fn align<C: HasDataLayout>(self, cx: &C) -> AbiAndPrefAlign {
+ use Float::*;
+ let dl = cx.data_layout();
+
+ match self {
+ F16 => dl.f16_align,
+ F32 => dl.f32_align,
+ F64 => dl.f64_align,
+ F128 => dl.f128_align,
+ }
+ }
+}
+
/// Fundamental unit of memory access and layout.
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
@@ -938,10 +973,7 @@
/// a negative integer passed by zero-extension will appear positive in
/// the callee, and most operations on it will produce the wrong values.
Int(Integer, bool),
- F16,
- F32,
- F64,
- F128,
+ Float(Float),
Pointer(AddressSpace),
}
@@ -952,10 +984,7 @@
match self {
Int(i, _) => i.size(),
- F16 => Size::from_bits(16),
- F32 => Size::from_bits(32),
- F64 => Size::from_bits(64),
- F128 => Size::from_bits(128),
+ Float(f) => f.size(),
// FIXME(erikdesjardins): ignoring address space is technically wrong, pointers in
// different address spaces can have different sizes
// (but TargetDataLayout doesn't currently parse that part of the DL string)
@@ -969,10 +998,7 @@
match self {
Int(i, _) => i.align(dl),
- F16 => dl.f16_align,
- F32 => dl.f32_align,
- F64 => dl.f64_align,
- F128 => dl.f128_align,
+ Float(f) => f.align(dl),
// FIXME(erikdesjardins): ignoring address space is technically wrong, pointers in
// different address spaces can have different alignments
// (but TargetDataLayout doesn't currently parse that part of the DL string)
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 6d9656c..7951b7e 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -1422,7 +1422,7 @@
/// of `if` / `while` expressions. (e.g., `if let 0 = x { .. }`).
///
/// `Span` represents the whole `let pat = expr` statement.
- Let(P<Pat>, P<Expr>, Span, Option<ErrorGuaranteed>),
+ Let(P<Pat>, P<Expr>, Span, Recovered),
/// An `if` block, with an optional `else` block.
///
/// `if expr { block } else { expr }`
@@ -2881,17 +2881,20 @@
pub is_placeholder: bool,
}
+/// Was parsing recovery performed?
+#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic)]
+pub enum Recovered {
+ No,
+ Yes(ErrorGuaranteed),
+}
+
/// Fields and constructor ids of enum variants and structs.
#[derive(Clone, Encodable, Decodable, Debug)]
pub enum VariantData {
/// Struct variant.
///
/// E.g., `Bar { .. }` as in `enum Foo { Bar { .. } }`.
- Struct {
- fields: ThinVec<FieldDef>,
- // FIXME: investigate making this a `Option<ErrorGuaranteed>`
- recovered: bool,
- },
+ Struct { fields: ThinVec<FieldDef>, recovered: Recovered },
/// Tuple variant.
///
/// E.g., `Bar(..)` as in `enum Foo { Bar(..) }`.
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 443b596..a553109 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -158,13 +158,13 @@
let ohs = self.lower_expr(ohs);
hir::ExprKind::AddrOf(*k, *m, ohs)
}
- ExprKind::Let(pat, scrutinee, span, is_recovered) => {
+ ExprKind::Let(pat, scrutinee, span, recovered) => {
hir::ExprKind::Let(self.arena.alloc(hir::LetExpr {
span: self.lower_span(*span),
pat: self.lower_pat(pat),
ty: None,
init: self.lower_expr(scrutinee),
- is_recovered: *is_recovered,
+ recovered: *recovered,
}))
}
ExprKind::If(cond, then, else_opt) => {
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 6c54363..a769357 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1283,7 +1283,8 @@
fields.iter().enumerate().map(|f| this.lower_field_def(f)),
);
let span = t.span;
- let variant_data = hir::VariantData::Struct { fields, recovered: false };
+ let variant_data =
+ hir::VariantData::Struct { fields, recovered: ast::Recovered::No };
// FIXME: capture the generics from the outer adt.
let generics = hir::Generics::empty();
let kind = match t.kind {
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 6c82dd1..6f0bd05 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -494,7 +494,7 @@
{
self.suggest_cloning(err, ty, expr, None, Some(move_spans));
} else if self.suggest_hoisting_call_outside_loop(err, expr) {
- // The place where the the type moves would be misleading to suggest clone.
+ // The place where the type moves would be misleading to suggest clone.
// #121466
self.suggest_cloning(err, ty, expr, None, Some(move_spans));
}
diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index 5ebdb69..e3ad92a 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -317,36 +317,39 @@
let mut has_dyn = false;
let mut failed = false;
- let elaborated_args = std::iter::zip(*args, &generics.params).map(|(arg, param)| {
- if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
- let default = tcx.object_lifetime_default(param.def_id);
+ let elaborated_args =
+ std::iter::zip(*args, &generics.own_params).map(|(arg, param)| {
+ if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
+ let default = tcx.object_lifetime_default(param.def_id);
- let re_static = tcx.lifetimes.re_static;
+ let re_static = tcx.lifetimes.re_static;
- let implied_region = match default {
- // This is not entirely precise.
- ObjectLifetimeDefault::Empty => re_static,
- ObjectLifetimeDefault::Ambiguous => {
- failed = true;
- re_static
- }
- ObjectLifetimeDefault::Param(param_def_id) => {
- let index = generics.param_def_id_to_index[¶m_def_id] as usize;
- args.get(index).and_then(|arg| arg.as_region()).unwrap_or_else(|| {
+ let implied_region = match default {
+ // This is not entirely precise.
+ ObjectLifetimeDefault::Empty => re_static,
+ ObjectLifetimeDefault::Ambiguous => {
failed = true;
re_static
- })
- }
- ObjectLifetimeDefault::Static => re_static,
- };
+ }
+ ObjectLifetimeDefault::Param(param_def_id) => {
+ let index = generics.param_def_id_to_index[¶m_def_id] as usize;
+ args.get(index).and_then(|arg| arg.as_region()).unwrap_or_else(
+ || {
+ failed = true;
+ re_static
+ },
+ )
+ }
+ ObjectLifetimeDefault::Static => re_static,
+ };
- has_dyn = true;
+ has_dyn = true;
- Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
- } else {
- arg
- }
- });
+ Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
+ } else {
+ arg
+ }
+ });
let elaborated_ty = Ty::new_adt(tcx, *def, tcx.mk_args_from_iter(elaborated_args));
if has_dyn && !failed {
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 0b4018a..88172c6 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -1344,7 +1344,7 @@
Applicability::MaybeIncorrect,
);
for error in errors {
- if let FulfillmentErrorCode::SelectionError(
+ if let FulfillmentErrorCode::Select(
SelectionError::Unimplemented,
) = error.code
&& let ty::PredicateKind::Clause(ty::ClauseKind::Trait(
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 5d74a01..c9a09c1 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -1283,7 +1283,7 @@
}
// The type doesn't implement Clone because of unmet obligations.
for error in errors {
- if let traits::FulfillmentErrorCode::SelectionError(
+ if let traits::FulfillmentErrorCode::Select(
traits::SelectionError::Unimplemented,
) = error.code
&& let ty::PredicateKind::Clause(ty::ClauseKind::Trait(
@@ -1483,10 +1483,9 @@
} else {
// otherwise, suggest that the user annotates the binding; we provide the
// type of the local.
- let ty_mut = decl_ty.builtin_deref(true).unwrap();
- assert_eq!(ty_mut.mutbl, hir::Mutability::Not);
+ let ty = decl_ty.builtin_deref(true).unwrap();
- (false, span, format!("{}mut {}", if decl_ty.is_ref() { "&" } else { "*" }, ty_mut.ty))
+ (false, span, format!("{}mut {}", if decl_ty.is_ref() { "&" } else { "*" }, ty))
}
}
diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index 5457444..e58723c 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -1326,14 +1326,20 @@
})
}
- // Evaluate whether `sup_region == sub_region`.
- fn eval_equal(&self, r1: RegionVid, r2: RegionVid) -> bool {
+ /// Evaluate whether `sup_region == sub_region`.
+ ///
+ /// Panics if called before `solve()` executes,
+ // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.
+ pub fn eval_equal(&self, r1: RegionVid, r2: RegionVid) -> bool {
self.eval_outlives(r1, r2) && self.eval_outlives(r2, r1)
}
- // Evaluate whether `sup_region: sub_region`.
+ /// Evaluate whether `sup_region: sub_region`.
+ ///
+ /// Panics if called before `solve()` executes,
+ // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.
#[instrument(skip(self), level = "debug", ret)]
- fn eval_outlives(&self, sup_region: RegionVid, sub_region: RegionVid) -> bool {
+ pub fn eval_outlives(&self, sup_region: RegionVid, sub_region: RegionVid) -> bool {
debug!(
"sup_region's value = {:?} universal={:?}",
self.region_value_str(sup_region),
@@ -2053,7 +2059,7 @@
// We currently do not store the `DefId` in the `ConstraintCategory`
// for performances reasons. The error reporting code used by NLL only
// uses the span, so this doesn't cause any problems at the moment.
- Some(ObligationCauseCode::BindingObligation(
+ Some(ObligationCauseCode::SpannedWhereClause(
CRATE_DEF_ID.to_def_id(),
predicate_span,
))
@@ -2061,7 +2067,7 @@
None
}
})
- .unwrap_or_else(|| ObligationCauseCode::MiscObligation);
+ .unwrap_or_else(|| ObligationCauseCode::Misc);
// Classify each of the constraints along the path.
let mut categorized_path: Vec<BlameConstraint<'tcx>> = path
@@ -2246,7 +2252,10 @@
}
/// Access to the SCC constraint graph.
- pub(crate) fn constraint_sccs(&self) -> &Sccs<RegionVid, ConstraintSccIndex> {
+ /// This can be used to quickly under-approximate the regions which are equal to each other
+ /// and their relative orderings.
+ // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.
+ pub fn constraint_sccs(&self) -> &Sccs<RegionVid, ConstraintSccIndex> {
self.constraint_sccs.as_ref()
}
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
index 73ba5be..f601a9d 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
@@ -40,7 +40,7 @@
/// compares lifetimes directly, so we need to map the inference variables
/// back to concrete lifetimes: `'static`, `ReEarlyParam` or `ReLateParam`.
///
- /// First we map the regions in the the generic parameters `_Return<'1>` to
+ /// First we map the regions in the generic parameters `_Return<'1>` to
/// their `external_name` giving `_Return<'a>`. This step is a bit involved.
/// See the [rustc-dev-guide chapter] for more info.
///
diff --git a/compiler/rustc_borrowck/src/renumber.rs b/compiler/rustc_borrowck/src/renumber.rs
index f5757bc..d382f26 100644
--- a/compiler/rustc_borrowck/src/renumber.rs
+++ b/compiler/rustc_borrowck/src/renumber.rs
@@ -26,9 +26,7 @@
renumberer.visit_body(body);
}
-// FIXME(@lcnr): A lot of these variants overlap and it seems like
-// this type is only used to decide which region should be used
-// as representative. This should be cleaned up.
+// The fields are used only for debugging output in `sccs_info`.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub(crate) enum RegionCtxt {
Location(Location),
diff --git a/compiler/rustc_borrowck/src/type_check/input_output.rs b/compiler/rustc_borrowck/src/type_check/input_output.rs
index 2511a15..4e45dc4 100644
--- a/compiler/rustc_borrowck/src/type_check/input_output.rs
+++ b/compiler/rustc_borrowck/src/type_check/input_output.rs
@@ -11,7 +11,6 @@
use itertools::Itertools;
use rustc_hir as hir;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{BoundRegionConversionTime, RegionVariableOrigin};
use rustc_middle::mir::*;
use rustc_middle::ty::{self, Ty};
@@ -74,9 +73,7 @@
}),
);
- let next_ty_var = || {
- self.infcx.next_ty_var(TypeVariableOrigin { span: body.span, param_def_id: None })
- };
+ let next_ty_var = || self.infcx.next_ty_var(body.span);
let output_ty = Ty::new_coroutine(
self.tcx(),
self.tcx().coroutine_for_closure(mir_def_id),
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs b/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
index da54566..ccd9fb2 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
@@ -1,4 +1,3 @@
-use rustc_data_structures::vec_linked_list as vll;
use rustc_index::IndexVec;
use rustc_middle::mir::visit::{PlaceContext, Visitor};
use rustc_middle::mir::{Body, Local, Location};
@@ -37,9 +36,12 @@
/// we add for each local variable.
first_drop_at: IndexVec<Local, Option<AppearanceIndex>>,
- appearances: IndexVec<AppearanceIndex, Appearance>,
+ appearances: Appearances,
}
+// The `Appearance::next` field effectively embeds a linked list within `Appearances`.
+type Appearances = IndexVec<AppearanceIndex, Appearance>;
+
struct Appearance {
point_index: PointIndex,
next: Option<AppearanceIndex>,
@@ -49,14 +51,34 @@
pub struct AppearanceIndex {}
}
-impl vll::LinkElem for Appearance {
- type LinkIndex = AppearanceIndex;
+fn appearances_iter(
+ first: Option<AppearanceIndex>,
+ appearances: &Appearances,
+) -> impl Iterator<Item = AppearanceIndex> + '_ {
+ AppearancesIter { appearances, current: first }
+}
- fn next(elem: &Self) -> Option<AppearanceIndex> {
- elem.next
+// Iterates over `Appearances` by following `next` fields.
+struct AppearancesIter<'a> {
+ appearances: &'a Appearances,
+ current: Option<AppearanceIndex>,
+}
+
+impl<'a> Iterator for AppearancesIter<'a> {
+ type Item = AppearanceIndex;
+
+ fn next(&mut self) -> Option<AppearanceIndex> {
+ if let Some(c) = self.current {
+ self.current = self.appearances[c].next;
+ Some(c)
+ } else {
+ None
+ }
}
}
+//-----------------------------------------------------------------------------
+
impl LocalUseMap {
pub(crate) fn build(
live_locals: &[Local],
@@ -86,17 +108,17 @@
}
pub(crate) fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
- vll::iter(self.first_def_at[local], &self.appearances)
+ appearances_iter(self.first_def_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
pub(crate) fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
- vll::iter(self.first_use_at[local], &self.appearances)
+ appearances_iter(self.first_use_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
pub(crate) fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
- vll::iter(self.first_drop_at[local], &self.appearances)
+ appearances_iter(self.first_drop_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
}
@@ -146,7 +168,7 @@
fn insert(
elements: &DenseLocationMap,
first_appearance: &mut Option<AppearanceIndex>,
- appearances: &mut IndexVec<AppearanceIndex, Appearance>,
+ appearances: &mut Appearances,
location: Location,
) {
let point_index = elements.point_from_location(location);
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 13acc67..76daa1d6 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -16,7 +16,6 @@
use rustc_infer::infer::canonical::QueryRegionConstraints;
use rustc_infer::infer::outlives::env::RegionBoundPairs;
use rustc_infer::infer::region_constraints::RegionConstraintData;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{
BoundRegion, BoundRegionConversionTime, InferCtxt, NllRegionVariableOrigin,
};
@@ -401,7 +400,7 @@
} else if let Some(static_def_id) = constant.check_static_ptr(tcx) {
let unnormalized_ty = tcx.type_of(static_def_id).instantiate_identity();
let normalized_ty = self.cx.normalize(unnormalized_ty, locations);
- let literal_ty = constant.const_.ty().builtin_deref(true).unwrap().ty;
+ let literal_ty = constant.const_.ty().builtin_deref(true).unwrap();
if let Err(terr) = self.cx.eq_types(
literal_ty,
@@ -638,7 +637,7 @@
match pi {
ProjectionElem::Deref => {
let deref_ty = base_ty.builtin_deref(true);
- PlaceTy::from_ty(deref_ty.map(|t| t.ty).unwrap_or_else(|| {
+ PlaceTy::from_ty(deref_ty.unwrap_or_else(|| {
span_mirbug_and_err!(self, place, "deref of non-pointer {:?}", base_ty)
}))
}
@@ -2356,10 +2355,7 @@
// Types with regions are comparable if they have a common super-type.
ty::RawPtr(_, _) | ty::FnPtr(_) => {
let ty_right = right.ty(body, tcx);
- let common_ty = self.infcx.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: body.source_info(location).span,
- });
+ let common_ty = self.infcx.next_ty_var(body.source_info(location).span);
self.sub_types(
ty_left,
common_ty,
diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
index 5e4b3e5..493c41e 100644
--- a/compiler/rustc_borrowck/src/type_check/relate_tys.rs
+++ b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -1,6 +1,5 @@
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::ErrorGuaranteed;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::NllRegionVariableOrigin;
use rustc_infer::infer::{ObligationEmittingRelation, StructurallyRelateAliases};
use rustc_infer::traits::{Obligation, PredicateObligations};
@@ -129,10 +128,7 @@
// by using `ty_vid rel B` and then finally and end by equating `ty_vid` to
// the opaque.
let mut enable_subtyping = |ty, opaque_is_expected| {
- let ty_vid = infcx.next_ty_var_id_in_universe(
- TypeVariableOrigin { param_def_id: None, span: self.span() },
- ty::UniverseIndex::ROOT,
- );
+ let ty_vid = infcx.next_ty_var_id_in_universe(self.span(), ty::UniverseIndex::ROOT);
let variance = if opaque_is_expected {
self.ambient_variance
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
index dc73caa..a6457f4 100644
--- a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
@@ -31,7 +31,7 @@
};
// We received arguments of type `&T`. Convert them to type `T` by stripping
- // any leading `&` or adding `*`. This isn't necessary for type checking, but
+ // any leading `&`. This isn't necessary for type checking, but
// it results in better error messages if something goes wrong.
//
// Note: for arguments that look like `&{ x }`, which occur with packed
@@ -53,8 +53,7 @@
inner.clone()
}
} else {
- // No leading `&`: add a leading `*`.
- cx.expr_deref(field.span, expr.clone())
+ expr.clone()
}
};
cx.expr_binary(
diff --git a/compiler/rustc_builtin_macros/src/deriving/mod.rs b/compiler/rustc_builtin_macros/src/deriving/mod.rs
index d6e2d1d..e3a93ae 100644
--- a/compiler/rustc_builtin_macros/src/deriving/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/mod.rs
@@ -123,7 +123,7 @@
span: Span,
assert_path: &[Symbol],
) {
- // Deny anonymous structs or unions to avoid wierd errors.
+ // Deny anonymous structs or unions to avoid weird errors.
assert!(!ty.kind.is_anon_adt(), "Anonymous structs or unions cannot be type parameters");
// Generate statement `let _: assert_path<ty>;`.
let span = cx.with_def_site_ctxt(span);
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index 2450ac8..a5fc74f 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -7,14 +7,13 @@
use rustc_ast::{
Expr, ExprKind, FormatAlignment, FormatArgPosition, FormatArgPositionKind, FormatArgs,
FormatArgsPiece, FormatArgument, FormatArgumentKind, FormatArguments, FormatCount,
- FormatDebugHex, FormatOptions, FormatPlaceholder, FormatSign, FormatTrait,
+ FormatDebugHex, FormatOptions, FormatPlaceholder, FormatSign, FormatTrait, Recovered,
};
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{Applicability, Diag, MultiSpan, PResult, SingleLabelManySpans};
use rustc_expand::base::*;
use rustc_lint_defs::builtin::NAMED_ARGUMENTS_USED_POSITIONALLY;
use rustc_lint_defs::{BufferedEarlyLint, BuiltinLintDiag, LintId};
-use rustc_parse::parser::Recovered;
use rustc_parse_format as parse;
use rustc_span::symbol::{Ident, Symbol};
use rustc_span::{BytePos, ErrorGuaranteed, InnerSpan, Span};
@@ -112,7 +111,7 @@
_ => return Err(err),
}
}
- Ok(Recovered::Yes) => (),
+ Ok(Recovered::Yes(_)) => (),
Ok(Recovered::No) => unreachable!(),
}
}
@@ -315,7 +314,7 @@
let mut used = vec![false; args.explicit_args().len()];
let mut invalid_refs = Vec::new();
- let mut numeric_refences_to_named_arg = Vec::new();
+ let mut numeric_references_to_named_arg = Vec::new();
enum ArgRef<'a> {
Index(usize),
@@ -336,7 +335,7 @@
used[index] = true;
if arg.kind.ident().is_some() {
// This was a named argument, but it was used as a positional argument.
- numeric_refences_to_named_arg.push((index, span, used_as));
+ numeric_references_to_named_arg.push((index, span, used_as));
}
Ok(index)
} else {
@@ -544,7 +543,7 @@
// Only check for unused named argument names if there are no other errors to avoid causing
// too much noise in output errors, such as when a named argument is entirely unused.
if invalid_refs.is_empty() && !has_unused && !unnamed_arg_after_named_arg {
- for &(index, span, used_as) in &numeric_refences_to_named_arg {
+ for &(index, span, used_as) in &numeric_references_to_named_arg {
let (position_sp_to_replace, position_sp_for_msg) = match used_as {
Placeholder(pspan) => (span, pspan),
Precision => {
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index e3d050d..8874efa 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -670,11 +670,8 @@
let to_ty = fx.monomorphize(to_ty);
fn is_fat_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
- ty.builtin_deref(true).is_some_and(
- |ty::TypeAndMut { ty: pointee_ty, mutbl: _ }| {
- has_ptr_meta(fx.tcx, pointee_ty)
- },
- )
+ ty.builtin_deref(true)
+ .is_some_and(|pointee_ty| has_ptr_meta(fx.tcx, pointee_ty))
}
if is_fat_ptr(fx, from_ty) {
diff --git a/compiler/rustc_codegen_cranelift/src/common.rs b/compiler/rustc_codegen_cranelift/src/common.rs
index 2a24d61..21d0cd2 100644
--- a/compiler/rustc_codegen_cranelift/src/common.rs
+++ b/compiler/rustc_codegen_cranelift/src/common.rs
@@ -7,7 +7,7 @@
use rustc_middle::ty::TypeFoldable;
use rustc_span::source_map::Spanned;
use rustc_target::abi::call::FnAbi;
-use rustc_target::abi::{Integer, Primitive};
+use rustc_target::abi::{Float, Integer, Primitive};
use rustc_target::spec::{HasTargetSpec, Target};
use crate::constant::ConstantCx;
@@ -32,10 +32,12 @@
Integer::I64 => types::I64,
Integer::I128 => types::I128,
},
- Primitive::F16 => unimplemented!("f16_f128"),
- Primitive::F32 => types::F32,
- Primitive::F64 => types::F64,
- Primitive::F128 => unimplemented!("f16_f128"),
+ Primitive::Float(float) => match float {
+ Float::F16 => unimplemented!("f16_f128"),
+ Float::F32 => types::F32,
+ Float::F64 => types::F64,
+ Float::F128 => unimplemented!("f16_f128"),
+ },
// FIXME(erikdesjardins): handle non-default addrspace ptr sizes
Primitive::Pointer(_) => pointer_ty(tcx),
}
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index 79a9050..cafdc05 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -586,7 +586,7 @@
intrinsic_args!(fx, args => (base, offset); intrinsic);
let offset = offset.load_scalar(fx);
- let pointee_ty = base.layout().ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = base.layout().ty.builtin_deref(true).unwrap();
let pointee_size = fx.layout_of(pointee_ty).size.bytes();
let ptr_diff = if pointee_size != 1 {
fx.bcx.ins().imul_imm(offset, pointee_size as i64)
@@ -610,7 +610,7 @@
let val = val.load_scalar(fx);
let count = count.load_scalar(fx);
- let pointee_ty = dst.layout().ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = dst.layout().ty.builtin_deref(true).unwrap();
let pointee_size = fx.layout_of(pointee_ty).size.bytes();
let count = if pointee_size != 1 {
fx.bcx.ins().imul_imm(count, pointee_size as i64)
@@ -715,7 +715,7 @@
// Cranelift treats loads as volatile by default
// FIXME correctly handle unaligned_volatile_load
- let inner_layout = fx.layout_of(ptr.layout().ty.builtin_deref(true).unwrap().ty);
+ let inner_layout = fx.layout_of(ptr.layout().ty.builtin_deref(true).unwrap());
let val = CValue::by_ref(Pointer::new(ptr.load_scalar(fx)), inner_layout);
ret.write_cvalue(fx, val);
}
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index 67f9d83..452b598 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -974,7 +974,7 @@
intrinsic_args!(fx, args => (ptr, offset); intrinsic);
let (lane_count, ptr_lane_ty) = ptr.layout().ty.simd_size_and_type(fx.tcx);
- let pointee_ty = ptr_lane_ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = ptr_lane_ty.builtin_deref(true).unwrap();
let pointee_size = fx.layout_of(pointee_ty).size.bytes();
let (ret_lane_count, ret_lane_ty) = ret.layout().ty.simd_size_and_type(fx.tcx);
let ret_lane_layout = fx.layout_of(ret_lane_ty);
diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index c9f84b6..e72951b 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -95,7 +95,7 @@
pub(crate) use rustc_middle::mir::{self, *};
pub(crate) use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
pub(crate) use rustc_middle::ty::{
- self, FloatTy, Instance, InstanceDef, IntTy, ParamEnv, Ty, TyCtxt, TypeAndMut, UintTy,
+ self, FloatTy, Instance, InstanceDef, IntTy, ParamEnv, Ty, TyCtxt, UintTy,
};
pub(crate) use rustc_span::Span;
pub(crate) use rustc_target::abi::{Abi, FieldIdx, Scalar, Size, VariantIdx, FIRST_VARIANT};
diff --git a/compiler/rustc_codegen_cranelift/src/num.rs b/compiler/rustc_codegen_cranelift/src/num.rs
index 7148580..4d96a26 100644
--- a/compiler/rustc_codegen_cranelift/src/num.rs
+++ b/compiler/rustc_codegen_cranelift/src/num.rs
@@ -388,12 +388,8 @@
in_lhs: CValue<'tcx>,
in_rhs: CValue<'tcx>,
) -> CValue<'tcx> {
- let is_thin_ptr = in_lhs
- .layout()
- .ty
- .builtin_deref(true)
- .map(|TypeAndMut { ty, mutbl: _ }| !has_ptr_meta(fx.tcx, ty))
- .unwrap_or(true);
+ let is_thin_ptr =
+ in_lhs.layout().ty.builtin_deref(true).map(|ty| !has_ptr_meta(fx.tcx, ty)).unwrap_or(true);
if is_thin_ptr {
match bin_op {
@@ -404,7 +400,7 @@
codegen_compare_bin_op(fx, bin_op, false, lhs, rhs)
}
BinOp::Offset => {
- let pointee_ty = in_lhs.layout().ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = in_lhs.layout().ty.builtin_deref(true).unwrap();
let (base, offset) = (in_lhs, in_rhs.load_scalar(fx));
let pointee_size = fx.layout_of(pointee_ty).size.bytes();
let ptr_diff = fx.bcx.ins().imul_imm(offset, pointee_size as i64);
diff --git a/compiler/rustc_codegen_cranelift/src/unsize.rs b/compiler/rustc_codegen_cranelift/src/unsize.rs
index f33bacb..4acbc8a 100644
--- a/compiler/rustc_codegen_cranelift/src/unsize.rs
+++ b/compiler/rustc_codegen_cranelift/src/unsize.rs
@@ -127,7 +127,7 @@
let dst_ty = dst.layout().ty;
let mut coerce_ptr = || {
let (base, info) =
- if fx.layout_of(src.layout().ty.builtin_deref(true).unwrap().ty).is_unsized() {
+ if fx.layout_of(src.layout().ty.builtin_deref(true).unwrap()).is_unsized() {
let (old_base, old_info) = src.load_scalar_pair(fx);
unsize_ptr(fx, old_base, src.layout(), dst.layout(), Some(old_info))
} else {
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index dded6df..a11abd0 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -819,7 +819,7 @@
}
pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, '_, 'tcx>) -> CPlace<'tcx> {
- let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty);
+ let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap());
if has_ptr_meta(fx.tcx, inner_layout.ty) {
let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)
diff --git a/compiler/rustc_codegen_cranelift/src/vtable.rs b/compiler/rustc_codegen_cranelift/src/vtable.rs
index 04e2432..14c607c 100644
--- a/compiler/rustc_codegen_cranelift/src/vtable.rs
+++ b/compiler/rustc_codegen_cranelift/src/vtable.rs
@@ -59,7 +59,7 @@
if let ty::Ref(_, ty, _) = arg.layout().ty.kind() {
if ty.is_dyn_star() {
- let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap().ty);
+ let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap());
let dyn_star = CPlace::for_ptr(Pointer::new(arg.load_scalar(fx)), inner_layout);
let ptr = dyn_star.place_field(fx, FieldIdx::ZERO).to_ptr();
let vtable =
diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index 23a5e5f..4a3b6f6 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -1301,19 +1301,13 @@
fn memmove(
&mut self,
dst: RValue<'gcc>,
- dst_align: Align,
+ _dst_align: Align,
src: RValue<'gcc>,
- src_align: Align,
+ _src_align: Align,
size: RValue<'gcc>,
flags: MemFlags,
) {
- if flags.contains(MemFlags::NONTEMPORAL) {
- // HACK(nox): This is inefficient but there is no nontemporal memmove.
- let val = self.load(src.get_type().get_pointee().expect("get_pointee"), src, src_align);
- let ptr = self.pointercast(dst, self.type_ptr_to(self.val_ty(val)));
- self.store_with_flags(val, ptr, dst_align, flags);
- return;
- }
+ assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memmove not supported");
let size = self.intcast(size, self.type_size_t(), false);
let _is_volatile = flags.contains(MemFlags::VOLATILE);
let dst = self.pointercast(dst, self.type_i8p());
@@ -1335,6 +1329,7 @@
_align: Align,
flags: MemFlags,
) {
+ assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memset not supported");
let _is_volatile = flags.contains(MemFlags::VOLATILE);
let ptr = self.pointercast(ptr, self.type_i8p());
let memset = self.context.get_builtin_function("memset");
diff --git a/compiler/rustc_codegen_gcc/src/type_of.rs b/compiler/rustc_codegen_gcc/src/type_of.rs
index 01056c1..2155cab 100644
--- a/compiler/rustc_codegen_gcc/src/type_of.rs
+++ b/compiler/rustc_codegen_gcc/src/type_of.rs
@@ -8,8 +8,8 @@
use rustc_middle::ty::{self, Ty, TypeVisitableExt};
use rustc_target::abi::call::{CastTarget, FnAbi, Reg};
use rustc_target::abi::{
- self, Abi, Align, FieldsShape, Int, Integer, PointeeInfo, Pointer, Size, TyAbiInterface,
- Variants, F128, F16, F32, F64,
+ self, Abi, Align, FieldsShape, Float, Int, Integer, PointeeInfo, Pointer, Size, TyAbiInterface,
+ Variants,
};
use crate::abi::{FnAbiGcc, FnAbiGccExt, GccType};
@@ -283,10 +283,7 @@
match scalar.primitive() {
Int(i, true) => cx.type_from_integer(i),
Int(i, false) => cx.type_from_unsigned_integer(i),
- F16 => cx.type_f16(),
- F32 => cx.type_f32(),
- F64 => cx.type_f64(),
- F128 => cx.type_f128(),
+ Float(f) => cx.type_from_float(f),
Pointer(address_space) => {
// If we know the alignment, pick something better than i8.
let pointee = if let Some(pointee) = self.pointee_info_at(cx, offset) {
diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 123aef0..a6a3f0f 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -583,7 +583,7 @@
let element_type_index = unsafe { llvm::LLVMRustGetElementTypeArgIndex(callsite) };
if element_type_index >= 0 {
let arg_ty = self.args[element_type_index as usize].layout.ty;
- let pointee_ty = arg_ty.builtin_deref(true).expect("Must be pointer argument").ty;
+ let pointee_ty = arg_ty.builtin_deref(true).expect("Must be pointer argument");
let element_type_attr = unsafe {
llvm::LLVMRustCreateElementTypeAttr(bx.llcx, bx.layout_of(pointee_ty).llvm_type(bx))
};
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index e09869c..71d4343 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -904,8 +904,8 @@
Primitive::Int(Integer::I16, _) => cx.type_i16(),
Primitive::Int(Integer::I32, _) => cx.type_i32(),
Primitive::Int(Integer::I64, _) => cx.type_i64(),
- Primitive::F32 => cx.type_f32(),
- Primitive::F64 => cx.type_f64(),
+ Primitive::Float(Float::F32) => cx.type_f32(),
+ Primitive::Float(Float::F64) => cx.type_f64(),
// FIXME(erikdesjardins): handle non-default addrspace ptr sizes
Primitive::Pointer(_) => cx.type_from_integer(dl.ptr_sized_integer()),
_ => unreachable!(),
@@ -950,7 +950,7 @@
bx.shuffle_vector(value, bx.const_undef(vec_ty), bx.const_vector(&indices))
}
(InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd), Abi::Scalar(s))
- if s.primitive() == Primitive::F64 =>
+ if s.primitive() == Primitive::Float(Float::F64) =>
{
bx.bitcast(value, bx.cx.type_i64())
}
@@ -986,8 +986,8 @@
match s.primitive() {
// MIPS only supports register-length arithmetics.
Primitive::Int(Integer::I8 | Integer::I16, _) => bx.zext(value, bx.cx.type_i32()),
- Primitive::F32 => bx.bitcast(value, bx.cx.type_i32()),
- Primitive::F64 => bx.bitcast(value, bx.cx.type_i64()),
+ Primitive::Float(Float::F32) => bx.bitcast(value, bx.cx.type_i32()),
+ Primitive::Float(Float::F64) => bx.bitcast(value, bx.cx.type_i64()),
_ => value,
}
}
@@ -1027,7 +1027,7 @@
bx.shuffle_vector(value, bx.const_undef(vec_ty), bx.const_vector(&indices))
}
(InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd), Abi::Scalar(s))
- if s.primitive() == Primitive::F64 =>
+ if s.primitive() == Primitive::Float(Float::F64) =>
{
bx.bitcast(value, bx.cx.type_f64())
}
@@ -1064,8 +1064,8 @@
// MIPS only supports register-length arithmetics.
Primitive::Int(Integer::I8, _) => bx.trunc(value, bx.cx.type_i8()),
Primitive::Int(Integer::I16, _) => bx.trunc(value, bx.cx.type_i16()),
- Primitive::F32 => bx.bitcast(value, bx.cx.type_f32()),
- Primitive::F64 => bx.bitcast(value, bx.cx.type_f64()),
+ Primitive::Float(Float::F32) => bx.bitcast(value, bx.cx.type_f32()),
+ Primitive::Float(Float::F64) => bx.bitcast(value, bx.cx.type_f64()),
_ => value,
}
}
@@ -1100,7 +1100,7 @@
cx.type_vector(elem_ty, count * 2)
}
(InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd), Abi::Scalar(s))
- if s.primitive() == Primitive::F64 =>
+ if s.primitive() == Primitive::Float(Float::F64) =>
{
cx.type_i64()
}
@@ -1136,8 +1136,8 @@
match s.primitive() {
// MIPS only supports register-length arithmetics.
Primitive::Int(Integer::I8 | Integer::I16, _) => cx.type_i32(),
- Primitive::F32 => cx.type_i32(),
- Primitive::F64 => cx.type_i64(),
+ Primitive::Float(Float::F32) => cx.type_i32(),
+ Primitive::Float(Float::F64) => cx.type_i64(),
_ => layout.llvm_type(cx),
}
}
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 1a1b4ae..230c58d 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -576,7 +576,7 @@
}
}
}
- abi::F16 | abi::F32 | abi::F64 | abi::F128 => {}
+ abi::Float(_) => {}
}
}
@@ -976,6 +976,7 @@
align: Align,
flags: MemFlags,
) {
+ assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memset not supported");
let is_volatile = flags.contains(MemFlags::VOLATILE);
unsafe {
llvm::LLVMRustBuildMemSet(
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index e5fecdd..f44738b 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1281,7 +1281,7 @@
let mut names = generics
.parent
.map_or_else(Vec::new, |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id)));
- names.extend(generics.params.iter().map(|param| param.name));
+ names.extend(generics.own_params.iter().map(|param| param.name));
names
}
}
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
index 657e9ce..bacd74f 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
@@ -122,10 +122,7 @@
// Niche tags are always normalized to unsized integers of the correct size.
match tag.primitive() {
Primitive::Int(t, _) => t,
- Primitive::F16 => Integer::I16,
- Primitive::F32 => Integer::I32,
- Primitive::F64 => Integer::I64,
- Primitive::F128 => Integer::I128,
+ Primitive::Float(f) => Integer::from_size(f.size()).unwrap(),
// FIXME(erikdesjardins): handle non-default addrspace ptr sizes
Primitive::Pointer(_) => {
// If the niche is the NULL value of a reference, then `discr_enum_ty` will be
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 4fdaa59..6149c18 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -512,7 +512,7 @@
let mut names = generics.parent.map_or_else(Vec::new, |def_id| {
get_parameter_names(cx, cx.tcx.generics_of(def_id))
});
- names.extend(generics.params.iter().map(|param| param.name));
+ names.extend(generics.own_params.iter().map(|param| param.name));
names
}
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 56550dbf..b0b8677 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -18,7 +18,7 @@
use rustc_middle::ty::{self, GenericArgsRef, Ty};
use rustc_middle::{bug, span_bug};
use rustc_span::{sym, Span, Symbol};
-use rustc_target::abi::{self, Align, HasDataLayout, Primitive, Size};
+use rustc_target::abi::{self, Align, Float, HasDataLayout, Primitive, Size};
use rustc_target::spec::{HasTargetSpec, PanicStrategy};
use std::cmp::Ordering;
@@ -231,13 +231,17 @@
emit_va_arg(self, args[0], ret_ty)
}
}
- Primitive::F16 => bug!("the va_arg intrinsic does not work with `f16`"),
- Primitive::F64 | Primitive::Pointer(_) => {
+ Primitive::Float(Float::F16) => {
+ bug!("the va_arg intrinsic does not work with `f16`")
+ }
+ Primitive::Float(Float::F64) | Primitive::Pointer(_) => {
emit_va_arg(self, args[0], ret_ty)
}
// `va_arg` should never be used with the return type f32.
- Primitive::F32 => bug!("the va_arg intrinsic does not work with `f32`"),
- Primitive::F128 => {
+ Primitive::Float(Float::F32) => {
+ bug!("the va_arg intrinsic does not work with `f32`")
+ }
+ Primitive::Float(Float::F128) => {
bug!("the va_arg intrinsic does not work with `f128`")
}
}
@@ -2383,7 +2387,7 @@
let pointee = in_elem.builtin_deref(true).unwrap_or_else(|| {
span_bug!(span, "must be called with a vector of pointer types as first argument")
});
- let layout = bx.layout_of(pointee.ty);
+ let layout = bx.layout_of(pointee);
let ptrs = args[0].immediate();
// The second argument must be a ptr-sized integer.
// (We don't care about the signedness, this is wrapping anyway.)
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 40ed6ba..5f60fd2 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -6,7 +6,7 @@
use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
use rustc_middle::ty::{self, Ty, TypeVisitableExt};
use rustc_target::abi::{Abi, Align, FieldsShape};
-use rustc_target::abi::{Int, Pointer, F128, F16, F32, F64};
+use rustc_target::abi::{Float, Int, Pointer};
use rustc_target::abi::{Scalar, Size, Variants};
use std::fmt::Write;
@@ -272,10 +272,7 @@
fn scalar_llvm_type_at<'a>(&self, cx: &CodegenCx<'a, 'tcx>, scalar: Scalar) -> &'a Type {
match scalar.primitive() {
Int(i, _) => cx.type_from_integer(i),
- F16 => cx.type_f16(),
- F32 => cx.type_f32(),
- F64 => cx.type_f64(),
- F128 => cx.type_f128(),
+ Float(f) => cx.type_from_float(f),
Pointer(address_space) => cx.type_ptr_ext(address_space),
}
}
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 2f57695..d36972d 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1060,7 +1060,7 @@
// Make sure that we've actually unwrapped the rcvr down
// to a pointer or ref to `dyn* Trait`.
- if !op.layout.ty.builtin_deref(true).unwrap().ty.is_dyn_star() {
+ if !op.layout.ty.builtin_deref(true).unwrap().is_dyn_star() {
span_bug!(span, "can't codegen a virtual call on {:#?}", op);
}
let place = op.deref(bx.cx());
diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index 50bf1ef..6b89636 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -120,7 +120,7 @@
{
fn deref(&self, bx: &mut Bx) -> Self {
bx.cx().layout_of(
- self.ty.builtin_deref(true).unwrap_or_else(|| bug!("cannot deref `{}`", self.ty)).ty,
+ self.ty.builtin_deref(true).unwrap_or_else(|| bug!("cannot deref `{}`", self.ty)),
)
}
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 4cff6eb..0479dd1 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -245,8 +245,7 @@
.layout
.ty
.builtin_deref(true)
- .unwrap_or_else(|| bug!("deref of non-pointer {:?}", self))
- .ty;
+ .unwrap_or_else(|| bug!("deref of non-pointer {:?}", self));
let (llptr, llextra) = match self.val {
OperandValue::Immediate(llptr) => (llptr, None),
@@ -485,8 +484,7 @@
.layout
.ty
.builtin_deref(true)
- .unwrap_or_else(|| bug!("indirect_dest has non-pointer type: {:?}", indirect_dest))
- .ty;
+ .unwrap_or_else(|| bug!("indirect_dest has non-pointer type: {:?}", indirect_dest));
let OperandValue::Ref(PlaceValue { llval: llptr, llextra: Some(llextra), .. }) = self
else {
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 06663a0..2976ca1 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -308,17 +308,15 @@
self.assume_scalar_range(bx, imm, from_scalar, from_backend_ty);
imm = match (from_scalar.primitive(), to_scalar.primitive()) {
- (Int(..) | F16 | F32 | F64 | F128, Int(..) | F16 | F32 | F64 | F128) => {
- bx.bitcast(imm, to_backend_ty)
- }
+ (Int(..) | Float(_), Int(..) | Float(_)) => bx.bitcast(imm, to_backend_ty),
(Pointer(..), Pointer(..)) => bx.pointercast(imm, to_backend_ty),
(Int(..), Pointer(..)) => bx.ptradd(bx.const_null(bx.type_ptr()), imm),
(Pointer(..), Int(..)) => bx.ptrtoint(imm, to_backend_ty),
- (F16 | F32 | F64 | F128, Pointer(..)) => {
+ (Float(_), Pointer(..)) => {
let int_imm = bx.bitcast(imm, bx.cx().type_isize());
bx.ptradd(bx.const_null(bx.type_ptr()), int_imm)
}
- (Pointer(..), F16 | F32 | F64 | F128) => {
+ (Pointer(..), Float(_)) => {
let int_imm = bx.ptrtoint(imm, bx.cx().type_isize());
bx.bitcast(int_imm, to_backend_ty)
}
@@ -904,8 +902,7 @@
mir::BinOp::Offset => {
let pointee_type = input_ty
.builtin_deref(true)
- .unwrap_or_else(|| bug!("deref of non-pointer {:?}", input_ty))
- .ty;
+ .unwrap_or_else(|| bug!("deref of non-pointer {:?}", input_ty));
let pointee_layout = bx.cx().layout_of(pointee_type);
if pointee_layout.is_zst() {
// `Offset` works in terms of the size of pointee,
diff --git a/compiler/rustc_codegen_ssa/src/traits/type_.rs b/compiler/rustc_codegen_ssa/src/traits/type_.rs
index ccb3562..403f6a7 100644
--- a/compiler/rustc_codegen_ssa/src/traits/type_.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/type_.rs
@@ -7,7 +7,7 @@
use rustc_middle::ty::layout::TyAndLayout;
use rustc_middle::ty::{self, Ty};
use rustc_target::abi::call::{ArgAbi, CastTarget, FnAbi, Reg};
-use rustc_target::abi::{AddressSpace, Integer};
+use rustc_target::abi::{AddressSpace, Float, Integer};
// This depends on `Backend` and not `BackendTypes`, because consumers will probably want to use
// `LayoutOf` or `HasTyCtxt`. This way, they don't have to add a constraint on it themselves.
@@ -65,6 +65,16 @@
}
}
+ fn type_from_float(&self, f: Float) -> Self::Type {
+ use Float::*;
+ match f {
+ F16 => self.type_f16(),
+ F32 => self.type_f32(),
+ F64 => self.type_f64(),
+ F128 => self.type_f128(),
+ }
+ }
+
fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool {
ty.needs_drop(self.tcx(), ty::ParamEnv::reveal_all())
}
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index b79d744..20f0f27 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -69,9 +69,6 @@
accessing {$allocation} which contains a function
const_eval_deref_vtable_pointer =
accessing {$allocation} which contains a vtable
-const_eval_different_allocations =
- `{$name}` called on pointers into different allocations
-
const_eval_division_by_zero =
dividing by zero
const_eval_division_overflow =
@@ -234,12 +231,18 @@
const_eval_nullary_intrinsic_fail =
could not evaluate nullary intrinsic
+const_eval_offset_from_different_allocations =
+ `{$name}` called on pointers into different allocations
+const_eval_offset_from_different_integers =
+ `{$name}` called on different pointers without provenance (i.e., without an associated allocation)
const_eval_offset_from_overflow =
`{$name}` called when first pointer is too far ahead of second
-
-const_eval_offset_from_test = out-of-bounds `offset_from`
+const_eval_offset_from_test =
+ out-of-bounds `offset_from`
const_eval_offset_from_underflow =
`{$name}` called when first pointer is too far before second
+const_eval_offset_from_unsigned_overflow =
+ `ptr_offset_from_unsigned` called when first pointer has smaller offset than second: {$a_offset} < {$b_offset}
const_eval_operator_non_const =
cannot call non-const operator in {const_eval_const_context}s
@@ -381,8 +384,6 @@
const_eval_unreachable_unwind =
unwinding past a stack frame that does not allow unwinding
-const_eval_unsigned_offset_from_overflow =
- `ptr_offset_from_unsigned` called when first pointer has smaller offset than second: {$a_offset} < {$b_offset}
const_eval_unsized_local = unsized locals are not supported
const_eval_unstable_const_fn = `{$def_path}` is not yet stable as a const fn
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index 71a41e9..d9f329c 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -222,7 +222,7 @@
// This codepath solely exists for `valtree_to_const_value` to not need to generate
// a `ConstValue::Indirect` for wide references, so it is tightly restricted to just
// that case.
- let pointee_ty = imm.layout.ty.builtin_deref(false).unwrap().ty; // `false` = no raw ptrs
+ let pointee_ty = imm.layout.ty.builtin_deref(false).unwrap(); // `false` = no raw ptrs
debug_assert!(
matches!(
ecx.tcx.struct_tail_without_normalization(pointee_ty).kind(),
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 88ce5a7..52c3162 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -8,21 +8,16 @@
use rustc_middle::ty::GenericArgsRef;
use rustc_middle::ty::{Ty, TyCtxt};
use rustc_middle::{
- mir::{
- self,
- interpret::{
- Allocation, ConstAllocation, GlobalId, InterpResult, PointerArithmetic, Scalar,
- },
- BinOp, ConstValue, NonDivergingIntrinsic,
- },
+ mir::{self, BinOp, ConstValue, NonDivergingIntrinsic},
ty::layout::TyAndLayout,
};
use rustc_span::symbol::{sym, Symbol};
use rustc_target::abi::Size;
use super::{
- memory::MemoryKind, util::ensure_monomorphic_enough, CheckInAllocMsg, ImmTy, InterpCx,
- MPlaceTy, Machine, OpTy, Pointer,
+ memory::MemoryKind, util::ensure_monomorphic_enough, Allocation, CheckInAllocMsg,
+ ConstAllocation, GlobalId, ImmTy, InterpCx, InterpResult, MPlaceTy, Machine, OpTy, Pointer,
+ PointerArithmetic, Scalar,
};
use crate::fluent_generated as fluent;
@@ -249,14 +244,22 @@
match (self.ptr_try_get_alloc_id(a), self.ptr_try_get_alloc_id(b)) {
(Err(a), Err(b)) => {
// Neither pointer points to an allocation.
- // If these are inequal or null, this *will* fail the deref check below.
+ // This is okay only if they are the same.
+ if a != b {
+ // We'd catch this below in the "dereferenceable" check, but
+ // show a nicer error for this particular case.
+ throw_ub_custom!(
+ fluent::const_eval_offset_from_different_integers,
+ name = intrinsic_name,
+ );
+ }
(a, b)
}
(Err(_), _) | (_, Err(_)) => {
// We managed to find a valid allocation for one pointer, but not the other.
// That means they are definitely not pointing to the same allocation.
throw_ub_custom!(
- fluent::const_eval_different_allocations,
+ fluent::const_eval_offset_from_different_allocations,
name = intrinsic_name,
);
}
@@ -264,7 +267,7 @@
// Found allocation for both. They must be into the same allocation.
if a_alloc_id != b_alloc_id {
throw_ub_custom!(
- fluent::const_eval_different_allocations,
+ fluent::const_eval_offset_from_different_allocations,
name = intrinsic_name,
);
}
@@ -286,7 +289,7 @@
// a < b
if intrinsic_name == sym::ptr_offset_from_unsigned {
throw_ub_custom!(
- fluent::const_eval_unsigned_offset_from_overflow,
+ fluent::const_eval_offset_from_unsigned_overflow,
a_offset = a_offset,
b_offset = b_offset,
);
@@ -602,7 +605,7 @@
nonoverlapping: bool,
) -> InterpResult<'tcx> {
let count = self.read_target_usize(count)?;
- let layout = self.layout_of(src.layout.ty.builtin_deref(true).unwrap().ty)?;
+ let layout = self.layout_of(src.layout.ty.builtin_deref(true).unwrap())?;
let (size, align) = (layout.size, layout.align.abi);
// `checked_mul` enforces a too small bound (the correct one would probably be target_isize_max),
// but no actual allocation can be big enough for the difference to be noticeable.
@@ -646,7 +649,7 @@
byte: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>,
count: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>,
) -> InterpResult<'tcx> {
- let layout = self.layout_of(dst.layout.ty.builtin_deref(true).unwrap().ty)?;
+ let layout = self.layout_of(dst.layout.ty.builtin_deref(true).unwrap())?;
let dst = self.read_pointer(dst)?;
let byte = self.read_scalar(byte)?.to_u8()?;
@@ -685,7 +688,7 @@
lhs: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>,
rhs: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::Provenance>,
) -> InterpResult<'tcx, Scalar<M::Provenance>> {
- let layout = self.layout_of(lhs.layout.ty.builtin_deref(true).unwrap().ty)?;
+ let layout = self.layout_of(lhs.layout.ty.builtin_deref(true).unwrap())?;
assert!(layout.is_sized());
let get_bytes = |this: &InterpCx<'mir, 'tcx, M>,
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
index 9af755e..2d5dbbd 100644
--- a/compiler/rustc_const_eval/src/interpret/operator.rs
+++ b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -357,7 +357,7 @@
Offset => {
let ptr = left.to_scalar().to_pointer(self)?;
let offset_count = right.to_scalar().to_target_isize(self)?;
- let pointee_ty = left.layout.ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = left.layout.ty.builtin_deref(true).unwrap();
// We cannot overflow i64 as a type's size must be <= isize::MAX.
let pointee_size = i64::try_from(self.layout_of(pointee_ty)?.size.bytes()).unwrap();
diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
index e5241f1..809aca1 100644
--- a/compiler/rustc_const_eval/src/interpret/place.rs
+++ b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -415,7 +415,7 @@
val: &ImmTy<'tcx, M::Provenance>,
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
let pointee_type =
- val.layout.ty.builtin_deref(true).expect("`ref_to_mplace` called on non-ptr type").ty;
+ val.layout.ty.builtin_deref(true).expect("`ref_to_mplace` called on non-ptr type");
let layout = self.layout_of(pointee_type)?;
let (ptr, meta) = val.to_scalar_and_meta();
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
index f9786ac..d43dc46 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -738,7 +738,7 @@
let cause = ObligationCause::new(
terminator.source_info.span,
self.body.source.def_id().expect_local(),
- ObligationCauseCode::ItemObligation(callee),
+ ObligationCauseCode::WhereClause(callee),
);
let normalized_predicates = ocx.normalize(&cause, param_env, predicates);
ocx.register_obligations(traits::predicates_for_generics(
diff --git a/compiler/rustc_const_eval/src/transform/validate.rs b/compiler/rustc_const_eval/src/transform/validate.rs
index 837c02a..c95166d 100644
--- a/compiler/rustc_const_eval/src/transform/validate.rs
+++ b/compiler/rustc_const_eval/src/transform/validate.rs
@@ -1291,7 +1291,7 @@
)) => {
let src_ty = src.ty(&self.body.local_decls, self.tcx);
let op_src_ty = if let Some(src_deref) = src_ty.builtin_deref(true) {
- src_deref.ty
+ src_deref
} else {
self.fail(
location,
@@ -1301,7 +1301,7 @@
};
let dst_ty = dst.ty(&self.body.local_decls, self.tcx);
let op_dst_ty = if let Some(dst_deref) = dst_ty.builtin_deref(true) {
- dst_deref.ty
+ dst_deref
} else {
self.fail(
location,
diff --git a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
index 8c4af5e..3659750 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -115,7 +115,7 @@
// Special magic check for references and boxes (i.e., special pointer types).
if let Some(pointee) = this.ty.builtin_deref(false) {
- let pointee = cx.layout_of(pointee.ty)?;
+ let pointee = cx.layout_of(pointee)?;
// We need to ensure that the LLVM attributes `aligned` and `dereferenceable(size)` are satisfied.
if pointee.align.abi.bytes() > 1 {
// 0x01-filling is not aligned.
diff --git a/compiler/rustc_data_structures/src/fingerprint.rs b/compiler/rustc_data_structures/src/fingerprint.rs
index 9995c08..1bee159 100644
--- a/compiler/rustc_data_structures/src/fingerprint.rs
+++ b/compiler/rustc_data_structures/src/fingerprint.rs
@@ -1,3 +1,4 @@
+use crate::stable_hasher::impl_stable_traits_for_trivial_type;
use crate::stable_hasher::{Hash64, StableHasher, StableHasherResult};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use std::hash::{Hash, Hasher};
diff --git a/compiler/rustc_data_structures/src/flock/windows.rs b/compiler/rustc_data_structures/src/flock/windows.rs
index 9be1065..7dc7266 100644
--- a/compiler/rustc_data_structures/src/flock/windows.rs
+++ b/compiler/rustc_data_structures/src/flock/windows.rs
@@ -2,6 +2,7 @@
use std::io;
use std::os::windows::prelude::*;
use std::path::Path;
+use tracing::debug;
use windows::{
Win32::Foundation::{ERROR_INVALID_FUNCTION, HANDLE},
diff --git a/compiler/rustc_data_structures/src/graph/implementation/mod.rs b/compiler/rustc_data_structures/src/graph/implementation/mod.rs
index 3910c6f..8cf4b41 100644
--- a/compiler/rustc_data_structures/src/graph/implementation/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/implementation/mod.rs
@@ -22,6 +22,7 @@
use rustc_index::bit_set::BitSet;
use std::fmt::Debug;
+use tracing::debug;
#[cfg(test)]
mod tests;
diff --git a/compiler/rustc_data_structures/src/graph/implementation/tests.rs b/compiler/rustc_data_structures/src/graph/implementation/tests.rs
index 3ae5f58..b4dbd65 100644
--- a/compiler/rustc_data_structures/src/graph/implementation/tests.rs
+++ b/compiler/rustc_data_structures/src/graph/implementation/tests.rs
@@ -1,4 +1,5 @@
use crate::graph::implementation::*;
+use tracing::debug;
type TestGraph = Graph<&'static str, &'static str>;
diff --git a/compiler/rustc_data_structures/src/graph/scc/mod.rs b/compiler/rustc_data_structures/src/graph/scc/mod.rs
index 5021e5e..914a6a1 100644
--- a/compiler/rustc_data_structures/src/graph/scc/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/scc/mod.rs
@@ -10,6 +10,7 @@
use crate::graph::{DirectedGraph, NumEdges, Successors};
use rustc_index::{Idx, IndexSlice, IndexVec};
use std::ops::Range;
+use tracing::{debug, instrument};
#[cfg(test)]
mod tests;
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index 8dd85b2..85b5a3c 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -42,12 +42,52 @@
#![feature(unwrap_infallible)]
// tidy-alphabetical-end
-#[macro_use]
-extern crate tracing;
+pub use atomic_ref::AtomicRef;
+pub use ena::snapshot_vec;
+pub use ena::undo_log;
+pub use ena::unify;
+pub use rustc_index::static_assert_size;
use std::fmt;
-pub use rustc_index::static_assert_size;
+pub mod aligned;
+pub mod base_n;
+pub mod binary_search_util;
+pub mod captures;
+pub mod fingerprint;
+pub mod flat_map_in_place;
+pub mod flock;
+pub mod frozen;
+pub mod fx;
+pub mod graph;
+pub mod intern;
+pub mod jobserver;
+pub mod marker;
+pub mod memmap;
+pub mod obligation_forest;
+pub mod owned_slice;
+pub mod packed;
+pub mod profiling;
+pub mod sharded;
+pub mod sip128;
+pub mod small_c_str;
+pub mod snapshot_map;
+pub mod sorted_map;
+pub mod sso;
+pub mod stable_hasher;
+pub mod stack;
+pub mod steal;
+pub mod svh;
+pub mod sync;
+pub mod tagged_ptr;
+pub mod temp_dir;
+pub mod transitive_relation;
+pub mod unhash;
+pub mod unord;
+pub mod work_queue;
+
+mod atomic_ref;
+mod hashes;
/// This calls the passed function while ensuring it won't be inlined into the caller.
#[inline(never)]
@@ -56,53 +96,6 @@
f()
}
-pub mod base_n;
-pub mod binary_search_util;
-pub mod captures;
-pub mod flat_map_in_place;
-pub mod flock;
-pub mod fx;
-pub mod graph;
-pub mod intern;
-pub mod jobserver;
-pub mod macros;
-pub mod obligation_forest;
-pub mod sip128;
-pub mod small_c_str;
-pub mod snapshot_map;
-pub mod svh;
-pub use ena::snapshot_vec;
-pub mod memmap;
-pub mod sorted_map;
-#[macro_use]
-pub mod stable_hasher;
-mod atomic_ref;
-pub mod fingerprint;
-pub mod marker;
-pub mod profiling;
-pub mod sharded;
-pub mod stack;
-pub mod sync;
-pub mod tiny_list;
-pub mod transitive_relation;
-pub mod vec_linked_list;
-pub mod work_queue;
-pub use atomic_ref::AtomicRef;
-pub mod aligned;
-pub mod frozen;
-mod hashes;
-pub mod owned_slice;
-pub mod packed;
-pub mod sso;
-pub mod steal;
-pub mod tagged_ptr;
-pub mod temp_dir;
-pub mod unhash;
-pub mod unord;
-
-pub use ena::undo_log;
-pub use ena::unify;
-
/// Returns a structure that calls `f` when dropped.
pub fn defer<F: FnOnce()>(f: F) -> OnDrop<F> {
OnDrop(Some(f))
diff --git a/compiler/rustc_data_structures/src/macros.rs b/compiler/rustc_data_structures/src/macros.rs
deleted file mode 100644
index e05491f..0000000
--- a/compiler/rustc_data_structures/src/macros.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[macro_export]
-macro_rules! enum_from_u32 {
- ($(#[$attr:meta])* pub enum $name:ident {
- $($(#[$var_attr:meta])* $variant:ident = $e:expr,)*
- }) => {
- $(#[$attr])*
- pub enum $name {
- $($(#[$var_attr])* $variant = $e),*
- }
-
- impl $name {
- pub fn from_u32(u: u32) -> Option<$name> {
- $(if u == $name::$variant as u32 {
- return Some($name::$variant)
- })*
- None
- }
- }
- };
- ($(#[$attr:meta])* pub enum $name:ident {
- $($(#[$var_attr:meta])* $variant:ident,)*
- }) => {
- $(#[$attr])*
- pub enum $name {
- $($(#[$var_attr])* $variant,)*
- }
-
- impl $name {
- pub fn from_u32(u: u32) -> Option<$name> {
- $(if u == $name::$variant as u32 {
- return Some($name::$variant)
- })*
- None
- }
- }
- }
-}
diff --git a/compiler/rustc_data_structures/src/obligation_forest/mod.rs b/compiler/rustc_data_structures/src/obligation_forest/mod.rs
index a479086..d477b86 100644
--- a/compiler/rustc_data_structures/src/obligation_forest/mod.rs
+++ b/compiler/rustc_data_structures/src/obligation_forest/mod.rs
@@ -70,12 +70,12 @@
//! aren't needed anymore.
use crate::fx::{FxHashMap, FxHashSet};
-
use std::cell::Cell;
use std::collections::hash_map::Entry;
use std::fmt::Debug;
use std::hash;
use std::marker::PhantomData;
+use tracing::debug;
mod graphviz;
diff --git a/compiler/rustc_data_structures/src/packed.rs b/compiler/rustc_data_structures/src/packed.rs
index b8d4b29..0a392d9 100644
--- a/compiler/rustc_data_structures/src/packed.rs
+++ b/compiler/rustc_data_structures/src/packed.rs
@@ -3,8 +3,10 @@
use std::cmp::Ordering;
use std::fmt;
-#[repr(packed(8))]
+/// A packed 128-bit integer. Useful for reducing the size of structures in
+/// some cases.
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[repr(packed(8))]
pub struct Pu128(pub u128);
impl Pu128 {
diff --git a/compiler/rustc_data_structures/src/profiling.rs b/compiler/rustc_data_structures/src/profiling.rs
index 2569684..c6d51a5 100644
--- a/compiler/rustc_data_structures/src/profiling.rs
+++ b/compiler/rustc_data_structures/src/profiling.rs
@@ -99,6 +99,7 @@
use measureme::{EventIdBuilder, Profiler, SerializableString, StringId};
use parking_lot::RwLock;
use smallvec::SmallVec;
+use tracing::warn;
bitflags::bitflags! {
#[derive(Clone, Copy)]
diff --git a/compiler/rustc_data_structures/src/stable_hasher.rs b/compiler/rustc_data_structures/src/stable_hasher.rs
index 8418b4b..b5bdf2e 100644
--- a/compiler/rustc_data_structures/src/stable_hasher.rs
+++ b/compiler/rustc_data_structures/src/stable_hasher.rs
@@ -296,6 +296,8 @@
};
}
+pub(crate) use impl_stable_traits_for_trivial_type;
+
impl_stable_traits_for_trivial_type!(i8);
impl_stable_traits_for_trivial_type!(i16);
impl_stable_traits_for_trivial_type!(i32);
diff --git a/compiler/rustc_data_structures/src/tiny_list.rs b/compiler/rustc_data_structures/src/tiny_list.rs
deleted file mode 100644
index 11a408f..0000000
--- a/compiler/rustc_data_structures/src/tiny_list.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//! A singly-linked list.
-//!
-//! Using this data structure only makes sense under very specific
-//! circumstances:
-//!
-//! - If you have a list that rarely stores more than one element, then this
-//! data-structure can store the element without allocating and only uses as
-//! much space as an `Option<(T, usize)>`. If T can double as the `Option`
-//! discriminant, it will even only be as large as `T, usize`.
-//!
-//! If you expect to store more than 1 element in the common case, steer clear
-//! and use a `Vec<T>`, `Box<[T]>`, or a `SmallVec<T>`.
-
-#[cfg(test)]
-mod tests;
-
-#[derive(Clone)]
-pub struct TinyList<T> {
- head: Option<Element<T>>,
-}
-
-impl<T: PartialEq> TinyList<T> {
- #[inline]
- pub fn new() -> TinyList<T> {
- TinyList { head: None }
- }
-
- #[inline]
- pub fn new_single(data: T) -> TinyList<T> {
- TinyList { head: Some(Element { data, next: None }) }
- }
-
- #[inline]
- pub fn insert(&mut self, data: T) {
- self.head = Some(Element { data, next: self.head.take().map(Box::new) });
- }
-
- #[inline]
- pub fn remove(&mut self, data: &T) -> bool {
- self.head = match &mut self.head {
- Some(head) if head.data == *data => head.next.take().map(|x| *x),
- Some(head) => return head.remove_next(data),
- None => return false,
- };
- true
- }
-
- #[inline]
- pub fn contains(&self, data: &T) -> bool {
- let mut elem = self.head.as_ref();
- while let Some(e) = elem {
- if &e.data == data {
- return true;
- }
- elem = e.next.as_deref();
- }
- false
- }
-}
-
-#[derive(Clone)]
-struct Element<T> {
- data: T,
- next: Option<Box<Element<T>>>,
-}
-
-impl<T: PartialEq> Element<T> {
- fn remove_next(mut self: &mut Self, data: &T) -> bool {
- loop {
- match self.next {
- Some(ref mut next) if next.data == *data => {
- self.next = next.next.take();
- return true;
- }
- Some(ref mut next) => self = next,
- None => return false,
- }
- }
- }
-}
diff --git a/compiler/rustc_data_structures/src/tiny_list/tests.rs b/compiler/rustc_data_structures/src/tiny_list/tests.rs
deleted file mode 100644
index 4b95e62..0000000
--- a/compiler/rustc_data_structures/src/tiny_list/tests.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use super::*;
-
-extern crate test;
-use test::{black_box, Bencher};
-
-impl<T> TinyList<T> {
- fn len(&self) -> usize {
- let (mut elem, mut count) = (self.head.as_ref(), 0);
- while let Some(e) = elem {
- count += 1;
- elem = e.next.as_deref();
- }
- count
- }
-}
-
-#[test]
-fn test_contains_and_insert() {
- fn do_insert(i: u32) -> bool {
- i % 2 == 0
- }
-
- let mut list = TinyList::new();
-
- for i in 0..10 {
- for j in 0..i {
- if do_insert(j) {
- assert!(list.contains(&j));
- } else {
- assert!(!list.contains(&j));
- }
- }
-
- assert!(!list.contains(&i));
-
- if do_insert(i) {
- list.insert(i);
- assert!(list.contains(&i));
- }
- }
-}
-
-#[test]
-fn test_remove_first() {
- let mut list = TinyList::new();
- list.insert(1);
- list.insert(2);
- list.insert(3);
- list.insert(4);
- assert_eq!(list.len(), 4);
-
- assert!(list.remove(&4));
- assert!(!list.contains(&4));
-
- assert_eq!(list.len(), 3);
- assert!(list.contains(&1));
- assert!(list.contains(&2));
- assert!(list.contains(&3));
-}
-
-#[test]
-fn test_remove_last() {
- let mut list = TinyList::new();
- list.insert(1);
- list.insert(2);
- list.insert(3);
- list.insert(4);
- assert_eq!(list.len(), 4);
-
- assert!(list.remove(&1));
- assert!(!list.contains(&1));
-
- assert_eq!(list.len(), 3);
- assert!(list.contains(&2));
- assert!(list.contains(&3));
- assert!(list.contains(&4));
-}
-
-#[test]
-fn test_remove_middle() {
- let mut list = TinyList::new();
- list.insert(1);
- list.insert(2);
- list.insert(3);
- list.insert(4);
- assert_eq!(list.len(), 4);
-
- assert!(list.remove(&2));
- assert!(!list.contains(&2));
-
- assert_eq!(list.len(), 3);
- assert!(list.contains(&1));
- assert!(list.contains(&3));
- assert!(list.contains(&4));
-}
-
-#[test]
-fn test_remove_single() {
- let mut list = TinyList::new();
- list.insert(1);
- assert_eq!(list.len(), 1);
-
- assert!(list.remove(&1));
- assert!(!list.contains(&1));
-
- assert_eq!(list.len(), 0);
-}
-
-#[bench]
-fn bench_insert_empty(b: &mut Bencher) {
- b.iter(|| {
- let mut list = black_box(TinyList::new());
- list.insert(1);
- list
- })
-}
-
-#[bench]
-fn bench_insert_one(b: &mut Bencher) {
- b.iter(|| {
- let mut list = black_box(TinyList::new_single(0));
- list.insert(1);
- list
- })
-}
-
-#[bench]
-fn bench_contains_empty(b: &mut Bencher) {
- b.iter(|| black_box(TinyList::new()).contains(&1));
-}
-
-#[bench]
-fn bench_contains_unknown(b: &mut Bencher) {
- b.iter(|| black_box(TinyList::new_single(0)).contains(&1));
-}
-
-#[bench]
-fn bench_contains_one(b: &mut Bencher) {
- b.iter(|| black_box(TinyList::new_single(1)).contains(&1));
-}
-
-#[bench]
-fn bench_remove_empty(b: &mut Bencher) {
- b.iter(|| black_box(TinyList::new()).remove(&1));
-}
-
-#[bench]
-fn bench_remove_unknown(b: &mut Bencher) {
- b.iter(|| black_box(TinyList::new_single(0)).remove(&1));
-}
-
-#[bench]
-fn bench_remove_one(b: &mut Bencher) {
- b.iter(|| black_box(TinyList::new_single(1)).remove(&1));
-}
diff --git a/compiler/rustc_data_structures/src/vec_linked_list.rs b/compiler/rustc_data_structures/src/vec_linked_list.rs
deleted file mode 100644
index fda72c9..0000000
--- a/compiler/rustc_data_structures/src/vec_linked_list.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use rustc_index::{Idx, IndexVec};
-
-pub fn iter<Ls>(
- first: Option<Ls::LinkIndex>,
- links: &Ls,
-) -> impl Iterator<Item = Ls::LinkIndex> + '_
-where
- Ls: Links,
-{
- VecLinkedListIterator { links, current: first }
-}
-
-pub struct VecLinkedListIterator<Ls>
-where
- Ls: Links,
-{
- links: Ls,
- current: Option<Ls::LinkIndex>,
-}
-
-impl<Ls> Iterator for VecLinkedListIterator<Ls>
-where
- Ls: Links,
-{
- type Item = Ls::LinkIndex;
-
- fn next(&mut self) -> Option<Ls::LinkIndex> {
- if let Some(c) = self.current {
- self.current = <Ls as Links>::next(&self.links, c);
- Some(c)
- } else {
- None
- }
- }
-}
-
-pub trait Links {
- type LinkIndex: Copy;
-
- fn next(links: &Self, index: Self::LinkIndex) -> Option<Self::LinkIndex>;
-}
-
-impl<Ls> Links for &Ls
-where
- Ls: Links,
-{
- type LinkIndex = Ls::LinkIndex;
-
- fn next(links: &Self, index: Ls::LinkIndex) -> Option<Ls::LinkIndex> {
- <Ls as Links>::next(links, index)
- }
-}
-
-pub trait LinkElem {
- type LinkIndex: Copy;
-
- fn next(elem: &Self) -> Option<Self::LinkIndex>;
-}
-
-impl<L, E> Links for IndexVec<L, E>
-where
- E: LinkElem<LinkIndex = L>,
- L: Idx,
-{
- type LinkIndex = L;
-
- fn next(links: &Self, index: L) -> Option<L> {
- <E as LinkElem>::next(&links[index])
- }
-}
diff --git a/compiler/rustc_expand/src/placeholders.rs b/compiler/rustc_expand/src/placeholders.rs
index 7026425..e21f041 100644
--- a/compiler/rustc_expand/src/placeholders.rs
+++ b/compiler/rustc_expand/src/placeholders.rs
@@ -174,7 +174,10 @@
}]),
AstFragmentKind::Variants => AstFragment::Variants(smallvec![ast::Variant {
attrs: Default::default(),
- data: ast::VariantData::Struct { fields: Default::default(), recovered: false },
+ data: ast::VariantData::Struct {
+ fields: Default::default(),
+ recovered: ast::Recovered::No
+ },
disr_expr: None,
id,
ident,
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 244c479..7d991e2 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1308,9 +1308,9 @@
pub pat: &'hir Pat<'hir>,
pub ty: Option<&'hir Ty<'hir>>,
pub init: &'hir Expr<'hir>,
- /// `Some` when this let expressions is not in a syntanctically valid location.
+ /// `Recovered::Yes` when this let expressions is not in a syntanctically valid location.
/// Used to prevent building MIR in such situations.
- pub is_recovered: Option<ErrorGuaranteed>,
+ pub recovered: ast::Recovered,
}
#[derive(Debug, Clone, Copy, HashStable_Generic)]
@@ -3030,11 +3030,7 @@
/// A struct variant.
///
/// E.g., `Bar { .. }` as in `enum Foo { Bar { .. } }`.
- Struct {
- fields: &'hir [FieldDef<'hir>],
- // FIXME: investigate making this a `Option<ErrorGuaranteed>`
- recovered: bool,
- },
+ Struct { fields: &'hir [FieldDef<'hir>], recovered: ast::Recovered },
/// A tuple variant.
///
/// E.g., `Bar(..)` as in `enum Foo { Bar(..) }`.
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index fa89a4a..0b095db 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -768,7 +768,7 @@
ExprKind::DropTemps(ref subexpression) => {
try_visit!(visitor.visit_expr(subexpression));
}
- ExprKind::Let(LetExpr { span: _, pat, ty, init, is_recovered: _ }) => {
+ ExprKind::Let(LetExpr { span: _, pat, ty, init, recovered: _ }) => {
// match the visit order in walk_local
try_visit!(visitor.visit_expr(init));
try_visit!(visitor.visit_pat(pat));
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index e870a04..c4be67c 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -55,21 +55,27 @@
(
$( $(#[$attr:meta])* $variant:ident, $module:ident :: $name:ident, $method:ident, $target:expr, $generics:expr; )*
) => {
-
- rustc_data_structures::enum_from_u32! {
- /// A representation of all the valid lang items in Rust.
- #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)]
- pub enum LangItem {
- $(
- #[doc = concat!("The `", stringify!($name), "` lang item.")]
- ///
- $(#[$attr])*
- $variant,
- )*
- }
+ /// A representation of all the valid lang items in Rust.
+ #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)]
+ pub enum LangItem {
+ $(
+ #[doc = concat!("The `", stringify!($name), "` lang item.")]
+ $(#[$attr])*
+ $variant,
+ )*
}
impl LangItem {
+ fn from_u32(u: u32) -> Option<LangItem> {
+ // This implementation is clumsy, but makes no assumptions
+ // about how discriminant tags are allocated within the
+ // range `0 .. std::mem::variant_count::<LangItem>()`.
+ $(if u == LangItem::$variant as u32 {
+ return Some(LangItem::$variant)
+ })*
+ None
+ }
+
/// Returns the `name` symbol in `#[lang = "$name"]`.
/// For example, [`LangItem::PartialEq`]`.name()`
/// would result in [`sym::eq`] since it is `#[lang = "eq"]`.
@@ -147,7 +153,7 @@
Clone, sym::clone, clone_trait, Target::Trait, GenericRequirement::None;
Sync, sym::sync, sync_trait, Target::Trait, GenericRequirement::Exact(0);
DiscriminantKind, sym::discriminant_kind, discriminant_kind_trait, Target::Trait, GenericRequirement::None;
- /// The associated item of the [`DiscriminantKind`] trait.
+ /// The associated item of the `DiscriminantKind` trait.
Discriminant, sym::discriminant_type, discriminant_type, Target::AssocTy, GenericRequirement::None;
PointeeTrait, sym::pointee_trait, pointee_trait, Target::Trait, GenericRequirement::None;
diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
index f101c59..2bf14a2 100644
--- a/compiler/rustc_hir_analysis/src/autoderef.rs
+++ b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -68,28 +68,27 @@
}
// Otherwise, deref if type is derefable:
- let (kind, new_ty) = if let Some(ty::TypeAndMut { ty, .. }) =
- self.state.cur_ty.builtin_deref(self.include_raw_pointers)
- {
- debug_assert_eq!(ty, self.infcx.resolve_vars_if_possible(ty));
- // NOTE: we may still need to normalize the built-in deref in case
- // we have some type like `&<Ty as Trait>::Assoc`, since users of
- // autoderef expect this type to have been structurally normalized.
- if self.infcx.next_trait_solver()
- && let ty::Alias(..) = ty.kind()
- {
- let (normalized_ty, obligations) = self.structurally_normalize(ty)?;
- self.state.obligations.extend(obligations);
- (AutoderefKind::Builtin, normalized_ty)
+ let (kind, new_ty) =
+ if let Some(ty) = self.state.cur_ty.builtin_deref(self.include_raw_pointers) {
+ debug_assert_eq!(ty, self.infcx.resolve_vars_if_possible(ty));
+ // NOTE: we may still need to normalize the built-in deref in case
+ // we have some type like `&<Ty as Trait>::Assoc`, since users of
+ // autoderef expect this type to have been structurally normalized.
+ if self.infcx.next_trait_solver()
+ && let ty::Alias(..) = ty.kind()
+ {
+ let (normalized_ty, obligations) = self.structurally_normalize(ty)?;
+ self.state.obligations.extend(obligations);
+ (AutoderefKind::Builtin, normalized_ty)
+ } else {
+ (AutoderefKind::Builtin, ty)
+ }
+ } else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
+ // The overloaded deref check already normalizes the pointee type.
+ (AutoderefKind::Overloaded, ty)
} else {
- (AutoderefKind::Builtin, ty)
- }
- } else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
- // The overloaded deref check already normalizes the pointee type.
- (AutoderefKind::Overloaded, ty)
- } else {
- return None;
- };
+ return None;
+ };
self.state.steps.push((self.state.cur_ty, kind));
debug!(
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 32e1b19..fb9d97b 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -561,7 +561,7 @@
let generics = tcx.generics_of(generics);
def_id = generics.parent;
- for param in &generics.params {
+ for param in &generics.own_params {
if expected_captures.contains(¶m.def_id) {
assert_eq!(
variances[param.index as usize],
@@ -778,7 +778,7 @@
let def_id = item.id.owner_id.def_id;
let generics = tcx.generics_of(def_id);
let own_counts = generics.own_counts();
- if generics.params.len() - own_counts.lifetimes != 0 {
+ if generics.own_params.len() - own_counts.lifetimes != 0 {
let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts)
{
(_, 0) => ("type", "types", Some("u32")),
@@ -1544,7 +1544,7 @@
.collect::<FxIndexMap<_, _>>()
});
- let mut params_used = BitSet::new_empty(generics.params.len());
+ let mut params_used = BitSet::new_empty(generics.own_params.len());
for leaf in ty.walk() {
if let GenericArgKind::Type(leaf_ty) = leaf.unpack()
&& let ty::Param(param) = leaf_ty.kind()
@@ -1554,7 +1554,7 @@
}
}
- for param in &generics.params {
+ for param in &generics.own_params {
if !params_used.contains(param.index)
&& let ty::GenericParamDefKind::Type { .. } = param.kind
{
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index d275908..b2b8267 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -9,7 +9,6 @@
use rustc_hir::intravisit;
use rustc_hir::{GenericParamKind, ImplItemKind};
use rustc_infer::infer::outlives::env::OutlivesEnvironment;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
use rustc_infer::traits::{util, FulfillmentError};
use rustc_middle::ty::error::{ExpectedFound, TypeError};
@@ -176,7 +175,7 @@
let cause = ObligationCause::new(
impl_m_span,
impl_m_def_id,
- ObligationCauseCode::CompareImplItemObligation {
+ ObligationCauseCode::CompareImplItem {
impl_item_def_id: impl_m_def_id,
trait_item_def_id: trait_m.def_id,
kind: impl_m.kind,
@@ -237,7 +236,7 @@
let cause = ObligationCause::new(
span,
impl_m_def_id,
- ObligationCauseCode::CompareImplItemObligation {
+ ObligationCauseCode::CompareImplItem {
impl_item_def_id: impl_m_def_id,
trait_item_def_id: trait_m.def_id,
kind: impl_m.kind,
@@ -465,7 +464,7 @@
let cause = ObligationCause::new(
return_span,
impl_m_def_id,
- ObligationCauseCode::CompareImplItemObligation {
+ ObligationCauseCode::CompareImplItem {
impl_item_def_id: impl_m_def_id,
trait_item_def_id: trait_m.def_id,
kind: impl_m.kind,
@@ -716,7 +715,7 @@
// since we previously enforce that the trait method and impl method have the
// same generics.
let num_trait_args = trait_to_impl_args.len();
- let num_impl_args = tcx.generics_of(impl_m.container_id(tcx)).params.len();
+ let num_impl_args = tcx.generics_of(impl_m.container_id(tcx)).own_params.len();
let ty = match ty.try_fold_with(&mut RemapHiddenTyRegions {
tcx,
map,
@@ -800,10 +799,7 @@
bug!("FIXME(RPITIT): error here");
}
// Replace with infer var
- let infer_ty = self
- .ocx
- .infcx
- .next_ty_var(TypeVariableOrigin { span: self.span, param_def_id: None });
+ let infer_ty = self.ocx.infcx.next_ty_var(self.span);
self.types.insert(proj.def_id, (infer_ty, proj.args));
// Recurse into bounds
for (pred, pred_span) in self
@@ -823,7 +819,7 @@
ObligationCause::new(
self.span,
self.body_id,
- ObligationCauseCode::BindingObligation(proj.def_id, pred_span),
+ ObligationCauseCode::SpannedWhereClause(proj.def_id, pred_span),
),
self.param_env,
pred,
@@ -1494,14 +1490,16 @@
let mut error_found = None;
let impl_m_generics = tcx.generics_of(impl_m.def_id);
let trait_m_generics = tcx.generics_of(trait_m.def_id);
- let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| match param.kind {
- GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
- GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
- });
- let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| match param.kind {
- GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
- GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
- });
+ let impl_m_type_params =
+ impl_m_generics.own_params.iter().filter_map(|param| match param.kind {
+ GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
+ GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
+ });
+ let trait_m_type_params =
+ trait_m_generics.own_params.iter().filter_map(|param| match param.kind {
+ GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
+ GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => None,
+ });
for ((impl_def_id, impl_synthetic), (trait_def_id, trait_synthetic)) in
iter::zip(impl_m_type_params, trait_m_type_params)
{
@@ -1639,7 +1637,7 @@
assert_eq!(impl_item.kind, trait_item.kind);
let ty_const_params_of = |def_id| {
- tcx.generics_of(def_id).params.iter().filter(|param| {
+ tcx.generics_of(def_id).own_params.iter().filter(|param| {
matches!(
param.kind,
GenericParamDefKind::Const { .. } | GenericParamDefKind::Type { .. }
@@ -1754,7 +1752,7 @@
let impl_ty = tcx.type_of(impl_ct_def_id).instantiate_identity();
let trait_ty = tcx.type_of(trait_ct.def_id).instantiate(tcx, trait_to_impl_args);
- let code = ObligationCauseCode::CompareImplItemObligation {
+ let code = ObligationCauseCode::CompareImplItem {
impl_item_def_id: impl_ct_def_id,
trait_item_def_id: trait_ct.def_id,
kind: impl_ct.kind,
@@ -1926,7 +1924,7 @@
let cause = ObligationCause::new(
span,
impl_ty_def_id,
- ObligationCauseCode::CompareImplItemObligation {
+ ObligationCauseCode::CompareImplItem {
impl_item_def_id: impl_ty.def_id.expect_local(),
trait_item_def_id: trait_ty.def_id,
kind: impl_ty.kind,
@@ -2014,9 +2012,9 @@
);
let mk_cause = |span: Span| {
let code = if span.is_dummy() {
- traits::ItemObligation(trait_ty.def_id)
+ ObligationCauseCode::WhereClause(trait_ty.def_id)
} else {
- traits::BindingObligation(trait_ty.def_id, span)
+ ObligationCauseCode::SpannedWhereClause(trait_ty.def_id, span)
};
ObligationCause::new(impl_ty_span, impl_ty_def_id, code)
};
@@ -2140,7 +2138,7 @@
};
let mut bound_vars: smallvec::SmallVec<[ty::BoundVariableKind; 8]> =
- smallvec::SmallVec::with_capacity(tcx.generics_of(impl_ty.def_id).params.len());
+ smallvec::SmallVec::with_capacity(tcx.generics_of(impl_ty.def_id).own_params.len());
// Extend the impl's identity args with late-bound GAT vars
let normalize_impl_ty_args = ty::GenericArgs::identity_for_item(tcx, container_id)
.extend_to(tcx, impl_ty.def_id, |param, _| match param.kind {
@@ -2253,7 +2251,8 @@
};
for error in errors {
- if let traits::BindingObligation(def_id, _) = *error.root_obligation.cause.code()
+ if let ObligationCauseCode::SpannedWhereClause(def_id, _) =
+ *error.root_obligation.cause.code()
&& def_id == async_future_def_id
&& let Some(proj) = error.root_obligation.predicate.to_opt_poly_projection_pred()
&& let Some(proj) = proj.no_bound_vars()
diff --git a/compiler/rustc_hir_analysis/src/check/dropck.rs b/compiler/rustc_hir_analysis/src/check/dropck.rs
index 82a6b6b..be412dd 100644
--- a/compiler/rustc_hir_analysis/src/check/dropck.rs
+++ b/compiler/rustc_hir_analysis/src/check/dropck.rs
@@ -5,6 +5,7 @@
use rustc_errors::{codes::*, struct_span_code_err, ErrorGuaranteed};
use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
+use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::ty::util::CheckRegions;
use rustc_middle::ty::GenericArgsRef;
use rustc_middle::ty::{self, TyCtxt};
@@ -139,7 +140,7 @@
for (pred, span) in tcx.predicates_of(drop_impl_def_id).instantiate_identity(tcx) {
let normalize_cause = traits::ObligationCause::misc(span, adt_def_id);
let pred = ocx.normalize(&normalize_cause, param_env, pred);
- let cause = traits::ObligationCause::new(span, adt_def_id, traits::DropImpl);
+ let cause = traits::ObligationCause::new(span, adt_def_id, ObligationCauseCode::DropImpl);
ocx.register_obligation(traits::Obligation::new(tcx, cause, param_env, pred));
}
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 5b127e0..0578317 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -431,7 +431,7 @@
}
let gat_generics = tcx.generics_of(gat_def_id);
// FIXME(jackh726): we can also warn in the more general case
- if gat_generics.params.is_empty() {
+ if gat_generics.own_params.is_empty() {
continue;
}
@@ -1136,7 +1136,7 @@
traits::ObligationCause::new(
hir_ty.span,
wfcx.body_def_id,
- traits::FieldSized {
+ ObligationCauseCode::FieldSized {
adt_kind: match &item.kind {
ItemKind::Struct(..) => AdtKind::Struct,
ItemKind::Union(..) => AdtKind::Union,
@@ -1161,7 +1161,7 @@
let cause = traits::ObligationCause::new(
tcx.def_span(discr_def_id),
wfcx.body_def_id,
- traits::MiscObligation,
+ ObligationCauseCode::Misc,
);
wfcx.register_obligation(traits::Obligation::new(
tcx,
@@ -1278,7 +1278,11 @@
wfcx.register_wf_obligation(ty_span, Some(WellFormedLoc::Ty(item_id)), item_ty.into());
if forbid_unsized {
wfcx.register_bound(
- traits::ObligationCause::new(ty_span, wfcx.body_def_id, traits::WellFormed(None)),
+ traits::ObligationCause::new(
+ ty_span,
+ wfcx.body_def_id,
+ ObligationCauseCode::WellFormed(None),
+ ),
wfcx.param_env,
item_ty,
tcx.require_lang_item(LangItem::Sized, None),
@@ -1293,7 +1297,11 @@
if should_check_for_sync {
wfcx.register_bound(
- traits::ObligationCause::new(ty_span, wfcx.body_def_id, traits::SharedStatic),
+ traits::ObligationCause::new(
+ ty_span,
+ wfcx.body_def_id,
+ ObligationCauseCode::SharedStatic,
+ ),
wfcx.param_env,
item_ty,
tcx.require_lang_item(LangItem::Sync, Some(ty_span)),
@@ -1400,7 +1408,7 @@
// struct Foo<T = Vec<[u32]>> { .. }
//
// Here, the default `Vec<[u32]>` is not WF because `[u32]: Sized` does not hold.
- for param in &generics.params {
+ for param in &generics.own_params {
match param.kind {
GenericParamDefKind::Type { .. } => {
if is_our_default(param) {
@@ -1542,7 +1550,7 @@
let cause = traits::ObligationCause::new(
sp,
wfcx.body_def_id,
- traits::ItemObligation(def_id.to_def_id()),
+ ObligationCauseCode::WhereClause(def_id.to_def_id()),
);
traits::Obligation::new(tcx, cause, wfcx.param_env, pred)
});
@@ -1879,7 +1887,7 @@
continue;
}
- let ty_param = &ty_generics.params[index];
+ let ty_param = &ty_generics.own_params[index];
let hir_param = &hir_generics.params[index];
if ty_param.def_id != hir_param.def_id.into() {
@@ -1982,7 +1990,11 @@
let obligation = traits::Obligation::new(
tcx,
- traits::ObligationCause::new(span, self.body_def_id, traits::TrivialBound),
+ traits::ObligationCause::new(
+ span,
+ self.body_def_id,
+ ObligationCauseCode::TrivialBound,
+ ),
empty_env,
pred,
);
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index 819e092..8e1b2e8 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -571,7 +571,7 @@
if let Some(def_id) = origin.param_def_id {
// The generics of an `impl` don't have a parent, we can index directly.
let index = self.generics.param_def_id_to_index[&def_id];
- let name = self.generics.params[index as usize].name;
+ let name = self.generics.own_params[index as usize].name;
Ty::new_param(self.infcx.tcx, index, name)
} else {
diff --git a/compiler/rustc_hir_analysis/src/coherence/unsafety.rs b/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
index 13ce4f0..8a1dbc1 100644
--- a/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/unsafety.rs
@@ -14,7 +14,7 @@
trait_def: &TraitDef,
) -> Result<(), ErrorGuaranteed> {
let unsafe_attr =
- tcx.generics_of(def_id).params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle");
+ tcx.generics_of(def_id).own_params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle");
let trait_ref = trait_header.trait_ref.instantiate_identity();
match (trait_def.unsafety, unsafe_attr, trait_header.unsafety, trait_header.polarity) {
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 9198ceb..566f818 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -14,6 +14,7 @@
//! At present, however, we do run collection across all items in the
//! crate as a kind of pass. This should eventually be factored away.
+use rustc_ast::Recovered;
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
use rustc_data_structures::unord::UnordMap;
@@ -1005,10 +1006,7 @@
vis: tcx.visibility(f.def_id),
})
.collect();
- let recovered = match def {
- hir::VariantData::Struct { recovered, .. } => *recovered,
- _ => false,
- };
+ let recovered = matches!(def, hir::VariantData::Struct { recovered: Recovered::Yes(_), .. });
ty::VariantDef::new(
ident.name,
variant_did.map(LocalDefId::to_def_id),
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index f83ddc5..6b41f79 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -22,28 +22,28 @@
let trait_def_id = tcx.parent(fn_def_id);
let opaque_ty_generics = tcx.generics_of(opaque_def_id);
let opaque_ty_parent_count = opaque_ty_generics.parent_count;
- let mut params = opaque_ty_generics.params.clone();
+ let mut own_params = opaque_ty_generics.own_params.clone();
let parent_generics = tcx.generics_of(trait_def_id);
- let parent_count = parent_generics.parent_count + parent_generics.params.len();
+ let parent_count = parent_generics.parent_count + parent_generics.own_params.len();
- let mut trait_fn_params = tcx.generics_of(fn_def_id).params.clone();
+ let mut trait_fn_params = tcx.generics_of(fn_def_id).own_params.clone();
- for param in &mut params {
+ for param in &mut own_params {
param.index = param.index + parent_count as u32 + trait_fn_params.len() as u32
- opaque_ty_parent_count as u32;
}
- trait_fn_params.extend(params);
- params = trait_fn_params;
+ trait_fn_params.extend(own_params);
+ own_params = trait_fn_params;
let param_def_id_to_index =
- params.iter().map(|param| (param.def_id, param.index)).collect();
+ own_params.iter().map(|param| (param.def_id, param.index)).collect();
return ty::Generics {
parent: Some(trait_def_id),
parent_count,
- params,
+ own_params,
param_def_id_to_index,
has_self: opaque_ty_generics.has_self,
has_late_bound_regions: opaque_ty_generics.has_late_bound_regions,
@@ -124,9 +124,9 @@
let generics = tcx.generics_of(parent_def_id.to_def_id());
let param_def_idx = generics.param_def_id_to_index[¶m_id.to_def_id()];
// In the above example this would be .params[..N#0]
- let params = generics.params_to(param_def_idx as usize, tcx).to_owned();
+ let own_params = generics.params_to(param_def_idx as usize, tcx).to_owned();
let param_def_id_to_index =
- params.iter().map(|param| (param.def_id, param.index)).collect();
+ own_params.iter().map(|param| (param.def_id, param.index)).collect();
return ty::Generics {
// we set the parent of these generics to be our parent's parent so that we
@@ -134,7 +134,7 @@
// struct Foo<const N: usize, const M: usize = { ... }>;
parent: generics.parent,
parent_count: generics.parent_count,
- params,
+ own_params,
param_def_id_to_index,
has_self: generics.has_self,
has_late_bound_regions: generics.has_late_bound_regions,
@@ -274,17 +274,17 @@
parent_has_self = generics.has_self;
host_effect_index = generics.host_effect_index;
own_start = generics.count() as u32;
- generics.parent_count + generics.params.len()
+ generics.parent_count + generics.own_params.len()
});
- let mut params: Vec<_> = Vec::with_capacity(hir_generics.params.len() + has_self as usize);
+ let mut own_params: Vec<_> = Vec::with_capacity(hir_generics.params.len() + has_self as usize);
if let Some(opt_self) = opt_self {
- params.push(opt_self);
+ own_params.push(opt_self);
}
let early_lifetimes = super::early_bound_lifetimes_from_generics(tcx, hir_generics);
- params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
+ own_params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
name: param.name.ident().name,
index: own_start + i as u32,
def_id: param.def_id.to_def_id(),
@@ -293,7 +293,7 @@
}));
// Now create the real type and const parameters.
- let type_start = own_start - has_self as u32 + params.len() as u32;
+ let type_start = own_start - has_self as u32 + own_params.len() as u32;
let mut i: u32 = 0;
let mut next_index = || {
let prev = i;
@@ -304,7 +304,7 @@
const TYPE_DEFAULT_NOT_ALLOWED: &'static str = "defaults for type parameters are only allowed in \
`struct`, `enum`, `type`, or `trait` definitions";
- params.extend(hir_generics.params.iter().filter_map(|param| match param.kind {
+ own_params.extend(hir_generics.params.iter().filter_map(|param| match param.kind {
GenericParamKind::Lifetime { .. } => None,
GenericParamKind::Type { default, synthetic, .. } => {
if default.is_some() {
@@ -404,7 +404,7 @@
][..],
};
- params.extend(dummy_args.iter().map(|&arg| ty::GenericParamDef {
+ own_params.extend(dummy_args.iter().map(|&arg| ty::GenericParamDef {
index: next_index(),
name: Symbol::intern(arg),
def_id: def_id.to_def_id(),
@@ -415,7 +415,7 @@
// provide junk type parameter defs for const blocks.
if let Node::ConstBlock(_) = node {
- params.push(ty::GenericParamDef {
+ own_params.push(ty::GenericParamDef {
index: next_index(),
name: Symbol::intern("<const_ty>"),
def_id: def_id.to_def_id(),
@@ -424,12 +424,13 @@
});
}
- let param_def_id_to_index = params.iter().map(|param| (param.def_id, param.index)).collect();
+ let param_def_id_to_index =
+ own_params.iter().map(|param| (param.def_id, param.index)).collect();
ty::Generics {
parent: parent_def_id,
parent_count,
- params,
+ own_params,
param_def_id_to_index,
has_self: has_self || parent_has_self,
has_late_bound_regions: has_late_bound_regions(tcx, node),
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 4726572..7e82571 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -73,8 +73,8 @@
// opaque lifetimes, which explains the slicing below.
compute_bidirectional_outlives_predicates(
tcx,
- &tcx.generics_of(def_id.to_def_id()).params
- [tcx.generics_of(fn_def_id).params.len()..],
+ &tcx.generics_of(def_id.to_def_id()).own_params
+ [tcx.generics_of(fn_def_id).own_params.len()..],
&mut predicates,
);
@@ -300,7 +300,7 @@
};
debug!(?lifetimes);
- compute_bidirectional_outlives_predicates(tcx, &generics.params, &mut predicates);
+ compute_bidirectional_outlives_predicates(tcx, &generics.own_params, &mut predicates);
debug!(?predicates);
}
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index a5f038d..3ef132a 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -1562,7 +1562,7 @@
ObjectLifetimeDefault::Ambiguous => None,
};
generics
- .params
+ .own_params
.iter()
.filter_map(|param| {
match self.tcx.def_kind(param.def_id) {
@@ -1668,7 +1668,7 @@
binding.ident,
ty::AssocKind::Fn,
) {
- bound_vars.extend(self.tcx.generics_of(assoc_fn.def_id).params.iter().map(
+ bound_vars.extend(self.tcx.generics_of(assoc_fn.def_id).own_params.iter().map(
|param| match param.kind {
ty::GenericParamDefKind::Lifetime => ty::BoundVariableKind::Region(
ty::BoundRegionKind::BrNamed(param.def_id, param.name),
@@ -2003,7 +2003,8 @@
// just consider args to be unconstrained.
let generics = self.tcx.generics_of(alias_def);
let mut walker = ConstrainedCollectorPostHirTyLowering {
- arg_is_constrained: vec![false; generics.params.len()].into_boxed_slice(),
+ arg_is_constrained: vec![false; generics.own_params.len()]
+ .into_boxed_slice(),
};
walker.visit_ty(self.tcx.type_of(alias_def).instantiate_identity());
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 5ccfd06..24a5349 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -255,7 +255,7 @@
debug!(?parent_node);
debug!(?generics, ?arg_idx);
if let Some(param_def_id) = generics
- .params
+ .own_params
.iter()
.filter(|param| param.kind.is_ty_or_const())
.nth(match generics.has_self && generics.parent.is_none() {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index 8e64a94..bc6ecae 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -1299,7 +1299,7 @@
// same name as the assoc type name in type binding
let generics = tcx.generics_of(def_id);
let matching_param =
- generics.params.iter().find(|p| p.name.as_str() == binding.ident.as_str());
+ generics.own_params.iter().find(|p| p.name.as_str() == binding.ident.as_str());
// Now emit the appropriate suggestion
if let Some(matching_param) = matching_param {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
index e6a7dfa..749f78e 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
@@ -196,7 +196,7 @@
let mut args: SmallVec<[ty::GenericArg<'tcx>; 8]> = SmallVec::with_capacity(count);
// Iterate over each segment of the path.
while let Some((def_id, defs)) = stack.pop() {
- let mut params = defs.params.iter().peekable();
+ let mut params = defs.own_params.iter().peekable();
// If we have already computed the generic arguments for parents,
// we can use those directly.
@@ -312,7 +312,7 @@
// We're going to iterate over the parameters to sort them out, and
// show that order to the user as a possible order for the parameters
let mut param_types_present = defs
- .params
+ .own_params
.iter()
.map(|param| (param.kind.to_ord(), param.clone()))
.collect::<Vec<(ParamKindOrd, GenericParamDef)>>();
@@ -435,13 +435,13 @@
// Subtracting from param count to ensure type params synthesized from `impl Trait`
// cannot be explicitly specified.
let synth_type_param_count = gen_params
- .params
+ .own_params
.iter()
.filter(|param| matches!(param.kind, ty::GenericParamDefKind::Type { synthetic: true, .. }))
.count();
let named_type_param_count = param_counts.types - has_self as usize - synth_type_param_count;
let synth_const_param_count = gen_params
- .params
+ .own_params
.iter()
.filter(|param| {
matches!(param.kind, ty::GenericParamDefKind::Const { is_host_effect: true, .. })
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index f721344..591d554 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -411,7 +411,7 @@
// Traits always have `Self` as a generic parameter, which means they will not return early
// here and so associated type bindings will be handled regardless of whether there are any
// non-`Self` generic parameters.
- if generics.params.is_empty() {
+ if generics.own_params.is_empty() {
return (tcx.mk_args(parent_args), arg_count);
}
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
index 97ba946..297cfe7 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
@@ -227,7 +227,7 @@
.skip(1) // Remove `Self` for `ExistentialPredicate`.
.map(|(index, arg)| {
if arg == dummy_self.into() {
- let param = &generics.params[index];
+ let param = &generics.own_params[index];
missing_type_params.push(param.name);
Ty::new_misc_error(tcx).into()
} else if arg.walk().any(|arg| arg == dummy_self.into()) {
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check.rs b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
index caa8509..002be61 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
@@ -114,7 +114,7 @@
.collect();
let mut res = Ok(());
- for param in &impl_generics.params {
+ for param in &impl_generics.own_params {
match param.kind {
// Disallow ANY unconstrained type parameters.
ty::GenericParamDefKind::Type { .. } => {
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
index be1be1a..de697b0 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -212,7 +212,7 @@
traits::ObligationCause::new(
impl1_span,
impl1_def_id,
- traits::ObligationCauseCode::BindingObligation(impl2_node.def_id(), span),
+ traits::ObligationCauseCode::SpannedWhereClause(impl2_node.def_id(), span),
)
},
);
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 66b86c9..e757408 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -184,7 +184,7 @@
let def_kind = tcx.def_kind(item_def_id);
match def_kind {
DefKind::Static { .. } => tcx.ensure().eval_static_initializer(item_def_id),
- DefKind::Const if tcx.generics_of(item_def_id).params.is_empty() => {
+ DefKind::Const if tcx.generics_of(item_def_id).own_params.is_empty() => {
let instance = ty::Instance::new(item_def_id.into(), ty::GenericArgs::empty());
let cid = GlobalId { instance, promoted: None };
let param_env = ty::ParamEnv::reveal_all();
diff --git a/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs b/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
index dcab571e..9ddba7a 100644
--- a/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_hir_analysis/src/structured_errors/wrong_number_of_generic_args.rs
@@ -421,7 +421,7 @@
// We could not gather enough lifetime parameters in the scope.
// We use the parameter names from the target type's definition instead.
self.gen_params
- .params
+ .own_params
.iter()
.skip(self.params_offset + self.num_provided_lifetime_args())
.take(num_params_to_take)
@@ -464,7 +464,7 @@
})
};
self.gen_params
- .params
+ .own_params
.iter()
.skip(self.params_offset + self.num_provided_type_or_const_args())
.take(num_params_to_take)
@@ -1076,7 +1076,7 @@
} else {
let params = self
.gen_params
- .params
+ .own_params
.iter()
.skip(self.params_offset)
.take(bound)
diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs
index 42885b0..27fdea0 100644
--- a/compiler/rustc_hir_analysis/src/variance/mod.rs
+++ b/compiler/rustc_hir_analysis/src/variance/mod.rs
@@ -133,7 +133,7 @@
let mut generics = generics;
while let Some(def_id) = generics.parent {
generics = tcx.generics_of(def_id);
- for param in &generics.params {
+ for param in &generics.own_params {
match param.kind {
ty::GenericParamDefKind::Lifetime => {
variances[param.index as usize] = ty::Bivariant;
diff --git a/compiler/rustc_hir_analysis/src/variance/solve.rs b/compiler/rustc_hir_analysis/src/variance/solve.rs
index 54da327..e64c672 100644
--- a/compiler/rustc_hir_analysis/src/variance/solve.rs
+++ b/compiler/rustc_hir_analysis/src/variance/solve.rs
@@ -76,7 +76,7 @@
let tcx = self.terms_cx.tcx;
// Make all const parameters invariant.
- for param in generics.params.iter() {
+ for param in generics.own_params.iter() {
if let ty::GenericParamDefKind::Const { .. } = param.kind {
variances[param.index as usize] = ty::Invariant;
}
diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
index 4ff6678..c2e62e4 100644
--- a/compiler/rustc_hir_typeck/src/_match.rs
+++ b/compiler/rustc_hir_typeck/src/_match.rs
@@ -5,7 +5,6 @@
use rustc_hir::def_id::LocalDefId;
use rustc_hir::{self as hir, ExprKind, PatKind};
use rustc_hir_pretty::ty_to_string;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_middle::ty::{self, Ty};
use rustc_span::Span;
use rustc_trait_selection::traits::{
@@ -67,7 +66,7 @@
// arm for inconsistent arms or to the whole match when a `()` type
// is required).
Expectation::ExpectHasType(ety) if ety != tcx.types.unit => ety,
- _ => self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr.span }),
+ _ => self.next_ty_var(expr.span),
};
CoerceMany::with_coercion_sites(coerce_first, arms)
};
@@ -575,8 +574,7 @@
// ...but otherwise we want to use any supertype of the
// scrutinee. This is sort of a workaround, see note (*) in
// `check_pat` for some details.
- let scrut_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: scrut.span });
+ let scrut_ty = self.next_ty_var(scrut.span);
self.check_expr_has_type_or_error(scrut, scrut_ty, |_| {});
scrut_ty
}
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index dfd0b7c..defb557 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -9,11 +9,11 @@
use rustc_hir::def::{self, CtorKind, Namespace, Res};
use rustc_hir::def_id::DefId;
use rustc_hir_analysis::autoderef::Autoderef;
+use rustc_infer::traits::ObligationCauseCode;
use rustc_infer::{
infer,
- traits::{self, Obligation},
+ traits::{self, Obligation, ObligationCause},
};
-use rustc_infer::{infer::type_variable::TypeVariableOrigin, traits::ObligationCause};
use rustc_middle::ty::adjustment::{
Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability,
};
@@ -118,7 +118,11 @@
};
// we must check that return type of called functions is WF:
- self.register_wf_obligation(output.into(), call_expr.span, traits::WellFormed(None));
+ self.register_wf_obligation(
+ output.into(),
+ call_expr.span,
+ ObligationCauseCode::WellFormed(None),
+ );
output
}
@@ -180,14 +184,12 @@
infer::FnCall,
closure_args.coroutine_closure_sig(),
);
- let tupled_upvars_ty = self
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: callee_expr.span });
+ let tupled_upvars_ty = self.next_ty_var(callee_expr.span);
// We may actually receive a coroutine back whose kind is different
// from the closure that this dispatched from. This is because when
// we have no captures, we automatically implement `FnOnce`. This
// impl forces the closure kind to `FnOnce` i.e. `u8`.
- let kind_ty = self
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: callee_expr.span });
+ let kind_ty = self.next_ty_var(callee_expr.span);
let call_sig = self.tcx.mk_fn_sig(
[coroutine_closure_sig.tupled_inputs_ty],
coroutine_closure_sig.to_coroutine(
@@ -298,12 +300,7 @@
let Some(trait_def_id) = opt_trait_def_id else { continue };
let opt_input_type = opt_arg_exprs.map(|arg_exprs| {
- Ty::new_tup_from_iter(
- self.tcx,
- arg_exprs.iter().map(|e| {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: e.span })
- }),
- )
+ Ty::new_tup_from_iter(self.tcx, arg_exprs.iter().map(|e| self.next_ty_var(e.span)))
});
if let Some(ok) = self.lookup_method_in_trait(
@@ -532,9 +529,9 @@
self.register_bound(
ty,
self.tcx.require_lang_item(hir::LangItem::Tuple, Some(sp)),
- traits::ObligationCause::new(sp, self.body_id, traits::RustCall),
+ traits::ObligationCause::new(sp, self.body_id, ObligationCauseCode::RustCall),
);
- self.require_type_is_sized(ty, sp, traits::RustCall);
+ self.require_type_is_sized(ty, sp, ObligationCauseCode::RustCall);
} else {
self.dcx().emit_err(errors::RustCallIncorrectArgs { span: sp });
}
diff --git a/compiler/rustc_hir_typeck/src/check.rs b/compiler/rustc_hir_typeck/src/check.rs
index b106eca..89e64cf 100644
--- a/compiler/rustc_hir_typeck/src/check.rs
+++ b/compiler/rustc_hir_typeck/src/check.rs
@@ -8,14 +8,12 @@
use rustc_hir::intravisit::Visitor;
use rustc_hir::lang_items::LangItem;
use rustc_hir_analysis::check::{check_function_signature, forbid_intrinsic_abi};
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::RegionVariableOrigin;
use rustc_infer::traits::WellFormedLoc;
use rustc_middle::ty::{self, Binder, Ty, TyCtxt};
use rustc_span::def_id::LocalDefId;
use rustc_span::symbol::sym;
use rustc_target::spec::abi::Abi;
-use rustc_trait_selection::traits;
use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
/// Helper used for fns and closures. Does the grungy work of checking a function
@@ -77,7 +75,7 @@
fcx.register_wf_obligation(
param_ty.into(),
param.span,
- traits::WellFormed(Some(WellFormedLoc::Param {
+ ObligationCauseCode::WellFormed(Some(WellFormedLoc::Param {
function: fn_def_id,
param_idx: idx,
})),
@@ -102,7 +100,7 @@
param.pat.span,
// ty.span == binding_span iff this is a closure parameter with no type ascription,
// or if it's an implicit `self` parameter
- traits::SizedArgumentType(
+ ObligationCauseCode::SizedArgumentType(
if ty_span == Some(param.span) && tcx.is_closure_like(fn_def_id.into()) {
None
} else {
@@ -122,10 +120,18 @@
hir::FnRetTy::Return(ty) => ty.span,
};
- fcx.require_type_is_sized(declared_ret_ty, return_or_body_span, traits::SizedReturnType);
+ fcx.require_type_is_sized(
+ declared_ret_ty,
+ return_or_body_span,
+ ObligationCauseCode::SizedReturnType,
+ );
// We checked the root's signature during wfcheck, but not the child.
if fcx.tcx.is_typeck_child(fn_def_id.to_def_id()) {
- fcx.require_type_is_sized(declared_ret_ty, return_or_body_span, traits::WellFormed(None));
+ fcx.require_type_is_sized(
+ declared_ret_ty,
+ return_or_body_span,
+ ObligationCauseCode::WellFormed(None),
+ );
}
fcx.is_whole_body.set(true);
@@ -142,7 +148,7 @@
// We have special-cased the case where the function is declared
// `-> dyn Foo` and we don't actually relate it to the
// `fcx.ret_coercion`, so just instantiate a type variable.
- actual_return_ty = fcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span });
+ actual_return_ty = fcx.next_ty_var(span);
debug!("actual_return_ty replaced with {:?}", actual_return_ty);
}
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index 8652692..f52f95d 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -6,9 +6,9 @@
use rustc_hir as hir;
use rustc_hir::lang_items::LangItem;
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes};
use rustc_infer::infer::{InferOk, InferResult};
+use rustc_infer::traits::ObligationCauseCode;
use rustc_macros::{TypeFoldable, TypeVisitable};
use rustc_middle::ty::visit::{TypeVisitable, TypeVisitableExt};
use rustc_middle::ty::GenericArgs;
@@ -73,8 +73,7 @@
let parent_args =
GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id(expr_def_id.to_def_id()));
- let tupled_upvars_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
+ let tupled_upvars_ty = self.next_ty_var(expr_span);
// FIXME: We could probably actually just unify this further --
// instead of having a `FnSig` and a `Option<CoroutineTypes>`,
@@ -101,9 +100,7 @@
// Create a type variable (for now) to represent the closure kind.
// It will be unified during the upvar inference phase (`upvar.rs`)
- None => {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
- }
+ None => self.next_ty_var(expr_span),
};
let closure_args = ty::ClosureArgs::new(
@@ -122,11 +119,12 @@
let yield_ty = match kind {
hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _)
| hir::CoroutineKind::Coroutine(_) => {
- let yield_ty = self.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: expr_span,
- });
- self.require_type_is_sized(yield_ty, expr_span, traits::SizedYieldType);
+ let yield_ty = self.next_ty_var(expr_span);
+ self.require_type_is_sized(
+ yield_ty,
+ expr_span,
+ ObligationCauseCode::SizedYieldType,
+ );
yield_ty
}
// HACK(-Ztrait-solver=next): In the *old* trait solver, we must eagerly
@@ -134,11 +132,12 @@
// in this block in projection correctly. In the new trait solver, it is
// not a problem.
hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _) => {
- let yield_ty = self.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: expr_span,
- });
- self.require_type_is_sized(yield_ty, expr_span, traits::SizedYieldType);
+ let yield_ty = self.next_ty_var(expr_span);
+ self.require_type_is_sized(
+ yield_ty,
+ expr_span,
+ ObligationCauseCode::SizedYieldType,
+ );
Ty::new_adt(
tcx,
@@ -163,8 +162,7 @@
// Resume type defaults to `()` if the coroutine has no argument.
let resume_ty = liberated_sig.inputs().get(0).copied().unwrap_or(tcx.types.unit);
- let interior =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
+ let interior = self.next_ty_var(expr_span);
self.deferred_coroutine_interiors.borrow_mut().push((
expr_def_id,
body.id(),
@@ -177,7 +175,7 @@
// ty of `().`
let kind_ty = match kind {
hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) => {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
+ self.next_ty_var(expr_span)
}
_ => tcx.types.unit,
};
@@ -212,23 +210,18 @@
}
};
// Compute all of the variables that will be used to populate the coroutine.
- let resume_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
- let interior =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
+ let resume_ty = self.next_ty_var(expr_span);
+ let interior = self.next_ty_var(expr_span);
let closure_kind_ty = match expected_kind {
Some(kind) => Ty::from_closure_kind(tcx, kind),
// Create a type variable (for now) to represent the closure kind.
// It will be unified during the upvar inference phase (`upvar.rs`)
- None => {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
- }
+ None => self.next_ty_var(expr_span),
};
- let coroutine_captures_by_ref_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
+ let coroutine_captures_by_ref_ty = self.next_ty_var(expr_span);
let closure_args = ty::CoroutineClosureArgs::new(
tcx,
ty::CoroutineClosureArgsParts {
@@ -260,13 +253,10 @@
// Create a type variable (for now) to represent the closure kind.
// It will be unified during the upvar inference phase (`upvar.rs`)
- None => {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
- }
+ None => self.next_ty_var(expr_span),
};
- let coroutine_upvars_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
+ let coroutine_upvars_ty = self.next_ty_var(expr_span);
// We need to turn the liberated signature that we got from HIR, which
// looks something like `|Args...| -> T`, into a signature that is suitable
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index df92af8..ff0377d 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -41,7 +41,6 @@
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{Coercion, DefineOpaqueTypes, InferOk, InferResult};
use rustc_infer::traits::{IfExpressionCause, MatchExpressionArmCause};
use rustc_infer::traits::{Obligation, PredicateObligation};
@@ -257,11 +256,7 @@
if b.is_ty_var() {
// Two unresolved type variables: create a `Coerce` predicate.
- let target_ty = if self.use_lub {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: self.cause.span })
- } else {
- b
- };
+ let target_ty = if self.use_lub { self.next_ty_var(self.cause.span) } else { b };
let mut obligations = Vec::with_capacity(2);
for &source_ty in &[a, b] {
@@ -557,8 +552,7 @@
// the `CoerceUnsized` target type and the expected type.
// We only have the latter, so we use an inference variable
// for the former and let type inference do the rest.
- let origin = TypeVariableOrigin { param_def_id: None, span: self.cause.span };
- let coerce_target = self.next_ty_var(origin);
+ let coerce_target = self.next_ty_var(self.cause.span);
let mut coercion = self.unify_and(coerce_target, target, |target| {
let unsize = Adjustment { kind: Adjust::Pointer(PointerCoercion::Unsize), target };
match reborrow {
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
index 60c0b18..b211249 100644
--- a/compiler/rustc_hir_typeck/src/demand.rs
+++ b/compiler/rustc_hir_typeck/src/demand.rs
@@ -330,16 +330,13 @@
hir.body(hir.maybe_body_owned_by(self.body_id).expect("expected item to have body"));
expr_finder.visit_expr(body.value);
- use rustc_infer::infer::type_variable::*;
- use rustc_middle::infer::unify_key::*;
// Replaces all of the variables in the given type with a fresh inference variable.
let mut fudger = BottomUpFolder {
tcx: self.tcx,
ty_op: |ty| {
if let ty::Infer(infer) = ty.kind() {
match infer {
- ty::TyVar(_) => self
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: DUMMY_SP }),
+ ty::TyVar(_) => self.next_ty_var(DUMMY_SP),
ty::IntVar(_) => self.next_int_var(),
ty::FloatVar(_) => self.next_float_var(),
ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
@@ -353,10 +350,7 @@
lt_op: |_| self.tcx.lifetimes.re_erased,
ct_op: |ct| {
if let ty::ConstKind::Infer(_) = ct.kind() {
- self.next_const_var(
- ct.ty(),
- ConstVariableOrigin { param_def_id: None, span: DUMMY_SP },
- )
+ self.next_const_var(ct.ty(), DUMMY_SP)
} else {
ct
}
diff --git a/compiler/rustc_hir_typeck/src/expectation.rs b/compiler/rustc_hir_typeck/src/expectation.rs
index 5106d29..91deae4 100644
--- a/compiler/rustc_hir_typeck/src/expectation.rs
+++ b/compiler/rustc_hir_typeck/src/expectation.rs
@@ -1,4 +1,3 @@
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_middle::ty::{self, Ty};
use rustc_span::Span;
@@ -110,7 +109,6 @@
/// Like `only_has_type`, but instead of returning `None` if no
/// hard constraint exists, creates a fresh type variable.
pub(super) fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
- self.only_has_type(fcx)
- .unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span }))
+ self.only_has_type(fcx).unwrap_or_else(|| fcx.next_ty_var(span))
}
}
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 7b552bb..cdf17f3 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -37,7 +37,6 @@
use rustc_hir::{ExprKind, HirId, QPath};
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer as _;
use rustc_infer::infer;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::DefineOpaqueTypes;
use rustc_infer::infer::InferOk;
use rustc_infer::traits::query::NoSolution;
@@ -80,8 +79,7 @@
return Ty::new_error(self.tcx(), reported);
}
- let adj_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr.span });
+ let adj_ty = self.next_ty_var(expr.span);
self.apply_adjustments(
expr,
vec![Adjustment { kind: Adjust::NeverToAny, target: adj_ty }],
@@ -575,7 +573,7 @@
self.require_type_is_sized_deferred(
input,
span,
- traits::SizedArgumentType(None),
+ ObligationCauseCode::SizedArgumentType(None),
);
}
}
@@ -593,7 +591,7 @@
self.require_type_is_sized_deferred(
output,
call.map_or(expr.span, |e| e.span),
- traits::SizedCallReturnType,
+ ObligationCauseCode::SizedCallReturnType,
);
}
@@ -1251,7 +1249,7 @@
}
});
- self.require_type_is_sized(lhs_ty, lhs.span, traits::AssignmentLhsSized);
+ self.require_type_is_sized(lhs_ty, lhs.span, ObligationCauseCode::AssignmentLhsSized);
if let Err(guar) = (lhs_ty, rhs_ty).error_reported() {
Ty::new_error(self.tcx, guar)
@@ -1271,7 +1269,7 @@
// otherwise check exactly as a let statement
self.check_decl((let_expr, hir_id).into());
// but return a bool, for this is a boolean expression
- if let Some(error_guaranteed) = let_expr.is_recovered {
+ if let ast::Recovered::Yes(error_guaranteed) = let_expr.recovered {
self.set_tainted_by_errors(error_guaranteed);
Ty::new_error(self.tcx, error_guaranteed)
} else {
@@ -1412,9 +1410,7 @@
ty::Array(ty, _) | ty::Slice(ty) => Some(ty),
_ => None,
})
- .unwrap_or_else(|| {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr.span })
- });
+ .unwrap_or_else(|| self.next_ty_var(expr.span));
let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
assert_eq!(self.diverges.get(), Diverges::Maybe);
for e in args {
@@ -1424,7 +1420,7 @@
}
coerce.complete(self)
} else {
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr.span })
+ self.next_ty_var(expr.span)
};
let array_len = args.len() as u64;
self.suggest_array_len(expr, array_len);
@@ -1475,7 +1471,7 @@
crate::GatherLocalsVisitor::new(&fcx).visit_body(body);
let ty = fcx.check_expr_with_expectation(body.value, expected);
- fcx.require_type_is_sized(ty, body.value.span, traits::ConstSized);
+ fcx.require_type_is_sized(ty, body.value.span, ObligationCauseCode::ConstSized);
fcx.write_ty(block.hir_id, ty);
ty
}
@@ -1507,8 +1503,7 @@
(uty, uty)
}
None => {
- let ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: element.span });
+ let ty = self.next_ty_var(element.span);
let element_ty = self.check_expr_has_type_or_error(element, ty, |_| {});
(element_ty, ty)
}
@@ -1522,7 +1517,7 @@
let ty = Ty::new_array_with_const_len(tcx, t, count);
- self.register_wf_obligation(ty.into(), expr.span, traits::WellFormed(None));
+ self.register_wf_obligation(ty.into(), expr.span, ObligationCauseCode::WellFormed(None));
ty
}
@@ -1612,7 +1607,11 @@
if let Err(guar) = tuple.error_reported() {
Ty::new_error(self.tcx, guar)
} else {
- self.require_type_is_sized(tuple, expr.span, traits::TupleInitializerSized);
+ self.require_type_is_sized(
+ tuple,
+ expr.span,
+ ObligationCauseCode::TupleInitializerSized,
+ );
tuple
}
}
@@ -1651,7 +1650,7 @@
base_expr,
);
- self.require_type_is_sized(adt_ty, expr.span, traits::StructInitializerSized);
+ self.require_type_is_sized(adt_ty, expr.span, ObligationCauseCode::StructInitializerSized);
adt_ty
}
@@ -3084,14 +3083,12 @@
polarity: ty::PredicatePolarity::Positive,
}),
|derived| {
- traits::ImplDerivedObligation(Box::new(
- traits::ImplDerivedObligationCause {
- derived,
- impl_or_alias_def_id: impl_def_id,
- impl_def_predicate_index: Some(idx),
- span,
- },
- ))
+ ObligationCauseCode::ImplDerived(Box::new(traits::ImplDerivedCause {
+ derived,
+ impl_or_alias_def_id: impl_def_id,
+ impl_def_predicate_index: Some(idx),
+ span,
+ }))
},
)
},
@@ -3182,7 +3179,7 @@
fn check_expr_asm_operand(&self, expr: &'tcx hir::Expr<'tcx>, is_input: bool) {
let needs = if is_input { Needs::None } else { Needs::MutPlace };
let ty = self.check_expr_with_needs(expr, needs);
- self.require_type_is_sized(ty, expr.span, traits::InlineAsmSized);
+ self.require_type_is_sized(ty, expr.span, ObligationCauseCode::InlineAsmSized);
if !is_input && !expr.is_syntactic_place_expr() {
self.dcx()
@@ -3353,7 +3350,7 @@
let field_ty = self.field_ty(expr.span, field, args);
// FIXME: DSTs with static alignment should be allowed
- self.require_type_is_sized(field_ty, expr.span, traits::MiscObligation);
+ self.require_type_is_sized(field_ty, expr.span, ObligationCauseCode::Misc);
if field.vis.is_accessible_from(sub_def_scope, self.tcx) {
self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
@@ -3381,7 +3378,7 @@
let field_ty = self.field_ty(expr.span, field, args);
// FIXME: DSTs with static alignment should be allowed
- self.require_type_is_sized(field_ty, expr.span, traits::MiscObligation);
+ self.require_type_is_sized(field_ty, expr.span, ObligationCauseCode::Misc);
if field.vis.is_accessible_from(def_scope, self.tcx) {
self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
@@ -3402,7 +3399,7 @@
&& field.name == sym::integer(index)
{
for ty in tys.iter().take(index + 1) {
- self.require_type_is_sized(ty, expr.span, traits::MiscObligation);
+ self.require_type_is_sized(ty, expr.span, ObligationCauseCode::Misc);
}
if let Some(&field_ty) = tys.get(index) {
field_indices.push((FIRST_VARIANT, index.into()));
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 552747b..881f726 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -409,7 +409,7 @@
pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> LoweredTy<'tcx> {
let ty = self.lowerer().lower_ty(hir_ty);
- self.register_wf_obligation(ty.into(), hir_ty.span, traits::WellFormed(None));
+ self.register_wf_obligation(ty.into(), hir_ty.span, ObligationCauseCode::WellFormed(None));
LoweredTy::from_raw(self, hir_ty.span, ty)
}
@@ -520,7 +520,7 @@
for arg in args.iter().filter(|arg| {
matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
}) {
- self.register_wf_obligation(arg, expr.span, traits::WellFormed(None));
+ self.register_wf_obligation(arg, expr.span, ObligationCauseCode::WellFormed(None));
}
}
@@ -624,10 +624,7 @@
/// returns a type of `&T`, but the actual type we assign to the
/// *expression* is `T`. So this function just peels off the return
/// type by one layer to yield `T`.
- pub(crate) fn make_overloaded_place_return_type(
- &self,
- method: MethodCallee<'tcx>,
- ) -> ty::TypeAndMut<'tcx> {
+ pub(crate) fn make_overloaded_place_return_type(&self, method: MethodCallee<'tcx>) -> Ty<'tcx> {
// extract method return type, which will be &T;
let ret_ty = method.sig.output();
@@ -775,7 +772,11 @@
};
if let Some(&cached_result) = self.typeck_results.borrow().type_dependent_defs().get(hir_id)
{
- self.register_wf_obligation(ty.raw.into(), qself.span, traits::WellFormed(None));
+ self.register_wf_obligation(
+ ty.raw.into(),
+ qself.span,
+ ObligationCauseCode::WellFormed(None),
+ );
// Return directly on cache hit. This is useful to avoid doubly reporting
// errors with default match binding modes. See #44614.
let def = cached_result.map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id));
@@ -814,7 +815,7 @@
self.register_wf_obligation(
ty.raw.into(),
qself.span,
- traits::WellFormed(None),
+ ObligationCauseCode::WellFormed(None),
);
}
@@ -848,7 +849,11 @@
});
if result.is_ok() {
- self.register_wf_obligation(ty.raw.into(), qself.span, traits::WellFormed(None));
+ self.register_wf_obligation(
+ ty.raw.into(),
+ qself.span,
+ ObligationCauseCode::WellFormed(None),
+ );
}
// Write back the new resolution.
@@ -1405,9 +1410,9 @@
) {
self.add_required_obligations_with_code(span, def_id, args, |idx, span| {
if span.is_dummy() {
- ObligationCauseCode::ExprItemObligation(def_id, hir_id, idx)
+ ObligationCauseCode::WhereClauseInExpr(def_id, hir_id, idx)
} else {
- ObligationCauseCode::ExprBindingObligation(def_id, span, hir_id, idx)
+ ObligationCauseCode::SpannedWhereClauseInExpr(def_id, span, hir_id, idx)
}
})
}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
index a718760..2699639 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
@@ -14,8 +14,8 @@
&self,
error: &mut traits::FulfillmentError<'tcx>,
) -> bool {
- let (traits::ExprItemObligation(def_id, hir_id, idx)
- | traits::ExprBindingObligation(def_id, _, hir_id, idx)) =
+ let (ObligationCauseCode::WhereClauseInExpr(def_id, hir_id, idx)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, hir_id, idx)) =
*error.obligation.cause.code().peel_derives()
else {
return false;
@@ -167,7 +167,7 @@
// the method's turbofish segments but still use `FunctionArgumentObligation`
// elsewhere. Hopefully this doesn't break something.
error.obligation.cause.map_code(|parent_code| {
- ObligationCauseCode::FunctionArgumentObligation {
+ ObligationCauseCode::FunctionArg {
arg_hir_id: receiver.hir_id,
call_hir_id: hir_id,
parent_code,
@@ -360,12 +360,9 @@
error: &traits::FulfillmentError<'tcx>,
span: Span,
) -> bool {
- if let traits::FulfillmentErrorCode::SelectionError(
- traits::SelectionError::SignatureMismatch(box traits::SignatureMismatchData {
- expected_trait_ref,
- ..
- }),
- ) = error.code
+ if let traits::FulfillmentErrorCode::Select(traits::SelectionError::SignatureMismatch(
+ box traits::SignatureMismatchData { expected_trait_ref, .. },
+ )) = error.code
&& let ty::Closure(def_id, _) | ty::Coroutine(def_id, ..) =
expected_trait_ref.self_ty().kind()
&& span.overlaps(self.tcx.def_span(*def_id))
@@ -459,12 +456,10 @@
self.blame_specific_expr_if_possible(error, arg_expr)
}
- error.obligation.cause.map_code(|parent_code| {
- ObligationCauseCode::FunctionArgumentObligation {
- arg_hir_id: arg.hir_id,
- call_hir_id,
- parent_code,
- }
+ error.obligation.cause.map_code(|parent_code| ObligationCauseCode::FunctionArg {
+ arg_hir_id: arg.hir_id,
+ call_hir_id,
+ parent_code,
});
return true;
} else if args_referencing_param.len() > 0 {
@@ -517,12 +512,12 @@
expr: &'tcx hir::Expr<'tcx>,
) -> Result<&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>> {
match obligation_cause_code {
- traits::ObligationCauseCode::ExprBindingObligation(_, _, _, _) => {
+ traits::ObligationCauseCode::SpannedWhereClauseInExpr(_, _, _, _) => {
// This is the "root"; we assume that the `expr` is already pointing here.
// Therefore, we return `Ok` so that this `expr` can be refined further.
Ok(expr)
}
- traits::ObligationCauseCode::ImplDerivedObligation(impl_derived) => self
+ traits::ObligationCauseCode::ImplDerived(impl_derived) => self
.blame_specific_expr_if_possible_for_derived_predicate_obligation(
impl_derived,
expr,
@@ -560,7 +555,7 @@
/// only a partial success - but it cannot be refined even further.
fn blame_specific_expr_if_possible_for_derived_predicate_obligation(
&self,
- obligation: &traits::ImplDerivedObligationCause<'tcx>,
+ obligation: &traits::ImplDerivedCause<'tcx>,
expr: &'tcx hir::Expr<'tcx>,
) -> Result<&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>> {
// First, we attempt to refine the `expr` for our span using the parent obligation.
@@ -729,7 +724,7 @@
};
let struct_generic_parameters: &ty::Generics = self.tcx.generics_of(in_ty_adt.did());
- if drill_generic_index >= struct_generic_parameters.params.len() {
+ if drill_generic_index >= struct_generic_parameters.own_params.len() {
return Err(expr);
}
@@ -852,7 +847,7 @@
};
let struct_generic_parameters: &ty::Generics = self.tcx.generics_of(in_ty_adt.did());
- if drill_generic_index >= struct_generic_parameters.params.len() {
+ if drill_generic_index >= struct_generic_parameters.own_params.len() {
return Err(expr);
}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index e45e088..4bf8235 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -31,16 +31,14 @@
use rustc_hir_analysis::structured_errors::StructuredDiag;
use rustc_index::IndexVec;
use rustc_infer::infer::error_reporting::{FailureCode, ObligationCauseExt};
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::TypeTrace;
use rustc_infer::infer::{DefineOpaqueTypes, InferOk};
-use rustc_middle::traits::ObligationCauseCode::ExprBindingObligation;
use rustc_middle::ty::adjustment::AllowTwoPhase;
use rustc_middle::ty::visit::TypeVisitableExt;
use rustc_middle::ty::{self, IsSuggestable, Ty, TyCtxt};
use rustc_session::Session;
use rustc_span::symbol::{kw, Ident};
-use rustc_span::{sym, BytePos, Span};
+use rustc_span::{sym, BytePos, Span, DUMMY_SP};
use rustc_trait_selection::traits::{self, ObligationCauseCode, SelectionContext};
use std::iter;
@@ -204,7 +202,11 @@
// All the input types from the fn signature must outlive the call
// so as to validate implied bounds.
for (&fn_input_ty, arg_expr) in iter::zip(formal_input_tys, provided_args) {
- self.register_wf_obligation(fn_input_ty.into(), arg_expr.span, traits::MiscObligation);
+ self.register_wf_obligation(
+ fn_input_ty.into(),
+ arg_expr.span,
+ ObligationCauseCode::Misc,
+ );
}
let mut err_code = E0061;
@@ -2011,7 +2013,8 @@
for (span, code) in errors_causecode {
self.dcx().try_steal_modify_and_emit_err(span, StashKey::MaybeForgetReturn, |err| {
if let Some(fn_sig) = self.body_fn_sig()
- && let ExprBindingObligation(_, _, binding_hir_id, ..) = code
+ && let ObligationCauseCode::SpannedWhereClauseInExpr(_, _, binding_hir_id, ..) =
+ code
&& !fn_sig.output().is_unit()
{
let mut block_num = 0;
@@ -2100,7 +2103,7 @@
//
// This is because due to normalization, we often register duplicate
// obligations with misc obligations that are basically impossible to
- // line back up with a useful ExprBindingObligation.
+ // line back up with a useful SpannedWhereClauseInExpr.
for error in not_adjusted {
for (span, predicate, cause) in &remap_cause {
if *predicate == error.obligation.predicate
@@ -2180,13 +2183,7 @@
let trait_ref = ty::TraitRef::new(
self.tcx,
self.tcx.fn_trait_kind_to_def_id(call_kind)?,
- [
- callee_ty,
- self.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: rustc_span::DUMMY_SP,
- }),
- ],
+ [callee_ty, self.next_ty_var(DUMMY_SP)],
);
let obligation = traits::Obligation::new(
self.tcx,
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
index 794b854..afba812 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -19,8 +19,6 @@
use rustc_infer::infer;
use rustc_infer::infer::error_reporting::sub_relations::SubRelations;
use rustc_infer::infer::error_reporting::TypeErrCtxt;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
-use rustc_middle::infer::unify_key::ConstVariableOrigin;
use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitableExt};
use rustc_session::Session;
use rustc_span::symbol::Ident;
@@ -156,7 +154,7 @@
}
pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
- self.cause(span, ObligationCauseCode::MiscObligation)
+ self.cause(span, ObligationCauseCode::Misc)
}
pub fn sess(&self) -> &Session {
@@ -239,7 +237,7 @@
fn ty_infer(&self, param: Option<&ty::GenericParamDef>, span: Span) -> Ty<'tcx> {
match param {
Some(param) => self.var_for_def(span, param).as_type().unwrap(),
- None => self.next_ty_var(TypeVariableOrigin { param_def_id: None, span }),
+ None => self.next_ty_var(span),
}
}
@@ -258,7 +256,7 @@
},
) => self.var_for_effect(param).as_const().unwrap(),
Some(param) => self.var_for_def(span, param).as_const().unwrap(),
- None => self.next_const_var(ty, ConstVariableOrigin { span, param_def_id: None }),
+ None => self.next_const_var(ty, span),
}
}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index f00d9d0..f1b719f 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1700,7 +1700,7 @@
}
}
for error in errors {
- if let traits::FulfillmentErrorCode::SelectionError(
+ if let traits::FulfillmentErrorCode::Select(
traits::SelectionError::Unimplemented,
) = error.code
&& let ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) =
diff --git a/compiler/rustc_hir_typeck/src/gather_locals.rs b/compiler/rustc_hir_typeck/src/gather_locals.rs
index fe0a469..13e4b62 100644
--- a/compiler/rustc_hir_typeck/src/gather_locals.rs
+++ b/compiler/rustc_hir_typeck/src/gather_locals.rs
@@ -2,12 +2,11 @@
use rustc_hir as hir;
use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::{HirId, PatKind};
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
+use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::ty::Ty;
use rustc_middle::ty::UserType;
use rustc_span::def_id::LocalDefId;
use rustc_span::Span;
-use rustc_trait_selection::traits;
/// Provides context for checking patterns in declarations. More specifically this
/// allows us to infer array types if the pattern is irrefutable and allows us to infer
@@ -50,7 +49,7 @@
impl<'a> From<(&'a hir::LetExpr<'a>, HirId)> for Declaration<'a> {
fn from((let_expr, hir_id): (&'a hir::LetExpr<'a>, HirId)) -> Self {
- let hir::LetExpr { pat, ty, span, init, is_recovered: _ } = *let_expr;
+ let hir::LetExpr { pat, ty, span, init, recovered: _ } = *let_expr;
Declaration { hir_id, pat, ty, span, init: Some(init), origin: DeclOrigin::LetExpr }
}
}
@@ -72,7 +71,7 @@
match ty_opt {
None => {
// Infer the variable's type.
- let var_ty = self.fcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span });
+ let var_ty = self.fcx.next_ty_var(span);
self.fcx.locals.borrow_mut().insert(nid, var_ty);
var_ty
}
@@ -147,7 +146,7 @@
p.span,
// ty_span == ident.span iff this is a closure parameter with no type
// ascription, or if it's an implicit `self` parameter
- traits::SizedArgumentType(
+ ObligationCauseCode::SizedArgumentType(
if ty_span == ident.span
&& self.fcx.tcx.is_closure_like(self.fcx.body_id.into())
{
@@ -160,7 +159,11 @@
}
} else {
if !self.fcx.tcx.features().unsized_locals {
- self.fcx.require_type_is_sized(var_ty, p.span, traits::VariableType(p.hir_id));
+ self.fcx.require_type_is_sized(
+ var_ty,
+ p.span,
+ ObligationCauseCode::VariableType(p.hir_id),
+ );
}
}
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 8bc070b..e270e58 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -60,10 +60,8 @@
use rustc_hir::{HirId, HirIdMap, Node};
use rustc_hir_analysis::check::check_abi;
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::traits::{ObligationCauseCode, ObligationInspector, WellFormedLoc};
use rustc_middle::query::Providers;
-use rustc_middle::traits;
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_session::config;
use rustc_span::def_id::LocalDefId;
@@ -171,7 +169,7 @@
let wf_code = ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(def_id)));
fcx.register_wf_obligation(expected_type.into(), body.value.span, wf_code);
- fcx.require_type_is_sized(expected_type, body.value.span, traits::ConstSized);
+ fcx.require_type_is_sized(expected_type, body.value.span, ObligationCauseCode::ConstSized);
// Gather locals in statics (because of block expressions).
GatherLocalsVisitor::new(&fcx).visit_body(body);
@@ -246,7 +244,7 @@
tcx.impl_trait_ref(item.container_id(tcx)).unwrap().instantiate_identity().args;
Some(tcx.type_of(trait_item).instantiate(tcx, args))
} else {
- Some(fcx.next_ty_var(TypeVariableOrigin { span, param_def_id: None }))
+ Some(fcx.next_ty_var(span))
}
} else if let Node::AnonConst(_) = node {
let id = tcx.local_def_id_to_hir_id(def_id);
@@ -254,7 +252,7 @@
Node::Ty(&hir::Ty { kind: hir::TyKind::Typeof(ref anon_const), span, .. })
if anon_const.hir_id == id =>
{
- Some(fcx.next_ty_var(TypeVariableOrigin { span, param_def_id: None }))
+ Some(fcx.next_ty_var(span))
}
Node::Expr(&hir::Expr { kind: hir::ExprKind::InlineAsm(asm), span, .. })
| Node::Item(&hir::Item { kind: hir::ItemKind::GlobalAsm(asm), span, .. }) => {
@@ -264,7 +262,7 @@
Some(fcx.next_int_var())
}
hir::InlineAsmOperand::SymFn { anon_const } if anon_const.hir_id == id => {
- Some(fcx.next_ty_var(TypeVariableOrigin { span, param_def_id: None }))
+ Some(fcx.next_ty_var(span))
}
_ => None,
})
diff --git a/compiler/rustc_hir_typeck/src/mem_categorization.rs b/compiler/rustc_hir_typeck/src/mem_categorization.rs
index b44c234..ae71c48 100644
--- a/compiler/rustc_hir_typeck/src/mem_categorization.rs
+++ b/compiler/rustc_hir_typeck/src/mem_categorization.rs
@@ -207,7 +207,7 @@
// but what we want here is the type of the underlying value being borrowed.
// So peel off one-level, turning the &T into T.
match base_ty.builtin_deref(false) {
- Some(t) => Ok(t.ty),
+ Some(ty) => Ok(ty),
None => {
debug!("By-ref binding of non-derefable type");
Err(())
@@ -485,7 +485,7 @@
) -> McResult<PlaceWithHirId<'tcx>> {
let base_curr_ty = base_place.place.ty();
let deref_ty = match base_curr_ty.builtin_deref(true) {
- Some(mt) => mt.ty,
+ Some(pointee_ty) => pointee_ty,
None => {
debug!("explicit deref of non-derefable type: {:?}", base_curr_ty);
return Err(());
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index d570152..56c296f 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -450,7 +450,7 @@
// `foo.bar::<u32>(...)` -- the `Self` type here will be the
// type of `foo` (possibly adjusted), but we don't want to
// include that. We want just the `[_, u32]` part.
- if !args.is_empty() && !generics.params.is_empty() {
+ if !args.is_empty() && !generics.own_params.is_empty() {
let user_type_annotation = self.probe(|_| {
let user_args = UserArgs {
args: GenericArgs::for_item(self.tcx, pick.item.def_id, |param, _| {
@@ -565,9 +565,9 @@
for obligation in traits::predicates_for_generics(
|idx, span| {
let code = if span.is_dummy() {
- ObligationCauseCode::ExprItemObligation(def_id, self.call_expr.hir_id, idx)
+ ObligationCauseCode::WhereClauseInExpr(def_id, self.call_expr.hir_id, idx)
} else {
- ObligationCauseCode::ExprBindingObligation(
+ ObligationCauseCode::SpannedWhereClauseInExpr(
def_id,
span,
self.call_expr.hir_id,
@@ -589,7 +589,7 @@
// the function type must also be well-formed (this is not
// implied by the args being well-formed because of inherent
// impls and late-bound regions - see issue #28609).
- self.register_wf_obligation(fty.into(), self.span, traits::WellFormed(None));
+ self.register_wf_obligation(fty.into(), self.span, ObligationCauseCode::WellFormed(None));
}
///////////////////////////////////////////////////////////////////////////
diff --git a/compiler/rustc_hir_typeck/src/method/mod.rs b/compiler/rustc_hir_typeck/src/method/mod.rs
index 39d54f1..ec613f3 100644
--- a/compiler/rustc_hir_typeck/src/method/mod.rs
+++ b/compiler/rustc_hir_typeck/src/method/mod.rs
@@ -315,7 +315,7 @@
trait_def_id: DefId,
self_ty: Ty<'tcx>,
opt_input_types: Option<&[Ty<'tcx>]>,
- ) -> (traits::PredicateObligation<'tcx>, &'tcx ty::List<ty::GenericArg<'tcx>>) {
+ ) -> (traits::PredicateObligation<'tcx>, ty::GenericArgsRef<'tcx>) {
// Construct a trait-reference `self_ty : Trait<input_tys>`
let args = GenericArgs::for_item(self.tcx, trait_def_id, |param, _| {
match param.kind {
@@ -365,7 +365,7 @@
m_name: Ident,
trait_def_id: DefId,
obligation: traits::PredicateObligation<'tcx>,
- args: &'tcx ty::List<ty::GenericArg<'tcx>>,
+ args: ty::GenericArgsRef<'tcx>,
) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
debug!(?obligation);
diff --git a/compiler/rustc_hir_typeck/src/method/prelude2021.rs b/compiler/rustc_hir_typeck/src/method/prelude2021.rs
index 22eef8e..305aaf3 100644
--- a/compiler/rustc_hir_typeck/src/method/prelude2021.rs
+++ b/compiler/rustc_hir_typeck/src/method/prelude2021.rs
@@ -7,7 +7,6 @@
use hir::ItemKind;
use rustc_errors::Applicability;
use rustc_hir as hir;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_middle::ty::{self, Ty};
use rustc_session::lint::builtin::RUST_2021_PRELUDE_COLLISIONS;
use rustc_span::symbol::kw::{Empty, Underscore};
@@ -218,8 +217,7 @@
// If we know it does not, we don't need to warn.
if method_name.name == sym::from_iter {
if let Some(trait_def_id) = self.tcx.get_diagnostic_item(sym::FromIterator) {
- let any_type =
- self.infcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span });
+ let any_type = self.infcx.next_ty_var(span);
if !self
.infcx
.type_implements_trait(trait_def_id, [self_ty, any_type], self.param_env)
@@ -251,23 +249,23 @@
let trait_path = self.trait_path_or_bare_name(span, expr_id, container_id);
let trait_generics = self.tcx.generics_of(container_id);
- let trait_name = if trait_generics.params.len() <= trait_generics.has_self as usize
- {
- trait_path
- } else {
- let counts = trait_generics.own_counts();
- format!(
- "{}<{}>",
- trait_path,
- std::iter::repeat("'_")
- .take(counts.lifetimes)
- .chain(std::iter::repeat("_").take(
- counts.types + counts.consts - trait_generics.has_self as usize
- ))
- .collect::<Vec<_>>()
- .join(", ")
- )
- };
+ let trait_name =
+ if trait_generics.own_params.len() <= trait_generics.has_self as usize {
+ trait_path
+ } else {
+ let counts = trait_generics.own_counts();
+ format!(
+ "{}<{}>",
+ trait_path,
+ std::iter::repeat("'_")
+ .take(counts.lifetimes)
+ .chain(std::iter::repeat("_").take(
+ counts.types + counts.consts - trait_generics.has_self as usize
+ ))
+ .collect::<Vec<_>>()
+ .join(", ")
+ )
+ };
let mut self_ty_name = self_ty_span
.find_ancestor_inside(span)
@@ -280,7 +278,7 @@
if !self_ty_name.contains('<') {
if let ty::Adt(def, _) = self_ty.kind() {
let generics = self.tcx.generics_of(def.did());
- if !generics.params.is_empty() {
+ if !generics.own_params.is_empty() {
let counts = generics.own_counts();
self_ty_name += &format!(
"<{}>",
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 8a7ebd6..434bd95 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -15,6 +15,7 @@
use rustc_infer::infer::error_reporting::TypeAnnotationNeeded::E0282;
use rustc_infer::infer::DefineOpaqueTypes;
use rustc_infer::infer::{self, InferOk, TyCtxtInferExt};
+use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::middle::stability;
use rustc_middle::query::Providers;
use rustc_middle::ty::fast_reject::{simplify_type, TreatParams};
@@ -1401,9 +1402,13 @@
ocx.register_obligations(traits::predicates_for_generics(
|idx, span| {
let code = if span.is_dummy() {
- traits::ExprItemObligation(impl_def_id, self.scope_expr_id, idx)
+ ObligationCauseCode::WhereClauseInExpr(
+ impl_def_id,
+ self.scope_expr_id,
+ idx,
+ )
} else {
- traits::ExprBindingObligation(
+ ObligationCauseCode::SpannedWhereClauseInExpr(
impl_def_id,
span,
self.scope_expr_id,
@@ -1735,7 +1740,7 @@
let generics = self.tcx.generics_of(method);
assert_eq!(args.len(), generics.parent_count);
- let xform_fn_sig = if generics.params.is_empty() {
+ let xform_fn_sig = if generics.own_params.is_empty() {
fn_sig.instantiate(self.tcx, args)
} else {
let args = GenericArgs::for_item(self.tcx, method, |param, _| {
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 0780095..4242981 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -22,8 +22,7 @@
use rustc_hir::PatKind::Binding;
use rustc_hir::PathSegment;
use rustc_hir::{ExprKind, Node, QPath};
-use rustc_infer::infer::{self, type_variable::TypeVariableOrigin, RegionVariableOrigin};
-use rustc_middle::infer::unify_key::ConstVariableOrigin;
+use rustc_infer::infer::{self, RegionVariableOrigin};
use rustc_middle::ty::fast_reject::DeepRejectCtxt;
use rustc_middle::ty::fast_reject::{simplify_type, TreatParams};
use rustc_middle::ty::print::{with_crate_prefix, with_forced_trimmed_paths};
@@ -75,11 +74,8 @@
self.autoderef(span, ty).any(|(ty, _)| {
info!("check deref {:?} impl FnOnce", ty);
self.probe(|_| {
- let trait_ref = ty::TraitRef::new(
- tcx,
- fn_once,
- [ty, self.next_ty_var(TypeVariableOrigin { param_def_id: None, span })],
- );
+ let trait_ref =
+ ty::TraitRef::new(tcx, fn_once, [ty, self.next_ty_var(span)]);
let poly_trait_ref = ty::Binder::dummy(trait_ref);
let obligation = Obligation::misc(
tcx,
@@ -150,7 +146,7 @@
return false;
};
let trait_ref = ty::TraitRef::new(self.tcx, into_iterator_trait, [ty]);
- let cause = ObligationCause::new(span, self.body_id, ObligationCauseCode::MiscObligation);
+ let cause = ObligationCause::new(span, self.body_id, ObligationCauseCode::Misc);
let obligation = Obligation::new(self.tcx, cause, self.param_env, trait_ref);
if !self.predicate_must_hold_modulo_regions(&obligation) {
return false;
@@ -830,12 +826,12 @@
// Extract the predicate span and parent def id of the cause,
// if we have one.
let (item_def_id, cause_span) = match cause.as_ref().map(|cause| cause.code()) {
- Some(ObligationCauseCode::ImplDerivedObligation(data)) => {
+ Some(ObligationCauseCode::ImplDerived(data)) => {
(data.impl_or_alias_def_id, data.span)
}
Some(
- ObligationCauseCode::ExprBindingObligation(def_id, span, _, _)
- | ObligationCauseCode::BindingObligation(def_id, span),
+ ObligationCauseCode::SpannedWhereClauseInExpr(def_id, span, _, _)
+ | ObligationCauseCode::SpannedWhereClause(def_id, span),
) => (*def_id, *span),
_ => continue,
};
@@ -1259,12 +1255,7 @@
args.map(|args| {
args.iter()
.map(|expr| {
- self.node_ty_opt(expr.hir_id).unwrap_or_else(|| {
- self.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: expr.span,
- })
- })
+ self.node_ty_opt(expr.hir_id).unwrap_or_else(|| self.next_ty_var(expr.span))
})
.collect()
}),
@@ -1846,18 +1837,10 @@
GenericArgKind::Lifetime(_) => self
.next_region_var(RegionVariableOrigin::MiscVariable(DUMMY_SP))
.into(),
- GenericArgKind::Type(_) => self
- .next_ty_var(TypeVariableOrigin {
- span: DUMMY_SP,
- param_def_id: None,
- })
- .into(),
- GenericArgKind::Const(arg) => self
- .next_const_var(
- arg.ty(),
- ConstVariableOrigin { span: DUMMY_SP, param_def_id: None },
- )
- .into(),
+ GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
+ GenericArgKind::Const(arg) => {
+ self.next_const_var(arg.ty(), DUMMY_SP).into()
+ }
}
} else {
arg
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index a4f840d..dca1cda 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -7,7 +7,6 @@
use rustc_data_structures::packed::Pu128;
use rustc_errors::{codes::*, struct_span_code_err, Applicability, Diag};
use rustc_hir as hir;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::ty::adjustment::{
Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability,
@@ -20,7 +19,7 @@
use rustc_span::Span;
use rustc_trait_selection::infer::InferCtxtExt;
use rustc_trait_selection::traits::error_reporting::suggestions::TypeErrCtxtExt as _;
-use rustc_trait_selection::traits::{self, FulfillmentError, ObligationCtxt};
+use rustc_trait_selection::traits::{FulfillmentError, ObligationCtxt};
use rustc_type_ir::TyKind::*;
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
@@ -219,8 +218,7 @@
// e.g., adding `&'a T` and `&'b T`, given `&'x T: Add<&'x T>`, will result
// in `&'a T <: &'x T` and `&'b T <: &'x T`, instead of `'a = 'b = 'x`.
let lhs_ty = self.check_expr(lhs_expr);
- let fresh_var = self
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: lhs_expr.span });
+ let fresh_var = self.next_ty_var(lhs_expr.span);
self.demand_coerce(lhs_expr, lhs_ty, fresh_var, Some(rhs_expr), AllowTwoPhase::No)
}
IsAssign::Yes => {
@@ -239,8 +237,7 @@
// using this variable as the expected type, which sometimes lets
// us do better coercions than we would be able to do otherwise,
// particularly for things like `String + &String`.
- let rhs_ty_var =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: rhs_expr.span });
+ let rhs_ty_var = self.next_ty_var(rhs_expr.span);
let result = self.lookup_op_method(
(lhs_expr, lhs_ty),
@@ -887,7 +884,7 @@
let input_types = opt_rhs_ty.as_slice();
let cause = self.cause(
span,
- traits::BinOp {
+ ObligationCauseCode::BinOp {
lhs_hir_id: lhs_expr.hir_id,
rhs_hir_id: opt_rhs_expr.map(|expr| expr.hir_id),
rhs_span: opt_rhs_expr.map(|expr| expr.span),
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 8c7ae7f..b1a0aa6 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -9,7 +9,6 @@
use rustc_hir::pat_util::EnumerateAndAdjustIterator;
use rustc_hir::{self as hir, BindingMode, ByRef, HirId, Mutability, Pat, PatKind};
use rustc_infer::infer;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_middle::mir::interpret::ErrorHandled;
use rustc_middle::ty::{self, Ty, TypeVisitableExt};
use rustc_session::lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
@@ -19,7 +18,7 @@
use rustc_span::symbol::{kw, sym, Ident};
use rustc_span::{BytePos, Span, DUMMY_SP};
use rustc_target::abi::FieldIdx;
-use rustc_trait_selection::traits::{ObligationCause, Pattern};
+use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
use ty::VariantDef;
use std::cmp;
@@ -89,8 +88,11 @@
impl<'tcx> FnCtxt<'_, 'tcx> {
fn pattern_cause(&self, ti: TopInfo<'tcx>, cause_span: Span) -> ObligationCause<'tcx> {
- let code =
- Pattern { span: ti.span, root_ty: ti.expected, origin_expr: ti.origin_expr.is_some() };
+ let code = ObligationCauseCode::Pattern {
+ span: ti.span,
+ root_ty: ti.expected,
+ origin_expr: ti.origin_expr.is_some(),
+ };
self.cause(cause_span, code)
}
@@ -919,8 +921,8 @@
inner: &Pat<'_>,
) -> Result<(), ErrorGuaranteed> {
if let PatKind::Binding(..) = inner.kind
- && let Some(mt) = self.shallow_resolve(expected).builtin_deref(true)
- && let ty::Dynamic(..) = mt.ty.kind()
+ && let Some(pointee_ty) = self.shallow_resolve(expected).builtin_deref(true)
+ && let ty::Dynamic(..) = pointee_ty.kind()
{
// This is "x = dyn SomeTrait" being reduced from
// "let &x = &dyn SomeTrait" or "let box x = Box<dyn SomeTrait>", an error.
@@ -1419,8 +1421,7 @@
}
let max_len = cmp::max(expected_len, elements.len());
- let element_tys_iter =
- (0..max_len).map(|_| self.next_ty_var(TypeVariableOrigin { param_def_id: None, span }));
+ let element_tys_iter = (0..max_len).map(|_| self.next_ty_var(span));
let element_tys = tcx.mk_type_list_from_iter(element_tys_iter);
let pat_ty = Ty::new_tup(tcx, element_tys);
if let Some(err) = self.demand_eqtype_pat_diag(span, expected, pat_ty, pat_info.top_info) {
@@ -1676,7 +1677,7 @@
unmentioned_fields: &mut Vec<(&'tcx ty::FieldDef, Ident)>,
pat: &'tcx Pat<'tcx>,
variant: &ty::VariantDef,
- args: &'tcx ty::List<ty::GenericArg<'tcx>>,
+ args: ty::GenericArgsRef<'tcx>,
) -> Diag<'tcx> {
let tcx = self.tcx;
let (field_names, t, plural) = if let [field] = inexistent_fields {
@@ -2046,8 +2047,7 @@
Ok(()) => {
// Here, `demand::subtype` is good enough, but I don't
// think any errors can be introduced by using `demand::eqtype`.
- let inner_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: inner.span });
+ let inner_ty = self.next_ty_var(inner.span);
let box_ty = Ty::new_box(tcx, inner_ty);
self.demand_eqtype_pat(span, expected, box_ty, pat_info.top_info);
(box_ty, inner_ty)
@@ -2142,10 +2142,7 @@
.insert(pat.hir_id);
(expected, expected)
} else {
- let inner_ty = self.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: inner.span,
- });
+ let inner_ty = self.next_ty_var(inner.span);
let ref_ty = self.new_ref_ty(pat.span, mutbl, inner_ty);
debug!("check_pat_ref: demanding {:?} = {:?}", expected, ref_ty);
let err = self.demand_eqtype_pat_diag(
@@ -2194,8 +2191,7 @@
let tcx = self.tcx;
let len = before.len();
- let ty_var_origin = TypeVariableOrigin { param_def_id: None, span };
- let inner_ty = self.next_ty_var(ty_var_origin);
+ let inner_ty = self.next_ty_var(span);
Some(Ty::new_array(tcx, inner_ty, len.try_into().unwrap()))
}
diff --git a/compiler/rustc_hir_typeck/src/place_op.rs b/compiler/rustc_hir_typeck/src/place_op.rs
index bce43b3..3742797 100644
--- a/compiler/rustc_hir_typeck/src/place_op.rs
+++ b/compiler/rustc_hir_typeck/src/place_op.rs
@@ -4,7 +4,6 @@
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_hir_analysis::autoderef::Autoderef;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::InferOk;
use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref, PointerCoercion};
use rustc_middle::ty::adjustment::{AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
@@ -20,8 +19,8 @@
oprnd_expr: &'tcx hir::Expr<'tcx>,
oprnd_ty: Ty<'tcx>,
) -> Option<Ty<'tcx>> {
- if let Some(mt) = oprnd_ty.builtin_deref(true) {
- return Some(mt.ty);
+ if let Some(ty) = oprnd_ty.builtin_deref(true) {
+ return Some(ty);
}
let ok = self.try_overloaded_deref(expr.span, oprnd_ty)?;
@@ -37,7 +36,7 @@
} else {
span_bug!(expr.span, "input to deref is not a ref?");
}
- let ty = self.make_overloaded_place_return_type(method).ty;
+ let ty = self.make_overloaded_place_return_type(method);
self.write_method_call_and_enforce_effects(expr.hir_id, expr.span, method);
Some(ty)
}
@@ -147,8 +146,7 @@
// If some lookup succeeds, write callee into table and extract index/element
// type from the method signature.
// If some lookup succeeded, install method in table
- let input_ty =
- self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: base_expr.span });
+ let input_ty = self.next_ty_var(base_expr.span);
let method =
self.try_overloaded_place_op(expr.span, self_ty, &[input_ty], PlaceOp::Index);
@@ -175,7 +173,7 @@
self.write_method_call_and_enforce_effects(expr.hir_id, expr.span, method);
- return Some((input_ty, self.make_overloaded_place_return_type(method).ty));
+ return Some((input_ty, self.make_overloaded_place_return_type(method)));
}
}
@@ -344,8 +342,7 @@
.borrow()
.expr_ty_adjusted(base_expr)
.builtin_deref(false)
- .expect("place op takes something that is not a ref")
- .ty;
+ .expect("place op takes something that is not a ref");
let arg_ty = match op {
PlaceOp::Deref => None,
diff --git a/compiler/rustc_infer/src/errors/note_and_explain.rs b/compiler/rustc_infer/src/errors/note_and_explain.rs
index 70d9487..c7f07eb 100644
--- a/compiler/rustc_infer/src/errors/note_and_explain.rs
+++ b/compiler/rustc_infer/src/errors/note_and_explain.rs
@@ -69,16 +69,8 @@
ty::RePlaceholder(_) | ty::ReError(_) => return None,
- // FIXME(#13998) RePlaceholder should probably print like
- // ReLateParam rather than dumping Debug output on the user.
- //
- // We shouldn't really be having unification failures with ReVar
- // and ReBound though.
- //
- // FIXME(@lcnr): figure out why we have to handle `ReBound`
- // here, this feels somewhat off.
ty::ReVar(_) | ty::ReBound(..) | ty::ReErased => {
- (alt_span, "revar", format!("{region:?}"))
+ bug!("unexpected region for DescriptionCtx: {:?}", region);
}
};
Some(DescriptionCtx { span, kind, arg })
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
index 734fa91..1abb808 100644
--- a/compiler/rustc_infer/src/infer/canonical/mod.rs
+++ b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -21,8 +21,7 @@
//!
//! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
-use crate::infer::ConstVariableOrigin;
-use crate::infer::{InferCtxt, RegionVariableOrigin, TypeVariableOrigin};
+use crate::infer::{InferCtxt, RegionVariableOrigin};
use rustc_index::IndexVec;
use rustc_middle::infer::unify_key::EffectVarValue;
use rustc_middle::ty::fold::TypeFoldable;
@@ -114,10 +113,9 @@
match cv_info.kind {
CanonicalVarKind::Ty(ty_kind) => {
let ty = match ty_kind {
- CanonicalTyVarKind::General(ui) => self.next_ty_var_in_universe(
- TypeVariableOrigin { param_def_id: None, span },
- universe_map(ui),
- ),
+ CanonicalTyVarKind::General(ui) => {
+ self.next_ty_var_in_universe(span, universe_map(ui))
+ }
CanonicalTyVarKind::Int => self.next_int_var(),
@@ -145,13 +143,9 @@
ty::Region::new_placeholder(self.tcx, placeholder_mapped).into()
}
- CanonicalVarKind::Const(ui, ty) => self
- .next_const_var_in_universe(
- ty,
- ConstVariableOrigin { param_def_id: None, span },
- universe_map(ui),
- )
- .into(),
+ CanonicalVarKind::Const(ui, ty) => {
+ self.next_const_var_in_universe(ty, span, universe_map(ui)).into()
+ }
CanonicalVarKind::Effect => {
let vid = self
.inner
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index 635bbca..89cdc3e 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -172,11 +172,9 @@
ty::ReError(_) => return,
- // We shouldn't really be having unification failures with ReVar
- // and ReBound though.
- //
- // FIXME(@lcnr): Figure out whether this is reachable and if so, why.
- ty::ReVar(_) | ty::ReBound(..) | ty::ReErased => (format!("lifetime `{region}`"), alt_span),
+ ty::ReVar(_) | ty::ReBound(..) | ty::ReErased => {
+ bug!("unexpected region for note_and_explain_region: {:?}", region);
+ }
};
emit_msg_span(err, prefix, description, span, suffix);
@@ -885,8 +883,8 @@
err.help("...or use `match` instead of `let...else`");
}
_ => {
- if let ObligationCauseCode::BindingObligation(_, span)
- | ObligationCauseCode::ExprBindingObligation(_, span, ..) =
+ if let ObligationCauseCode::SpannedWhereClause(_, span)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(_, span, ..) =
cause.code().peel_derives()
&& let TypeError::RegionsPlaceholderMismatch = terr
{
@@ -2014,7 +2012,6 @@
trace: &TypeTrace<'tcx>,
terr: TypeError<'tcx>,
) -> Vec<TypeErrorAdditionalDiags> {
- use crate::traits::ObligationCauseCode::{BlockTailExpression, MatchExpressionArm};
let mut suggestions = Vec::new();
let span = trace.cause.span();
let values = self.resolve_vars_if_possible(trace.values);
@@ -2081,8 +2078,11 @@
}
}
let code = trace.cause.code();
- if let &(MatchExpressionArm(box MatchExpressionArmCause { source, .. })
- | BlockTailExpression(.., source)) = code
+ if let &(ObligationCauseCode::MatchExpressionArm(box MatchExpressionArmCause {
+ source,
+ ..
+ })
+ | ObligationCauseCode::BlockTailExpression(.., source)) = code
&& let hir::MatchSource::TryDesugar(_) = source
&& let Some((expected_ty, found_ty, _)) = self.values_str(trace.values)
{
@@ -2507,7 +2507,7 @@
let generics = self.tcx.generics_of(lifetime_scope);
let mut used_names =
iter::successors(Some(generics), |g| g.parent.map(|p| self.tcx.generics_of(p)))
- .flat_map(|g| &g.params)
+ .flat_map(|g| &g.own_params)
.filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
.map(|p| p.name)
.collect::<Vec<_>>();
@@ -2775,19 +2775,17 @@
#[extension(pub trait ObligationCauseExt<'tcx>)]
impl<'tcx> ObligationCause<'tcx> {
fn as_failure_code(&self, terr: TypeError<'tcx>) -> FailureCode {
- use self::FailureCode::*;
- use crate::traits::ObligationCauseCode::*;
match self.code() {
- IfExpressionWithNoElse => Error0317,
- MainFunctionType => Error0580,
- CompareImplItemObligation { .. }
- | MatchExpressionArm(_)
- | IfExpression { .. }
- | LetElse
- | StartFunctionType
- | LangFunctionType(_)
- | IntrinsicType
- | MethodReceiver => Error0308,
+ ObligationCauseCode::IfExpressionWithNoElse => FailureCode::Error0317,
+ ObligationCauseCode::MainFunctionType => FailureCode::Error0580,
+ ObligationCauseCode::CompareImplItem { .. }
+ | ObligationCauseCode::MatchExpressionArm(_)
+ | ObligationCauseCode::IfExpression { .. }
+ | ObligationCauseCode::LetElse
+ | ObligationCauseCode::StartFunctionType
+ | ObligationCauseCode::LangFunctionType(_)
+ | ObligationCauseCode::IntrinsicType
+ | ObligationCauseCode::MethodReceiver => FailureCode::Error0308,
// In the case where we have no more specific thing to
// say, also take a look at the error code, maybe we can
@@ -2796,10 +2794,10 @@
TypeError::CyclicTy(ty)
if ty.is_closure() || ty.is_coroutine() || ty.is_coroutine_closure() =>
{
- Error0644
+ FailureCode::Error0644
}
- TypeError::IntrinsicCast => Error0308,
- _ => Error0308,
+ TypeError::IntrinsicCast => FailureCode::Error0308,
+ _ => FailureCode::Error0308,
},
}
}
@@ -2809,36 +2807,51 @@
span: Span,
subdiags: Vec<TypeErrorAdditionalDiags>,
) -> ObligationCauseFailureCode {
- use crate::traits::ObligationCauseCode::*;
match self.code() {
- CompareImplItemObligation { kind: ty::AssocKind::Fn, .. } => {
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Fn, .. } => {
ObligationCauseFailureCode::MethodCompat { span, subdiags }
}
- CompareImplItemObligation { kind: ty::AssocKind::Type, .. } => {
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Type, .. } => {
ObligationCauseFailureCode::TypeCompat { span, subdiags }
}
- CompareImplItemObligation { kind: ty::AssocKind::Const, .. } => {
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Const, .. } => {
ObligationCauseFailureCode::ConstCompat { span, subdiags }
}
- BlockTailExpression(.., hir::MatchSource::TryDesugar(_)) => {
+ ObligationCauseCode::BlockTailExpression(.., hir::MatchSource::TryDesugar(_)) => {
ObligationCauseFailureCode::TryCompat { span, subdiags }
}
- MatchExpressionArm(box MatchExpressionArmCause { source, .. }) => match source {
+ ObligationCauseCode::MatchExpressionArm(box MatchExpressionArmCause {
+ source, ..
+ }) => match source {
hir::MatchSource::TryDesugar(_) => {
ObligationCauseFailureCode::TryCompat { span, subdiags }
}
_ => ObligationCauseFailureCode::MatchCompat { span, subdiags },
},
- IfExpression { .. } => ObligationCauseFailureCode::IfElseDifferent { span, subdiags },
- IfExpressionWithNoElse => ObligationCauseFailureCode::NoElse { span },
- LetElse => ObligationCauseFailureCode::NoDiverge { span, subdiags },
- MainFunctionType => ObligationCauseFailureCode::FnMainCorrectType { span },
- StartFunctionType => ObligationCauseFailureCode::FnStartCorrectType { span, subdiags },
- &LangFunctionType(lang_item_name) => {
+ ObligationCauseCode::IfExpression { .. } => {
+ ObligationCauseFailureCode::IfElseDifferent { span, subdiags }
+ }
+ ObligationCauseCode::IfExpressionWithNoElse => {
+ ObligationCauseFailureCode::NoElse { span }
+ }
+ ObligationCauseCode::LetElse => {
+ ObligationCauseFailureCode::NoDiverge { span, subdiags }
+ }
+ ObligationCauseCode::MainFunctionType => {
+ ObligationCauseFailureCode::FnMainCorrectType { span }
+ }
+ ObligationCauseCode::StartFunctionType => {
+ ObligationCauseFailureCode::FnStartCorrectType { span, subdiags }
+ }
+ &ObligationCauseCode::LangFunctionType(lang_item_name) => {
ObligationCauseFailureCode::FnLangCorrectType { span, subdiags, lang_item_name }
}
- IntrinsicType => ObligationCauseFailureCode::IntrinsicCorrectType { span, subdiags },
- MethodReceiver => ObligationCauseFailureCode::MethodCorrectType { span, subdiags },
+ ObligationCauseCode::IntrinsicType => {
+ ObligationCauseFailureCode::IntrinsicCorrectType { span, subdiags }
+ }
+ ObligationCauseCode::MethodReceiver => {
+ ObligationCauseFailureCode::MethodCorrectType { span, subdiags }
+ }
// In the case where we have no more specific thing to
// say, also take a look at the error code, maybe we can
@@ -2858,22 +2871,21 @@
}
fn as_requirement_str(&self) -> &'static str {
- use crate::traits::ObligationCauseCode::*;
match self.code() {
- CompareImplItemObligation { kind: ty::AssocKind::Fn, .. } => {
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Fn, .. } => {
"method type is compatible with trait"
}
- CompareImplItemObligation { kind: ty::AssocKind::Type, .. } => {
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Type, .. } => {
"associated type is compatible with trait"
}
- CompareImplItemObligation { kind: ty::AssocKind::Const, .. } => {
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Const, .. } => {
"const is compatible with trait"
}
- MainFunctionType => "`main` function has the correct type",
- StartFunctionType => "`#[start]` function has the correct type",
- LangFunctionType(_) => "lang item function has the correct type",
- IntrinsicType => "intrinsic has the correct type",
- MethodReceiver => "method receiver has the correct type",
+ ObligationCauseCode::MainFunctionType => "`main` function has the correct type",
+ ObligationCauseCode::StartFunctionType => "`#[start]` function has the correct type",
+ ObligationCauseCode::LangFunctionType(_) => "lang item function has the correct type",
+ ObligationCauseCode::IntrinsicType => "intrinsic has the correct type",
+ ObligationCauseCode::MethodReceiver => "method receiver has the correct type",
_ => "types are compatible",
}
}
@@ -2884,16 +2896,17 @@
impl IntoDiagArg for ObligationCauseAsDiagArg<'_> {
fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
- use crate::traits::ObligationCauseCode::*;
let kind = match self.0.code() {
- CompareImplItemObligation { kind: ty::AssocKind::Fn, .. } => "method_compat",
- CompareImplItemObligation { kind: ty::AssocKind::Type, .. } => "type_compat",
- CompareImplItemObligation { kind: ty::AssocKind::Const, .. } => "const_compat",
- MainFunctionType => "fn_main_correct_type",
- StartFunctionType => "fn_start_correct_type",
- LangFunctionType(_) => "fn_lang_correct_type",
- IntrinsicType => "intrinsic_correct_type",
- MethodReceiver => "method_correct_type",
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Fn, .. } => "method_compat",
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Type, .. } => "type_compat",
+ ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Const, .. } => {
+ "const_compat"
+ }
+ ObligationCauseCode::MainFunctionType => "fn_main_correct_type",
+ ObligationCauseCode::StartFunctionType => "fn_start_correct_type",
+ ObligationCauseCode::LangFunctionType(_) => "fn_lang_correct_type",
+ ObligationCauseCode::IntrinsicType => "intrinsic_correct_type",
+ ObligationCauseCode::MethodReceiver => "method_correct_type",
_ => "other",
}
.into();
diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
index a2a38d1..415f0ee 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
@@ -3,7 +3,6 @@
SourceKindMultiSuggestion, SourceKindSubdiag,
};
use crate::infer::error_reporting::TypeErrCtxt;
-use crate::infer::type_variable::TypeVariableOrigin;
use crate::infer::InferCtxt;
use rustc_errors::{codes::*, Diag, IntoDiagArg};
use rustc_hir as hir;
@@ -13,7 +12,7 @@
use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::{Body, Closure, Expr, ExprKind, FnRetTy, HirId, LetStmt, LocalSource};
use rustc_middle::hir::nested_filter;
-use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableValue};
+use rustc_middle::infer::unify_key::ConstVariableValue;
use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
use rustc_middle::ty::print::{FmtPrinter, PrettyPrinter, Print, Printer};
use rustc_middle::ty::{
@@ -522,7 +521,7 @@
infer_subdiags.push(SourceKindSubdiag::GenericLabel {
span,
is_type,
- param_name: generics.params[argument_index].name.to_string(),
+ param_name: generics.own_params[argument_index].name.to_string(),
parent_exists,
parent_prefix,
parent_name,
@@ -542,18 +541,10 @@
match arg.unpack() {
GenericArgKind::Lifetime(_) => bug!("unexpected lifetime"),
- GenericArgKind::Type(_) => self
- .next_ty_var(TypeVariableOrigin {
- span: DUMMY_SP,
- param_def_id: None,
- })
- .into(),
- GenericArgKind::Const(arg) => self
- .next_const_var(
- arg.ty(),
- ConstVariableOrigin { span: DUMMY_SP, param_def_id: None },
- )
- .into(),
+ GenericArgKind::Type(_) => self.next_ty_var(DUMMY_SP).into(),
+ GenericArgKind::Const(arg) => {
+ self.next_const_var(arg.ty(), DUMMY_SP).into()
+ }
}
}))
.unwrap();
@@ -569,9 +560,7 @@
}
}
InferSourceKind::FullyQualifiedMethodCall { receiver, successor, args, def_id } => {
- let placeholder = Some(
- self.next_ty_var(TypeVariableOrigin { span: DUMMY_SP, param_def_id: None }),
- );
+ let placeholder = Some(self.next_ty_var(DUMMY_SP));
if let Some(args) = args.make_suggestable(self.infcx.tcx, true, placeholder) {
let mut printer = fmt_printer(self, Namespace::ValueNS);
printer.print_def_path(def_id, args).unwrap();
@@ -605,9 +594,7 @@
}
}
InferSourceKind::ClosureReturn { ty, data, should_wrap_expr } => {
- let placeholder = Some(
- self.next_ty_var(TypeVariableOrigin { span: DUMMY_SP, param_def_id: None }),
- );
+ let placeholder = Some(self.next_ty_var(DUMMY_SP));
if let Some(ty) = ty.make_suggestable(self.infcx.tcx, true, placeholder) {
let ty_info = ty_to_string(self, ty, None);
multi_suggestions.push(SourceKindMultiSuggestion::new_closure_return(
diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/mismatched_static_lifetime.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/mismatched_static_lifetime.rs
index b93b8dc..b6c3873 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/mismatched_static_lifetime.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/mismatched_static_lifetime.rs
@@ -32,14 +32,14 @@
// If we added a "points at argument expression" obligation, we remove it here, we care
// about the original obligation only.
let code = match cause.code() {
- ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => &*parent_code,
+ ObligationCauseCode::FunctionArg { parent_code, .. } => &*parent_code,
code => code,
};
let ObligationCauseCode::MatchImpl(parent, impl_def_id) = code else {
return None;
};
- let (ObligationCauseCode::BindingObligation(_, binding_span)
- | ObligationCauseCode::ExprBindingObligation(_, binding_span, ..)) = *parent.code()
+ let (ObligationCauseCode::SpannedWhereClause(_, binding_span)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(_, binding_span, ..)) = *parent.code()
else {
return None;
};
diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs
index 01e75d59..e3476d8 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs
@@ -240,8 +240,8 @@
let span = cause.span();
let (leading_ellipsis, satisfy_span, where_span, dup_span, def_id) =
- if let ObligationCauseCode::ItemObligation(def_id)
- | ObligationCauseCode::ExprItemObligation(def_id, ..) = *cause.code()
+ if let ObligationCauseCode::WhereClause(def_id)
+ | ObligationCauseCode::WhereClauseInExpr(def_id, ..) = *cause.code()
{
(
true,
diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs
index 0bbabef..e5950a7 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs
@@ -214,8 +214,8 @@
_ => cause.code(),
}
&& let (
- &ObligationCauseCode::ItemObligation(item_def_id)
- | &ObligationCauseCode::ExprItemObligation(item_def_id, ..),
+ &ObligationCauseCode::WhereClause(item_def_id)
+ | &ObligationCauseCode::WhereClauseInExpr(item_def_id, ..),
None,
) = (code, override_error_code)
{
diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs
index b4cf727..7f3e237 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs
@@ -4,13 +4,13 @@
use crate::infer::error_reporting::nice_region_error::NiceRegionError;
use crate::infer::lexical_region_resolve::RegionResolutionError;
use crate::infer::{Subtype, ValuePairs};
-use crate::traits::ObligationCauseCode::CompareImplItemObligation;
use rustc_errors::ErrorGuaranteed;
use rustc_hir as hir;
use rustc_hir::def::Res;
use rustc_hir::def_id::DefId;
use rustc_hir::intravisit::Visitor;
use rustc_middle::hir::nested_filter;
+use rustc_middle::traits::ObligationCauseCode;
use rustc_middle::ty::error::ExpectedFound;
use rustc_middle::ty::print::RegionHighlightMode;
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitor};
@@ -31,7 +31,8 @@
_,
) = error.clone()
&& let (Subtype(sup_trace), Subtype(sub_trace)) = (&sup_origin, &sub_origin)
- && let CompareImplItemObligation { trait_item_def_id, .. } = sub_trace.cause.code()
+ && let ObligationCauseCode::CompareImplItem { trait_item_def_id, .. } =
+ sub_trace.cause.code()
&& sub_trace.values == sup_trace.values
&& let ValuePairs::PolySigs(ExpectedFound { expected, found }) = sub_trace.values
{
diff --git a/compiler/rustc_infer/src/infer/error_reporting/note.rs b/compiler/rustc_infer/src/infer/error_reporting/note.rs
index 3ae1165..ecbe65f 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/note.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/note.rs
@@ -357,13 +357,13 @@
infer::Subtype(box ref trace)
if matches!(
&trace.cause.code().peel_derives(),
- ObligationCauseCode::BindingObligation(..)
- | ObligationCauseCode::ExprBindingObligation(..)
+ ObligationCauseCode::SpannedWhereClause(..)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(..)
) =>
{
// Hack to get around the borrow checker because trace.cause has an `Rc`.
- if let ObligationCauseCode::BindingObligation(_, span)
- | ObligationCauseCode::ExprBindingObligation(_, span, ..) =
+ if let ObligationCauseCode::SpannedWhereClause(_, span)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(_, span, ..) =
&trace.cause.code().peel_derives()
{
let span = *span;
@@ -371,7 +371,7 @@
.with_span_note(span, "the lifetime requirement is introduced here")
} else {
unreachable!(
- "control flow ensures we have a `BindingObligation` or `ExprBindingObligation` here..."
+ "control flow ensures we have a `BindingObligation` or `SpannedWhereClauseInExpr` here..."
)
}
}
diff --git a/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs b/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs
index 6a42f9b..c24ad1f 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs
@@ -629,8 +629,7 @@
| hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Fn(..), .. }),
)
);
- let impl_comparison =
- matches!(cause_code, ObligationCauseCode::CompareImplItemObligation { .. });
+ let impl_comparison = matches!(cause_code, ObligationCauseCode::CompareImplItem { .. });
let assoc = tcx.associated_item(proj_ty.def_id);
if impl_comparison {
// We do not want to suggest calling functions when the reason of the
diff --git a/compiler/rustc_infer/src/infer/error_reporting/suggest.rs b/compiler/rustc_infer/src/infer/error_reporting/suggest.rs
index bf470bb..75479de 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/suggest.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/suggest.rs
@@ -167,7 +167,7 @@
exp_span, exp_found.expected, exp_found.found,
);
- if let ObligationCauseCode::CompareImplItemObligation { .. } = cause.code() {
+ if let ObligationCauseCode::CompareImplItem { .. } = cause.code() {
return;
}
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index bb53aec..ce82296 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -528,8 +528,8 @@
/// Region variables created as the values for early-bound regions.
///
- /// FIXME(@lcnr): This can also store a `DefId`, similar to
- /// `TypeVariableOriginKind::TypeParameterDefinition`.
+ /// FIXME(@lcnr): This should also store a `DefId`, similar to
+ /// `TypeVariableOrigin`.
RegionParameterDefinition(Span, Symbol),
/// Region variables created when instantiating a binder with
@@ -989,41 +989,50 @@
self.inner.borrow_mut().type_variables().num_vars()
}
- pub fn next_ty_var_id(&self, origin: TypeVariableOrigin) -> TyVid {
- self.inner.borrow_mut().type_variables().new_var(self.universe(), origin)
+ pub fn next_ty_var(&self, span: Span) -> Ty<'tcx> {
+ self.next_ty_var_with_origin(TypeVariableOrigin { span, param_def_id: None })
}
- pub fn next_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
- Ty::new_var(self.tcx, self.next_ty_var_id(origin))
- }
-
- pub fn next_ty_var_id_in_universe(
- &self,
- origin: TypeVariableOrigin,
- universe: ty::UniverseIndex,
- ) -> TyVid {
- self.inner.borrow_mut().type_variables().new_var(universe, origin)
- }
-
- pub fn next_ty_var_in_universe(
- &self,
- origin: TypeVariableOrigin,
- universe: ty::UniverseIndex,
- ) -> Ty<'tcx> {
- let vid = self.next_ty_var_id_in_universe(origin, universe);
+ pub fn next_ty_var_with_origin(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
+ let vid = self.inner.borrow_mut().type_variables().new_var(self.universe(), origin);
Ty::new_var(self.tcx, vid)
}
- pub fn next_const_var(&self, ty: Ty<'tcx>, origin: ConstVariableOrigin) -> ty::Const<'tcx> {
- ty::Const::new_var(self.tcx, self.next_const_var_id(origin), ty)
+ pub fn next_ty_var_id_in_universe(&self, span: Span, universe: ty::UniverseIndex) -> TyVid {
+ let origin = TypeVariableOrigin { span, param_def_id: None };
+ self.inner.borrow_mut().type_variables().new_var(universe, origin)
+ }
+
+ pub fn next_ty_var_in_universe(&self, span: Span, universe: ty::UniverseIndex) -> Ty<'tcx> {
+ let vid = self.next_ty_var_id_in_universe(span, universe);
+ Ty::new_var(self.tcx, vid)
+ }
+
+ pub fn next_const_var(&self, ty: Ty<'tcx>, span: Span) -> ty::Const<'tcx> {
+ self.next_const_var_with_origin(ty, ConstVariableOrigin { span, param_def_id: None })
+ }
+
+ pub fn next_const_var_with_origin(
+ &self,
+ ty: Ty<'tcx>,
+ origin: ConstVariableOrigin,
+ ) -> ty::Const<'tcx> {
+ let vid = self
+ .inner
+ .borrow_mut()
+ .const_unification_table()
+ .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
+ .vid;
+ ty::Const::new_var(self.tcx, vid, ty)
}
pub fn next_const_var_in_universe(
&self,
ty: Ty<'tcx>,
- origin: ConstVariableOrigin,
+ span: Span,
universe: ty::UniverseIndex,
) -> ty::Const<'tcx> {
+ let origin = ConstVariableOrigin { span, param_def_id: None };
let vid = self
.inner
.borrow_mut()
@@ -1033,28 +1042,14 @@
ty::Const::new_var(self.tcx, vid, ty)
}
- pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid {
- self.inner
- .borrow_mut()
- .const_unification_table()
- .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
- .vid
- }
-
- fn next_int_var_id(&self) -> IntVid {
- self.inner.borrow_mut().int_unification_table().new_key(None)
- }
-
pub fn next_int_var(&self) -> Ty<'tcx> {
- Ty::new_int_var(self.tcx, self.next_int_var_id())
- }
-
- fn next_float_var_id(&self) -> FloatVid {
- self.inner.borrow_mut().float_unification_table().new_key(None)
+ let vid = self.inner.borrow_mut().int_unification_table().new_key(None);
+ Ty::new_int_var(self.tcx, vid)
}
pub fn next_float_var(&self) -> Ty<'tcx> {
- Ty::new_float_var(self.tcx, self.next_float_var_id())
+ let vid = self.inner.borrow_mut().float_unification_table().new_key(None);
+ Ty::new_float_var(self.tcx, vid)
}
/// Creates a fresh region variable with the next available index.
@@ -1468,24 +1463,13 @@
fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx> {
self.map
.entry(bt.var)
- .or_insert_with(|| {
- self.infcx
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: self.span })
- .into()
- })
+ .or_insert_with(|| self.infcx.next_ty_var(self.span).into())
.expect_ty()
}
fn replace_const(&mut self, bv: ty::BoundVar, ty: Ty<'tcx>) -> ty::Const<'tcx> {
self.map
.entry(bv)
- .or_insert_with(|| {
- self.infcx
- .next_const_var(
- ty,
- ConstVariableOrigin { param_def_id: None, span: self.span },
- )
- .into()
- })
+ .or_insert_with(|| self.infcx.next_const_var(ty, self.span).into())
.expect_const()
}
}
@@ -1892,7 +1876,7 @@
SubregionOrigin::ReferenceOutlivesReferent(ref_type, cause.span)
}
- traits::ObligationCauseCode::CompareImplItemObligation {
+ traits::ObligationCauseCode::CompareImplItem {
impl_item_def_id,
trait_item_def_id,
kind: _,
diff --git a/compiler/rustc_infer/src/infer/opaque_types/mod.rs b/compiler/rustc_infer/src/infer/opaque_types/mod.rs
index b7ee860..703bd5a 100644
--- a/compiler/rustc_infer/src/infer/opaque_types/mod.rs
+++ b/compiler/rustc_infer/src/infer/opaque_types/mod.rs
@@ -1,4 +1,3 @@
-use super::type_variable::TypeVariableOrigin;
use super::{DefineOpaqueTypes, InferResult};
use crate::errors::OpaqueHiddenTypeDiag;
use crate::infer::{InferCtxt, InferOk};
@@ -65,7 +64,7 @@
let span = if span.contains(def_span) { def_span } else { span };
let code = traits::ObligationCauseCode::OpaqueReturnType(None);
let cause = ObligationCause::new(span, body_id, code);
- let ty_var = self.next_ty_var(TypeVariableOrigin { param_def_id: None, span });
+ let ty_var = self.next_ty_var(span);
obligations.extend(
self.handle_opaque_type(ty, ty_var, &cause, param_env).unwrap().obligations,
);
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index fe32398..94f8a26 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -103,8 +103,8 @@
cause.span,
sup_type,
match cause.code().peel_derives() {
- ObligationCauseCode::BindingObligation(_, span)
- | ObligationCauseCode::ExprBindingObligation(_, span, ..) => Some(*span),
+ ObligationCauseCode::SpannedWhereClause(_, span)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(_, span, ..) => Some(*span),
_ => None,
},
)
diff --git a/compiler/rustc_infer/src/infer/projection.rs b/compiler/rustc_infer/src/infer/projection.rs
index e60efe3..041838f 100644
--- a/compiler/rustc_infer/src/infer/projection.rs
+++ b/compiler/rustc_infer/src/infer/projection.rs
@@ -3,7 +3,6 @@
use crate::traits::{Obligation, PredicateObligation};
-use super::type_variable::TypeVariableOrigin;
use super::InferCtxt;
impl<'tcx> InferCtxt<'tcx> {
@@ -23,10 +22,7 @@
) -> Ty<'tcx> {
debug_assert!(!self.next_trait_solver());
let def_id = projection_ty.def_id;
- let ty_var = self.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: self.tcx.def_span(def_id),
- });
+ let ty_var = self.next_ty_var(self.tcx.def_span(def_id));
let projection = ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::Projection(
ty::ProjectionPredicate { projection_ty, term: ty_var.into() },
)));
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index fb9198b..5880ca7 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -1,7 +1,7 @@
use std::mem;
use super::StructurallyRelateAliases;
-use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableValue};
+use crate::infer::type_variable::TypeVariableValue;
use crate::infer::{InferCtxt, ObligationEmittingRelation, RegionVariableOrigin};
use rustc_data_structures::sso::SsoHashMap;
use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -357,10 +357,7 @@
//
// cc trait-system-refactor-initiative#110
if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
- return Ok(self.infcx.next_ty_var_in_universe(
- TypeVariableOrigin { param_def_id: None, span: self.span },
- self.for_universe,
- ));
+ return Ok(self.infcx.next_ty_var_in_universe(self.span, self.for_universe));
}
let is_nested_alias = mem::replace(&mut self.in_alias, true);
@@ -380,10 +377,7 @@
}
debug!("generalization failure in alias");
- Ok(self.infcx.next_ty_var_in_universe(
- TypeVariableOrigin { param_def_id: None, span: self.span },
- self.for_universe,
- ))
+ Ok(self.infcx.next_ty_var_in_universe(self.span, self.for_universe))
}
}
};
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
index f9470c9..38e25b0 100644
--- a/compiler/rustc_infer/src/infer/relate/lattice.rs
+++ b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -18,7 +18,6 @@
//! [lattices]: https://en.wikipedia.org/wiki/Lattice_(order)
use super::combine::ObligationEmittingRelation;
-use crate::infer::type_variable::TypeVariableOrigin;
use crate::infer::{DefineOpaqueTypes, InferCtxt};
use crate::traits::ObligationCause;
@@ -88,14 +87,12 @@
// iterate on the subtype obligations that are returned, but I
// think this suffices. -nmatsakis
(&ty::Infer(TyVar(..)), _) => {
- let v = infcx
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: this.cause().span });
+ let v = infcx.next_ty_var(this.cause().span);
this.relate_bound(v, b, a)?;
Ok(v)
}
(_, &ty::Infer(TyVar(..))) => {
- let v = infcx
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: this.cause().span });
+ let v = infcx.next_ty_var(this.cause().span);
this.relate_bound(v, a, b)?;
Ok(v)
}
diff --git a/compiler/rustc_infer/src/infer/snapshot/fudge.rs b/compiler/rustc_infer/src/infer/snapshot/fudge.rs
index 83667f7..4408251 100644
--- a/compiler/rustc_infer/src/infer/snapshot/fudge.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/fudge.rs
@@ -195,7 +195,7 @@
// Recreate it with a fresh variable here.
let idx = vid.as_usize() - self.type_vars.0.start.as_usize();
let origin = self.type_vars.1[idx];
- self.infcx.next_ty_var(origin)
+ self.infcx.next_ty_var_with_origin(origin)
} else {
// This variable was created before the
// "fudging". Since we refresh all type
@@ -244,7 +244,7 @@
// Recreate it with a fresh variable here.
let idx = vid.index() - self.const_vars.0.start.index();
let origin = self.const_vars.1[idx];
- self.infcx.next_const_var(ct.ty(), origin)
+ self.infcx.next_const_var_with_origin(ct.ty(), origin)
} else {
ct
}
diff --git a/compiler/rustc_infer/src/traits/mod.rs b/compiler/rustc_infer/src/traits/mod.rs
index f77a611..85510cf 100644
--- a/compiler/rustc_infer/src/traits/mod.rs
+++ b/compiler/rustc_infer/src/traits/mod.rs
@@ -105,7 +105,7 @@
impl<'tcx> PolyTraitObligation<'tcx> {
pub fn derived_cause(
&self,
- variant: impl FnOnce(DerivedObligationCause<'tcx>) -> ObligationCauseCode<'tcx>,
+ variant: impl FnOnce(DerivedCause<'tcx>) -> ObligationCauseCode<'tcx>,
) -> ObligationCause<'tcx> {
self.cause.clone().derived_cause(self.predicate, variant)
}
@@ -138,10 +138,10 @@
/// Inherently impossible to fulfill; this trait is implemented if and only
/// if it is already implemented.
Cycle(Vec<PredicateObligation<'tcx>>),
- SelectionError(SelectionError<'tcx>),
- ProjectionError(MismatchedProjectionTypes<'tcx>),
- SubtypeError(ExpectedFound<Ty<'tcx>>, TypeError<'tcx>), // always comes from a SubtypePredicate
- ConstEquateError(ExpectedFound<Const<'tcx>>, TypeError<'tcx>),
+ Select(SelectionError<'tcx>),
+ Project(MismatchedProjectionTypes<'tcx>),
+ Subtype(ExpectedFound<Ty<'tcx>>, TypeError<'tcx>), // always comes from a SubtypePredicate
+ ConstEquate(ExpectedFound<Const<'tcx>>, TypeError<'tcx>),
Ambiguity {
/// Overflow is only `Some(suggest_recursion_limit)` when using the next generation
/// trait solver `-Znext-solver`. With the old solver overflow is eagerly handled by
@@ -209,10 +209,10 @@
pub fn is_true_error(&self) -> bool {
match self.code {
- FulfillmentErrorCode::SelectionError(_)
- | FulfillmentErrorCode::ProjectionError(_)
- | FulfillmentErrorCode::SubtypeError(_, _)
- | FulfillmentErrorCode::ConstEquateError(_, _) => true,
+ FulfillmentErrorCode::Select(_)
+ | FulfillmentErrorCode::Project(_)
+ | FulfillmentErrorCode::Subtype(_, _)
+ | FulfillmentErrorCode::ConstEquate(_, _) => true,
FulfillmentErrorCode::Cycle(_) | FulfillmentErrorCode::Ambiguity { overflow: _ } => {
false
}
diff --git a/compiler/rustc_infer/src/traits/structural_impls.rs b/compiler/rustc_infer/src/traits/structural_impls.rs
index 064e09b..b616d37 100644
--- a/compiler/rustc_infer/src/traits/structural_impls.rs
+++ b/compiler/rustc_infer/src/traits/structural_impls.rs
@@ -39,12 +39,12 @@
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
use traits::FulfillmentErrorCode::*;
match *self {
- SelectionError(ref e) => write!(f, "{e:?}"),
- ProjectionError(ref e) => write!(f, "{e:?}"),
- SubtypeError(ref a, ref b) => {
+ Select(ref e) => write!(f, "{e:?}"),
+ Project(ref e) => write!(f, "{e:?}"),
+ Subtype(ref a, ref b) => {
write!(f, "CodeSubtypeError({a:?}, {b:?})")
}
- ConstEquateError(ref a, ref b) => {
+ ConstEquate(ref a, ref b) => {
write!(f, "CodeConstEquateError({a:?}, {b:?})")
}
Ambiguity { overflow: None } => write!(f, "Ambiguity"),
diff --git a/compiler/rustc_infer/src/traits/util.rs b/compiler/rustc_infer/src/traits/util.rs
index 6d43011..d8d84b7 100644
--- a/compiler/rustc_infer/src/traits/util.rs
+++ b/compiler/rustc_infer/src/traits/util.rs
@@ -1,7 +1,7 @@
use smallvec::smallvec;
use crate::infer::outlives::components::{push_outlives_components, Component};
-use crate::traits::{self, Obligation, PredicateObligation};
+use crate::traits::{self, Obligation, ObligationCauseCode, PredicateObligation};
use rustc_data_structures::fx::FxHashSet;
use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt};
use rustc_span::symbol::Ident;
@@ -129,7 +129,7 @@
index: usize,
) -> Self {
let cause = self.cause.clone().derived_cause(parent_trait_pred, |derived| {
- traits::ImplDerivedObligation(Box::new(traits::ImplDerivedObligationCause {
+ ObligationCauseCode::ImplDerived(Box::new(traits::ImplDerivedCause {
derived,
impl_or_alias_def_id: parent_trait_pred.def_id(),
impl_def_predicate_index: Some(index),
diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index ce3f45a..a6876d8 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -9,7 +9,7 @@
use hir::{Expr, Pat};
use rustc_hir as hir;
use rustc_infer::{infer::TyCtxtInferExt, traits::ObligationCause};
-use rustc_middle::ty::{self, List};
+use rustc_middle::ty;
use rustc_session::{declare_lint, declare_lint_pass};
use rustc_span::{sym, Span};
use rustc_trait_selection::traits::ObligationCtxt;
@@ -123,7 +123,7 @@
fn suggest_question_mark<'tcx>(
cx: &LateContext<'tcx>,
adt: ty::AdtDef<'tcx>,
- args: &List<ty::GenericArg<'tcx>>,
+ args: ty::GenericArgsRef<'tcx>,
span: Span,
) -> bool {
let Some(body_id) = cx.enclosing_body else { return false };
@@ -150,11 +150,8 @@
let ocx = ObligationCtxt::new(&infcx);
let body_def_id = cx.tcx.hir().body_owner_def_id(body_id);
- let cause = ObligationCause::new(
- span,
- body_def_id,
- rustc_infer::traits::ObligationCauseCode::MiscObligation,
- );
+ let cause =
+ ObligationCause::new(span, body_def_id, rustc_infer::traits::ObligationCauseCode::Misc);
ocx.register_bound(
cause,
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
index 7bdf5ef..885c0bb 100644
--- a/compiler/rustc_lint/src/non_local_def.rs
+++ b/compiler/rustc_lint/src/non_local_def.rs
@@ -1,6 +1,5 @@
use rustc_hir::{def::DefKind, Body, Item, ItemKind, Node, TyKind};
use rustc_hir::{Path, QPath};
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::InferCtxt;
use rustc_infer::traits::{Obligation, ObligationCause};
use rustc_middle::ty::{self, Binder, Ty, TyCtxt, TypeFoldable, TypeFolder};
@@ -337,7 +336,7 @@
if let Some(def) = t.ty_adt_def()
&& (self.did_has_local_parent)(def.did())
{
- self.infcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span: self.infer_span })
+ self.infcx.next_ty_var(self.infer_span)
} else {
t.super_fold_with(self)
}
diff --git a/compiler/rustc_lint/src/reference_casting.rs b/compiler/rustc_lint/src/reference_casting.rs
index 63d55a7..b80e90c 100644
--- a/compiler/rustc_lint/src/reference_casting.rs
+++ b/compiler/rustc_lint/src/reference_casting.rs
@@ -202,7 +202,8 @@
// if the current expr looks like this `&mut expr[index]` then just looking
// at `expr[index]` won't give us the underlying allocation, so we just skip it
- if let ExprKind::Index(..) = e_alloc.kind {
+ // the same logic applies field access like `&mut expr.field`
+ if let ExprKind::Index(..) | ExprKind::Field(..) = e_alloc.kind {
return None;
}
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index c057f7e..7c96a6f 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1402,7 +1402,7 @@
let inferred_outlives = self.tcx.inferred_outlives_of(def_id);
record_defaulted_array!(self.tables.inferred_outlives_of[def_id] <- inferred_outlives);
- for param in &g.params {
+ for param in &g.own_params {
if let ty::GenericParamDefKind::Const { has_default: true, .. } = param.kind {
let default = self.tcx.const_param_default(param.def_id);
record!(self.tables.const_param_default[param.def_id] <- default);
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
index ee3cdf3..38cb1d5 100644
--- a/compiler/rustc_middle/src/mir/interpret/mod.rs
+++ b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -125,10 +125,11 @@
use std::num::NonZero;
use std::sync::atomic::{AtomicU32, Ordering};
+use smallvec::{smallvec, SmallVec};
+
use rustc_ast::LitKind;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::{HashMapExt, Lock};
-use rustc_data_structures::tiny_list::TinyList;
use rustc_errors::ErrorGuaranteed;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
@@ -266,8 +267,8 @@
#[derive(Clone)]
enum State {
Empty,
- InProgressNonAlloc(TinyList<DecodingSessionId>),
- InProgress(TinyList<DecodingSessionId>, AllocId),
+ InProgressNonAlloc(SmallVec<[DecodingSessionId; 1]>),
+ InProgress(SmallVec<[DecodingSessionId; 1]>, AllocId),
Done(AllocId),
}
@@ -337,8 +338,7 @@
// If this is an allocation, we need to reserve an
// `AllocId` so we can decode cyclic graphs.
let alloc_id = decoder.interner().reserve_alloc_id();
- *entry =
- State::InProgress(TinyList::new_single(self.session_id), alloc_id);
+ *entry = State::InProgress(smallvec![self.session_id], alloc_id);
Some(alloc_id)
}
AllocDiscriminant::Fn
@@ -346,8 +346,7 @@
| AllocDiscriminant::VTable => {
// Fns and statics cannot be cyclic, and their `AllocId`
// is determined later by interning.
- *entry =
- State::InProgressNonAlloc(TinyList::new_single(self.session_id));
+ *entry = State::InProgressNonAlloc(smallvec![self.session_id]);
None
}
}
@@ -357,7 +356,7 @@
bug!("this should be unreachable");
} else {
// Start decoding concurrently.
- sessions.insert(self.session_id);
+ sessions.push(self.session_id);
None
}
}
@@ -367,7 +366,7 @@
return alloc_id;
} else {
// Start decoding concurrently.
- sessions.insert(self.session_id);
+ sessions.push(self.session_id);
Some(alloc_id)
}
}
diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs
index 3881723..4994679 100644
--- a/compiler/rustc_middle/src/mir/tcx.rs
+++ b/compiler/rustc_middle/src/mir/tcx.rs
@@ -78,13 +78,9 @@
}
let answer = match *elem {
ProjectionElem::Deref => {
- let ty = self
- .ty
- .builtin_deref(true)
- .unwrap_or_else(|| {
- bug!("deref projection of non-dereferenceable ty {:?}", self)
- })
- .ty;
+ let ty = self.ty.builtin_deref(true).unwrap_or_else(|| {
+ bug!("deref projection of non-dereferenceable ty {:?}", self)
+ });
PlaceTy::from_ty(ty)
}
ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => {
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index 1ae037e..6c33a29 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -33,8 +33,6 @@
pub use self::select::{EvaluationCache, EvaluationResult, OverflowError, SelectionCache};
-pub use self::ObligationCauseCode::*;
-
/// Depending on the stage of compilation, we want projection to be
/// more or less conservative.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, HashStable, Encodable, Decodable)]
@@ -129,7 +127,7 @@
}
pub fn misc(span: Span, body_id: LocalDefId) -> ObligationCause<'tcx> {
- ObligationCause::new(span, body_id, MiscObligation)
+ ObligationCause::new(span, body_id, ObligationCauseCode::Misc)
}
#[inline(always)]
@@ -167,7 +165,7 @@
pub fn derived_cause(
mut self,
parent_trait_pred: ty::PolyTraitPredicate<'tcx>,
- variant: impl FnOnce(DerivedObligationCause<'tcx>) -> ObligationCauseCode<'tcx>,
+ variant: impl FnOnce(DerivedCause<'tcx>) -> ObligationCauseCode<'tcx>,
) -> ObligationCause<'tcx> {
/*!
* Creates a cause for obligations that are derived from
@@ -182,15 +180,14 @@
// NOTE(flaper87): As of now, it keeps track of the whole error
// chain. Ideally, we should have a way to configure this either
// by using -Z verbose-internals or just a CLI argument.
- self.code =
- variant(DerivedObligationCause { parent_trait_pred, parent_code: self.code }).into();
+ self.code = variant(DerivedCause { parent_trait_pred, parent_code: self.code }).into();
self
}
pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx> {
match self.code() {
- MatchImpl(cause, _) => cause.to_constraint_category(),
- AscribeUserTypeProvePredicate(predicate_span) => {
+ ObligationCauseCode::MatchImpl(cause, _) => cause.to_constraint_category(),
+ ObligationCauseCode::AscribeUserTypeProvePredicate(predicate_span) => {
ConstraintCategory::Predicate(*predicate_span)
}
_ => ConstraintCategory::BoringNoLocation,
@@ -209,7 +206,7 @@
#[derive(Clone, PartialEq, Eq, Default, HashStable)]
#[derive(TypeVisitable, TypeFoldable, TyEncodable, TyDecodable)]
pub struct InternedObligationCauseCode<'tcx> {
- /// `None` for `ObligationCauseCode::MiscObligation` (a common case, occurs ~60% of
+ /// `None` for `ObligationCauseCode::Misc` (a common case, occurs ~60% of
/// the time). `Some` otherwise.
code: Option<Lrc<ObligationCauseCode<'tcx>>>,
}
@@ -225,11 +222,7 @@
#[inline(always)]
fn into(self) -> InternedObligationCauseCode<'tcx> {
InternedObligationCauseCode {
- code: if let ObligationCauseCode::MiscObligation = self {
- None
- } else {
- Some(Lrc::new(self))
- },
+ code: if let ObligationCauseCode::Misc = self { None } else { Some(Lrc::new(self)) },
}
}
}
@@ -238,7 +231,7 @@
type Target = ObligationCauseCode<'tcx>;
fn deref(&self) -> &Self::Target {
- self.code.as_deref().unwrap_or(&ObligationCauseCode::MiscObligation)
+ self.code.as_deref().unwrap_or(&ObligationCauseCode::Misc)
}
}
@@ -246,7 +239,7 @@
#[derive(TypeVisitable, TypeFoldable)]
pub enum ObligationCauseCode<'tcx> {
/// Not well classified or should be obvious from the span.
- MiscObligation,
+ Misc,
/// A slice or array is WF only if `T: Sized`.
SliceOrArrayElem,
@@ -256,20 +249,20 @@
/// Must satisfy all of the where-clause predicates of the
/// given item.
- ItemObligation(DefId),
+ WhereClause(DefId),
- /// Like `ItemObligation`, but carries the span of the
+ /// Like `WhereClause`, but carries the span of the
/// predicate when it can be identified.
- BindingObligation(DefId, Span),
+ SpannedWhereClause(DefId, Span),
- /// Like `ItemObligation`, but carries the `HirId` of the
+ /// Like `WhereClause`, but carries the `HirId` of the
/// expression that caused the obligation, and the `usize`
/// indicates exactly which predicate it is in the list of
/// instantiated predicates.
- ExprItemObligation(DefId, HirId, usize),
+ WhereClauseInExpr(DefId, HirId, usize),
- /// Combines `ExprItemObligation` and `BindingObligation`.
- ExprBindingObligation(DefId, Span, HirId, usize),
+ /// Combines `SpannedWhereClause` and `WhereClauseInExpr`.
+ SpannedWhereClauseInExpr(DefId, Span, HirId, usize),
/// A type like `&'a T` is WF only if `T: 'a`.
ReferenceOutlivesReferent(Ty<'tcx>),
@@ -333,16 +326,18 @@
/// Derived obligation (i.e. theoretical `where` clause) on a built-in
/// implementation like `Copy` or `Sized`.
- BuiltinDerivedObligation(DerivedObligationCause<'tcx>),
+ BuiltinDerived(DerivedCause<'tcx>),
/// Derived obligation (i.e. `where` clause) on an user-provided impl
/// or a trait alias.
- ImplDerivedObligation(Box<ImplDerivedObligationCause<'tcx>>),
+ ImplDerived(Box<ImplDerivedCause<'tcx>>),
/// Derived obligation for WF goals.
- WellFormedDerivedObligation(DerivedObligationCause<'tcx>),
+ WellFormedDerived(DerivedCause<'tcx>),
- FunctionArgumentObligation {
+ /// Derived obligation refined to point at a specific argument in
+ /// a call or method expression.
+ FunctionArg {
/// The node of the relevant argument in the function call.
arg_hir_id: HirId,
/// The node of the function call.
@@ -353,7 +348,7 @@
/// Error derived when checking an impl item is compatible with
/// its corresponding trait item's definition
- CompareImplItemObligation {
+ CompareImplItem {
impl_item_def_id: LocalDefId,
trait_item_def_id: DefId,
kind: ty::AssocKind,
@@ -432,8 +427,8 @@
/// then it will be used to perform HIR-based wf checking
/// after an error occurs, in order to generate a more precise error span.
/// This is purely for diagnostic purposes - it is always
- /// correct to use `MiscObligation` instead, or to specify
- /// `WellFormed(None)`
+ /// correct to use `Misc` instead, or to specify
+ /// `WellFormed(None)`.
WellFormed(Option<WellFormedLoc>),
/// From `match_impl`. The cause for us having to match an impl, and the DefId we are matching against.
@@ -501,8 +496,8 @@
#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
#[derive(TypeVisitable, TypeFoldable)]
-pub struct ImplDerivedObligationCause<'tcx> {
- pub derived: DerivedObligationCause<'tcx>,
+pub struct ImplDerivedCause<'tcx> {
+ pub derived: DerivedCause<'tcx>,
/// The `DefId` of the `impl` that gave rise to the `derived` obligation.
/// If the `derived` obligation arose from a trait alias, which conceptually has a synthetic impl,
/// then this will be the `DefId` of that trait alias. Care should therefore be taken to handle
@@ -540,10 +535,10 @@
pub fn parent(&self) -> Option<(&Self, Option<ty::PolyTraitPredicate<'tcx>>)> {
match self {
- FunctionArgumentObligation { parent_code, .. } => Some((parent_code, None)),
- BuiltinDerivedObligation(derived)
- | WellFormedDerivedObligation(derived)
- | ImplDerivedObligation(box ImplDerivedObligationCause { derived, .. }) => {
+ ObligationCauseCode::FunctionArg { parent_code, .. } => Some((parent_code, None)),
+ ObligationCauseCode::BuiltinDerived(derived)
+ | ObligationCauseCode::WellFormedDerived(derived)
+ | ObligationCauseCode::ImplDerived(box ImplDerivedCause { derived, .. }) => {
Some((&derived.parent_code, Some(derived.parent_trait_pred)))
}
_ => None,
@@ -552,7 +547,7 @@
pub fn peel_match_impls(&self) -> &Self {
match self {
- MatchImpl(cause, _) => cause.code(),
+ ObligationCauseCode::MatchImpl(cause, _) => cause.code(),
_ => self,
}
}
@@ -598,7 +593,7 @@
#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
#[derive(TypeVisitable, TypeFoldable)]
-pub struct DerivedObligationCause<'tcx> {
+pub struct DerivedCause<'tcx> {
/// The trait predicate of the parent obligation that led to the
/// current obligation. Note that only trait obligations lead to
/// derived obligations, so we just store the trait predicate here
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index d2eacdf..1a55e49 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2060,7 +2060,7 @@
&& let DefKind::AssocTy = self.def_kind(def_id)
&& let DefKind::Impl { of_trait: false } = self.def_kind(self.parent(def_id))
{
- if generics.params.len() + 1 != args.len() {
+ if generics.own_params.len() + 1 != args.len() {
return false;
}
@@ -2085,7 +2085,7 @@
own_args
};
- for (param, arg) in std::iter::zip(&generics.params, own_args) {
+ for (param, arg) in std::iter::zip(&generics.own_params, own_args) {
match (¶m.kind, arg.unpack()) {
(ty::GenericParamDefKind::Type { .. }, ty::GenericArgKind::Type(_))
| (ty::GenericParamDefKind::Lifetime, ty::GenericArgKind::Lifetime(_))
@@ -2331,7 +2331,7 @@
pub fn mk_args_from_iter<I, T>(self, iter: I) -> T::Output
where
I: Iterator<Item = T>,
- T: CollectAndApply<GenericArg<'tcx>, &'tcx List<GenericArg<'tcx>>>,
+ T: CollectAndApply<GenericArg<'tcx>, ty::GenericArgsRef<'tcx>>,
{
T::collect_and_apply(iter, |xs| self.mk_args(xs))
}
@@ -2449,7 +2449,7 @@
span,
msg,
format!("#![feature({feature})]\n"),
- Applicability::MachineApplicable,
+ Applicability::MaybeIncorrect,
);
} else {
diag.help(msg);
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
index de2c01c..4a61308 100644
--- a/compiler/rustc_middle/src/ty/generic_args.rs
+++ b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -359,8 +359,8 @@
) where
F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
{
- args.reserve(defs.params.len());
- for param in &defs.params {
+ args.reserve(defs.own_params.len());
+ for param in &defs.own_params {
let kind = mk_kind(param, args);
assert_eq!(param.index as usize, args.len(), "{args:#?}, {defs:#?}");
args.push(kind);
diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
index 6bf2051..f380aea 100644
--- a/compiler/rustc_middle/src/ty/generics.rs
+++ b/compiler/rustc_middle/src/ty/generics.rs
@@ -132,7 +132,7 @@
pub struct Generics {
pub parent: Option<DefId>,
pub parent_count: usize,
- pub params: Vec<GenericParamDef>,
+ pub own_params: Vec<GenericParamDef>,
/// Reverse map to the `index` field of each `GenericParamDef`.
#[stable_hasher(ignore)]
@@ -163,7 +163,7 @@
#[inline]
pub fn count(&self) -> usize {
- self.parent_count + self.params.len()
+ self.parent_count + self.own_params.len()
}
pub fn own_counts(&self) -> GenericParamCount {
@@ -172,7 +172,7 @@
// presence of this method will be a constant reminder.
let mut own_counts = GenericParamCount::default();
- for param in &self.params {
+ for param in &self.own_params {
match param.kind {
GenericParamDefKind::Lifetime => own_counts.lifetimes += 1,
GenericParamDefKind::Type { .. } => own_counts.types += 1,
@@ -186,7 +186,7 @@
pub fn own_defaults(&self) -> GenericParamCount {
let mut own_defaults = GenericParamCount::default();
- for param in &self.params {
+ for param in &self.own_params {
match param.kind {
GenericParamDefKind::Lifetime => (),
GenericParamDefKind::Type { has_default, .. } => {
@@ -215,7 +215,7 @@
}
pub fn own_requires_monomorphization(&self) -> bool {
- for param in &self.params {
+ for param in &self.own_params {
match param.kind {
GenericParamDefKind::Type { .. }
| GenericParamDefKind::Const { is_host_effect: false, .. } => {
@@ -231,7 +231,7 @@
/// Returns the `GenericParamDef` with the given index.
pub fn param_at(&'tcx self, param_index: usize, tcx: TyCtxt<'tcx>) -> &'tcx GenericParamDef {
if let Some(index) = param_index.checked_sub(self.parent_count) {
- &self.params[index]
+ &self.own_params[index]
} else {
tcx.generics_of(self.parent.expect("parent_count > 0 but no parent?"))
.param_at(param_index, tcx)
@@ -245,7 +245,7 @@
tcx: TyCtxt<'tcx>,
) -> Option<&'tcx GenericParamDef> {
if let Some(index) = param_index.checked_sub(self.parent_count) {
- self.params.get(index)
+ self.own_params.get(index)
} else {
tcx.generics_of(self.parent.expect("parent_count > 0 but no parent?"))
.opt_param_at(param_index, tcx)
@@ -254,7 +254,7 @@
pub fn params_to(&'tcx self, param_index: usize, tcx: TyCtxt<'tcx>) -> &'tcx [GenericParamDef] {
if let Some(index) = param_index.checked_sub(self.parent_count) {
- &self.params[..index]
+ &self.own_params[..index]
} else {
tcx.generics_of(self.parent.expect("parent_count > 0 but no parent?"))
.params_to(param_index, tcx)
@@ -308,7 +308,7 @@
/// Returns `true` if `params` has `impl Trait`.
pub fn has_impl_trait(&'tcx self) -> bool {
- self.params.iter().any(|param| {
+ self.own_params.iter().any(|param| {
matches!(param.kind, ty::GenericParamDefKind::Type { synthetic: true, .. })
})
}
@@ -336,7 +336,7 @@
// good enough for now as this should only be used
// for diagnostics anyways.
own_params.end -= self
- .params
+ .own_params
.iter()
.rev()
.take_while(|param| {
@@ -358,7 +358,7 @@
&'tcx self,
args: &'tcx [ty::GenericArg<'tcx>],
) -> &'tcx [ty::GenericArg<'tcx>] {
- let own = &args[self.parent_count..][..self.params.len()];
+ let own = &args[self.parent_count..][..self.own_params.len()];
if self.has_self && self.parent.is_none() { &own[1..] } else { own }
}
@@ -372,7 +372,7 @@
args: &'tcx [ty::GenericArg<'tcx>],
) -> bool {
let mut default_param_seen = false;
- for param in self.params.iter() {
+ for param in self.own_params.iter() {
if let Some(inst) =
param.default_value(tcx).map(|default| default.instantiate(tcx, args))
{
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 8873025..cf701f8 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -114,16 +114,35 @@
}
}
+#[extension(pub trait FloatExt)]
+impl Float {
+ #[inline]
+ fn to_ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+ match *self {
+ F16 => tcx.types.f16,
+ F32 => tcx.types.f32,
+ F64 => tcx.types.f64,
+ F128 => tcx.types.f128,
+ }
+ }
+
+ fn from_float_ty(fty: ty::FloatTy) -> Self {
+ match fty {
+ ty::FloatTy::F16 => F16,
+ ty::FloatTy::F32 => F32,
+ ty::FloatTy::F64 => F64,
+ ty::FloatTy::F128 => F128,
+ }
+ }
+}
+
#[extension(pub trait PrimitiveExt)]
impl Primitive {
#[inline]
fn to_ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
match *self {
Int(i, signed) => i.to_ty(tcx, signed),
- F16 => tcx.types.f16,
- F32 => tcx.types.f32,
- F64 => tcx.types.f64,
- F128 => tcx.types.f128,
+ Float(f) => f.to_ty(tcx),
// FIXME(erikdesjardins): handle non-default addrspace ptr sizes
Pointer(_) => Ty::new_mut_ptr(tcx, tcx.types.unit),
}
@@ -140,7 +159,7 @@
let signed = false;
tcx.data_layout().ptr_sized_integer().to_ty(tcx, signed)
}
- F16 | F32 | F64 | F128 => bug!("floats do not have an int type"),
+ Float(_) => bug!("floats do not have an int type"),
}
}
}
diff --git a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
index 791f27a..115cf3e 100644
--- a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
+++ b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
@@ -100,8 +100,7 @@
/// codegen, we need to normalize the contents.
// FIXME(@lcnr): This method should not be necessary, we now normalize
// inside of binders. We should be able to only use
- // `tcx.instantiate_bound_regions_with_erased`. Same for the `try_X`
- // variant.
+ // `tcx.instantiate_bound_regions_with_erased`.
#[tracing::instrument(level = "debug", skip(self, param_env))]
pub fn normalize_erasing_late_bound_regions<T>(
self,
@@ -115,26 +114,6 @@
self.normalize_erasing_regions(param_env, value)
}
- /// If you have a `Binder<'tcx, T>`, you can do this to strip out the
- /// late-bound regions and then normalize the result, yielding up
- /// a `T` (with regions erased). This is appropriate when the
- /// binder is being instantiated at the call site.
- ///
- /// N.B., currently, higher-ranked type bounds inhibit
- /// normalization. Therefore, each time we erase them in
- /// codegen, we need to normalize the contents.
- pub fn try_normalize_erasing_late_bound_regions<T>(
- self,
- param_env: ty::ParamEnv<'tcx>,
- value: ty::Binder<'tcx, T>,
- ) -> Result<T, NormalizationError<'tcx>>
- where
- T: TypeFoldable<TyCtxt<'tcx>>,
- {
- let value = self.instantiate_bound_regions_with_erased(value);
- self.try_normalize_erasing_regions(param_env, value)
- }
-
/// Monomorphizes a type from the AST by first applying the
/// in-scope instantiations and then normalizing any associated
/// types.
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index 56dd525..48d900e 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -250,7 +250,7 @@
}
ExistentialPredicate::AutoTrait(did) => {
let generics = tcx.generics_of(did);
- let trait_ref = if generics.params.len() == 1 {
+ let trait_ref = if generics.own_params.len() == 1 {
ty::TraitRef::new(tcx, did, [self_ty])
} else {
// If this is an ill-formed auto trait, then synthesize
@@ -373,7 +373,7 @@
args: GenericArgsRef<'tcx>,
) -> ty::TraitRef<'tcx> {
let defs = tcx.generics_of(trait_id);
- ty::TraitRef::new(tcx, trait_id, tcx.mk_args(&args[..defs.params.len()]))
+ ty::TraitRef::new(tcx, trait_id, tcx.mk_args(&args[..defs.own_params.len()]))
}
/// Returns a `TraitRef` of the form `P0: Foo<P1..Pn>` where `Pi`
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index 9d0e112..eecd7dc 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -157,7 +157,7 @@
// If we have any generic arguments to print, we do that
// on top of the same path, but without its own generics.
_ => {
- if !generics.params.is_empty() && args.len() >= generics.count() {
+ if !generics.own_params.is_empty() && args.len() >= generics.count() {
let args = generics.own_args_no_defaults(self.tcx(), args);
return self.path_generic_args(
|cx| cx.print_def_path(def_id, parent_args),
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 5f47aef..46dcd18 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -977,7 +977,7 @@
fn pretty_print_opaque_impl_type(
&mut self,
def_id: DefId,
- args: &'tcx ty::List<ty::GenericArg<'tcx>>,
+ args: ty::GenericArgsRef<'tcx>,
) -> Result<(), PrintError> {
let tcx = self.tcx();
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index de70c4f..32b9709 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -2164,13 +2164,11 @@
///
/// The parameter `explicit` indicates if this is an *explicit* dereference.
/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
- pub fn builtin_deref(self, explicit: bool) -> Option<TypeAndMut<'tcx>> {
- match self.kind() {
- Adt(def, _) if def.is_box() => {
- Some(TypeAndMut { ty: self.boxed_ty(), mutbl: hir::Mutability::Not })
- }
- Ref(_, ty, mutbl) => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }),
- RawPtr(ty, mutbl) if explicit => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }),
+ pub fn builtin_deref(self, explicit: bool) -> Option<Ty<'tcx>> {
+ match *self.kind() {
+ Adt(def, _) if def.is_box() => Some(self.boxed_ty()),
+ Ref(_, ty, _) => Some(ty),
+ RawPtr(ty, _) if explicit => Some(ty),
_ => None,
}
}
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index f5e973f..6ad4f49 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -2,7 +2,7 @@
use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use crate::query::{IntoQueryParam, Providers};
-use crate::ty::layout::IntegerExt;
+use crate::ty::layout::{FloatExt, IntegerExt};
use crate::ty::{
self, FallibleTypeFolder, ToPredicate, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
TypeVisitableExt,
@@ -20,7 +20,7 @@
use rustc_macros::{extension, HashStable, TyDecodable, TyEncodable};
use rustc_session::Limit;
use rustc_span::sym;
-use rustc_target::abi::{Integer, IntegerType, Primitive, Size};
+use rustc_target::abi::{Float, Integer, IntegerType, Size};
use rustc_target::spec::abi::Abi;
use smallvec::{smallvec, SmallVec};
use std::{fmt, iter};
@@ -1145,8 +1145,7 @@
ty::Char => Size::from_bytes(4),
ty::Int(ity) => Integer::from_int_ty(&tcx, ity).size(),
ty::Uint(uty) => Integer::from_uint_ty(&tcx, uty).size(),
- ty::Float(ty::FloatTy::F32) => Primitive::F32.size(&tcx),
- ty::Float(ty::FloatTy::F64) => Primitive::F64.size(&tcx),
+ ty::Float(fty) => Float::from_float_ty(fty).size(),
_ => bug!("non primitive type"),
}
}
diff --git a/compiler/rustc_middle/src/values.rs b/compiler/rustc_middle/src/values.rs
index 5c17c0b..e3866b2 100644
--- a/compiler/rustc_middle/src/values.rs
+++ b/compiler/rustc_middle/src/values.rs
@@ -141,7 +141,7 @@
&& frame.query.dep_kind == dep_kinds::variances_of
&& let Some(def_id) = frame.query.def_id
{
- let n = tcx.generics_of(def_id).params.len();
+ let n = tcx.generics_of(def_id).own_params.len();
vec![ty::Variance::Bivariant; n].leak()
} else {
span_bug!(
diff --git a/compiler/rustc_mir_build/src/build/matches/util.rs b/compiler/rustc_mir_build/src/build/matches/util.rs
index 02bea6f..14c74c7 100644
--- a/compiler/rustc_mir_build/src/build/matches/util.rs
+++ b/compiler/rustc_mir_build/src/build/matches/util.rs
@@ -2,7 +2,6 @@
use crate::build::matches::{Binding, Candidate, FlatPat, MatchPair, TestCase};
use crate::build::Builder;
use rustc_data_structures::fx::FxIndexMap;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_middle::mir::*;
use rustc_middle::thir::{self, *};
use rustc_middle::ty::TypeVisitableExt;
@@ -180,9 +179,7 @@
cx.tcx,
ty::InlineConstArgsParts {
parent_args: ty::GenericArgs::identity_for_item(cx.tcx, parent_id),
- ty: cx
- .infcx
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span }),
+ ty: cx.infcx.next_ty_var(span),
},
)
.args;
diff --git a/compiler/rustc_mir_transform/src/check_alignment.rs b/compiler/rustc_mir_transform/src/check_alignment.rs
index 0af8872..5199c41 100644
--- a/compiler/rustc_mir_transform/src/check_alignment.rs
+++ b/compiler/rustc_mir_transform/src/check_alignment.rs
@@ -106,7 +106,7 @@
}
let pointee_ty =
- pointer_ty.builtin_deref(true).expect("no builtin_deref for an unsafe pointer").ty;
+ pointer_ty.builtin_deref(true).expect("no builtin_deref for an unsafe pointer");
// Ideally we'd support this in the future, but for now we are limited to sized types.
if !pointee_ty.is_sized(self.tcx, self.param_env) {
debug!("Unsafe pointer, but pointee is not known to be sized: {:?}", pointer_ty);
diff --git a/compiler/rustc_mir_transform/src/coverage/mappings.rs b/compiler/rustc_mir_transform/src/coverage/mappings.rs
index ddbe133..61aabea 100644
--- a/compiler/rustc_mir_transform/src/coverage/mappings.rs
+++ b/compiler/rustc_mir_transform/src/coverage/mappings.rs
@@ -52,104 +52,104 @@
pub(super) decision_depth: u16,
}
-pub(super) struct CoverageSpans {
- bcb_has_mappings: BitSet<BasicCoverageBlock>,
+#[derive(Default)]
+pub(super) struct ExtractedMappings {
pub(super) code_mappings: Vec<CodeMapping>,
pub(super) branch_pairs: Vec<BranchPair>,
- test_vector_bitmap_bytes: u32,
+ pub(super) mcdc_bitmap_bytes: u32,
pub(super) mcdc_branches: Vec<MCDCBranch>,
pub(super) mcdc_decisions: Vec<MCDCDecision>,
}
-impl CoverageSpans {
- pub(super) fn bcb_has_coverage_spans(&self, bcb: BasicCoverageBlock) -> bool {
- self.bcb_has_mappings.contains(bcb)
- }
-
- pub(super) fn test_vector_bitmap_bytes(&self) -> u32 {
- self.test_vector_bitmap_bytes
- }
-}
-
/// Extracts coverage-relevant spans from MIR, and associates them with
/// their corresponding BCBs.
-///
-/// Returns `None` if no coverage-relevant spans could be extracted.
-pub(super) fn generate_coverage_spans(
+pub(super) fn extract_all_mapping_info_from_mir(
mir_body: &mir::Body<'_>,
hir_info: &ExtractedHirInfo,
basic_coverage_blocks: &CoverageGraph,
-) -> Option<CoverageSpans> {
- let mut code_mappings = vec![];
- let mut branch_pairs = vec![];
- let mut mcdc_branches = vec![];
- let mut mcdc_decisions = vec![];
-
+) -> ExtractedMappings {
if hir_info.is_async_fn {
// An async function desugars into a function that returns a future,
// with the user code wrapped in a closure. Any spans in the desugared
// outer function will be unhelpful, so just keep the signature span
// and ignore all of the spans in the MIR body.
+ let mut mappings = ExtractedMappings::default();
if let Some(span) = hir_info.fn_sig_span_extended {
- code_mappings.push(CodeMapping { span, bcb: START_BCB });
+ mappings.code_mappings.push(CodeMapping { span, bcb: START_BCB });
}
- } else {
- extract_refined_covspans(mir_body, hir_info, basic_coverage_blocks, &mut code_mappings);
-
- branch_pairs.extend(extract_branch_pairs(mir_body, hir_info, basic_coverage_blocks));
-
- extract_mcdc_mappings(
- mir_body,
- hir_info.body_span,
- basic_coverage_blocks,
- &mut mcdc_branches,
- &mut mcdc_decisions,
- );
+ return mappings;
}
- if code_mappings.is_empty()
- && branch_pairs.is_empty()
- && mcdc_branches.is_empty()
- && mcdc_decisions.is_empty()
- {
- return None;
- }
+ let mut code_mappings = vec![];
+ let mut branch_pairs = vec![];
+ let mut mcdc_bitmap_bytes = 0;
+ let mut mcdc_branches = vec![];
+ let mut mcdc_decisions = vec![];
- // Identify which BCBs have one or more mappings.
- let mut bcb_has_mappings = BitSet::new_empty(basic_coverage_blocks.num_nodes());
- let mut insert = |bcb| {
- bcb_has_mappings.insert(bcb);
- };
+ extract_refined_covspans(mir_body, hir_info, basic_coverage_blocks, &mut code_mappings);
- for &CodeMapping { span: _, bcb } in &code_mappings {
- insert(bcb);
- }
- for &BranchPair { true_bcb, false_bcb, .. } in &branch_pairs {
- insert(true_bcb);
- insert(false_bcb);
- }
- for &MCDCBranch { true_bcb, false_bcb, .. } in &mcdc_branches {
- insert(true_bcb);
- insert(false_bcb);
- }
+ branch_pairs.extend(extract_branch_pairs(mir_body, hir_info, basic_coverage_blocks));
- // Determine the length of the test vector bitmap.
- let test_vector_bitmap_bytes = mcdc_decisions
- .iter()
- .map(|&MCDCDecision { bitmap_idx, conditions_num, .. }| {
- bitmap_idx + (1_u32 << u32::from(conditions_num)).div_ceil(8)
- })
- .max()
- .unwrap_or(0);
+ extract_mcdc_mappings(
+ mir_body,
+ hir_info.body_span,
+ basic_coverage_blocks,
+ &mut mcdc_bitmap_bytes,
+ &mut mcdc_branches,
+ &mut mcdc_decisions,
+ );
- Some(CoverageSpans {
- bcb_has_mappings,
+ ExtractedMappings {
code_mappings,
branch_pairs,
- test_vector_bitmap_bytes,
+ mcdc_bitmap_bytes,
mcdc_branches,
mcdc_decisions,
- })
+ }
+}
+
+impl ExtractedMappings {
+ pub(super) fn all_bcbs_with_counter_mappings(
+ &self,
+ basic_coverage_blocks: &CoverageGraph, // Only used for allocating a correctly-sized set
+ ) -> BitSet<BasicCoverageBlock> {
+ // Fully destructure self to make sure we don't miss any fields that have mappings.
+ let Self {
+ code_mappings,
+ branch_pairs,
+ mcdc_bitmap_bytes: _,
+ mcdc_branches,
+ mcdc_decisions,
+ } = self;
+
+ // Identify which BCBs have one or more mappings.
+ let mut bcbs_with_counter_mappings = BitSet::new_empty(basic_coverage_blocks.num_nodes());
+ let mut insert = |bcb| {
+ bcbs_with_counter_mappings.insert(bcb);
+ };
+
+ for &CodeMapping { span: _, bcb } in code_mappings {
+ insert(bcb);
+ }
+ for &BranchPair { true_bcb, false_bcb, .. } in branch_pairs {
+ insert(true_bcb);
+ insert(false_bcb);
+ }
+ for &MCDCBranch { true_bcb, false_bcb, .. } in mcdc_branches {
+ insert(true_bcb);
+ insert(false_bcb);
+ }
+
+ // MC/DC decisions refer to BCBs, but don't require those BCBs to have counters.
+ if bcbs_with_counter_mappings.is_empty() {
+ debug_assert!(
+ mcdc_decisions.is_empty(),
+ "A function with no counter mappings shouldn't have any decisions: {mcdc_decisions:?}",
+ );
+ }
+
+ bcbs_with_counter_mappings
+ }
}
fn resolve_block_markers(
@@ -215,6 +215,7 @@
mir_body: &mir::Body<'_>,
body_span: Span,
basic_coverage_blocks: &CoverageGraph,
+ mcdc_bitmap_bytes: &mut u32,
mcdc_branches: &mut impl Extend<MCDCBranch>,
mcdc_decisions: &mut impl Extend<MCDCDecision>,
) {
@@ -253,8 +254,6 @@
},
));
- let mut next_bitmap_idx = 0;
-
mcdc_decisions.extend(branch_info.mcdc_decision_spans.iter().filter_map(
|decision: &mir::coverage::MCDCDecisionSpan| {
let (span, _) = unexpand_into_body_span_with_visible_macro(decision.span, body_span)?;
@@ -265,8 +264,11 @@
.map(|&marker| bcb_from_marker(marker))
.collect::<Option<_>>()?;
- let bitmap_idx = next_bitmap_idx;
- next_bitmap_idx += (1_u32 << decision.conditions_num).div_ceil(8);
+ // Each decision containing N conditions needs 2^N bits of space in
+ // the bitmap, rounded up to a whole number of bytes.
+ // The decision's "bitmap index" points to its first byte in the bitmap.
+ let bitmap_idx = *mcdc_bitmap_bytes;
+ *mcdc_bitmap_bytes += (1_u32 << decision.conditions_num).div_ceil(8);
Some(MCDCDecision {
span,
diff --git a/compiler/rustc_mir_transform/src/coverage/mod.rs b/compiler/rustc_mir_transform/src/coverage/mod.rs
index 1e2599e..28e0c63 100644
--- a/compiler/rustc_mir_transform/src/coverage/mod.rs
+++ b/compiler/rustc_mir_transform/src/coverage/mod.rs
@@ -7,13 +7,9 @@
#[cfg(test)]
mod tests;
-use self::counters::{CounterIncrementSite, CoverageCounters};
-use self::graph::{BasicCoverageBlock, CoverageGraph};
-use self::mappings::CoverageSpans;
-
-use crate::MirPass;
-
-use rustc_middle::mir::coverage::*;
+use rustc_middle::mir::coverage::{
+ CodeRegion, CoverageKind, DecisionInfo, FunctionCoverageInfo, Mapping, MappingKind,
+};
use rustc_middle::mir::{
self, BasicBlock, BasicBlockData, SourceInfo, Statement, StatementKind, Terminator,
TerminatorKind,
@@ -23,6 +19,11 @@
use rustc_span::source_map::SourceMap;
use rustc_span::{BytePos, Pos, RelativeBytePos, Span, Symbol};
+use crate::coverage::counters::{CounterIncrementSite, CoverageCounters};
+use crate::coverage::graph::{BasicCoverageBlock, CoverageGraph};
+use crate::coverage::mappings::ExtractedMappings;
+use crate::MirPass;
+
/// Inserts `StatementKind::Coverage` statements that either instrument the binary with injected
/// counters, via intrinsic `llvm.instrprof.increment`, and/or inject metadata used during codegen
/// to construct the coverage map.
@@ -69,24 +70,27 @@
let basic_coverage_blocks = CoverageGraph::from_mir(mir_body);
////////////////////////////////////////////////////
- // Compute coverage spans from the `CoverageGraph`.
- let Some(coverage_spans) =
- mappings::generate_coverage_spans(mir_body, &hir_info, &basic_coverage_blocks)
- else {
- // No relevant spans were found in MIR, so skip instrumenting this function.
- return;
- };
+ // Extract coverage spans and other mapping info from MIR.
+ let extracted_mappings =
+ mappings::extract_all_mapping_info_from_mir(mir_body, &hir_info, &basic_coverage_blocks);
////////////////////////////////////////////////////
// Create an optimized mix of `Counter`s and `Expression`s for the `CoverageGraph`. Ensure
// every coverage span has a `Counter` or `Expression` assigned to its `BasicCoverageBlock`
// and all `Expression` dependencies (operands) are also generated, for any other
// `BasicCoverageBlock`s not already associated with a coverage span.
- let bcb_has_coverage_spans = |bcb| coverage_spans.bcb_has_coverage_spans(bcb);
- let coverage_counters =
- CoverageCounters::make_bcb_counters(&basic_coverage_blocks, bcb_has_coverage_spans);
+ let bcbs_with_counter_mappings =
+ extracted_mappings.all_bcbs_with_counter_mappings(&basic_coverage_blocks);
+ if bcbs_with_counter_mappings.is_empty() {
+ // No relevant spans were found in MIR, so skip instrumenting this function.
+ return;
+ }
- let mappings = create_mappings(tcx, &hir_info, &coverage_spans, &coverage_counters);
+ let bcb_has_counter_mappings = |bcb| bcbs_with_counter_mappings.contains(bcb);
+ let coverage_counters =
+ CoverageCounters::make_bcb_counters(&basic_coverage_blocks, bcb_has_counter_mappings);
+
+ let mappings = create_mappings(tcx, &hir_info, &extracted_mappings, &coverage_counters);
if mappings.is_empty() {
// No spans could be converted into valid mappings, so skip this function.
debug!("no spans could be converted into valid mappings; skipping");
@@ -96,13 +100,13 @@
inject_coverage_statements(
mir_body,
&basic_coverage_blocks,
- bcb_has_coverage_spans,
+ bcb_has_counter_mappings,
&coverage_counters,
);
- inject_mcdc_statements(mir_body, &basic_coverage_blocks, &coverage_spans);
+ inject_mcdc_statements(mir_body, &basic_coverage_blocks, &extracted_mappings);
- let mcdc_num_condition_bitmaps = coverage_spans
+ let mcdc_num_condition_bitmaps = extracted_mappings
.mcdc_decisions
.iter()
.map(|&mappings::MCDCDecision { decision_depth, .. }| decision_depth)
@@ -112,7 +116,7 @@
mir_body.function_coverage_info = Some(Box::new(FunctionCoverageInfo {
function_source_hash: hir_info.function_source_hash,
num_counters: coverage_counters.num_counters(),
- mcdc_bitmap_bytes: coverage_spans.test_vector_bitmap_bytes(),
+ mcdc_bitmap_bytes: extracted_mappings.mcdc_bitmap_bytes,
expressions: coverage_counters.into_expressions(),
mappings,
mcdc_num_condition_bitmaps,
@@ -127,7 +131,7 @@
fn create_mappings<'tcx>(
tcx: TyCtxt<'tcx>,
hir_info: &ExtractedHirInfo,
- coverage_spans: &CoverageSpans,
+ extracted_mappings: &ExtractedMappings,
coverage_counters: &CoverageCounters,
) -> Vec<Mapping> {
let source_map = tcx.sess.source_map();
@@ -148,9 +152,18 @@
};
let region_for_span = |span: Span| make_code_region(source_map, file_name, span, body_span);
+ // Fully destructure the mappings struct to make sure we don't miss any kinds.
+ let ExtractedMappings {
+ code_mappings,
+ branch_pairs,
+ mcdc_bitmap_bytes: _,
+ mcdc_branches,
+ mcdc_decisions,
+ } = extracted_mappings;
let mut mappings = Vec::new();
- mappings.extend(coverage_spans.code_mappings.iter().filter_map(
+ mappings.extend(code_mappings.iter().filter_map(
+ // Ordinary code mappings are the simplest kind.
|&mappings::CodeMapping { span, bcb }| {
let code_region = region_for_span(span)?;
let kind = MappingKind::Code(term_for_bcb(bcb));
@@ -158,7 +171,7 @@
},
));
- mappings.extend(coverage_spans.branch_pairs.iter().filter_map(
+ mappings.extend(branch_pairs.iter().filter_map(
|&mappings::BranchPair { span, true_bcb, false_bcb }| {
let true_term = term_for_bcb(true_bcb);
let false_term = term_for_bcb(false_bcb);
@@ -168,7 +181,7 @@
},
));
- mappings.extend(coverage_spans.mcdc_branches.iter().filter_map(
+ mappings.extend(mcdc_branches.iter().filter_map(
|&mappings::MCDCBranch { span, true_bcb, false_bcb, condition_info, decision_depth: _ }| {
let code_region = region_for_span(span)?;
let true_term = term_for_bcb(true_bcb);
@@ -181,7 +194,7 @@
},
));
- mappings.extend(coverage_spans.mcdc_decisions.iter().filter_map(
+ mappings.extend(mcdc_decisions.iter().filter_map(
|&mappings::MCDCDecision { span, bitmap_idx, conditions_num, .. }| {
let code_region = region_for_span(span)?;
let kind = MappingKind::MCDCDecision(DecisionInfo { bitmap_idx, conditions_num });
@@ -249,12 +262,8 @@
fn inject_mcdc_statements<'tcx>(
mir_body: &mut mir::Body<'tcx>,
basic_coverage_blocks: &CoverageGraph,
- coverage_spans: &CoverageSpans,
+ extracted_mappings: &ExtractedMappings,
) {
- if coverage_spans.test_vector_bitmap_bytes() == 0 {
- return;
- }
-
// Inject test vector update first because `inject_statement` always insert new statement at head.
for &mappings::MCDCDecision {
span: _,
@@ -262,7 +271,7 @@
bitmap_idx,
conditions_num: _,
decision_depth,
- } in &coverage_spans.mcdc_decisions
+ } in &extracted_mappings.mcdc_decisions
{
for end in end_bcbs {
let end_bb = basic_coverage_blocks[*end].leader_bb();
@@ -275,7 +284,7 @@
}
for &mappings::MCDCBranch { span: _, true_bcb, false_bcb, condition_info, decision_depth } in
- &coverage_spans.mcdc_branches
+ &extracted_mappings.mcdc_branches
{
let Some(condition_info) = condition_info else { continue };
let id = condition_info.condition_id;
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index d0f6ec8..3019b27 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -202,7 +202,7 @@
if let Some(target_len) = self.map().find_len(target.as_ref())
&& let operand_ty = operand.ty(self.local_decls, self.tcx)
&& let Some(operand_ty) = operand_ty.builtin_deref(true)
- && let ty::Array(_, len) = operand_ty.ty.kind()
+ && let ty::Array(_, len) = operand_ty.kind()
&& let Some(len) = Const::Ty(*len).try_eval_scalar_int(self.tcx, self.param_env)
{
state.insert_value_idx(target_len, FlatSet::Elem(len.into()), self.map());
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 4dd595c..342d1a1 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -594,7 +594,7 @@
let ty = place.ty(self.local_decls, self.tcx).ty;
if let Some(Mutability::Not) = ty.ref_mutability()
&& let Some(pointee_ty) = ty.builtin_deref(true)
- && pointee_ty.ty.is_freeze(self.tcx, self.param_env)
+ && pointee_ty.is_freeze(self.tcx, self.param_env)
{
// An immutable borrow `_x` always points to the same value for the
// lifetime of the borrow, so we can merge all instances of `*_x`.
@@ -1133,9 +1133,9 @@
if let Value::Cast { kind, from, to, .. } = self.get(inner)
&& let CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize) = kind
&& let Some(from) = from.builtin_deref(true)
- && let ty::Array(_, len) = from.ty.kind()
+ && let ty::Array(_, len) = from.kind()
&& let Some(to) = to.builtin_deref(true)
- && let ty::Slice(..) = to.ty.kind()
+ && let ty::Slice(..) = to.kind()
{
return self.insert_constant(Const::from_ty_const(*len, self.tcx));
}
diff --git a/compiler/rustc_mir_transform/src/mentioned_items.rs b/compiler/rustc_mir_transform/src/mentioned_items.rs
index 57b6126..db2bb60 100644
--- a/compiler/rustc_mir_transform/src/mentioned_items.rs
+++ b/compiler/rustc_mir_transform/src/mentioned_items.rs
@@ -79,8 +79,8 @@
// add everything that may involve a vtable.
let source_ty = operand.ty(self.body, self.tcx);
let may_involve_vtable = match (
- source_ty.builtin_deref(true).map(|t| t.ty.kind()),
- target_ty.builtin_deref(true).map(|t| t.ty.kind()),
+ source_ty.builtin_deref(true).map(|t| t.kind()),
+ target_ty.builtin_deref(true).map(|t| t.kind()),
) {
(Some(ty::Array(..)), Some(ty::Str | ty::Slice(..))) => false, // &str/&[T] unsizing
_ => true,
diff --git a/compiler/rustc_mir_transform/src/normalize_array_len.rs b/compiler/rustc_mir_transform/src/normalize_array_len.rs
index c26a546..2070895 100644
--- a/compiler/rustc_mir_transform/src/normalize_array_len.rs
+++ b/compiler/rustc_mir_transform/src/normalize_array_len.rs
@@ -48,9 +48,9 @@
let operand_ty = operand.ty(body, tcx);
debug!(?operand_ty);
if let Some(operand_ty) = operand_ty.builtin_deref(true)
- && let ty::Array(_, len) = operand_ty.ty.kind()
+ && let ty::Array(_, len) = operand_ty.kind()
&& let Some(cast_ty) = cast_ty.builtin_deref(true)
- && let ty::Slice(..) = cast_ty.ty.kind()
+ && let ty::Slice(..) = cast_ty.kind()
{
slice_lengths[local] = Some(*len);
}
diff --git a/compiler/rustc_monomorphize/src/polymorphize.rs b/compiler/rustc_monomorphize/src/polymorphize.rs
index 6d237df..6487169 100644
--- a/compiler/rustc_monomorphize/src/polymorphize.rs
+++ b/compiler/rustc_monomorphize/src/polymorphize.rs
@@ -131,7 +131,7 @@
) {
match tcx.def_kind(def_id) {
DefKind::Closure => {
- for param in &generics.params {
+ for param in &generics.own_params {
debug!(?param, "(closure/gen)");
unused_parameters.mark_used(param.index);
}
@@ -165,7 +165,7 @@
| DefKind::LifetimeParam
| DefKind::GlobalAsm
| DefKind::Impl { .. } => {
- for param in &generics.params {
+ for param in &generics.own_params {
debug!(?param, "(other)");
if let ty::GenericParamDefKind::Lifetime = param.kind {
unused_parameters.mark_used(param.index);
@@ -202,7 +202,7 @@
let mut param_names = Vec::new();
let mut next_generics = Some(generics);
while let Some(generics) = next_generics {
- for param in &generics.params {
+ for param in &generics.own_params {
if unused_parameters.is_unused(param.index) {
debug!(?param);
let def_span = tcx.def_span(param.def_id);
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 873095d..04f855e 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -401,10 +401,8 @@
.use_amp_amp_for_conjunction = use `&&` to perform logical conjunction
.use_pipe_pipe_for_disjunction = use `||` to perform logical disjunction
-parse_invalid_meta_item = expected unsuffixed literal or identifier, found `{$token}`
-
-parse_invalid_meta_item_unquoted_ident = expected unsuffixed literal, found `{$token}`
- .suggestion = surround the identifier with quotation marks to parse it as a string
+parse_invalid_meta_item = expected unsuffixed literal, found `{$token}`
+ .quote_ident_sugg = surround the identifier with quotation marks to make it into a string literal
parse_invalid_offset_of = offset_of expects dot-separated field and variant names
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index d06f03a..2f68a29 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -978,21 +978,13 @@
#[primary_span]
pub span: Span,
pub token: Token,
-}
-
-#[derive(Diagnostic)]
-#[diag(parse_invalid_meta_item_unquoted_ident)]
-pub(crate) struct InvalidMetaItemUnquotedIdent {
- #[primary_span]
- pub span: Span,
- pub token: Token,
#[subdiagnostic]
- pub sugg: InvalidMetaItemSuggQuoteIdent,
+ pub quote_ident_sugg: Option<InvalidMetaItemQuoteIdentSugg>,
}
#[derive(Subdiagnostic)]
-#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
-pub(crate) struct InvalidMetaItemSuggQuoteIdent {
+#[multipart_suggestion(parse_quote_ident_sugg, applicability = "machine-applicable")]
+pub(crate) struct InvalidMetaItemQuoteIdentSugg {
#[suggestion_part(code = "\"")]
pub before: Span,
#[suggestion_part(code = "\"")]
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index ab5f51e..d5d8060 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -1,7 +1,4 @@
-use crate::errors::{
- InvalidMetaItem, InvalidMetaItemSuggQuoteIdent, InvalidMetaItemUnquotedIdent,
- SuffixedLiteralInAttribute,
-};
+use crate::errors;
use crate::fluent_generated as fluent;
use crate::maybe_whole;
@@ -318,7 +315,7 @@
debug!("checking if {:?} is unsuffixed", lit);
if !lit.kind.is_unsuffixed() {
- self.dcx().emit_err(SuffixedLiteralInAttribute { span: lit.span });
+ self.dcx().emit_err(errors::SuffixedLiteralInAttribute { span: lit.span });
}
Ok(lit)
@@ -356,10 +353,11 @@
Ok(nmis)
}
- /// Matches the following grammar (per RFC 1559).
+ /// Parse a meta item per RFC 1559.
+ ///
/// ```ebnf
- /// meta_item : PATH ( '=' UNSUFFIXED_LIT | '(' meta_item_inner? ')' )? ;
- /// meta_item_inner : (meta_item | UNSUFFIXED_LIT) (',' meta_item_inner)? ;
+ /// MetaItem = SimplePath ( '=' UNSUFFIXED_LIT | '(' MetaSeq? ')' )? ;
+ /// MetaSeq = MetaItemInner (',' MetaItemInner)* ','? ;
/// ```
pub fn parse_meta_item(&mut self) -> PResult<'a, ast::MetaItem> {
// We can't use `maybe_whole` here because it would bump in the `None`
@@ -387,7 +385,6 @@
Ok(if self.eat(&token::Eq) {
ast::MetaItemKind::NameValue(self.parse_unsuffixed_meta_item_lit()?)
} else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) {
- // Matches `meta_seq = ( COMMASEP(meta_item_inner) )`.
let (list, _) = self.parse_paren_comma_seq(|p| p.parse_meta_item_inner())?;
ast::MetaItemKind::List(list)
} else {
@@ -395,38 +392,45 @@
})
}
- /// Matches `meta_item_inner : (meta_item | UNSUFFIXED_LIT) ;`.
+ /// Parse an inner meta item per RFC 1559.
+ ///
+ /// ```ebnf
+ /// MetaItemInner = UNSUFFIXED_LIT | MetaItem ;
+ /// ```
fn parse_meta_item_inner(&mut self) -> PResult<'a, ast::NestedMetaItem> {
match self.parse_unsuffixed_meta_item_lit() {
Ok(lit) => return Ok(ast::NestedMetaItem::Lit(lit)),
- Err(err) => err.cancel(),
+ Err(err) => err.cancel(), // we provide a better error below
}
match self.parse_meta_item() {
Ok(mi) => return Ok(ast::NestedMetaItem::MetaItem(mi)),
- Err(err) => err.cancel(),
+ Err(err) => err.cancel(), // we provide a better error below
}
- let token = self.token.clone();
+ let mut err = errors::InvalidMetaItem {
+ span: self.token.span,
+ token: self.token.clone(),
+ quote_ident_sugg: None,
+ };
- // Check for unquoted idents in meta items, e.g.: #[cfg(key = foo)]
- // `from_expansion()` ensures we don't suggest for cases such as
- // `#[cfg(feature = $expr)]` in macros
- if self.prev_token == token::Eq && !self.token.span.from_expansion() {
+ // Suggest quoting idents, e.g. in `#[cfg(key = value)]`. We don't use `Token::ident` and
+ // don't `uninterpolate` the token to avoid suggesting anything butchered or questionable
+ // when macro metavariables are involved.
+ if self.prev_token == token::Eq
+ && let token::Ident(..) = self.token.kind
+ {
let before = self.token.span.shrink_to_lo();
- while matches!(self.token.kind, token::Ident(..)) {
+ while let token::Ident(..) = self.token.kind {
self.bump();
}
- let after = self.prev_token.span.shrink_to_hi();
- let sugg = InvalidMetaItemSuggQuoteIdent { before, after };
- return Err(self.dcx().create_err(InvalidMetaItemUnquotedIdent {
- span: token.span,
- token,
- sugg,
- }));
+ err.quote_ident_sugg = Some(errors::InvalidMetaItemQuoteIdentSugg {
+ before,
+ after: self.prev_token.span.shrink_to_hi(),
+ });
}
- Err(self.dcx().create_err(InvalidMetaItem { span: token.span, token }))
+ Err(self.dcx().create_err(err))
}
}
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index f256dbf..995803f 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -22,7 +22,6 @@
use crate::parser;
use crate::parser::attr::InnerAttrPolicy;
use ast::token::IdentIsRaw;
-use parser::Recovered;
use rustc_ast as ast;
use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter, Lit, LitKind, Token, TokenKind};
@@ -31,7 +30,7 @@
use rustc_ast::{
AngleBracketedArg, AngleBracketedArgs, AnonConst, AttrVec, BinOpKind, BindingMode, Block,
BlockCheckMode, Expr, ExprKind, GenericArg, Generics, HasTokens, Item, ItemKind, Param, Pat,
- PatKind, Path, PathSegment, QSelf, Ty, TyKind,
+ PatKind, Path, PathSegment, QSelf, Recovered, Ty, TyKind,
};
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashSet;
@@ -527,14 +526,14 @@
//
// let x = 32:
// let y = 42;
- self.dcx().emit_err(ExpectedSemi {
+ let guar = self.dcx().emit_err(ExpectedSemi {
span: self.token.span,
token: self.token.clone(),
unexpected_token_label: None,
sugg: ExpectedSemiSugg::ChangeToSemi(self.token.span),
});
self.bump();
- return Ok(Recovered::Yes);
+ return Ok(Recovered::Yes(guar));
} else if self.look_ahead(0, |t| {
t == &token::CloseDelim(Delimiter::Brace)
|| ((t.can_begin_expr() || t.can_begin_item())
@@ -552,13 +551,13 @@
// let x = 32
// let y = 42;
let span = self.prev_token.span.shrink_to_hi();
- self.dcx().emit_err(ExpectedSemi {
+ let guar = self.dcx().emit_err(ExpectedSemi {
span,
token: self.token.clone(),
unexpected_token_label: Some(self.token.span),
sugg: ExpectedSemiSugg::AddSemi(span),
});
- return Ok(Recovered::Yes);
+ return Ok(Recovered::Yes(guar));
}
}
@@ -712,8 +711,8 @@
if self.check_too_many_raw_str_terminators(&mut err) {
if expected.contains(&TokenType::Token(token::Semi)) && self.eat(&token::Semi) {
- err.emit();
- return Ok(Recovered::Yes);
+ let guar = err.emit();
+ return Ok(Recovered::Yes(guar));
} else {
return Err(err);
}
@@ -1251,7 +1250,7 @@
}
}
}
- Ok((_, _, Recovered::Yes)) => {}
+ Ok((_, _, Recovered::Yes(_))) => {}
Err(err) => {
err.cancel();
}
@@ -1284,13 +1283,13 @@
/// Check to see if a pair of chained operators looks like an attempt at chained comparison,
/// e.g. `1 < x <= 3`. If so, suggest either splitting the comparison into two, or
- /// parenthesising the leftmost comparison.
+ /// parenthesising the leftmost comparison. The return value indicates if recovery happened.
fn attempt_chained_comparison_suggestion(
&mut self,
err: &mut ComparisonOperatorsCannotBeChained,
inner_op: &Expr,
outer_op: &Spanned<AssocOp>,
- ) -> Recovered {
+ ) -> bool {
if let ExprKind::Binary(op, l1, r1) = &inner_op.kind {
if let ExprKind::Field(_, ident) = l1.kind
&& ident.as_str().parse::<i32>().is_err()
@@ -1298,7 +1297,7 @@
{
// The parser has encountered `foo.bar<baz`, the likelihood of the turbofish
// suggestion being the only one to apply is high.
- return Recovered::No;
+ return false;
}
return match (op.node, &outer_op.node) {
// `x == y == z`
@@ -1317,7 +1316,7 @@
span: inner_op.span.shrink_to_hi(),
middle_term: expr_to_str(r1),
});
- Recovered::No // Keep the current parse behavior, where the AST is `(x < y) < z`.
+ false // Keep the current parse behavior, where the AST is `(x < y) < z`.
}
// `x == y < z`
(BinOpKind::Eq, AssocOp::Less | AssocOp::LessEqual | AssocOp::Greater | AssocOp::GreaterEqual) => {
@@ -1331,12 +1330,12 @@
left: r1.span.shrink_to_lo(),
right: r2.span.shrink_to_hi(),
});
- Recovered::Yes
+ true
}
Err(expr_err) => {
expr_err.cancel();
self.restore_snapshot(snapshot);
- Recovered::Yes
+ true
}
}
}
@@ -1351,19 +1350,19 @@
left: l1.span.shrink_to_lo(),
right: r1.span.shrink_to_hi(),
});
- Recovered::Yes
+ true
}
Err(expr_err) => {
expr_err.cancel();
self.restore_snapshot(snapshot);
- Recovered::No
+ false
}
}
}
- _ => Recovered::No,
+ _ => false
};
}
- Recovered::No
+ false
}
/// Produces an error if comparison operators are chained (RFC #558).
@@ -1494,7 +1493,7 @@
// misformatted turbofish, for instance), suggest a correct form.
let recovered = self
.attempt_chained_comparison_suggestion(&mut err, inner_op, outer_op);
- if matches!(recovered, Recovered::Yes) {
+ if recovered {
let guar = self.dcx().emit_err(err);
mk_err_expr(self, inner_op.span.to(self.prev_token.span), guar)
} else {
@@ -1503,10 +1502,10 @@
}
};
}
- let recover =
+ let recovered =
self.attempt_chained_comparison_suggestion(&mut err, inner_op, outer_op);
let guar = self.dcx().emit_err(err);
- if matches!(recover, Recovered::Yes) {
+ if recovered {
return mk_err_expr(self, inner_op.span.to(self.prev_token.span), guar);
}
}
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 8ed2a6e..577003e 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -3,7 +3,7 @@
use super::pat::{CommaRecoveryMode, Expected, RecoverColon, RecoverComma};
use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
use super::{
- AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Recovered, Restrictions,
+ AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Restrictions,
SemiColonMode, SeqSep, TokenExpectType, TokenType, Trailing, TrailingToken,
};
@@ -11,7 +11,7 @@
use crate::maybe_recover_from_interpolated_ty_qpath;
use ast::mut_visit::{noop_visit_expr, MutVisitor};
use ast::token::IdentIsRaw;
-use ast::{CoroutineKind, ForLoopKind, GenBlockKind, MatchKind, Pat, Path, PathSegment};
+use ast::{CoroutineKind, ForLoopKind, GenBlockKind, MatchKind, Pat, Path, PathSegment, Recovered};
use core::mem;
use core::ops::ControlFlow;
use rustc_ast::ptr::P;
@@ -2629,7 +2629,7 @@
CondChecker::new(self).visit_expr(&mut cond);
- if let ExprKind::Let(_, _, _, None) = cond.kind {
+ if let ExprKind::Let(_, _, _, Recovered::No) = cond.kind {
// Remove the last feature gating of a `let` expression since it's stable.
self.psess.gated_spans.ungate_last(sym::let_chains, cond.span);
}
@@ -2639,7 +2639,7 @@
/// Parses a `let $pat = $expr` pseudo-expression.
fn parse_expr_let(&mut self, restrictions: Restrictions) -> PResult<'a, P<Expr>> {
- let is_recovered = if !restrictions.contains(Restrictions::ALLOW_LET) {
+ let recovered = if !restrictions.contains(Restrictions::ALLOW_LET) {
let err = errors::ExpectedExpressionFoundLet {
span: self.token.span,
reason: ForbiddenLetReason::OtherForbidden,
@@ -2650,10 +2650,10 @@
// This was part of a closure, the that part of the parser recover.
return Err(self.dcx().create_err(err));
} else {
- Some(self.dcx().emit_err(err))
+ Recovered::Yes(self.dcx().emit_err(err))
}
} else {
- None
+ Recovered::No
};
self.bump(); // Eat `let` token
let lo = self.prev_token.span;
@@ -2674,7 +2674,7 @@
}
let expr = self.parse_expr_assoc_with(1 + prec_let_scrutinee_needs_par(), None.into())?;
let span = lo.to(expr.span);
- Ok(self.mk_expr(span, ExprKind::Let(pat, expr, span, is_recovered)))
+ Ok(self.mk_expr(span, ExprKind::Let(pat, expr, span, recovered)))
}
/// Parses an `else { ... }` expression (`else` token already eaten).
@@ -2998,7 +2998,7 @@
&mut self,
first_expr: &P<Expr>,
arrow_span: Span,
- ) -> Option<P<Expr>> {
+ ) -> Option<(Span, ErrorGuaranteed)> {
if self.token.kind != token::Semi {
return None;
}
@@ -3023,7 +3023,7 @@
errors::MatchArmBodyWithoutBracesSugg::UseComma { semicolon: semi_sp }
},
});
- this.mk_expr_err(span, guar)
+ (span, guar)
};
// We might have either a `,` -> `;` typo, or a block without braces. We need
// a more subtle parsing strategy.
@@ -3143,9 +3143,12 @@
arm_body = Some(expr);
this.eat(&token::Comma);
Ok(Recovered::No)
- } else if let Some(body) = this.parse_arm_body_missing_braces(&expr, arrow_span) {
+ } else if let Some((span, guar)) =
+ this.parse_arm_body_missing_braces(&expr, arrow_span)
+ {
+ let body = this.mk_expr_err(span, guar);
arm_body = Some(body);
- Ok(Recovered::Yes)
+ Ok(Recovered::Yes(guar))
} else {
let expr_span = expr.span;
arm_body = Some(expr);
@@ -3223,10 +3226,10 @@
.is_ok();
if pattern_follows && snapshot.check(&TokenKind::FatArrow) {
err.cancel();
- this.dcx().emit_err(errors::MissingCommaAfterMatchArm {
+ let guar = this.dcx().emit_err(errors::MissingCommaAfterMatchArm {
span: arm_span.shrink_to_hi(),
});
- return Ok(Recovered::Yes);
+ return Ok(Recovered::Yes(guar));
}
Err(err)
});
@@ -3904,15 +3907,16 @@
let span = e.span;
match e.kind {
- ExprKind::Let(_, _, _, ref mut is_recovered @ None) => {
+ ExprKind::Let(_, _, _, ref mut recovered @ Recovered::No) => {
if let Some(reason) = self.forbid_let_reason {
- *is_recovered =
- Some(self.parser.dcx().emit_err(errors::ExpectedExpressionFoundLet {
+ *recovered = Recovered::Yes(self.parser.dcx().emit_err(
+ errors::ExpectedExpressionFoundLet {
span,
reason,
missing_let: self.missing_let,
comparison: self.comparison,
- }));
+ },
+ ));
} else {
self.parser.psess.gated_spans.gate(sym::let_chains, span);
}
@@ -3980,7 +3984,7 @@
self.visit_expr(op);
self.forbid_let_reason = forbid_let_reason;
}
- ExprKind::Let(_, _, _, Some(_))
+ ExprKind::Let(_, _, _, Recovered::Yes(_))
| ExprKind::Array(_)
| ExprKind::ConstBlock(_)
| ExprKind::Lit(_)
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 3ac50a6..df6996d 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -1,8 +1,7 @@
use super::diagnostics::{dummy_arg, ConsumeClosingDelim};
use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
use super::{
- AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, Recovered, Trailing,
- TrailingToken,
+ AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, Trailing, TrailingToken,
};
use crate::errors::{self, MacroExpandsToAdtField};
use crate::fluent_generated as fluent;
@@ -1540,8 +1539,8 @@
this.bump(); // }
err.span_label(span, "while parsing this enum");
err.help(help);
- err.emit();
- (thin_vec![], Recovered::Yes)
+ let guar = err.emit();
+ (thin_vec![], Recovered::Yes(guar))
}
};
VariantData::Struct { fields, recovered: recovered.into() }
@@ -1699,16 +1698,15 @@
let mut recovered = Recovered::No;
if self.eat(&token::OpenDelim(Delimiter::Brace)) {
while self.token != token::CloseDelim(Delimiter::Brace) {
- let field = self.parse_field_def(adt_ty).map_err(|e| {
- self.consume_block(Delimiter::Brace, ConsumeClosingDelim::No);
- recovered = Recovered::Yes;
- e
- });
- match field {
- Ok(field) => fields.push(field),
+ match self.parse_field_def(adt_ty) {
+ Ok(field) => {
+ fields.push(field);
+ }
Err(mut err) => {
+ self.consume_block(Delimiter::Brace, ConsumeClosingDelim::No);
err.span_label(ident_span, format!("while parsing this {adt_ty}"));
- err.emit();
+ let guar = err.emit();
+ recovered = Recovered::Yes(guar);
break;
}
}
@@ -2469,7 +2467,7 @@
// `self.expected_tokens`, therefore, do not use `self.unexpected()` which doesn't
// account for this.
match self.expect_one_of(&[], &[]) {
- Ok(Recovered::Yes) => {}
+ Ok(Recovered::Yes(_)) => {}
Ok(Recovered::No) => unreachable!(),
Err(mut err) => {
// Qualifier keywords ordering check
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 7dedf03..bfb6c4a 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -27,13 +27,12 @@
use rustc_ast::util::case::Case;
use rustc_ast::{
self as ast, AnonConst, AttrArgs, AttrArgsEq, AttrId, ByRef, Const, CoroutineKind, DelimArgs,
- Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, StrLit, Unsafe, Visibility,
+ Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Recovered, StrLit, Unsafe, Visibility,
VisibilityKind, DUMMY_NODE_ID,
};
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::PResult;
-use rustc_errors::{Applicability, Diag, FatalError, MultiSpan};
+use rustc_errors::{Applicability, Diag, FatalError, MultiSpan, PResult};
use rustc_session::parse::ParseSess;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
@@ -374,19 +373,6 @@
No,
}
-/// Whether a function performed recovery
-#[derive(Copy, Clone, Debug)]
-pub enum Recovered {
- No,
- Yes,
-}
-
-impl From<Recovered> for bool {
- fn from(r: Recovered) -> bool {
- matches!(r, Recovered::Yes)
- }
-}
-
#[derive(Copy, Clone, Debug)]
pub enum Trailing {
No,
@@ -856,9 +842,9 @@
Ok(Recovered::No) => {
self.current_closure.take();
}
- Ok(Recovered::Yes) => {
+ Ok(Recovered::Yes(guar)) => {
self.current_closure.take();
- recovered = Recovered::Yes;
+ recovered = Recovered::Yes(guar);
break;
}
Err(mut expect_err) => {
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 6601011..d70afeb 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -11,14 +11,13 @@
use crate::maybe_whole;
use crate::errors::MalformedLoopLabel;
-use crate::parser::Recovered;
use ast::Label;
use rustc_ast as ast;
use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter, TokenKind};
use rustc_ast::util::classify;
use rustc_ast::{AttrStyle, AttrVec, LocalKind, MacCall, MacCallStmt, MacStmtStyle};
-use rustc_ast::{Block, BlockCheckMode, Expr, ExprKind, HasAttrs, Local, Stmt};
+use rustc_ast::{Block, BlockCheckMode, Expr, ExprKind, HasAttrs, Local, Recovered, Stmt};
use rustc_ast::{StmtKind, DUMMY_NODE_ID};
use rustc_errors::{Applicability, Diag, PResult};
use rustc_span::symbol::{kw, sym, Ident};
@@ -675,11 +674,8 @@
let replace_with_err = 'break_recover: {
match expect_result {
Ok(Recovered::No) => None,
- Ok(Recovered::Yes) => {
+ Ok(Recovered::Yes(guar)) => {
// Skip type error to avoid extra errors.
- let guar = self
- .dcx()
- .span_delayed_bug(self.prev_token.span, "expected `;` or `}`");
Some(guar)
}
Err(e) => {
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 9d58d30..3deefca 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -52,16 +52,16 @@
passes_both_ffi_const_and_pure =
`#[ffi_const]` function cannot be `#[ffi_pure]`
-passes_break_inside_async_block =
- `{$name}` inside of an `async` block
- .label = cannot `{$name}` inside of an `async` block
- .async_block_label = enclosing `async` block
-
passes_break_inside_closure =
`{$name}` inside of a closure
.label = cannot `{$name}` inside of a closure
.closure_label = enclosing closure
+passes_break_inside_coroutine =
+ `{$name}` inside `{$kind}` {$source}
+ .label = cannot `{$name}` inside `{$kind}` {$source}
+ .coroutine_label = enclosing `{$kind}` {$source}
+
passes_break_non_loop =
`break` with value from a `{$kind}` loop
.label = can only break with a value inside `loop` or breakable block
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 65cad82..b8586e7 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1086,14 +1086,16 @@
}
#[derive(Diagnostic)]
-#[diag(passes_break_inside_async_block, code = E0267)]
-pub struct BreakInsideAsyncBlock<'a> {
+#[diag(passes_break_inside_coroutine, code = E0267)]
+pub struct BreakInsideCoroutine<'a> {
#[primary_span]
#[label]
pub span: Span,
- #[label(passes_async_block_label)]
- pub closure_span: Span,
+ #[label(passes_coroutine_label)]
+ pub coroutine_span: Span,
pub name: &'a str,
+ pub kind: &'a str,
+ pub source: &'a str,
}
#[derive(Diagnostic)]
diff --git a/compiler/rustc_passes/src/loops.rs b/compiler/rustc_passes/src/loops.rs
index 4b5c4df..3b20112 100644
--- a/compiler/rustc_passes/src/loops.rs
+++ b/compiler/rustc_passes/src/loops.rs
@@ -13,7 +13,7 @@
use rustc_span::{BytePos, Span};
use crate::errors::{
- BreakInsideAsyncBlock, BreakInsideClosure, BreakNonLoop, ContinueLabeledBlock, OutsideLoop,
+ BreakInsideClosure, BreakInsideCoroutine, BreakNonLoop, ContinueLabeledBlock, OutsideLoop,
OutsideLoopSuggestion, UnlabeledCfInWhileCondition, UnlabeledInLabeledBlock,
};
@@ -23,7 +23,7 @@
Fn,
Loop(hir::LoopSource),
Closure(Span),
- AsyncClosure(Span),
+ Coroutine { coroutine_span: Span, kind: hir::CoroutineDesugaring, source: hir::CoroutineSource },
UnlabeledBlock(Span),
LabeledBlock,
Constant,
@@ -89,12 +89,10 @@
hir::ExprKind::Closure(&hir::Closure {
ref fn_decl, body, fn_decl_span, kind, ..
}) => {
- // FIXME(coroutines): This doesn't handle coroutines correctly
let cx = match kind {
- hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
- hir::CoroutineDesugaring::Async,
- hir::CoroutineSource::Block,
- )) => AsyncClosure(fn_decl_span),
+ hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(kind, source)) => {
+ Coroutine { coroutine_span: fn_decl_span, kind, source }
+ }
_ => Closure(fn_decl_span),
};
self.visit_fn_decl(fn_decl);
@@ -227,8 +225,24 @@
Closure(closure_span) => {
self.sess.dcx().emit_err(BreakInsideClosure { span, closure_span, name });
}
- AsyncClosure(closure_span) => {
- self.sess.dcx().emit_err(BreakInsideAsyncBlock { span, closure_span, name });
+ Coroutine { coroutine_span, kind, source } => {
+ let kind = match kind {
+ hir::CoroutineDesugaring::Async => "async",
+ hir::CoroutineDesugaring::Gen => "gen",
+ hir::CoroutineDesugaring::AsyncGen => "async gen",
+ };
+ let source = match source {
+ hir::CoroutineSource::Block => "block",
+ hir::CoroutineSource::Closure => "closure",
+ hir::CoroutineSource::Fn => "function",
+ };
+ self.sess.dcx().emit_err(BreakInsideCoroutine {
+ span,
+ coroutine_span,
+ name,
+ kind,
+ source,
+ });
}
UnlabeledBlock(block_span) if is_break && block_span.eq_ctxt(break_span) => {
let suggestion = Some(OutsideLoopSuggestion { block_span, break_span });
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index a78f7e6..e64d2eb 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -787,7 +787,7 @@
impl ReachEverythingInTheInterfaceVisitor<'_, '_> {
fn generics(&mut self) -> &mut Self {
- for param in &self.ev.tcx.generics_of(self.item_def_id).params {
+ for param in &self.ev.tcx.generics_of(self.item_def_id).own_params {
match param.kind {
GenericParamDefKind::Lifetime => {}
GenericParamDefKind::Type { has_default, .. } => {
@@ -1259,7 +1259,7 @@
impl SearchInterfaceForPrivateItemsVisitor<'_> {
fn generics(&mut self) -> &mut Self {
self.in_primary_interface = true;
- for param in &self.tcx.generics_of(self.item_def_id).params {
+ for param in &self.tcx.generics_of(self.item_def_id).own_params {
match param.kind {
GenericParamDefKind::Lifetime => {}
GenericParamDefKind::Type { has_default, .. } => {
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs b/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
index 6fb1560..cbc3aae 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
@@ -256,10 +256,9 @@
rustc_abi::Primitive::Int(length, signed) => {
Primitive::Int { length: length.stable(tables), signed: *signed }
}
- rustc_abi::Primitive::F16 => Primitive::Float { length: FloatLength::F16 },
- rustc_abi::Primitive::F32 => Primitive::Float { length: FloatLength::F32 },
- rustc_abi::Primitive::F64 => Primitive::Float { length: FloatLength::F64 },
- rustc_abi::Primitive::F128 => Primitive::Float { length: FloatLength::F128 },
+ rustc_abi::Primitive::Float(length) => {
+ Primitive::Float { length: length.stable(tables) }
+ }
rustc_abi::Primitive::Pointer(space) => Primitive::Pointer(space.stable(tables)),
}
}
@@ -287,6 +286,19 @@
}
}
+impl<'tcx> Stable<'tcx> for rustc_abi::Float {
+ type T = FloatLength;
+
+ fn stable(&self, _tables: &mut Tables<'_>) -> Self::T {
+ match self {
+ rustc_abi::Float::F16 => FloatLength::F16,
+ rustc_abi::Float::F32 => FloatLength::F32,
+ rustc_abi::Float::F64 => FloatLength::F64,
+ rustc_abi::Float::F128 => FloatLength::F128,
+ }
+ }
+}
+
impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange {
type T = WrappingRange;
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index 4abf991..c442d33 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -523,7 +523,7 @@
fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
use stable_mir::ty::Generics;
- let params: Vec<_> = self.params.iter().map(|param| param.stable(tables)).collect();
+ let params: Vec<_> = self.own_params.iter().map(|param| param.stable(tables)).collect();
let param_def_id_to_index =
params.iter().map(|param| (param.def_id, param.index)).collect();
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 5cdfb77..1de2ecb 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -630,8 +630,7 @@
let pointee_ty = ct
.ty()
.builtin_deref(true)
- .expect("tried to dereference on non-ptr type")
- .ty;
+ .expect("tried to dereference on non-ptr type");
// FIXME(const_generics): add an assert that we only do this for valtrees.
let dereferenced_const = self.tcx.mk_ct_from_kind(ct.kind(), pointee_ty);
dereferenced_const.print(self)?;
diff --git a/compiler/rustc_target/src/abi/call/loongarch.rs b/compiler/rustc_target/src/abi/call/loongarch.rs
index 943b12a..893818a 100644
--- a/compiler/rustc_target/src/abi/call/loongarch.rs
+++ b/compiler/rustc_target/src/abi/call/loongarch.rs
@@ -59,7 +59,7 @@
_ => return Err(CannotUseFpConv),
}
}
- abi::F16 | abi::F32 | abi::F64 | abi::F128 => {
+ abi::Float(_) => {
if arg_layout.size.bits() > flen {
return Err(CannotUseFpConv);
}
diff --git a/compiler/rustc_target/src/abi/call/mips64.rs b/compiler/rustc_target/src/abi/call/mips64.rs
index b2a2c34..5b52ebb 100644
--- a/compiler/rustc_target/src/abi/call/mips64.rs
+++ b/compiler/rustc_target/src/abi/call/mips64.rs
@@ -26,8 +26,8 @@
{
match ret.layout.field(cx, i).abi {
abi::Abi::Scalar(scalar) => match scalar.primitive() {
- abi::F32 => Some(Reg::f32()),
- abi::F64 => Some(Reg::f64()),
+ abi::Float(abi::F32) => Some(Reg::f32()),
+ abi::Float(abi::F64) => Some(Reg::f64()),
_ => None,
},
_ => None,
@@ -110,7 +110,7 @@
// We only care about aligned doubles
if let abi::Abi::Scalar(scalar) = field.abi {
- if let abi::F64 = scalar.primitive() {
+ if scalar.primitive() == abi::Float(abi::F64) {
if offset.is_aligned(dl.f64_align.abi) {
// Insert enough integers to cover [last_offset, offset)
assert!(last_offset.is_aligned(dl.f64_align.abi));
diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
index 3ddea42..919fa21 100644
--- a/compiler/rustc_target/src/abi/call/mod.rs
+++ b/compiler/rustc_target/src/abi/call/mod.rs
@@ -443,7 +443,7 @@
Abi::Scalar(scalar) => {
let kind = match scalar.primitive() {
abi::Int(..) | abi::Pointer(_) => RegKind::Integer,
- abi::F16 | abi::F32 | abi::F64 | abi::F128 => RegKind::Float,
+ abi::Float(_) => RegKind::Float,
};
Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
}
diff --git a/compiler/rustc_target/src/abi/call/riscv.rs b/compiler/rustc_target/src/abi/call/riscv.rs
index 5d4b3a9..84f13f8 100644
--- a/compiler/rustc_target/src/abi/call/riscv.rs
+++ b/compiler/rustc_target/src/abi/call/riscv.rs
@@ -65,7 +65,7 @@
_ => return Err(CannotUseFpConv),
}
}
- abi::F16 | abi::F32 | abi::F64 | abi::F128 => {
+ abi::Float(_) => {
if arg_layout.size.bits() > flen {
return Err(CannotUseFpConv);
}
diff --git a/compiler/rustc_target/src/abi/call/sparc64.rs b/compiler/rustc_target/src/abi/call/sparc64.rs
index acdcd5c..c0952130 100644
--- a/compiler/rustc_target/src/abi/call/sparc64.rs
+++ b/compiler/rustc_target/src/abi/call/sparc64.rs
@@ -20,7 +20,7 @@
{
let dl = cx.data_layout();
- if !matches!(scalar.primitive(), abi::F32 | abi::F64) {
+ if !matches!(scalar.primitive(), abi::Float(abi::F32 | abi::F64)) {
return data;
}
@@ -56,7 +56,7 @@
return data;
}
- if scalar.primitive() == abi::F32 {
+ if scalar.primitive() == abi::Float(abi::F32) {
data.arg_attribute = ArgAttribute::InReg;
data.prefix[data.prefix_index] = Some(Reg::f32());
data.last_offset = offset + Reg::f32().size;
@@ -80,14 +80,14 @@
{
data = arg_scalar(cx, scalar1, offset, data);
match (scalar1.primitive(), scalar2.primitive()) {
- (abi::F32, _) => offset += Reg::f32().size,
- (_, abi::F64) => offset += Reg::f64().size,
+ (abi::Float(abi::F32), _) => offset += Reg::f32().size,
+ (_, abi::Float(abi::F64)) => offset += Reg::f64().size,
(abi::Int(i, _signed), _) => offset += i.size(),
(abi::Pointer(_), _) => offset += Reg::i64().size,
_ => {}
}
- if (offset.bytes() % 4) != 0 && matches!(scalar2.primitive(), abi::F32 | abi::F64) {
+ if (offset.bytes() % 4) != 0 && matches!(scalar2.primitive(), abi::Float(abi::F32 | abi::F64)) {
offset += Size::from_bytes(4 - (offset.bytes() % 4));
}
data = arg_scalar(cx, scalar2, offset, data);
diff --git a/compiler/rustc_target/src/abi/call/x86_64.rs b/compiler/rustc_target/src/abi/call/x86_64.rs
index f3208fe..fcd7124 100644
--- a/compiler/rustc_target/src/abi/call/x86_64.rs
+++ b/compiler/rustc_target/src/abi/call/x86_64.rs
@@ -51,7 +51,7 @@
Abi::Scalar(scalar) => match scalar.primitive() {
abi::Int(..) | abi::Pointer(_) => Class::Int,
- abi::F16 | abi::F32 | abi::F64 | abi::F128 => Class::Sse,
+ abi::Float(_) => Class::Sse,
},
Abi::Vector { .. } => Class::Sse,
diff --git a/compiler/rustc_target/src/abi/mod.rs b/compiler/rustc_target/src/abi/mod.rs
index 24e49ff..666efd9 100644
--- a/compiler/rustc_target/src/abi/mod.rs
+++ b/compiler/rustc_target/src/abi/mod.rs
@@ -1,4 +1,5 @@
use rustc_data_structures::intern::Interned;
+pub use Float::*;
pub use Integer::*;
pub use Primitive::*;
@@ -11,7 +12,8 @@
pub mod call;
-pub use rustc_abi::*;
+// Explicitly import `Float` to avoid ambiguity with `Primitive::Float`.
+pub use rustc_abi::{Float, *};
impl ToJson for Endian {
fn to_json(&self) -> Json {
@@ -207,7 +209,7 @@
C: HasDataLayout,
{
match self.abi {
- Abi::Scalar(scalar) => matches!(scalar.primitive(), F32 | F64),
+ Abi::Scalar(scalar) => matches!(scalar.primitive(), Float(F32 | F64)),
Abi::Aggregate { .. } => {
if self.fields.count() == 1 && self.fields.offset(0).bytes() == 0 {
self.field(cx, 0).is_single_fp_element(cx)
diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index 84d7930..46c83be 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -7,16 +7,17 @@
//! more 'stuff' here in the future. It does not have a dependency on
//! LLVM.
+// tidy-alphabetical-start
+#![allow(internal_features)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
-#![feature(min_exhaustive_patterns)]
-#![feature(rustdoc_internals)]
#![feature(assert_matches)]
#![feature(iter_intersperse)]
#![feature(let_chains)]
+#![feature(min_exhaustive_patterns)]
#![feature(rustc_attrs)]
-#![feature(step_trait)]
-#![allow(internal_features)]
+#![feature(rustdoc_internals)]
+// tidy-alphabetical-end
use std::path::{Path, PathBuf};
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index cbb248a..8307803 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -603,19 +603,6 @@
self == LinkSelfContainedDefault::False
}
- /// Returns whether the target spec explicitly requests self-contained linking, i.e. not via
- /// inference.
- pub fn is_linker_enabled(self) -> bool {
- match self {
- LinkSelfContainedDefault::True => true,
- LinkSelfContainedDefault::False => false,
- LinkSelfContainedDefault::WithComponents(c) => {
- c.contains(LinkSelfContainedComponents::LINKER)
- }
- _ => false,
- }
- }
-
/// Returns the key to use when serializing the setting to json:
/// - individual components in a `link-self-contained` object value
/// - the other variants as a backwards-compatible `crt-objects-fallback` string
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs
index 5f73432..d601024 100644
--- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/canonical.rs
@@ -19,12 +19,10 @@
use rustc_infer::infer::canonical::CanonicalVarValues;
use rustc_infer::infer::canonical::{CanonicalExt, QueryRegionConstraints};
use rustc_infer::infer::resolve::EagerResolver;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::RegionVariableOrigin;
use rustc_infer::infer::{InferCtxt, InferOk};
use rustc_infer::traits::solve::NestedNormalizationGoals;
use rustc_middle::infer::canonical::Canonical;
-use rustc_middle::infer::unify_key::ConstVariableOrigin;
use rustc_middle::traits::query::NoSolution;
use rustc_middle::traits::solve::{
ExternalConstraintsData, MaybeCause, PredefinedOpaquesData, QueryInput,
@@ -409,6 +407,7 @@
/// This currently assumes that unifying the var values trivially succeeds.
/// Adding any inference constraints which weren't present when originally
/// computing the canonical query can result in bugs.
+#[instrument(level = "debug", skip(infcx, span, param_env))]
pub(in crate::solve) fn instantiate_canonical_state<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
infcx: &InferCtxt<'tcx>,
span: Span,
@@ -424,12 +423,8 @@
ty::GenericArgKind::Lifetime(_) => {
infcx.next_region_var(RegionVariableOrigin::MiscVariable(span)).into()
}
- ty::GenericArgKind::Type(_) => {
- infcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span }).into()
- }
- ty::GenericArgKind::Const(ct) => infcx
- .next_const_var(ct.ty(), ConstVariableOrigin { param_def_id: None, span })
- .into(),
+ ty::GenericArgKind::Type(_) => infcx.next_ty_var(span).into(),
+ ty::GenericArgKind::Const(ct) => infcx.next_const_var(ct.ty(), span).into(),
};
orig_values.push(unconstrained);
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
index 98aac58..9cd1841 100644
--- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
@@ -2,7 +2,6 @@
use rustc_hir::def_id::DefId;
use rustc_infer::infer::at::ToTrace;
use rustc_infer::infer::canonical::CanonicalVarValues;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{
BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, InferOk, TyCtxtInferExt,
};
@@ -11,7 +10,6 @@
use rustc_infer::traits::ObligationCause;
use rustc_macros::{extension, HashStable};
use rustc_middle::infer::canonical::CanonicalVarInfos;
-use rustc_middle::infer::unify_key::ConstVariableOrigin;
use rustc_middle::traits::solve::inspect;
use rustc_middle::traits::solve::{
CanonicalInput, CanonicalResponse, Certainty, PredefinedOpaques, PredefinedOpaquesData,
@@ -600,15 +598,13 @@
}
pub(super) fn next_ty_infer(&mut self) -> Ty<'tcx> {
- let ty = self.infcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span: DUMMY_SP });
+ let ty = self.infcx.next_ty_var(DUMMY_SP);
self.inspect.add_var_value(ty);
ty
}
pub(super) fn next_const_infer(&mut self, ty: Ty<'tcx>) -> ty::Const<'tcx> {
- let ct = self
- .infcx
- .next_const_var(ty, ConstVariableOrigin { param_def_id: None, span: DUMMY_SP });
+ let ct = self.infcx.next_const_var(ty, DUMMY_SP);
self.inspect.add_var_value(ct);
ct
}
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 39d2ec4..4cc041f 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -7,7 +7,7 @@
use rustc_infer::traits::solve::{CandidateSource, GoalSource, MaybeCause};
use rustc_infer::traits::{
self, FulfillmentError, FulfillmentErrorCode, MismatchedProjectionTypes, Obligation,
- ObligationCause, PredicateObligation, SelectionError, TraitEngine,
+ ObligationCause, ObligationCauseCode, PredicateObligation, SelectionError, TraitEngine,
};
use rustc_middle::ty::error::{ExpectedFound, TypeError};
use rustc_middle::ty::{self, TyCtxt};
@@ -203,39 +203,35 @@
let code = match obligation.predicate.kind().skip_binder() {
ty::PredicateKind::Clause(ty::ClauseKind::Projection(_)) => {
- FulfillmentErrorCode::ProjectionError(
+ FulfillmentErrorCode::Project(
// FIXME: This could be a `Sorts` if the term is a type
MismatchedProjectionTypes { err: TypeError::Mismatch },
)
}
ty::PredicateKind::NormalizesTo(..) => {
- FulfillmentErrorCode::ProjectionError(MismatchedProjectionTypes {
- err: TypeError::Mismatch,
- })
+ FulfillmentErrorCode::Project(MismatchedProjectionTypes { err: TypeError::Mismatch })
}
ty::PredicateKind::AliasRelate(_, _, _) => {
- FulfillmentErrorCode::ProjectionError(MismatchedProjectionTypes {
- err: TypeError::Mismatch,
- })
+ FulfillmentErrorCode::Project(MismatchedProjectionTypes { err: TypeError::Mismatch })
}
ty::PredicateKind::Subtype(pred) => {
let (a, b) = infcx.enter_forall_and_leak_universe(
obligation.predicate.kind().rebind((pred.a, pred.b)),
);
let expected_found = ExpectedFound::new(true, a, b);
- FulfillmentErrorCode::SubtypeError(expected_found, TypeError::Sorts(expected_found))
+ FulfillmentErrorCode::Subtype(expected_found, TypeError::Sorts(expected_found))
}
ty::PredicateKind::Coerce(pred) => {
let (a, b) = infcx.enter_forall_and_leak_universe(
obligation.predicate.kind().rebind((pred.a, pred.b)),
);
let expected_found = ExpectedFound::new(false, a, b);
- FulfillmentErrorCode::SubtypeError(expected_found, TypeError::Sorts(expected_found))
+ FulfillmentErrorCode::Subtype(expected_found, TypeError::Sorts(expected_found))
}
ty::PredicateKind::Clause(_)
| ty::PredicateKind::ObjectSafe(_)
| ty::PredicateKind::Ambiguous => {
- FulfillmentErrorCode::SelectionError(SelectionError::Unimplemented)
+ FulfillmentErrorCode::Select(SelectionError::Unimplemented)
}
ty::PredicateKind::ConstEquate(..) => {
bug!("unexpected goal: {obligation:?}")
@@ -429,7 +425,7 @@
tcx.predicates_of(impl_def_id).instantiate_identity(tcx).iter().nth(idx)
{
cause = cause.derived_cause(parent_trait_pred, |derived| {
- traits::ImplDerivedObligation(Box::new(traits::ImplDerivedObligationCause {
+ ObligationCauseCode::ImplDerived(Box::new(traits::ImplDerivedCause {
derived,
impl_or_alias_def_id: impl_def_id,
impl_def_predicate_index: Some(idx),
@@ -439,7 +435,7 @@
}
}
ProbeKind::TraitCandidate { source: CandidateSource::BuiltinImpl(..), result: _ } => {
- cause = cause.derived_cause(parent_trait_pred, traits::BuiltinDerivedObligation);
+ cause = cause.derived_cause(parent_trait_pred, ObligationCauseCode::BuiltinDerived);
}
_ => {}
};
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index fa4323a..fd36b7f 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -12,10 +12,8 @@
use rustc_ast_ir::try_visit;
use rustc_ast_ir::visit::VisitorResult;
use rustc_infer::infer::resolve::EagerResolver;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, InferOk};
use rustc_macros::extension;
-use rustc_middle::infer::unify_key::ConstVariableOrigin;
use rustc_middle::traits::query::NoSolution;
use rustc_middle::traits::solve::{inspect, QueryResult};
use rustc_middle::traits::solve::{Certainty, Goal};
@@ -146,6 +144,11 @@
/// inference constraints, and optionally the args of an impl if this candidate
/// came from a `CandidateSource::Impl`. This function modifies the state of the
/// `infcx`.
+ #[instrument(
+ level = "debug",
+ skip_all,
+ fields(goal = ?self.goal.goal, nested_goals = ?self.nested_goals)
+ )]
pub fn instantiate_nested_goals_and_opt_impl_args(
&self,
span: Span,
@@ -201,22 +204,28 @@
.map(|(source, goal)| match goal.predicate.kind().no_bound_vars() {
Some(ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })) => {
let unconstrained_term = match term.unpack() {
- ty::TermKind::Ty(_) => infcx
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span })
- .into(),
- ty::TermKind::Const(ct) => infcx
- .next_const_var(
- ct.ty(),
- ConstVariableOrigin { param_def_id: None, span },
- )
- .into(),
+ ty::TermKind::Ty(_) => infcx.next_ty_var(span).into(),
+ ty::TermKind::Const(ct) => infcx.next_const_var(ct.ty(), span).into(),
};
let goal =
goal.with(infcx.tcx, ty::NormalizesTo { alias, term: unconstrained_term });
- let proof_tree = EvalCtxt::enter_root(infcx, GenerateProofTree::Yes, |ecx| {
- ecx.evaluate_goal_raw(GoalEvaluationKind::Root, GoalSource::Misc, goal)
- })
- .1;
+ // We have to use a `probe` here as evaluating a `NormalizesTo` can constrain the
+ // expected term. This means that candidates which only fail due to nested goals
+ // and which normalize to a different term then the final result could ICE: when
+ // building their proof tree, the expected term was unconstrained, but when
+ // instantiating the candidate it is already constrained to the result of another
+ // candidate.
+ let proof_tree = infcx
+ .probe(|_| {
+ EvalCtxt::enter_root(infcx, GenerateProofTree::Yes, |ecx| {
+ ecx.evaluate_goal_raw(
+ GoalEvaluationKind::Root,
+ GoalSource::Misc,
+ goal,
+ )
+ })
+ })
+ .1;
InspectGoal::new(
infcx,
self.goal.depth + 1,
@@ -225,13 +234,17 @@
source,
)
}
- _ => InspectGoal::new(
- infcx,
- self.goal.depth + 1,
- infcx.evaluate_root_goal(goal, GenerateProofTree::Yes).1.unwrap(),
- None,
- source,
- ),
+ _ => {
+ // We're using a probe here as evaluating a goal could constrain
+ // inference variables by choosing one candidate. If we then recurse
+ // into another candidate who ends up with different inference
+ // constraints, we get an ICE if we already applied the constraints
+ // from the chosen candidate.
+ let proof_tree = infcx
+ .probe(|_| infcx.evaluate_root_goal(goal, GenerateProofTree::Yes).1)
+ .unwrap();
+ InspectGoal::new(infcx, self.goal.depth + 1, proof_tree, None, source)
+ }
})
.collect();
diff --git a/compiler/rustc_trait_selection/src/solve/normalize.rs b/compiler/rustc_trait_selection/src/solve/normalize.rs
index 65ef465..cd1add9 100644
--- a/compiler/rustc_trait_selection/src/solve/normalize.rs
+++ b/compiler/rustc_trait_selection/src/solve/normalize.rs
@@ -3,11 +3,9 @@
use crate::traits::{BoundVarReplacer, PlaceholderReplacer};
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_infer::infer::at::At;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::InferCtxt;
use rustc_infer::traits::TraitEngineExt;
use rustc_infer::traits::{FulfillmentError, Obligation, TraitEngine};
-use rustc_middle::infer::unify_key::ConstVariableOrigin;
use rustc_middle::traits::ObligationCause;
use rustc_middle::ty::{self, AliasTy, Ty, TyCtxt, UniverseIndex};
use rustc_middle::ty::{FallibleTypeFolder, TypeFolder, TypeSuperFoldable};
@@ -74,8 +72,7 @@
self.depth += 1;
- let new_infer_ty =
- infcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span: self.at.cause.span });
+ let new_infer_ty = infcx.next_ty_var(self.at.cause.span);
let obligation = Obligation::new(
tcx,
self.at.cause.clone(),
@@ -120,10 +117,7 @@
self.depth += 1;
- let new_infer_ct = infcx.next_const_var(
- ty,
- ConstVariableOrigin { param_def_id: None, span: self.at.cause.span },
- );
+ let new_infer_ct = infcx.next_const_var(ty, self.at.cause.span);
let obligation = Obligation::new(
tcx,
self.at.cause.clone(),
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs
index 9e5701f..4b5b1d7 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/infer_ctxt_ext.rs
@@ -1,4 +1,3 @@
-use crate::infer::type_variable::TypeVariableOrigin;
use crate::infer::InferCtxt;
use crate::traits::{Obligation, ObligationCause, ObligationCtxt};
use rustc_errors::{codes::*, pluralize, struct_span_code_err, Applicability, Diag};
@@ -218,8 +217,7 @@
let Some(trait_def_id) = trait_def_id else { continue };
// Make a fresh inference variable so we can determine what the generic parameters
// of the trait are.
- let var =
- self.next_ty_var(TypeVariableOrigin { span: DUMMY_SP, param_def_id: None });
+ let var = self.next_ty_var(DUMMY_SP);
// FIXME(effects)
let trait_ref = ty::TraitRef::new(self.tcx, trait_def_id, [ty.skip_binder(), var]);
let obligation = Obligation::new(
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
index f1eb5b7..c46cee3 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
@@ -127,9 +127,9 @@
flags.push((sym::ItemContext, enclosure));
match obligation.cause.code() {
- ObligationCauseCode::BuiltinDerivedObligation(..)
- | ObligationCauseCode::ImplDerivedObligation(..)
- | ObligationCauseCode::WellFormedDerivedObligation(..) => {}
+ ObligationCauseCode::BuiltinDerived(..)
+ | ObligationCauseCode::ImplDerived(..)
+ | ObligationCauseCode::WellFormedDerived(..) => {}
_ => {
// this is a "direct", user-specified, rather than derived,
// obligation.
@@ -165,7 +165,7 @@
));
}
- for param in generics.params.iter() {
+ for param in generics.own_params.iter() {
let value = match param.kind {
GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
args[param.index as usize].to_string()
@@ -350,12 +350,14 @@
option_name: &'static str,
) {
if let (Some(new_item), Some(old_item)) = (new, old) {
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- new_item,
- IgnoredDiagnosticOption { span: new_item, prev_span: old_item, option_name },
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ new_item,
+ IgnoredDiagnosticOption { span: new_item, prev_span: old_item, option_name },
+ );
+ }
}
}
}
@@ -639,30 +641,38 @@
AttrArgs::Eq(span, AttrArgsEq::Hir(expr)) => span.to(expr.span),
};
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- report_span,
- MalformedOnUnimplementedAttrLint::new(report_span),
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ report_span,
+ MalformedOnUnimplementedAttrLint::new(report_span),
+ );
+ }
Ok(None)
}
} else if is_diagnostic_namespace_variant {
match &attr.kind {
AttrKind::Normal(p) if !matches!(p.item.args, AttrArgs::Empty) => {
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- attr.span,
- MalformedOnUnimplementedAttrLint::new(attr.span),
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ attr.span,
+ MalformedOnUnimplementedAttrLint::new(attr.span),
+ );
+ }
}
- _ => tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- attr.span,
- MissingOptionsForOnUnimplementedAttr,
- ),
+ _ => {
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ attr.span,
+ MissingOptionsForOnUnimplementedAttr,
+ )
+ }
+ }
};
Ok(None)
@@ -791,12 +801,14 @@
|| format_spec.precision_span.is_some()
|| format_spec.fill_span.is_some())
{
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- self.span,
- InvalidFormatSpecifier,
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ self.span,
+ InvalidFormatSpecifier,
+ );
+ }
}
match a.position {
Position::ArgumentNamed(s) => {
@@ -809,18 +821,20 @@
()
}
// So is `{A}` if A is a type parameter
- s if generics.params.iter().any(|param| param.name == s) => (),
+ s if generics.own_params.iter().any(|param| param.name == s) => (),
s => {
if self.is_diagnostic_namespace_variant {
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- self.span,
- UnknownFormatParameterForOnUnimplementedAttr {
- argument_name: s,
- trait_name,
- },
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ self.span,
+ UnknownFormatParameterForOnUnimplementedAttr {
+ argument_name: s,
+ trait_name,
+ },
+ );
+ }
} else {
result = Err(struct_span_code_err!(
tcx.dcx(),
@@ -842,12 +856,14 @@
// `{:1}` and `{}` are not to be used
Position::ArgumentIs(..) | Position::ArgumentImplicitlyIs(_) => {
if self.is_diagnostic_namespace_variant {
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- self.span,
- DisallowedPositionalArgument,
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ self.span,
+ DisallowedPositionalArgument,
+ );
+ }
} else {
let reported = struct_span_code_err!(
tcx.dcx(),
@@ -870,12 +886,14 @@
// so that users are aware that something is not correct
for e in parser.errors {
if self.is_diagnostic_namespace_variant {
- tcx.emit_node_span_lint(
- UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
- tcx.local_def_id_to_hir_id(item_def_id.expect_local()),
- self.span,
- WrappedParserError { description: e.description, label: e.label },
- );
+ if let Some(item_def_id) = item_def_id.as_local() {
+ tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ tcx.local_def_id_to_hir_id(item_def_id),
+ self.span,
+ WrappedParserError { description: e.description, label: e.label },
+ );
+ }
} else {
let reported =
struct_span_code_err!(tcx.dcx(), self.span, E0231, "{}", e.description,).emit();
@@ -897,7 +915,7 @@
let trait_str = tcx.def_path_str(trait_ref.def_id);
let generics = tcx.generics_of(trait_ref.def_id);
let generic_map = generics
- .params
+ .own_params
.iter()
.filter_map(|param| {
let value = match param.kind {
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index 3d2574a..3defc03 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -7,7 +7,7 @@
use crate::errors;
use crate::infer::InferCtxt;
-use crate::traits::{ImplDerivedObligationCause, NormalizeExt, ObligationCtxt};
+use crate::traits::{ImplDerivedCause, NormalizeExt, ObligationCtxt};
use hir::def::CtorOf;
use rustc_data_structures::fx::FxHashSet;
@@ -24,7 +24,6 @@
use rustc_hir::lang_items::LangItem;
use rustc_hir::{CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, HirId, Node};
use rustc_infer::infer::error_reporting::TypeErrCtxt;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk};
use rustc_macros::extension;
use rustc_middle::hir::map;
@@ -456,8 +455,7 @@
trait_pred: ty::PolyTraitPredicate<'tcx>,
) -> bool {
let mut code = obligation.cause.code();
- if let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, call_hir_id, .. } =
- code
+ if let ObligationCauseCode::FunctionArg { arg_hir_id, call_hir_id, .. } = code
&& let Some(typeck_results) = &self.typeck_results
&& let hir::Node::Expr(expr) = self.tcx.hir_node(*arg_hir_id)
&& let Some(arg_ty) = typeck_results.expr_ty_adjusted_opt(expr)
@@ -847,7 +845,7 @@
.collect::<Vec<_>>()
.join(", ");
- if matches!(obligation.cause.code(), ObligationCauseCode::FunctionArgumentObligation { .. })
+ if matches!(obligation.cause.code(), ObligationCauseCode::FunctionArg { .. })
&& obligation.cause.span.can_be_used_for_suggestions()
{
// When the obligation error has been ensured to have been caused by
@@ -981,8 +979,7 @@
};
let ty::Ref(_, inner_ty, hir::Mutability::Not) = ty.kind() else { return false };
let ty::Param(param) = inner_ty.kind() else { return false };
- let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
- obligation.cause.code()
+ let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = obligation.cause.code()
else {
return false;
};
@@ -1205,9 +1202,9 @@
let span = obligation.cause.span;
let code = match obligation.cause.code() {
- ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => parent_code,
- c @ ObligationCauseCode::ItemObligation(_)
- | c @ ObligationCauseCode::ExprItemObligation(..) => c,
+ ObligationCauseCode::FunctionArg { parent_code, .. } => parent_code,
+ c @ ObligationCauseCode::WhereClause(_)
+ | c @ ObligationCauseCode::WhereClauseInExpr(..) => c,
c if matches!(
span.ctxt().outer_expn_data().kind,
ExpnKind::Desugaring(DesugaringKind::ForLoop)
@@ -1263,8 +1260,8 @@
let mut_ref_self_ty_satisfies_pred = mk_result(trait_pred_and_mut_ref);
let (ref_inner_ty_satisfies_pred, ref_inner_ty_mut) =
- if let ObligationCauseCode::ItemObligation(_)
- | ObligationCauseCode::ExprItemObligation(..) = obligation.cause.code()
+ if let ObligationCauseCode::WhereClause(_)
+ | ObligationCauseCode::WhereClauseInExpr(..) = obligation.cause.code()
&& let ty::Ref(_, ty, mutability) = old_pred.self_ty().skip_binder().kind()
{
(
@@ -1402,12 +1399,12 @@
return false;
};
- if let ObligationCauseCode::ImplDerivedObligation(cause) = &*code {
+ if let ObligationCauseCode::ImplDerived(cause) = &*code {
try_borrowing(cause.derived.parent_trait_pred, &[])
- } else if let ObligationCauseCode::BindingObligation(_, _)
- | ObligationCauseCode::ItemObligation(_)
- | ObligationCauseCode::ExprItemObligation(..)
- | ObligationCauseCode::ExprBindingObligation(..) = code
+ } else if let ObligationCauseCode::SpannedWhereClause(_, _)
+ | ObligationCauseCode::WhereClause(_)
+ | ObligationCauseCode::WhereClauseInExpr(..)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(..) = code
{
try_borrowing(poly_trait_pred, &never_suggest_borrow)
} else {
@@ -1645,10 +1642,8 @@
err: &mut Diag<'_>,
trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
- let points_at_arg = matches!(
- obligation.cause.code(),
- ObligationCauseCode::FunctionArgumentObligation { .. },
- );
+ let points_at_arg =
+ matches!(obligation.cause.code(), ObligationCauseCode::FunctionArg { .. },);
let span = obligation.cause.span;
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
@@ -1893,8 +1888,7 @@
ty::Tuple(inputs) if infcx.tcx.is_fn_trait(trait_ref.def_id) => {
infcx.tcx.mk_fn_sig(
*inputs,
- infcx
- .next_ty_var(TypeVariableOrigin { span: DUMMY_SP, param_def_id: None }),
+ infcx.next_ty_var(DUMMY_SP),
false,
hir::Unsafety::Normal,
abi::Abi::Rust,
@@ -1902,7 +1896,7 @@
}
_ => infcx.tcx.mk_fn_sig(
[inputs],
- infcx.next_ty_var(TypeVariableOrigin { span: DUMMY_SP, param_def_id: None }),
+ infcx.next_ty_var(DUMMY_SP),
false,
hir::Unsafety::Normal,
abi::Abi::Rust,
@@ -1955,7 +1949,7 @@
found: Ty<'tcx>,
param_env: ty::ParamEnv<'tcx>,
) {
- let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } = cause else {
+ let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = cause else {
return;
};
let ty::FnPtr(expected) = expected.kind() else {
@@ -2106,10 +2100,10 @@
cause: &ObligationCauseCode<'tcx>,
err: &mut Diag<'tcx>,
) {
- // First, look for an `ExprBindingObligation`, which means we can get
+ // First, look for an `SpannedWhereClauseInExpr`, which means we can get
// the uninstantiated predicate list of the called function. And check
// that the predicate that we failed to satisfy is a `Fn`-like trait.
- if let ObligationCauseCode::ExprBindingObligation(def_id, _, _, idx) = cause
+ if let ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, _, idx) = cause
&& let predicates = self.tcx.predicates_of(def_id).instantiate_identity(self.tcx)
&& let Some(pred) = predicates.predicates.get(*idx)
&& let ty::ClauseKind::Trait(trait_pred) = pred.kind().skip_binder()
@@ -2263,10 +2257,10 @@
while let Some(code) = next_code {
debug!(?code);
match code {
- ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => {
+ ObligationCauseCode::FunctionArg { parent_code, .. } => {
next_code = Some(parent_code);
}
- ObligationCauseCode::ImplDerivedObligation(cause) => {
+ ObligationCauseCode::ImplDerived(cause) => {
let ty = cause.derived.parent_trait_pred.skip_binder().self_ty();
debug!(
parent_trait_ref = ?cause.derived.parent_trait_pred,
@@ -2295,8 +2289,8 @@
next_code = Some(&cause.derived.parent_code);
}
- ObligationCauseCode::WellFormedDerivedObligation(derived_obligation)
- | ObligationCauseCode::BuiltinDerivedObligation(derived_obligation) => {
+ ObligationCauseCode::WellFormedDerived(derived_obligation)
+ | ObligationCauseCode::BuiltinDerived(derived_obligation) => {
let ty = derived_obligation.parent_trait_pred.skip_binder().self_ty();
debug!(
parent_trait_ref = ?derived_obligation.parent_trait_pred,
@@ -2721,7 +2715,7 @@
| ObligationCauseCode::MethodReceiver
| ObligationCauseCode::ReturnNoExpression
| ObligationCauseCode::UnifyReceiver(..)
- | ObligationCauseCode::MiscObligation
+ | ObligationCauseCode::Misc
| ObligationCauseCode::WellFormed(..)
| ObligationCauseCode::MatchImpl(..)
| ObligationCauseCode::ReturnValue(_)
@@ -2750,13 +2744,12 @@
ObligationCauseCode::TupleElem => {
err.note("only the last element of a tuple may have a dynamically sized type");
}
- ObligationCauseCode::ItemObligation(_)
- | ObligationCauseCode::ExprItemObligation(..) => {
+ ObligationCauseCode::WhereClause(_) | ObligationCauseCode::WhereClauseInExpr(..) => {
// We hold the `DefId` of the item introducing the obligation, but displaying it
// doesn't add user usable information. It always point at an associated item.
}
- ObligationCauseCode::BindingObligation(item_def_id, span)
- | ObligationCauseCode::ExprBindingObligation(item_def_id, span, ..) => {
+ ObligationCauseCode::SpannedWhereClause(item_def_id, span)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(item_def_id, span, ..) => {
let item_name = tcx.def_path_str(item_def_id);
let short_item_name = with_forced_trimmed_paths!(tcx.def_path_str(item_def_id));
let mut multispan = MultiSpan::from(span);
@@ -2799,7 +2792,7 @@
// Check if this is an implicit bound, even in foreign crates.
if tcx
.generics_of(item_def_id)
- .params
+ .own_params
.iter()
.any(|param| tcx.def_span(param.def_id) == span)
{
@@ -3177,7 +3170,7 @@
ObligationCauseCode::SharedStatic => {
err.note("shared static variables must have a type that implements `Sync`");
}
- ObligationCauseCode::BuiltinDerivedObligation(ref data) => {
+ ObligationCauseCode::BuiltinDerived(ref data) => {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let ty = parent_trait_ref.skip_binder().self_ty();
if parent_trait_ref.references_error() {
@@ -3192,8 +3185,7 @@
let is_upvar_tys_infer_tuple = if !matches!(ty.kind(), ty::Tuple(..)) {
false
} else {
- if let ObligationCauseCode::BuiltinDerivedObligation(data) = &*data.parent_code
- {
+ if let ObligationCauseCode::BuiltinDerived(data) = &*data.parent_code {
let parent_trait_ref =
self.resolve_vars_if_possible(data.parent_trait_pred);
let nested_ty = parent_trait_ref.skip_binder().self_ty();
@@ -3299,7 +3291,7 @@
});
}
}
- ObligationCauseCode::ImplDerivedObligation(ref data) => {
+ ObligationCauseCode::ImplDerived(ref data) => {
let mut parent_trait_pred =
self.resolve_vars_if_possible(data.derived.parent_trait_pred);
let parent_def_id = parent_trait_pred.def_id();
@@ -3369,9 +3361,7 @@
if is_auto_trait {
// We don't want to point at the ADT saying "required because it appears within
// the type `X`", like we would otherwise do in test `supertrait-auto-trait.rs`.
- while let ObligationCauseCode::BuiltinDerivedObligation(derived) =
- &*data.parent_code
- {
+ while let ObligationCauseCode::BuiltinDerived(derived) = &*data.parent_code {
let child_trait_ref =
self.resolve_vars_if_possible(derived.parent_trait_pred);
let child_def_id = child_trait_ref.def_id();
@@ -3383,7 +3373,7 @@
parent_trait_pred = child_trait_ref;
}
}
- while let ObligationCauseCode::ImplDerivedObligation(child) = &*data.parent_code {
+ while let ObligationCauseCode::ImplDerived(child) = &*data.parent_code {
// Skip redundant recursive obligation notes. See `ui/issue-20413.rs`.
let child_trait_pred =
self.resolve_vars_if_possible(child.derived.parent_trait_pred);
@@ -3424,7 +3414,7 @@
)
});
}
- ObligationCauseCode::WellFormedDerivedObligation(ref data) => {
+ ObligationCauseCode::WellFormedDerived(ref data) => {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let parent_predicate = parent_trait_ref;
// #74711: avoid a stack overflow
@@ -3460,11 +3450,8 @@
format!("required by a bound on the type alias `{}`", tcx.item_name(def_id)),
);
}
- ObligationCauseCode::FunctionArgumentObligation {
- arg_hir_id,
- call_hir_id,
- ref parent_code,
- ..
+ ObligationCauseCode::FunctionArg {
+ arg_hir_id, call_hir_id, ref parent_code, ..
} => {
self.note_function_argument_obligation(
body_id,
@@ -3487,7 +3474,7 @@
)
});
}
- ObligationCauseCode::CompareImplItemObligation { trait_item_def_id, kind, .. } => {
+ ObligationCauseCode::CompareImplItem { trait_item_def_id, kind, .. } => {
let item_name = tcx.item_name(trait_item_def_id);
let msg = format!(
"the requirement `{predicate}` appears on the `impl`'s {kind} \
@@ -3696,7 +3683,7 @@
err: &mut Diag<'_>,
trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
- if let ObligationCauseCode::ImplDerivedObligation(_) = obligation.cause.code()
+ if let ObligationCauseCode::ImplDerived(_) = obligation.cause.code()
&& self
.tcx
.is_diagnostic_item(sym::SliceIndex, trait_pred.skip_binder().trait_ref.def_id)
@@ -3813,7 +3800,7 @@
// to an associated type (as seen from `trait_pred`) in the predicate. Like in
// trait_pred `S: Sum<<Self as Iterator>::Item>` and predicate `i32: Sum<&()>`
let mut type_diffs = vec![];
- if let ObligationCauseCode::ExprBindingObligation(def_id, _, _, idx) = parent_code
+ if let ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, _, idx) = parent_code
&& let Some(node_args) = typeck_results.node_args_opt(call_hir_id)
&& let where_clauses =
self.tcx.predicates_of(def_id).instantiate(self.tcx, node_args)
@@ -4263,7 +4250,6 @@
continue;
};
- let origin = TypeVariableOrigin { param_def_id: None, span };
// Make `Self` be equivalent to the type of the call chain
// expression we're looking at now, so that we can tell what
// for example `Iterator::Item` is at this point in the chain.
@@ -4277,7 +4263,7 @@
// This will hold the resolved type of the associated type, if the
// current expression implements the trait that associated type is
// in. For example, this would be what `Iterator::Item` is here.
- let ty = self.infcx.next_ty_var(origin);
+ let ty = self.infcx.next_ty_var(span);
// This corresponds to `<ExprTy as Iterator>::Item = _`.
let projection = ty::Binder::dummy(ty::PredicateKind::Clause(
ty::ClauseKind::Projection(ty::ProjectionPredicate {
@@ -4323,8 +4309,8 @@
) {
// We can only suggest the slice coersion for function and binary operation arguments,
// since the suggestion would make no sense in turbofish or call
- let (ObligationCauseCode::BinOp { .. }
- | ObligationCauseCode::FunctionArgumentObligation { .. }) = obligation.cause.code()
+ let (ObligationCauseCode::BinOp { .. } | ObligationCauseCode::FunctionArg { .. }) =
+ obligation.cause.code()
else {
return;
};
@@ -4410,7 +4396,7 @@
return;
}
- if let ObligationCauseCode::FunctionArgumentObligation {
+ if let ObligationCauseCode::FunctionArg {
call_hir_id,
arg_hir_id,
parent_code: _,
@@ -4970,7 +4956,7 @@
trait_name: &str,
predicate: ty::Predicate<'_>,
generics: &hir::Generics<'_>,
- data: &ImplDerivedObligationCause<'_>,
+ data: &ImplDerivedCause<'_>,
) {
let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() else {
return;
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
index e50cb2a..de8ec17 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
@@ -6,7 +6,6 @@
AsyncClosureNotFn, ClosureFnMutLabel, ClosureFnOnceLabel, ClosureKindMismatch,
};
use crate::infer::error_reporting::{TyCategory, TypeAnnotationNeeded as ErrorCode};
-use crate::infer::type_variable::TypeVariableOrigin;
use crate::infer::InferCtxtExt as _;
use crate::infer::{self, InferCtxt};
use crate::traits::error_reporting::infer_ctxt_ext::InferCtxtExt;
@@ -392,7 +391,7 @@
}
}
- if let ObligationCauseCode::CompareImplItemObligation {
+ if let ObligationCauseCode::CompareImplItem {
impl_item_def_id,
trait_item_def_id,
kind: _,
@@ -1018,7 +1017,7 @@
if let Some((_, Some(parent))) = obligation.cause.code().parent() {
// If we have a derived obligation, then the parent will be a `AsyncFn*` goal.
trait_ref = parent.to_poly_trait_ref();
- } else if let &ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
+ } else if let &ObligationCauseCode::FunctionArg { arg_hir_id, .. } =
obligation.cause.code()
&& let Some(typeck_results) = &self.typeck_results
&& let ty::Closure(closure_def_id, _) | ty::CoroutineClosure(closure_def_id, _) =
@@ -1105,8 +1104,7 @@
&self,
obligation: &PredicateObligation<'tcx>,
) -> Result<(), ErrorGuaranteed> {
- if let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
- obligation.cause.code()
+ if let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = obligation.cause.code()
&& let Node::Expr(arg) = self.tcx.hir_node(*arg_hir_id)
&& let arg = arg.peel_borrows()
&& let hir::ExprKind::Path(hir::QPath::Resolved(
@@ -1505,13 +1503,12 @@
}
match error.code {
- FulfillmentErrorCode::SelectionError(ref selection_error) => self
- .report_selection_error(
- error.obligation.clone(),
- &error.root_obligation,
- selection_error,
- ),
- FulfillmentErrorCode::ProjectionError(ref e) => {
+ FulfillmentErrorCode::Select(ref selection_error) => self.report_selection_error(
+ error.obligation.clone(),
+ &error.root_obligation,
+ selection_error,
+ ),
+ FulfillmentErrorCode::Project(ref e) => {
self.report_projection_error(&error.obligation, e)
}
FulfillmentErrorCode::Ambiguity { overflow: None } => {
@@ -1520,7 +1517,7 @@
FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) } => {
self.report_overflow_no_abort(error.obligation.clone(), suggest_increasing_limit)
}
- FulfillmentErrorCode::SubtypeError(ref expected_found, ref err) => self
+ FulfillmentErrorCode::Subtype(ref expected_found, ref err) => self
.report_mismatched_types(
&error.obligation.cause,
expected_found.expected,
@@ -1528,7 +1525,7 @@
*err,
)
.emit(),
- FulfillmentErrorCode::ConstEquateError(ref expected_found, ref err) => {
+ FulfillmentErrorCode::ConstEquate(ref expected_found, ref err) => {
let mut diag = self.report_mismatched_consts(
&error.obligation.cause,
expected_found.expected,
@@ -1536,10 +1533,10 @@
*err,
);
let code = error.obligation.cause.code().peel_derives().peel_match_impls();
- if let ObligationCauseCode::BindingObligation(..)
- | ObligationCauseCode::ItemObligation(..)
- | ObligationCauseCode::ExprBindingObligation(..)
- | ObligationCauseCode::ExprItemObligation(..) = code
+ if let ObligationCauseCode::SpannedWhereClause(..)
+ | ObligationCauseCode::WhereClause(..)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(..)
+ | ObligationCauseCode::WhereClauseInExpr(..) = code
{
self.note_obligation_cause_code(
error.obligation.cause.body_id,
@@ -1613,10 +1610,10 @@
let is_normalized_term_expected = !matches!(
obligation.cause.code().peel_derives(),
- ObligationCauseCode::ItemObligation(_)
- | ObligationCauseCode::BindingObligation(_, _)
- | ObligationCauseCode::ExprItemObligation(..)
- | ObligationCauseCode::ExprBindingObligation(..)
+ ObligationCauseCode::WhereClause(_)
+ | ObligationCauseCode::SpannedWhereClause(_, _)
+ | ObligationCauseCode::WhereClauseInExpr(..)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(..)
| ObligationCauseCode::Coercion { .. }
);
@@ -2213,7 +2210,7 @@
code: &ObligationCauseCode<'tcx>,
) -> Option<(Ty<'tcx>, Option<Span>)> {
match code {
- ObligationCauseCode::BuiltinDerivedObligation(data) => {
+ ObligationCauseCode::BuiltinDerived(data) => {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
match self.get_parent_trait_ref(&data.parent_code) {
Some(t) => Some(t),
@@ -2225,7 +2222,7 @@
}
}
}
- ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => {
+ ObligationCauseCode::FunctionArg { parent_code, .. } => {
self.get_parent_trait_ref(parent_code)
}
_ => None,
@@ -2448,8 +2445,8 @@
}
}
- if let ObligationCauseCode::ItemObligation(def_id)
- | ObligationCauseCode::ExprItemObligation(def_id, ..) = *obligation.cause.code()
+ if let ObligationCauseCode::WhereClause(def_id)
+ | ObligationCauseCode::WhereClauseInExpr(def_id, ..) = *obligation.cause.code()
{
self.suggest_fully_qualified_path(&mut err, def_id, span, trait_ref.def_id());
}
@@ -2826,9 +2823,7 @@
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
if let ty::Param(_) = *ty.kind() {
let infcx = self.infcx;
- *self.var_map.entry(ty).or_insert_with(|| {
- infcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span: DUMMY_SP })
- })
+ *self.var_map.entry(ty).or_insert_with(|| infcx.next_ty_var(DUMMY_SP))
} else {
ty.super_fold_with(self)
}
@@ -2886,8 +2881,8 @@
else {
return;
};
- let (ObligationCauseCode::BindingObligation(item_def_id, span)
- | ObligationCauseCode::ExprBindingObligation(item_def_id, span, ..)) =
+ let (ObligationCauseCode::SpannedWhereClause(item_def_id, span)
+ | ObligationCauseCode::SpannedWhereClauseInExpr(item_def_id, span, ..)) =
*obligation.cause.code().peel_derives()
else {
return;
@@ -3007,7 +3002,7 @@
obligated_types: &mut Vec<Ty<'tcx>>,
cause_code: &ObligationCauseCode<'tcx>,
) -> bool {
- if let ObligationCauseCode::BuiltinDerivedObligation(ref data) = cause_code {
+ if let ObligationCauseCode::BuiltinDerived(ref data) = cause_code {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let self_ty = parent_trait_ref.skip_binder().self_ty();
if obligated_types.iter().any(|ot| ot == &self_ty) {
@@ -3184,8 +3179,8 @@
ObligationCauseCode::RustCall => {
err.primary_message("functions with the \"rust-call\" ABI must take a single non-self tuple argument");
}
- ObligationCauseCode::BindingObligation(def_id, _)
- | ObligationCauseCode::ItemObligation(def_id)
+ ObligationCauseCode::SpannedWhereClause(def_id, _)
+ | ObligationCauseCode::WhereClause(def_id)
if self.tcx.is_fn_trait(*def_id) =>
{
err.code(E0059);
@@ -3443,8 +3438,6 @@
self.dcx().try_steal_replace_and_emit_err(self.tcx.def_span(def_id), StashKey::Cycle, err)
}
- // FIXME(@lcnr): This function could be changed to trait `TraitRef` directly
- // instead of using a `Binder`.
fn report_signature_mismatch_error(
&self,
obligation: &PredicateObligation<'tcx>,
@@ -3576,7 +3569,7 @@
match self.tcx.sess.source_map().span_to_snippet(const_span) {
Ok(snippet) => {
let code = format!("[(); {snippet}{cast}]:");
- let def_id = if let ObligationCauseCode::CompareImplItemObligation {
+ let def_id = if let ObligationCauseCode::CompareImplItem {
trait_item_def_id,
..
} = obligation.cause.code()
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 1f10cb7..e3497c6 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -411,7 +411,7 @@
ty::PredicateKind::ObjectSafe(trait_def_id) => {
if !self.selcx.tcx().check_is_object_safe(trait_def_id) {
- ProcessResult::Error(FulfillmentErrorCode::SelectionError(Unimplemented))
+ ProcessResult::Error(FulfillmentErrorCode::Select(Unimplemented))
} else {
ProcessResult::Changed(vec![])
}
@@ -435,7 +435,7 @@
ty,
) {
Ok(inf_ok) => ProcessResult::Changed(mk_pending(inf_ok.into_obligations())),
- Err(_) => ProcessResult::Error(FulfillmentErrorCode::SelectionError(
+ Err(_) => ProcessResult::Error(FulfillmentErrorCode::Select(
SelectionError::Unimplemented,
)),
}
@@ -493,10 +493,7 @@
Ok(Err(err)) => {
let expected_found =
ExpectedFound::new(subtype.a_is_expected, subtype.a, subtype.b);
- ProcessResult::Error(FulfillmentErrorCode::SubtypeError(
- expected_found,
- err,
- ))
+ ProcessResult::Error(FulfillmentErrorCode::Subtype(expected_found, err))
}
}
}
@@ -516,10 +513,7 @@
Ok(Ok(ok)) => ProcessResult::Changed(mk_pending(ok.obligations)),
Ok(Err(err)) => {
let expected_found = ExpectedFound::new(false, coerce.a, coerce.b);
- ProcessResult::Error(FulfillmentErrorCode::SubtypeError(
- expected_found,
- err,
- ))
+ ProcessResult::Error(FulfillmentErrorCode::Subtype(expected_found, err))
}
}
}
@@ -542,7 +536,7 @@
Err(
e @ NotConstEvaluatable::MentionsParam
| e @ NotConstEvaluatable::Error(_),
- ) => ProcessResult::Error(FulfillmentErrorCode::SelectionError(
+ ) => ProcessResult::Error(FulfillmentErrorCode::Select(
SelectionError::NotConstEvaluatable(e),
)),
}
@@ -638,7 +632,7 @@
ProcessResult::Changed(mk_pending(inf_ok.into_obligations()))
}
Err(err) => {
- ProcessResult::Error(FulfillmentErrorCode::ConstEquateError(
+ ProcessResult::Error(FulfillmentErrorCode::ConstEquate(
ExpectedFound::new(true, c1, c2),
err,
))
@@ -646,13 +640,11 @@
}
}
(Err(ErrorHandled::Reported(reported, _)), _)
- | (_, Err(ErrorHandled::Reported(reported, _))) => {
- ProcessResult::Error(FulfillmentErrorCode::SelectionError(
- SelectionError::NotConstEvaluatable(NotConstEvaluatable::Error(
- reported.into(),
- )),
- ))
- }
+ | (_, Err(ErrorHandled::Reported(reported, _))) => ProcessResult::Error(
+ FulfillmentErrorCode::Select(SelectionError::NotConstEvaluatable(
+ NotConstEvaluatable::Error(reported.into()),
+ )),
+ ),
(Err(ErrorHandled::TooGeneric(_)), _)
| (_, Err(ErrorHandled::TooGeneric(_))) => {
if c1.has_non_region_infer() || c2.has_non_region_infer() {
@@ -660,7 +652,7 @@
} else {
// Two different constants using generic parameters ~> error.
let expected_found = ExpectedFound::new(true, c1, c2);
- ProcessResult::Error(FulfillmentErrorCode::ConstEquateError(
+ ProcessResult::Error(FulfillmentErrorCode::ConstEquate(
expected_found,
TypeError::ConstMismatch(expected_found),
))
@@ -741,7 +733,7 @@
Err(selection_err) => {
debug!("selecting trait at depth {} yielded Err", obligation.recursion_depth);
- ProcessResult::Error(FulfillmentErrorCode::SelectionError(selection_err))
+ ProcessResult::Error(FulfillmentErrorCode::Select(selection_err))
}
}
}
@@ -793,7 +785,7 @@
project_obligation.with(tcx, project_obligation.predicate),
])),
ProjectAndUnifyResult::MismatchedProjectionTypes(e) => {
- ProcessResult::Error(FulfillmentErrorCode::ProjectionError(e))
+ ProcessResult::Error(FulfillmentErrorCode::Project(e))
}
}
}
diff --git a/compiler/rustc_trait_selection/src/traits/misc.rs b/compiler/rustc_trait_selection/src/traits/misc.rs
index 93f9c23..da2b004 100644
--- a/compiler/rustc_trait_selection/src/traits/misc.rs
+++ b/compiler/rustc_trait_selection/src/traits/misc.rs
@@ -10,7 +10,7 @@
use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
use rustc_infer::traits::query::NoSolution;
use rustc_infer::{infer::outlives::env::OutlivesEnvironment, traits::FulfillmentError};
-use rustc_middle::ty::{self, AdtDef, GenericArg, List, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt};
use rustc_span::DUMMY_SP;
use super::outlives_bounds::InferCtxtExt;
@@ -129,7 +129,7 @@
param_env: ty::ParamEnv<'tcx>,
self_type: Ty<'tcx>,
adt: AdtDef<'tcx>,
- args: &'tcx List<GenericArg<'tcx>>,
+ args: ty::GenericArgsRef<'tcx>,
parent_cause: ObligationCause<'tcx>,
lang_item: LangItem,
) -> Result<(), Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>> {
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
index 0e15dd2..5cb61df 100644
--- a/compiler/rustc_trait_selection/src/traits/object_safety.rs
+++ b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -397,7 +397,7 @@
// Associated types can only be object safe if they have `Self: Sized` bounds.
ty::AssocKind::Type => {
if !tcx.features().generic_associated_types_extended
- && !tcx.generics_of(item.def_id).params.is_empty()
+ && !tcx.generics_of(item.def_id).own_params.is_empty()
&& !item.is_impl_trait_in_trait()
{
vec![ObjectSafetyViolation::GAT(item.name, item.ident(tcx).span)]
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 116e17c..0aafc1a 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -13,12 +13,12 @@
use super::SelectionContext;
use super::SelectionError;
use super::{Normalized, NormalizedTy, ProjectionCacheEntry, ProjectionCacheKey};
+use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::traits::BuiltinImplSource;
use rustc_middle::traits::ImplSource;
use rustc_middle::traits::ImplSourceUserDefinedData;
use crate::errors::InherentProjectionNormalizationOverflow;
-use crate::infer::type_variable::TypeVariableOrigin;
use crate::infer::{BoundRegionConversionTime, InferOk};
use crate::traits::normalize::normalize_with_depth;
use crate::traits::normalize::normalize_with_depth_to;
@@ -521,10 +521,7 @@
predicate: trait_ref.to_predicate(selcx.tcx()),
};
let tcx = selcx.infcx.tcx;
- let new_value = selcx.infcx.next_ty_var(TypeVariableOrigin {
- param_def_id: None,
- span: tcx.def_span(projection_ty.def_id),
- });
+ let new_value = selcx.infcx.next_ty_var(tcx.def_span(projection_ty.def_id));
Normalized { value: new_value, obligations: vec![trait_obligation] }
}
@@ -577,9 +574,9 @@
// diagnostics which is not ideal.
// Consider creating separate cause codes for this specific situation.
if span.is_dummy() {
- super::ItemObligation(alias_ty.def_id)
+ ObligationCauseCode::WhereClause(alias_ty.def_id)
} else {
- super::BindingObligation(alias_ty.def_id, span)
+ ObligationCauseCode::SpannedWhereClause(alias_ty.def_id, span)
},
);
@@ -2117,22 +2114,22 @@
let nested_cause = if matches!(
obligation.cause.code(),
- super::CompareImplItemObligation { .. }
- | super::CheckAssociatedTypeBounds { .. }
- | super::AscribeUserTypeProvePredicate(..)
+ ObligationCauseCode::CompareImplItem { .. }
+ | ObligationCauseCode::CheckAssociatedTypeBounds { .. }
+ | ObligationCauseCode::AscribeUserTypeProvePredicate(..)
) {
obligation.cause.clone()
} else if span.is_dummy() {
ObligationCause::new(
obligation.cause.span,
obligation.cause.body_id,
- super::ItemObligation(obligation.predicate.def_id),
+ ObligationCauseCode::WhereClause(obligation.predicate.def_id),
)
} else {
ObligationCause::new(
obligation.cause.span,
obligation.cause.body_id,
- super::BindingObligation(obligation.predicate.def_id, span),
+ ObligationCauseCode::SpannedWhereClause(obligation.predicate.def_id, span),
)
};
nested.push(Obligation::with_depth(
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 4fa2455..0b91dd7 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -11,6 +11,7 @@
use rustc_hir::lang_items::LangItem;
use rustc_infer::infer::HigherRankedType;
use rustc_infer::infer::{DefineOpaqueTypes, InferOk};
+use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::traits::{BuiltinImplSource, SignatureMismatchData};
use rustc_middle::ty::{
self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, ToPredicate,
@@ -25,10 +26,9 @@
VtblSegment,
};
use crate::traits::{
- BuiltinDerivedObligation, ImplDerivedObligation, ImplDerivedObligationCause, ImplSource,
- ImplSourceUserDefinedData, Normalized, Obligation, ObligationCause, PolyTraitObligation,
- PredicateObligation, Selection, SelectionError, SignatureMismatch, TraitNotObjectSafe,
- TraitObligation, Unimplemented,
+ ImplDerivedCause, ImplSource, ImplSourceUserDefinedData, Normalized, Obligation,
+ ObligationCause, PolyTraitObligation, PredicateObligation, Selection, SelectionError,
+ SignatureMismatch, TraitNotObjectSafe, TraitObligation, Unimplemented,
};
use super::BuiltinImplConditions;
@@ -275,7 +275,7 @@
bug!("obligation {:?} had matched a builtin impl but now doesn't", obligation);
};
- let cause = obligation.derived_cause(BuiltinDerivedObligation);
+ let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
self.collect_predicates_for_types(
obligation.param_env,
cause,
@@ -435,7 +435,7 @@
) -> Vec<PredicateObligation<'tcx>> {
debug!(?nested, "vtable_auto_impl");
ensure_sufficient_stack(|| {
- let cause = obligation.derived_cause(BuiltinDerivedObligation);
+ let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
let poly_trait_ref = obligation.predicate.to_poly_trait_ref();
let trait_ref = self.infcx.enter_forall_and_leak_universe(poly_trait_ref);
@@ -606,7 +606,7 @@
for assoc_type in assoc_types {
let defs: &ty::Generics = tcx.generics_of(assoc_type);
- if !defs.params.is_empty() && !tcx.features().generic_associated_types_extended {
+ if !defs.own_params.is_empty() && !tcx.features().generic_associated_types_extended {
tcx.dcx().span_delayed_bug(
obligation.cause.span,
"GATs in trait object shouldn't have been considered",
@@ -693,7 +693,8 @@
let vtable_base = vtable_trait_first_method_offset(
tcx,
- (unnormalized_upcast_trait_ref, ty::Binder::dummy(object_trait_ref)),
+ unnormalized_upcast_trait_ref,
+ ty::Binder::dummy(object_trait_ref),
);
Ok(ImplSource::Builtin(BuiltinImplSource::Object { vtable_base: vtable_base }, nested))
@@ -722,7 +723,7 @@
let mut nested =
self.equate_trait_refs(obligation.with(tcx, placeholder_predicate), trait_ref)?;
- let cause = obligation.derived_cause(BuiltinDerivedObligation);
+ let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
// Confirm the `type Output: Sized;` bound that is present on `FnOnce`
let output_ty = self.infcx.enter_forall_and_leak_universe(sig.output());
@@ -1380,7 +1381,7 @@
let self_ty = obligation.self_ty().map_bound(|ty| self.infcx.shallow_resolve(ty));
let mut nested = vec![];
- let cause = obligation.derived_cause(BuiltinDerivedObligation);
+ let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
// If we have a custom `impl const Drop`, then
// first check it like a regular impl candidate.
@@ -1395,7 +1396,7 @@
debug!(?args, "impl args");
let cause = obligation.derived_cause(|derived| {
- ImplDerivedObligation(Box::new(ImplDerivedObligationCause {
+ ObligationCauseCode::ImplDerived(Box::new(ImplDerivedCause {
derived,
impl_or_alias_def_id: impl_def_id,
impl_def_predicate_index: None,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 18cb318..50353a1 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -13,9 +13,9 @@
use super::util::closure_trait_ref_and_return_type;
use super::wf;
use super::{
- ImplDerivedObligation, ImplDerivedObligationCause, Normalized, Obligation, ObligationCause,
- ObligationCauseCode, Overflow, PolyTraitObligation, PredicateObligation, Selection,
- SelectionError, SelectionResult, TraitQueryMode,
+ ImplDerivedCause, Normalized, Obligation, ObligationCause, ObligationCauseCode, Overflow,
+ PolyTraitObligation, PredicateObligation, Selection, SelectionError, SelectionResult,
+ TraitQueryMode,
};
use crate::infer::{InferCtxt, InferOk, TypeFreshener};
@@ -1777,7 +1777,7 @@
// If this type is a GAT, and of the GAT args resolve to something new,
// that means that we must have newly inferred something about the GAT.
// We should give up in that case.
- if !generics.params.is_empty()
+ if !generics.own_params.is_empty()
&& obligation.predicate.args[generics.parent_count..].iter().any(|&p| {
p.has_non_region_infer() && self.infcx.resolve_vars_if_possible(p) != p
})
@@ -2441,7 +2441,7 @@
});
let tcx = self.tcx();
- let trait_ref = if tcx.generics_of(trait_def_id).params.len() == 1 {
+ let trait_ref = if tcx.generics_of(trait_def_id).own_params.len() == 1 {
ty::TraitRef::new(tcx, trait_def_id, [normalized_ty])
} else {
// If this is an ill-formed auto/built-in trait, then synthesize
@@ -2771,7 +2771,7 @@
cause.clone()
} else {
cause.clone().derived_cause(parent_trait_pred, |derived| {
- ImplDerivedObligation(Box::new(ImplDerivedObligationCause {
+ ObligationCauseCode::ImplDerived(Box::new(ImplDerivedCause {
derived,
impl_or_alias_def_id: def_id,
impl_def_predicate_index: Some(index),
diff --git a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
index 64ab837..96a06e0 100644
--- a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
@@ -1,5 +1,4 @@
use rustc_infer::infer::at::At;
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::traits::{FulfillmentError, TraitEngine};
use rustc_macros::extension;
use rustc_middle::ty::{self, Ty};
@@ -20,9 +19,7 @@
return Ok(ty);
};
- let new_infer_ty = self
- .infcx
- .next_ty_var(TypeVariableOrigin { param_def_id: None, span: self.cause.span });
+ let new_infer_ty = self.infcx.next_ty_var(self.cause.span);
// We simply emit an `alias-eq` goal here, since that will take care of
// normalizing the LHS of the projection until it is a rigid projection
diff --git a/compiler/rustc_trait_selection/src/traits/vtable.rs b/compiler/rustc_trait_selection/src/traits/vtable.rs
index 178f3c6..3f1ba80 100644
--- a/compiler/rustc_trait_selection/src/traits/vtable.rs
+++ b/compiler/rustc_trait_selection/src/traits/vtable.rs
@@ -320,16 +320,11 @@
}
/// Find slot base for trait methods within vtable entries of another trait
-// FIXME(@lcnr): This isn't a query, so why does it take a tuple as its argument.
pub(super) fn vtable_trait_first_method_offset<'tcx>(
tcx: TyCtxt<'tcx>,
- key: (
- ty::PolyTraitRef<'tcx>, // trait_to_be_found
- ty::PolyTraitRef<'tcx>, // trait_owning_vtable
- ),
+ trait_to_be_found: ty::PolyTraitRef<'tcx>,
+ trait_owning_vtable: ty::PolyTraitRef<'tcx>,
) -> usize {
- let (trait_to_be_found, trait_owning_vtable) = key;
-
// #90177
let trait_to_be_found_erased = tcx.erase_regions(trait_to_be_found);
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index 28ee76f..ebcda61 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -2,6 +2,7 @@
use crate::traits;
use rustc_hir as hir;
use rustc_hir::lang_items::LangItem;
+use rustc_infer::traits::ObligationCauseCode;
use rustc_middle::ty::{
self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
};
@@ -333,7 +334,7 @@
return self.out;
}
- let cause = self.cause(traits::WellFormed(None));
+ let cause = self.cause(ObligationCauseCode::WellFormed(None));
let param_env = self.param_env;
let mut obligations = Vec::with_capacity(self.out.len());
for mut obligation in self.out {
@@ -381,7 +382,7 @@
if let Some(parent_trait_pred) = predicate.to_opt_poly_trait_pred() {
cause = cause.derived_cause(
parent_trait_pred,
- traits::ObligationCauseCode::WellFormedDerivedObligation,
+ traits::ObligationCauseCode::WellFormedDerived,
);
}
extend_cause_with_original_assoc_item_obligation(tcx, item, &mut cause, predicate);
@@ -485,7 +486,7 @@
&mut traits::SelectionContext::new(self.infcx),
self.param_env,
data,
- self.cause(traits::WellFormed(None)),
+ self.cause(ObligationCauseCode::WellFormed(None)),
self.recursion_depth,
&mut self.out,
);
@@ -498,7 +499,7 @@
fn compute_projection_args(&mut self, args: GenericArgsRef<'tcx>) {
let tcx = self.tcx();
- let cause = self.cause(traits::WellFormed(None));
+ let cause = self.cause(ObligationCauseCode::WellFormed(None));
let param_env = self.param_env;
let depth = self.recursion_depth;
@@ -565,9 +566,9 @@
iter::zip(predicates, origins.into_iter().rev())
.map(|((pred, span), origin_def_id)| {
let code = if span.is_dummy() {
- traits::ItemObligation(origin_def_id)
+ ObligationCauseCode::WhereClause(origin_def_id)
} else {
- traits::BindingObligation(origin_def_id, span)
+ ObligationCauseCode::SpannedWhereClause(origin_def_id, span)
};
let cause = self.cause(code);
traits::Obligation::with_depth(
@@ -626,7 +627,7 @@
self.out.reserve(implicit_bounds.len());
for implicit_bound in implicit_bounds {
- let cause = self.cause(traits::ObjectTypeBound(ty, explicit_bound));
+ let cause = self.cause(ObligationCauseCode::ObjectTypeBound(ty, explicit_bound));
let outlives =
ty::Binder::dummy(ty::OutlivesPredicate(explicit_bound, implicit_bound));
self.out.push(traits::Obligation::with_depth(
@@ -644,7 +645,7 @@
impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
type Result = ();
- fn visit_ty(&mut self, t: <TyCtxt<'tcx> as ty::Interner>::Ty) -> Self::Result {
+ fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
debug!("wf bounds for t={:?} t.kind={:#?}", t, t.kind());
let tcx = self.tcx();
@@ -673,22 +674,22 @@
ty::Infer(ty::FloatVar(_)) => {}
ty::Slice(subty) => {
- self.require_sized(subty, traits::SliceOrArrayElem);
+ self.require_sized(subty, ObligationCauseCode::SliceOrArrayElem);
}
ty::Array(subty, _) => {
- self.require_sized(subty, traits::SliceOrArrayElem);
+ self.require_sized(subty, ObligationCauseCode::SliceOrArrayElem);
// Note that we handle the len is implicitly checked while walking `arg`.
}
ty::Pat(subty, _) => {
- self.require_sized(subty, traits::MiscObligation);
+ self.require_sized(subty, ObligationCauseCode::Misc);
}
ty::Tuple(tys) => {
if let Some((_last, rest)) = tys.split_last() {
for &elem in rest {
- self.require_sized(elem, traits::TupleElem);
+ self.require_sized(elem, ObligationCauseCode::TupleElem);
}
}
}
@@ -728,7 +729,7 @@
ty::Ref(r, rty, _) => {
// WfReference
if !r.has_escaping_bound_vars() && !rty.has_escaping_bound_vars() {
- let cause = self.cause(traits::ReferenceOutlivesReferent(t));
+ let cause = self.cause(ObligationCauseCode::ReferenceOutlivesReferent(t));
self.out.push(traits::Obligation::with_depth(
tcx,
cause,
@@ -825,7 +826,7 @@
if let Some(principal) = data.principal_def_id() {
self.out.push(traits::Obligation::with_depth(
tcx,
- self.cause(traits::WellFormed(None)),
+ self.cause(ObligationCauseCode::WellFormed(None)),
self.recursion_depth,
self.param_env,
ty::Binder::dummy(ty::PredicateKind::ObjectSafe(principal)),
@@ -847,7 +848,7 @@
// See also the comment on `fn obligations`, describing "livelock"
// prevention, which happens before this can be reached.
ty::Infer(_) => {
- let cause = self.cause(traits::WellFormed(None));
+ let cause = self.cause(ObligationCauseCode::WellFormed(None));
self.out.push(traits::Obligation::with_depth(
tcx,
cause,
@@ -863,7 +864,7 @@
t.super_visit_with(self)
}
- fn visit_const(&mut self, c: <TyCtxt<'tcx> as ty::Interner>::Const) -> Self::Result {
+ fn visit_const(&mut self, c: ty::Const<'tcx>) -> Self::Result {
let tcx = self.tcx();
match c.kind() {
@@ -875,7 +876,7 @@
let predicate = ty::Binder::dummy(ty::PredicateKind::Clause(
ty::ClauseKind::ConstEvaluatable(c),
));
- let cause = self.cause(traits::WellFormed(None));
+ let cause = self.cause(ObligationCauseCode::WellFormed(None));
self.out.push(traits::Obligation::with_depth(
tcx,
cause,
@@ -886,7 +887,7 @@
}
}
ty::ConstKind::Infer(_) => {
- let cause = self.cause(traits::WellFormed(None));
+ let cause = self.cause(ObligationCauseCode::WellFormed(None));
self.out.push(traits::Obligation::with_depth(
tcx,
@@ -909,7 +910,7 @@
let predicate = ty::Binder::dummy(ty::PredicateKind::Clause(
ty::ClauseKind::ConstEvaluatable(c),
));
- let cause = self.cause(traits::WellFormed(None));
+ let cause = self.cause(ObligationCauseCode::WellFormed(None));
self.out.push(traits::Obligation::with_depth(
tcx,
cause,
@@ -933,7 +934,7 @@
c.super_visit_with(self)
}
- fn visit_predicate(&mut self, _p: <TyCtxt<'tcx> as ty::Interner>::Predicate) -> Self::Result {
+ fn visit_predicate(&mut self, _p: ty::Predicate<'tcx>) -> Self::Result {
bug!("predicate should not be checked for well-formedness");
}
}
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index ba75424..d3fe829 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -340,22 +340,22 @@
impl_assoc_ty.generics_of({
let trait_assoc_generics = tcx.generics_of(trait_assoc_def_id);
let trait_assoc_parent_count = trait_assoc_generics.parent_count;
- let mut params = trait_assoc_generics.params.clone();
+ let mut own_params = trait_assoc_generics.own_params.clone();
let parent_generics = tcx.generics_of(impl_local_def_id.to_def_id());
- let parent_count = parent_generics.parent_count + parent_generics.params.len();
+ let parent_count = parent_generics.parent_count + parent_generics.own_params.len();
- for param in &mut params {
+ for param in &mut own_params {
param.index = param.index + parent_count as u32 - trait_assoc_parent_count as u32;
}
let param_def_id_to_index =
- params.iter().map(|param| (param.def_id, param.index)).collect();
+ own_params.iter().map(|param| (param.def_id, param.index)).collect();
ty::Generics {
parent: Some(impl_local_def_id.to_def_id()),
parent_count,
- params,
+ own_params,
param_def_id_to_index,
has_self: false,
has_late_bound_regions: trait_assoc_generics.has_late_bound_regions,
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
index e1534af..862fb2e 100644
--- a/compiler/rustc_ty_utils/src/implied_bounds.rs
+++ b/compiler/rustc_ty_utils/src/implied_bounds.rs
@@ -69,7 +69,8 @@
// case, since it has been liberated), map it back to the early-bound lifetime of
// the GAT. Since RPITITs also have all of the fn's generics, we slice only
// the end of the list corresponding to the opaque's generics.
- for param in &generics.params[tcx.generics_of(fn_def_id).params.len()..] {
+ for param in &generics.own_params[tcx.generics_of(fn_def_id).own_params.len()..]
+ {
let orig_lt =
tcx.map_opaque_lifetime_to_parent_lifetime(param.def_id.expect_local());
if matches!(*orig_lt, ty::ReLateParam(..)) {
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 902b76e..f78a28d 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -5,7 +5,7 @@
use rustc_middle::mir::{CoroutineLayout, CoroutineSavedLocal};
use rustc_middle::query::Providers;
use rustc_middle::ty::layout::{
- IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, MAX_SIMD_LANES,
+ FloatExt, IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, MAX_SIMD_LANES,
};
use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_middle::ty::{
@@ -180,12 +180,7 @@
)),
ty::Int(ity) => scalar(Int(Integer::from_int_ty(dl, ity), true)),
ty::Uint(ity) => scalar(Int(Integer::from_uint_ty(dl, ity), false)),
- ty::Float(fty) => scalar(match fty {
- ty::FloatTy::F16 => F16,
- ty::FloatTy::F32 => F32,
- ty::FloatTy::F64 => F64,
- ty::FloatTy::F128 => F128,
- }),
+ ty::Float(fty) => scalar(Float(Float::from_float_ty(fty))),
ty::FnPtr(_) => {
let mut ptr = scalar_unit(Pointer(dl.instruction_address_space));
ptr.valid_range_mut().start = 1;
diff --git a/compiler/rustc_ty_utils/src/representability.rs b/compiler/rustc_ty_utils/src/representability.rs
index a5ffa55..446f16b 100644
--- a/compiler/rustc_ty_utils/src/representability.rs
+++ b/compiler/rustc_ty_utils/src/representability.rs
@@ -85,7 +85,7 @@
fn params_in_repr(tcx: TyCtxt<'_>, def_id: LocalDefId) -> BitSet<u32> {
let adt_def = tcx.adt_def(def_id);
let generics = tcx.generics_of(def_id);
- let mut params_in_repr = BitSet::new_empty(generics.params.len());
+ let mut params_in_repr = BitSet::new_empty(generics.own_params.len());
for variant in adt_def.variants() {
for field in variant.fields.iter() {
params_in_repr_ty(
diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs
index c0d292c..3e23612 100644
--- a/library/alloc/src/str.rs
+++ b/library/alloc/src/str.rs
@@ -375,14 +375,16 @@
// Safety: We have written only valid ASCII to our vec
let mut s = unsafe { String::from_utf8_unchecked(out) };
- for (i, c) in rest[..].char_indices() {
+ for (i, c) in rest.char_indices() {
if c == 'Σ' {
// Σ maps to σ, except at the end of a word where it maps to ς.
// This is the only conditional (contextual) but language-independent mapping
// in `SpecialCasing.txt`,
// so hard-code it rather than have a generic "condition" mechanism.
// See https://github.com/rust-lang/rust/issues/26035
- map_uppercase_sigma(rest, i, &mut s)
+ let out_len = self.len() - rest.len();
+ let sigma_lowercase = map_uppercase_sigma(&self, i + out_len);
+ s.push(sigma_lowercase);
} else {
match conversions::to_lower(c) {
[a, '\0', _] => s.push(a),
@@ -400,13 +402,13 @@
}
return s;
- fn map_uppercase_sigma(from: &str, i: usize, to: &mut String) {
+ fn map_uppercase_sigma(from: &str, i: usize) -> char {
// See https://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
// for the definition of `Final_Sigma`.
debug_assert!('Σ'.len_utf8() == 2);
let is_word_final = case_ignorable_then_cased(from[..i].chars().rev())
&& !case_ignorable_then_cased(from[i + 2..].chars());
- to.push_str(if is_word_final { "ς" } else { "σ" });
+ if is_word_final { 'ς' } else { 'σ' }
}
fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
diff --git a/library/alloc/tests/str.rs b/library/alloc/tests/str.rs
index df8a260..0078f5e 100644
--- a/library/alloc/tests/str.rs
+++ b/library/alloc/tests/str.rs
@@ -1848,6 +1848,9 @@
assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
+ // https://github.com/rust-lang/rust/issues/124714
+ assert_eq!("abcdefghijklmnopΣ".to_lowercase(), "abcdefghijklmnopς");
+
// a really long string that has it's lowercase form
// even longer. this tests that implementations don't assume
// an incorrect upper bound on allocations
diff --git a/library/core/benches/str.rs b/library/core/benches/str.rs
index 7d36eff..0f14809 100644
--- a/library/core/benches/str.rs
+++ b/library/core/benches/str.rs
@@ -3,6 +3,7 @@
mod char_count;
mod corpora;
+mod debug;
mod iter;
#[bench]
diff --git a/library/core/benches/str/debug.rs b/library/core/benches/str/debug.rs
new file mode 100644
index 0000000..7c72228
--- /dev/null
+++ b/library/core/benches/str/debug.rs
@@ -0,0 +1,79 @@
+//! This primarily benchmarks `impl Debug for str`,
+//! and it also explicitly tests that we minimizes calls to the underlying `Write`r.
+//! While that is an implementation detail and there are no guarantees about it,
+//! we should still try to minimize those calls over time rather than regress them.
+
+use std::fmt::{self, Write};
+use test::{black_box, Bencher};
+
+#[derive(Default)]
+struct CountingWriter {
+ buf: String,
+ write_calls: usize,
+}
+
+impl Write for CountingWriter {
+ fn write_str(&mut self, s: &str) -> fmt::Result {
+ self.buf.push_str(s);
+ self.write_calls += 1;
+ Ok(())
+ }
+}
+
+fn assert_fmt(s: &str, expected: &str, expected_write_calls: usize) {
+ let mut w = CountingWriter::default();
+
+ write!(&mut w, "{s:?}").unwrap();
+ assert_eq!(s.len(), 64);
+ assert_eq!(w.buf, expected);
+ assert_eq!(w.write_calls, expected_write_calls);
+}
+
+#[bench]
+fn ascii_only(b: &mut Bencher) {
+ let s = "just a bit of ascii text that has no escapes. 64 bytes exactly!!";
+ assert_fmt(s, r#""just a bit of ascii text that has no escapes. 64 bytes exactly!!""#, 3);
+ b.iter(|| {
+ black_box(format!("{:?}", black_box(s)));
+ });
+}
+
+#[bench]
+fn ascii_escapes(b: &mut Bencher) {
+ let s = "some\tmore\tascii\ttext\nthis time with some \"escapes\", also 64 byte";
+ assert_fmt(
+ s,
+ r#""some\tmore\tascii\ttext\nthis time with some \"escapes\", also 64 byte""#,
+ 21,
+ );
+ b.iter(|| {
+ black_box(format!("{:?}", black_box(s)));
+ });
+}
+
+#[bench]
+fn some_unicode(b: &mut Bencher) {
+ let s = "egy kis szöveg néhány unicode betűvel. legyen ez is 64 byte.";
+ assert_fmt(s, r#""egy kis szöveg néhány unicode betűvel. legyen ez is 64 byte.""#, 3);
+ b.iter(|| {
+ black_box(format!("{:?}", black_box(s)));
+ });
+}
+
+#[bench]
+fn mostly_unicode(b: &mut Bencher) {
+ let s = "предложение из кириллических букв.";
+ assert_fmt(s, r#""предложение из кириллических букв.""#, 3);
+ b.iter(|| {
+ black_box(format!("{:?}", black_box(s)));
+ });
+}
+
+#[bench]
+fn mixed(b: &mut Bencher) {
+ let s = "\"❤️\"\n\"hűha ez betű\"\n\"кириллических букв\".";
+ assert_fmt(s, r#""\"❤\u{fe0f}\"\n\"hűha ez betű\"\n\"кириллических букв\".""#, 36);
+ b.iter(|| {
+ black_box(format!("{:?}", black_box(s)));
+ });
+}
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index c02f73f..09a341e 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -1412,11 +1412,9 @@
#[cfg_attr(feature = "panic_immediate_abort", inline)]
#[cold]
#[track_caller]
-const fn from_str_radix_assert(radix: u32) {
- if 2 > radix || radix > 36 {
- // The only difference between these two functions is their panic message.
- intrinsics::const_eval_select((radix,), from_str_radix_panic_ct, from_str_radix_panic_rt);
- }
+const fn from_str_radix_panic(radix: u32) {
+ // The only difference between these two functions is their panic message.
+ intrinsics::const_eval_select((radix,), from_str_radix_panic_ct, from_str_radix_panic_rt);
}
macro_rules! from_str_radix {
@@ -1450,7 +1448,9 @@
use self::IntErrorKind::*;
use self::ParseIntError as PIE;
- from_str_radix_assert(radix);
+ if 2 > radix || radix > 36 {
+ from_str_radix_panic(radix);
+ }
if src.is_empty() {
return Err(PIE { kind: Empty });
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 133cde8..9bee504 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -1337,8 +1337,10 @@
#[must_use]
pub const fn as_chunks<const N: usize>(&self) -> (&[[T; N]], &[T]) {
assert!(N != 0, "chunk size must be non-zero");
- let len = self.len() / N;
- let (multiple_of_n, remainder) = self.split_at(len * N);
+ let len_rounded_down = self.len() / N * N;
+ // SAFETY: The rounded-down value is always the same or smaller than the
+ // original length, and thus must be in-bounds of the slice.
+ let (multiple_of_n, remainder) = unsafe { self.split_at_unchecked(len_rounded_down) };
// SAFETY: We already panicked for zero, and ensured by construction
// that the length of the subslice is a multiple of N.
let array_slice = unsafe { multiple_of_n.as_chunks_unchecked() };
@@ -1487,8 +1489,10 @@
#[must_use]
pub const fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[T; N]], &mut [T]) {
assert!(N != 0, "chunk size must be non-zero");
- let len = self.len() / N;
- let (multiple_of_n, remainder) = self.split_at_mut(len * N);
+ let len_rounded_down = self.len() / N * N;
+ // SAFETY: The rounded-down value is always the same or smaller than the
+ // original length, and thus must be in-bounds of the slice.
+ let (multiple_of_n, remainder) = unsafe { self.split_at_mut_unchecked(len_rounded_down) };
// SAFETY: We already panicked for zero, and ensured by construction
// that the length of the subslice is a multiple of N.
let array_slice = unsafe { multiple_of_n.as_chunks_unchecked_mut() };
diff --git a/library/test/src/bench.rs b/library/test/src/bench.rs
index 23925e6..9a5dc35 100644
--- a/library/test/src/bench.rs
+++ b/library/test/src/bench.rs
@@ -68,12 +68,12 @@
use std::fmt::Write;
let mut output = String::new();
- let median = bs.ns_iter_summ.median as usize;
- let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize;
+ let median = bs.ns_iter_summ.median;
+ let deviation = bs.ns_iter_summ.max - bs.ns_iter_summ.min;
write!(
output,
- "{:>11} ns/iter (+/- {})",
+ "{:>14} ns/iter (+/- {})",
fmt_thousands_sep(median, ','),
fmt_thousands_sep(deviation, ',')
)
@@ -85,24 +85,27 @@
}
// Format a number with thousands separators
-fn fmt_thousands_sep(mut n: usize, sep: char) -> String {
+fn fmt_thousands_sep(mut n: f64, sep: char) -> String {
use std::fmt::Write;
let mut output = String::new();
let mut trailing = false;
for &pow in &[9, 6, 3, 0] {
let base = 10_usize.pow(pow);
- if pow == 0 || trailing || n / base != 0 {
- if !trailing {
- write!(output, "{}", n / base).unwrap();
- } else {
- write!(output, "{:03}", n / base).unwrap();
+ if pow == 0 || trailing || n / base as f64 >= 1.0 {
+ match (pow, trailing) {
+ // modern CPUs can execute multiple instructions per nanosecond
+ // e.g. benching an ADD takes about 0.25ns.
+ (0, true) => write!(output, "{:06.2}", n / base as f64).unwrap(),
+ (0, false) => write!(output, "{:.2}", n / base as f64).unwrap(),
+ (_, true) => write!(output, "{:03}", n as usize / base).unwrap(),
+ _ => write!(output, "{}", n as usize / base).unwrap()
}
if pow != 0 {
output.push(sep);
}
trailing = true;
}
- n %= base;
+ n %= base as f64;
}
output
diff --git a/library/test/src/formatters/json.rs b/library/test/src/formatters/json.rs
index 47c4e77..6245aae 100644
--- a/library/test/src/formatters/json.rs
+++ b/library/test/src/formatters/json.rs
@@ -167,8 +167,8 @@
),
TestResult::TrBench(ref bs) => {
- let median = bs.ns_iter_summ.median as usize;
- let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize;
+ let median = bs.ns_iter_summ.median;
+ let deviation = bs.ns_iter_summ.max - bs.ns_iter_summ.min;
let mbps = if bs.mb_s == 0 {
String::new()
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 6c4b26e..8d7e53d 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -2549,7 +2549,12 @@
// FIXME: the guard against msvc shouldn't need to be here
if target.is_msvc() {
if let Some(ref cl) = builder.config.llvm_clang_cl {
- self.command.env("CC", cl).env("CXX", cl);
+ // FIXME: There is a bug in Clang 18 when building for ARM64:
+ // https://github.com/llvm/llvm-project/pull/81849. This is
+ // fixed in LLVM 19, but can't be backported.
+ if !target.starts_with("aarch64") && !target.starts_with("arm64ec") {
+ self.command.env("CC", cl).env("CXX", cl);
+ }
}
} else {
let ccache = builder.config.ccache.as_ref();
diff --git a/src/bootstrap/src/utils/render_tests.rs b/src/bootstrap/src/utils/render_tests.rs
index 462b76d..5c9918b 100644
--- a/src/bootstrap/src/utils/render_tests.rs
+++ b/src/bootstrap/src/utils/render_tests.rs
@@ -215,8 +215,8 @@
for bench in &self.benches {
rows.push((
&bench.name,
- format!("{:.2?}/iter", Duration::from_nanos(bench.median)),
- format!("+/- {:.2?}", Duration::from_nanos(bench.deviation)),
+ format!("{:.2?}/iter", bench.median),
+ format!("+/- {:.2?}", bench.deviation),
));
}
@@ -394,8 +394,8 @@
#[derive(serde_derive::Deserialize)]
struct BenchOutcome {
name: String,
- median: u64,
- deviation: u64,
+ median: f64,
+ deviation: f64,
}
#[derive(serde_derive::Deserialize)]
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-linux/build-clang.sh b/src/ci/docker/host-x86_64/dist-x86_64-linux/build-clang.sh
index 005f453..f3591a6 100755
--- a/src/ci/docker/host-x86_64/dist-x86_64-linux/build-clang.sh
+++ b/src/ci/docker/host-x86_64/dist-x86_64-linux/build-clang.sh
@@ -4,6 +4,7 @@
source shared.sh
+# Try to keep the LLVM version here in sync with src/ci/scripts/install-clang.sh
LLVM=llvmorg-18.1.0
mkdir llvm-project
diff --git a/src/ci/github-actions/calculate-job-matrix.py b/src/ci/github-actions/calculate-job-matrix.py
index 68565f4..4f9bc39 100755
--- a/src/ci/github-actions/calculate-job-matrix.py
+++ b/src/ci/github-actions/calculate-job-matrix.py
@@ -8,10 +8,11 @@
and filters them based on the event that happened on CI.
"""
import dataclasses
-import enum
import json
import logging
import os
+import re
+import typing
from pathlib import Path
from typing import List, Dict, Any, Optional
@@ -44,10 +45,22 @@
return jobs
-class WorkflowRunType(enum.Enum):
- PR = enum.auto()
- Try = enum.auto()
- Auto = enum.auto()
+@dataclasses.dataclass
+class PRRunType:
+ pass
+
+
+@dataclasses.dataclass
+class TryRunType:
+ custom_jobs: List[str]
+
+
+@dataclasses.dataclass
+class AutoRunType:
+ pass
+
+
+WorkflowRunType = typing.Union[PRRunType, TryRunType, AutoRunType]
@dataclasses.dataclass
@@ -55,11 +68,28 @@
event_name: str
ref: str
repository: str
+ commit_message: Optional[str]
+
+
+def get_custom_jobs(ctx: GitHubCtx) -> List[str]:
+ """
+ Tries to parse names of specific CI jobs that should be executed in the form of
+ try-job: <job-name>
+ from the commit message of the passed GitHub context.
+ """
+ if ctx.commit_message is None:
+ return []
+
+ regex = re.compile(r"^try-job: (.*)", re.MULTILINE)
+ jobs = []
+ for match in regex.finditer(ctx.commit_message):
+ jobs.append(match.group(1))
+ return jobs
def find_run_type(ctx: GitHubCtx) -> Optional[WorkflowRunType]:
if ctx.event_name == "pull_request":
- return WorkflowRunType.PR
+ return PRRunType()
elif ctx.event_name == "push":
old_bors_try_build = (
ctx.ref in ("refs/heads/try", "refs/heads/try-perf") and
@@ -72,20 +102,41 @@
try_build = old_bors_try_build or new_bors_try_build
if try_build:
- return WorkflowRunType.Try
+ jobs = get_custom_jobs(ctx)
+ return TryRunType(custom_jobs=jobs)
if ctx.ref == "refs/heads/auto" and ctx.repository == "rust-lang-ci/rust":
- return WorkflowRunType.Auto
+ return AutoRunType()
return None
def calculate_jobs(run_type: WorkflowRunType, job_data: Dict[str, Any]) -> List[Job]:
- if run_type == WorkflowRunType.PR:
+ if isinstance(run_type, PRRunType):
return add_base_env(name_jobs(job_data["pr"], "PR"), job_data["envs"]["pr"])
- elif run_type == WorkflowRunType.Try:
- return add_base_env(name_jobs(job_data["try"], "try"), job_data["envs"]["try"])
- elif run_type == WorkflowRunType.Auto:
+ elif isinstance(run_type, TryRunType):
+ jobs = job_data["try"]
+ custom_jobs = run_type.custom_jobs
+ if custom_jobs:
+ if len(custom_jobs) > 10:
+ raise Exception(
+ f"It is only possible to schedule up to 10 custom jobs, "
+ f"received {len(custom_jobs)} jobs"
+ )
+
+ jobs = []
+ unknown_jobs = []
+ for custom_job in custom_jobs:
+ job = [j for j in job_data["auto"] if j["image"] == custom_job]
+ if not job:
+ unknown_jobs.append(custom_job)
+ continue
+ jobs.append(job[0])
+ if unknown_jobs:
+ raise Exception(f"Custom job(s) `{unknown_jobs}` not found in auto jobs")
+
+ return add_base_env(name_jobs(jobs, "try"), job_data["envs"]["try"])
+ elif isinstance(run_type, AutoRunType):
return add_base_env(name_jobs(job_data["auto"], "auto"), job_data["envs"]["auto"])
return []
@@ -99,19 +150,25 @@
def get_github_ctx() -> GitHubCtx:
+ event_name = os.environ["GITHUB_EVENT_NAME"]
+
+ commit_message = None
+ if event_name == "push":
+ commit_message = os.environ["COMMIT_MESSAGE"]
return GitHubCtx(
- event_name=os.environ["GITHUB_EVENT_NAME"],
+ event_name=event_name,
ref=os.environ["GITHUB_REF"],
- repository=os.environ["GITHUB_REPOSITORY"]
+ repository=os.environ["GITHUB_REPOSITORY"],
+ commit_message=commit_message
)
def format_run_type(run_type: WorkflowRunType) -> str:
- if run_type == WorkflowRunType.PR:
+ if isinstance(run_type, PRRunType):
return "pr"
- elif run_type == WorkflowRunType.Auto:
+ elif isinstance(run_type, AutoRunType):
return "auto"
- elif run_type == WorkflowRunType.Try:
+ elif isinstance(run_type, TryRunType):
return "try"
else:
raise AssertionError()
@@ -135,6 +192,10 @@
if run_type is not None:
jobs = calculate_jobs(run_type, data)
jobs = skip_jobs(jobs, channel)
+
+ if not jobs:
+ raise Exception("Scheduled job list is empty, this is an error")
+
run_type = format_run_type(run_type)
logging.info(f"Output:\n{yaml.dump(dict(jobs=jobs, run_type=run_type), indent=4)}")
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 20b1a55..04888dc 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -32,14 +32,6 @@
os: windows-2022-16core-64gb
<<: *base-job
- - &job-windows-2019-8c
- os: windows-2019-8core-32gb
- <<: *base-job
-
- - &job-windows-2019-16c
- os: windows-2019-16core-64gb
- <<: *base-job
-
- &job-aarch64-linux
os: [ self-hosted, ARM64, linux ]
@@ -349,13 +341,13 @@
env:
RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-profiler
SCRIPT: make ci-msvc
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
- image: i686-msvc
env:
RUST_CONFIGURE_ARGS: --build=i686-pc-windows-msvc
SCRIPT: make ci-msvc
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
- image: x86_64-msvc-ext
env:
@@ -363,7 +355,7 @@
HOST_TARGET: x86_64-pc-windows-msvc
RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-lld --save-toolstates=/tmp/toolstate/toolstates.json
DEPLOY_TOOLSTATES_JSON: toolstates-windows.json
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
# 32/64-bit MinGW builds.
#
@@ -414,7 +406,7 @@
--set rust.codegen-units=1
SCRIPT: python x.py build --set rust.debug=true opt-dist && PGO_HOST=x86_64-pc-windows-msvc ./build/x86_64-pc-windows-msvc/stage0-tools-bin/opt-dist windows-ci -- python x.py dist bootstrap --include-default-paths
DIST_REQUIRE_ALL_TOOLS: 1
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
- image: dist-i686-msvc
env:
@@ -426,7 +418,7 @@
--enable-profiler
SCRIPT: python x.py dist bootstrap --include-default-paths
DIST_REQUIRE_ALL_TOOLS: 1
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
- image: dist-aarch64-msvc
env:
@@ -437,7 +429,7 @@
--enable-profiler
SCRIPT: python x.py dist bootstrap --include-default-paths
DIST_REQUIRE_ALL_TOOLS: 1
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
- image: dist-i686-mingw
env:
@@ -471,4 +463,4 @@
env:
RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended --enable-profiler
SCRIPT: python x.py dist bootstrap --include-default-paths
- <<: *job-windows-2019-8c
+ <<: *job-windows-8c
diff --git a/src/ci/scripts/install-clang.sh b/src/ci/scripts/install-clang.sh
index aa7ff81..24b9904 100755
--- a/src/ci/scripts/install-clang.sh
+++ b/src/ci/scripts/install-clang.sh
@@ -10,18 +10,24 @@
source "$(cd "$(dirname "$0")" && pwd)/../shared.sh"
# Update both macOS's and Windows's tarballs when bumping the version here.
-LLVM_VERSION="14.0.5"
+# Try to keep this in sync with src/ci/docker/host-x86_64/dist-x86_64-linux/build-clang.sh
+LLVM_VERSION="18.1.4"
if isMacOS; then
+ # FIXME: This is the latest pre-built version of LLVM that's available for
+ # x86_64 MacOS. We may want to consider bulding our own LLVM binaries
+ # instead, or set `USE_XCODE_CLANG` like AArch64 does.
+ LLVM_VERSION="15.0.7"
+
# If the job selects a specific Xcode version, use that instead of
# downloading our own version.
if [[ ${USE_XCODE_CLANG-0} -eq 1 ]]; then
bindir="$(xcode-select --print-path)/Toolchains/XcodeDefault.xctoolchain/usr/bin"
else
- file="${MIRRORS_BASE}/clang%2Bllvm-${LLVM_VERSION}-x86_64-apple-darwin.tar.xz"
- retry curl -f "${file}" -o "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin.tar.xz"
- tar xJf "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin.tar.xz"
- bindir="$(pwd)/clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin/bin"
+ file="${MIRRORS_BASE}/clang%2Bllvm-${LLVM_VERSION}-x86_64-apple-darwin21.0.tar.xz"
+ retry curl -f "${file}" -o "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin21.0.tar.xz"
+ tar xJf "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin21.0.tar.xz"
+ bindir="$(pwd)/clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin21.0/bin"
fi
ciCommandSetEnv CC "${bindir}/clang"
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index daf6399..c464820 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -150,7 +150,7 @@
let generics = tcx.generics_of(item_def_id);
let params: ThinVec<_> = generics
- .params
+ .own_params
.iter()
.inspect(|param| {
if cfg!(debug_assertions) {
@@ -326,7 +326,7 @@
}
let region_params: FxIndexSet<_> = generics
- .params
+ .own_params
.iter()
.filter_map(|param| match param.kind {
ty::GenericParamDefKind::Lifetime => Some(param.name),
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 1f84c9d..90f2e3d 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -795,7 +795,7 @@
let mut impl_trait = BTreeMap::<u32, Vec<GenericBound>>::default();
let params: ThinVec<_> = gens
- .params
+ .own_params
.iter()
.filter(|param| match param.kind {
ty::GenericParamDefKind::Lifetime => !param.is_anonymous_lifetime(),
@@ -1988,7 +1988,7 @@
let generics = tcx.generics_of(container);
debug_assert_eq!(generics.parent_count, 0);
- let param = generics.params[index].def_id;
+ let param = generics.own_params[index].def_id;
let default = tcx.object_lifetime_default(param);
match default {
rbv::ObjectLifetimeDefault::Param(lifetime) => {
diff --git a/src/tools/clippy/clippy_lints/src/default_union_representation.rs b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
index 3f87ed8..b4290b6 100644
--- a/src/tools/clippy/clippy_lints/src/default_union_representation.rs
+++ b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
@@ -2,7 +2,7 @@
use rustc_hir::{HirId, Item, ItemKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, FieldDef, GenericArg, List};
+use rustc_middle::ty::{self, FieldDef};
use rustc_session::declare_lint_pass;
use rustc_span::sym;
@@ -85,7 +85,7 @@
}
}
-fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: &'tcx List<GenericArg<'tcx>>) -> bool {
+fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: ty::GenericArgsRef<'tcx>) -> bool {
let ty = field.ty(cx.tcx, args);
if let Ok(layout) = cx.layout_of(ty) {
layout.is_zst()
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index b936b28..c6aef9a 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -382,7 +382,7 @@
cx,
impl_ty,
trait_id,
- &args[..cx.tcx.generics_of(trait_id).params.len() - 1],
+ &args[..cx.tcx.generics_of(trait_id).own_params.len() - 1],
)
{
false
diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs
index 42cd19f..9662c8f 100644
--- a/src/tools/clippy/clippy_lints/src/derive.rs
+++ b/src/tools/clippy/clippy_lints/src/derive.rs
@@ -480,7 +480,7 @@
// Vec<(param_def, needs_eq)>
let mut params = tcx
.generics_of(did)
- .params
+ .own_params
.iter()
.map(|p| (p, matches!(p.kind, GenericParamDefKind::Type { .. })))
.collect::<Vec<_>>();
diff --git a/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs b/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs
index 3bf8d61..dc935ed 100644
--- a/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/src/tools/clippy/clippy_lints/src/implied_bounds_in_impls.rs
@@ -148,7 +148,7 @@
match args.get(index - 1) {
Some(GenericArg::Type(ty)) => Some(lower_ty(tcx, ty)),
Some(_) => None,
- None => Some(tcx.type_of(generics.params[index].def_id).skip_binder()),
+ None => Some(tcx.type_of(generics.own_params[index].def_id).skip_binder()),
}
}
diff --git a/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs b/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
index c749a71..a75dfaf 100644
--- a/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
+++ b/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
@@ -225,7 +225,7 @@
&& let ImplItemKind::Fn(sig, _) = item.kind
&& let FnRetTy::Return(ret) = sig.decl.output
&& is_nameable_in_impl_trait(ret)
- && cx.tcx.generics_of(item_did).params.is_empty()
+ && cx.tcx.generics_of(item_did).own_params.is_empty()
&& sig.decl.implicit_self == expected_implicit_self
&& sig.decl.inputs.len() == 1
&& let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id())
diff --git a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 10c3203..f775ea0 100644
--- a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -6,7 +6,7 @@
use rustc_hir::intravisit::{walk_expr, Visitor};
use rustc_hir::{Arm, Expr, ExprKind, MatchSource};
use rustc_lint::{LateContext, LintContext};
-use rustc_middle::ty::{GenericArgKind, Ty, TypeAndMut};
+use rustc_middle::ty::{GenericArgKind, Ty};
use rustc_span::Span;
use super::SIGNIFICANT_DROP_IN_SCRUTINEE;
@@ -234,9 +234,9 @@
}
let ty = self.sig_drop_checker.get_type(expr);
if ty.is_ref() {
- // We checked that the type was ref, so builtin_deref will return Some TypeAndMut,
- // but let's avoid any chance of an ICE
- if let Some(TypeAndMut { ty, .. }) = ty.builtin_deref(true) {
+ // We checked that the type was ref, so builtin_deref will return Some,
+ // but let's avoid any chance of an ICE.
+ if let Some(ty) = ty.builtin_deref(true) {
if ty.is_trivially_pure_clone_copy() {
self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndDerefToCopy);
} else if allow_move_and_clone {
diff --git a/src/tools/clippy/clippy_lints/src/mismatching_type_param_order.rs b/src/tools/clippy/clippy_lints/src/mismatching_type_param_order.rs
index 0842a87..934b9f4 100644
--- a/src/tools/clippy/clippy_lints/src/mismatching_type_param_order.rs
+++ b/src/tools/clippy/clippy_lints/src/mismatching_type_param_order.rs
@@ -76,7 +76,7 @@
};
// get the names of the generic parameters in the type
- let type_params = &cx.tcx.generics_of(defid).params;
+ let type_params = &cx.tcx.generics_of(defid).own_params;
let type_param_names: Vec<_> = type_params
.iter()
.filter_map(|p| match p.kind {
diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
index a24cd4f..e6c6a15 100644
--- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -13,7 +13,7 @@
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::mir::{Rvalue, StatementKind};
use rustc_middle::ty::{
- self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, List, ParamTy, ProjectionPredicate, Ty,
+ self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, ParamTy, ProjectionPredicate, Ty,
};
use rustc_session::impl_lint_pass;
use rustc_span::symbol::sym;
@@ -161,7 +161,7 @@
cx: &LateContext<'tcx>,
possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
fn_id: DefId,
- callee_args: &'tcx List<GenericArg<'tcx>>,
+ callee_args: ty::GenericArgsRef<'tcx>,
arg_index: usize,
param_ty: ParamTy,
mut expr: &Expr<'tcx>,
diff --git a/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs b/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs
index ea8ed28..208b20a 100644
--- a/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs
@@ -70,7 +70,7 @@
let without_deref = symmetric_partial_eq(cx, arg_ty, other_ty).unwrap_or_default();
let with_deref = arg_ty
.builtin_deref(true)
- .and_then(|tam| symmetric_partial_eq(cx, tam.ty, other_ty))
+ .and_then(|ty| symmetric_partial_eq(cx, ty, other_ty))
.unwrap_or_default();
if !with_deref.is_implemented() && !without_deref.is_implemented() {
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 325c9be..d8d26e2 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -134,7 +134,7 @@
) => Err((span, "function pointer casts are not allowed in const fn".into())),
Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::Unsize), op, cast_ty) => {
let pointee_ty = if let Some(deref_ty) = cast_ty.builtin_deref(true) {
- deref_ty.ty
+ deref_ty
} else {
// We cannot allow this for now.
return Err((span, "unsizing casts are only allowed for references right now".into()));
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
index 23750ed..97bba86 100644
--- a/src/tools/clippy/clippy_utils/src/ty.rs
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -10,7 +10,6 @@
use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
use rustc_hir::def_id::DefId;
use rustc_hir::{Expr, FnDecl, LangItem, TyKind, Unsafety};
-use rustc_infer::infer::type_variable::TypeVariableOrigin;
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::LateContext;
use rustc_middle::mir::interpret::Scalar;
@@ -19,7 +18,7 @@
use rustc_middle::ty::layout::ValidityRequirement;
use rustc_middle::ty::{
self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
- GenericParamDefKind, IntTy, List, ParamEnv, Region, RegionKind, ToPredicate, TraitRef, Ty, TyCtxt,
+ GenericParamDefKind, IntTy, ParamEnv, Region, RegionKind, ToPredicate, TraitRef, Ty, TyCtxt,
TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, VariantDef, VariantDiscr,
};
use rustc_span::symbol::Ident;
@@ -276,11 +275,7 @@
.into_iter()
.map(|arg| {
arg.into().unwrap_or_else(|| {
- let orig = TypeVariableOrigin {
- span: DUMMY_SP,
- param_def_id: None,
- };
- infcx.next_ty_var(orig).into()
+ infcx.next_ty_var(DUMMY_SP).into()
})
})
.collect::<Vec<_>>();
@@ -961,7 +956,11 @@
impl AdtVariantInfo {
/// Returns ADT variants ordered by size
- pub fn new<'tcx>(cx: &LateContext<'tcx>, adt: AdtDef<'tcx>, subst: &'tcx List<GenericArg<'tcx>>) -> Vec<Self> {
+ pub fn new<'tcx>(
+ cx: &LateContext<'tcx>,
+ adt: AdtDef<'tcx>,
+ subst: GenericArgsRef<'tcx>
+ ) -> Vec<Self> {
let mut variants_size = adt
.variants()
.iter()
@@ -1070,11 +1069,11 @@
fn assert_generic_args_match<'tcx>(tcx: TyCtxt<'tcx>, did: DefId, args: &[GenericArg<'tcx>]) {
let g = tcx.generics_of(did);
let parent = g.parent.map(|did| tcx.generics_of(did));
- let count = g.parent_count + g.params.len();
+ let count = g.parent_count + g.own_params.len();
let params = parent
- .map_or([].as_slice(), |p| p.params.as_slice())
+ .map_or([].as_slice(), |p| p.own_params.as_slice())
.iter()
- .chain(&g.params)
+ .chain(&g.own_params)
.map(|x| &x.kind);
assert!(
diff --git a/src/tools/clippy/clippy_utils/src/ty/type_certainty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/type_certainty/mod.rs
index 2241494..c2ff199 100644
--- a/src/tools/clippy/clippy_utils/src/ty/type_certainty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/type_certainty/mod.rs
@@ -176,7 +176,7 @@
.get(*lang_item)
.map_or(Certainty::Uncertain, |def_id| {
let generics = cx.tcx.generics_of(def_id);
- if generics.parent_count == 0 && generics.params.is_empty() {
+ if generics.parent_count == 0 && generics.own_params.is_empty() {
Certainty::Certain(if resolves_to_type { Some(def_id) } else { None })
} else {
Certainty::Uncertain
@@ -206,7 +206,7 @@
// Checking `res_generics_def_id(..)` before calling `generics_of` avoids an ICE.
if cx.tcx.res_generics_def_id(path_segment.res).is_some() {
let generics = cx.tcx.generics_of(def_id);
- let count = generics.params.len() - usize::from(generics.host_effect_index.is_some());
+ let count = generics.own_params.len() - usize::from(generics.host_effect_index.is_some());
let lhs = if (parent_certainty.is_certain() || generics.parent_count == 0) && count == 0 {
Certainty::Certain(None)
} else {
@@ -299,7 +299,7 @@
let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
// Check that all type parameters appear in the functions input types.
- (0..(generics.parent_count + generics.params.len()) as u32).all(|index| {
+ (0..(generics.parent_count + generics.own_params.len()) as u32).all(|index| {
Some(index as usize) == generics.host_effect_index
|| fn_sig
.inputs()
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index 42159b1..c7c807d 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -932,6 +932,8 @@
"test-mir-pass",
"unset-exec-env",
"unset-rustc-env",
+ // Used by the tidy check `unknown_revision`.
+ "unused-revision-names",
// tidy-alphabetical-end
];
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index a6dd1d8..3da8744 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -136,7 +136,7 @@
cx: &crate::MiriInterpCx<'_, 'tcx>,
) -> Self {
// `ty` is not the `Box` but the field of the Box with this pointer (due to allocator handling).
- let pointee = ty.builtin_deref(true).unwrap().ty;
+ let pointee = ty.builtin_deref(true).unwrap();
if pointee.is_unpin(*cx.tcx, cx.param_env()) {
// A regular box. On `FnEntry` this is `noalias`, but not `dereferenceable` (hence only
// a weak protector).
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index fc5eb94..b5bf16d 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -173,7 +173,7 @@
cx: &crate::MiriInterpCx<'_, 'tcx>,
zero_size: bool,
) -> Option<Self> {
- let pointee = ty.builtin_deref(true).unwrap().ty;
+ let pointee = ty.builtin_deref(true).unwrap();
pointee.is_unpin(*cx.tcx, cx.param_env()).then_some(()).map(|()| {
// Regular `Unpin` box, give it `noalias` but only a weak protector
// because it is valid to deallocate it within the function.
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index effd7f6..9e7fc7a 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -117,7 +117,7 @@
"write_bytes" | "volatile_set_memory" => {
let [ptr, val_byte, count] = check_arg_count(args)?;
- let ty = ptr.layout.ty.builtin_deref(true).unwrap().ty;
+ let ty = ptr.layout.ty.builtin_deref(true).unwrap();
let ty_layout = this.layout_of(ty)?;
let val_byte = this.read_scalar(val_byte)?.to_u8()?;
let ptr = this.read_pointer(ptr)?;
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 3be98d7..d0a7842 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -267,7 +267,7 @@
Op::WrappingOffset => {
let ptr = left.to_scalar().to_pointer(this)?;
let offset_count = right.to_scalar().to_target_isize(this)?;
- let pointee_ty = left.layout.ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = left.layout.ty.builtin_deref(true).unwrap();
let pointee_size = i64::try_from(this.layout_of(pointee_ty)?.size.bytes()).unwrap();
let offset_bytes = offset_count.wrapping_mul(pointee_size);
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 595cf64..aaf4724 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -378,8 +378,7 @@
.builtin_deref(true)
.ok_or_else(|| err_ub_format!(
"wrong signature used for `pthread_key_create`: first argument must be a raw pointer."
- ))?
- .ty;
+ ))?;
let key_layout = this.layout_of(key_type)?;
// Create key and write it into the memory where `key_ptr` wants it.
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_different_ints.rs b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_different_ints.rs
new file mode 100644
index 0000000..57b4fd0
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_different_ints.rs
@@ -0,0 +1,21 @@
+#![feature(strict_provenance)]
+use core::ptr;
+
+fn main() {
+ unsafe {
+ let base = ptr::without_provenance::<()>(10);
+ let unit = &*base;
+ let p1 = unit as *const ();
+
+ let base = ptr::without_provenance::<()>(11);
+ let unit = &*base;
+ let p2 = unit as *const ();
+
+ // Seems to work because they are same pointer
+ // even though it's dangling.
+ let _ = p1.byte_offset_from(p1);
+
+ // UB because different pointers.
+ let _ = p1.byte_offset_from(p2); //~ERROR: different pointers without provenance
+ }
+}
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_different_ints.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_different_ints.stderr
new file mode 100644
index 0000000..6e9e563
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_different_ints.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: `ptr_offset_from` called on different pointers without provenance (i.e., without an associated allocation)
+ --> $DIR/ptr_offset_from_different_ints.rs:LL:CC
+ |
+LL | let _ = p1.byte_offset_from(p2);
+ | ^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from` called on different pointers without provenance (i.e., without an associated allocation)
+ |
+ = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+ = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+ = note: BACKTRACE:
+ = note: inside `main` at $DIR/ptr_offset_from_different_ints.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/opt-dist/Cargo.toml b/src/tools/opt-dist/Cargo.toml
index 4cb6acb..1ff410e 100644
--- a/src/tools/opt-dist/Cargo.toml
+++ b/src/tools/opt-dist/Cargo.toml
@@ -16,7 +16,7 @@
reqwest = { version = "0.11", features = ["blocking"] }
zip = { version = "0.6", default-features = false, features = ["deflate"] }
tar = "0.4"
-xz = "0.1"
+xz = { version = "0.1", package = "xz2" }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
glob = "0.3"
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index dd949e2..d9fd029 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -6,8 +6,8 @@
use chalk_ir::{AdtId, FloatTy, IntTy, TyKind, UintTy};
use hir_def::{
layout::{
- Abi, FieldsShape, Integer, LayoutCalculator, LayoutS, Primitive, ReprOptions, Scalar, Size,
- StructKind, TargetDataLayout, WrappingRange,
+ Abi, FieldsShape, Float, Integer, LayoutCalculator, LayoutS, Primitive, ReprOptions,
+ Scalar, Size, StructKind, TargetDataLayout, WrappingRange,
},
LocalFieldId, StructId,
};
@@ -264,10 +264,10 @@
),
chalk_ir::Scalar::Float(f) => scalar(
dl,
- match f {
- FloatTy::F32 => Primitive::F32,
- FloatTy::F64 => Primitive::F64,
- },
+ Primitive::Float(match f {
+ FloatTy::F32 => Float::F32,
+ FloatTy::F64 => Float::F64,
+ }),
),
},
TyKind::Tuple(len, tys) => {
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index f4ae7b0..e87950b 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -245,8 +245,6 @@
run-make/rmeta-preferred/Makefile
run-make/rustc-macro-dep-files/Makefile
run-make/rustdoc-io-error/Makefile
-run-make/rustdoc-map-file/Makefile
-run-make/rustdoc-output-path/Makefile
run-make/rustdoc-scrape-examples-invalid-expr/Makefile
run-make/rustdoc-scrape-examples-macros/Makefile
run-make/rustdoc-scrape-examples-multiple/Makefile
diff --git a/src/tools/tidy/src/iter_header.rs b/src/tools/tidy/src/iter_header.rs
index ae63590..684c789 100644
--- a/src/tools/tidy/src/iter_header.rs
+++ b/src/tools/tidy/src/iter_header.rs
@@ -3,6 +3,7 @@
/// A header line, like `//@name: value` consists of the prefix `//@` and the directive
/// `name: value`. It is also possibly revisioned, e.g. `//@[revision] name: value`.
pub(crate) struct HeaderLine<'ln> {
+ pub(crate) line_number: usize,
pub(crate) revision: Option<&'ln str>,
pub(crate) directive: &'ln str,
}
@@ -11,7 +12,7 @@
///
/// Adjusted from compiletest/src/header.rs.
pub(crate) fn iter_header<'ln>(contents: &'ln str, it: &mut dyn FnMut(HeaderLine<'ln>)) {
- for ln in contents.lines() {
+ for (line_number, ln) in (1..).zip(contents.lines()) {
let ln = ln.trim();
// We're left with potentially `[rev]name: value`.
@@ -24,9 +25,9 @@
panic!("malformed revision directive: expected `//@[rev]`, found `{ln}`");
};
// We trimmed off the `[rev]` portion, left with `name: value`.
- it(HeaderLine { revision: Some(revision), directive: remainder.trim() });
+ it(HeaderLine { line_number, revision: Some(revision), directive: remainder.trim() });
} else {
- it(HeaderLine { revision: None, directive: remainder.trim() });
+ it(HeaderLine { line_number, revision: None, directive: remainder.trim() });
}
}
}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index c15081a..ae9d2b8 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -87,6 +87,7 @@
pub mod tests_revision_unpaired_stdout_stderr;
pub mod ui_tests;
pub mod unit_tests;
+pub mod unknown_revision;
pub mod unstable_book;
pub mod walk;
pub mod x_version;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 7769181..1d2b2e4 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -110,6 +110,7 @@
check!(rustdoc_gui_tests, &tests_path);
check!(rustdoc_css_themes, &librustdoc_path);
check!(known_bug, &crashes_path);
+ check!(unknown_revision, &tests_path);
// Checks that only make sense for the compiler.
check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], verbose);
diff --git a/src/tools/tidy/src/target_specific_tests.rs b/src/tools/tidy/src/target_specific_tests.rs
index cb242bf..c876aae 100644
--- a/src/tools/tidy/src/target_specific_tests.rs
+++ b/src/tools/tidy/src/target_specific_tests.rs
@@ -20,7 +20,7 @@
crate::walk::walk(path, |path, _is_dir| filter_not_rust(path), &mut |entry, content| {
let file = entry.path().display();
let mut header_map = BTreeMap::new();
- iter_header(content, &mut |HeaderLine { revision, directive }| {
+ iter_header(content, &mut |HeaderLine { revision, directive, .. }| {
if let Some(value) = directive.strip_prefix(LLVM_COMPONENTS_HEADER) {
let info = header_map.entry(revision).or_insert(RevisionInfo::default());
let comp_vec = info.llvm_components.get_or_insert(Vec::new());
diff --git a/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs b/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
index a0773c8..00edf99 100644
--- a/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
+++ b/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
@@ -61,7 +61,7 @@
let contents = std::fs::read_to_string(test).unwrap();
// Collect directives.
- iter_header(&contents, &mut |HeaderLine { revision, directive }| {
+ iter_header(&contents, &mut |HeaderLine { revision, directive, .. }| {
// We're trying to *find* `//@ revision: xxx` directives themselves, not revisioned
// directives.
if revision.is_some() {
diff --git a/src/tools/tidy/src/unknown_revision.rs b/src/tools/tidy/src/unknown_revision.rs
new file mode 100644
index 0000000..abfff1d
--- /dev/null
+++ b/src/tools/tidy/src/unknown_revision.rs
@@ -0,0 +1,114 @@
+//! Checks that test revision names appearing in header directives and error
+//! annotations have actually been declared in `revisions`.
+
+// FIXME(jieyouxu) Ideally these checks would be integrated into compiletest's
+// own directive and revision handling, but for now they've been split out as a
+// separate `tidy` check to avoid making compiletest even messier.
+
+use std::collections::{BTreeSet, HashMap, HashSet};
+use std::path::Path;
+use std::sync::OnceLock;
+
+use ignore::DirEntry;
+use regex::Regex;
+
+use crate::iter_header::{iter_header, HeaderLine};
+use crate::walk::{filter_dirs, filter_not_rust, walk};
+
+pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
+ walk(
+ tests_path.as_ref(),
+ |path, is_dir| {
+ filter_dirs(path) || filter_not_rust(path) || {
+ // Auxiliary source files for incremental tests can refer to revisions
+ // declared by the main file, which this check doesn't handle.
+ is_dir && path.file_name().is_some_and(|name| name == "auxiliary")
+ }
+ },
+ &mut |entry, contents| visit_test_file(entry, contents, bad),
+ );
+}
+
+fn visit_test_file(entry: &DirEntry, contents: &str, bad: &mut bool) {
+ let mut revisions = HashSet::new();
+ let mut unused_revision_names = HashSet::new();
+
+ // Maps each mentioned revision to the first line it was mentioned on.
+ let mut mentioned_revisions = HashMap::<&str, usize>::new();
+ let mut add_mentioned_revision = |line_number: usize, revision| {
+ let first_line = mentioned_revisions.entry(revision).or_insert(line_number);
+ *first_line = (*first_line).min(line_number);
+ };
+
+ // Scan all `//@` headers to find declared revisions and mentioned revisions.
+ iter_header(contents, &mut |HeaderLine { line_number, revision, directive }| {
+ if let Some(revs) = directive.strip_prefix("revisions:") {
+ revisions.extend(revs.split_whitespace());
+ } else if let Some(revs) = directive.strip_prefix("unused-revision-names:") {
+ unused_revision_names.extend(revs.split_whitespace());
+ }
+
+ if let Some(revision) = revision {
+ add_mentioned_revision(line_number, revision);
+ }
+ });
+
+ // If a wildcard appears in `unused-revision-names`, skip all revision name
+ // checking for this file.
+ if unused_revision_names.contains(&"*") {
+ return;
+ }
+
+ // Scan all `//[rev]~` error annotations to find mentioned revisions.
+ for_each_error_annotation_revision(contents, &mut |ErrorAnnRev { line_number, revision }| {
+ add_mentioned_revision(line_number, revision);
+ });
+
+ let path = entry.path().display();
+
+ // Fail if any revision names appear in both places, since that's probably a mistake.
+ for rev in revisions.intersection(&unused_revision_names).copied().collect::<BTreeSet<_>>() {
+ tidy_error!(
+ bad,
+ "revision name [{rev}] appears in both `revisions` and `unused-revision-names` in {path}"
+ );
+ }
+
+ // Compute the set of revisions that were mentioned but not declared,
+ // sorted by the first line number they appear on.
+ let mut bad_revisions = mentioned_revisions
+ .into_iter()
+ .filter(|(rev, _)| !revisions.contains(rev) && !unused_revision_names.contains(rev))
+ .map(|(rev, line_number)| (line_number, rev))
+ .collect::<Vec<_>>();
+ bad_revisions.sort();
+
+ for (line_number, rev) in bad_revisions {
+ tidy_error!(bad, "unknown revision [{rev}] at {path}:{line_number}");
+ }
+}
+
+struct ErrorAnnRev<'a> {
+ line_number: usize,
+ revision: &'a str,
+}
+
+fn for_each_error_annotation_revision<'a>(
+ contents: &'a str,
+ callback: &mut dyn FnMut(ErrorAnnRev<'a>),
+) {
+ let error_regex = {
+ // Simplified from the regex used by `parse_expected` in `src/tools/compiletest/src/errors.rs`,
+ // because we only care about extracting revision names.
+ static RE: OnceLock<Regex> = OnceLock::new();
+ RE.get_or_init(|| Regex::new(r"//\[(?<revs>[^]]*)\]~").unwrap())
+ };
+
+ for (line_number, line) in (1..).zip(contents.lines()) {
+ let Some(captures) = error_regex.captures(line) else { continue };
+
+ for revision in captures.name("revs").unwrap().as_str().split(',') {
+ callback(ErrorAnnRev { line_number, revision });
+ }
+ }
+}
diff --git a/tests/crashes/124702.rs b/tests/crashes/124702.rs
deleted file mode 100644
index e3767de..0000000
--- a/tests/crashes/124702.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ known-bug: rust-lang/rust#124702
-//@ compile-flags: -Znext-solver=coherence
-trait X {}
-
-trait Z {
- type Assoc: Y;
-}
-struct A<T>(T);
-
-impl<T: X> Z for A<T> {
- type Assoc = T;
-}
-
-impl<T> From<<A<A<T>> as Z>::Assoc> for T {}
diff --git a/tests/run-make/alloc-no-oom-handling/Makefile b/tests/run-make/alloc-no-oom-handling/Makefile
index 87f74c6..7c3ae90 100644
--- a/tests/run-make/alloc-no-oom-handling/Makefile
+++ b/tests/run-make/alloc-no-oom-handling/Makefile
@@ -1,3 +1,6 @@
+# This test checks that alloc can still compile correctly when the unstable no_global_oom_handling feature is turned on.
+# See https://github.com/rust-lang/rust/pull/84266
+
include ../tools.mk
all:
diff --git a/tests/run-make/alloc-no-rc/Makefile b/tests/run-make/alloc-no-rc/Makefile
index 9824b17..fcfe160 100644
--- a/tests/run-make/alloc-no-rc/Makefile
+++ b/tests/run-make/alloc-no-rc/Makefile
@@ -1,3 +1,6 @@
+# This test checks that alloc can still compile correctly when the unstable no_rc feature is turned on.
+# See https://github.com/rust-lang/rust/pull/89891
+
include ../tools.mk
all:
diff --git a/tests/run-make/alloc-no-sync/Makefile b/tests/run-make/alloc-no-sync/Makefile
index 04ec4c7..997dbcf 100644
--- a/tests/run-make/alloc-no-sync/Makefile
+++ b/tests/run-make/alloc-no-sync/Makefile
@@ -1,3 +1,6 @@
+# This test checks that alloc can still compile correctly when the unstable no_sync feature is turned on.
+# See https://github.com/rust-lang/rust/pull/89891
+
include ../tools.mk
all:
diff --git a/tests/run-make/allocator-shim-circular-deps/Makefile b/tests/run-make/allocator-shim-circular-deps/Makefile
index 4624b84..f667e2e 100644
--- a/tests/run-make/allocator-shim-circular-deps/Makefile
+++ b/tests/run-make/allocator-shim-circular-deps/Makefile
@@ -1,3 +1,8 @@
+# This test is designed to intentionally introduce a circular dependency scenario to check that a specific compiler bug doesn't make a resurgence.
+# The bug in question arose when at least one crate required a global allocator, and that crate was placed after the one defining it in the linker order.
+# The generated symbols.o should not result in any linker errors.
+# See https://github.com/rust-lang/rust/issues/112715
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/archive-duplicate-names/Makefile b/tests/run-make/archive-duplicate-names/Makefile
index 5433a42..207eee3 100644
--- a/tests/run-make/archive-duplicate-names/Makefile
+++ b/tests/run-make/archive-duplicate-names/Makefile
@@ -1,3 +1,7 @@
+# When two object archives with the same filename are present, an iterator is supposed to inspect each object, recognize the duplication and extract each one to a different directory.
+# This test checks that this duplicate handling behaviour has not been broken.
+# See https://github.com/rust-lang/rust/pull/24439
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/bare-outfile/Makefile b/tests/run-make/bare-outfile/Makefile
index 23b619e..ad6fe4b 100644
--- a/tests/run-make/bare-outfile/Makefile
+++ b/tests/run-make/bare-outfile/Makefile
@@ -1,3 +1,5 @@
+# This test checks that manually setting the output file as a bare file with no file extension still results in successful compilation.
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-dynamic-dylib/Makefile b/tests/run-make/c-dynamic-dylib/Makefile
index b5bfbc7..0d40964 100644
--- a/tests/run-make/c-dynamic-dylib/Makefile
+++ b/tests/run-make/c-dynamic-dylib/Makefile
@@ -1,3 +1,6 @@
+# This test checks that dynamic Rust linking with C does not encounter any errors, with dynamic dependencies given preference over static.
+# See https://github.com/rust-lang/rust/issues/10434
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-dynamic-rlib/Makefile b/tests/run-make/c-dynamic-rlib/Makefile
index 0475bd8..a64e89c 100644
--- a/tests/run-make/c-dynamic-rlib/Makefile
+++ b/tests/run-make/c-dynamic-rlib/Makefile
@@ -1,3 +1,6 @@
+# This test checks that dynamic Rust linking with C does not encounter any errors, with static dependencies given preference over dynamic. (This is the default behaviour.)
+# See https://github.com/rust-lang/rust/issues/10434
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-link-to-rust-dylib/Makefile b/tests/run-make/c-link-to-rust-dylib/Makefile
index 2763cb6e..201f717 100644
--- a/tests/run-make/c-link-to-rust-dylib/Makefile
+++ b/tests/run-make/c-link-to-rust-dylib/Makefile
@@ -1,3 +1,6 @@
+# This test checks that C linking with Rust does not encounter any errors, with dynamic libraries.
+# See https://github.com/rust-lang/rust/issues/10434
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-link-to-rust-staticlib/Makefile b/tests/run-make/c-link-to-rust-staticlib/Makefile
index e14775f..d36cc42 100644
--- a/tests/run-make/c-link-to-rust-staticlib/Makefile
+++ b/tests/run-make/c-link-to-rust-staticlib/Makefile
@@ -1,3 +1,6 @@
+# This test checks that C linking with Rust does not encounter any errors, with static libraries.
+# See https://github.com/rust-lang/rust/issues/10434
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-static-dylib/Makefile b/tests/run-make/c-static-dylib/Makefile
index 4e23edb..05da174 100644
--- a/tests/run-make/c-static-dylib/Makefile
+++ b/tests/run-make/c-static-dylib/Makefile
@@ -1,3 +1,6 @@
+# This test checks that static Rust linking with C does not encounter any errors, with dynamic dependencies given preference over static.
+# See https://github.com/rust-lang/rust/issues/10434
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-static-rlib/Makefile b/tests/run-make/c-static-rlib/Makefile
index 4e35112..298e432 100644
--- a/tests/run-make/c-static-rlib/Makefile
+++ b/tests/run-make/c-static-rlib/Makefile
@@ -1,3 +1,6 @@
+# This test checks that static Rust linking with C does not encounter any errors, with static dependencies given preference over dynamic. (This is the default behaviour.)
+# See https://github.com/rust-lang/rust/issues/10434
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile b/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile
index b8e0e94..2bb8d42 100644
--- a/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile
+++ b/tests/run-make/c-unwind-abi-catch-lib-panic/Makefile
@@ -1,3 +1,6 @@
+# Exercise unwinding a panic. This catches a panic across an FFI boundary and downcasts it into an integer. The Rust code that panics is in a separate crate.
+# See https://github.com/rust-lang/rust/commit/baf227ea0c1e07fc54395a51e4b3881d701180cb
+
# ignore-cross-compile
# needs-unwind
include ../tools.mk
diff --git a/tests/run-make/c-unwind-abi-catch-panic/Makefile b/tests/run-make/c-unwind-abi-catch-panic/Makefile
index 1760ddb..0a38d83 100644
--- a/tests/run-make/c-unwind-abi-catch-panic/Makefile
+++ b/tests/run-make/c-unwind-abi-catch-panic/Makefile
@@ -1,3 +1,6 @@
+# Exercise unwinding a panic. This catches a panic across an FFI boundary and downcasts it into an integer. The Rust code that panics is in the same directory.
+# See https://github.com/rust-lang/rust/commit/baf227ea0c1e07fc54395a51e4b3881d701180cb
+
# ignore-cross-compile
# needs-unwind
include ../tools.mk
diff --git a/tests/run-make/cat-and-grep-sanity-check/Makefile b/tests/run-make/cat-and-grep-sanity-check/Makefile
index 82351e2..8ee69c0 100644
--- a/tests/run-make/cat-and-grep-sanity-check/Makefile
+++ b/tests/run-make/cat-and-grep-sanity-check/Makefile
@@ -1,3 +1,7 @@
+# grep in run-make tests was partially replaced with a custom script, CGREP. This tests that CGREP does its job correctly.
+# See https://github.com/rust-lang/rust/commit/ab788a2ee175c7560f0ca58bbc183ecfd57d2f7a
+# FIXME(Oneirical): Note that this test will likely become useless after the port to rmake.rs tests (see https://github.com/rust-lang/rust/issues/121876)
+
include ../tools.mk
all:
diff --git a/tests/run-make/cdylib-dylib-linkage/Makefile b/tests/run-make/cdylib-dylib-linkage/Makefile
index 51fbfef..db8393d 100644
--- a/tests/run-make/cdylib-dylib-linkage/Makefile
+++ b/tests/run-make/cdylib-dylib-linkage/Makefile
@@ -1,3 +1,6 @@
+# This test checks that cdylibs can link against dylibs as dependencies, after this restriction was disabled.
+# See https://github.com/rust-lang/rust/commit/72aaa3a414d17aa0c4f19feafa5bab5f84b60e63
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/cdylib-fewer-symbols/Makefile b/tests/run-make/cdylib-fewer-symbols/Makefile
index 4e08f97..d587cec 100644
--- a/tests/run-make/cdylib-fewer-symbols/Makefile
+++ b/tests/run-make/cdylib-fewer-symbols/Makefile
@@ -1,6 +1,8 @@
# ignore-cross-compile
+
# Test that allocator-related symbols don't show up as exported from a cdylib as
# they're internal to Rust and not part of the public ABI.
+# See https://github.com/rust-lang/rust/commit/fbf98697021173a30b84d9145df0966a23a2f9d2
include ../tools.mk
diff --git a/tests/run-make/cdylib/Makefile b/tests/run-make/cdylib/Makefile
index 3c8b526..2c6414c 100644
--- a/tests/run-make/cdylib/Makefile
+++ b/tests/run-make/cdylib/Makefile
@@ -1,3 +1,6 @@
+# When the cdylib crate type was added as a variation of dylib, it needed a test to check its function.
+# See https://github.com/rust-lang/rust/pull/33553
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/codegen-options-parsing/Makefile b/tests/run-make/codegen-options-parsing/Makefile
index 56bb900..beaf233 100644
--- a/tests/run-make/codegen-options-parsing/Makefile
+++ b/tests/run-make/codegen-options-parsing/Makefile
@@ -1,3 +1,5 @@
+# This test intentionally feeds invalid inputs to codegen and checks if the error message outputs contain specific helpful indications.
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/comment-section/Makefile b/tests/run-make/comment-section/Makefile
index 9f81006..d0b9817 100644
--- a/tests/run-make/comment-section/Makefile
+++ b/tests/run-make/comment-section/Makefile
@@ -1,3 +1,6 @@
+# Both GCC and Clang write by default a `.comment` section with compiler information. Rustc received a similar .comment section, so this tests checks that this section properly appears.
+# See https://github.com/rust-lang/rust/commit/74b8d324eb77a8f337b35dc68ac91b0c2c06debc
+
include ../tools.mk
# only-linux
diff --git a/tests/run-make/compile-stdin/Makefile b/tests/run-make/compile-stdin/Makefile
index 2a49528..b3d7cc7 100644
--- a/tests/run-make/compile-stdin/Makefile
+++ b/tests/run-make/compile-stdin/Makefile
@@ -1,3 +1,6 @@
+# When provided standard input piped directly into rustc, this test checks that the compilation completes successfully and that the output can be executed.
+# See https://github.com/rust-lang/rust/pull/28805
+
# ignore-cross-compile
include ../tools.mk
diff --git a/tests/run-make/compiler-lookup-paths-2/Makefile b/tests/run-make/compiler-lookup-paths-2/Makefile
index d4ff7d8..ecc0577 100644
--- a/tests/run-make/compiler-lookup-paths-2/Makefile
+++ b/tests/run-make/compiler-lookup-paths-2/Makefile
@@ -1,3 +1,6 @@
+# This test checks that extern crate declarations in Cargo without a corresponding declaration in the manifest of a dependency are NOT allowed.
+# See https://github.com/rust-lang/rust/pull/21113
+
include ../tools.mk
all:
diff --git a/tests/run-make/compiler-lookup-paths/Makefile b/tests/run-make/compiler-lookup-paths/Makefile
index 310d677..fc0cbde 100644
--- a/tests/run-make/compiler-lookup-paths/Makefile
+++ b/tests/run-make/compiler-lookup-paths/Makefile
@@ -1,3 +1,6 @@
+# rustc supports different types of lookup paths, such as dependency, native or crate. This test checks that these lookup paths are functional and result in functional compilation.
+# See https://github.com/rust-lang/rust/pull/19941
+
include ../tools.mk
# ignore-wasm32 (need a C compiler)
diff --git a/tests/run-make/libtest-padding/Makefile b/tests/run-make/libtest-padding/Makefile
index 42bc119..c8e2fc0 100644
--- a/tests/run-make/libtest-padding/Makefile
+++ b/tests/run-make/libtest-padding/Makefile
@@ -2,7 +2,7 @@
# needs-unwind because #[bench] and -Cpanic=abort requires -Zpanic-abort-tests
include ../tools.mk
-NORMALIZE=sed 's%[0-9,]\{1,\} ns/iter (+/- [0-9,]\{1,\})%?? ns/iter (+/- ??)%' | sed 's%finished in [0-9\.]\{1,\}%finished in ??%'
+NORMALIZE=sed 's%[0-9,\.]\{1,\} ns/iter (+/- [0-9,\.]\{1,\})%?? ns/iter (+/- ??)%' | sed 's%finished in [0-9\.]\{1,\}%finished in ??%'
all:
$(RUSTC) --test tests.rs
diff --git a/tests/run-make/rustdoc-map-file/Makefile b/tests/run-make/rustdoc-map-file/Makefile
deleted file mode 100644
index 5cbf774..0000000
--- a/tests/run-make/rustdoc-map-file/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-include ../tools.mk
-
-all:
- $(RUSTDOC) -Z unstable-options --generate-redirect-map foo.rs -o "$(TMPDIR)/out"
- "$(PYTHON)" validate_json.py "$(TMPDIR)/out"
diff --git a/tests/run-make/rustdoc-map-file/rmake.rs b/tests/run-make/rustdoc-map-file/rmake.rs
new file mode 100644
index 0000000..aaa7fea
--- /dev/null
+++ b/tests/run-make/rustdoc-map-file/rmake.rs
@@ -0,0 +1,15 @@
+use run_make_support::{rustdoc, tmp_dir};
+use std::process::Command;
+
+fn main() {
+ let out_dir = tmp_dir().join("out");
+ rustdoc()
+ .input("foo.rs")
+ .arg("-Zunstable-options")
+ .arg("--generate-redirect-map")
+ .output(&out_dir)
+ .run();
+ // FIXME (GuillaumeGomez): Port the python script to Rust as well.
+ let python = std::env::var("PYTHON").unwrap_or("python".into());
+ assert!(Command::new(python).arg("validate_json.py").arg(&out_dir).status().unwrap().success());
+}
diff --git a/tests/run-make/rustdoc-output-path/Makefile b/tests/run-make/rustdoc-output-path/Makefile
deleted file mode 100644
index 8f5cda9..0000000
--- a/tests/run-make/rustdoc-output-path/Makefile
+++ /dev/null
@@ -1,4 +0,0 @@
-include ../tools.mk
-
-all:
- $(RUSTDOC) -o "$(TMPDIR)/foo/bar/doc" foo.rs
diff --git a/tests/run-make/rustdoc-output-path/rmake.rs b/tests/run-make/rustdoc-output-path/rmake.rs
new file mode 100644
index 0000000..74fb0a5
--- /dev/null
+++ b/tests/run-make/rustdoc-output-path/rmake.rs
@@ -0,0 +1,9 @@
+// Checks that if the output folder doesn't exist, rustdoc will create it.
+
+use run_make_support::{rustdoc, tmp_dir};
+
+fn main() {
+ let out_dir = tmp_dir().join("foo/bar/doc");
+ rustdoc().input("foo.rs").output(&out_dir).run();
+ assert!(out_dir.exists());
+}
diff --git a/tests/ui-fulldeps/pprust-expr-roundtrip.rs b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
index 475a69f..2b1fec9 100644
--- a/tests/ui-fulldeps/pprust-expr-roundtrip.rs
+++ b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
@@ -180,7 +180,10 @@
18 => {
let pat =
P(Pat { id: DUMMY_NODE_ID, kind: PatKind::Wild, span: DUMMY_SP, tokens: None });
- iter_exprs(depth - 1, &mut |e| g(ExprKind::Let(pat.clone(), e, DUMMY_SP, None)))
+ iter_exprs(
+ depth - 1,
+ &mut |e| g(ExprKind::Let(pat.clone(), e, DUMMY_SP, Recovered::No))
+ )
}
_ => panic!("bad counter value in iter_exprs"),
}
diff --git a/tests/ui/abi/debug.stderr b/tests/ui/abi/debug.stderr
index 00fc7d1..7365839 100644
--- a/tests/ui/abi/debug.stderr
+++ b/tests/ui/abi/debug.stderr
@@ -576,7 +576,9 @@
},
abi: Scalar(
Initialized {
- value: F32,
+ value: Float(
+ F32,
+ ),
valid_range: $FULL,
},
),
diff --git a/tests/ui/associated-types/bound-lifetime-constrained.ok.stderr b/tests/ui/associated-types/bound-lifetime-constrained.ok.stderr
new file mode 100644
index 0000000..9082044
--- /dev/null
+++ b/tests/ui/associated-types/bound-lifetime-constrained.ok.stderr
@@ -0,0 +1,8 @@
+error: fatal error triggered by #[rustc_error]
+ --> $DIR/bound-lifetime-constrained.rs:48:1
+ |
+LL | fn main() { }
+ | ^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/associated-types/bound-lifetime-constrained.rs b/tests/ui/associated-types/bound-lifetime-constrained.rs
index 880d350..1dc3b2f 100644
--- a/tests/ui/associated-types/bound-lifetime-constrained.rs
+++ b/tests/ui/associated-types/bound-lifetime-constrained.rs
@@ -1,4 +1,4 @@
-//@ revisions: func object clause
+//@ revisions: func object clause ok
#![allow(dead_code)]
#![feature(rustc_attrs)]
diff --git a/tests/ui/async-await/async-block-control-flow-static-semantics.rs b/tests/ui/async-await/async-block-control-flow-static-semantics.rs
index 0ef7cb7..6e04c53 100644
--- a/tests/ui/async-await/async-block-control-flow-static-semantics.rs
+++ b/tests/ui/async-await/async-block-control-flow-static-semantics.rs
@@ -29,14 +29,14 @@
fn no_break_in_async_block() {
async {
- break 0u8; //~ ERROR `break` inside of an `async` block
+ break 0u8; //~ ERROR `break` inside `async` block
};
}
fn no_break_in_async_block_even_with_outer_loop() {
loop {
async {
- break 0u8; //~ ERROR `break` inside of an `async` block
+ break 0u8; //~ ERROR `break` inside `async` block
};
}
}
diff --git a/tests/ui/async-await/async-block-control-flow-static-semantics.stderr b/tests/ui/async-await/async-block-control-flow-static-semantics.stderr
index c89671c..ce0d003 100644
--- a/tests/ui/async-await/async-block-control-flow-static-semantics.stderr
+++ b/tests/ui/async-await/async-block-control-flow-static-semantics.stderr
@@ -1,18 +1,18 @@
-error[E0267]: `break` inside of an `async` block
+error[E0267]: `break` inside `async` block
--> $DIR/async-block-control-flow-static-semantics.rs:32:9
|
LL | / async {
LL | | break 0u8;
- | | ^^^^^^^^^ cannot `break` inside of an `async` block
+ | | ^^^^^^^^^ cannot `break` inside `async` block
LL | | };
| |_____- enclosing `async` block
-error[E0267]: `break` inside of an `async` block
+error[E0267]: `break` inside `async` block
--> $DIR/async-block-control-flow-static-semantics.rs:39:13
|
LL | / async {
LL | | break 0u8;
- | | ^^^^^^^^^ cannot `break` inside of an `async` block
+ | | ^^^^^^^^^ cannot `break` inside `async` block
LL | | };
| |_________- enclosing `async` block
diff --git a/tests/ui/attributes/nonterminal-expansion.rs b/tests/ui/attributes/nonterminal-expansion.rs
index 6db7aea..1b2e92a 100644
--- a/tests/ui/attributes/nonterminal-expansion.rs
+++ b/tests/ui/attributes/nonterminal-expansion.rs
@@ -5,7 +5,7 @@
macro_rules! pass_nonterminal {
($n:expr) => {
#[repr(align($n))]
- //~^ ERROR expected unsuffixed literal or identifier, found `n!()`
+ //~^ ERROR expected unsuffixed literal, found `n!()`
struct S;
};
}
diff --git a/tests/ui/attributes/nonterminal-expansion.stderr b/tests/ui/attributes/nonterminal-expansion.stderr
index 7854149..b640575 100644
--- a/tests/ui/attributes/nonterminal-expansion.stderr
+++ b/tests/ui/attributes/nonterminal-expansion.stderr
@@ -1,4 +1,4 @@
-error: expected unsuffixed literal or identifier, found `n!()`
+error: expected unsuffixed literal, found `n!()`
--> $DIR/nonterminal-expansion.rs:7:22
|
LL | #[repr(align($n))]
diff --git a/tests/ui/borrowck/two-phase-activation-sharing-interference.nll_target.stderr b/tests/ui/borrowck/two-phase-activation-sharing-interference.nll_target.stderr
index aacf178..6cd64c5 100644
--- a/tests/ui/borrowck/two-phase-activation-sharing-interference.nll_target.stderr
+++ b/tests/ui/borrowck/two-phase-activation-sharing-interference.nll_target.stderr
@@ -1,5 +1,5 @@
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
- --> $DIR/two-phase-activation-sharing-interference.rs:28:15
+ --> $DIR/two-phase-activation-sharing-interference.rs:29:15
|
LL | let y = &mut x;
| ------ mutable borrow occurs here
@@ -10,7 +10,7 @@
| ------- mutable borrow later used here
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
- --> $DIR/two-phase-activation-sharing-interference.rs:36:13
+ --> $DIR/two-phase-activation-sharing-interference.rs:37:13
|
LL | let y = &mut x;
| ------ mutable borrow occurs here
@@ -32,7 +32,7 @@
| ------- mutable borrow later used here
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
- --> $DIR/two-phase-activation-sharing-interference.rs:58:14
+ --> $DIR/two-phase-activation-sharing-interference.rs:56:14
|
LL | let y = &mut x;
| ------ mutable borrow occurs here
diff --git a/tests/ui/borrowck/two-phase-activation-sharing-interference.rs b/tests/ui/borrowck/two-phase-activation-sharing-interference.rs
index beee991..1b4526a 100644
--- a/tests/ui/borrowck/two-phase-activation-sharing-interference.rs
+++ b/tests/ui/borrowck/two-phase-activation-sharing-interference.rs
@@ -1,6 +1,7 @@
//@ revisions: nll_target
// The following revisions are disabled due to missing support from two-phase beyond autorefs
+//@ unused-revision-names: nll_beyond
//@[nll_beyond] compile-flags: -Z two-phase-beyond-autoref
// This is an important corner case pointed out by Niko: one is
@@ -36,8 +37,7 @@
let z = &x;
//[nll_target]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
*y += 1;
- //[lxl_beyond]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
- //[nll_beyond]~^^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+ //[nll_beyond]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
read(z);
}
@@ -48,8 +48,6 @@
//[nll_target]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
read(z);
*y += 1;
- //[lxl_beyond]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
- // (okay with (generalized) nll today)
}
fn should_also_eventually_be_ok_with_nll() {
@@ -58,8 +56,6 @@
let _z = &x;
//[nll_target]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
*y += 1;
- //[lxl_beyond]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
- // (okay with (generalized) nll today)
}
fn main() { }
diff --git a/tests/ui/borrowck/two-phase-allow-access-during-reservation.nll_target.stderr b/tests/ui/borrowck/two-phase-allow-access-during-reservation.nll_target.stderr
index 1356c80..b7a1de0 100644
--- a/tests/ui/borrowck/two-phase-allow-access-during-reservation.nll_target.stderr
+++ b/tests/ui/borrowck/two-phase-allow-access-during-reservation.nll_target.stderr
@@ -1,5 +1,5 @@
error[E0503]: cannot use `i` because it was mutably borrowed
- --> $DIR/two-phase-allow-access-during-reservation.rs:26:19
+ --> $DIR/two-phase-allow-access-during-reservation.rs:27:19
|
LL | /*1*/ let p = &mut i; // (reservation of `i` starts here)
| ------ `i` is borrowed here
@@ -11,7 +11,7 @@
| ------- borrow later used here
error[E0503]: cannot use `i` because it was mutably borrowed
- --> $DIR/two-phase-allow-access-during-reservation.rs:31:19
+ --> $DIR/two-phase-allow-access-during-reservation.rs:32:19
|
LL | /*1*/ let p = &mut i; // (reservation of `i` starts here)
| ------ `i` is borrowed here
diff --git a/tests/ui/borrowck/two-phase-allow-access-during-reservation.rs b/tests/ui/borrowck/two-phase-allow-access-during-reservation.rs
index e6b2501..6b5a2f5 100644
--- a/tests/ui/borrowck/two-phase-allow-access-during-reservation.rs
+++ b/tests/ui/borrowck/two-phase-allow-access-during-reservation.rs
@@ -1,6 +1,7 @@
//@ revisions: nll_target
// The following revisions are disabled due to missing support for two_phase_beyond_autoref
+//@ unused-revision-names: nll_beyond
//@[nll_beyond] compile-flags: -Z two_phase_beyond_autoref
// This is the second counter-example from Niko's blog post
diff --git a/tests/ui/borrowck/two-phase-nonrecv-autoref.base.stderr b/tests/ui/borrowck/two-phase-nonrecv-autoref.base.stderr
index e122977..c9d49b8 100644
--- a/tests/ui/borrowck/two-phase-nonrecv-autoref.base.stderr
+++ b/tests/ui/borrowck/two-phase-nonrecv-autoref.base.stderr
@@ -1,5 +1,5 @@
error[E0499]: cannot borrow `*f` as mutable more than once at a time
- --> $DIR/two-phase-nonrecv-autoref.rs:50:11
+ --> $DIR/two-phase-nonrecv-autoref.rs:51:11
|
LL | f(f(10));
| - ^ second mutable borrow occurs here
@@ -8,7 +8,7 @@
| first borrow later used by call
error[E0382]: use of moved value: `f`
- --> $DIR/two-phase-nonrecv-autoref.rs:57:11
+ --> $DIR/two-phase-nonrecv-autoref.rs:58:11
|
LL | fn twice_ten_so<F: FnOnce(i32) -> i32>(f: Box<F>) {
| - move occurs because `f` has type `Box<F>`, which does not implement the `Copy` trait
@@ -18,7 +18,7 @@
| value moved here
error[E0499]: cannot borrow `*f` as mutable more than once at a time
- --> $DIR/two-phase-nonrecv-autoref.rs:62:11
+ --> $DIR/two-phase-nonrecv-autoref.rs:63:11
|
LL | f(f(10));
| - ^ second mutable borrow occurs here
@@ -27,7 +27,7 @@
| first borrow later used by call
error[E0382]: use of moved value: `f`
- --> $DIR/two-phase-nonrecv-autoref.rs:69:11
+ --> $DIR/two-phase-nonrecv-autoref.rs:70:11
|
LL | fn twice_ten_oo(f: Box<dyn FnOnce(i32) -> i32>) {
| - move occurs because `f` has type `Box<dyn FnOnce(i32) -> i32>`, which does not implement the `Copy` trait
@@ -37,7 +37,7 @@
| value moved here
error[E0502]: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/two-phase-nonrecv-autoref.rs:107:27
+ --> $DIR/two-phase-nonrecv-autoref.rs:108:27
|
LL | double_access(&mut a, &a);
| ------------- ------ ^^ immutable borrow occurs here
@@ -46,7 +46,7 @@
| mutable borrow later used by call
error[E0502]: cannot borrow `i` as immutable because it is also borrowed as mutable
- --> $DIR/two-phase-nonrecv-autoref.rs:132:7
+ --> $DIR/two-phase-nonrecv-autoref.rs:133:7
|
LL | i[i[3]] = 4;
| --^----
@@ -56,18 +56,18 @@
| mutable borrow occurs here
|
help: try adding a local storing this...
- --> $DIR/two-phase-nonrecv-autoref.rs:132:8
+ --> $DIR/two-phase-nonrecv-autoref.rs:133:8
|
LL | i[i[3]] = 4;
| ^^^
help: ...and then using that local here
- --> $DIR/two-phase-nonrecv-autoref.rs:132:6
+ --> $DIR/two-phase-nonrecv-autoref.rs:133:6
|
LL | i[i[3]] = 4;
| ^^^^^^
error[E0502]: cannot borrow `i` as immutable because it is also borrowed as mutable
- --> $DIR/two-phase-nonrecv-autoref.rs:138:7
+ --> $DIR/two-phase-nonrecv-autoref.rs:139:7
|
LL | i[i[3]] = i[4];
| --^----
@@ -77,12 +77,12 @@
| mutable borrow occurs here
|
help: try adding a local storing this...
- --> $DIR/two-phase-nonrecv-autoref.rs:138:8
+ --> $DIR/two-phase-nonrecv-autoref.rs:139:8
|
LL | i[i[3]] = i[4];
| ^^^
help: ...and then using that local here
- --> $DIR/two-phase-nonrecv-autoref.rs:138:6
+ --> $DIR/two-phase-nonrecv-autoref.rs:139:6
|
LL | i[i[3]] = i[4];
| ^^^^^^
diff --git a/tests/ui/borrowck/two-phase-nonrecv-autoref.rs b/tests/ui/borrowck/two-phase-nonrecv-autoref.rs
index f52e9c2..3a8ab4e 100644
--- a/tests/ui/borrowck/two-phase-nonrecv-autoref.rs
+++ b/tests/ui/borrowck/two-phase-nonrecv-autoref.rs
@@ -1,5 +1,6 @@
//@ revisions: base
+//@ unused-revision-names: g2p
//@[g2p]compile-flags: -Z two-phase-beyond-autoref
// the above revision is disabled until two-phase-beyond-autoref support is better
diff --git a/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr b/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr
index b1e4392..5eda482 100644
--- a/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr
+++ b/tests/ui/borrowck/two-phase-reservation-sharing-interference.nll_target.stderr
@@ -1,5 +1,5 @@
error[E0502]: cannot borrow `vec` as mutable because it is also borrowed as immutable
- --> $DIR/two-phase-reservation-sharing-interference.rs:32:17
+ --> $DIR/two-phase-reservation-sharing-interference.rs:33:17
|
LL | let shared = &vec;
| ---- immutable borrow occurs here
diff --git a/tests/ui/borrowck/two-phase-reservation-sharing-interference.rs b/tests/ui/borrowck/two-phase-reservation-sharing-interference.rs
index b6bcf7b..6144657 100644
--- a/tests/ui/borrowck/two-phase-reservation-sharing-interference.rs
+++ b/tests/ui/borrowck/two-phase-reservation-sharing-interference.rs
@@ -1,6 +1,7 @@
//@ revisions: nll_target
// The nll_beyond revision is disabled due to missing support from two-phase beyond autorefs
+//@ unused-revision-names: nll_beyond
//@[nll_beyond]compile-flags: -Z two-phase-beyond-autoref
//@[nll_beyond]should-fail
diff --git a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
index c196f60..755373d 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
@@ -30,7 +30,7 @@
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition name: `feature`
- --> $DIR/exhaustive-names-values.rs:25:7
+ --> $DIR/exhaustive-names-values.rs:24:7
|
LL | #[cfg(feature = "std")]
| ^^^^^^^^^^^^^^^
diff --git a/tests/ui/check-cfg/exhaustive-names-values.rs b/tests/ui/check-cfg/exhaustive-names-values.rs
index a6190f1..7b2d89b 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.rs
+++ b/tests/ui/check-cfg/exhaustive-names-values.rs
@@ -16,15 +16,13 @@
pub fn f() {}
#[cfg(feature = "unk")]
-//[empty_names_values]~^ WARNING unexpected `cfg` condition name
-//[empty_cfg]~^^ WARNING unexpected `cfg` condition name
-//[feature]~^^^ WARNING unexpected `cfg` condition value
-//[full]~^^^^ WARNING unexpected `cfg` condition value
+//[empty_cfg]~^ WARNING unexpected `cfg` condition name
+//[feature]~^^ WARNING unexpected `cfg` condition value
+//[full]~^^^ WARNING unexpected `cfg` condition value
pub fn feat() {}
#[cfg(feature = "std")]
-//[empty_names_values]~^ WARNING unexpected `cfg` condition name
-//[empty_cfg]~^^ WARNING unexpected `cfg` condition name
+//[empty_cfg]~^ WARNING unexpected `cfg` condition name
pub fn feat() {}
#[cfg(windows)]
diff --git a/tests/ui/check-cfg/values-none.concat_1.stderr b/tests/ui/check-cfg/values-none.concat_1.stderr
new file mode 100644
index 0000000..b8f0b02
--- /dev/null
+++ b/tests/ui/check-cfg/values-none.concat_1.stderr
@@ -0,0 +1,13 @@
+warning: unexpected `cfg` condition value: `bar`
+ --> $DIR/values-none.rs:16:7
+ |
+LL | #[cfg(foo = "bar")]
+ | ^^^^^^^^^^^
+ |
+ = note: expected values for `foo` are: (none), `too`
+ = help: to expect this configuration use `--check-cfg=cfg(foo, values("bar"))`
+ = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+ = note: `#[warn(unexpected_cfgs)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/check-cfg/values-none.concat_2.stderr b/tests/ui/check-cfg/values-none.concat_2.stderr
new file mode 100644
index 0000000..b8f0b02
--- /dev/null
+++ b/tests/ui/check-cfg/values-none.concat_2.stderr
@@ -0,0 +1,13 @@
+warning: unexpected `cfg` condition value: `bar`
+ --> $DIR/values-none.rs:16:7
+ |
+LL | #[cfg(foo = "bar")]
+ | ^^^^^^^^^^^
+ |
+ = note: expected values for `foo` are: (none), `too`
+ = help: to expect this configuration use `--check-cfg=cfg(foo, values("bar"))`
+ = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+ = note: `#[warn(unexpected_cfgs)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/check-cfg/values-none.rs b/tests/ui/check-cfg/values-none.rs
index 6856d2f..447fde2 100644
--- a/tests/ui/check-cfg/values-none.rs
+++ b/tests/ui/check-cfg/values-none.rs
@@ -1,7 +1,7 @@
//@ check-pass
//
//@ no-auto-check-cfg
-//@ revisions: explicit implicit
+//@ revisions: explicit implicit simple concat_1 concat_2
//@ [explicit]compile-flags: --check-cfg=cfg(foo,values(none()))
//@ [implicit]compile-flags: --check-cfg=cfg(foo)
//@ [simple] compile-flags: --check-cfg=cfg(foo,values(none(),"too"))
diff --git a/tests/ui/check-cfg/values-none.simple.stderr b/tests/ui/check-cfg/values-none.simple.stderr
new file mode 100644
index 0000000..b8f0b02
--- /dev/null
+++ b/tests/ui/check-cfg/values-none.simple.stderr
@@ -0,0 +1,13 @@
+warning: unexpected `cfg` condition value: `bar`
+ --> $DIR/values-none.rs:16:7
+ |
+LL | #[cfg(foo = "bar")]
+ | ^^^^^^^^^^^
+ |
+ = note: expected values for `foo` are: (none), `too`
+ = help: to expect this configuration use `--check-cfg=cfg(foo, values("bar"))`
+ = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+ = note: `#[warn(unexpected_cfgs)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
index 408eaff..d885281 100644
--- a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
+++ b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
@@ -28,8 +28,8 @@
macro_rules! generate_s10 {
($expr: expr) => {
#[cfg(feature = $expr)]
- //~^ ERROR expected unsuffixed literal or identifier, found `concat!("nonexistent")`
- //~| ERROR expected unsuffixed literal or identifier, found `concat!("nonexistent")`
+ //~^ ERROR expected unsuffixed literal, found `concat!("nonexistent")`
+ //~| ERROR expected unsuffixed literal, found `concat!("nonexistent")`
struct S10;
}
}
diff --git a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
index 12557ff..3dd0823 100644
--- a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
@@ -54,7 +54,7 @@
| |
| help: consider removing the prefix
-error: expected unsuffixed literal or identifier, found `concat!("nonexistent")`
+error: expected unsuffixed literal, found `concat!("nonexistent")`
--> $DIR/cfg-attr-syntax-validation.rs:30:25
|
LL | #[cfg(feature = $expr)]
@@ -65,7 +65,7 @@
|
= note: this error originates in the macro `generate_s10` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: expected unsuffixed literal or identifier, found `concat!("nonexistent")`
+error: expected unsuffixed literal, found `concat!("nonexistent")`
--> $DIR/cfg-attr-syntax-validation.rs:30:25
|
LL | #[cfg(feature = $expr)]
diff --git a/tests/ui/consts/offset_from_ub.rs b/tests/ui/consts/offset_from_ub.rs
index 51163e6..e0dd270 100644
--- a/tests/ui/consts/offset_from_ub.rs
+++ b/tests/ui/consts/offset_from_ub.rs
@@ -42,7 +42,7 @@
let ptr1 = 8 as *const u8;
let ptr2 = 16 as *const u8;
unsafe { ptr_offset_from(ptr2, ptr1) } //~ERROR evaluation of constant value failed
- //~| 0x8[noalloc] is a dangling pointer
+ //~| different pointers without provenance
};
const OUT_OF_BOUNDS_1: isize = {
@@ -81,13 +81,13 @@
};
pub const TOO_FAR_APART1: isize = {
- let ptr1 = ptr::null::<u8>();
+ let ptr1 = &0u8 as *const u8;
let ptr2 = ptr1.wrapping_add(isize::MAX as usize + 42);
unsafe { ptr_offset_from(ptr2, ptr1) } //~ERROR evaluation of constant value failed
//~| too far ahead
};
pub const TOO_FAR_APART2: isize = {
- let ptr1 = ptr::null::<u8>();
+ let ptr1 = &0u8 as *const u8;
let ptr2 = ptr1.wrapping_add(isize::MAX as usize + 42);
unsafe { ptr_offset_from(ptr1, ptr2) } //~ERROR evaluation of constant value failed
//~| too far before
@@ -100,7 +100,7 @@
//~| first pointer has smaller offset than second: 0 < 8
};
pub const TOO_FAR_APART_UNSIGNED: usize = {
- let ptr1 = ptr::null::<u8>();
+ let ptr1 = &0u8 as *const u8;
let ptr2 = ptr1.wrapping_add(isize::MAX as usize + 42);
// This would fit into a `usize` but we still don't allow it.
unsafe { ptr_offset_from_unsigned(ptr2, ptr1) } //~ERROR evaluation of constant value failed
diff --git a/tests/ui/consts/offset_from_ub.stderr b/tests/ui/consts/offset_from_ub.stderr
index 4fbb2f0..e3bac8d 100644
--- a/tests/ui/consts/offset_from_ub.stderr
+++ b/tests/ui/consts/offset_from_ub.stderr
@@ -33,7 +33,7 @@
--> $DIR/offset_from_ub.rs:44:14
|
LL | unsafe { ptr_offset_from(ptr2, ptr1) }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds `offset_from`: 0x8[noalloc] is a dangling pointer (it has no provenance)
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from` called on different pointers without provenance (i.e., without an associated allocation)
error[E0080]: evaluation of constant value failed
--> $DIR/offset_from_ub.rs:53:14
@@ -86,7 +86,7 @@
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
|
- = note: out-of-bounds `offset_from`: null pointer is a dangling pointer (it has no provenance)
+ = note: `ptr_offset_from` called on different pointers without provenance (i.e., without an associated allocation)
|
note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
@@ -99,7 +99,7 @@
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
|
- = note: out-of-bounds `offset_from`: null pointer is a dangling pointer (it has no provenance)
+ = note: `ptr_offset_from` called on different pointers without provenance (i.e., without an associated allocation)
|
note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
diff --git a/tests/ui/coroutine/break-inside-coroutine-issue-124495.rs b/tests/ui/coroutine/break-inside-coroutine-issue-124495.rs
new file mode 100644
index 0000000..5d93db5
--- /dev/null
+++ b/tests/ui/coroutine/break-inside-coroutine-issue-124495.rs
@@ -0,0 +1,26 @@
+//@ edition: 2024
+//@ compile-flags: -Z unstable-options
+
+#![feature(gen_blocks)]
+#![feature(async_closure)]
+
+async fn async_fn() {
+ break; //~ ERROR `break` inside `async` function
+}
+
+gen fn gen_fn() {
+ break; //~ ERROR `break` inside `gen` function
+}
+
+async gen fn async_gen_fn() {
+ break; //~ ERROR `break` inside `async gen` function
+}
+
+fn main() {
+ let _ = async { break; }; //~ ERROR `break` inside `async` block
+ let _ = async || { break; }; //~ ERROR `break` inside `async` closure
+
+ let _ = gen { break; }; //~ ERROR `break` inside `gen` block
+
+ let _ = async gen { break; }; //~ ERROR `break` inside `async gen` block
+}
diff --git a/tests/ui/coroutine/break-inside-coroutine-issue-124495.stderr b/tests/ui/coroutine/break-inside-coroutine-issue-124495.stderr
new file mode 100644
index 0000000..a7f37fa
--- /dev/null
+++ b/tests/ui/coroutine/break-inside-coroutine-issue-124495.stderr
@@ -0,0 +1,69 @@
+error[E0267]: `break` inside `async` function
+ --> $DIR/break-inside-coroutine-issue-124495.rs:8:5
+ |
+LL | async fn async_fn() {
+ | _____________________-
+LL | | break;
+ | | ^^^^^ cannot `break` inside `async` function
+LL | | }
+ | |_- enclosing `async` function
+
+error[E0267]: `break` inside `gen` function
+ --> $DIR/break-inside-coroutine-issue-124495.rs:12:5
+ |
+LL | gen fn gen_fn() {
+ | _________________-
+LL | | break;
+ | | ^^^^^ cannot `break` inside `gen` function
+LL | | }
+ | |_- enclosing `gen` function
+
+error[E0267]: `break` inside `async gen` function
+ --> $DIR/break-inside-coroutine-issue-124495.rs:16:5
+ |
+LL | async gen fn async_gen_fn() {
+ | _____________________________-
+LL | | break;
+ | | ^^^^^ cannot `break` inside `async gen` function
+LL | | }
+ | |_- enclosing `async gen` function
+
+error[E0267]: `break` inside `async` block
+ --> $DIR/break-inside-coroutine-issue-124495.rs:20:21
+ |
+LL | let _ = async { break; };
+ | --------^^^^^---
+ | | |
+ | | cannot `break` inside `async` block
+ | enclosing `async` block
+
+error[E0267]: `break` inside `async` closure
+ --> $DIR/break-inside-coroutine-issue-124495.rs:21:24
+ |
+LL | let _ = async || { break; };
+ | --^^^^^---
+ | | |
+ | | cannot `break` inside `async` closure
+ | enclosing `async` closure
+
+error[E0267]: `break` inside `gen` block
+ --> $DIR/break-inside-coroutine-issue-124495.rs:23:19
+ |
+LL | let _ = gen { break; };
+ | ------^^^^^---
+ | | |
+ | | cannot `break` inside `gen` block
+ | enclosing `gen` block
+
+error[E0267]: `break` inside `async gen` block
+ --> $DIR/break-inside-coroutine-issue-124495.rs:25:25
+ |
+LL | let _ = async gen { break; };
+ | ------------^^^^^---
+ | | |
+ | | cannot `break` inside `async gen` block
+ | enclosing `async gen` block
+
+error: aborting due to 7 previous errors
+
+For more information about this error, try `rustc --explain E0267`.
diff --git a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
index 078c766..a030da5 100644
--- a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
+++ b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
@@ -4,7 +4,7 @@
LL | #[deprecated(note = test)]
| ^^^^
|
-help: surround the identifier with quotation marks to parse it as a string
+help: surround the identifier with quotation marks to make it into a string literal
|
LL | #[deprecated(note = "test")]
| + +
diff --git a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr b/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
index d0b14ef..e88a523 100644
--- a/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
+++ b/tests/ui/derives/derives-span-PartialEq-enum-struct-variant.stderr
@@ -1,4 +1,4 @@
-error[E0369]: binary operation `==` cannot be applied to type `Error`
+error[E0369]: binary operation `==` cannot be applied to type `&Error`
--> $DIR/derives-span-PartialEq-enum-struct-variant.rs:9:6
|
LL | #[derive(PartialEq)]
diff --git a/tests/ui/derives/derives-span-PartialEq-enum.stderr b/tests/ui/derives/derives-span-PartialEq-enum.stderr
index f69451a..80b2254 100644
--- a/tests/ui/derives/derives-span-PartialEq-enum.stderr
+++ b/tests/ui/derives/derives-span-PartialEq-enum.stderr
@@ -1,4 +1,4 @@
-error[E0369]: binary operation `==` cannot be applied to type `Error`
+error[E0369]: binary operation `==` cannot be applied to type `&Error`
--> $DIR/derives-span-PartialEq-enum.rs:9:6
|
LL | #[derive(PartialEq)]
diff --git a/tests/ui/deriving/deriving-all-codegen.rs b/tests/ui/deriving/deriving-all-codegen.rs
index 498930f..6fa4f74 100644
--- a/tests/ui/deriving/deriving-all-codegen.rs
+++ b/tests/ui/deriving/deriving-all-codegen.rs
@@ -156,6 +156,20 @@
Two(U),
}
+// An enum that has variant, which does't implement `Copy`.
+#[derive(PartialEq)]
+enum NonCopyEnum {
+ // The `dyn NonCopyTrait` implements `PartialEq`, but it doesn't require `Copy`.
+ // So we cannot generate `PartialEq` with dereference.
+ NonCopyField(Box<dyn NonCopyTrait>),
+}
+trait NonCopyTrait {}
+impl PartialEq for dyn NonCopyTrait {
+ fn eq(&self, _other: &Self) -> bool {
+ true
+ }
+}
+
// A union. Most builtin traits are not derivable for unions.
#[derive(Clone, Copy)]
pub union Union {
diff --git a/tests/ui/deriving/deriving-all-codegen.stdout b/tests/ui/deriving/deriving-all-codegen.stdout
index 9f8a9f3..6b69b57 100644
--- a/tests/ui/deriving/deriving-all-codegen.stdout
+++ b/tests/ui/deriving/deriving-all-codegen.stdout
@@ -876,7 +876,7 @@
fn eq(&self, other: &Enum1) -> bool {
match (self, other) {
(Enum1::Single { x: __self_0 }, Enum1::Single { x: __arg1_0 }) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
}
}
}
@@ -1119,10 +1119,10 @@
__self_discr == __arg1_discr &&
match (self, other) {
(Mixed::R(__self_0), Mixed::R(__arg1_0)) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
(Mixed::S { d1: __self_0, d2: __self_1 }, Mixed::S {
d1: __arg1_0, d2: __arg1_1 }) =>
- *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1,
+ __self_0 == __arg1_0 && __self_1 == __arg1_1,
_ => true,
}
}
@@ -1245,11 +1245,11 @@
__self_discr == __arg1_discr &&
match (self, other) {
(Fielded::X(__self_0), Fielded::X(__arg1_0)) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
(Fielded::Y(__self_0), Fielded::Y(__arg1_0)) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
(Fielded::Z(__self_0), Fielded::Z(__arg1_0)) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
_ => unsafe { ::core::intrinsics::unreachable() }
}
}
@@ -1368,9 +1368,9 @@
__self_discr == __arg1_discr &&
match (self, other) {
(EnumGeneric::One(__self_0), EnumGeneric::One(__arg1_0)) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
(EnumGeneric::Two(__self_0), EnumGeneric::Two(__arg1_0)) =>
- *__self_0 == *__arg1_0,
+ __self_0 == __arg1_0,
_ => unsafe { ::core::intrinsics::unreachable() }
}
}
@@ -1426,6 +1426,30 @@
}
}
+// An enum that has variant, which does't implement `Copy`.
+enum NonCopyEnum {
+
+ // The `dyn NonCopyTrait` implements `PartialEq`, but it doesn't require `Copy`.
+ // So we cannot generate `PartialEq` with dereference.
+ NonCopyField(Box<dyn NonCopyTrait>),
+}
+#[automatically_derived]
+impl ::core::marker::StructuralPartialEq for NonCopyEnum { }
+#[automatically_derived]
+impl ::core::cmp::PartialEq for NonCopyEnum {
+ #[inline]
+ fn eq(&self, other: &NonCopyEnum) -> bool {
+ match (self, other) {
+ (NonCopyEnum::NonCopyField(__self_0),
+ NonCopyEnum::NonCopyField(__arg1_0)) => __self_0 == __arg1_0,
+ }
+ }
+}
+trait NonCopyTrait {}
+impl PartialEq for dyn NonCopyTrait {
+ fn eq(&self, _other: &Self) -> bool { true }
+}
+
// A union. Most builtin traits are not derivable for unions.
pub union Union {
pub b: bool,
diff --git a/tests/ui/diagnostic_namespace/auxiliary/bad_on_unimplemented.rs b/tests/ui/diagnostic_namespace/auxiliary/bad_on_unimplemented.rs
index 4a5fca4..e44c7e4 100644
--- a/tests/ui/diagnostic_namespace/auxiliary/bad_on_unimplemented.rs
+++ b/tests/ui/diagnostic_namespace/auxiliary/bad_on_unimplemented.rs
@@ -1,2 +1,26 @@
#[diagnostic::on_unimplemented(aa = "broken")]
-pub trait Test {}
+pub trait MissingAttr {}
+
+#[diagnostic::on_unimplemented(label = "a", label = "b")]
+pub trait DuplicateAttr {}
+
+#[diagnostic::on_unimplemented = "broken"]
+pub trait NotMetaList {}
+
+#[diagnostic::on_unimplemented]
+pub trait Empty {}
+
+#[diagnostic::on_unimplemented {}]
+pub trait WrongDelim {}
+
+#[diagnostic::on_unimplemented(label = "{A:.3}")]
+pub trait BadFormatter<A> {}
+
+#[diagnostic::on_unimplemented(label = "test {}")]
+pub trait NoImplicitArgs {}
+
+#[diagnostic::on_unimplemented(label = "{missing}")]
+pub trait MissingArg {}
+
+#[diagnostic::on_unimplemented(label = "{_}")]
+pub trait BadArg {}
diff --git a/tests/ui/diagnostic_namespace/malformed_foreign_on_unimplemented.rs b/tests/ui/diagnostic_namespace/malformed_foreign_on_unimplemented.rs
new file mode 100644
index 0000000..8b7467a
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/malformed_foreign_on_unimplemented.rs
@@ -0,0 +1,31 @@
+//@ edition:2021
+//@ aux-build:bad_on_unimplemented.rs
+
+// Do not ICE when encountering a malformed `#[diagnostic::on_unimplemented]` annotation in a
+// dependency when incorrectly used (#124651).
+
+extern crate bad_on_unimplemented;
+
+use bad_on_unimplemented::*;
+
+fn missing_attr<T: MissingAttr>(_: T) {}
+fn duplicate_attr<T: DuplicateAttr>(_: T) {}
+fn not_meta_list<T: NotMetaList>(_: T) {}
+fn empty<T: Empty>(_: T) {}
+fn wrong_delim<T: WrongDelim>(_: T) {}
+fn bad_formatter<T: BadFormatter<()>>(_: T) {}
+fn no_implicit_args<T: NoImplicitArgs>(_: T) {}
+fn missing_arg<T: MissingArg>(_: T) {}
+fn bad_arg<T: BadArg>(_: T) {}
+
+fn main() {
+ missing_attr(()); //~ ERROR E0277
+ duplicate_attr(()); //~ ERROR E0277
+ not_meta_list(()); //~ ERROR E0277
+ empty(()); //~ ERROR E0277
+ wrong_delim(()); //~ ERROR E0277
+ bad_formatter(()); //~ ERROR E0277
+ no_implicit_args(()); //~ ERROR E0277
+ missing_arg(()); //~ ERROR E0277
+ bad_arg(()); //~ ERROR E0277
+}
diff --git a/tests/ui/diagnostic_namespace/malformed_foreign_on_unimplemented.stderr b/tests/ui/diagnostic_namespace/malformed_foreign_on_unimplemented.stderr
new file mode 100644
index 0000000..c3e5655
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/malformed_foreign_on_unimplemented.stderr
@@ -0,0 +1,134 @@
+error[E0277]: the trait bound `(): bad_on_unimplemented::MissingAttr` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:22:18
+ |
+LL | missing_attr(());
+ | ------------ ^^ the trait `bad_on_unimplemented::MissingAttr` is not implemented for `()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `missing_attr`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:11:20
+ |
+LL | fn missing_attr<T: MissingAttr>(_: T) {}
+ | ^^^^^^^^^^^ required by this bound in `missing_attr`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::DuplicateAttr` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:23:20
+ |
+LL | duplicate_attr(());
+ | -------------- ^^ a
+ | |
+ | required by a bound introduced by this call
+ |
+ = help: the trait `bad_on_unimplemented::DuplicateAttr` is not implemented for `()`
+note: required by a bound in `duplicate_attr`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:12:22
+ |
+LL | fn duplicate_attr<T: DuplicateAttr>(_: T) {}
+ | ^^^^^^^^^^^^^ required by this bound in `duplicate_attr`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::NotMetaList` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:24:19
+ |
+LL | not_meta_list(());
+ | ------------- ^^ the trait `bad_on_unimplemented::NotMetaList` is not implemented for `()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `not_meta_list`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:13:21
+ |
+LL | fn not_meta_list<T: NotMetaList>(_: T) {}
+ | ^^^^^^^^^^^ required by this bound in `not_meta_list`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::Empty` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:25:11
+ |
+LL | empty(());
+ | ----- ^^ the trait `bad_on_unimplemented::Empty` is not implemented for `()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `empty`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:14:13
+ |
+LL | fn empty<T: Empty>(_: T) {}
+ | ^^^^^ required by this bound in `empty`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::WrongDelim` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:26:17
+ |
+LL | wrong_delim(());
+ | ----------- ^^ the trait `bad_on_unimplemented::WrongDelim` is not implemented for `()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `wrong_delim`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:15:19
+ |
+LL | fn wrong_delim<T: WrongDelim>(_: T) {}
+ | ^^^^^^^^^^ required by this bound in `wrong_delim`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::BadFormatter<()>` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:27:19
+ |
+LL | bad_formatter(());
+ | ------------- ^^ ()
+ | |
+ | required by a bound introduced by this call
+ |
+ = help: the trait `bad_on_unimplemented::BadFormatter<()>` is not implemented for `()`
+note: required by a bound in `bad_formatter`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:16:21
+ |
+LL | fn bad_formatter<T: BadFormatter<()>>(_: T) {}
+ | ^^^^^^^^^^^^^^^^ required by this bound in `bad_formatter`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::NoImplicitArgs` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:28:22
+ |
+LL | no_implicit_args(());
+ | ---------------- ^^ test {}
+ | |
+ | required by a bound introduced by this call
+ |
+ = help: the trait `bad_on_unimplemented::NoImplicitArgs` is not implemented for `()`
+note: required by a bound in `no_implicit_args`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:17:24
+ |
+LL | fn no_implicit_args<T: NoImplicitArgs>(_: T) {}
+ | ^^^^^^^^^^^^^^ required by this bound in `no_implicit_args`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::MissingArg` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:29:17
+ |
+LL | missing_arg(());
+ | ----------- ^^ {missing}
+ | |
+ | required by a bound introduced by this call
+ |
+ = help: the trait `bad_on_unimplemented::MissingArg` is not implemented for `()`
+note: required by a bound in `missing_arg`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:18:19
+ |
+LL | fn missing_arg<T: MissingArg>(_: T) {}
+ | ^^^^^^^^^^ required by this bound in `missing_arg`
+
+error[E0277]: the trait bound `(): bad_on_unimplemented::BadArg` is not satisfied
+ --> $DIR/malformed_foreign_on_unimplemented.rs:30:13
+ |
+LL | bad_arg(());
+ | ------- ^^ {_}
+ | |
+ | required by a bound introduced by this call
+ |
+ = help: the trait `bad_on_unimplemented::BadArg` is not implemented for `()`
+note: required by a bound in `bad_arg`
+ --> $DIR/malformed_foreign_on_unimplemented.rs:19:15
+ |
+LL | fn bad_arg<T: BadArg>(_: T) {}
+ | ^^^^^^ required by this bound in `bad_arg`
+
+error: aborting due to 9 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented_ice.rs b/tests/ui/diagnostic_namespace/on_unimplemented_ice.rs
deleted file mode 100644
index 8969f50..0000000
--- a/tests/ui/diagnostic_namespace/on_unimplemented_ice.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ edition:2021
-//@ compile-flags:--test
-//@ aux-build:bad_on_unimplemented.rs
-
-// Do not ICE when encountering a malformed `#[diagnostic::on_unimplemented]` annotation in a
-// dependency when incorrectly used (#124651).
-
-extern crate bad_on_unimplemented;
-
-use bad_on_unimplemented::Test;
-
-fn breakage<T: Test>(_: T) {}
-
-#[test]
-fn test() {
- breakage(1); //~ ERROR E0277
-}
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented_ice.stderr b/tests/ui/diagnostic_namespace/on_unimplemented_ice.stderr
deleted file mode 100644
index 1c0da96..0000000
--- a/tests/ui/diagnostic_namespace/on_unimplemented_ice.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0277]: the trait bound `{integer}: Test` is not satisfied
- --> $DIR/on_unimplemented_ice.rs:16:14
- |
-LL | breakage(1);
- | -------- ^ the trait `Test` is not implemented for `{integer}`
- | |
- | required by a bound introduced by this call
- |
-note: required by a bound in `breakage`
- --> $DIR/on_unimplemented_ice.rs:12:16
- |
-LL | fn breakage<T: Test>(_: T) {}
- | ^^^^ required by this bound in `breakage`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/dyn-star/param-env-region-infer.current.stderr b/tests/ui/dyn-star/param-env-region-infer.current.stderr
index b50117c..6e464c1 100644
--- a/tests/ui/dyn-star/param-env-region-infer.current.stderr
+++ b/tests/ui/dyn-star/param-env-region-infer.current.stderr
@@ -1,5 +1,5 @@
error[E0282]: type annotations needed
- --> $DIR/param-env-region-infer.rs:19:10
+ --> $DIR/param-env-region-infer.rs:20:10
|
LL | t as _
| ^ cannot infer type
diff --git a/tests/ui/dyn-star/param-env-region-infer.rs b/tests/ui/dyn-star/param-env-region-infer.rs
index c538610..842964a 100644
--- a/tests/ui/dyn-star/param-env-region-infer.rs
+++ b/tests/ui/dyn-star/param-env-region-infer.rs
@@ -1,9 +1,10 @@
//@ revisions: current
//@ incremental
-// FIXME(-Znext-solver): THis currently results in unstable query results:
+// FIXME(-Znext-solver): This currently results in unstable query results:
// `normalizes-to(opaque, opaque)` changes from `Maybe(Ambiguous)` to `Maybe(Overflow)`
// once the hidden type of the opaque is already defined to be itself.
+//@ unused-revision-names: next
// checks that we don't ICE if there are region inference variables in the environment
// when computing `PointerLike` builtin candidates.
diff --git a/tests/ui/instrument-coverage/coverage-options.rs b/tests/ui/instrument-coverage/coverage-options.rs
index 332da32..2a80ce4 100644
--- a/tests/ui/instrument-coverage/coverage-options.rs
+++ b/tests/ui/instrument-coverage/coverage-options.rs
@@ -1,5 +1,5 @@
//@ needs-profiler-support
-//@ revisions: block branch bad
+//@ revisions: block branch mcdc bad
//@ compile-flags -Cinstrument-coverage
//@ [block] check-pass
diff --git a/tests/ui/lint/reference_casting.rs b/tests/ui/lint/reference_casting.rs
index 3d0c36c..87a6822 100644
--- a/tests/ui/lint/reference_casting.rs
+++ b/tests/ui/lint/reference_casting.rs
@@ -255,6 +255,12 @@
let a3 = a2 as *mut u64;
unsafe { *a3 = 3 };
}
+
+ unsafe fn field_access(v: &mut Vec3<i32>) {
+ let r = &mut v.0;
+ let ptr = r as *mut i32 as *mut Vec3<i32>;
+ unsafe { *ptr = Vec3(0, 0, 0) }
+ }
}
const RAW_PTR: *mut u8 = 1 as *mut u8;
diff --git a/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr b/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr
index 4221dd0..a489040 100644
--- a/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr
+++ b/tests/ui/meta/meta-expected-error-wrong-rev.a.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/meta-expected-error-wrong-rev.rs:13:18
+ --> $DIR/meta-expected-error-wrong-rev.rs:14:18
|
LL | let x: u32 = 22_usize;
| --- ^^^^^^^^ expected `u32`, found `usize`
diff --git a/tests/ui/meta/meta-expected-error-wrong-rev.rs b/tests/ui/meta/meta-expected-error-wrong-rev.rs
index de27629..1c3a3fc 100644
--- a/tests/ui/meta/meta-expected-error-wrong-rev.rs
+++ b/tests/ui/meta/meta-expected-error-wrong-rev.rs
@@ -1,6 +1,7 @@
//@ ignore-compare-mode-polonius
//@ revisions: a
+//@ unused-revision-names: b
//@ should-fail
// This is a "meta-test" of the compilertest framework itself. In
diff --git a/tests/ui/methods/method-lookup-order.rs b/tests/ui/methods/method-lookup-order.rs
index f794e5a..ad56da9 100644
--- a/tests/ui/methods/method-lookup-order.rs
+++ b/tests/ui/methods/method-lookup-order.rs
@@ -17,6 +17,7 @@
// {mutbar_for_foo, valbar_for_etmut_foo} (which are lower precedent than the inherent `&mut self` method on `Foo`; e.g. b10101 *is* included.
//@ revisions: b00001 b00010 b00011 b00100 b00101 b00110 b00111 b01000 b01001 b01100 b01101 b10000 b10001 b10010 b10011 b10101 b10111 b11000 b11001 b11101
+//@ unused-revision-names: b01010 b01011 b01110 b01111 b10100 b10110 b11010 b11011 b11100 b11110 b11111
//@ compile-flags: --check-cfg=cfg(inherent_mut,bar_for_foo,mutbar_for_foo)
//@ compile-flags: --check-cfg=cfg(valbar_for_et_foo,valbar_for_etmut_foo)
diff --git a/tests/ui/parser/attribute/attr-bad-meta-4.rs b/tests/ui/parser/attribute/attr-bad-meta-4.rs
index cedbd1d..2a69ae5 100644
--- a/tests/ui/parser/attribute/attr-bad-meta-4.rs
+++ b/tests/ui/parser/attribute/attr-bad-meta-4.rs
@@ -1,12 +1,17 @@
macro_rules! mac {
($attr_item: meta) => {
#[cfg($attr_item)]
- //~^ ERROR expected unsuffixed literal or identifier, found `an(arbitrary token stream)`
- //~| ERROR expected unsuffixed literal or identifier, found `an(arbitrary token stream)`
+ //~^ ERROR expected unsuffixed literal, found `an(arbitrary token stream)`
+ //~| ERROR expected unsuffixed literal, found `an(arbitrary token stream)`
struct S;
}
}
mac!(an(arbitrary token stream));
+#[cfg(feature = -1)]
+//~^ ERROR expected unsuffixed literal, found `-`
+//~| ERROR expected unsuffixed literal, found `-`
+fn handler() {}
+
fn main() {}
diff --git a/tests/ui/parser/attribute/attr-bad-meta-4.stderr b/tests/ui/parser/attribute/attr-bad-meta-4.stderr
index a543bcb..192be28 100644
--- a/tests/ui/parser/attribute/attr-bad-meta-4.stderr
+++ b/tests/ui/parser/attribute/attr-bad-meta-4.stderr
@@ -1,4 +1,10 @@
-error: expected unsuffixed literal or identifier, found `an(arbitrary token stream)`
+error: expected unsuffixed literal, found `-`
+ --> $DIR/attr-bad-meta-4.rs:12:17
+ |
+LL | #[cfg(feature = -1)]
+ | ^
+
+error: expected unsuffixed literal, found `an(arbitrary token stream)`
--> $DIR/attr-bad-meta-4.rs:3:15
|
LL | #[cfg($attr_item)]
@@ -9,7 +15,7 @@
|
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: expected unsuffixed literal or identifier, found `an(arbitrary token stream)`
+error: expected unsuffixed literal, found `an(arbitrary token stream)`
--> $DIR/attr-bad-meta-4.rs:3:15
|
LL | #[cfg($attr_item)]
@@ -21,5 +27,13 @@
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
= note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 2 previous errors
+error: expected unsuffixed literal, found `-`
+ --> $DIR/attr-bad-meta-4.rs:12:17
+ |
+LL | #[cfg(feature = -1)]
+ | ^
+ |
+ = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 4 previous errors
diff --git a/tests/ui/parser/attribute/attr-unquoted-ident.fixed b/tests/ui/parser/attribute/attr-unquoted-ident.fixed
deleted file mode 100644
index bc861ef..0000000
--- a/tests/ui/parser/attribute/attr-unquoted-ident.fixed
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Zdeduplicate-diagnostics=yes
-//@ run-rustfix
-
-#![allow(unexpected_cfgs)]
-
-fn main() {
- #[cfg(key="foo")]
- //~^ ERROR expected unsuffixed literal, found `foo`
- //~| HELP surround the identifier with quotation marks to parse it as a string
- println!();
- #[cfg(key="bar")]
- println!();
- #[cfg(key="foo bar baz")]
- //~^ ERROR expected unsuffixed literal, found `foo`
- //~| HELP surround the identifier with quotation marks to parse it as a string
- println!();
-}
diff --git a/tests/ui/parser/attribute/attr-unquoted-ident.rs b/tests/ui/parser/attribute/attr-unquoted-ident.rs
index 8bdb860..5b15b8d 100644
--- a/tests/ui/parser/attribute/attr-unquoted-ident.rs
+++ b/tests/ui/parser/attribute/attr-unquoted-ident.rs
@@ -1,17 +1,25 @@
//@ compile-flags: -Zdeduplicate-diagnostics=yes
-//@ run-rustfix
#![allow(unexpected_cfgs)]
fn main() {
#[cfg(key=foo)]
//~^ ERROR expected unsuffixed literal, found `foo`
- //~| HELP surround the identifier with quotation marks to parse it as a string
+ //~| HELP surround the identifier with quotation marks to make it into a string literal
println!();
#[cfg(key="bar")]
println!();
#[cfg(key=foo bar baz)]
//~^ ERROR expected unsuffixed literal, found `foo`
- //~| HELP surround the identifier with quotation marks to parse it as a string
+ //~| HELP surround the identifier with quotation marks to make it into a string literal
println!();
}
+
+// Don't suggest surrounding `$name` or `nickname` with quotes:
+
+macro_rules! make {
+ ($name:ident) => { #[doc(alias = $name)] pub struct S; }
+ //~^ ERROR expected unsuffixed literal, found `nickname`
+}
+
+make!(nickname); //~ NOTE in this expansion
diff --git a/tests/ui/parser/attribute/attr-unquoted-ident.stderr b/tests/ui/parser/attribute/attr-unquoted-ident.stderr
index 99484a5..e0f9945 100644
--- a/tests/ui/parser/attribute/attr-unquoted-ident.stderr
+++ b/tests/ui/parser/attribute/attr-unquoted-ident.stderr
@@ -1,24 +1,35 @@
error: expected unsuffixed literal, found `foo`
- --> $DIR/attr-unquoted-ident.rs:7:15
+ --> $DIR/attr-unquoted-ident.rs:6:15
|
LL | #[cfg(key=foo)]
| ^^^
|
-help: surround the identifier with quotation marks to parse it as a string
+help: surround the identifier with quotation marks to make it into a string literal
|
LL | #[cfg(key="foo")]
| + +
error: expected unsuffixed literal, found `foo`
- --> $DIR/attr-unquoted-ident.rs:13:15
+ --> $DIR/attr-unquoted-ident.rs:12:15
|
LL | #[cfg(key=foo bar baz)]
| ^^^
|
-help: surround the identifier with quotation marks to parse it as a string
+help: surround the identifier with quotation marks to make it into a string literal
|
LL | #[cfg(key="foo bar baz")]
| + +
-error: aborting due to 2 previous errors
+error: expected unsuffixed literal, found `nickname`
+ --> $DIR/attr-unquoted-ident.rs:21:38
+ |
+LL | ($name:ident) => { #[doc(alias = $name)] pub struct S; }
+ | ^^^^^
+...
+LL | make!(nickname);
+ | --------------- in this macro invocation
+ |
+ = note: this error originates in the macro `make` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
diff --git a/tests/ui/target-feature/tied-features-cli.rs b/tests/ui/target-feature/tied-features-cli.rs
index 1168245..17c1382 100644
--- a/tests/ui/target-feature/tied-features-cli.rs
+++ b/tests/ui/target-feature/tied-features-cli.rs
@@ -1,4 +1,4 @@
-//@ revisions: one two three
+//@ revisions: one two three four
//@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
//@ needs-llvm-components: aarch64
//
diff --git a/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-1.rs b/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-1.rs
new file mode 100644
index 0000000..151c3b2
--- /dev/null
+++ b/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-1.rs
@@ -0,0 +1,43 @@
+//@ compile-flags: -Znext-solver=coherence
+//@ check-pass
+
+// A regression test for #124791. Computing ambiguity causes
+// for the overlap of the `ToString` impls caused an ICE.
+#![crate_type = "lib"]
+#![feature(min_specialization)]
+trait Display {}
+
+trait ToOwned {
+ type Owned;
+}
+
+impl<T> ToOwned for T {
+ type Owned = T;
+}
+
+struct Cow<B: ?Sized>(B);
+
+impl<B: ?Sized> Display for Cow<B>
+where
+ B: ToOwned,
+ B::Owned: Display,
+{
+}
+
+impl Display for () {}
+
+trait ToString {
+ fn to_string();
+}
+
+impl<T: Display + ?Sized> ToString for T {
+ default fn to_string() {}
+}
+
+impl ToString for Cow<str> {
+ fn to_string() {}
+}
+
+impl ToOwned for str {
+ type Owned = ();
+}
diff --git a/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-2.rs b/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-2.rs
new file mode 100644
index 0000000..b472499
--- /dev/null
+++ b/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-2.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -Znext-solver=coherence
+
+// A regression test for #124791. Computing ambiguity causes
+// for the overlap of the `ToString` impls caused an ICE.
+#![crate_type = "lib"]
+trait ToOwned {
+ type Owned;
+}
+impl<T> ToOwned for T {
+ type Owned = u8;
+}
+impl ToOwned for str {
+ type Owned = i8;
+}
+
+trait Overlap {}
+impl<T: ToOwned<Owned = i8> + ?Sized> Overlap for T {}
+impl Overlap for str {}
+//~^ ERROR conflicting implementations of trait `Overlap`
diff --git a/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-2.stderr b/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-2.stderr
new file mode 100644
index 0000000..469f7a9
--- /dev/null
+++ b/tests/ui/traits/next-solver/coherence/ambiguity-causes-canonical-state-ice-2.stderr
@@ -0,0 +1,11 @@
+error[E0119]: conflicting implementations of trait `Overlap` for type `str`
+ --> $DIR/ambiguity-causes-canonical-state-ice-2.rs:18:1
+ |
+LL | impl<T: ToOwned<Owned = i8> + ?Sized> Overlap for T {}
+ | --------------------------------------------------- first implementation here
+LL | impl Overlap for str {}
+ | ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `str`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.rs b/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.rs
index 8bb4ff4..7eea81c 100644
--- a/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.rs
+++ b/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.rs
@@ -61,7 +61,7 @@
// entering the cycle from `A` fails, but would work if we were to use the cache
// result of `B<X>`.
impls_trait::<A<X>, _, _, _>();
- //~^ ERROR the trait bound `A<X>: Trait<i32, u8, u8>` is not satisfied
+ //~^ ERROR the trait bound `A<X>: Trait<_, _, _>` is not satisfied
}
fn main() {
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.stderr b/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.stderr
index cdb4ff4..ffa3f29 100644
--- a/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.stderr
+++ b/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.stderr
@@ -1,10 +1,11 @@
-error[E0277]: the trait bound `A<X>: Trait<i32, u8, u8>` is not satisfied
+error[E0277]: the trait bound `A<X>: Trait<_, _, _>` is not satisfied
--> $DIR/incompleteness-unstable-result.rs:63:19
|
LL | impls_trait::<A<X>, _, _, _>();
- | ^^^^ the trait `Trait<i32, u8, u8>` is not implemented for `A<X>`, which is required by `A<X>: Trait<_, _, _>`
+ | ^^^^ the trait `Trait<_, _, _>` is not implemented for `A<X>`, which is required by `A<X>: Trait<_, _, _>`
|
-note: required for `A<X>` to implement `Trait<i32, u8, u8>`
+ = help: the trait `Trait<U, V, D>` is implemented for `A<T>`
+note: required for `A<X>` to implement `Trait<_, _, _>`
--> $DIR/incompleteness-unstable-result.rs:32:50
|
LL | impl<T: ?Sized, U: ?Sized, V: ?Sized, D: ?Sized> Trait<U, V, D> for A<T>
@@ -13,16 +14,12 @@
LL | A<T>: Trait<U, D, V>,
| -------------- unsatisfied trait bound introduced here
= note: 8 redundant requirements hidden
- = note: required for `A<X>` to implement `Trait<i32, u8, u8>`
+ = note: required for `A<X>` to implement `Trait<_, _, _>`
note: required by a bound in `impls_trait`
--> $DIR/incompleteness-unstable-result.rs:51:28
|
LL | fn impls_trait<T: ?Sized + Trait<U, V, D>, U: ?Sized, V: ?Sized, D: ?Sized>() {}
| ^^^^^^^^^^^^^^ required by this bound in `impls_trait`
-help: consider extending the `where` clause, but there might be an alternative better way to express this requirement
- |
-LL | X: IncompleteGuidance<u32, i16>, A<X>: Trait<i32, u8, u8>
- | ~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 1 previous error
diff --git a/tests/ui/transmutability/primitives/bool-mut.rs b/tests/ui/transmutability/primitives/bool-mut.rs
index 5f3f4f3..09b6d58 100644
--- a/tests/ui/transmutability/primitives/bool-mut.rs
+++ b/tests/ui/transmutability/primitives/bool-mut.rs
@@ -1,5 +1,4 @@
//@ check-fail
-//@[next] compile-flags: -Znext-solver
#![feature(transmutability)]
mod assert {
diff --git a/tests/ui/transmutability/primitives/bool-mut.stderr b/tests/ui/transmutability/primitives/bool-mut.stderr
index 464c275..a6cf146 100644
--- a/tests/ui/transmutability/primitives/bool-mut.stderr
+++ b/tests/ui/transmutability/primitives/bool-mut.stderr
@@ -1,11 +1,11 @@
error[E0277]: `u8` cannot be safely transmuted into `bool`
- --> $DIR/bool-mut.rs:15:50
+ --> $DIR/bool-mut.rs:14:50
|
LL | assert::is_transmutable::<&'static mut bool, &'static mut u8>()
| ^^^^^^^^^^^^^^^ at least one value of `u8` isn't a bit-valid value of `bool`
|
note: required by a bound in `is_transmutable`
- --> $DIR/bool-mut.rs:10:14
+ --> $DIR/bool-mut.rs:9:14
|
LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function
diff --git a/tests/ui/version/version-info-flags.rs b/tests/ui/version/version-info-flags.rs
index 6121134..96be9c5 100644
--- a/tests/ui/version/version-info-flags.rs
+++ b/tests/ui/version/version-info-flags.rs
@@ -4,6 +4,6 @@
//@ check-pass
//@[version] compile-flags: -V
//@[verbose-version] compile-flags: -vV
-//@[long-verbose-verison] compile-flags: --version --verbose
+//@[long-verbose-version] compile-flags: --version --verbose
fn main() {}
