# with about ~1700 lines of Rust code to be linted against

# us
1.96s user 0.11s system 101% cpu 2.043 total

# this is cause you need to build the project for clippy
66.18s user 8.03s system 315% cpu 23.517 total

fn get_src<'a'>(
    vfs: &'a Vfs,
    file_id: FileId
) -> Result<&'a str, Utf8Error>
{
    std::str::from_utf8(
        virtual_fs.read_contents(file_id)
    ) // guarantees mem safety
}

auto get_src(
    const Vfs& virtual_fs,
    FileId file_id
) -> std::string_view
{
    auto [src, length] =
    	virtual_fs.read_contents(file_id);
    return std::string_view{
        src,
        length
    }; // this constructor can raise exception
    // ----- no guarantee of mem safety -----
    // so if src is dangling after above call
    // it will be a `use-after-free`
}

   Compiling test v0.0.1 (/test)
error[E0433]: failed to resolve: use of undeclared type `HashMap`
 --> src/main.rs:2:13
  |
2 |     let _ = HashMap::<u32, String>::new();
  |             ^^^^^^^ not found in this scope
  |
help: consider importing one of these items
  |
1 | use hashbrown::HashMap;
  |
1 | use hashbrown_0_12_3::HashMap;
  |
1 | use nom::lib::std::collections::HashMap;
  |
1 | use std::collections::HashMap;
  |

For more information about this error, try `rustc --explain E0433`.
error: could not compile `test` due to previous error

// this not nearly enough code to write good async
// this had to be fit into this slide
use futures::*; // this might not be enough of an import but I don't have
// a code slice that will fit here so ask me later about everything else
fn process_vfs_paths(paths: impl Iterator<Item = (FileId, Vfs)>) -> Vec<Info> {
    let pool = ThreadPool::new()
    	.expect("Failed to build thread pool"); // pls don't use `expect` in prod
    let (tx, mut rx) = mpsc::unbounded::<Info>();
    // some shared state
    let shared_state = SharedStateProvider();
	
    pool.spawn_ok(
        stream::iter(paths.zip(repeat(move || tx.clone()))).for_each_concurrent(
            10,
            |((file_id, ref vfs), tx)| async move {
                // TODO: retry? if receiver not dropped!
                let sn = __process(file_id, vfs, &shared_state);
                let Err(e) = tx().unbounded_send(sn) else { return; };
                eprintln!("error sending, {e:?}");
            },
        ),
    );
    let mut ret = Vec::new();
    loop {
        match rx.try_next() {
            Ok(Some(Ok(x))) => ret.push(x),
            Ok(None) => break,
            _ => {}
        }
    }
    ret
}

// this is pseudo code to explain how something
// with shared state would work with rayon
use rayon::prelude::*;

fn process_vfs_paths(paths: impl Iterator<Item = (FileId, Vfs)>) -> Vec<Info> {
    paths
    .par_bridge()
    .map_with(SharedStateProvider(), |ref shared_state, (file_id, ref vfs)| {
        __process(file_id, vfs, shared_state)
    })
    .filter_map(|issues| issues.ok())
    .collect() // this will run our stack in parallel then build Vec
}