foundry_cheatcodes/inspector/
analysis.rs1use alloy_primitives::map::HashSet;
4use foundry_common::fmt::{StructDefinitions, TypeDefMap};
5use solar::sema::{self, Compiler, Gcx, hir};
6use std::sync::{Arc, OnceLock};
7use thiserror::Error;
8
9#[derive(Debug, Clone, PartialEq, Eq, Error)]
11pub enum AnalysisError {
12 #[error("unable to resolve struct definitions")]
14 StructDefinitionsResolutionFailed,
15}
16
17#[derive(Clone)]
37pub struct CheatcodeAnalysis {
38 pub compiler: Arc<Compiler>,
40
41 struct_defs: OnceLock<Result<StructDefinitions, AnalysisError>>,
44}
45
46impl std::fmt::Debug for CheatcodeAnalysis {
47 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 f.debug_struct("CheatcodeAnalysis")
49 .field("compiler", &"<compiler>")
50 .field("struct_defs", &self.struct_defs)
51 .finish()
52 }
53}
54
55impl CheatcodeAnalysis {
56 pub const fn new(compiler: Arc<solar::sema::Compiler>) -> Self {
57 Self { compiler, struct_defs: OnceLock::new() }
58 }
59
60 pub fn struct_defs(&self) -> Result<&StructDefinitions, &AnalysisError> {
62 self.struct_defs
63 .get_or_init(|| {
64 self.compiler.enter(|compiler| {
65 let gcx = compiler.gcx();
66
67 StructDefinitionResolver::new(gcx).process()
68 })
69 })
70 .as_ref()
71 }
72}
73
74struct StructDefinitionResolver<'gcx> {
78 gcx: Gcx<'gcx>,
79 struct_defs: TypeDefMap,
80 visited: HashSet<hir::StructId>,
82}
83
84impl<'gcx> StructDefinitionResolver<'gcx> {
85 pub fn new(gcx: Gcx<'gcx>) -> Self {
87 Self { gcx, struct_defs: TypeDefMap::new(), visited: HashSet::default() }
88 }
89
90 pub fn process(mut self) -> Result<StructDefinitions, AnalysisError> {
92 for id in self.hir().strukt_ids() {
93 self.resolve_struct_definition(id)?;
94 }
95 Ok(self.struct_defs.into())
96 }
97
98 #[inline]
99 fn hir(&self) -> &'gcx hir::Hir<'gcx> {
100 &self.gcx.hir
101 }
102
103 fn resolve_struct_definition(&mut self, id: hir::StructId) -> Result<(), AnalysisError> {
105 let qualified_name = self.get_fully_qualified_name(id);
106 if !self.visited.insert(id) || self.struct_defs.contains_key(&qualified_name) {
107 return Ok(());
108 }
109
110 let hir = self.hir();
111 let strukt = hir.strukt(id);
112 let mut fields = Vec::with_capacity(strukt.fields.len());
113
114 for &field_id in strukt.fields {
115 let var = hir.variable(field_id);
116 let name =
117 var.name.ok_or(AnalysisError::StructDefinitionsResolutionFailed)?.to_string();
118 if let Some(ty_str) = self.ty_to_string(self.gcx.type_of_hir_ty(&var.ty)) {
119 fields.push((name, ty_str));
120 }
121 }
122
123 if !fields.is_empty() {
125 self.struct_defs.insert(qualified_name, fields);
126 }
127
128 Ok(())
129 }
130
131 fn ty_to_string(&mut self, ty: sema::Ty<'gcx>) -> Option<String> {
133 let ty = ty.peel_refs();
134 let res = match ty.kind {
135 sema::ty::TyKind::Elementary(e) => e.to_string(),
136 sema::ty::TyKind::Array(ty, size) => {
137 let inner_type = self.ty_to_string(ty)?;
138 format!("{inner_type}[{size}]")
139 }
140 sema::ty::TyKind::DynArray(ty) => {
141 let inner_type = self.ty_to_string(ty)?;
142 format!("{inner_type}[]")
143 }
144 sema::ty::TyKind::Struct(id) => {
145 self.resolve_struct_definition(id).ok()?;
147 self.get_fully_qualified_name(id)
148 }
149 sema::ty::TyKind::Udvt(ty, _) => self.ty_to_string(ty)?,
150 sema::ty::TyKind::Enum(_) => "uint8".to_string(),
152 sema::ty::TyKind::Contract(_) => "address".to_string(),
154 _ => return None,
156 };
157
158 Some(res)
159 }
160
161 fn get_fully_qualified_name(&self, id: hir::StructId) -> String {
163 let hir = self.hir();
164 let strukt = hir.strukt(id);
165 if let Some(contract_id) = strukt.contract {
166 format!("{}.{}", hir.contract(contract_id).name.as_str(), strukt.name.as_str())
167 } else {
168 strukt.name.as_str().into()
169 }
170 }
171}