ferro-jtype 0.2.8

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

use crate::ir::{ClassIr, InstructionIr, InstructionOperandIr, MemberRefIr, MethodIr};
use crate::summary::value_type_matches_descriptor;
use crate::{
    ClassName, FieldSummaries, FieldSummaryResolver, InferredType, MethodInference, TypeDescriptor,
    TypeHierarchy,
};
use rust_asm::opcodes as op;

pub(super) struct StaticFieldResolver<'a> {
    external: Option<&'a dyn FieldSummaryResolver>,
    local: &'a FieldSummaries,
}

impl StaticFieldResolver<'_> {
    pub(super) fn new<'a>(
        external: Option<&'a dyn FieldSummaryResolver>,
        local: &'a FieldSummaries,
    ) -> StaticFieldResolver<'a> {
        StaticFieldResolver { external, local }
    }
}

impl FieldSummaryResolver for StaticFieldResolver<'_> {
    fn value_type(
        &self,
        owner: &ClassName,
        name: &str,
        descriptor: &TypeDescriptor,
    ) -> Option<InferredType> {
        self.external
            .and_then(|resolver| resolver.value_type(owner, name, descriptor))
            .or_else(|| self.local.value_type(owner, name, descriptor))
    }
}

pub(super) fn update_local_static_field_summaries(
    class: &ClassIr,
    method: &MethodIr,
    inference: &MethodInference,
    fields: &mut FieldSummaries,
    hierarchy: Option<&dyn TypeHierarchy>,
) -> Vec<FieldKey> {
    if method.name != "<clinit>" || !inference.analysis_complete() {
        return Vec::new();
    }

    let observations = inference
        .instructions()
        .iter()
        .map(|instruction| (instruction.bytecode_offset(), instruction))
        .collect::<HashMap<_, _>>();
    let mut discovered = HashMap::new();

    for instruction in method
        .instructions
        .iter()
        .filter(|instruction| instruction.opcode == op::PUTSTATIC)
    {
        let Some(key) = local_static_field_key(class, instruction) else {
            continue;
        };
        let Some(value_type) = observations
            .get(&instruction.offset)
            .and_then(|instruction| instruction.stack_before().last())
        else {
            continue;
        };
        if !value_type_matches_descriptor(&key.descriptor, value_type) {
            continue;
        }
        discovered
            .entry(key)
            .and_modify(|current: &mut InferredType| {
                *current = current.join_with_hierarchy(value_type, hierarchy);
            })
            .or_insert_with(|| value_type.clone());
    }

    let mut changed = Vec::new();
    for (key, value_type) in discovered {
        if fields
            .value_type(&class.name, &key.name, &key.descriptor)
            .as_ref()
            == Some(&value_type)
        {
            continue;
        }
        fields.insert_value_type(
            class.name.clone(),
            key.name.clone(),
            key.descriptor.clone(),
            value_type,
        );
        changed.push(key);
    }
    changed
}

pub(super) fn local_field_readers(class: &ClassIr) -> HashMap<FieldKey, Vec<usize>> {
    let mut readers = HashMap::<FieldKey, Vec<usize>>::new();
    for (method_index, method) in class.methods.iter().enumerate() {
        for instruction in method
            .instructions
            .iter()
            .filter(|instruction| instruction.opcode == op::GETSTATIC)
        {
            let Some(key) = local_static_field_key(class, instruction) else {
                continue;
            };
            readers.entry(key).or_default().push(method_index);
        }
    }
    for field_readers in readers.values_mut() {
        field_readers.sort_unstable();
        field_readers.dedup();
    }
    readers
}

fn local_static_field_key(class: &ClassIr, instruction: &InstructionIr) -> Option<FieldKey> {
    let InstructionOperandIr::Member(MemberRefIr::Resolved {
        owner,
        name,
        descriptor,
    }) = &instruction.operand
    else {
        return None;
    };
    if owner != &class.name {
        return None;
    }
    Some(FieldKey {
        name: name.clone(),
        descriptor: TypeDescriptor::parse(descriptor).ok()?,
    })
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(super) struct FieldKey {
    pub(super) name: String,
    pub(super) descriptor: TypeDescriptor,
}