Added information about the setup steps neccesary for running a specifc cargo test.

Author: FractalFir

CONTRIBUTING.md

@@ -34,6 +34,30 @@ To run specific tests, use appropriate flags such as:
 - `./y.sh test --test-libcore`
 - `./y.sh test --std-tests`
 - `cargo test -- <name of test>`
+##### Cargo tests
+To run `cargo test`s, you need to do a few things.
+First and foremost, set the correct `LD_LIBRARY_PATH` and `LIBRARY_PATH`. 
+
+You can find out this path by running `./y.sh build`. 
+You should see output like this:
+```
+[BUILD] build system
+    Finished `release` profile [optimized] target(s) in 0.01s
+Using `EXAMPLE_PATH` as path for libgccjit
+    Finished `dev` profile [optimized + debuginfo] target(s) in 0.02s
+```
+Copy the path from that output, and use it to set `LD_LIBRARY_PATH` and `LIBRARY_PATH`. 
+```shell
+export EXAMPLE_PATH=SOME_PATH
+export EXAMPLE_PATH=SOME_PATH
+```
+Before running any of the cargo tests, you must also first run this command:
+```sh
+./y.sh test --mini-tests
+```
+It will build some of the dependencies neccesary for running tests.
+
+##### `libgccjit` tests
 
 Additionally, you can run the tests of `libgccjit`:
 

src/attributes.rs

@@ -24,10 +24,10 @@ fn resursively_inline<'gcc, 'tcx>(
     // `expect_local` ought to never fail: we should be checking a function within this codegen unit.
     let body = cx.tcx.optimized_mir(instance.def_id());
     for block in body.basic_blocks.iter() {
-        let Some(terminator) = &block.terminator else { continue };
+        let Some(ref terminator) = block.terminator else { continue };
         // I assmume that the resursive-inline issue applies only to functions, and not to drops.
         // In principle, a recursive, `#[inline(always)]` drop could(?) exist, but I don't think it does.
-        let TerminatorKind::Call { func, .. } = &terminator.kind else { continue };
+        let TerminatorKind::Call { ref func, .. } = terminator.kind else { continue };
         let Some((def, _args)) = func.const_fn_def() else { continue };
         // Check if the called function is recursively inline.
         if matches!(