1use crate::{
2 ClassName, Diagnostic, DynamicCallKind, GenericSignature, InferredType, MethodDescriptor,
3 ReturnType, TypeDescriptor,
4};
5
6#[derive(Debug, Clone)]
12pub struct ClassInference {
13 class_name: ClassName,
14 generic_signature: Option<GenericSignature>,
15 methods: Vec<MethodInference>,
16 diagnostics: Vec<Diagnostic>,
17}
18
19impl ClassInference {
20 pub(crate) fn new(
21 class_name: ClassName,
22 generic_signature: Option<GenericSignature>,
23 methods: Vec<MethodInference>,
24 diagnostics: Vec<Diagnostic>,
25 ) -> Self {
26 Self {
27 class_name,
28 generic_signature,
29 methods,
30 diagnostics,
31 }
32 }
33
34 #[must_use]
36 pub const fn class_name(&self) -> &ClassName {
37 &self.class_name
38 }
39
40 #[must_use]
42 pub const fn generic_signature(&self) -> Option<&GenericSignature> {
43 self.generic_signature.as_ref()
44 }
45
46 #[must_use]
48 pub fn methods(&self) -> &[MethodInference] {
49 &self.methods
50 }
51
52 #[must_use]
54 pub fn diagnostics(&self) -> &[Diagnostic] {
55 &self.diagnostics
56 }
57
58 #[must_use]
63 pub fn analysis_complete(&self) -> bool {
64 self.methods.iter().all(MethodInference::analysis_complete)
65 }
66
67 pub(crate) fn mark_batch_analysis_incomplete(&mut self) {
68 for method in &mut self.methods {
69 method.mark_analysis_incomplete();
70 }
71 self.diagnostics.push(Diagnostic::new(
72 crate::DiagnosticSeverity::Error,
73 crate::DiagnosticKind::AnalysisLimitReached,
74 crate::DiagnosticLocation::class_level(),
75 "batch method-summary work-item budget was reached",
76 ));
77 }
78}
79
80#[derive(Debug, Clone)]
85pub struct ClassInferences {
86 classes: Vec<ClassInference>,
87}
88
89impl ClassInferences {
90 pub(crate) const fn new(classes: Vec<ClassInference>) -> Self {
91 Self { classes }
92 }
93
94 #[must_use]
96 pub fn classes(&self) -> &[ClassInference] {
97 &self.classes
98 }
99
100 #[must_use]
102 pub fn get(&self, class_name: &ClassName) -> Option<&ClassInference> {
103 self.classes
104 .iter()
105 .find(|inference| inference.class_name() == class_name)
106 }
107
108 #[must_use]
110 pub const fn len(&self) -> usize {
111 self.classes.len()
112 }
113
114 #[must_use]
116 pub const fn is_empty(&self) -> bool {
117 self.classes.is_empty()
118 }
119
120 #[must_use]
122 pub fn analysis_complete(&self) -> bool {
123 self.classes.iter().all(ClassInference::analysis_complete)
124 }
125}
126
127#[derive(Debug, Clone)]
132pub struct MethodInference {
133 name: String,
134 descriptor: MethodDescriptor,
135 generic_signature: Option<GenericSignature>,
136 analysis_complete: bool,
137 parameter_types: Vec<InferredType>,
138 return_type: ReturnType,
139 inferred_return_type: Option<InferredType>,
140 returned_parameter_index: Option<usize>,
141 local_types: Vec<InferredType>,
142 instructions: Vec<InstructionInference>,
143}
144
145pub(crate) struct MethodHeader {
146 pub(crate) descriptor: MethodDescriptor,
147 pub(crate) generic_signature: Option<GenericSignature>,
148 pub(crate) analysis_complete: bool,
149 pub(crate) parameter_types: Vec<InferredType>,
150 pub(crate) return_type: ReturnType,
151 pub(crate) inferred_return_type: Option<InferredType>,
152 pub(crate) returned_parameter_index: Option<usize>,
153}
154
155impl MethodInference {
156 pub(crate) fn new(
157 name: String,
158 header: MethodHeader,
159 local_types: Vec<InferredType>,
160 instructions: Vec<InstructionInference>,
161 ) -> Self {
162 Self {
163 name,
164 descriptor: header.descriptor,
165 generic_signature: header.generic_signature,
166 analysis_complete: header.analysis_complete,
167 parameter_types: header.parameter_types,
168 return_type: header.return_type,
169 inferred_return_type: header.inferred_return_type,
170 returned_parameter_index: header.returned_parameter_index,
171 local_types,
172 instructions,
173 }
174 }
175
176 #[must_use]
178 pub fn name(&self) -> &str {
179 &self.name
180 }
181
182 #[must_use]
184 pub const fn descriptor(&self) -> &MethodDescriptor {
185 &self.descriptor
186 }
187
188 #[must_use]
190 pub const fn generic_signature(&self) -> Option<&GenericSignature> {
191 self.generic_signature.as_ref()
192 }
193
194 #[must_use]
196 pub const fn analysis_complete(&self) -> bool {
197 self.analysis_complete
198 }
199
200 #[must_use]
202 pub fn parameter_types(&self) -> &[InferredType] {
203 &self.parameter_types
204 }
205
206 #[must_use]
208 pub const fn return_type(&self) -> &ReturnType {
209 &self.return_type
210 }
211
212 #[must_use]
219 pub const fn inferred_return_type(&self) -> Option<&InferredType> {
220 self.inferred_return_type.as_ref()
221 }
222
223 #[must_use]
229 pub const fn returned_parameter_index(&self) -> Option<usize> {
230 self.returned_parameter_index
231 }
232
233 pub(crate) fn mark_analysis_incomplete(&mut self) {
234 self.analysis_complete = false;
235 self.inferred_return_type = None;
236 self.returned_parameter_index = None;
237 }
238
239 #[must_use]
245 pub fn local_types(&self) -> &[InferredType] {
246 &self.local_types
247 }
248
249 #[must_use]
251 pub fn instructions(&self) -> &[InstructionInference] {
252 &self.instructions
253 }
254}
255
256#[derive(Debug, Clone)]
261pub struct InstructionInference {
262 bytecode_offset: u16,
263 dynamic_call_kind: Option<DynamicCallKind>,
264 operand_expectations: Vec<OperandExpectation>,
265 local_types: std::sync::Arc<[InferredType]>,
266 stack_before: Vec<InferredType>,
267 stack_after: Vec<InferredType>,
268}
269
270impl InstructionInference {
271 pub(crate) fn new(
272 bytecode_offset: u16,
273 dynamic_call_kind: Option<DynamicCallKind>,
274 operand_expectations: Vec<OperandExpectation>,
275 local_types: std::sync::Arc<[InferredType]>,
276 stack_before: Vec<InferredType>,
277 stack_after: Vec<InferredType>,
278 ) -> Self {
279 Self {
280 bytecode_offset,
281 dynamic_call_kind,
282 operand_expectations,
283 local_types,
284 stack_before,
285 stack_after,
286 }
287 }
288
289 #[must_use]
291 pub const fn bytecode_offset(&self) -> u16 {
292 self.bytecode_offset
293 }
294
295 #[must_use]
297 pub const fn dynamic_call_kind(&self) -> Option<DynamicCallKind> {
298 self.dynamic_call_kind
299 }
300
301 #[must_use]
309 pub fn operand_expectations(&self) -> &[OperandExpectation] {
310 &self.operand_expectations
311 }
312
313 #[must_use]
318 pub fn local_types(&self) -> &[InferredType] {
319 &self.local_types
320 }
321
322 #[must_use]
324 pub fn stack_before(&self) -> &[InferredType] {
325 &self.stack_before
326 }
327
328 #[must_use]
330 pub fn stack_after(&self) -> &[InferredType] {
331 &self.stack_after
332 }
333}
334
335#[derive(Debug, Clone, PartialEq, Eq)]
341pub struct OperandExpectation {
342 stack_index: usize,
343 constraint: OperandConstraint,
344}
345
346impl OperandExpectation {
347 pub(crate) const fn new(stack_index: usize, constraint: OperandConstraint) -> Self {
348 Self {
349 stack_index,
350 constraint,
351 }
352 }
353
354 #[must_use]
356 pub const fn stack_index(&self) -> usize {
357 self.stack_index
358 }
359
360 #[must_use]
362 pub const fn constraint(&self) -> &OperandConstraint {
363 &self.constraint
364 }
365}
366
367#[derive(Debug, Clone, PartialEq, Eq)]
369pub enum OperandConstraint {
370 Descriptor(TypeDescriptor),
372 ReceiverAssignableTo(ClassName),
374}