Jauhien Piatlicki <jauhien@gentoo.org> Jauhien Piatlicki <jpiatlicki@zertisa.com>
Jay True <glacjay@gmail.com>
Jeremy Letang <letang.jeremy@gmail.com>
+Jeremy Stucki <dev@jeremystucki.ch> <stucki.jeremy@gmail.com>
+Jeremy Stucki <dev@jeremystucki.ch> <jeremy@myelin.ch>
+Jeremy Stucki <dev@jeremystucki.ch>
Jethro Beekman <github@jbeekman.nl>
Jihyun Yu <j.yu@navercorp.com> <yjh0502@gmail.com>
Jihyun Yu <j.yu@navercorp.com> jihyun <jihyun@nablecomm.com>
[[package]]
name = "libc"
-version = "0.2.60"
+version = "0.2.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d44e80633f007889c7eff624b709ab43c92d708caad982295768a7b13ca3b5eb"
+checksum = "c665266eb592905e8503ba3403020f4b8794d26263f412ca33171600eca9a6fa"
dependencies = [
"rustc-std-workspace-core",
]
[[package]]
name = "rustfmt-nightly"
-version = "1.4.4"
+version = "1.4.5"
dependencies = [
"annotate-snippets",
"atty",
if !up_to_date(Path::new("build.rs"), ×tamp) || !up_to_date(src_dir, ×tamp) {
Ok(NativeLibBoilerplate {
src_dir: src_dir.to_path_buf(),
- out_dir: out_dir,
+ out_dir,
})
} else {
Err(())
ENV TARGETS=$TARGETS,armv7-unknown-linux-musleabihf
ENV TARGETS=$TARGETS,aarch64-unknown-linux-musl
ENV TARGETS=$TARGETS,sparc64-unknown-linux-gnu
-# FIXME: temporarily disable the redox builder,
-# see: https://github.com/rust-lang/rust/issues/63160
-# ENV TARGETS=$TARGETS,x86_64-unknown-redox
+ENV TARGETS=$TARGETS,x86_64-unknown-redox
ENV TARGETS=$TARGETS,thumbv6m-none-eabi
ENV TARGETS=$TARGETS,thumbv7m-none-eabi
ENV TARGETS=$TARGETS,thumbv7em-none-eabi
CC_thumbv7neon_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc \
AR_thumbv7neon_unknown_linux_gnueabihf=arm-linux-gnueabihf-ar \
CXX_thumbv7neon_unknown_linux_gnueabihf=arm-linux-gnueabihf-g++
-
+
ENV RUST_CONFIGURE_ARGS \
--musl-root-armv5te=/musl-armv5te \
--musl-root-arm=/musl-arm \
To fix the lint, add documentation to all items.
-## single-use-lifetime
+## single-use-lifetimes
This lint detects lifetimes that are only used once. Some example code that
triggers this lint:
other
}
- /// Moves all the elements of `other` into `Self`, leaving `other` empty.
+ /// Moves all the elements of `other` into `self`, leaving `other` empty.
///
/// # Panics
///
///
/// let mut buf = VecDeque::new();
/// buf.extend(1..5);
- /// buf.retain(|&x| x%2 == 0);
+ /// buf.retain(|&x| x % 2 == 0);
/// assert_eq!(buf, [2, 4]);
/// ```
///
impl Ord for $t {
#[inline]
fn cmp(&self, other: &$t) -> Ordering {
- if *self == *other { Equal }
- else if *self < *other { Less }
- else { Greater }
+ // The order here is important to generate more optimal assembly.
+ // See <https://github.com/rust-lang/rust/issues/63758> for more info.
+ if *self < *other { Less }
+ else if *self > *other { Greater }
+ else { Equal }
}
}
)*)
Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>
{
match self.peeked.take() {
- Some(None) => return Try::from_ok(init),
+ Some(None) => Try::from_ok(init),
Some(Some(v)) => match self.iter.try_rfold(init, &mut f).into_result() {
Ok(acc) => f(acc, v),
Err(e) => {
where Fold: FnMut(Acc, Self::Item) -> Acc,
{
match self.peeked {
- Some(None) => return init,
+ Some(None) => init,
Some(Some(v)) => {
let acc = self.iter.rfold(init, &mut fold);
fold(acc, v)
/// use std::f32;
///
/// let x = 2.0_f32;
- /// let abs_difference = (x.recip() - (1.0/x)).abs();
+ /// let abs_difference = (x.recip() - (1.0 / x)).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
///
/// ```
/// let x = 2.0_f64;
- /// let abs_difference = (x.recip() - (1.0/x)).abs();
+ /// let abs_difference = (x.recip() - (1.0 / x)).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
if size == 0 {
// This _cannot_ use `unchecked_sub` because we depend on wrapping
// to represent the length of long ZST slice iterators.
- let diff = ($self.end as usize).wrapping_sub(start as usize);
- diff
+ ($self.end as usize).wrapping_sub(start as usize)
} else {
// We know that `start <= end`, so can do better than `offset_from`,
// which needs to deal in signed. By setting appropriate flags here
&self.forest.krate.attrs
}
- pub fn get_module(&self, module: DefId) -> (&'hir Mod, Span, HirId)
- {
+ pub fn get_module(&self, module: DefId) -> (&'hir Mod, Span, HirId) {
let hir_id = self.as_local_hir_id(module).unwrap();
self.read(hir_id);
match self.find_entry(hir_id).unwrap().node {
..
}) => (m, span, hir_id),
Node::Crate => (&self.forest.krate.module, self.forest.krate.span, hir_id),
- _ => panic!("not a module")
+ node => panic!("not a module: {:?}", node),
}
}
}
}
+ /// Wether `hir_id` corresponds to a `mod` or a crate.
+ pub fn is_hir_id_module(&self, hir_id: HirId) -> bool {
+ match self.lookup(hir_id) {
+ Some(Entry { node: Node::Item(Item { node: ItemKind::Mod(_), .. }), .. }) |
+ Some(Entry { node: Node::Crate, .. }) => true,
+ _ => false,
+ }
+ }
+
+
/// If there is some error when walking the parents (e.g., a node does not
/// have a parent in the map or a node can't be found), then we return the
/// last good `HirId` we found. Note that reaching the crate root (`id == 0`),
hir::MatchSource::IfLetDesugar { .. } => "`if let` arms have compatible types",
_ => "match arms have compatible types",
},
- IfExpression { .. } => "if and else have compatible types",
+ IfExpression { .. } => "if and else have incompatible types",
IfExpressionWithNoElse => "if missing an else returns ()",
MainFunctionType => "`main` function has the correct type",
StartFunctionType => "`start` function has the correct type",
}
impl<'tcx> TyCtxt<'tcx> {
- pub fn note_and_explain_type_err(self,
- db: &mut DiagnosticBuilder<'_>,
- err: &TypeError<'tcx>,
- sp: Span) {
+ pub fn note_and_explain_type_err(
+ self,
+ db: &mut DiagnosticBuilder<'_>,
+ err: &TypeError<'tcx>,
+ sp: Span,
+ ) {
use self::TypeError::*;
- match err.clone() {
+ match err {
Sorts(values) => {
let expected_str = values.expected.sort_string(self);
let found_str = values.found.sort_string(self);
db.note("no two closures, even if identical, have the same type");
db.help("consider boxing your closure and/or using it as a trait object");
}
+ if expected_str == found_str && expected_str == "opaque type" { // Issue #63167
+ db.note("distinct uses of `impl Trait` result in different opaque types");
+ let e_str = values.expected.to_string();
+ let f_str = values.found.to_string();
+ if &e_str == &f_str && &e_str == "impl std::future::Future" {
+ // FIXME: use non-string based check.
+ db.help("if both `Future`s have the same `Output` type, consider \
+ `.await`ing on both of them");
+ }
+ }
if let (ty::Infer(ty::IntVar(_)), ty::Float(_)) =
(&values.found.sty, &values.expected.sty) // Issue #53280
{
}
}
- fn update_macro_reachable_mod(
- &mut self,
- reachable_mod: hir::HirId,
- defining_mod: DefId,
- ) {
+ fn update_macro_reachable_mod(&mut self, reachable_mod: hir::HirId, defining_mod: DefId) {
let module_def_id = self.tcx.hir().local_def_id(reachable_mod);
let module = self.tcx.hir().get_module(module_def_id).0;
for item_id in &module.item_ids {
self.update_macro_reachable_def(hir_id, def_kind, vis, defining_mod);
}
}
-
if let Some(exports) = self.tcx.module_exports(module_def_id) {
for export in exports {
if export.vis.is_accessible_from(defining_mod, self.tcx) {
if let Res::Def(def_kind, def_id) = export.res {
let vis = def_id_visibility(self.tcx, def_id).0;
if let Some(hir_id) = self.tcx.hir().as_local_hir_id(def_id) {
- self.update_macro_reachable_def(
- hir_id,
- def_kind,
- vis,
- defining_mod,
- );
+ self.update_macro_reachable_def(hir_id, def_kind, vis, defining_mod);
}
}
}
self.tcx.hir().local_def_id(md.hir_id)
).unwrap();
let mut module_id = self.tcx.hir().as_local_hir_id(macro_module_def_id).unwrap();
+ if !self.tcx.hir().is_hir_id_module(module_id) {
+ // `module_id` doesn't correspond to a `mod`, return early (#63164).
+ return;
+ }
let level = if md.vis.node.is_pub() { self.get(module_id) } else { None };
let new_level = self.update(md.hir_id, level);
if new_level.is_none() {
- return
+ return;
}
loop {
var themePicker = document.getElementById("theme-picker");
function showThemeButtonState() {{
- themes.style.display = "none";
- themePicker.style.borderBottomRightRadius = "3px";
- themePicker.style.borderBottomLeftRadius = "3px";
-}}
-
-function hideThemeButtonState() {{
themes.style.display = "block";
themePicker.style.borderBottomRightRadius = "0";
themePicker.style.borderBottomLeftRadius = "0";
}}
+function hideThemeButtonState() {{
+ themes.style.display = "none";
+ themePicker.style.borderBottomRightRadius = "3px";
+ themePicker.style.borderBottomLeftRadius = "3px";
+}}
+
function switchThemeButtonState() {{
if (themes.style.display === "block") {{
- showThemeButtonState();
- }} else {{
hideThemeButtonState();
+ }} else {{
+ showThemeButtonState();
}}
}};
sidebar.appendChild(div);
}
}
- var themePicker = document.getElementsByClassName("theme-picker");
- if (themePicker && themePicker.length > 0) {
- themePicker[0].style.display = "none";
+ var themePickers = document.getElementsByClassName("theme-picker");
+ if (themePickers && themePickers.length > 0) {
+ themePickers[0].style.display = "none";
}
}
filler.remove();
}
document.getElementsByTagName("body")[0].style.marginTop = "";
- var themePicker = document.getElementsByClassName("theme-picker");
- if (themePicker && themePicker.length > 0) {
- themePicker[0].style.display = null;
+ var themePickers = document.getElementsByClassName("theme-picker");
+ if (themePickers && themePickers.length > 0) {
+ themePickers[0].style.display = null;
}
}
/// let b = 60.0_f32;
///
/// // 100.0
- /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
+ /// let abs_difference = (m.mul_add(x, b) - ((m * x) + b)).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
/// use std::f32;
///
/// let x = 2.0_f32;
- /// let abs_difference = (x.powi(2) - x*x).abs();
+ /// let abs_difference = (x.powi(2) - (x * x)).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
/// use std::f32;
///
/// let x = 2.0_f32;
- /// let abs_difference = (x.powf(2.0) - x*x).abs();
+ /// let abs_difference = (x.powf(2.0) - (x * x)).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
/// ```
/// use std::f32;
///
- /// let x = f32::consts::PI/2.0;
+ /// let x = f32::consts::FRAC_PI_2;
///
/// let abs_difference = (x.sin() - 1.0).abs();
///
/// ```
/// use std::f32;
///
- /// let x = 2.0*f32::consts::PI;
+ /// let x = 2.0 * f32::consts::PI;
///
/// let abs_difference = (x.cos() - 1.0).abs();
///
/// ```
/// use std::f32;
///
- /// let x = f32::consts::PI / 4.0;
+ /// let x = f32::consts::FRAC_PI_4;
/// let abs_difference = (x.tan() - 1.0).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
/// use std::f32;
///
- /// let f = f32::consts::PI / 2.0;
+ /// let f = f32::consts::FRAC_PI_2;
///
/// // asin(sin(pi/2))
- /// let abs_difference = (f.sin().asin() - f32::consts::PI / 2.0).abs();
+ /// let abs_difference = (f.sin().asin() - f32::consts::FRAC_PI_2).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
/// ```
/// use std::f32;
///
- /// let f = f32::consts::PI / 4.0;
+ /// let f = f32::consts::FRAC_PI_4;
///
/// // acos(cos(pi/4))
- /// let abs_difference = (f.cos().acos() - f32::consts::PI / 4.0).abs();
+ /// let abs_difference = (f.cos().acos() - f32::consts::FRAC_PI_4).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// ```
/// ```
/// use std::f32;
///
- /// let pi = f32::consts::PI;
/// // Positive angles measured counter-clockwise
/// // from positive x axis
/// // -pi/4 radians (45 deg clockwise)
/// let x2 = -3.0f32;
/// let y2 = 3.0f32;
///
- /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
- /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
+ /// let abs_difference_1 = (y1.atan2(x1) - (-f32::consts::FRAC_PI_4)).abs();
+ /// let abs_difference_2 = (y2.atan2(x2) - (3.0 * f32::consts::FRAC_PI_4)).abs();
///
/// assert!(abs_difference_1 <= f32::EPSILON);
/// assert!(abs_difference_2 <= f32::EPSILON);
/// ```
/// use std::f32;
///
- /// let x = f32::consts::PI/4.0;
+ /// let x = f32::consts::FRAC_PI_4;
/// let f = x.sin_cos();
///
/// let abs_difference_0 = (f.0 - x.sin()).abs();
///
/// let f = x.sinh();
/// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
- /// let g = (e*e - 1.0)/(2.0*e);
+ /// let g = ((e * e) - 1.0) / (2.0 * e);
/// let abs_difference = (f - g).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// let x = 1.0f32;
/// let f = x.cosh();
/// // Solving cosh() at 1 gives this result
- /// let g = (e*e + 1.0)/(2.0*e);
+ /// let g = ((e * e) + 1.0) / (2.0 * e);
/// let abs_difference = (f - g).abs();
///
/// // Same result
///
/// let f = x.tanh();
/// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
- /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));
+ /// let g = (1.0 - e.powi(-2)) / (1.0 + e.powi(-2));
/// let abs_difference = (f - g).abs();
///
/// assert!(abs_difference <= f32::EPSILON);
/// let b = 60.0_f64;
///
/// // 100.0
- /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
+ /// let abs_difference = (m.mul_add(x, b) - ((m * x) + b)).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
///
/// ```
/// let x = 2.0_f64;
- /// let abs_difference = (x.powi(2) - x*x).abs();
+ /// let abs_difference = (x.powi(2) - (x * x)).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
///
/// ```
/// let x = 2.0_f64;
- /// let abs_difference = (x.powf(2.0) - x*x).abs();
+ /// let abs_difference = (x.powf(2.0) - (x * x)).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
/// ```
/// use std::f64;
///
- /// let x = f64::consts::PI/2.0;
+ /// let x = f64::consts::FRAC_PI_2;
///
/// let abs_difference = (x.sin() - 1.0).abs();
///
/// ```
/// use std::f64;
///
- /// let x = 2.0*f64::consts::PI;
+ /// let x = 2.0 * f64::consts::PI;
///
/// let abs_difference = (x.cos() - 1.0).abs();
///
/// ```
/// use std::f64;
///
- /// let x = f64::consts::PI/4.0;
+ /// let x = f64::consts::FRAC_PI_4;
/// let abs_difference = (x.tan() - 1.0).abs();
///
/// assert!(abs_difference < 1e-14);
/// ```
/// use std::f64;
///
- /// let f = f64::consts::PI / 2.0;
+ /// let f = f64::consts::FRAC_PI_2;
///
/// // asin(sin(pi/2))
- /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs();
+ /// let abs_difference = (f.sin().asin() - f64::consts::FRAC_PI_2).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
/// ```
/// use std::f64;
///
- /// let f = f64::consts::PI / 4.0;
+ /// let f = f64::consts::FRAC_PI_4;
///
/// // acos(cos(pi/4))
- /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs();
+ /// let abs_difference = (f.cos().acos() - f64::consts::FRAC_PI_4).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
/// ```
/// use std::f64;
///
- /// let pi = f64::consts::PI;
/// // Positive angles measured counter-clockwise
/// // from positive x axis
/// // -pi/4 radians (45 deg clockwise)
/// let x2 = -3.0_f64;
/// let y2 = 3.0_f64;
///
- /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
- /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
+ /// let abs_difference_1 = (y1.atan2(x1) - (-f64::consts::FRAC_PI_4)).abs();
+ /// let abs_difference_2 = (y2.atan2(x2) - (3.0 * f64::consts::FRAC_PI_4)).abs();
///
/// assert!(abs_difference_1 < 1e-10);
/// assert!(abs_difference_2 < 1e-10);
/// ```
/// use std::f64;
///
- /// let x = f64::consts::PI/4.0;
+ /// let x = f64::consts::FRAC_PI_4;
/// let f = x.sin_cos();
///
/// let abs_difference_0 = (f.0 - x.sin()).abs();
///
/// let f = x.sinh();
/// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
- /// let g = (e*e - 1.0)/(2.0*e);
+ /// let g = ((e * e) - 1.0) / (2.0 * e);
/// let abs_difference = (f - g).abs();
///
/// assert!(abs_difference < 1e-10);
/// let x = 1.0_f64;
/// let f = x.cosh();
/// // Solving cosh() at 1 gives this result
- /// let g = (e*e + 1.0)/(2.0*e);
+ /// let g = ((e * e) + 1.0) / (2.0 * e);
/// let abs_difference = (f - g).abs();
///
/// // Same result
///
/// let f = x.tanh();
/// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
- /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));
+ /// let g = (1.0 - e.powi(-2)) / (1.0 + e.powi(-2));
/// let abs_difference = (f - g).abs();
///
/// assert!(abs_difference < 1.0e-10);
/// use std::ffi::{CString, CStr};
///
/// let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
- /// let c_str = c_string.as_c_str();
- /// assert_eq!(c_str,
+ /// let cstr = c_string.as_c_str();
+ /// assert_eq!(cstr,
/// CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
/// ```
#[inline]
/// ```
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"hello");
- /// assert!(c_str.is_err());
+ /// let cstr = CStr::from_bytes_with_nul(b"hello");
+ /// assert!(cstr.is_err());
/// ```
///
/// Creating a `CStr` with an interior nul byte is an error:
/// ```
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"he\0llo\0");
- /// assert!(c_str.is_err());
+ /// let cstr = CStr::from_bytes_with_nul(b"he\0llo\0");
+ /// assert!(cstr.is_err());
/// ```
#[stable(feature = "cstr_from_bytes", since = "1.10.0")]
pub fn from_bytes_with_nul(bytes: &[u8])
/// ```
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
- /// assert_eq!(c_str.to_bytes(), b"foo");
+ /// let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
+ /// assert_eq!(cstr.to_bytes(), b"foo");
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
/// ```
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
- /// assert_eq!(c_str.to_bytes_with_nul(), b"foo\0");
+ /// let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
+ /// assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
/// ```
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
- /// assert_eq!(c_str.to_str(), Ok("foo"));
+ /// let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
+ /// assert_eq!(cstr.to_str(), Ok("foo"));
/// ```
#[stable(feature = "cstr_to_str", since = "1.4.0")]
pub fn to_str(&self) -> Result<&str, str::Utf8Error> {
/// use std::borrow::Cow;
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"Hello World\0")
+ /// let cstr = CStr::from_bytes_with_nul(b"Hello World\0")
/// .expect("CStr::from_bytes_with_nul failed");
- /// assert_eq!(c_str.to_string_lossy(), Cow::Borrowed("Hello World"));
+ /// assert_eq!(cstr.to_string_lossy(), Cow::Borrowed("Hello World"));
/// ```
///
/// Calling `to_string_lossy` on a `CStr` containing invalid UTF-8:
/// use std::borrow::Cow;
/// use std::ffi::CStr;
///
- /// let c_str = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
+ /// let cstr = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
/// .expect("CStr::from_bytes_with_nul failed");
/// assert_eq!(
- /// c_str.to_string_lossy(),
+ /// cstr.to_string_lossy(),
/// Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
/// );
/// ```
/// ```
/// use std::ffi::OsString;
///
- /// let mut os_string = OsString::with_capacity(10);
+ /// let os_string = OsString::with_capacity(10);
/// assert!(os_string.capacity() >= 10);
/// ```
#[stable(feature = "osstring_simple_functions", since = "1.9.0")]
/// Note that this does **not** return the number of bytes in the string in
/// OS string form.
///
- /// The length returned is that of the underlying storage used by `OsStr`;
+ /// The length returned is that of the underlying storage used by `OsStr`.
/// As discussed in the [`OsString`] introduction, [`OsString`] and `OsStr`
/// store strings in a form best suited for cheap inter-conversion between
/// native-platform and Rust string forms, which may differ significantly
/// [`len`]: #method.len
///
/// Note: This example shows the internals of `&str`. `unsafe` should not be
-/// used to get a string slice under normal circumstances. Use `as_slice`
+/// used to get a string slice under normal circumstances. Use `as_str`
/// instead.
#[stable(feature = "rust1", since = "1.0.0")]
mod prim_str { }
cvt_r(|| libc::dup2(fd, libc::STDERR_FILENO))?;
}
- if cfg!(not(any(target_os = "l4re"))) {
+ #[cfg(not(target_os = "l4re"))]
+ {
if let Some(u) = self.get_gid() {
cvt(libc::setgid(u as gid_t))?;
}
if let Some(u) = self.get_uid() {
+ // When dropping privileges from root, the `setgroups` call
+ // will remove any extraneous groups. If we don't call this,
+ // then even though our uid has dropped, we may still have
+ // groups that enable us to do super-user things. This will
+ // fail if we aren't root, so don't bother checking the
+ // return value, this is just done as an optimistic
+ // privilege dropping function.
//FIXME: Redox kernel does not support setgroups yet
- if cfg!(not(target_os = "redox")) {
- // When dropping privileges from root, the `setgroups` call
- // will remove any extraneous groups. If we don't call this,
- // then even though our uid has dropped, we may still have
- // groups that enable us to do super-user things. This will
- // fail if we aren't root, so don't bother checking the
- // return value, this is just done as an optimistic
- // privilege dropping function.
- let _ = libc::setgroups(0, ptr::null());
- }
-
+ #[cfg(not(target_os = "redox"))]
+ let _ = libc::setgroups(0, ptr::null());
cvt(libc::setuid(u as uid_t))?;
}
}
}
// emscripten has no signal support.
- #[cfg(not(any(target_os = "emscripten")))]
+ #[cfg(not(target_os = "emscripten"))]
{
use crate::mem::MaybeUninit;
// Reset signal handling so the child process starts in a
#[cfg(any(
target_os = "cloudabi",
- target_os = "redox",
all(target_arch = "wasm32", not(target_os = "emscripten")),
all(target_vendor = "fortanix", target_env = "sgx")
))]
fn stdout_isatty() -> bool {
- // FIXME: Implement isatty on Redox and SGX
+ // FIXME: Implement isatty on SGX
false
}
#[cfg(unix)]
}
}
- #[cfg(target_os = "redox")]
+ #[cfg(target_os = "vxworks")]
fn num_cpus() -> usize {
- // FIXME: Implement num_cpus on Redox
+ // FIXME: Implement num_cpus on vxWorks
1
}
- #[cfg(target_os = "vxworks")]
+ #[cfg(target_os = "redox")]
fn num_cpus() -> usize {
- // FIXME: Implement num_cpus on vxWorks
+ // FIXME: Implement num_cpus on Redox
1
}
target_os = "ios",
target_os = "linux",
target_os = "macos",
- target_os = "solaris"
+ target_os = "solaris",
))]
fn num_cpus() -> usize {
unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as usize }
--- /dev/null
+// This is test for more optimal Ord implementation for integers.
+// See <https://github.com/rust-lang/rust/issues/63758> for more info.
+
+// compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+// CHECK-LABEL: @cmp_signed
+#[no_mangle]
+pub fn cmp_signed(a: i64, b: i64) -> Ordering {
+// CHECK: icmp slt
+// CHECK: icmp sgt
+// CHECK: zext i1
+// CHECK: select i1
+ a.cmp(&b)
+}
+
+// CHECK-LABEL: @cmp_unsigned
+#[no_mangle]
+pub fn cmp_unsigned(a: u32, b: u32) -> Ordering {
+// CHECK: icmp ult
+// CHECK: icmp ugt
+// CHECK: zext i1
+// CHECK: select i1
+ a.cmp(&b)
+}
--- /dev/null
+// run-pass
+#![feature(decl_macro)]
+
+pub fn moo() {
+ pub macro ABC() {{}}
+}
+
+fn main() {}
--- /dev/null
+#![feature(core_intrinsics)]
+#![allow(warnings)]
+#![crate_type = "rlib"]
+
+use std::intrinsics;
+
+#[derive(Copy, Clone)]
+pub struct Foo(i64);
+pub type Bar = &'static Fn();
+pub type Quux = [u8; 100];
+
+pub unsafe fn test_bool_load(p: &mut bool, v: bool) {
+ intrinsics::atomic_load(p);
+ //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `bool`
+}
+
+pub unsafe fn test_bool_store(p: &mut bool, v: bool) {
+ intrinsics::atomic_store(p, v);
+ //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `bool`
+}
+
+pub unsafe fn test_bool_xchg(p: &mut bool, v: bool) {
+ intrinsics::atomic_xchg(p, v);
+ //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `bool`
+}
+
+pub unsafe fn test_bool_cxchg(p: &mut bool, v: bool) {
+ intrinsics::atomic_cxchg(p, v, v);
+ //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `bool`
+}
+
+pub unsafe fn test_Foo_load(p: &mut Foo, v: Foo) {
+ intrinsics::atomic_load(p);
+ //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `Foo`
+}
+
+pub unsafe fn test_Foo_store(p: &mut Foo, v: Foo) {
+ intrinsics::atomic_store(p, v);
+ //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `Foo`
+}
+
+pub unsafe fn test_Foo_xchg(p: &mut Foo, v: Foo) {
+ intrinsics::atomic_xchg(p, v);
+ //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `Foo`
+}
+
+pub unsafe fn test_Foo_cxchg(p: &mut Foo, v: Foo) {
+ intrinsics::atomic_cxchg(p, v, v);
+ //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `Foo`
+}
+
+pub unsafe fn test_Bar_load(p: &mut Bar, v: Bar) {
+ intrinsics::atomic_load(p);
+ //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
+}
+
+pub unsafe fn test_Bar_store(p: &mut Bar, v: Bar) {
+ intrinsics::atomic_store(p, v);
+ //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
+}
+
+pub unsafe fn test_Bar_xchg(p: &mut Bar, v: Bar) {
+ intrinsics::atomic_xchg(p, v);
+ //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
+}
+
+pub unsafe fn test_Bar_cxchg(p: &mut Bar, v: Bar) {
+ intrinsics::atomic_cxchg(p, v, v);
+ //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
+}
+
+pub unsafe fn test_Quux_load(p: &mut Quux, v: Quux) {
+ intrinsics::atomic_load(p);
+ //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+pub unsafe fn test_Quux_store(p: &mut Quux, v: Quux) {
+ intrinsics::atomic_store(p, v);
+ //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+pub unsafe fn test_Quux_xchg(p: &mut Quux, v: Quux) {
+ intrinsics::atomic_xchg(p, v);
+ //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+pub unsafe fn test_Quux_cxchg(p: &mut Quux, v: Quux) {
+ intrinsics::atomic_cxchg(p, v, v);
+ //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `[u8; 100]`
+}
--- /dev/null
+error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `bool`
+ --> $DIR/non-integer-atomic.rs:13:5
+ |
+LL | intrinsics::atomic_load(p);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `bool`
+ --> $DIR/non-integer-atomic.rs:18:5
+ |
+LL | intrinsics::atomic_store(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `bool`
+ --> $DIR/non-integer-atomic.rs:23:5
+ |
+LL | intrinsics::atomic_xchg(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `bool`
+ --> $DIR/non-integer-atomic.rs:28:5
+ |
+LL | intrinsics::atomic_cxchg(p, v, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `Foo`
+ --> $DIR/non-integer-atomic.rs:33:5
+ |
+LL | intrinsics::atomic_load(p);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `Foo`
+ --> $DIR/non-integer-atomic.rs:38:5
+ |
+LL | intrinsics::atomic_store(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `Foo`
+ --> $DIR/non-integer-atomic.rs:43:5
+ |
+LL | intrinsics::atomic_xchg(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `Foo`
+ --> $DIR/non-integer-atomic.rs:48:5
+ |
+LL | intrinsics::atomic_cxchg(p, v, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
+ --> $DIR/non-integer-atomic.rs:53:5
+ |
+LL | intrinsics::atomic_load(p);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
+ --> $DIR/non-integer-atomic.rs:58:5
+ |
+LL | intrinsics::atomic_store(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
+ --> $DIR/non-integer-atomic.rs:63:5
+ |
+LL | intrinsics::atomic_xchg(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
+ --> $DIR/non-integer-atomic.rs:68:5
+ |
+LL | intrinsics::atomic_cxchg(p, v, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `[u8; 100]`
+ --> $DIR/non-integer-atomic.rs:73:5
+ |
+LL | intrinsics::atomic_load(p);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `[u8; 100]`
+ --> $DIR/non-integer-atomic.rs:78:5
+ |
+LL | intrinsics::atomic_store(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `[u8; 100]`
+ --> $DIR/non-integer-atomic.rs:83:5
+ |
+LL | intrinsics::atomic_xchg(p, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `[u8; 100]`
+ --> $DIR/non-integer-atomic.rs:88:5
+ |
+LL | intrinsics::atomic_cxchg(p, v, v);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors
+
+++ /dev/null
-#![feature(core_intrinsics)]
-#![allow(warnings)]
-#![crate_type = "rlib"]
-
-use std::intrinsics;
-
-#[derive(Copy, Clone)]
-pub struct Foo(i64);
-pub type Bar = &'static Fn();
-pub type Quux = [u8; 100];
-
-pub unsafe fn test_bool_load(p: &mut bool, v: bool) {
- intrinsics::atomic_load(p);
- //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `bool`
-}
-
-pub unsafe fn test_bool_store(p: &mut bool, v: bool) {
- intrinsics::atomic_store(p, v);
- //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `bool`
-}
-
-pub unsafe fn test_bool_xchg(p: &mut bool, v: bool) {
- intrinsics::atomic_xchg(p, v);
- //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `bool`
-}
-
-pub unsafe fn test_bool_cxchg(p: &mut bool, v: bool) {
- intrinsics::atomic_cxchg(p, v, v);
- //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `bool`
-}
-
-pub unsafe fn test_Foo_load(p: &mut Foo, v: Foo) {
- intrinsics::atomic_load(p);
- //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `Foo`
-}
-
-pub unsafe fn test_Foo_store(p: &mut Foo, v: Foo) {
- intrinsics::atomic_store(p, v);
- //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `Foo`
-}
-
-pub unsafe fn test_Foo_xchg(p: &mut Foo, v: Foo) {
- intrinsics::atomic_xchg(p, v);
- //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `Foo`
-}
-
-pub unsafe fn test_Foo_cxchg(p: &mut Foo, v: Foo) {
- intrinsics::atomic_cxchg(p, v, v);
- //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `Foo`
-}
-
-pub unsafe fn test_Bar_load(p: &mut Bar, v: Bar) {
- intrinsics::atomic_load(p);
- //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
-}
-
-pub unsafe fn test_Bar_store(p: &mut Bar, v: Bar) {
- intrinsics::atomic_store(p, v);
- //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
-}
-
-pub unsafe fn test_Bar_xchg(p: &mut Bar, v: Bar) {
- intrinsics::atomic_xchg(p, v);
- //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
-}
-
-pub unsafe fn test_Bar_cxchg(p: &mut Bar, v: Bar) {
- intrinsics::atomic_cxchg(p, v, v);
- //~^ ERROR expected basic integer type, found `&dyn std::ops::Fn()`
-}
-
-pub unsafe fn test_Quux_load(p: &mut Quux, v: Quux) {
- intrinsics::atomic_load(p);
- //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `[u8; 100]`
-}
-
-pub unsafe fn test_Quux_store(p: &mut Quux, v: Quux) {
- intrinsics::atomic_store(p, v);
- //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `[u8; 100]`
-}
-
-pub unsafe fn test_Quux_xchg(p: &mut Quux, v: Quux) {
- intrinsics::atomic_xchg(p, v);
- //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `[u8; 100]`
-}
-
-pub unsafe fn test_Quux_cxchg(p: &mut Quux, v: Quux) {
- intrinsics::atomic_cxchg(p, v, v);
- //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `[u8; 100]`
-}
+++ /dev/null
-error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `bool`
- --> $DIR/non-interger-atomic.rs:13:5
- |
-LL | intrinsics::atomic_load(p);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `bool`
- --> $DIR/non-interger-atomic.rs:18:5
- |
-LL | intrinsics::atomic_store(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `bool`
- --> $DIR/non-interger-atomic.rs:23:5
- |
-LL | intrinsics::atomic_xchg(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `bool`
- --> $DIR/non-interger-atomic.rs:28:5
- |
-LL | intrinsics::atomic_cxchg(p, v, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `Foo`
- --> $DIR/non-interger-atomic.rs:33:5
- |
-LL | intrinsics::atomic_load(p);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `Foo`
- --> $DIR/non-interger-atomic.rs:38:5
- |
-LL | intrinsics::atomic_store(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `Foo`
- --> $DIR/non-interger-atomic.rs:43:5
- |
-LL | intrinsics::atomic_xchg(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `Foo`
- --> $DIR/non-interger-atomic.rs:48:5
- |
-LL | intrinsics::atomic_cxchg(p, v, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
- --> $DIR/non-interger-atomic.rs:53:5
- |
-LL | intrinsics::atomic_load(p);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
- --> $DIR/non-interger-atomic.rs:58:5
- |
-LL | intrinsics::atomic_store(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
- --> $DIR/non-interger-atomic.rs:63:5
- |
-LL | intrinsics::atomic_xchg(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `&dyn std::ops::Fn()`
- --> $DIR/non-interger-atomic.rs:68:5
- |
-LL | intrinsics::atomic_cxchg(p, v, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_load` intrinsic: expected basic integer type, found `[u8; 100]`
- --> $DIR/non-interger-atomic.rs:73:5
- |
-LL | intrinsics::atomic_load(p);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_store` intrinsic: expected basic integer type, found `[u8; 100]`
- --> $DIR/non-interger-atomic.rs:78:5
- |
-LL | intrinsics::atomic_store(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_xchg` intrinsic: expected basic integer type, found `[u8; 100]`
- --> $DIR/non-interger-atomic.rs:83:5
- |
-LL | intrinsics::atomic_xchg(p, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `atomic_cxchg` intrinsic: expected basic integer type, found `[u8; 100]`
- --> $DIR/non-interger-atomic.rs:88:5
- |
-LL | intrinsics::atomic_cxchg(p, v, v);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 16 previous errors
-
--- /dev/null
+// edition:2018
+use core::future::Future;
+
+async fn base_thing() -> Result<(), ()> {
+ Ok(())
+}
+
+fn thing_one() -> impl Future<Output = Result<(), ()>> {
+ base_thing()
+}
+
+fn thing_two() -> impl Future<Output = Result<(), ()>> {
+ base_thing()
+}
+
+async fn thing() -> Result<(), ()> {
+ if true {
+ thing_one()
+ } else {
+ thing_two() //~ ERROR if and else have incompatible types
+ }.await
+}
+
+fn main() {}
--- /dev/null
+error[E0308]: if and else have incompatible types
+ --> $DIR/opaque-type-error.rs:20:9
+ |
+LL | / if true {
+LL | | thing_one()
+ | | ----------- expected because of this
+LL | | } else {
+LL | | thing_two()
+ | | ^^^^^^^^^^^ expected opaque type, found a different opaque type
+LL | | }.await
+ | |_____- if and else have incompatible types
+ |
+ = note: expected type `impl std::future::Future` (opaque type)
+ found type `impl std::future::Future` (opaque type)
+ = note: distinct uses of `impl Trait` result in different opaque types
+ = help: if both `Future`s have the same `Output` type, consider `.await`ing on both of them
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
'@ryankurte @thejpster @therealprof'
),
'edition-guide': '@ehuss @Centril @steveklabnik',
- 'rustc-guide': '@mark-i-m @spastorino'
+ 'rustc-guide': '@mark-i-m @spastorino @amanjeev'
}
REPOS = {
-Subproject commit 0462008de87d2757e8ef1dc26f2c54dd789a59a8
+Subproject commit 9792ff05297c0a5c40942b346c9b0341b9e7c0ee
projects / rust.git / commitdiff