use std::collections::HashMap;
use crate::{ClassName, InferredType, MethodDescriptor, MethodInvocationKind, TypeDescriptor};
pub trait MethodSummaryResolver: Send + Sync {
fn return_type(
&self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
) -> Option<InferredType>;
fn return_type_for_invocation(
&self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
invocation_kind: MethodInvocationKind,
) -> Option<InferredType> {
let _ = invocation_kind;
self.return_type(owner, name, descriptor)
}
fn return_type_for_call(
&self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
invocation_kind: MethodInvocationKind,
receiver_is_exact_allocation: bool,
) -> Option<InferredType> {
let _ = receiver_is_exact_allocation;
self.return_type_for_invocation(owner, name, descriptor, invocation_kind)
}
fn returned_parameter_index_for_invocation(
&self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
invocation_kind: MethodInvocationKind,
) -> Option<usize> {
let _ = (owner, name, descriptor, invocation_kind);
None
}
fn returned_parameter_index_for_call(
&self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
invocation_kind: MethodInvocationKind,
receiver_is_exact_allocation: bool,
) -> Option<usize> {
let _ = receiver_is_exact_allocation;
self.returned_parameter_index_for_invocation(owner, name, descriptor, invocation_kind)
}
}
pub trait FieldSummaryResolver: Send + Sync {
fn value_type(
&self,
owner: &ClassName,
name: &str,
descriptor: &TypeDescriptor,
) -> Option<InferredType>;
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct MethodSummaries {
returns: HashMap<ClassName, HashMap<String, HashMap<MethodDescriptor, InferredType>>>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct FieldSummaries {
values: HashMap<ClassName, HashMap<String, HashMap<TypeDescriptor, InferredType>>>,
}
impl FieldSummaries {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn insert_value_type(
&mut self,
owner: ClassName,
name: impl Into<String>,
descriptor: TypeDescriptor,
value_type: InferredType,
) -> Option<InferredType> {
self.values
.entry(owner)
.or_default()
.entry(name.into())
.or_default()
.insert(descriptor, value_type)
}
#[must_use]
pub fn len(&self) -> usize {
self.values
.values()
.flat_map(|fields| fields.values())
.map(HashMap::len)
.sum()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.values.is_empty()
}
}
impl MethodSummaries {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn insert_return_type(
&mut self,
owner: ClassName,
name: impl Into<String>,
descriptor: MethodDescriptor,
return_type: InferredType,
) -> Option<InferredType> {
self.returns
.entry(owner)
.or_default()
.entry(name.into())
.or_default()
.insert(descriptor, return_type)
}
#[must_use]
pub fn len(&self) -> usize {
self.returns
.values()
.flat_map(|methods| methods.values())
.map(HashMap::len)
.sum()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.returns.is_empty()
}
pub(crate) fn remove_return_type(
&mut self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
) -> Option<InferredType> {
let removed = self
.returns
.get_mut(owner)?
.get_mut(name)?
.remove(descriptor);
if self
.returns
.get(owner)
.and_then(|methods| methods.get(name))
.is_some_and(HashMap::is_empty)
{
self.returns.get_mut(owner)?.remove(name);
}
if self.returns.get(owner).is_some_and(HashMap::is_empty) {
self.returns.remove(owner);
}
removed
}
}
impl MethodSummaryResolver for MethodSummaries {
fn return_type(
&self,
owner: &ClassName,
name: &str,
descriptor: &MethodDescriptor,
) -> Option<InferredType> {
self.returns.get(owner)?.get(name)?.get(descriptor).cloned()
}
}
impl FieldSummaryResolver for FieldSummaries {
fn value_type(
&self,
owner: &ClassName,
name: &str,
descriptor: &TypeDescriptor,
) -> Option<InferredType> {
self.values.get(owner)?.get(name)?.get(descriptor).cloned()
}
}
pub(crate) fn value_type_matches_descriptor(
descriptor: &TypeDescriptor,
value_type: &InferredType,
) -> bool {
match descriptor {
TypeDescriptor::Primitive(
crate::PrimitiveType::Boolean
| crate::PrimitiveType::Byte
| crate::PrimitiveType::Char
| crate::PrimitiveType::Short
| crate::PrimitiveType::Int,
) => value_type.integral_types().is_some(),
TypeDescriptor::Primitive(crate::PrimitiveType::Float) => {
matches!(value_type, InferredType::Float)
}
TypeDescriptor::Primitive(crate::PrimitiveType::Long) => {
matches!(value_type, InferredType::Long)
}
TypeDescriptor::Primitive(crate::PrimitiveType::Double) => {
matches!(value_type, InferredType::Double)
}
TypeDescriptor::Reference(_) | TypeDescriptor::Array { .. } => {
reference_value_matches_descriptor(descriptor, value_type)
}
}
}
fn reference_value_matches_descriptor(
descriptor: &TypeDescriptor,
value_type: &InferredType,
) -> bool {
match value_type {
InferredType::Reference(reference) => match descriptor {
TypeDescriptor::Reference(_) => matches!(
reference,
crate::ReferenceType::Exact(_)
| crate::ReferenceType::Array(_)
| crate::ReferenceType::Null
),
TypeDescriptor::Array { .. } => matches!(
reference,
crate::ReferenceType::Array(_) | crate::ReferenceType::Null
),
TypeDescriptor::Primitive(_) => false,
},
InferredType::Alternatives(values) => {
!values.is_empty()
&& values
.iter()
.all(|value| reference_value_matches_descriptor(descriptor, value))
}
_ => false,
}
}