ferro-jtype 0.2.8

Type inference for Java class bytecode without JDK symbols
Documentation
use crate::ir::{InstructionIr, InstructionOperandIr, MethodIr};
use crate::solver::frame::{Frame, inferred_from_descriptor};
use crate::{Diagnostic, InferredType, IntegralTypeSet, ReferenceType, TypeDescriptor};

use super::{discard, pop, type_name};

pub(super) fn array_load(
    frame: &mut Frame,
    result: InferredType,
    method: &MethodIr,
    instruction: &InstructionIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    discard(frame, method, instruction, diagnostics);
    discard(frame, method, instruction, diagnostics);
    frame.push(result);
}

pub(super) fn integral_array_load(
    frame: &mut Frame,
    fallback: IntegralTypeSet,
    method: &MethodIr,
    instruction: &InstructionIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    discard(frame, method, instruction, diagnostics);
    let array = pop(frame, method, instruction, diagnostics);
    let result = primitive_array_element(&array)
        .filter(|element| {
            element
                .exact_type()
                .is_some_and(|primitive| fallback.contains(primitive))
        })
        .unwrap_or(fallback);
    frame.push(InferredType::from_integral_types(result));
}

fn primitive_array_element(array: &InferredType) -> Option<IntegralTypeSet> {
    let InferredType::Reference(ReferenceType::Array(TypeDescriptor::Array {
        dimensions: 1,
        element,
    })) = array
    else {
        return None;
    };

    let TypeDescriptor::Primitive(primitive) = element.as_ref() else {
        return None;
    };
    IntegralTypeSet::from_primitive(*primitive)
}

pub(super) fn reference_array_load(
    frame: &mut Frame,
    method: &MethodIr,
    instruction: &InstructionIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    discard(frame, method, instruction, diagnostics);
    let array = pop(frame, method, instruction, diagnostics);
    frame.push(reference_array_element_type(&array));
}

fn reference_array_element_type(array: &InferredType) -> InferredType {
    if let InferredType::Alternatives(arrays) = array {
        return arrays
            .iter()
            .map(reference_array_element_type)
            .reduce(|left, right| left.join(&right))
            .unwrap_or(InferredType::Reference(ReferenceType::Unknown));
    }
    let InferredType::Reference(ReferenceType::Array(TypeDescriptor::Array {
        dimensions,
        element,
    })) = array
    else {
        return InferredType::Reference(ReferenceType::Unknown);
    };

    if *dimensions == 1 {
        return inferred_from_descriptor(element);
    }

    InferredType::Reference(ReferenceType::Array(TypeDescriptor::Array {
        dimensions: dimensions - 1,
        element: element.clone(),
    }))
}

pub(super) fn array_store(
    frame: &mut Frame,
    method: &MethodIr,
    instruction: &InstructionIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    discard(frame, method, instruction, diagnostics);
    discard(frame, method, instruction, diagnostics);
    discard(frame, method, instruction, diagnostics);
}

pub(super) fn allocate_primitive_array(
    instruction: &InstructionIr,
    frame: &mut Frame,
    method: &MethodIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    discard(frame, method, instruction, diagnostics);
    let primitive = match instruction.operand {
        InstructionOperandIr::Immediate(4) => crate::PrimitiveType::Boolean,
        InstructionOperandIr::Immediate(5) => crate::PrimitiveType::Char,
        InstructionOperandIr::Immediate(6) => crate::PrimitiveType::Float,
        InstructionOperandIr::Immediate(7) => crate::PrimitiveType::Double,
        InstructionOperandIr::Immediate(8) => crate::PrimitiveType::Byte,
        InstructionOperandIr::Immediate(9) => crate::PrimitiveType::Short,
        InstructionOperandIr::Immediate(10) => crate::PrimitiveType::Int,
        InstructionOperandIr::Immediate(11) => crate::PrimitiveType::Long,
        _ => {
            frame.push(InferredType::Reference(ReferenceType::Unknown));
            return;
        }
    };
    frame.push(InferredType::Reference(ReferenceType::Array(
        TypeDescriptor::Array {
            dimensions: 1,
            element: Box::new(TypeDescriptor::Primitive(primitive)),
        },
    )));
}

pub(super) fn allocate_reference_array(
    instruction: &InstructionIr,
    frame: &mut Frame,
    method: &MethodIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    discard(frame, method, instruction, diagnostics);
    let reference = type_name(instruction)
        .and_then(array_element_descriptor)
        .and_then(array_of)
        .map(ReferenceType::Array)
        .unwrap_or(ReferenceType::Unknown);
    frame.push(InferredType::Reference(reference));
}

pub(super) fn allocate_multi_array(
    instruction: &InstructionIr,
    frame: &mut Frame,
    method: &MethodIr,
    diagnostics: &mut Vec<Diagnostic>,
) {
    let dimensions = match instruction.operand {
        InstructionOperandIr::MultiArray { dimensions, .. } => dimensions,
        _ => 0,
    };
    for _ in 0..dimensions {
        discard(frame, method, instruction, diagnostics);
    }
    let reference = type_name(instruction)
        .and_then(|name| TypeDescriptor::parse(name).ok())
        .and_then(|descriptor| match descriptor {
            descriptor @ TypeDescriptor::Array { .. } => Some(ReferenceType::Array(descriptor)),
            TypeDescriptor::Primitive(_) | TypeDescriptor::Reference(_) => None,
        })
        .unwrap_or(ReferenceType::Unknown);
    frame.push(InferredType::Reference(reference));
}

fn array_element_descriptor(name: &str) -> Option<TypeDescriptor> {
    reference_descriptor(name).or_else(|| {
        crate::ClassName::parse(name)
            .ok()
            .map(TypeDescriptor::Reference)
    })
}

fn array_of(component: TypeDescriptor) -> Option<TypeDescriptor> {
    match component {
        TypeDescriptor::Array {
            dimensions,
            element,
        } => Some(TypeDescriptor::Array {
            dimensions: dimensions.checked_add(1)?,
            element,
        }),
        element => Some(TypeDescriptor::Array {
            dimensions: 1,
            element: Box::new(element),
        }),
    }
}

fn reference_descriptor(name: &str) -> Option<TypeDescriptor> {
    if name.starts_with('[') {
        TypeDescriptor::parse(name).ok()
    } else {
        crate::ClassName::parse(name)
            .ok()
            .map(TypeDescriptor::Reference)
    }
}