mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #97401 - Dylan-DPC:rollup-fh9e61o, r=Dylan-DPC

Browse Source 
Rollup of 5 pull requests

Successful merges:

 - #97302 (Do writeback of Closure params before visiting the parent expression)
 - #97328 (rustc: Fix ICE in native library error reporting)
 - #97351 (Output correct type responsible for structural match violation)
 - #97398 (Add regression test for #82830)
 - #97400 (Fix a typo on Struct `Substructure`)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2022-05-25 16:39:37 +00:00
commit 1b5e1215ef
16 changed files with 164 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
View File

@ -257,7 +257,7 @@ pub struct Substructure<'a> {
pub type_ident: Ident,
/// ident of the method
pub method_ident: Ident,
/// dereferenced access to any [`Self_`] or [`Ptr(Self_, _)][ptr]` arguments
/// dereferenced access to any [`Self_`] or [`Ptr(Self_, _)`][ptr] arguments
///
/// [`Self_`]: ty::Ty::Self_
/// [ptr]: ty::Ty::Ptr

9
compiler/rustc_metadata/src/native_libs.rs
View File

@ -418,10 +418,11 @@ fn process_command_line(&mut self) {
// involved or not, library reordering and kind overriding without
// explicit `:rename` in particular.
if lib.has_modifiers() || passed_lib.has_modifiers() {
self.tcx.sess.span_err(
self.tcx.def_span(lib.foreign_module.unwrap()),
"overriding linking modifiers from command line is not supported"
);
let msg = "overriding linking modifiers from command line is not supported";
match lib.foreign_module {
Some(def_id) => self.tcx.sess.span_err(self.tcx.def_span(def_id), msg),
None => self.tcx.sess.err(msg),
};
}
if passed_lib.kind != NativeLibKind::Unspecified {
lib.kind = passed_lib.kind;

18
compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
View File

@ -121,27 +121,27 @@ fn adt_derive_msg(&self, adt_def: AdtDef<'tcx>) -> String {
fn search_for_structural_match_violation(&self, ty: Ty<'tcx>) -> Option<String> {
traits::search_for_structural_match_violation(self.span, self.tcx(), ty).map(|non_sm_ty| {
with_no_trimmed_paths!(match non_sm_ty {
traits::NonStructuralMatchTy::Adt(adt) => self.adt_derive_msg(adt),
traits::NonStructuralMatchTy::Dynamic => {
with_no_trimmed_paths!(match non_sm_ty.kind {
traits::NonStructuralMatchTyKind::Adt(adt) => self.adt_derive_msg(adt),
traits::NonStructuralMatchTyKind::Dynamic => {
"trait objects cannot be used in patterns".to_string()
}
traits::NonStructuralMatchTy::Opaque => {
traits::NonStructuralMatchTyKind::Opaque => {
"opaque types cannot be used in patterns".to_string()
}
traits::NonStructuralMatchTy::Closure => {
traits::NonStructuralMatchTyKind::Closure => {
"closures cannot be used in patterns".to_string()
}
traits::NonStructuralMatchTy::Generator => {
traits::NonStructuralMatchTyKind::Generator => {
"generators cannot be used in patterns".to_string()
}
traits::NonStructuralMatchTy::Param => {
traits::NonStructuralMatchTyKind::Param => {
bug!("use of a constant whose type is a parameter inside a pattern")
}
traits::NonStructuralMatchTy::Projection => {
traits::NonStructuralMatchTyKind::Projection => {
bug!("use of a constant whose type is a projection inside a pattern")
}
traits::NonStructuralMatchTy::Foreign => {
traits::NonStructuralMatchTyKind::Foreign => {
bug!("use of a value of a foreign type inside a pattern")
}
})

2
compiler/rustc_trait_selection/src/traits/mod.rs
View File

@ -62,7 +62,7 @@
pub use self::specialize::specialization_graph::FutureCompatOverlapErrorKind;
pub use self::specialize::{specialization_graph, translate_substs, OverlapError};
pub use self::structural_match::search_for_structural_match_violation;
pub use self::structural_match::NonStructuralMatchTy;
pub use self::structural_match::{NonStructuralMatchTy, NonStructuralMatchTyKind};
pub use self::util::{
elaborate_obligations, elaborate_predicates, elaborate_predicates_with_span,
elaborate_trait_ref, elaborate_trait_refs,

32
compiler/rustc_trait_selection/src/traits/structural_match.rs
View File

@ -11,7 +11,13 @@
use std::ops::ControlFlow;
#[derive(Debug)]
pub enum NonStructuralMatchTy<'tcx> {
pub struct NonStructuralMatchTy<'tcx> {
pub ty: Ty<'tcx>,
pub kind: NonStructuralMatchTyKind<'tcx>,
}
#[derive(Debug)]
pub enum NonStructuralMatchTyKind<'tcx> {
Adt(AdtDef<'tcx>),
Param,
Dynamic,
@ -137,25 +143,32 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
let (adt_def, substs) = match *ty.kind() {
ty::Adt(adt_def, substs) => (adt_def, substs),
ty::Param(_) => {
return ControlFlow::Break(NonStructuralMatchTy::Param);
let kind = NonStructuralMatchTyKind::Param;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::Dynamic(..) => {
return ControlFlow::Break(NonStructuralMatchTy::Dynamic);
let kind = NonStructuralMatchTyKind::Dynamic;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::Foreign(_) => {
return ControlFlow::Break(NonStructuralMatchTy::Foreign);
let kind = NonStructuralMatchTyKind::Foreign;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::Opaque(..) => {
return ControlFlow::Break(NonStructuralMatchTy::Opaque);
let kind = NonStructuralMatchTyKind::Opaque;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::Projection(..) => {
return ControlFlow::Break(NonStructuralMatchTy::Projection);
let kind = NonStructuralMatchTyKind::Projection;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::Closure(..) => {
return ControlFlow::Break(NonStructuralMatchTy::Closure);
let kind = NonStructuralMatchTyKind::Closure;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::Generator(..) | ty::GeneratorWitness(..) => {
return ControlFlow::Break(NonStructuralMatchTy::Generator);
let kind = NonStructuralMatchTyKind::Generator;
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
ty::RawPtr(..) => {
// structural-match ignores substructure of
@ -215,7 +228,8 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
if !self.type_marked_structural(ty) {
debug!("Search found ty: {:?}", ty);
return ControlFlow::Break(NonStructuralMatchTy::Adt(adt_def));
let kind = NonStructuralMatchTyKind::Adt(adt_def);
return ControlFlow::Break(NonStructuralMatchTy { ty, kind });
}
// structural-match does not care about the

24
compiler/rustc_typeck/src/check/wfcheck.rs
View File

@ -827,7 +827,9 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
);
}
if traits::search_for_structural_match_violation(param.span, tcx, ty).is_some() {
if let Some(non_structural_match_ty) =
traits::search_for_structural_match_violation(param.span, tcx, ty)
{
// We use the same error code in both branches, because this is really the same
// issue: we just special-case the message for type parameters to make it
// clearer.
@ -853,19 +855,23 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
)
.emit();
} else {
struct_span_err!(
let mut diag = struct_span_err!(
tcx.sess,
hir_ty.span,
E0741,
"`{}` must be annotated with `#[derive(PartialEq, Eq)]` to be used as \
the type of a const parameter",
ty,
)
.span_label(
hir_ty.span,
format!("`{ty}` doesn't derive both `PartialEq` and `Eq`"),
)
.emit();
non_structural_match_ty.ty,
);
if ty == non_structural_match_ty.ty {
diag.span_label(
hir_ty.span,
format!("`{ty}` doesn't derive both `PartialEq` and `Eq`"),
);
}
diag.emit();
}
}
} else {

3
compiler/rustc_typeck/src/check/writeback.rs
View File

@ -263,8 +263,6 @@ fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) {
self.fix_scalar_builtin_expr(e);
self.fix_index_builtin_expr(e);
self.visit_node_id(e.span, e.hir_id);
match e.kind {
hir::ExprKind::Closure(_, _, body, _, _) => {
let body = self.fcx.tcx.hir().body(body);
@ -291,6 +289,7 @@ fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) {
_ => {}
}
self.visit_node_id(e.span, e.hir_id);
intravisit::walk_expr(self, e);
}

4
src/test/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
View File

@ -1,8 +1,8 @@
error[E0741]: `&'static (dyn A + 'static)` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
error[E0741]: `(dyn A + 'static)` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
--> $DIR/issue-63322-forbid-dyn.rs:9:18
|
LL | fn test<const T: &'static dyn A>() {
| ^^^^^^^^^^^^^^ `&'static (dyn A + 'static)` doesn't derive both `PartialEq` and `Eq`
| ^^^^^^^^^^^^^^
error: aborting due to previous error

14
src/test/ui/const-generics/issues/issue-97278.rs Normal file
View File

@ -0,0 +1,14 @@
#![feature(adt_const_params)]
#![allow(incomplete_features)]
use std::sync::Arc;
#[derive(PartialEq, Eq)]
enum Bar {
Bar(Arc<i32>)
}
fn test<const BAR: Bar>() {}
//~^ ERROR `Arc<i32>` must be annotated with `#[derive(PartialEq, Eq)]`
fn main() {}

9
src/test/ui/const-generics/issues/issue-97278.stderr Normal file
View File

@ -0,0 +1,9 @@
error[E0741]: `Arc<i32>` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
--> $DIR/issue-97278.rs:11:20
|
LL | fn test<const BAR: Bar>() {}
| ^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0741`.

7
src/test/ui/native-library-link-flags/modifiers-override-3.rs Normal file
View File

@ -0,0 +1,7 @@
// Regression test for issue #97299, one command line library with modifiers
// overrides another command line library with modifiers.
// compile-flags:-lstatic:+whole-archive=foo -lstatic:+whole-archive=foo
// error-pattern: overriding linking modifiers from command line is not supported
fn main() {}

4
src/test/ui/native-library-link-flags/modifiers-override-3.stderr Normal file
View File

@ -0,0 +1,4 @@
error: overriding linking modifiers from command line is not supported
error: aborting due to previous error

16
src/test/ui/traits/issue-82830.rs Normal file
View File

@ -0,0 +1,16 @@
trait A<Y, N> {
type B;
}
type MaybeBox<T> = <T as A<T, Box<T>>>::B;
struct P {
t: MaybeBox<P>, //~ ERROR: overflow evaluating the requirement `P: Sized`
}
impl<Y, N> A<Y, N> for P {
type B = N;
}
fn main() {
let t: MaybeBox<P>;
}

15
src/test/ui/traits/issue-82830.stderr Normal file
View File

@ -0,0 +1,15 @@
error[E0275]: overflow evaluating the requirement `P: Sized`
--> $DIR/issue-82830.rs:7:8
|
LL | t: MaybeBox<P>,
| ^^^^^^^^^^^
|
note: required because of the requirements on the impl of `A<P, Box<P>>` for `P`
--> $DIR/issue-82830.rs:10:12
|
LL | impl<Y, N> A<Y, N> for P {
| ^^^^^^^ ^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0275`.

18
src/test/ui/type/type-check/unknown_type_for_closure.rs
View File

@ -1,3 +1,17 @@
fn main() {
let x = |_| { }; //~ ERROR type annotations needed
fn infer_in_arg() {
let x = |b: Vec<_>| {}; //~ ERROR E0282
}
fn empty_pattern() {
let x = |_| {}; //~ ERROR type annotations needed
}
fn infer_ty() {
let x = |k: _| {}; //~ ERROR type annotations needed
}
fn ambig_return() {
let x = || -> Vec<_> { Vec::new() }; //~ ERROR type annotations needed for the closure `fn() -> Vec<_>`
}
fn main() {}

29
src/test/ui/type/type-check/unknown_type_for_closure.stderr
View File

@ -1,9 +1,32 @@
error[E0282]: type annotations needed
error[E0282]: type annotations needed for `Vec<_>`
--> $DIR/unknown_type_for_closure.rs:2:14
|
LL | let x = |_| { };
LL | let x = |b: Vec<_>| {};
| ^ consider giving this closure parameter a type
error: aborting due to previous error
error[E0282]: type annotations needed
--> $DIR/unknown_type_for_closure.rs:6:14
|
LL | let x = |_| {};
| ^ consider giving this closure parameter a type
error[E0282]: type annotations needed
--> $DIR/unknown_type_for_closure.rs:10:14
|
LL | let x = |k: _| {};
| ^ consider giving this closure parameter a type
error[E0282]: type annotations needed for the closure `fn() -> Vec<_>`
--> $DIR/unknown_type_for_closure.rs:14:28
|
LL | let x = || -> Vec<_> { Vec::new() };
| ^^^^^^^^ cannot infer type for type parameter `T`
|
help: give this closure an explicit return type without `_` placeholders
|
LL | let x = || -> Vec<_> { Vec::new() };
| ~~~~~~
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0282`.