Function check_one_const

crates/ffi/src/kernel.rs:2280–2376

(
  i: usize,
  progress_index: usize,
  progress_total: usize,
  ixon_env: &IxonEnv,
  lookups: &IxonIngressLookups,
  names: &[Name],
  expect_pass: &[bool],
  ungrounded: &FxHashMap<Name, String>,

  let mut handles: Vec<thread::JoinHandle<()>> =
    Vec::with_capacity(worker_count);
  for worker_idx in 0..worker_count {
    let env = Arc::clone(&env);
    let work = Arc::clone(&work);
    let next_index = Arc::clone(&next_index);
    let passed = Arc::clone(&passed);
    let failed = Arc::clone(&failed);
    let sinks = Arc::clone(&sinks);
    let handle = thread::Builder::new()
      .name(format!("ix-kernel-profile-{worker_idx}"))
      .stack_size(KERNEL_CHECK_STACK_SIZE)
      .spawn(move || {
        let mut kenv = KEnv::<Anon>::new();
        kenv.profile_sink = Some(ProfileSink::new(isolate));
        let clear_every = kernel_check_clear_every();
        let mut checks_since_clear = clear_every;
        loop {
          let work_idx = next_index.fetch_add(1, Ordering::Relaxed);
          if work_idx >= work_total {
            break;
          }
          // `clear_releasing_memory` preserves `profile_sink`, so recording
          // accumulates across scheduled-block boundaries.
          if checks_since_clear >= clear_every {
            kenv.clear_releasing_memory();
            checks_since_clear = 0;
          }
          let primary_addr = match &work[work_idx] {
            AnonWorkItem::Standalone { addr, .. } => addr.clone(),
            AnonWorkItem::Block { primary_addr, .. } => primary_addr.clone(),
          };
          let kid = KId::<Anon>::new(primary_addr, ());
          let res = {
            let mut tc =
              TypeChecker::<Anon>::new_with_lazy_anon(&mut kenv, &env);
            let r = tc.check_const(&kid);
            // The TypeChecker is recreated per work item, so the final
            // constant's record would never be flushed by a trailing reset —
            // flush it explicitly.
            tc.finish_constant_accounting();
            r
          };
          if res.is_ok() {
            passed.fetch_add(1, Ordering::Relaxed);
          } else {
            failed.fetch_add(1, Ordering::Relaxed);
          }
          checks_since_clear += 1;
        }
        if let Some(sink) = kenv.profile_sink.take() {
          sinks.lock().unwrap().push(sink);
        }
      })
      .map_err(|e| format!("spawn profile worker: {e}"))?;
    handles.push(handle);
  }

  let mut panicked = false;
  for h in handles {