Skip to content

Commit 3bfde2f

Browse files
borsbors
committed
Auto merge of rust-lang#91104 - matthiaskrgr:rollup-duk33o1, r=matthiaskrgr
Rollup of 4 pull requests Successful merges: - rust-lang#91008 (Adds IEEE 754-2019 minimun and maximum functions for f32/f64) - rust-lang#91070 (Make `LLVMRustGetOrInsertGlobal` always return a `GlobalVariable`) - rust-lang#91097 (Add spaces in opaque `impl Trait` with more than one trait) - rust-lang#91098 (Don't suggest certain fixups (`.field`, `.await`, etc) when reporting errors while matching on arrays ) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
2 parents b8e5ab2 + a54eae9 commit 3bfde2f

File tree

17 files changed

+344
-27
lines changed

17 files changed

+344
-27
lines changed

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

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1695,11 +1695,23 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
16951695
}
16961696
_ => exp_found,
16971697
};
1698-
debug!("exp_found {:?} terr {:?}", exp_found, terr);
1698+
debug!("exp_found {:?} terr {:?} cause.code {:?}", exp_found, terr, cause.code);
16991699
if let Some(exp_found) = exp_found {
1700-
self.suggest_as_ref_where_appropriate(span, &exp_found, diag);
1701-
self.suggest_accessing_field_where_appropriate(cause, &exp_found, diag);
1702-
self.suggest_await_on_expect_found(cause, span, &exp_found, diag);
1700+
let should_suggest_fixes = if let ObligationCauseCode::Pattern { root_ty, .. } =
1701+
&cause.code
1702+
{
1703+
// Skip if the root_ty of the pattern is not the same as the expected_ty.
1704+
// If these types aren't equal then we've probably peeled off a layer of arrays.
1705+
same_type_modulo_infer(self.resolve_vars_if_possible(*root_ty), exp_found.expected)
1706+
} else {
1707+
true
1708+
};
1709+
1710+
if should_suggest_fixes {
1711+
self.suggest_as_ref_where_appropriate(span, &exp_found, diag);
1712+
self.suggest_accessing_field_where_appropriate(cause, &exp_found, diag);
1713+
self.suggest_await_on_expect_found(cause, span, &exp_found, diag);
1714+
}
17031715
}
17041716

17051717
// In some (most?) cases cause.body_id points to actual body, but in some cases
@@ -1879,7 +1891,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
18791891
.iter()
18801892
.filter(|field| field.vis.is_accessible_from(field.did, self.tcx))
18811893
.map(|field| (field.ident.name, field.ty(self.tcx, expected_substs)))
1882-
.find(|(_, ty)| ty::TyS::same_type(ty, exp_found.found))
1894+
.find(|(_, ty)| same_type_modulo_infer(ty, exp_found.found))
18831895
{
18841896
if let ObligationCauseCode::Pattern { span: Some(span), .. } = cause.code {
18851897
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
@@ -1944,7 +1956,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
19441956
| (_, ty::Infer(_))
19451957
| (ty::Param(_), _)
19461958
| (ty::Infer(_), _) => {}
1947-
_ if ty::TyS::same_type(exp_ty, found_ty) => {}
1959+
_ if same_type_modulo_infer(exp_ty, found_ty) => {}
19481960
_ => show_suggestion = false,
19491961
};
19501962
}

‎compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -124,8 +124,18 @@ extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
124124

125125
extern "C" LLVMValueRef
126126
LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty) {
127+
Module *Mod = unwrap(M);
127128
StringRef NameRef(Name, NameLen);
128-
return wrap(unwrap(M)->getOrInsertGlobal(NameRef, unwrap(Ty)));
129+
130+
// We don't use Module::getOrInsertGlobal because that returns a Constant*,
131+
// which may either be the real GlobalVariable*, or a constant bitcast of it
132+
// if our type doesn't match the original declaration. We always want the
133+
// GlobalVariable* so we can access linkage, visibility, etc.
134+
GlobalVariable *GV = Mod->getGlobalVariable(NameRef, true);
135+
if (!GV)
136+
GV = new GlobalVariable(*Mod, unwrap(Ty), false,
137+
GlobalValue::ExternalLinkage, nullptr, NameRef);
138+
return wrap(GV);
129139
}
130140

131141
extern "C" LLVMValueRef

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -688,7 +688,7 @@ pub trait PrettyPrinter<'tcx>:
688688
}
689689

690690
p!(
691-
write("{}", if first { " " } else { "+" }),
691+
write("{}", if first { " " } else { " + " }),
692692
print(trait_ref.print_only_trait_path())
693693
);
694694

@@ -699,7 +699,7 @@ pub trait PrettyPrinter<'tcx>:
699699
}
700700

701701
if is_future {
702-
p!(write("{}Future", if first { " " } else { "+" }));
702+
p!(write("{}Future", if first { " " } else { " + " }));
703703
first = false;
704704

705705
if let Some(future_output_ty) = future_output_ty {
@@ -712,7 +712,7 @@ pub trait PrettyPrinter<'tcx>:
712712
}
713713

714714
if !is_sized {
715-
p!(write("{}?Sized", if first { " " } else { "+" }));
715+
p!(write("{}?Sized", if first { " " } else { " + " }));
716716
} else if first {
717717
p!(" Sized");
718718
}

‎library/core/src/num/f32.rs

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -673,6 +673,9 @@ impl f32 {
673673

674674
/// Returns the maximum of the two numbers.
675675
///
676+
/// Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs.
677+
/// This matches the behavior of libm’s fmin.
678+
///
676679
/// ```
677680
/// let x = 1.0f32;
678681
/// let y = 2.0f32;
@@ -689,6 +692,9 @@ impl f32 {
689692

690693
/// Returns the minimum of the two numbers.
691694
///
695+
/// Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs.
696+
/// This matches the behavior of libm’s fmin.
697+
///
692698
/// ```
693699
/// let x = 1.0f32;
694700
/// let y = 2.0f32;
@@ -703,6 +709,68 @@ impl f32 {
703709
intrinsics::minnumf32(self, other)
704710
}
705711

712+
/// Returns the maximum of the two numbers, propagating NaNs.
713+
///
714+
/// This returns NaN when *either* argument is NaN, as opposed to
715+
/// [`f32::max`] which only returns NaN when *both* arguments are NaN.
716+
///
717+
/// ```
718+
/// #![feature(float_minimum_maximum)]
719+
/// let x = 1.0f32;
720+
/// let y = 2.0f32;
721+
///
722+
/// assert_eq!(x.maximum(y), y);
723+
/// assert!(x.maximum(f32::NAN).is_nan());
724+
/// ```
725+
///
726+
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater
727+
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
728+
/// Note that this follows the semantics specified in IEEE 754-2019.
729+
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
730+
#[inline]
731+
pub fn maximum(self, other: f32) -> f32 {
732+
if self > other {
733+
self
734+
} else if other > self {
735+
other
736+
} else if self == other {
737+
if self.is_sign_positive() && other.is_sign_negative() { self } else { other }
738+
} else {
739+
self + other
740+
}
741+
}
742+
743+
/// Returns the minimum of the two numbers, propagating NaNs.
744+
///
745+
/// This returns NaN when *either* argument is NaN, as opposed to
746+
/// [`f32::min`] which only returns NaN when *both* arguments are NaN.
747+
///
748+
/// ```
749+
/// #![feature(float_minimum_maximum)]
750+
/// let x = 1.0f32;
751+
/// let y = 2.0f32;
752+
///
753+
/// assert_eq!(x.minimum(y), x);
754+
/// assert!(x.minimum(f32::NAN).is_nan());
755+
/// ```
756+
///
757+
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser
758+
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
759+
/// Note that this follows the semantics specified in IEEE 754-2019.
760+
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
761+
#[inline]
762+
pub fn minimum(self, other: f32) -> f32 {
763+
if self < other {
764+
self
765+
} else if other < self {
766+
other
767+
} else if self == other {
768+
if self.is_sign_negative() && other.is_sign_positive() { self } else { other }
769+
} else {
770+
self + other
771+
}
772+
}
773+
706774
/// Rounds toward zero and converts to any primitive integer type,
707775
/// assuming that the value is finite and fits in that type.
708776
///

‎library/core/src/num/f64.rs

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -689,6 +689,9 @@ impl f64 {
689689

690690
/// Returns the maximum of the two numbers.
691691
///
692+
/// Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs.
693+
/// This matches the behavior of libm’s fmin.
694+
///
692695
/// ```
693696
/// let x = 1.0_f64;
694697
/// let y = 2.0_f64;
@@ -705,6 +708,9 @@ impl f64 {
705708

706709
/// Returns the minimum of the two numbers.
707710
///
711+
/// Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs.
712+
/// This matches the behavior of libm’s fmin.
713+
///
708714
/// ```
709715
/// let x = 1.0_f64;
710716
/// let y = 2.0_f64;
@@ -719,6 +725,68 @@ impl f64 {
719725
intrinsics::minnumf64(self, other)
720726
}
721727

728+
/// Returns the maximum of the two numbers, propagating NaNs.
729+
///
730+
/// This returns NaN when *either* argument is NaN, as opposed to
731+
/// [`f64::max`] which only returns NaN when *both* arguments are NaN.
732+
///
733+
/// ```
734+
/// #![feature(float_minimum_maximum)]
735+
/// let x = 1.0_f64;
736+
/// let y = 2.0_f64;
737+
///
738+
/// assert_eq!(x.maximum(y), y);
739+
/// assert!(x.maximum(f64::NAN).is_nan());
740+
/// ```
741+
///
742+
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater
743+
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
744+
/// Note that this follows the semantics specified in IEEE 754-2019.
745+
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
746+
#[inline]
747+
pub fn maximum(self, other: f64) -> f64 {
748+
if self > other {
749+
self
750+
} else if other > self {
751+
other
752+
} else if self == other {
753+
if self.is_sign_positive() && other.is_sign_negative() { self } else { other }
754+
} else {
755+
self + other
756+
}
757+
}
758+
759+
/// Returns the minimum of the two numbers, propagating NaNs.
760+
///
761+
/// This returns NaN when *either* argument is NaN, as opposed to
762+
/// [`f64::min`] which only returns NaN when *both* arguments are NaN.
763+
///
764+
/// ```
765+
/// #![feature(float_minimum_maximum)]
766+
/// let x = 1.0_f64;
767+
/// let y = 2.0_f64;
768+
///
769+
/// assert_eq!(x.minimum(y), x);
770+
/// assert!(x.minimum(f64::NAN).is_nan());
771+
/// ```
772+
///
773+
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser
774+
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
775+
/// Note that this follows the semantics specified in IEEE 754-2019.
776+
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
777+
#[inline]
778+
pub fn minimum(self, other: f64) -> f64 {
779+
if self < other {
780+
self
781+
} else if other < self {
782+
other
783+
} else if self == other {
784+
if self.is_sign_negative() && other.is_sign_positive() { self } else { other }
785+
} else {
786+
self + other
787+
}
788+
}
789+
722790
/// Rounds toward zero and converts to any primitive integer type,
723791
/// assuming that the value is finite and fits in that type.
724792
///

‎library/core/tests/lib.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727
#![feature(extern_types)]
2828
#![feature(flt2dec)]
2929
#![feature(fmt_internals)]
30+
#![feature(float_minimum_maximum)]
3031
#![feature(array_from_fn)]
3132
#![feature(hashmap_internals)]
3233
#![feature(try_find)]

‎library/core/tests/num/mod.rs

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -715,6 +715,67 @@ macro_rules! test_float {
715715
assert!(($nan as $fty).max($nan).is_nan());
716716
}
717717
#[test]
718+
fn minimum() {
719+
assert_eq!((0.0 as $fty).minimum(0.0), 0.0);
720+
assert!((0.0 as $fty).minimum(0.0).is_sign_positive());
721+
assert_eq!((-0.0 as $fty).minimum(0.0), -0.0);
722+
assert!((-0.0 as $fty).minimum(0.0).is_sign_negative());
723+
assert_eq!((-0.0 as $fty).minimum(-0.0), -0.0);
724+
assert!((-0.0 as $fty).minimum(-0.0).is_sign_negative());
725+
assert_eq!((9.0 as $fty).minimum(9.0), 9.0);
726+
assert_eq!((-9.0 as $fty).minimum(0.0), -9.0);
727+
assert_eq!((0.0 as $fty).minimum(9.0), 0.0);
728+
assert!((0.0 as $fty).minimum(9.0).is_sign_positive());
729+
assert_eq!((-0.0 as $fty).minimum(9.0), -0.0);
730+
assert!((-0.0 as $fty).minimum(9.0).is_sign_negative());
731+
assert_eq!((-0.0 as $fty).minimum(-9.0), -9.0);
732+
assert_eq!(($inf as $fty).minimum(9.0), 9.0);
733+
assert_eq!((9.0 as $fty).minimum($inf), 9.0);
734+
assert_eq!(($inf as $fty).minimum(-9.0), -9.0);
735+
assert_eq!((-9.0 as $fty).minimum($inf), -9.0);
736+
assert_eq!(($neginf as $fty).minimum(9.0), $neginf);
737+
assert_eq!((9.0 as $fty).minimum($neginf), $neginf);
738+
assert_eq!(($neginf as $fty).minimum(-9.0), $neginf);
739+
assert_eq!((-9.0 as $fty).minimum($neginf), $neginf);
740+
assert!(($nan as $fty).minimum(9.0).is_nan());
741+
assert!(($nan as $fty).minimum(-9.0).is_nan());
742+
assert!((9.0 as $fty).minimum($nan).is_nan());
743+
assert!((-9.0 as $fty).minimum($nan).is_nan());
744+
assert!(($nan as $fty).minimum($nan).is_nan());
745+
}
746+
#[test]
747+
fn maximum() {
748+
assert_eq!((0.0 as $fty).maximum(0.0), 0.0);
749+
assert!((0.0 as $fty).maximum(0.0).is_sign_positive());
750+
assert_eq!((-0.0 as $fty).maximum(0.0), 0.0);
751+
assert!((-0.0 as $fty).maximum(0.0).is_sign_positive());
752+
assert_eq!((-0.0 as $fty).maximum(-0.0), -0.0);
753+
assert!((-0.0 as $fty).maximum(-0.0).is_sign_negative());
754+
assert_eq!((9.0 as $fty).maximum(9.0), 9.0);
755+
assert_eq!((-9.0 as $fty).maximum(0.0), 0.0);
756+
assert!((-9.0 as $fty).maximum(0.0).is_sign_positive());
757+
assert_eq!((-9.0 as $fty).maximum(-0.0), -0.0);
758+
assert!((-9.0 as $fty).maximum(-0.0).is_sign_negative());
759+
assert_eq!((0.0 as $fty).maximum(9.0), 9.0);
760+
assert_eq!((0.0 as $fty).maximum(-9.0), 0.0);
761+
assert!((0.0 as $fty).maximum(-9.0).is_sign_positive());
762+
assert_eq!((-0.0 as $fty).maximum(-9.0), -0.0);
763+
assert!((-0.0 as $fty).maximum(-9.0).is_sign_negative());
764+
assert_eq!(($inf as $fty).maximum(9.0), $inf);
765+
assert_eq!((9.0 as $fty).maximum($inf), $inf);
766+
assert_eq!(($inf as $fty).maximum(-9.0), $inf);
767+
assert_eq!((-9.0 as $fty).maximum($inf), $inf);
768+
assert_eq!(($neginf as $fty).maximum(9.0), 9.0);
769+
assert_eq!((9.0 as $fty).maximum($neginf), 9.0);
770+
assert_eq!(($neginf as $fty).maximum(-9.0), -9.0);
771+
assert_eq!((-9.0 as $fty).maximum($neginf), -9.0);
772+
assert!(($nan as $fty).maximum(9.0).is_nan());
773+
assert!(($nan as $fty).maximum(-9.0).is_nan());
774+
assert!((9.0 as $fty).maximum($nan).is_nan());
775+
assert!((-9.0 as $fty).maximum($nan).is_nan());
776+
assert!(($nan as $fty).maximum($nan).is_nan());
777+
}
778+
#[test]
718779
fn rem_euclid() {
719780
let a: $fty = 42.0;
720781
assert!($inf.rem_euclid(a).is_nan());

‎library/std/src/f32/tests.rs

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,18 @@ fn test_max_nan() {
1919
assert_eq!(2.0f32.max(f32::NAN), 2.0);
2020
}
2121

22+
#[test]
23+
fn test_minimum() {
24+
assert!(f32::NAN.minimum(2.0).is_nan());
25+
assert!(2.0f32.minimum(f32::NAN).is_nan());
26+
}
27+
28+
#[test]
29+
fn test_maximum() {
30+
assert!(f32::NAN.maximum(2.0).is_nan());
31+
assert!(2.0f32.maximum(f32::NAN).is_nan());
32+
}
33+
2234
#[test]
2335
fn test_nan() {
2436
let nan: f32 = f32::NAN;

‎library/std/src/lib.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -287,6 +287,7 @@
287287
#![feature(exhaustive_patterns)]
288288
#![feature(extend_one)]
289289
#![feature(fn_traits)]
290+
#![feature(float_minimum_maximum)]
290291
#![feature(format_args_nl)]
291292
#![feature(gen_future)]
292293
#![feature(generator_trait)]

‎src/test/ui/associated-types/issue-87261.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -83,17 +83,17 @@ fn main() {
8383
//~^ ERROR type mismatch resolving `<impl DerivedTrait as Trait>::Associated == ()`
8484

8585
accepts_trait(returns_opaque_foo());
86-
//~^ ERROR type mismatch resolving `<impl Trait+Foo as Trait>::Associated == ()`
86+
//~^ ERROR type mismatch resolving `<impl Trait + Foo as Trait>::Associated == ()`
8787

8888
accepts_trait(returns_opaque_derived_foo());
89-
//~^ ERROR type mismatch resolving `<impl DerivedTrait+Foo as Trait>::Associated == ()`
89+
//~^ ERROR type mismatch resolving `<impl DerivedTrait + Foo as Trait>::Associated == ()`
9090

9191
accepts_generic_trait(returns_opaque_generic());
9292
//~^ ERROR type mismatch resolving `<impl GenericTrait<()> as GenericTrait<()>>::Associated == ()`
9393

9494
accepts_generic_trait(returns_opaque_generic_foo());
95-
//~^ ERROR type mismatch resolving `<impl GenericTrait<()>+Foo as GenericTrait<()>>::Associated == ()`
95+
//~^ ERROR type mismatch resolving `<impl GenericTrait<()> + Foo as GenericTrait<()>>::Associated == ()`
9696

9797
accepts_generic_trait(returns_opaque_generic_duplicate());
98-
//~^ ERROR type mismatch resolving `<impl GenericTrait<()>+GenericTrait<u8> as GenericTrait<()>>::Associated == ()`
98+
//~^ ERROR type mismatch resolving `<impl GenericTrait<()> + GenericTrait<u8> as GenericTrait<()>>::Associated == ()`
9999
}

0 commit comments

Comments
 (0)