rust: Lower minimum supported Rust version to 1.49

gcc/rust/ChangeLog:

	* checks/errors/borrowck/ffi-polonius/Cargo.lock: Regenerate.
	* checks/errors/borrowck/ffi-polonius/Cargo.toml: Update to use source patching instead of
	vendoring, lower edition to 2018.
	* checks/errors/borrowck/ffi-polonius/vendor/log/Cargo.toml: Change edition to 2018.
	* checks/errors/borrowck/ffi-polonius/vendor/log/src/lib.rs: Remove uses of unstable
	feature.
	* checks/errors/borrowck/ffi-polonius/.cargo/config.toml: Removed.

libgrust/ChangeLog:

	* libformat_parser/Makefile.am: Avoid using --config as it is unsupported by cargo 1.49.
	* libformat_parser/Makefile.in: Regenerate.
	* libformat_parser/generic_format_parser/src/lib.rs: Use extension trait for missing
	features.
	* libformat_parser/src/lib.rs: Likewise.
	* libformat_parser/.cargo/config: Moved to...
	* libformat_parser/.cargo/config.toml: ...here.

Author: CohenArthur

gcc/rust/checks/errors/borrowck/ffi-polonius/Cargo.lock

@@ -1,11 +1,17 @@
 [package]
 name = "ffi-polonius"
 version = "0.1.0"
-edition = "2021"
+edition = "2018"
 license = "GPL-3"
 
 [lib]
 crate-type = ["staticlib"]
 
 [dependencies]
-polonius-engine = "0.13.0"
+polonius-engine = "0.13.0"
+
+[patch.crates-io]
+log = { path = "vendor/log" }
+datafrog = { path = "vendor/datafrog" }
+polonius-engine = { path = "vendor/polonius-engine" }
+rustc-hash = { path = "vendor/rustc-hash" }

gcc/rust/checks/errors/borrowck/ffi-polonius/Cargo.toml

@@ -10,7 +10,7 @@
 # See Cargo.toml.orig for the original contents.
 
 [package]
-edition = "2021"
+edition = "2018"
 rust-version = "1.60.0"
 name = "log"
 version = "0.4.22"

gcc/rust/checks/errors/borrowck/ffi-polonius/vendor/log/Cargo.toml

@@ -397,20 +397,13 @@ mod serde;
 #[cfg(feature = "kv")]
 pub mod kv;
 
-#[cfg(target_has_atomic = "ptr")]
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-#[cfg(not(target_has_atomic = "ptr"))]
 use std::cell::Cell;
-#[cfg(not(target_has_atomic = "ptr"))]
 use std::sync::atomic::Ordering;
 
-#[cfg(not(target_has_atomic = "ptr"))]
 struct AtomicUsize {
     v: Cell<usize>,
 }
 
-#[cfg(not(target_has_atomic = "ptr"))]
 impl AtomicUsize {
     const fn new(v: usize) -> AtomicUsize {
         AtomicUsize { v: Cell::new(v) }
@@ -423,26 +416,10 @@ impl AtomicUsize {
     fn store(&self, val: usize, _order: Ordering) {
         self.v.set(val)
     }
-
-    #[cfg(target_has_atomic = "ptr")]
-    fn compare_exchange(
-        &self,
-        current: usize,
-        new: usize,
-        _success: Ordering,
-        _failure: Ordering,
-    ) -> Result<usize, usize> {
-        let prev = self.v.get();
-        if current == prev {
-            self.v.set(new);
-        }
-        Ok(prev)
-    }
 }
 
 // Any platform without atomics is unlikely to have multiple cores, so
 // writing via Cell will not be a race condition.
-#[cfg(not(target_has_atomic = "ptr"))]
 unsafe impl Sync for AtomicUsize {}
 
 // The LOGGER static holds a pointer to the global logger. It is protected by
@@ -1258,17 +1235,6 @@ where
     }
 }
 
-/// Sets the global maximum log level.
-///
-/// Generally, this should only be called by the active logging implementation.
-///
-/// Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.
-#[inline]
-#[cfg(target_has_atomic = "ptr")]
-pub fn set_max_level(level: LevelFilter) {
-    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed);
-}
-
 /// A thread-unsafe version of [`set_max_level`].
 ///
 /// This function is available on all platforms, even those that do not have
@@ -1320,110 +1286,6 @@ pub fn max_level() -> LevelFilter {
     unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
 }
 
-/// Sets the global logger to a `Box<Log>`.
-///
-/// This is a simple convenience wrapper over `set_logger`, which takes a
-/// `Box<Log>` rather than a `&'static Log`. See the documentation for
-/// [`set_logger`] for more details.
-///
-/// Requires the `std` feature.
-///
-/// # Errors
-///
-/// An error is returned if a logger has already been set.
-///
-/// [`set_logger`]: fn.set_logger.html
-#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
-pub fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), SetLoggerError> {
-    set_logger_inner(|| Box::leak(logger))
-}
-
-/// Sets the global logger to a `&'static Log`.
-///
-/// This function may only be called once in the lifetime of a program. Any log
-/// events that occur before the call to `set_logger` completes will be ignored.
-///
-/// This function does not typically need to be called manually. Logger
-/// implementations should provide an initialization method that installs the
-/// logger internally.
-///
-/// # Availability
-///
-/// This method is available even when the `std` feature is disabled. However,
-/// it is currently unavailable on `thumbv6` targets, which lack support for
-/// some atomic operations which are used by this function. Even on those
-/// targets, [`set_logger_racy`] will be available.
-///
-/// # Errors
-///
-/// An error is returned if a logger has already been set.
-///
-/// # Examples
-///
-/// ```
-/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
-///
-/// static MY_LOGGER: MyLogger = MyLogger;
-///
-/// struct MyLogger;
-///
-/// impl log::Log for MyLogger {
-///     fn enabled(&self, metadata: &Metadata) -> bool {
-///         metadata.level() <= Level::Info
-///     }
-///
-///     fn log(&self, record: &Record) {
-///         if self.enabled(record.metadata()) {
-///             println!("{} - {}", record.level(), record.args());
-///         }
-///     }
-///     fn flush(&self) {}
-/// }
-///
-/// # fn main(){
-/// log::set_logger(&MY_LOGGER).unwrap();
-/// log::set_max_level(LevelFilter::Info);
-///
-/// info!("hello log");
-/// warn!("warning");
-/// error!("oops");
-/// # }
-/// ```
-///
-/// [`set_logger_racy`]: fn.set_logger_racy.html
-#[cfg(target_has_atomic = "ptr")]
-pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
-    set_logger_inner(|| logger)
-}
-
-#[cfg(target_has_atomic = "ptr")]
-fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
-where
-    F: FnOnce() -> &'static dyn Log,
-{
-    match STATE.compare_exchange(
-        UNINITIALIZED,
-        INITIALIZING,
-        Ordering::Acquire,
-        Ordering::Relaxed,
-    ) {
-        Ok(UNINITIALIZED) => {
-            unsafe {
-                LOGGER = make_logger();
-            }
-            STATE.store(INITIALIZED, Ordering::Release);
-            Ok(())
-        }
-        Err(INITIALIZING) => {
-            while STATE.load(Ordering::Relaxed) == INITIALIZING {
-                std::hint::spin_loop();
-            }
-            Err(SetLoggerError(()))
-        }
-        _ => Err(SetLoggerError(())),
-    }
-}
-
 /// A thread-unsafe version of [`set_logger`].
 ///
 /// This function is available on all platforms, even those that do not have

gcc/rust/checks/errors/borrowck/ffi-polonius/vendor/log/src/lib.rs

@@ -2,12 +2,9 @@ LIBFORMAT_PARSER = debug/liblibformat_parser.a
 
 all-local: $(LIBFORMAT_PARSER)
 
+RUST_BUILD_DIR=$(PWD)
+
 # TODO: Improve `cargo` invocation with host specific flags, possibly creating a $(CARGO) variable?
 $(LIBFORMAT_PARSER): $(srcdir)/Cargo.toml $(srcdir)/src/*.rs
-	cargo \
-	  --config $(srcdir)/.cargo/config \
-	  build \
-	    --offline \
-	    --target-dir . \
-	    --manifest-path $(srcdir)/Cargo.toml \
-	    # FIXME: Not always '--release', right?
+	cd $(srcdir) && \
+	cargo build --offline --target-dir $(RUST_BUILD_DIR)

libgrust/libformat_parser/.cargo/config

@@ -263,6 +263,7 @@ top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 LIBFORMAT_PARSER = debug/liblibformat_parser.a
+RUST_BUILD_DIR = $(PWD)
 all: all-am
 
 .SUFFIXES:
@@ -428,13 +429,8 @@ all-local: $(LIBFORMAT_PARSER)
 
 # TODO: Improve `cargo` invocation with host specific flags, possibly creating a $(CARGO) variable?
 $(LIBFORMAT_PARSER): $(srcdir)/Cargo.toml $(srcdir)/src/*.rs
-	cargo \
-	  --config $(srcdir)/.cargo/config \
-	  build \
-	    --offline \
-	    --target-dir . \
-	    --manifest-path $(srcdir)/Cargo.toml \
-	    # FIXME: Not always '--release', right?
+	cd $(srcdir) && \
+	cargo build --offline --target-dir $(RUST_BUILD_DIR)
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.

gcc/rust/checks/errors/borrowck/ffi-polonius/.cargo/config.toml renamed to libgrust/libformat_parser/.cargo/config.toml

@@ -32,6 +32,20 @@ use std::iter;
 use std::str;
 use std::string;
 
+// Extension trait for `Option<T>::is_some_and()` which was not a feature in Rust 1.49
+pub trait OptionIsSomeAndExt<T> {
+    fn is_some_and(self, f: impl FnOnce(T) -> bool) -> bool;
+}
+
+impl<T> OptionIsSomeAndExt<T> for Option<T> {
+    fn is_some_and(self, f: impl FnOnce(T) -> bool) -> bool {
+        match self {
+            None => false,
+            Some(x) => f(x),
+        }
+    }
+}
+
 // Note: copied from rustc_span
 /// Range inside of a `Span` used for diagnostics when we only have access to relative positions.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]

libgrust/libformat_parser/Makefile.am

@@ -21,6 +21,17 @@ where
     }
 }
 
+// Extension trait to provide `String::leak` which did not exist in Rust 1.49
+pub trait StringLeakExt {
+    fn leak<'a>(self) -> &'a mut str;
+}
+
+impl StringLeakExt for String {
+    fn leak<'a>(self) -> &'a mut str {
+        Box::leak(self.into_boxed_str())
+    }
+}
+
 // FIXME: Make an ffi module in a separate file
 // FIXME: Remember to leak the boxed type somehow
 // FIXME: How to encode the Option type? As a pointer? Option<T> -> Option<&T> -> *const T could work maybe?