Skip to main content

InstructionInference

Struct InstructionInference 

Source
pub struct InstructionInference { /* private fields */ }
Expand description

Inferred abstract state at one bytecode instruction.

The local-variable and operand-stack slices describe the state immediately before and immediately after the instruction at Self::bytecode_offset.

Implementations§

Source§

impl InstructionInference

Source

pub const fn bytecode_offset(&self) -> u16

Returns this instruction’s offset within its method’s Code attribute.

Examples found in repository?
examples/support/comparison.rs (line 79)
55pub fn compare(left: &ClassInferences, right: &ClassInferences) {
56    let mut changed = 0;
57    let mut stacks = 0;
58    let mut locals = 0;
59    let mut coverage = 0;
60    let mut returns = 0;
61    let mut method_locals = 0;
62    let mut constraints = 0;
63    assert_eq!(
64        left.len(),
65        right.len(),
66        "the same inputs must retain class metadata"
67    );
68    for (class, other) in left.classes().iter().zip(right.classes()) {
69        assert_eq!(class.class_name(), other.class_name());
70        assert_eq!(class.methods().len(), other.methods().len());
71        for (method, other) in class.methods().iter().zip(other.methods()) {
72            assert_eq!(method.name(), other.name());
73            assert_eq!(method.descriptor(), other.descriptor());
74            returns += usize::from(method.inferred_return_type() != other.inferred_return_type());
75            method_locals += usize::from(method.local_types() != other.local_types());
76            let before = method
77                .instructions()
78                .iter()
79                .map(|i| (i.bytecode_offset(), i))
80                .collect::<BTreeMap<_, _>>();
81            let after = other
82                .instructions()
83                .iter()
84                .map(|i| (i.bytecode_offset(), i))
85                .collect::<BTreeMap<_, _>>();
86            let offsets = before
87                .keys()
88                .chain(after.keys())
89                .copied()
90                .collect::<BTreeSet<_>>();
91            let mut method_changes = 0;
92            for offset in offsets {
93                let (Some(instruction), Some(other)) = (before.get(&offset), after.get(&offset))
94                else {
95                    coverage += 1;
96                    continue;
97                };
98                let local_changed = instruction.local_types() != other.local_types();
99                let stack_changed = instruction.stack_before() != other.stack_before()
100                    || instruction.stack_after() != other.stack_after();
101                locals += usize::from(local_changed);
102                stacks += usize::from(stack_changed);
103                constraints +=
104                    usize::from(instruction.operand_expectations() != other.operand_expectations());
105                if local_changed || stack_changed {
106                    changed += 1;
107                    method_changes += 1;
108                }
109            }
110            if method_changes != 0 {
111                println!(
112                    "  {}.{} {:?}: {method_changes} instruction states differ",
113                    class.class_name(),
114                    method.name(),
115                    method.descriptor()
116                );
117            }
118        }
119    }
120    println!(
121        "Differences: instructions={changed}, stacks={stacks}, locals={locals}, reachability={coverage}, returns={returns}, method-local summaries={method_locals}, operand constraints={constraints}"
122    );
123    println!(
124        "Bottom in unused locals and category-two companion slots is not a missing type. Reference alternatives are retained evidence, not Unknown. Completion is not proof of recovered source types."
125    );
126}
More examples
Hide additional examples
examples/infer.rs (line 84)
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}
Source

pub const fn dynamic_call_kind(&self) -> Option<DynamicCallKind>

Returns recognized bootstrap metadata for an invokedynamic instruction.

Source

pub fn operand_expectations(&self) -> &[OperandExpectation]

Returns verifier-derived requirements for operands consumed by this instruction.

Each expectation names an index into Self::stack_before. The index uses that slice’s bottom-to-top order. Member calls, invokedynamic, field stores, and value returns report constraints when their descriptors and a complete operand stack are available. This does not execute a bootstrap method or alter the observed inferred types.

Examples found in repository?
examples/support/comparison.rs (line 21)
5pub fn report(label: &str, result: &ClassInferences) {
6    let mut methods = 0;
7    let mut instructions = 0;
8    let mut diagnostics = 0;
9    let mut unknown = 0;
10    let mut conflict = 0;
11    let mut bottom = 0;
12    let mut alternatives = 0;
13    let mut integral_all = 0;
14    let mut expectations = 0;
15    for class in result.classes() {
16        diagnostics += class.diagnostics().len();
17        for method in class.methods() {
18            methods += 1;
19            for instruction in method.instructions() {
20                instructions += 1;
21                expectations += instruction.operand_expectations().len();
22                for value in instruction
23                    .stack_before()
24                    .iter()
25                    .chain(instruction.stack_after())
26                {
27                    unknown += usize::from(contains(
28                        value,
29                        &InferredType::Reference(ReferenceType::Unknown),
30                    ));
31                    conflict += usize::from(contains(value, &InferredType::Conflict));
32                    bottom += usize::from(contains(value, &InferredType::Bottom));
33                    alternatives += usize::from(matches!(value, InferredType::Alternatives(_)));
34                    integral_all +=
35                        usize::from(value.integral_types() == Some(IntegralTypeSet::ALL));
36                }
37            }
38        }
39    }
40    println!(
41        "{label}: classes={}, methods={methods}, instructions={instructions}, complete={}, diagnostics={diagnostics}, stack unknown={unknown}, conflict={conflict}, bottom={bottom}, alternatives={alternatives}",
42        result.len(),
43        result.analysis_complete()
44    );
45    println!(
46        "  operand constraints={expectations}, stack values with all integral candidates={integral_all}"
47    );
48}
49
50fn contains(value: &InferredType, needle: &InferredType) -> bool {
51    value == needle
52        || matches!(value, InferredType::Alternatives(values) if values.iter().any(|value| contains(value, needle)))
53}
54
55pub fn compare(left: &ClassInferences, right: &ClassInferences) {
56    let mut changed = 0;
57    let mut stacks = 0;
58    let mut locals = 0;
59    let mut coverage = 0;
60    let mut returns = 0;
61    let mut method_locals = 0;
62    let mut constraints = 0;
63    assert_eq!(
64        left.len(),
65        right.len(),
66        "the same inputs must retain class metadata"
67    );
68    for (class, other) in left.classes().iter().zip(right.classes()) {
69        assert_eq!(class.class_name(), other.class_name());
70        assert_eq!(class.methods().len(), other.methods().len());
71        for (method, other) in class.methods().iter().zip(other.methods()) {
72            assert_eq!(method.name(), other.name());
73            assert_eq!(method.descriptor(), other.descriptor());
74            returns += usize::from(method.inferred_return_type() != other.inferred_return_type());
75            method_locals += usize::from(method.local_types() != other.local_types());
76            let before = method
77                .instructions()
78                .iter()
79                .map(|i| (i.bytecode_offset(), i))
80                .collect::<BTreeMap<_, _>>();
81            let after = other
82                .instructions()
83                .iter()
84                .map(|i| (i.bytecode_offset(), i))
85                .collect::<BTreeMap<_, _>>();
86            let offsets = before
87                .keys()
88                .chain(after.keys())
89                .copied()
90                .collect::<BTreeSet<_>>();
91            let mut method_changes = 0;
92            for offset in offsets {
93                let (Some(instruction), Some(other)) = (before.get(&offset), after.get(&offset))
94                else {
95                    coverage += 1;
96                    continue;
97                };
98                let local_changed = instruction.local_types() != other.local_types();
99                let stack_changed = instruction.stack_before() != other.stack_before()
100                    || instruction.stack_after() != other.stack_after();
101                locals += usize::from(local_changed);
102                stacks += usize::from(stack_changed);
103                constraints +=
104                    usize::from(instruction.operand_expectations() != other.operand_expectations());
105                if local_changed || stack_changed {
106                    changed += 1;
107                    method_changes += 1;
108                }
109            }
110            if method_changes != 0 {
111                println!(
112                    "  {}.{} {:?}: {method_changes} instruction states differ",
113                    class.class_name(),
114                    method.name(),
115                    method.descriptor()
116                );
117            }
118        }
119    }
120    println!(
121        "Differences: instructions={changed}, stacks={stacks}, locals={locals}, reachability={coverage}, returns={returns}, method-local summaries={method_locals}, operand constraints={constraints}"
122    );
123    println!(
124        "Bottom in unused locals and category-two companion slots is not a missing type. Reference alternatives are retained evidence, not Unknown. Completion is not proof of recovered source types."
125    );
126}
More examples
Hide additional examples
examples/infer.rs (line 79)
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}
Source

pub fn local_types(&self) -> &[InferredType]

Returns local-variable types immediately before this instruction.

Values from different or unproven origins retain reference alternatives at joins. A reference hierarchy may refine joins of the same proven value.

Examples found in repository?
examples/support/comparison.rs (line 98)
55pub fn compare(left: &ClassInferences, right: &ClassInferences) {
56    let mut changed = 0;
57    let mut stacks = 0;
58    let mut locals = 0;
59    let mut coverage = 0;
60    let mut returns = 0;
61    let mut method_locals = 0;
62    let mut constraints = 0;
63    assert_eq!(
64        left.len(),
65        right.len(),
66        "the same inputs must retain class metadata"
67    );
68    for (class, other) in left.classes().iter().zip(right.classes()) {
69        assert_eq!(class.class_name(), other.class_name());
70        assert_eq!(class.methods().len(), other.methods().len());
71        for (method, other) in class.methods().iter().zip(other.methods()) {
72            assert_eq!(method.name(), other.name());
73            assert_eq!(method.descriptor(), other.descriptor());
74            returns += usize::from(method.inferred_return_type() != other.inferred_return_type());
75            method_locals += usize::from(method.local_types() != other.local_types());
76            let before = method
77                .instructions()
78                .iter()
79                .map(|i| (i.bytecode_offset(), i))
80                .collect::<BTreeMap<_, _>>();
81            let after = other
82                .instructions()
83                .iter()
84                .map(|i| (i.bytecode_offset(), i))
85                .collect::<BTreeMap<_, _>>();
86            let offsets = before
87                .keys()
88                .chain(after.keys())
89                .copied()
90                .collect::<BTreeSet<_>>();
91            let mut method_changes = 0;
92            for offset in offsets {
93                let (Some(instruction), Some(other)) = (before.get(&offset), after.get(&offset))
94                else {
95                    coverage += 1;
96                    continue;
97                };
98                let local_changed = instruction.local_types() != other.local_types();
99                let stack_changed = instruction.stack_before() != other.stack_before()
100                    || instruction.stack_after() != other.stack_after();
101                locals += usize::from(local_changed);
102                stacks += usize::from(stack_changed);
103                constraints +=
104                    usize::from(instruction.operand_expectations() != other.operand_expectations());
105                if local_changed || stack_changed {
106                    changed += 1;
107                    method_changes += 1;
108                }
109            }
110            if method_changes != 0 {
111                println!(
112                    "  {}.{} {:?}: {method_changes} instruction states differ",
113                    class.class_name(),
114                    method.name(),
115                    method.descriptor()
116                );
117            }
118        }
119    }
120    println!(
121        "Differences: instructions={changed}, stacks={stacks}, locals={locals}, reachability={coverage}, returns={returns}, method-local summaries={method_locals}, operand constraints={constraints}"
122    );
123    println!(
124        "Bottom in unused locals and category-two companion slots is not a missing type. Reference alternatives are retained evidence, not Unknown. Completion is not proof of recovered source types."
125    );
126}
Source

pub fn stack_before(&self) -> &[InferredType]

Returns operand-stack types immediately before this instruction.

Examples found in repository?
examples/support/comparison.rs (line 23)
5pub fn report(label: &str, result: &ClassInferences) {
6    let mut methods = 0;
7    let mut instructions = 0;
8    let mut diagnostics = 0;
9    let mut unknown = 0;
10    let mut conflict = 0;
11    let mut bottom = 0;
12    let mut alternatives = 0;
13    let mut integral_all = 0;
14    let mut expectations = 0;
15    for class in result.classes() {
16        diagnostics += class.diagnostics().len();
17        for method in class.methods() {
18            methods += 1;
19            for instruction in method.instructions() {
20                instructions += 1;
21                expectations += instruction.operand_expectations().len();
22                for value in instruction
23                    .stack_before()
24                    .iter()
25                    .chain(instruction.stack_after())
26                {
27                    unknown += usize::from(contains(
28                        value,
29                        &InferredType::Reference(ReferenceType::Unknown),
30                    ));
31                    conflict += usize::from(contains(value, &InferredType::Conflict));
32                    bottom += usize::from(contains(value, &InferredType::Bottom));
33                    alternatives += usize::from(matches!(value, InferredType::Alternatives(_)));
34                    integral_all +=
35                        usize::from(value.integral_types() == Some(IntegralTypeSet::ALL));
36                }
37            }
38        }
39    }
40    println!(
41        "{label}: classes={}, methods={methods}, instructions={instructions}, complete={}, diagnostics={diagnostics}, stack unknown={unknown}, conflict={conflict}, bottom={bottom}, alternatives={alternatives}",
42        result.len(),
43        result.analysis_complete()
44    );
45    println!(
46        "  operand constraints={expectations}, stack values with all integral candidates={integral_all}"
47    );
48}
49
50fn contains(value: &InferredType, needle: &InferredType) -> bool {
51    value == needle
52        || matches!(value, InferredType::Alternatives(values) if values.iter().any(|value| contains(value, needle)))
53}
54
55pub fn compare(left: &ClassInferences, right: &ClassInferences) {
56    let mut changed = 0;
57    let mut stacks = 0;
58    let mut locals = 0;
59    let mut coverage = 0;
60    let mut returns = 0;
61    let mut method_locals = 0;
62    let mut constraints = 0;
63    assert_eq!(
64        left.len(),
65        right.len(),
66        "the same inputs must retain class metadata"
67    );
68    for (class, other) in left.classes().iter().zip(right.classes()) {
69        assert_eq!(class.class_name(), other.class_name());
70        assert_eq!(class.methods().len(), other.methods().len());
71        for (method, other) in class.methods().iter().zip(other.methods()) {
72            assert_eq!(method.name(), other.name());
73            assert_eq!(method.descriptor(), other.descriptor());
74            returns += usize::from(method.inferred_return_type() != other.inferred_return_type());
75            method_locals += usize::from(method.local_types() != other.local_types());
76            let before = method
77                .instructions()
78                .iter()
79                .map(|i| (i.bytecode_offset(), i))
80                .collect::<BTreeMap<_, _>>();
81            let after = other
82                .instructions()
83                .iter()
84                .map(|i| (i.bytecode_offset(), i))
85                .collect::<BTreeMap<_, _>>();
86            let offsets = before
87                .keys()
88                .chain(after.keys())
89                .copied()
90                .collect::<BTreeSet<_>>();
91            let mut method_changes = 0;
92            for offset in offsets {
93                let (Some(instruction), Some(other)) = (before.get(&offset), after.get(&offset))
94                else {
95                    coverage += 1;
96                    continue;
97                };
98                let local_changed = instruction.local_types() != other.local_types();
99                let stack_changed = instruction.stack_before() != other.stack_before()
100                    || instruction.stack_after() != other.stack_after();
101                locals += usize::from(local_changed);
102                stacks += usize::from(stack_changed);
103                constraints +=
104                    usize::from(instruction.operand_expectations() != other.operand_expectations());
105                if local_changed || stack_changed {
106                    changed += 1;
107                    method_changes += 1;
108                }
109            }
110            if method_changes != 0 {
111                println!(
112                    "  {}.{} {:?}: {method_changes} instruction states differ",
113                    class.class_name(),
114                    method.name(),
115                    method.descriptor()
116                );
117            }
118        }
119    }
120    println!(
121        "Differences: instructions={changed}, stacks={stacks}, locals={locals}, reachability={coverage}, returns={returns}, method-local summaries={method_locals}, operand constraints={constraints}"
122    );
123    println!(
124        "Bottom in unused locals and category-two companion slots is not a missing type. Reference alternatives are retained evidence, not Unknown. Completion is not proof of recovered source types."
125    );
126}
Source

pub fn stack_after(&self) -> &[InferredType]

Returns operand-stack types immediately after this instruction.

Examples found in repository?
examples/support/comparison.rs (line 25)
5pub fn report(label: &str, result: &ClassInferences) {
6    let mut methods = 0;
7    let mut instructions = 0;
8    let mut diagnostics = 0;
9    let mut unknown = 0;
10    let mut conflict = 0;
11    let mut bottom = 0;
12    let mut alternatives = 0;
13    let mut integral_all = 0;
14    let mut expectations = 0;
15    for class in result.classes() {
16        diagnostics += class.diagnostics().len();
17        for method in class.methods() {
18            methods += 1;
19            for instruction in method.instructions() {
20                instructions += 1;
21                expectations += instruction.operand_expectations().len();
22                for value in instruction
23                    .stack_before()
24                    .iter()
25                    .chain(instruction.stack_after())
26                {
27                    unknown += usize::from(contains(
28                        value,
29                        &InferredType::Reference(ReferenceType::Unknown),
30                    ));
31                    conflict += usize::from(contains(value, &InferredType::Conflict));
32                    bottom += usize::from(contains(value, &InferredType::Bottom));
33                    alternatives += usize::from(matches!(value, InferredType::Alternatives(_)));
34                    integral_all +=
35                        usize::from(value.integral_types() == Some(IntegralTypeSet::ALL));
36                }
37            }
38        }
39    }
40    println!(
41        "{label}: classes={}, methods={methods}, instructions={instructions}, complete={}, diagnostics={diagnostics}, stack unknown={unknown}, conflict={conflict}, bottom={bottom}, alternatives={alternatives}",
42        result.len(),
43        result.analysis_complete()
44    );
45    println!(
46        "  operand constraints={expectations}, stack values with all integral candidates={integral_all}"
47    );
48}
49
50fn contains(value: &InferredType, needle: &InferredType) -> bool {
51    value == needle
52        || matches!(value, InferredType::Alternatives(values) if values.iter().any(|value| contains(value, needle)))
53}
54
55pub fn compare(left: &ClassInferences, right: &ClassInferences) {
56    let mut changed = 0;
57    let mut stacks = 0;
58    let mut locals = 0;
59    let mut coverage = 0;
60    let mut returns = 0;
61    let mut method_locals = 0;
62    let mut constraints = 0;
63    assert_eq!(
64        left.len(),
65        right.len(),
66        "the same inputs must retain class metadata"
67    );
68    for (class, other) in left.classes().iter().zip(right.classes()) {
69        assert_eq!(class.class_name(), other.class_name());
70        assert_eq!(class.methods().len(), other.methods().len());
71        for (method, other) in class.methods().iter().zip(other.methods()) {
72            assert_eq!(method.name(), other.name());
73            assert_eq!(method.descriptor(), other.descriptor());
74            returns += usize::from(method.inferred_return_type() != other.inferred_return_type());
75            method_locals += usize::from(method.local_types() != other.local_types());
76            let before = method
77                .instructions()
78                .iter()
79                .map(|i| (i.bytecode_offset(), i))
80                .collect::<BTreeMap<_, _>>();
81            let after = other
82                .instructions()
83                .iter()
84                .map(|i| (i.bytecode_offset(), i))
85                .collect::<BTreeMap<_, _>>();
86            let offsets = before
87                .keys()
88                .chain(after.keys())
89                .copied()
90                .collect::<BTreeSet<_>>();
91            let mut method_changes = 0;
92            for offset in offsets {
93                let (Some(instruction), Some(other)) = (before.get(&offset), after.get(&offset))
94                else {
95                    coverage += 1;
96                    continue;
97                };
98                let local_changed = instruction.local_types() != other.local_types();
99                let stack_changed = instruction.stack_before() != other.stack_before()
100                    || instruction.stack_after() != other.stack_after();
101                locals += usize::from(local_changed);
102                stacks += usize::from(stack_changed);
103                constraints +=
104                    usize::from(instruction.operand_expectations() != other.operand_expectations());
105                if local_changed || stack_changed {
106                    changed += 1;
107                    method_changes += 1;
108                }
109            }
110            if method_changes != 0 {
111                println!(
112                    "  {}.{} {:?}: {method_changes} instruction states differ",
113                    class.class_name(),
114                    method.name(),
115                    method.descriptor()
116                );
117            }
118        }
119    }
120    println!(
121        "Differences: instructions={changed}, stacks={stacks}, locals={locals}, reachability={coverage}, returns={returns}, method-local summaries={method_locals}, operand constraints={constraints}"
122    );
123    println!(
124        "Bottom in unused locals and category-two companion slots is not a missing type. Reference alternatives are retained evidence, not Unknown. Completion is not proof of recovered source types."
125    );
126}

Trait Implementations§

Source§

impl Clone for InstructionInference

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for InstructionInference

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.