Skip to content

Commit 7092d42

Browse files
borsbors
committed
Auto merge of #97980 - Dylan-DPC:rollup-l8exe4b, r=Dylan-DPC
Rollup of 6 pull requests Successful merges: - #96868 (Stabilize explicit_generic_args_with_impl_trait) - #97703 (some additional `need_type_info.rs` cleanup) - #97812 (Suggest to swap a struct and a trait in trait impls) - #97958 (ExitStatus docs fixups) - #97967 (Mention `infer::Trace` methods on `infer::At` methods' docs) - #97972 (Update #[doc(html_playground_url)] documentation to mention what the request will be) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
2 parents c845946 + 1f68d5f commit 7092d42

File tree

51 files changed

+495
-368
lines changed

Some content is hidden

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

51 files changed

+495
-368
lines changed

‎compiler/rustc_error_codes/src/error_codes/E0632.md

+3-1
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,11 @@
1+
#### Note: this error code is no longer emitted by the compiler.
2+
13
An explicit generic argument was provided when calling a function that
24
uses `impl Trait` in argument position.
35

46
Erroneous code example:
57

6-
```compile_fail,E0632
8+
```ignore (no longer an error)
79
fn foo<T: Copy>(a: T, b: impl Clone) {}
810
911
foo::<i32>(0i32, "abc".to_string());

‎compiler/rustc_error_messages/locales/en-US/typeck.ftl

-6
Original file line numberDiff line numberDiff line change
@@ -95,12 +95,6 @@ typeck-expected-return-type = expected `{$expected}` because of return type
9595
typeck-unconstrained-opaque-type = unconstrained opaque type
9696
.note = `{$name}` must be used in combination with a concrete type within the same module
9797
98-
typeck-explicit-generic-args-with-impl-trait =
99-
cannot provide explicit generic arguments when `impl Trait` is used in argument position
100-
.label = explicit generic argument not allowed
101-
.note = see issue #83701 <https://github.com/rust-lang/rust/issues/83701> for more information
102-
.help = add `#![feature(explicit_generic_args_with_impl_trait)]` to the crate attributes to enable
103-
10498
typeck-missing-type-params =
10599
the type {$parameterCount ->
106100
[one] parameter

‎compiler/rustc_feature/src/accepted.rs

+2
Original file line numberDiff line numberDiff line change
@@ -142,6 +142,8 @@ declare_features! (
142142
(accepted, dyn_trait, "1.27.0", Some(44662), None),
143143
/// Allows integer match exhaustiveness checking (RFC 2591).
144144
(accepted, exhaustive_integer_patterns, "1.33.0", Some(50907), None),
145+
/// Allows explicit generic arguments specification with `impl Trait` present.
146+
(accepted, explicit_generic_args_with_impl_trait, "1.63.0", Some(83701), None),
145147
/// Allows arbitrary expressions in key-value attributes at parse time.
146148
(accepted, extended_key_value_attributes, "1.54.0", Some(78835), None),
147149
/// Allows resolving absolute paths as paths from other crates.

‎compiler/rustc_feature/src/active.rs

-2
Original file line numberDiff line numberDiff line change
@@ -383,8 +383,6 @@ declare_features! (
383383
(active, exclusive_range_pattern, "1.11.0", Some(37854), None),
384384
/// Allows exhaustive pattern matching on types that contain uninhabited types.
385385
(active, exhaustive_patterns, "1.13.0", Some(51085), None),
386-
/// Allows explicit generic arguments specification with `impl Trait` present.
387-
(active, explicit_generic_args_with_impl_trait, "1.56.0", Some(83701), None),
388386
/// Allows defining `extern type`s.
389387
(active, extern_types, "1.23.0", Some(43467), None),
390388
/// Allows the use of `#[ffi_const]` on foreign functions.

‎compiler/rustc_infer/src/infer/at.rs

+21
Original file line numberDiff line numberDiff line change
@@ -111,6 +111,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
111111
}
112112

113113
/// Makes `a <: b`, where `a` may or may not be expected.
114+
///
115+
/// See [`At::trace_exp`] and [`Trace::sub`] for a version of
116+
/// this method that only requires `T: Relate<'tcx>`
114117
pub fn sub_exp<T>(self, a_is_expected: bool, a: T, b: T) -> InferResult<'tcx, ()>
115118
where
116119
T: ToTrace<'tcx>,
@@ -122,6 +125,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
122125
/// call like `foo(x)`, where `foo: fn(i32)`, you might have
123126
/// `sup(i32, x)`, since the "expected" type is the type that
124127
/// appears in the signature.
128+
///
129+
/// See [`At::trace`] and [`Trace::sub`] for a version of
130+
/// this method that only requires `T: Relate<'tcx>`
125131
pub fn sup<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()>
126132
where
127133
T: ToTrace<'tcx>,
@@ -130,6 +136,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
130136
}
131137

132138
/// Makes `expected <: actual`.
139+
///
140+
/// See [`At::trace`] and [`Trace::sub`] for a version of
141+
/// this method that only requires `T: Relate<'tcx>`
133142
pub fn sub<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()>
134143
where
135144
T: ToTrace<'tcx>,
@@ -138,6 +147,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
138147
}
139148

140149
/// Makes `expected <: actual`.
150+
///
151+
/// See [`At::trace_exp`] and [`Trace::eq`] for a version of
152+
/// this method that only requires `T: Relate<'tcx>`
141153
pub fn eq_exp<T>(self, a_is_expected: bool, a: T, b: T) -> InferResult<'tcx, ()>
142154
where
143155
T: ToTrace<'tcx>,
@@ -146,6 +158,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
146158
}
147159

148160
/// Makes `expected <: actual`.
161+
///
162+
/// See [`At::trace`] and [`Trace::eq`] for a version of
163+
/// this method that only requires `T: Relate<'tcx>`
149164
pub fn eq<T>(self, expected: T, actual: T) -> InferResult<'tcx, ()>
150165
where
151166
T: ToTrace<'tcx>,
@@ -176,6 +191,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
176191
/// this can result in an error (e.g., if asked to compute LUB of
177192
/// u32 and i32), it is meaningful to call one of them the
178193
/// "expected type".
194+
///
195+
/// See [`At::trace`] and [`Trace::lub`] for a version of
196+
/// this method that only requires `T: Relate<'tcx>`
179197
pub fn lub<T>(self, expected: T, actual: T) -> InferResult<'tcx, T>
180198
where
181199
T: ToTrace<'tcx>,
@@ -186,6 +204,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
186204
/// Computes the greatest-lower-bound, or mutual subtype, of two
187205
/// values. As with `lub` order doesn't matter, except for error
188206
/// cases.
207+
///
208+
/// See [`At::trace`] and [`Trace::glb`] for a version of
209+
/// this method that only requires `T: Relate<'tcx>`
189210
pub fn glb<T>(self, expected: T, actual: T) -> InferResult<'tcx, T>
190211
where
191212
T: ToTrace<'tcx>,

‎compiler/rustc_infer/src/infer/error_reporting/mod.rs

+10-46
Original file line numberDiff line numberDiff line change
@@ -67,10 +67,8 @@ use rustc_hir::{Item, ItemKind, Node};
6767
use rustc_middle::dep_graph::DepContext;
6868
use rustc_middle::ty::print::with_no_trimmed_paths;
6969
use rustc_middle::ty::{
70-
self,
71-
error::TypeError,
72-
subst::{GenericArgKind, Subst, SubstsRef},
73-
Binder, EarlyBinder, List, Region, Ty, TyCtxt, TypeFoldable, TypeSuperFoldable,
70+
self, error::TypeError, Binder, List, Region, Subst, Ty, TyCtxt, TypeFoldable,
71+
TypeSuperFoldable,
7472
};
7573
use rustc_span::{sym, symbol::kw, BytePos, DesugaringKind, Pos, Span};
7674
use rustc_target::spec::abi;
@@ -926,10 +924,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
926924
mut t1_out: &mut DiagnosticStyledString,
927925
mut t2_out: &mut DiagnosticStyledString,
928926
path: String,
929-
sub: ty::subst::SubstsRef<'tcx>,
927+
sub: &'tcx [ty::GenericArg<'tcx>],
930928
other_path: String,
931929
other_ty: Ty<'tcx>,
932930
) -> Option<()> {
931+
// FIXME/HACK: Go back to `SubstsRef` to use its inherent methods,
932+
// ideally that shouldn't be necessary.
933+
let sub = self.tcx.intern_substs(sub);
933934
for (i, ta) in sub.types().enumerate() {
934935
if ta == other_ty {
935936
self.highlight_outer(&mut t1_out, &mut t2_out, path, sub, i, other_ty);
@@ -960,45 +961,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
960961
}
961962
}
962963

963-
/// For generic types with parameters with defaults, remove the parameters corresponding to
964-
/// the defaults. This repeats a lot of the logic found in `ty::print::pretty`.
965-
fn strip_generic_default_params(
966-
&self,
967-
def_id: DefId,
968-
substs: ty::subst::SubstsRef<'tcx>,
969-
) -> SubstsRef<'tcx> {
970-
let generics = self.tcx.generics_of(def_id);
971-
let mut num_supplied_defaults = 0;
972-
973-
let default_params = generics.params.iter().rev().filter_map(|param| match param.kind {
974-
ty::GenericParamDefKind::Type { has_default: true, .. } => Some(param.def_id),
975-
ty::GenericParamDefKind::Const { has_default: true } => Some(param.def_id),
976-
_ => None,
977-
});
978-
for (def_id, actual) in iter::zip(default_params, substs.iter().rev()) {
979-
match actual.unpack() {
980-
GenericArgKind::Const(c) => {
981-
if EarlyBinder(self.tcx.const_param_default(def_id)).subst(self.tcx, substs)
982-
!= c
983-
{
984-
break;
985-
}
986-
}
987-
GenericArgKind::Type(ty) => {
988-
if self.tcx.bound_type_of(def_id).subst(self.tcx, substs) != ty {
989-
break;
990-
}
991-
}
992-
_ => break,
993-
}
994-
num_supplied_defaults += 1;
995-
}
996-
let len = generics.params.len();
997-
let mut generics = generics.clone();
998-
generics.params.truncate(len - num_supplied_defaults);
999-
substs.truncate_to(self.tcx, &generics)
1000-
}
1001-
1002964
/// Given two `fn` signatures highlight only sub-parts that are different.
1003965
fn cmp_fn_sig(
1004966
&self,
@@ -1156,8 +1118,10 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
11561118
(&ty::Adt(def1, sub1), &ty::Adt(def2, sub2)) => {
11571119
let did1 = def1.did();
11581120
let did2 = def2.did();
1159-
let sub_no_defaults_1 = self.strip_generic_default_params(did1, sub1);
1160-
let sub_no_defaults_2 = self.strip_generic_default_params(did2, sub2);
1121+
let sub_no_defaults_1 =
1122+
self.tcx.generics_of(did1).own_substs_no_defaults(self.tcx, sub1);
1123+
let sub_no_defaults_2 =
1124+
self.tcx.generics_of(did2).own_substs_no_defaults(self.tcx, sub2);
11611125
let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new());
11621126
let path1 = self.tcx.def_path_str(did1);
11631127
let path2 = self.tcx.def_path_str(did2);

‎compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs

+21-27
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ use crate::infer::type_variable::TypeVariableOriginKind;
22
use crate::infer::InferCtxt;
33
use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, ErrorGuaranteed};
44
use rustc_hir as hir;
5+
use rustc_hir::def::Res;
56
use rustc_hir::def::{CtorOf, DefKind, Namespace};
67
use rustc_hir::def_id::DefId;
78
use rustc_hir::intravisit::{self, Visitor};
@@ -11,7 +12,7 @@ use rustc_middle::infer::unify_key::ConstVariableOriginKind;
1112
use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
1213
use rustc_middle::ty::print::{FmtPrinter, PrettyPrinter, Print, Printer};
1314
use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst, SubstsRef};
14-
use rustc_middle::ty::{self, DefIdTree, GenericParamDefKind, InferConst};
15+
use rustc_middle::ty::{self, DefIdTree, InferConst};
1516
use rustc_middle::ty::{Ty, TyCtxt, TypeckResults};
1617
use rustc_span::symbol::{kw, Ident};
1718
use rustc_span::{BytePos, Span};
@@ -853,12 +854,23 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
853854
hir::TyKind::Path(hir::QPath::Resolved(_self_ty, path)),
854855
) => {
855856
if tcx.res_generics_def_id(path.res) != Some(def.did()) {
856-
bug!(
857-
"unexpected path: def={:?} substs={:?} path={:?}",
858-
def,
859-
substs,
860-
path,
861-
);
857+
match path.res {
858+
Res::Def(DefKind::TyAlias, _) => {
859+
// FIXME: Ideally we should support this. For that
860+
// we have to map back from the self type to the
861+
// type alias though. That's difficult.
862+
//
863+
// See the `need_type_info/type-alias.rs` test for
864+
// some examples.
865+
}
866+
// There cannot be inference variables in the self type,
867+
// so there's nothing for us to do here.
868+
Res::SelfTy { .. } => {}
869+
_ => warn!(
870+
"unexpected path: def={:?} substs={:?} path={:?}",
871+
def, substs, path,
872+
),
873+
}
862874
} else {
863875
return Box::new(
864876
self.resolved_path_inferred_subst_iter(path, substs)
@@ -958,26 +970,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
958970
generics.own_substs(substs).iter().position(|&arg| self.generic_arg_is_target(arg))
959971
{
960972
let substs = self.infcx.resolve_vars_if_possible(substs);
961-
let num_args = generics
962-
.params
963-
.iter()
964-
.rev()
965-
.filter(|&p| !matches!(p.kind, GenericParamDefKind::Lifetime))
966-
.skip_while(|&param| {
967-
if let Some(default) = param.default_value(tcx) {
968-
// FIXME: Using structural comparisions has a bunch of false negatives.
969-
//
970-
// We should instead try to replace inference variables with placeholders and
971-
// then use `infcx.can_eq`. That probably should be a separate method
972-
// generally used during error reporting.
973-
default.subst(tcx, substs) == substs[param.index as usize]
974-
} else {
975-
false
976-
}
977-
})
978-
.count();
979-
let generic_args =
980-
&generics.own_substs(substs)[generics.own_counts().lifetimes..][..num_args];
973+
let generic_args = &generics.own_substs_no_defaults(tcx, substs)
974+
[generics.own_counts().lifetimes..];
981975
let span = match expr.kind {
982976
ExprKind::MethodCall(path, _, _) => path.ident.span,
983977
_ => expr.span,

‎compiler/rustc_middle/src/ty/generics.rs

+40-1
Original file line numberDiff line numberDiff line change
@@ -228,8 +228,47 @@ impl<'tcx> Generics {
228228
})
229229
}
230230

231+
/// Returns the substs corresponding to the generic parameters
232+
/// of this item, excluding `Self`.
233+
///
234+
/// **This should only be used for diagnostics purposes.**
235+
pub fn own_substs_no_defaults(
236+
&'tcx self,
237+
tcx: TyCtxt<'tcx>,
238+
substs: &'tcx [ty::GenericArg<'tcx>],
239+
) -> &'tcx [ty::GenericArg<'tcx>] {
240+
let mut own_params = self.parent_count..self.count();
241+
if self.has_self && self.parent.is_none() {
242+
own_params.start = 1;
243+
}
244+
245+
// Filter the default arguments.
246+
//
247+
// This currently uses structural equality instead
248+
// of semantic equivalance. While not ideal, that's
249+
// good enough for now as this should only be used
250+
// for diagnostics anyways.
251+
own_params.end -= self
252+
.params
253+
.iter()
254+
.rev()
255+
.take_while(|param| {
256+
param.default_value(tcx).map_or(false, |default| {
257+
default.subst(tcx, substs) == substs[param.index as usize]
258+
})
259+
})
260+
.count();
261+
262+
&substs[own_params]
263+
}
264+
231265
/// Returns the substs corresponding to the generic parameters of this item, excluding `Self`.
232-
pub fn own_substs(&'tcx self, substs: SubstsRef<'tcx>) -> &'tcx [ty::GenericArg<'tcx>] {
266+
///
267+
/// **This should only be used for diagnostics purposes.**
268+
pub fn own_substs(
269+
&'tcx self,
270+
substs: &'tcx [ty::GenericArg<'tcx>],
271+
) -> &'tcx [ty::GenericArg<'tcx>] {
233272
let own = &substs[self.parent_count..][..self.params.len()];
234273
if self.has_self && self.parent.is_none() { &own[1..] } else { &own }
235274
}

‎compiler/rustc_middle/src/ty/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,6 @@ use crate::mir::{Body, GeneratorLayout};
2222
use crate::traits::{self, Reveal};
2323
use crate::ty;
2424
use crate::ty::fast_reject::SimplifiedType;
25-
use crate::ty::subst::{GenericArg, InternalSubsts, Subst, SubstsRef};
2625
use crate::ty::util::Discr;
2726
pub use adt::*;
2827
pub use assoc::*;
@@ -44,6 +43,7 @@ use rustc_session::cstore::CrateStoreDyn;
4443
use rustc_span::symbol::{kw, sym, Ident, Symbol};
4544
use rustc_span::Span;
4645
use rustc_target::abi::Align;
46+
pub use subst::*;
4747
pub use vtable::*;
4848

4949
use std::fmt::Debug;

‎compiler/rustc_middle/src/ty/print/mod.rs

+1-38
Original file line numberDiff line numberDiff line change
@@ -149,7 +149,7 @@ pub trait Printer<'tcx>: Sized {
149149
// on top of the same path, but without its own generics.
150150
_ => {
151151
if !generics.params.is_empty() && substs.len() >= generics.count() {
152-
let args = self.generic_args_to_print(generics, substs);
152+
let args = generics.own_substs_no_defaults(self.tcx(), substs);
153153
return self.path_generic_args(
154154
|cx| cx.print_def_path(def_id, parent_substs),
155155
args,
@@ -184,43 +184,6 @@ pub trait Printer<'tcx>: Sized {
184184
}
185185
}
186186

187-
fn generic_args_to_print(
188-
&self,
189-
generics: &'tcx ty::Generics,
190-
substs: &'tcx [GenericArg<'tcx>],
191-
) -> &'tcx [GenericArg<'tcx>] {
192-
let mut own_params = generics.parent_count..generics.count();
193-
194-
// Don't print args for `Self` parameters (of traits).
195-
if generics.has_self && own_params.start == 0 {
196-
own_params.start = 1;
197-
}
198-
199-
// Don't print args that are the defaults of their respective parameters.
200-
own_params.end -= generics
201-
.params
202-
.iter()
203-
.rev()
204-
.take_while(|param| match param.kind {
205-
ty::GenericParamDefKind::Lifetime => false,
206-
ty::GenericParamDefKind::Type { has_default, .. } => {
207-
has_default
208-
&& substs[param.index as usize]
209-
== GenericArg::from(
210-
self.tcx().bound_type_of(param.def_id).subst(self.tcx(), substs),
211-
)
212-
}
213-
ty::GenericParamDefKind::Const { has_default } => {
214-
has_default
215-
&& substs[param.index as usize]
216-
== GenericArg::from(self.tcx().const_param_default(param.def_id))
217-
}
218-
})
219-
.count();
220-
221-
&substs[own_params]
222-
}
223-
224187
fn default_print_impl_path(
225188
self,
226189
impl_def_id: DefId,

0 commit comments

Comments
 (0)