From 78271132959eb3a1b42852fd6c56e83af6ef4103 Mon Sep 17 00:00:00 2001 From: FroyaTheHen Date: Tue, 9 Dec 2025 10:55:25 +0800 Subject: [PATCH] improve SignatureError handling commit-id:a61f6971 --- .../src/documentable_formatter.rs | 208 ++++++------------ crates/cairo-lang-doc/src/signature_data.rs | 146 +++--------- crates/cairo-lang-doc/src/signature_errors.rs | 20 +- 3 files changed, 110 insertions(+), 264 deletions(-) diff --git a/crates/cairo-lang-doc/src/documentable_formatter.rs b/crates/cairo-lang-doc/src/documentable_formatter.rs index 93d8ced7982..7babb995394 100644 --- a/crates/cairo-lang-doc/src/documentable_formatter.rs +++ b/crates/cairo-lang-doc/src/documentable_formatter.rs @@ -153,7 +153,7 @@ impl<'db> HirFormatter<'db> { element_type: TypeId<'db>, postfix: Option<&str>, full_path: &String, - ) -> fmt::Result { + ) -> Result<(), SignatureError> { self.write_str(prefix.unwrap_or_default())?; let formatted_element_type = element_type.format(self.db); @@ -181,7 +181,7 @@ impl<'db> HirFormatter<'db> { } else { self.write_str(&extract_and_format(&formatted_element_type))?; } - self.write_str(postfix.unwrap_or_default()) + self.hir_write(postfix.unwrap_or_default()) } /// Adds [`LocationLink`] to [`HirFormatter`] instance, writes `name` argument into signature @@ -238,9 +238,7 @@ impl<'db> HirFormatter<'db> { impl<'db> HirDisplay<'db> for VariantId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let name = self.name(f.db); - let variant_semantic = - f.db.variant_semantic(self.enum_id(f.db), *self) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(self.full_path(f.db)))?; + let variant_semantic = f.db.variant_semantic(self.enum_id(f.db), *self)?; if !variant_semantic.ty.is_unit(f.db) { f.write_type( Some(&format!("{}: ", name.long(f.db))), @@ -249,9 +247,8 @@ impl<'db> HirDisplay<'db> for VariantId<'db> { &self.full_path(f.db), ) } else { - f.write_str(name.long(f.db)) + f.hir_write(name.long(f.db)) } - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db))) } } @@ -263,10 +260,7 @@ impl<'db> HirDisplay<'db> for EnumId<'db> { "{}enum {} {{", get_syntactic_visibility(&enum_full_signature.visibility), enum_full_signature.name.long(f.db), - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(enum_full_signature.full_path.clone()) - })?; + )?; let variants = enum_full_signature.variants; if let Some(variants) = variants { let is_variants_empty = variants.is_empty(); @@ -279,19 +273,13 @@ impl<'db> HirDisplay<'db> for EnumId<'db> { &enum_full_signature.full_path, ) } else { - write!(f, "\n{INDENT}{},", name.long(f.db)) - } - .map_err(|_| { - SignatureError::FailedWritingSignature(enum_full_signature.full_path.clone()) - })?; + f.hir_write(&format!("\n{INDENT}{},", name.long(f.db))) + }?; } - f.write_str(if is_variants_empty { "}" } else { "\n}" }) + f.hir_write(if is_variants_empty { "}" } else { "\n}" }) } else { - f.write_str("}") - } - .map_err(|_| { - SignatureError::FailedWritingSignature(enum_full_signature.full_path.clone()) - })?; + f.hir_write("}") + }?; f.format(); Ok(()) } @@ -302,12 +290,11 @@ impl<'db> HirDisplay<'db> for MemberId<'db> { let member_full_signature = Self::retrieve_signature_data(f.db, *self)?; if let Some(return_type) = member_full_signature.return_type { if return_type.is_unit(f.db) { - write!( - f, - "{}{}", + f.hir_write(&format!( + "{}{} = ", get_syntactic_visibility(&member_full_signature.visibility), - member_full_signature.name.long(f.db) - ) + member_full_signature.name.long(f.db), + )) } else { f.write_type( Some(&format!( @@ -320,13 +307,8 @@ impl<'db> HirDisplay<'db> for MemberId<'db> { &member_full_signature.full_path, ) } - .map_err(|_| { - SignatureError::FailedWritingSignatureFormatter( - member_full_signature.full_path.clone(), - ) - }) } else { - Err(SignatureError::FailedRetrievingSemanticData(self.full_path(f.db))) + Err(SignatureError::FailedWritingSignature(member_full_signature.full_path.clone())) } } } @@ -335,9 +317,7 @@ impl<'db> HirDisplay<'db> for StructId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let struct_full_signature = Self::retrieve_signature_data(f.db, *self)?; if let Some(attributes) = struct_full_signature.attributes { - let stx = get_struct_attributes_syntax(attributes, f.db).map_err(|_| { - SignatureError::FailedWritingSignature(struct_full_signature.full_path.clone()) - })?; + let stx = get_struct_attributes_syntax(attributes, f.db)?; f.hir_write(&stx)?; } write!( @@ -345,19 +325,13 @@ impl<'db> HirDisplay<'db> for StructId<'db> { "{}struct {}", get_syntactic_visibility(&struct_full_signature.visibility), struct_full_signature.name.long(f.db), - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(struct_full_signature.full_path.clone()) - })?; + )?; if let Some(generic_params) = struct_full_signature.generic_params { - let (stx, lls) = get_generic_params(generic_params, f.db).map_err(|_| { - SignatureError::FailedWritingSignature(struct_full_signature.full_path.clone()) - })?; + let (stx, lls) = get_generic_params(generic_params, f.db)?; f.write_chunk(&stx, lls)?; } - f.write_str(" {").map_err(|_| { - SignatureError::FailedWritingSignature(struct_full_signature.full_path.clone()) - })?; + + f.hir_write(" {")?; if let Some(members) = struct_full_signature.members { let is_members_empty = members.is_empty(); @@ -372,14 +346,9 @@ impl<'db> HirDisplay<'db> for StructId<'db> { member_type, Some(","), &struct_full_signature.full_path, - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(struct_full_signature.full_path.clone()) - })?; + )?; } - f.write_str(if is_members_empty { "}" } else { "\n}" }).map_err(|_| { - SignatureError::FailedWritingSignature(struct_full_signature.full_path.clone()) - })?; + f.hir_write(if is_members_empty { "}" } else { "\n}" })?; }; f.format(); Ok(()) @@ -389,8 +358,7 @@ impl<'db> HirDisplay<'db> for StructId<'db> { impl<'db> HirDisplay<'db> for FreeFunctionId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let free_function_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_function_signature(f, free_function_full_signature, "".to_string()) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_function_signature(f, free_function_full_signature, "".to_string())?; f.format(); Ok(()) } @@ -404,10 +372,7 @@ impl<'db> HirDisplay<'db> for ConstantId<'db> { "{}const {}: ", get_syntactic_visibility(&constant_full_signature.visibility), constant_full_signature.name.long(f.db), - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(constant_full_signature.full_path.clone()) - })?; + )?; if let Some(return_type) = constant_full_signature.return_type { f.write_type(None, return_type, Some(" = "), &constant_full_signature.full_path)?; } @@ -415,11 +380,7 @@ impl<'db> HirDisplay<'db> for ConstantId<'db> { match return_value_expr { Expr::Literal(v) => write!(f, "{};", v.value), Expr::FunctionCall(_) => { - let const_value_id = f.db.constant_const_value(*self).map_err(|_| { - SignatureError::FailedRetrievingSemanticData( - constant_full_signature.full_path.clone(), - ) - })?; + let const_value_id = f.db.constant_const_value(*self)?; let constant_value = const_value_id.long(f.db); if let ConstValue::Int(value, _) = constant_value { let stx = get_syntactic_evaluation(constant_full_signature.item_id, f.db)?; @@ -452,10 +413,7 @@ impl<'db> HirDisplay<'db> for ImplConstantDefId<'db> { return_type, Some(" = "), &constant_full_signature.full_path, - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(constant_full_signature.full_path.clone()) - })?; + )?; } let stx = get_syntactic_evaluation(constant_full_signature.item_id, f.db)?; f.hir_write(&stx)?; @@ -467,8 +425,7 @@ impl<'db> HirDisplay<'db> for ImplConstantDefId<'db> { impl<'db> HirDisplay<'db> for TraitFunctionId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let trait_function_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_function_signature(f, trait_function_full_signature, "".to_string()) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_function_signature(f, trait_function_full_signature, "".to_string())?; f.format(); Ok(()) } @@ -477,8 +434,7 @@ impl<'db> HirDisplay<'db> for TraitFunctionId<'db> { impl<'db> HirDisplay<'db> for ImplFunctionId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let impl_function_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_function_signature(f, impl_function_full_signature, "".to_string()) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_function_signature(f, impl_function_full_signature, "".to_string())?; f.format(); Ok(()) } @@ -505,19 +461,16 @@ impl<'db> HirDisplay<'db> for TraitId<'db> { impl<'db> HirDisplay<'db> for TraitConstantId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let trait_const_full_signature = Self::retrieve_signature_data(f.db, *self)?; - if let Some(return_type) = trait_const_full_signature.return_type { - write!( - f, - "const {}: {};", - trait_const_full_signature.name.long(f.db), - extract_and_format(&return_type.format(f.db)), - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(trait_const_full_signature.full_path) - })?; - } else { - Err(SignatureError::FailedRetrievingSemanticData(self.full_path(f.db)))?; - } + let return_type = trait_const_full_signature.return_type.ok_or( + SignatureError::FailedRetrievingSemanticData(trait_const_full_signature.full_path), + )?; + write!( + f, + "const {}: {};", + trait_const_full_signature.name.long(f.db), + extract_and_format(&return_type.format(f.db)), + )?; + f.format(); Ok(()) } @@ -526,9 +479,8 @@ impl<'db> HirDisplay<'db> for TraitConstantId<'db> { impl<'db> HirDisplay<'db> for ImplDefId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let impl_def_full_signature = Self::retrieve_signature_data(f.db, *self)?; - let trait_id = f.db.impl_def_trait(*self).map_err(|_| { - SignatureError::FailedRetrievingSemanticData(impl_def_full_signature.full_path.clone()) - })?; + let trait_id = f.db.impl_def_trait(*self)?; + if let Some(resolver_generic_params) = impl_def_full_signature.resolver_generic_params { let resolver_generic_params = format_resolver_generic_params(f.db, resolver_generic_params); @@ -539,19 +491,12 @@ impl<'db> HirDisplay<'db> for ImplDefId<'db> { impl_def_full_signature.name.long(f.db), resolver_generic_params, trait_id.name(f.db).long(f.db), - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(impl_def_full_signature.full_path.clone()) - })?; + )?; } if let Some(generic_args) = impl_def_full_signature.generic_args { - write_generic_args(generic_args, f).map_err(|_| { - SignatureError::FailedWritingSignature(impl_def_full_signature.full_path.clone()) - })?; + write_generic_args(generic_args, f)?; } - f.write_str(";").map_err(|_| { - SignatureError::FailedWritingSignature(impl_def_full_signature.full_path) - })?; + f.hir_write(";")?; f.format(); Ok(()) } @@ -565,10 +510,7 @@ impl<'db> HirDisplay<'db> for ImplAliasId<'db> { "{}impl {} = ", get_syntactic_visibility(&impl_alias_full_signature.visibility), self.name(f.db).long(f.db), - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(impl_alias_full_signature.full_path.clone()) - })?; + )?; let stx = get_syntactic_evaluation(impl_alias_full_signature.item_id, f.db)?; write!(f, "{}", stx)?; f.format(); @@ -579,8 +521,7 @@ impl<'db> HirDisplay<'db> for ImplAliasId<'db> { impl<'db> HirDisplay<'db> for ModuleTypeAliasId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let module_type_alias_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_type_signature(f, module_type_alias_full_signature, false) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_type_signature(f, module_type_alias_full_signature, false)?; f.format(); Ok(()) } @@ -589,8 +530,7 @@ impl<'db> HirDisplay<'db> for ModuleTypeAliasId<'db> { impl<'db> HirDisplay<'db> for TraitTypeId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let trait_type_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_type_signature(f, trait_type_full_signature, false) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_type_signature(f, trait_type_full_signature, false)?; f.format(); Ok(()) } @@ -599,8 +539,7 @@ impl<'db> HirDisplay<'db> for TraitTypeId<'db> { impl<'db> HirDisplay<'db> for ImplTypeDefId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let impl_type_def_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_type_signature(f, impl_type_def_full_signature, false) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_type_signature(f, impl_type_def_full_signature, false)?; f.format(); Ok(()) } @@ -609,8 +548,7 @@ impl<'db> HirDisplay<'db> for ImplTypeDefId<'db> { impl<'db> HirDisplay<'db> for ExternTypeId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let extern_type_full_signature = Self::retrieve_signature_data(f.db, *self)?; - write_type_signature(f, extern_type_full_signature, true) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + write_type_signature(f, extern_type_full_signature, true)?; f.format(); Ok(()) } @@ -619,19 +557,10 @@ impl<'db> HirDisplay<'db> for ExternTypeId<'db> { impl<'db> HirDisplay<'db> for ExternFunctionId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let extern_function_full_signature = Self::retrieve_signature_data(f.db, *self)?; - let signature = match f.db.extern_function_signature(*self) { - Ok(signature) => signature, - _ => { - return Err(SignatureError::FailedRetrievingSemanticData( - extern_function_full_signature.full_path, - )); - } - }; - write_function_signature(f, extern_function_full_signature, "extern ".to_string()) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + let signature = f.db.extern_function_signature(*self)?; + write_function_signature(f, extern_function_full_signature, "extern ".to_string())?; if !signature.implicits.is_empty() { - f.write_str(" implicits(") - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + f.write_str(" implicits(")?; let mut count = signature.implicits.len(); for type_id in &signature.implicits { write!( @@ -639,27 +568,22 @@ impl<'db> HirDisplay<'db> for ExternFunctionId<'db> { "{}{}", extract_and_format(&type_id.format(f.db)), if count == 1 { ")".to_string() } else { ", ".to_string() } - ) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + )?; count -= 1; } } if !signature.panicable { - f.write_str(" nopanic") - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + f.write_str(" nopanic")?; }; - f.write_str(";").map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db))) + f.hir_write(";") } } impl<'db> HirDisplay<'db> for MacroDeclarationId<'db> { fn hir_fmt(&self, f: &mut HirFormatter<'db>) -> Result<(), SignatureError> { let module_item_id = ModuleItemId::MacroDeclaration(*self); - f.write_str(&format!("macro {} {{", module_item_id.name(f.db).long(f.db))) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; - let macro_rules_data = - f.db.macro_declaration_rules(*self) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(self.full_path(f.db)))?; + f.write_str(&format!("macro {} {{", module_item_id.name(f.db).long(f.db)))?; + let macro_rules_data = f.db.macro_declaration_rules(*self)?; for rule_data in macro_rules_data { let (left_bracket, elements, right_bracket) = match rule_data.pattern { @@ -677,10 +601,9 @@ impl<'db> HirDisplay<'db> for MacroDeclarationId<'db> { f.write_str( format!("\n {}{}{} => {{ ... }};", left_bracket, macro_match, right_bracket) .as_str(), - ) - .map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db)))?; + )?; } - f.write_str("\n}").map_err(|_| SignatureError::FailedWritingSignature(self.full_path(f.db))) + f.hir_write("\n}") } } @@ -818,18 +741,11 @@ fn write_function_signature<'db>( syntactic_kind, documentable_signature.name.long(f.db), resolver_generic_params, - ) - .map_err(|_| { - SignatureError::FailedWritingSignature(documentable_signature.full_path.clone()) - })?; + )?; if let Some(generic_args) = documentable_signature.generic_args { - write_generic_args(generic_args, f).map_err(|_| { - SignatureError::FailedWritingSignature(documentable_signature.full_path.clone()) - })?; + write_generic_args(generic_args, f)?; } - f.write_str("(").map_err(|_| { - SignatureError::FailedWritingSignature(documentable_signature.full_path.clone()) - })?; + f.write_str("(")?; if let Some(params) = documentable_signature.params { let mut count = params.len(); let mut postfix = String::from(", "); @@ -1045,7 +961,7 @@ fn write_type_signature<'db>( )?; if let Some(generic_params) = documentable_signature.generic_params { let (stx, lls) = get_generic_params(generic_params, f.db)?; - f.write_chunk(&stx, lls).map_err(|_| fmt::Error)?; + f.write_chunk(&stx, lls)?; } if let Some(return_type) = documentable_signature.return_type { write!(f, " = ")?; diff --git a/crates/cairo-lang-doc/src/signature_data.rs b/crates/cairo-lang-doc/src/signature_data.rs index c4eff4befde..6f490592ce5 100644 --- a/crates/cairo-lang-doc/src/signature_data.rs +++ b/crates/cairo-lang-doc/src/signature_data.rs @@ -106,14 +106,8 @@ fn get_module_item_info<'db>( ) -> Result, SignatureError> { let parent_module = module_item_id.parent_module(db); let item_name = module_item_id.name(db); - if let Some(module_item_info) = db - .module_item_info_by_name(parent_module, item_name) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(module_item_id.full_path(db)))? - { - Ok(module_item_info) - } else { - Err(SignatureError::FailedRetrievingSemanticData(module_item_id.full_path(db))) - } + db.module_item_info_by_name(parent_module, item_name)? + .ok_or(SignatureError::FailedRetrievingSemanticData(module_item_id.full_path(db))) } /// Retrieves data for enum signature formatting. Returns [`SignatureError`] if any relevant data @@ -125,15 +119,11 @@ fn get_enum_signature_data<'db>( let module_item_id = ModuleItemId::Enum(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - let enum_variants = db - .enum_variants(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(module_item_id.full_path(db)))?; + let enum_variants = db.enum_variants(item_id)?; let mut variants = Vec::new(); for (name, variant_id) in enum_variants.iter() { - let variant_semantic = db.variant_semantic(item_id, *variant_id).map_err(|_| { - SignatureError::FailedRetrievingSemanticData(module_item_id.full_path(db)) - })?; + let variant_semantic = db.variant_semantic(item_id, *variant_id)?; variants.push((*name, variant_semantic.ty)); } Ok(DocumentableItemSignatureData { @@ -161,20 +151,15 @@ fn get_struct_signature_data<'db>( let module_item_id = ModuleItemId::Struct(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - let struct_attributes = db - .struct_attributes(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let struct_attributes = db.struct_attributes(item_id)?; let members = db - .struct_members(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))? + .struct_members(item_id)? .iter() .map(|(name, member)| (*name, member.ty, member.visibility)) .collect(); - let generic_params = db - .struct_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.struct_generic_params(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::Struct(item_id))), @@ -201,11 +186,7 @@ fn get_member_signature_data<'db>( let name = item_id.name(db); let struct_id = item_id.struct_id(db); - if let Some(member) = db - .struct_members(struct_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))? - .get(&name) - { + if let Some(member) = db.struct_members(struct_id)?.get(&name) { Ok(DocumentableItemSignatureData { item_id: Member(item_id), name, @@ -234,17 +215,9 @@ fn get_free_function_signature_data<'db>( let module_item_id = ModuleItemId::FreeFunction(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - let generic_params = db - .free_function_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let signature = db - .free_function_signature(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let resolver_data = db - .free_function_declaration_resolver_data(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.free_function_generic_params(item_id)?; + let signature = db.free_function_signature(item_id)?; + let resolver_data = db.free_function_declaration_resolver_data(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::FreeFunction( @@ -270,24 +243,14 @@ fn get_trait_function_signature_data<'db>( db: &'db dyn Database, item_id: TraitFunctionId<'db>, ) -> Result, SignatureError> { - let signature = db - .trait_function_signature(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let generic_params = db - .trait_function_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let resolver_data = db - .trait_function_resolver_data(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let signature = db.trait_function_signature(item_id)?; + let generic_params = db.trait_function_generic_params(item_id)?; + let resolver_data = db.trait_function_resolver_data(item_id)?; // trait function resolver data contains both: its own and the traits generic params, // to get a signature relevant subset, the trait ones need to be filtered out let trait_id = item_id.trait_id(db); - let trait_resolver_data = trait_id - .resolver_data(db) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let trait_resolver_data = trait_id.resolver_data(db)?; let trait_params_set: HashSet<_> = trait_resolver_data.generic_params.iter().collect(); let function_generic_params: Vec> = resolver_data @@ -319,13 +282,9 @@ fn get_impl_function_signature_data<'db>( db: &'db dyn Database, item_id: ImplFunctionId<'db>, ) -> Result, SignatureError> { - let signature = db - .impl_function_signature(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let signature = db.impl_function_signature(item_id)?; - let generic_params = db - .impl_function_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.impl_function_generic_params(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ImplItem(ImplItemId::Function(item_id))), @@ -352,9 +311,7 @@ fn get_constant_signature_data<'db>( let module_item_id = ModuleItemId::Constant(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - let constant = db - .constant_semantic_data(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let constant = db.constant_semantic_data(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::Constant( @@ -380,11 +337,7 @@ fn get_impl_constant_signature_data<'db>( db: &'db dyn Database, item_id: ImplConstantDefId<'db>, ) -> Result, SignatureError> { - let return_type = db - .impl_constant_def_value(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))? - .ty(db) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let return_type = db.impl_constant_def_value(item_id)?.ty(db)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ImplItem(ImplItemId::Constant(item_id))), @@ -411,9 +364,7 @@ fn get_trait_signature_data<'db>( let module_item_id = ModuleItemId::Trait(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - let generic_params = db - .trait_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.trait_generic_params(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::Trait(item_id))), @@ -437,13 +388,8 @@ fn get_trait_const_signature_data<'db>( db: &'db dyn Database, item_id: TraitConstantId<'db>, ) -> Result, SignatureError> { - let attributes = db - .trait_constant_attributes(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let return_type = db - .trait_constant_type(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let attributes = db.trait_constant_attributes(item_id)?; + let return_type = db.trait_constant_type(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::TraitItem(TraitItemId::Constant(item_id))), @@ -469,15 +415,8 @@ fn get_impl_def_signature_data<'db>( ) -> Result, SignatureError> { let module_item_id = ModuleItemId::Impl(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - - let resolver_data = db - .impl_def_resolver_data(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let intern = db - .impl_def_concrete_trait(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))? - .long(db); + let resolver_data = db.impl_def_resolver_data(item_id)?; + let intern = db.impl_def_concrete_trait(item_id)?.long(db); Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::Impl(item_id))), @@ -531,13 +470,8 @@ fn get_module_type_alias_full_signature<'db>( let module_item_id = ModuleItemId::TypeAlias(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - let generic_params = db - .module_type_alias_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let resolved_type = db - .module_type_alias_resolved_type(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.module_type_alias_generic_params(item_id)?; + let resolved_type = db.module_type_alias_resolved_type(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::TypeAlias( @@ -563,9 +497,7 @@ fn get_trait_type_full_signature<'db>( db: &'db dyn Database, item_id: TraitTypeId<'db>, ) -> Result, SignatureError> { - let generic_params = db - .trait_type_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.trait_type_generic_params(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::TraitItem(TraitItemId::Type(item_id))), @@ -589,13 +521,8 @@ fn get_impl_type_def_full_signature<'db>( db: &'db dyn Database, item_id: ImplTypeDefId<'db>, ) -> Result, SignatureError> { - let resolved_type = db - .impl_type_def_resolved_type(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let generic_params = db - .impl_type_def_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let resolved_type = db.impl_type_def_resolved_type(item_id)?; + let generic_params = db.impl_type_def_generic_params(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ImplItem(ImplItemId::Type(item_id))), @@ -621,10 +548,7 @@ fn get_extern_type_full_signature<'db>( ) -> Result, SignatureError> { let module_item_id = ModuleItemId::ExternType(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - - let generic_params = db - .extern_type_declaration_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.extern_type_declaration_generic_params(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::ExternType( @@ -652,14 +576,8 @@ fn get_extern_function_full_signature<'db>( ) -> Result, SignatureError> { let module_item_id = ModuleItemId::ExternFunction(item_id); let module_item_info = get_module_item_info(db, module_item_id)?; - - let generic_params = db - .extern_function_declaration_generic_params(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; - - let signature = db - .extern_function_signature(item_id) - .map_err(|_| SignatureError::FailedRetrievingSemanticData(item_id.full_path(db)))?; + let generic_params = db.extern_function_declaration_generic_params(item_id)?; + let signature = db.extern_function_signature(item_id)?; Ok(DocumentableItemSignatureData { item_id: DocumentableItemId::from(LookupItemId::ModuleItem(ModuleItemId::ExternFunction( diff --git a/crates/cairo-lang-doc/src/signature_errors.rs b/crates/cairo-lang-doc/src/signature_errors.rs index b871566e839..ba451c337c0 100644 --- a/crates/cairo-lang-doc/src/signature_errors.rs +++ b/crates/cairo-lang-doc/src/signature_errors.rs @@ -1,20 +1,26 @@ use std::fmt; +use cairo_lang_diagnostics::DiagnosticAdded; + #[derive(Debug)] pub enum SignatureError { FailedRetrievingSemanticData(String), FailedWritingSignature(String), - FailedWritingSignatureFormatter(String), + FailedWritingSignatureDiagnostic(DiagnosticAdded), + FailedWritingSignatureFormatter(fmt::Error), } impl fmt::Display for SignatureError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { SignatureError::FailedRetrievingSemanticData(full_path) => { - write!(f, "Failed retrieving semantic data for {full_path:?}.") + write!(f, "{full_path:?} Failed retrieving semantic data.") } SignatureError::FailedWritingSignature(full_path) => { - write!(f, "Failed writing signature for {full_path:?}.") + write!(f, "{full_path:?} Failed writing signature.") + } + SignatureError::FailedWritingSignatureDiagnostic(diagnostics) => { + write!(f, "Failed writing signature. {diagnostics:?}") } SignatureError::FailedWritingSignatureFormatter(e) => { write!(f, "Failed writing signature formatter. {e:?}") @@ -25,7 +31,7 @@ impl fmt::Display for SignatureError { impl From for SignatureError { fn from(e: fmt::Error) -> Self { - SignatureError::FailedWritingSignatureFormatter(e.to_string()) + SignatureError::FailedWritingSignatureFormatter(e) } } @@ -34,3 +40,9 @@ impl From for fmt::Error { fmt::Error } } + +impl From for SignatureError { + fn from(e: DiagnosticAdded) -> Self { + SignatureError::FailedWritingSignatureDiagnostic(e) + } +}