test: fix doctests, a few small failing tests

Author: bitwalker

.github/workflows/x86_64-unknown-linux-gnu-compiler.yml

@@ -32,7 +32,7 @@ jobs:
           wget https://apt.llvm.org/llvm.sh
           chmod +x llvm.sh
           sudo ./llvm.sh "${LLVM_VERSION}"
-          apt-get install -y "llvm-${LLVM_VERSION}" "libllvm${LLVM_VERSION}" "llvm-${LLVM_VERSION}-dev" "libmlir-${LLVM_VERSION}-dev"
+          sudo apt-get install -y "llvm-${LLVM_VERSION}" "libllvm${LLVM_VERSION}" "llvm-${LLVM_VERSION}-dev" "libmlir-${LLVM_VERSION}-dev"
           if ! "${LLVM_PREFIX}/bin/llvm-config" --prefix; then
             echo "$("${LLVM_PREFIX}/bin/llvm-config" --prefix)"
             exit 1

compiler/syntax_kernel/src/ir/mod.rs

@@ -126,7 +126,7 @@ impl fmt::Debug for Expr {
             Self::Break(expr) => write!(f, "{:#?}", expr),
             Self::Return(expr) => write!(f, "{:#?}", expr),
             Self::Values(expr) => write!(f, "{:#?}", expr),
-            Self::Local(name) => write!(f, "{}", &name.item),
+            Self::Local(name) => write!(f, "Local({})", &name.item),
             Self::Remote(expr) => write!(f, "{:#?}", expr),
         }
     }

library/rt/src/backtrace/symbolication.rs

@@ -221,15 +221,15 @@ pub const MAX_FILENAME_LEN: usize = 120;
 ///
 /// Each frame looks like:
 ///
-/// ```ignore
+/// ```erlang,ignore
 ///     {module, function, arity, [{file, "path/to/file"}, {line, 1}]}
 /// ```
 ///
 /// However, the first frame may optionally contain the arguments, used for certain
 /// classes of errors like function_clause errors. In this case, one frame will look
 /// like so:
 ///
-/// ```ignore
+/// ```erlang,ignore
 ///     {module, function, [..args], [{file, "path/to/file"}, {line, 1}]}
 /// ```
 ///
@@ -238,7 +238,7 @@ pub const MAX_FILENAME_LEN: usize = 120;
 /// To calculate the total heap needed to allocate all of the terms, we define a heap
 /// layout something like the following:
 ///
-/// ```ignore
+/// ```text,ignore
 /// struct Frames {
 ///   list: [Cons<Frame>; NUM_FRAMES], // the cons cells for each frame, references `data`
 ///   data: [Frame; NUM_FRAMES], // the data for each frame

library/rt/src/function/apply/mod.rs

@@ -23,6 +23,7 @@ use crate::term::{Atom, OpaqueTerm};
 
 use super::{ErlangResult, FunctionSymbol, ModuleFunctionArity};
 
+#[cfg(all(feature = "std", any(unix, windows)))]
 const BIFS: &'static [&'static str] = &[
     "erlang:++/2",
     "erlang:--/2",

library/rt/src/process/mod.rs

@@ -1341,7 +1341,8 @@ impl<'a> ProcessLock<'a> {
         let mature_available = self.guard.heap.mature().heap_available();
         if has_mature && mature_size > mature_available {
             log::trace!(target: "gc", "insufficient space on target mature heap (only {} available), full sweep required", mature_available);
-            return Err(GcError::FullsweepRequired);
+            // Switch to a full collection
+            return self.gc_full(needed, roots);
         }
 
         let prev_old_top = self.guard.heap.mature().heap_top();

library/rt/src/process/monitor.rs

@@ -400,7 +400,9 @@ pub struct LocalMonitorInfo {
     ///
     /// When a monitor message is sent to a process, it looks like so:
     ///
+    /// ```erlang
     ///     {'DOWN', MonitorRef, Type, From, Payload}
+    /// ```
     ///
     /// Where `'DOWN'` is the tag for the message. When a custom tag is used, it replaces
     /// that default tag with whatever term was given. This is typically used to enable a

library/rt/src/process/stack.rs

@@ -114,12 +114,14 @@ pub struct StackOverflowError;
 ///
 /// Call frames are laid out as follows, where the address on the left is relative to the frame pointer (fp):
 ///
+/// ```text,ignore
 ///     N+1 | NONE           <- sp
 ///     N   | ARGN
 ///     .   |
 ///     2   | ARG0
 ///     1   | RETURN_ADDRESS
 ///     0   | RETURN_VALUE   <- fp
+/// ```
 ///
 /// The first call frame in the call stack has a null return address, which is what signals that control
 /// has reached the bottom of the call stack, and that the currently executing process should exit normally.

library/rt/src/services/error_logger.rs

@@ -206,7 +206,9 @@ enum Args<'a, T> {
 
 /// Sends a message of the following format to the `error_logger` process:
 ///
+/// ```erlang
 ///     {log, Level, Format, Args, #{gl => Gl, pid => Pid, time => Time, error_logger => #{Tag => Level, emulator => true}}}
+/// ```
 ///
 /// Where:
 ///

library/rt/src/services/timers/wheel.rs

@@ -289,6 +289,7 @@ impl TimerWheel {
     ///
     /// This function returns true if a cycle was completed in the process of advancing the wheel.
     #[cfg(test)]
+    #[allow(unused)]
     pub fn skip(&mut self) -> bool {
         match self.skippable() {
             // If this wheel is empty, we treat it as if we've completed a full cycle
@@ -814,6 +815,7 @@ impl HierarchicalTimerWheel {
     ///
     /// If the wheel is empty, this function will leave the wheel time reset to the beginning of a new cycle.
     #[cfg(test)]
+    #[allow(unused)]
     pub fn skip(&mut self) {
         if !self.wheels[Self::SOON].skip() {
             return;

library/rt/src/term/binary/matching.rs

@@ -15,7 +15,7 @@ use crate::term::{BinaryData, Boxable, Header, LayoutBuilder, OpaqueTerm, Tag, T
 /// and produced by binary matching intrinsics, it is equivalent to a multi-value
 /// return with 3 values, and is used like so in generated code:
 ///
-/// ```ignore
+/// ```text,ignore
 /// let (is_err, term_or_err, match_ctx) = bs_match(...);
 /// if is_err {
 ///   let error = cast term_or_err as *mut Exception