Jack O'Connor oconnor663

It seems like the cycle_initial of a query can be called more than once, if the query alternates between being a cycle head and not being one. To start with, here's example of a mutually recursive Salsa program that eventually stabilizes, by fixpoint-iterating an integer until it reaches some upper bound (3). Then there's a modified version of that program that makes the inner query sometimes call itself directly. This version never stabilizes, because the directly recursive call always returns cycle_initial (0). I find that surprising. Is this an intended behavior?

	use std::alloc::{Layout, alloc, dealloc};
	use std::mem::{self, MaybeUninit};
	use std::ops::{Deref, DerefMut};
	use std::slice;

	pub struct FixedVec<'a, T> {
	buf: &'a mut [MaybeUninit<T>],
	len: usize,
	}

	use core::pin::pin;
	use core::sync::atomic::{AtomicBool, Ordering::Relaxed};
	use core::task::Poll;

	async fn foo() -> std::io::Result<i32> {
	let no_return = AtomicBool::new(false);
	let mut value = None;
	let mut fut = pin!(async {
	value = Some({
	// begin user code

	/c
	for i = 1, 3 do
	game.player.force.technologies["worker-robots-storage-" .. i].researched = true
	end
	for i = 1, 7 do
	game.player.force.technologies["worker-robots-speed-" .. i].researched = true
	end
	game.player.force.technologies["worker-robots-speed-7"].level = 10
	local r=1000
	game.player.force.chart(game.player.surface, {{x = -r, y = -r}, {x = r, y = r}})

	use anyhow::Context;
	use std::error::Error;
	use std::fmt;

	#[derive(Debug)]
	struct FooError {}

	impl fmt::Display for FooError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	write!(f, "foo error!")

	use std::io;
	use std::process::Command;
	use std::thread;

	pub fn waitpid(id: u32) -> io::Result<i32> {
	let mut status = 0i32;
	let ret = unsafe { libc::waitpid(id as i32, &mut status, 0) };
	if ret != -1 {
	Ok(status)
	} else {

	use blake3::{Hasher, OutputReader};

	pub enum RatchetingHasher {
	Absorbing(Hasher),
	Squeezing(OutputReader),
	}

	use RatchetingHasher::{Absorbing, Squeezing};

	impl RatchetingHasher {