use crate::{DeclId, Signature, Type};
use rustc_hash::FxBuildHasher;
use std::{
collections::HashMap,
sync::{Arc, Mutex, MutexGuard, OnceLock},
};
#[derive(Default)]
pub(super) struct SignatureCache {
pub(super) effective: Vec<OnceLock<Arc<Signature>>>,
pub(super) declared: Mutex<HashMap<DeclId, Arc<Signature>, FxBuildHasher>>,
pub(super) call_outputs: Mutex<HashMap<DeclId, OutputTypes, FxBuildHasher>>,
pub(super) declared_outputs: Mutex<HashMap<DeclId, OutputTypes, FxBuildHasher>>,
}
pub(super) type OutputTypes = Vec<(Option<Type>, Option<Type>)>;
impl SignatureCache {
const MAX_INPUT_TYPES: usize = 16;
const MAX_COLUMNS: usize = 16;
pub(super) fn new(num_decls: usize) -> Self {
Self {
effective: std::iter::repeat_with(OnceLock::new)
.take(num_decls)
.collect(),
..Self::default()
}
}
pub(super) fn lock<T>(map: &Mutex<T>) -> MutexGuard<'_, T> {
map.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
}
fn is_small(ty: &Type) -> bool {
fn fits(ty: &Type, budget: &mut usize) -> bool {
match ty {
Type::Record(columns) | Type::Table(columns) => {
match budget.checked_sub(columns.len()) {
Some(rest) => *budget = rest,
None => return false,
}
columns.iter().all(|(_, ty)| fits(ty, budget))
}
Type::List(ty) => fits(ty, budget),
Type::OneOf(types) => types.iter().all(|ty| fits(ty, budget)),
_ => true,
}
}
let mut budget = Self::MAX_COLUMNS;
fits(ty, &mut budget)
}
pub(super) fn output_type(
map: &Mutex<HashMap<DeclId, OutputTypes, FxBuildHasher>>,
decl_id: DeclId,
input: Option<&Type>,
compute: impl FnOnce() -> Option<Type>,
) -> Option<Type> {
if input.is_some_and(|ty| !Self::is_small(ty)) {
return compute();
}
let remembered = |outputs: &OutputTypes| {
outputs
.iter()
.find(|(seen, _)| seen.as_ref() == input)
.map(|(_, output)| output.clone())
};
if let Some(output) = Self::lock(map).get(&decl_id).and_then(remembered) {
return output;
}
let output = compute();
let mut map = Self::lock(map);
let outputs = map.entry(decl_id).or_default();
if outputs.len() < Self::MAX_INPUT_TYPES && remembered(outputs).is_none() {
outputs.push((input.cloned(), output.clone()));
}
output
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::CollectionColumns;
fn columns(n: usize, ty: &Type) -> CollectionColumns<Type> {
(0..n).map(|i| (format!("c{i}"), ty.clone())).collect()
}
#[test]
fn only_types_with_few_columns_are_small() {
let limit = SignatureCache::MAX_COLUMNS;
assert!(SignatureCache::is_small(&Type::String));
assert!(SignatureCache::is_small(&Type::Record(columns(
limit,
&Type::Int
))));
assert!(!SignatureCache::is_small(&Type::Record(columns(
limit + 1,
&Type::Int
))));
let half = Type::Record(columns(limit / 2, &Type::Int));
assert!(!SignatureCache::is_small(&Type::Record(columns(
limit / 2,
&half
))));
assert!(!SignatureCache::is_small(&Type::list(Type::Table(
columns(limit + 1, &Type::Int)
))));
assert!(!SignatureCache::is_small(&Type::one_of([
Type::Record(columns(limit, &Type::Int)),
Type::Table(columns(1, &Type::Int)),
])));
}
#[test]
fn output_types_of_large_input_types_are_not_remembered() {
let map = Mutex::default();
let decl_id = DeclId::new(0);
let large = Type::Record(columns(SignatureCache::MAX_COLUMNS + 1, &Type::Int));
let output = SignatureCache::output_type(&map, decl_id, Some(&large), || Some(Type::Int));
assert_eq!(output, Some(Type::Int));
assert!(SignatureCache::lock(&map).is_empty());
let small = Type::Record(columns(1, &Type::Int));
SignatureCache::output_type(&map, decl_id, Some(&small), || Some(Type::Int));
assert_eq!(SignatureCache::lock(&map)[&decl_id].len(), 1);
}
}