Skip to content

Commit f7b1501

Browse files
borsbors
committed
Auto merge of #124961 - matthiaskrgr:rollup-1jj65p6, r=matthiaskrgr
Rollup of 7 pull requests Successful merges: - #124551 (Add benchmarks for `impl Debug for str`) - #124915 (`rustc_target` cleanups) - #124918 (Eliminate some `FIXME(lcnr)` comments) - #124927 (opt-dist: use xz2 instead of xz crate) - #124936 (analyse visitor: build proof tree in probe) - #124943 (always use `GenericArgsRef`) - #124955 (Use fewer origins when creating type variables.) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 98dabb6 + 0ee2580 commit f7b1501

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

66 files changed

+359
-460
lines changed

Diff for: ‎Cargo.lock

+1-10
Original file line numberDiff line numberDiff line change
@@ -2760,7 +2760,7 @@ dependencies = [
27602760
"tabled",
27612761
"tar",
27622762
"tempfile",
2763-
"xz",
2763+
"xz2",
27642764
"zip",
27652765
]
27662766

@@ -6586,15 +6586,6 @@ dependencies = [
65866586
"rustix",
65876587
]
65886588

6589-
[[package]]
6590-
name = "xz"
6591-
version = "0.1.0"
6592-
source = "registry+https://github.com/rust-lang/crates.io-index"
6593-
checksum = "3c887690ff2a2e233e8e49633461521f98ec57fbff9d59a884c9a4f04ec1da34"
6594-
dependencies = [
6595-
"xz2",
6596-
]
6597-
65986589
[[package]]
65996590
name = "xz2"
66006591
version = "0.1.7"

Diff for: ‎compiler/rustc_borrowck/src/renumber.rs

+1-3
Original file line numberDiff line numberDiff line change
@@ -26,9 +26,7 @@ pub fn renumber_mir<'tcx>(
2626
renumberer.visit_body(body);
2727
}
2828

29-
// FIXME(@lcnr): A lot of these variants overlap and it seems like
30-
// this type is only used to decide which region should be used
31-
// as representative. This should be cleaned up.
29+
// The fields are used only for debugging output in `sccs_info`.
3230
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
3331
pub(crate) enum RegionCtxt {
3432
Location(Location),

Diff for: ‎compiler/rustc_borrowck/src/type_check/input_output.rs

+1-4
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@ use std::assert_matches::assert_matches;
1111

1212
use itertools::Itertools;
1313
use rustc_hir as hir;
14-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
1514
use rustc_infer::infer::{BoundRegionConversionTime, RegionVariableOrigin};
1615
use rustc_middle::mir::*;
1716
use rustc_middle::ty::{self, Ty};
@@ -74,9 +73,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
7473
}),
7574
);
7675

77-
let next_ty_var = || {
78-
self.infcx.next_ty_var(TypeVariableOrigin { span: body.span, param_def_id: None })
79-
};
76+
let next_ty_var = || self.infcx.next_ty_var(body.span);
8077
let output_ty = Ty::new_coroutine(
8178
self.tcx(),
8279
self.tcx().coroutine_for_closure(mir_def_id),

Diff for: ‎compiler/rustc_borrowck/src/type_check/mod.rs

+1-5
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,6 @@ use rustc_index::{IndexSlice, IndexVec};
1616
use rustc_infer::infer::canonical::QueryRegionConstraints;
1717
use rustc_infer::infer::outlives::env::RegionBoundPairs;
1818
use rustc_infer::infer::region_constraints::RegionConstraintData;
19-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
2019
use rustc_infer::infer::{
2120
BoundRegion, BoundRegionConversionTime, InferCtxt, NllRegionVariableOrigin,
2221
};
@@ -2356,10 +2355,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
23562355
// Types with regions are comparable if they have a common super-type.
23572356
ty::RawPtr(_, _) | ty::FnPtr(_) => {
23582357
let ty_right = right.ty(body, tcx);
2359-
let common_ty = self.infcx.next_ty_var(TypeVariableOrigin {
2360-
param_def_id: None,
2361-
span: body.source_info(location).span,
2362-
});
2358+
let common_ty = self.infcx.next_ty_var(body.source_info(location).span);
23632359
self.sub_types(
23642360
ty_left,
23652361
common_ty,

Diff for: ‎compiler/rustc_borrowck/src/type_check/relate_tys.rs

+1-5
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
use rustc_data_structures::fx::FxHashMap;
22
use rustc_errors::ErrorGuaranteed;
3-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
43
use rustc_infer::infer::NllRegionVariableOrigin;
54
use rustc_infer::infer::{ObligationEmittingRelation, StructurallyRelateAliases};
65
use rustc_infer::traits::{Obligation, PredicateObligations};
@@ -129,10 +128,7 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
129128
// by using `ty_vid rel B` and then finally and end by equating `ty_vid` to
130129
// the opaque.
131130
let mut enable_subtyping = |ty, opaque_is_expected| {
132-
let ty_vid = infcx.next_ty_var_id_in_universe(
133-
TypeVariableOrigin { param_def_id: None, span: self.span() },
134-
ty::UniverseIndex::ROOT,
135-
);
131+
let ty_vid = infcx.next_ty_var_id_in_universe(self.span(), ty::UniverseIndex::ROOT);
136132

137133
let variance = if opaque_is_expected {
138134
self.ambient_variance

Diff for: ‎compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

+1-5
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,6 @@ use rustc_hir::def::{DefKind, Res};
99
use rustc_hir::intravisit;
1010
use rustc_hir::{GenericParamKind, ImplItemKind};
1111
use rustc_infer::infer::outlives::env::OutlivesEnvironment;
12-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
1312
use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
1413
use rustc_infer::traits::{util, FulfillmentError};
1514
use rustc_middle::ty::error::{ExpectedFound, TypeError};
@@ -800,10 +799,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ImplTraitInTraitCollector<'_, 'tcx> {
800799
bug!("FIXME(RPITIT): error here");
801800
}
802801
// Replace with infer var
803-
let infer_ty = self
804-
.ocx
805-
.infcx
806-
.next_ty_var(TypeVariableOrigin { span: self.span, param_def_id: None });
802+
let infer_ty = self.ocx.infcx.next_ty_var(self.span);
807803
self.types.insert(proj.def_id, (infer_ty, proj.args));
808804
// Recurse into bounds
809805
for (pred, pred_span) in self

Diff for: ‎compiler/rustc_hir_typeck/src/_match.rs

+2-4
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@ use rustc_hir::def::{CtorOf, DefKind, Res};
55
use rustc_hir::def_id::LocalDefId;
66
use rustc_hir::{self as hir, ExprKind, PatKind};
77
use rustc_hir_pretty::ty_to_string;
8-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
98
use rustc_middle::ty::{self, Ty};
109
use rustc_span::Span;
1110
use rustc_trait_selection::traits::{
@@ -67,7 +66,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
6766
// arm for inconsistent arms or to the whole match when a `()` type
6867
// is required).
6968
Expectation::ExpectHasType(ety) if ety != tcx.types.unit => ety,
70-
_ => self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr.span }),
69+
_ => self.next_ty_var(expr.span),
7170
};
7271
CoerceMany::with_coercion_sites(coerce_first, arms)
7372
};
@@ -575,8 +574,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
575574
// ...but otherwise we want to use any supertype of the
576575
// scrutinee. This is sort of a workaround, see note (*) in
577576
// `check_pat` for some details.
578-
let scrut_ty =
579-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: scrut.span });
577+
let scrut_ty = self.next_ty_var(scrut.span);
580578
self.check_expr_has_type_or_error(scrut, scrut_ty, |_| {});
581579
scrut_ty
582580
}

Diff for: ‎compiler/rustc_hir_typeck/src/callee.rs

+4-12
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,8 @@ use rustc_hir::def_id::DefId;
1111
use rustc_hir_analysis::autoderef::Autoderef;
1212
use rustc_infer::{
1313
infer,
14-
traits::{self, Obligation},
14+
traits::{self, Obligation, ObligationCause},
1515
};
16-
use rustc_infer::{infer::type_variable::TypeVariableOrigin, traits::ObligationCause};
1716
use rustc_middle::ty::adjustment::{
1817
Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability,
1918
};
@@ -180,14 +179,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
180179
infer::FnCall,
181180
closure_args.coroutine_closure_sig(),
182181
);
183-
let tupled_upvars_ty = self
184-
.next_ty_var(TypeVariableOrigin { param_def_id: None, span: callee_expr.span });
182+
let tupled_upvars_ty = self.next_ty_var(callee_expr.span);
185183
// We may actually receive a coroutine back whose kind is different
186184
// from the closure that this dispatched from. This is because when
187185
// we have no captures, we automatically implement `FnOnce`. This
188186
// impl forces the closure kind to `FnOnce` i.e. `u8`.
189-
let kind_ty = self
190-
.next_ty_var(TypeVariableOrigin { param_def_id: None, span: callee_expr.span });
187+
let kind_ty = self.next_ty_var(callee_expr.span);
191188
let call_sig = self.tcx.mk_fn_sig(
192189
[coroutine_closure_sig.tupled_inputs_ty],
193190
coroutine_closure_sig.to_coroutine(
@@ -298,12 +295,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
298295
let Some(trait_def_id) = opt_trait_def_id else { continue };
299296

300297
let opt_input_type = opt_arg_exprs.map(|arg_exprs| {
301-
Ty::new_tup_from_iter(
302-
self.tcx,
303-
arg_exprs.iter().map(|e| {
304-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: e.span })
305-
}),
306-
)
298+
Ty::new_tup_from_iter(self.tcx, arg_exprs.iter().map(|e| self.next_ty_var(e.span)))
307299
});
308300

309301
if let Some(ok) = self.lookup_method_in_trait(

Diff for: ‎compiler/rustc_hir_typeck/src/check.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@ use rustc_hir::def::DefKind;
88
use rustc_hir::intravisit::Visitor;
99
use rustc_hir::lang_items::LangItem;
1010
use rustc_hir_analysis::check::{check_function_signature, forbid_intrinsic_abi};
11-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
1211
use rustc_infer::infer::RegionVariableOrigin;
1312
use rustc_infer::traits::WellFormedLoc;
1413
use rustc_middle::ty::{self, Binder, Ty, TyCtxt};
@@ -142,7 +141,7 @@ pub(super) fn check_fn<'a, 'tcx>(
142141
// We have special-cased the case where the function is declared
143142
// `-> dyn Foo` and we don't actually relate it to the
144143
// `fcx.ret_coercion`, so just instantiate a type variable.
145-
actual_return_ty = fcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span });
144+
actual_return_ty = fcx.next_ty_var(span);
146145
debug!("actual_return_ty replaced with {:?}", actual_return_ty);
147146
}
148147

Diff for: ‎compiler/rustc_hir_typeck/src/closure.rs

+12-31
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,6 @@ use rustc_errors::ErrorGuaranteed;
66
use rustc_hir as hir;
77
use rustc_hir::lang_items::LangItem;
88
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
9-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
109
use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes};
1110
use rustc_infer::infer::{InferOk, InferResult};
1211
use rustc_macros::{TypeFoldable, TypeVisitable};
@@ -73,8 +72,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
7372
let parent_args =
7473
GenericArgs::identity_for_item(tcx, tcx.typeck_root_def_id(expr_def_id.to_def_id()));
7574

76-
let tupled_upvars_ty =
77-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
75+
let tupled_upvars_ty = self.next_ty_var(expr_span);
7876

7977
// FIXME: We could probably actually just unify this further --
8078
// instead of having a `FnSig` and a `Option<CoroutineTypes>`,
@@ -101,9 +99,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10199

102100
// Create a type variable (for now) to represent the closure kind.
103101
// It will be unified during the upvar inference phase (`upvar.rs`)
104-
None => {
105-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
106-
}
102+
None => self.next_ty_var(expr_span),
107103
};
108104

109105
let closure_args = ty::ClosureArgs::new(
@@ -122,10 +118,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
122118
let yield_ty = match kind {
123119
hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _)
124120
| hir::CoroutineKind::Coroutine(_) => {
125-
let yield_ty = self.next_ty_var(TypeVariableOrigin {
126-
param_def_id: None,
127-
span: expr_span,
128-
});
121+
let yield_ty = self.next_ty_var(expr_span);
129122
self.require_type_is_sized(yield_ty, expr_span, traits::SizedYieldType);
130123
yield_ty
131124
}
@@ -134,10 +127,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
134127
// in this block in projection correctly. In the new trait solver, it is
135128
// not a problem.
136129
hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _) => {
137-
let yield_ty = self.next_ty_var(TypeVariableOrigin {
138-
param_def_id: None,
139-
span: expr_span,
140-
});
130+
let yield_ty = self.next_ty_var(expr_span);
141131
self.require_type_is_sized(yield_ty, expr_span, traits::SizedYieldType);
142132

143133
Ty::new_adt(
@@ -163,8 +153,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
163153
// Resume type defaults to `()` if the coroutine has no argument.
164154
let resume_ty = liberated_sig.inputs().get(0).copied().unwrap_or(tcx.types.unit);
165155

166-
let interior =
167-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
156+
let interior = self.next_ty_var(expr_span);
168157
self.deferred_coroutine_interiors.borrow_mut().push((
169158
expr_def_id,
170159
body.id(),
@@ -177,7 +166,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
177166
// ty of `().`
178167
let kind_ty = match kind {
179168
hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) => {
180-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
169+
self.next_ty_var(expr_span)
181170
}
182171
_ => tcx.types.unit,
183172
};
@@ -212,23 +201,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
212201
}
213202
};
214203
// Compute all of the variables that will be used to populate the coroutine.
215-
let resume_ty =
216-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
217-
let interior =
218-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
204+
let resume_ty = self.next_ty_var(expr_span);
205+
let interior = self.next_ty_var(expr_span);
219206

220207
let closure_kind_ty = match expected_kind {
221208
Some(kind) => Ty::from_closure_kind(tcx, kind),
222209

223210
// Create a type variable (for now) to represent the closure kind.
224211
// It will be unified during the upvar inference phase (`upvar.rs`)
225-
None => {
226-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
227-
}
212+
None => self.next_ty_var(expr_span),
228213
};
229214

230-
let coroutine_captures_by_ref_ty =
231-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
215+
let coroutine_captures_by_ref_ty = self.next_ty_var(expr_span);
232216
let closure_args = ty::CoroutineClosureArgs::new(
233217
tcx,
234218
ty::CoroutineClosureArgsParts {
@@ -260,13 +244,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
260244

261245
// Create a type variable (for now) to represent the closure kind.
262246
// It will be unified during the upvar inference phase (`upvar.rs`)
263-
None => {
264-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span })
265-
}
247+
None => self.next_ty_var(expr_span),
266248
};
267249

268-
let coroutine_upvars_ty =
269-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: expr_span });
250+
let coroutine_upvars_ty = self.next_ty_var(expr_span);
270251

271252
// We need to turn the liberated signature that we got from HIR, which
272253
// looks something like `|Args...| -> T`, into a signature that is suitable

Diff for: ‎compiler/rustc_hir_typeck/src/coercion.rs

+2-8
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,6 @@ use rustc_errors::{codes::*, struct_span_code_err, Applicability, Diag};
4141
use rustc_hir as hir;
4242
use rustc_hir::def_id::{DefId, LocalDefId};
4343
use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
44-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
4544
use rustc_infer::infer::{Coercion, DefineOpaqueTypes, InferOk, InferResult};
4645
use rustc_infer::traits::{IfExpressionCause, MatchExpressionArmCause};
4746
use rustc_infer::traits::{Obligation, PredicateObligation};
@@ -257,11 +256,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
257256

258257
if b.is_ty_var() {
259258
// Two unresolved type variables: create a `Coerce` predicate.
260-
let target_ty = if self.use_lub {
261-
self.next_ty_var(TypeVariableOrigin { param_def_id: None, span: self.cause.span })
262-
} else {
263-
b
264-
};
259+
let target_ty = if self.use_lub { self.next_ty_var(self.cause.span) } else { b };
265260

266261
let mut obligations = Vec::with_capacity(2);
267262
for &source_ty in &[a, b] {
@@ -557,8 +552,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
557552
// the `CoerceUnsized` target type and the expected type.
558553
// We only have the latter, so we use an inference variable
559554
// for the former and let type inference do the rest.
560-
let origin = TypeVariableOrigin { param_def_id: None, span: self.cause.span };
561-
let coerce_target = self.next_ty_var(origin);
555+
let coerce_target = self.next_ty_var(self.cause.span);
562556
let mut coercion = self.unify_and(coerce_target, target, |target| {
563557
let unsize = Adjustment { kind: Adjust::Pointer(PointerCoercion::Unsize), target };
564558
match reborrow {

Diff for: ‎compiler/rustc_hir_typeck/src/demand.rs

+2-8
Original file line numberDiff line numberDiff line change
@@ -330,16 +330,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
330330
hir.body(hir.maybe_body_owned_by(self.body_id).expect("expected item to have body"));
331331
expr_finder.visit_expr(body.value);
332332

333-
use rustc_infer::infer::type_variable::*;
334-
use rustc_middle::infer::unify_key::*;
335333
// Replaces all of the variables in the given type with a fresh inference variable.
336334
let mut fudger = BottomUpFolder {
337335
tcx: self.tcx,
338336
ty_op: |ty| {
339337
if let ty::Infer(infer) = ty.kind() {
340338
match infer {
341-
ty::TyVar(_) => self
342-
.next_ty_var(TypeVariableOrigin { param_def_id: None, span: DUMMY_SP }),
339+
ty::TyVar(_) => self.next_ty_var(DUMMY_SP),
343340
ty::IntVar(_) => self.next_int_var(),
344341
ty::FloatVar(_) => self.next_float_var(),
345342
ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
@@ -353,10 +350,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
353350
lt_op: |_| self.tcx.lifetimes.re_erased,
354351
ct_op: |ct| {
355352
if let ty::ConstKind::Infer(_) = ct.kind() {
356-
self.next_const_var(
357-
ct.ty(),
358-
ConstVariableOrigin { param_def_id: None, span: DUMMY_SP },
359-
)
353+
self.next_const_var(ct.ty(), DUMMY_SP)
360354
} else {
361355
ct
362356
}

Diff for: ‎compiler/rustc_hir_typeck/src/expectation.rs

+1-3
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
use rustc_infer::infer::type_variable::TypeVariableOrigin;
21
use rustc_middle::ty::{self, Ty};
32
use rustc_span::Span;
43

@@ -110,7 +109,6 @@ impl<'a, 'tcx> Expectation<'tcx> {
110109
/// Like `only_has_type`, but instead of returning `None` if no
111110
/// hard constraint exists, creates a fresh type variable.
112111
pub(super) fn coercion_target_type(self, fcx: &FnCtxt<'a, 'tcx>, span: Span) -> Ty<'tcx> {
113-
self.only_has_type(fcx)
114-
.unwrap_or_else(|| fcx.next_ty_var(TypeVariableOrigin { param_def_id: None, span }))
112+
self.only_has_type(fcx).unwrap_or_else(|| fcx.next_ty_var(span))
115113
}
116114
}

0 commit comments

Comments
 (0)