ferro-jtype 0.2.8

Type inference for Java class bytecode without JDK symbols
Documentation
use std::collections::{HashMap, VecDeque};

use crate::ir::ClassIr;
use crate::{
    ClassInference, ClassName, DiagnosticSeverity, Error, InferenceConfig, InferredType,
    MethodDescriptor, MethodInvocationKind, MethodSummaries, MethodSummaryResolver,
};
use rust_asm::opcodes as op;

use super::resolution::{BatchCallTargets, BatchMethodKey, MethodKey, resolved_method_reference};
use super::summaries::analyze_class_with_method_summaries;

pub(crate) fn analyze_classes(
    classes: &[ClassIr],
    config: &InferenceConfig,
) -> Result<Vec<ClassInference>, Error> {
    let callers = batch_summary_callers(classes);
    let targets = BatchCallTargets::from_classes(classes);
    let mut summaries = MethodSummaries::new();
    let mut returned_parameters = HashMap::new();
    let mut analyses = (0..classes.len())
        .map(|_| None)
        .collect::<Vec<Option<ClassInference>>>();
    let mut scheduled = vec![true; classes.len()];
    let mut worklist = VecDeque::from_iter(0..classes.len());
    let mut reanalysis_items = 0_usize;
    let mut analysis_complete = true;

    while let Some(class_index) = worklist.pop_front() {
        scheduled[class_index] = false;
        if analyses[class_index].is_some() {
            reanalysis_items += 1;
            if !config.unbounded_analysis() && reanalysis_items > config.max_work_items() {
                analysis_complete = false;
                break;
            }
        }

        let class = &classes[class_index];
        let resolver = BatchSummaryResolver {
            external: config.method_summaries(),
            summaries: &summaries,
            returned_parameters: &returned_parameters,
            targets: &targets,
            current_owner: &class.name,
        };
        let inference = analyze_class_with_method_summaries(class, config, Some(&resolver))?;
        let changed =
            update_batch_method_summaries(&mut summaries, &mut returned_parameters, &inference);
        analyses[class_index] = Some(inference);

        for key in changed {
            let Some(callers) = callers.get(&key) else {
                continue;
            };
            for caller in callers {
                if !scheduled[*caller] {
                    scheduled[*caller] = true;
                    worklist.push_back(*caller);
                }
            }
        }
    }

    let mut analyses = analyses
        .into_iter()
        .map(|analysis| analysis.expect("every batch class is analyzed before summary convergence"))
        .collect::<Vec<_>>();
    if !analysis_complete {
        for analysis in &mut analyses {
            analysis.mark_batch_analysis_incomplete();
        }
    }

    if config.strict()
        && let Some(diagnostic) = analyses
            .iter()
            .flat_map(|analysis| analysis.diagnostics())
            .find(|diagnostic| diagnostic.severity() != DiagnosticSeverity::Note)
    {
        return Err(Error::StrictAnalysis {
            message: diagnostic.message().to_owned(),
        });
    }

    Ok(analyses)
}

struct BatchSummaryResolver<'a> {
    external: Option<&'a dyn MethodSummaryResolver>,
    summaries: &'a MethodSummaries,
    returned_parameters: &'a HashMap<BatchMethodKey, usize>,
    targets: &'a BatchCallTargets,
    current_owner: &'a ClassName,
}

impl BatchSummaryResolver<'_> {
    fn batch_return_type(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &MethodDescriptor,
        invocation_kind: MethodInvocationKind,
        receiver_is_exact_allocation: bool,
    ) -> Option<InferredType> {
        if owner == self.current_owner
            || !self.targets.is_deterministic(
                owner,
                name,
                descriptor,
                invocation_kind,
                receiver_is_exact_allocation,
            )
        {
            return None;
        }
        self.summaries.return_type(owner, name, descriptor)
    }
}

impl MethodSummaryResolver for BatchSummaryResolver<'_> {
    fn return_type(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &MethodDescriptor,
    ) -> Option<InferredType> {
        self.external
            .and_then(|resolver| resolver.return_type(owner, name, descriptor))
    }

    fn return_type_for_invocation(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &MethodDescriptor,
        invocation_kind: MethodInvocationKind,
    ) -> Option<InferredType> {
        self.external
            .and_then(|resolver| {
                resolver.return_type_for_invocation(owner, name, descriptor, invocation_kind)
            })
            .or_else(|| self.batch_return_type(owner, name, descriptor, invocation_kind, false))
    }

    fn return_type_for_call(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &MethodDescriptor,
        invocation_kind: MethodInvocationKind,
        receiver_is_exact_allocation: bool,
    ) -> Option<InferredType> {
        self.external
            .and_then(|resolver| {
                resolver.return_type_for_call(
                    owner,
                    name,
                    descriptor,
                    invocation_kind,
                    receiver_is_exact_allocation,
                )
            })
            .or_else(|| {
                self.batch_return_type(
                    owner,
                    name,
                    descriptor,
                    invocation_kind,
                    receiver_is_exact_allocation,
                )
            })
    }

    fn returned_parameter_index_for_invocation(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &MethodDescriptor,
        invocation_kind: MethodInvocationKind,
    ) -> Option<usize> {
        self.returned_parameter_index_for_call(owner, name, descriptor, invocation_kind, false)
    }

    fn returned_parameter_index_for_call(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &MethodDescriptor,
        invocation_kind: MethodInvocationKind,
        receiver_is_exact_allocation: bool,
    ) -> Option<usize> {
        if let Some(resolver) = self.external {
            let index = resolver.returned_parameter_index_for_call(
                owner,
                name,
                descriptor,
                invocation_kind,
                receiver_is_exact_allocation,
            );
            if index.is_some()
                || resolver
                    .return_type_for_call(
                        owner,
                        name,
                        descriptor,
                        invocation_kind,
                        receiver_is_exact_allocation,
                    )
                    .is_some()
            {
                return index;
            }
        }
        self.batch_return_type(
            owner,
            name,
            descriptor,
            invocation_kind,
            receiver_is_exact_allocation,
        )?;
        self.returned_parameters
            .get(&BatchMethodKey {
                owner: owner.clone(),
                method: MethodKey {
                    name: name.to_owned(),
                    descriptor: descriptor.clone(),
                },
            })
            .copied()
    }
}

fn update_batch_method_summaries(
    summaries: &mut MethodSummaries,
    returned_parameters: &mut HashMap<BatchMethodKey, usize>,
    inference: &ClassInference,
) -> Vec<BatchMethodKey> {
    let mut changed = Vec::new();
    for method in inference.methods() {
        let key = BatchMethodKey {
            owner: inference.class_name().clone(),
            method: MethodKey {
                name: method.name().to_owned(),
                descriptor: method.descriptor().clone(),
            },
        };
        let previous = summaries.return_type(&key.owner, &key.method.name, &key.method.descriptor);
        let next = method.inferred_return_type().cloned();
        let parameter_index = method.returned_parameter_index();
        let parameter_changed = returned_parameters.get(&key).copied() != parameter_index;
        if parameter_changed {
            match parameter_index {
                Some(index) => {
                    returned_parameters.insert(key.clone(), index);
                }
                None => {
                    returned_parameters.remove(&key);
                }
            }
        }
        if previous == next && !parameter_changed {
            continue;
        }
        match next {
            Some(return_type) => {
                summaries.insert_return_type(
                    key.owner.clone(),
                    key.method.name.clone(),
                    key.method.descriptor.clone(),
                    return_type,
                );
            }
            None => {
                summaries.remove_return_type(&key.owner, &key.method.name, &key.method.descriptor);
            }
        }
        changed.push(key);
    }
    changed
}

fn batch_summary_callers(classes: &[ClassIr]) -> HashMap<BatchMethodKey, Vec<usize>> {
    let mut callers = HashMap::<BatchMethodKey, Vec<usize>>::new();
    for (class_index, class) in classes.iter().enumerate() {
        for method in &class.methods {
            for instruction in method.instructions.iter().filter(|instruction| {
                matches!(instruction.opcode, op::INVOKEVIRTUAL..=op::INVOKESTATIC)
            }) {
                let Some((owner, name, descriptor)) = resolved_method_reference(instruction) else {
                    continue;
                };
                let Ok(descriptor) = MethodDescriptor::parse(descriptor) else {
                    continue;
                };
                callers
                    .entry(BatchMethodKey {
                        owner: owner.clone(),
                        method: MethodKey {
                            name: name.to_owned(),
                            descriptor,
                        },
                    })
                    .or_default()
                    .push(class_index);
            }
        }
    }
    for callers in callers.values_mut() {
        callers.sort_unstable();
        callers.dedup();
    }
    callers
}