Function rs_compile_env_rust_first

crates/ffi/src/compile.rs:672–712

(
  env_consts_ptr: LeanList<LeanBorrowed<'_>>,
)

    };

  // Build block map: lowlink name -> (serialized bytes, sharing len)
  let mut blocks: HashMap<Name, (Vec<u8>, usize)> = HashMap::new();

  // Iterate over all names and their addresses
  for entry in rust_stt.name_to_addr.iter() {
    let name = entry.key().clone();
    let addr = entry.value().clone();

    // Skip if we already have this block (multiple names map to same block)
    if blocks.contains_key(&name) {
      continue;
    }

    // Get the compiled constant
    if let Some(constant) = rust_stt.env.get_const(&addr) {
      let mut bytes = Vec::new();
      constant.put(&mut bytes);
      let sharing_len = constant.sharing.len();
      blocks.insert(name, (bytes, sharing_len));
    }
  }

  // Return boxed RustCompiledEnv with full compile state for pre-sharing access
  Box::into_raw(Box::new(RustCompiledEnv { blocks, compile_state: rust_stt }))
}

/// FFI: Compare a single block and return packed result.
/// Returns a packed u64: high 32 bits = matches (1) or error code (0 = mismatch, 2 = not found)
///                       low 32 bits = first diff offset (if mismatch)
#[cfg(feature = "test-ffi")]
#[unsafe(no_mangle)]
extern "C" fn rs_compare_block(
  rust_env: *const RustCompiledEnv,
  lowlink_name: LeanOwned,
  lean_bytes: LeanByteArray<LeanOwned>,
) -> u64 {
  if rust_env.is_null() {
    return 2u64 << 32; // not found
  }
  let global_cache = GlobalCache::default();
  let name = decode_name(lowlink_name.borrow(), &global_cache);

  let rust_env = unsafe { &*rust_env };
  let lean_data = lean_bytes.as_bytes();