Skip to main content

ClassInference

Struct ClassInference 

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

Type-inference results for one Java class file.

Diagnostics describe recoverable conditions observed while processing the class. Inspect them when consuming inference from malformed, unsupported, or intentionally obfuscated bytecode.

Implementations§

Source§

impl ClassInference

Source

pub const fn class_name(&self) -> &ClassName

Returns the JVM internal name of the analyzed class.

Examples found in repository?
examples/support/comparison.rs (line 69)
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 56)
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 generic_signature(&self) -> Option<&GenericSignature>

Returns the class’s generic Signature attribute, when present.

Source

pub fn methods(&self) -> &[MethodInference]

Returns one inference result for each method in the class file.

Examples found in repository?
examples/support/comparison.rs (line 17)
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 59)
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 diagnostics(&self) -> &[Diagnostic]

Returns diagnostics emitted while analyzing the class.

Examples found in repository?
examples/support/comparison.rs (line 16)
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}
More examples
Hide additional examples
examples/infer.rs (line 96)
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 analysis_complete(&self) -> bool

Returns whether every method reached a fixed point within configured limits.

This does not hide instruction-level diagnostics; inspect Self::diagnostics for unsupported or malformed bytecode details.

Examples found in repository?
examples/infer.rs (line 57)
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}

Trait Implementations§

Source§

impl Clone for ClassInference

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 ClassInference

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.