use std::{collections::BTreeSet, sync::Arc};
use crate::ir::parse_and_lower;
use crate::solver::{analyze_class, analyze_classes};
use crate::{
ClassInference, ClassInferences, Error, FieldSummaryResolver, MethodSummaryResolver,
TypeHierarchy,
};
#[derive(Clone)]
pub struct InferenceConfig {
strict: bool,
max_block_iterations: usize,
max_work_items: usize,
unbounded_analysis: bool,
use_local_variable_metadata: bool,
hierarchy: Option<Arc<dyn TypeHierarchy>>,
method_summaries: Option<Arc<dyn MethodSummaryResolver>>,
field_summaries: Option<Arc<dyn FieldSummaryResolver>>,
}
impl std::fmt::Debug for InferenceConfig {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("InferenceConfig")
.field("strict", &self.strict)
.field("max_block_iterations", &self.max_block_iterations)
.field("max_work_items", &self.max_work_items)
.field("unbounded_analysis", &self.unbounded_analysis)
.field(
"use_local_variable_metadata",
&self.use_local_variable_metadata,
)
.field("has_type_hierarchy", &self.hierarchy.is_some())
.field("has_method_summaries", &self.method_summaries.is_some())
.field("has_field_summaries", &self.field_summaries.is_some())
.finish()
}
}
impl PartialEq for InferenceConfig {
fn eq(&self, other: &Self) -> bool {
self.strict == other.strict
&& self.max_block_iterations == other.max_block_iterations
&& self.max_work_items == other.max_work_items
&& self.unbounded_analysis == other.unbounded_analysis
&& self.use_local_variable_metadata == other.use_local_variable_metadata
&& match (&self.hierarchy, &other.hierarchy) {
(Some(left), Some(right)) => Arc::ptr_eq(left, right),
(None, None) => true,
_ => false,
}
&& match (&self.method_summaries, &other.method_summaries) {
(Some(left), Some(right)) => Arc::ptr_eq(left, right),
(None, None) => true,
_ => false,
}
&& match (&self.field_summaries, &other.field_summaries) {
(Some(left), Some(right)) => Arc::ptr_eq(left, right),
(None, None) => true,
_ => false,
}
}
}
impl Eq for InferenceConfig {}
impl Default for InferenceConfig {
fn default() -> Self {
Self {
strict: false,
max_block_iterations: 128,
max_work_items: 50_000,
unbounded_analysis: true,
use_local_variable_metadata: false,
hierarchy: None,
method_summaries: None,
field_summaries: None,
}
}
}
impl InferenceConfig {
#[must_use]
pub const fn strict(&self) -> bool {
self.strict
}
#[must_use]
pub const fn max_block_iterations(&self) -> usize {
self.max_block_iterations
}
#[must_use]
pub const fn max_work_items(&self) -> usize {
self.max_work_items
}
#[must_use]
pub const fn unbounded_analysis(&self) -> bool {
self.unbounded_analysis
}
#[must_use]
pub const fn uses_local_variable_metadata(&self) -> bool {
self.use_local_variable_metadata
}
#[must_use]
pub const fn has_type_hierarchy(&self) -> bool {
self.hierarchy.is_some()
}
#[must_use]
pub const fn has_method_summaries(&self) -> bool {
self.method_summaries.is_some()
}
#[must_use]
pub const fn has_field_summaries(&self) -> bool {
self.field_summaries.is_some()
}
#[must_use]
pub const fn with_strict(mut self, strict: bool) -> Self {
self.strict = strict;
self
}
#[must_use]
pub const fn with_max_block_iterations(mut self, max_block_iterations: usize) -> Self {
self.max_block_iterations = max_block_iterations;
self.unbounded_analysis = false;
self
}
#[must_use]
pub const fn with_max_work_items(mut self, max_work_items: usize) -> Self {
self.max_work_items = max_work_items;
self.unbounded_analysis = false;
self
}
#[must_use]
pub const fn with_unbounded_analysis(mut self) -> Self {
self.unbounded_analysis = true;
self
}
#[must_use]
pub const fn with_local_variable_metadata(mut self, use_local_variable_metadata: bool) -> Self {
self.use_local_variable_metadata = use_local_variable_metadata;
self
}
#[must_use]
pub fn with_shared_type_hierarchy(mut self, hierarchy: Arc<dyn TypeHierarchy>) -> Self {
self.hierarchy = Some(hierarchy);
self
}
#[must_use]
pub fn with_shared_method_summaries(
mut self,
method_summaries: Arc<dyn MethodSummaryResolver>,
) -> Self {
self.method_summaries = Some(method_summaries);
self
}
#[must_use]
pub fn with_shared_field_summaries(
mut self,
field_summaries: Arc<dyn FieldSummaryResolver>,
) -> Self {
self.field_summaries = Some(field_summaries);
self
}
pub(crate) fn type_hierarchy(&self) -> Option<&dyn TypeHierarchy> {
self.hierarchy.as_deref()
}
pub(crate) fn method_summaries(&self) -> Option<&dyn MethodSummaryResolver> {
self.method_summaries.as_deref()
}
pub(crate) fn field_summaries(&self) -> Option<&dyn FieldSummaryResolver> {
self.field_summaries.as_deref()
}
pub(crate) fn validate(&self) -> Result<(), Error> {
if self.max_block_iterations == 0 {
return Err(Error::InvalidConfiguration {
message: "max_block_iterations must be greater than zero".to_owned(),
});
}
if self.max_work_items == 0 {
return Err(Error::InvalidConfiguration {
message: "max_work_items must be greater than zero".to_owned(),
});
}
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct Inferer {
config: InferenceConfig,
}
impl Default for Inferer {
fn default() -> Self {
Self::new(InferenceConfig::default()).expect("default inference configuration is valid")
}
}
impl Inferer {
pub fn new(config: InferenceConfig) -> Result<Self, Error> {
config.validate()?;
Ok(Self { config })
}
#[must_use]
pub const fn config(&self) -> &InferenceConfig {
&self.config
}
pub fn infer_class(&self, bytes: &[u8]) -> Result<ClassInference, Error> {
let class = parse_and_lower(bytes)?;
analyze_class(&class, &self.config)
}
pub fn infer_classes<I, B>(&self, class_files: I) -> Result<ClassInferences, Error>
where
I: IntoIterator<Item = B>,
B: AsRef<[u8]>,
{
let mut names = BTreeSet::new();
let mut classes = Vec::new();
for bytes in class_files {
let class = parse_and_lower(bytes.as_ref())?;
if !names.insert(class.name.clone()) {
return Err(Error::DuplicateClass {
class_name: class.name,
});
}
classes.push(class);
}
analyze_classes(&classes, &self.config).map(ClassInferences::new)
}
}
pub fn infer_class(bytes: &[u8]) -> Result<ClassInference, Error> {
Inferer::default().infer_class(bytes)
}
pub fn infer_classes<I, B>(class_files: I) -> Result<ClassInferences, Error>
where
I: IntoIterator<Item = B>,
B: AsRef<[u8]>,
{
Inferer::default().infer_classes(class_files)
}