Skip to main content

infer/
infer.rs

1use std::{env, fs, path::Path, process::ExitCode, sync::Arc};
2
3use ferro_jtype::{ClassHierarchy, InferenceConfig, Inferer};
4
5fn main() -> ExitCode {
6    let mut arguments = env::args_os().skip(1);
7    let Some(path) = arguments.next() else {
8        eprintln!("usage: cargo run --example infer -- <class-file> [--reference <jar>]...");
9        return ExitCode::FAILURE;
10    };
11
12    let mut hierarchy = ClassHierarchy::new();
13    while let Some(option) = arguments.next() {
14        if option != "--reference" {
15            eprintln!("unknown option: {}", option.to_string_lossy());
16            return ExitCode::FAILURE;
17        }
18        let Some(reference) = arguments.next() else {
19            eprintln!("--reference requires a JAR path");
20            return ExitCode::FAILURE;
21        };
22        if let Err(error) = hierarchy.insert_jar_file(&reference) {
23            eprintln!("failed to index {}: {error}", reference.to_string_lossy());
24            return ExitCode::FAILURE;
25        }
26    }
27    let mut config = InferenceConfig::default();
28    if !hierarchy.is_empty() {
29        config = config.with_shared_type_hierarchy(Arc::new(hierarchy));
30    }
31    let inferer = match Inferer::new(config) {
32        Ok(inferer) => inferer,
33        Err(error) => {
34            eprintln!("failed to configure inference: {error}");
35            return ExitCode::FAILURE;
36        }
37    };
38
39    let path = Path::new(&path);
40    let bytes = match fs::read(path) {
41        Ok(bytes) => bytes,
42        Err(error) => {
43            eprintln!("failed to read {}: {error}", path.display());
44            return ExitCode::FAILURE;
45        }
46    };
47
48    let inference = match inferer.infer_class(&bytes) {
49        Ok(inference) => inference,
50        Err(error) => {
51            eprintln!("failed to infer {}: {error}", path.display());
52            return ExitCode::FAILURE;
53        }
54    };
55
56    println!("class: {}", inference.class_name().as_str());
57    println!("analysis complete: {}", inference.analysis_complete());
58
59    for method in inference.methods() {
60        println!("\nmethod: {}", method.name());
61        println!("  descriptor: {:?}", method.descriptor());
62        println!("  declared return type: {:?}", method.return_type());
63        println!(
64            "  inferred return type: {:?}",
65            method.inferred_return_type()
66        );
67        println!(
68            "  returned parameter index: {:?}",
69            method.returned_parameter_index()
70        );
71        println!("  analysis complete: {}", method.analysis_complete());
72        println!("  local types:");
73
74        for (slot, inferred_type) in method.local_types().iter().enumerate() {
75            println!("    {slot}: {inferred_type:?}");
76        }
77
78        for instruction in method.instructions() {
79            if instruction.operand_expectations().is_empty() {
80                continue;
81            }
82            println!(
83                "  operand expectations at {}:",
84                instruction.bytecode_offset()
85            );
86            for expectation in instruction.operand_expectations() {
87                println!(
88                    "    stack[{}]: {:?}",
89                    expectation.stack_index(),
90                    expectation.constraint()
91                );
92            }
93        }
94    }
95
96    if inference.diagnostics().is_empty() {
97        println!("\ndiagnostics: none");
98    } else {
99        println!("\ndiagnostics:");
100        for diagnostic in inference.diagnostics() {
101            let location = diagnostic.location();
102            println!(
103                "  {:?} {:?}: {}",
104                diagnostic.severity(),
105                diagnostic.kind(),
106                diagnostic.message()
107            );
108
109            if let Some(method_name) = location.method_name() {
110                println!(
111                    "    method: {}{}",
112                    method_name,
113                    location.method_descriptor().unwrap_or_default()
114                );
115            }
116            if let Some(offset) = location.bytecode_offset() {
117                println!("    bytecode offset: {offset}");
118            }
119        }
120    }
121
122    ExitCode::SUCCESS
123}