docs(sylvia-derive): Document inner types

sylvia-derive/src/contract.rs

@@ -21,11 +21,26 @@ use crate::types::msg_variant::MsgVariants;
 mod communication;
 mod mt;
 
-/// Preprocessed `contract` macro input for non-trait impl block
+/// Preprocessed `contract` macro input for struct impl block.
+///
+/// Generates:
+///     - [Messages](https://cosmwasm-docs.vercel.app/sylvia/macros/generated-types/message-types#contract-messages)
+///         - InstantiateMsg
+///         - ExecMsg
+///         - QueryMsg
+///         - SudoMsg
+///         - MigrateMsg
+///         - ContractExecMsg
+///         - ContractQueryMsg
+///         - ContractSudoMsg
+///     - [MultiTest](https://cosmwasm-docs.vercel.app/sylvia/macros/generated-types/multitest) helpers
+///     - [Querier](https://cosmwasm-docs.vercel.app/cw-multi-test) trait implementation
+///     - [Executor](https://cosmwasm-docs.vercel.app/cw-multi-test) trait implementation
+///     - Api trait implementation
 pub struct ContractInput<'a> {
-    error: ContractErrorAttr,
     item: &'a ItemImpl,
     generics: Vec<&'a GenericParam>,
+    error: ContractErrorAttr,
     custom: Custom,
     override_entry_points: Vec<OverrideEntryPoint>,
     interfaces: Interfaces,
@@ -52,6 +67,7 @@ impl<'a> ContractInput<'a> {
         }
     }
 
+    /// Process the input and generate the contract code.
     pub fn process(&self) -> TokenStream {
         let Self {
             item,

sylvia-derive/src/contract/communication/executor.rs

@@ -10,6 +10,7 @@ use crate::types::msg_field::MsgField;
 use crate::types::msg_variant::{MsgVariant, MsgVariants};
 use crate::utils::SvCasing;
 
+/// Emits execute helper
 pub struct Executor<'a> {
     generics: Generics,
     self_ty: Type,

sylvia-derive/src/contract/communication/querier.rs

@@ -10,6 +10,7 @@ use crate::types::msg_field::MsgField;
 use crate::types::msg_variant::{MsgVariant, MsgVariants};
 use crate::utils::SvCasing;
 
+/// Emits query helper
 pub struct Querier<'a> {
     generics: Generics,
     self_ty: Type,

sylvia-derive/src/contract/communication/struct_msg.rs

@@ -23,7 +23,6 @@ pub struct StructMessage<'a> {
 }
 
 impl<'a> StructMessage<'a> {
-    /// Creates new struct message of given type from impl block
     pub fn new(
         source: &'a ItemImpl,
         msg_ty: MsgType,

sylvia-derive/src/contract/communication/wrapper_msg.rs

@@ -9,7 +9,8 @@ use syn::fold::Fold;
 use syn::spanned::Spanned;
 use syn::{Ident, ItemImpl, Type};
 
-/// Glue message is the message composing Exec/Query messages from several traits
+/// Glue message is the message composing Exec/Query/Sudo messages from several traits and a
+/// contract
 #[derive(Debug)]
 pub struct GlueMessage<'a> {
     source: &'a ItemImpl,

sylvia-derive/src/contract/mt.rs

@@ -22,6 +22,7 @@ fn get_ident_from_type(contract_name: &Type) -> &Ident {
     &segment.ident
 }
 
+/// Emits helpers for testing contract messages using MultiTest.
 pub struct MtHelpers<'a> {
     error_type: Type,
     contract_name: &'a Type,

sylvia-derive/src/entry_points.rs

@@ -13,6 +13,11 @@ use crate::parser::{
 };
 use crate::types::msg_variant::MsgVariants;
 
+/// Preprocessed [`entry_points`](crate::entry_points) macro input.
+///
+/// Generates `entry_points` module containing:
+///     - instantiate, execute, query and sudo entry points by default
+///     - migrate and reply entry points if respective messages are defined
 pub struct EntryPointInput<'a> {
     item: &'a ItemImpl,
     args: EntryPointArgs,
@@ -42,13 +47,15 @@ impl<'a> EntryPointInput<'a> {
         Self { item, args }
     }
 
+    /// Process the input and generate the interface code.
     pub fn process(&self) -> TokenStream {
         let Self { item, args } = self;
 
         EntryPoints::new(item, args).emit()
     }
 }
 
+/// Defines logic for generating entry points.
 pub struct EntryPoints<'a> {
     source: &'a ItemImpl,
     name: Type,
@@ -156,7 +163,7 @@ impl<'a> EntryPoints<'a> {
         }
     }
 
-    pub fn emit_default_entry_point(&self, msg_ty: MsgType) -> TokenStream {
+    fn emit_default_entry_point(&self, msg_ty: MsgType) -> TokenStream {
         let Self {
             name,
             error,

sylvia-derive/src/interface.rs

@@ -17,7 +17,17 @@ use crate::types::msg_variant::MsgVariants;
 mod communication;
 mod mt;
 
-/// Preprocessed `interface` macro input
+/// Preprocessed [`interface`](crate::interface) macro input.
+///
+/// Generates `sv` module containing:
+///     - [Messages](https://cosmwasm-docs.vercel.app/sylvia/macros/generated-types/message-types#interface-messages)
+///         - ExecMsg
+///         - QueryMsg
+///         - SudoMsg
+///     - [MultiTest](https://cosmwasm-docs.vercel.app/sylvia/macros/generated-types/multitest#proxy-trait) helpers
+///     - [Querier](https://cosmwasm-docs.vercel.app/cw-multi-test) trait implementation
+///     - [Executor](https://cosmwasm-docs.vercel.app/cw-multi-test) trait implementation
+///     - Api trait implementation
 pub struct InterfaceInput<'a> {
     item: &'a ItemTrait,
     custom: Custom,
@@ -52,7 +62,7 @@ impl<'a> InterfaceInput<'a> {
 
         if custom.msg.is_none()
             && !associated_types
-                .all_names()
+                .as_names()
                 .any(|assoc_type| assoc_type == EXEC_TYPE)
         {
             emit_warning!(
@@ -64,7 +74,7 @@ impl<'a> InterfaceInput<'a> {
 
         if custom.query.is_none()
             && !associated_types
-                .all_names()
+                .as_names()
                 .any(|assoc_type| assoc_type == QUERY_TYPE)
         {
             emit_warning!(
@@ -81,6 +91,7 @@ impl<'a> InterfaceInput<'a> {
         }
     }
 
+    /// Process the input and generate the interface code.
     pub fn process(&self) -> TokenStream {
         let Self {
             associated_types,

sylvia-derive/src/interface/communication/api.rs

@@ -6,6 +6,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::ItemTrait;
 
+/// Emits `InterfaceMessagesApi` trait.
 pub struct Api<'a> {
     source: &'a ItemTrait,
     associated_types: &'a AssociatedTypes<'a>,

sylvia-derive/src/interface/communication/enum_msg.rs

@@ -1,5 +1,5 @@
 use crate::parser::attributes::MsgAttrForwarding;
-use crate::parser::{parse_associated_custom_type, Custom, MsgType, ParsedSylviaAttributes};
+use crate::parser::{Custom, MsgType, ParsedSylviaAttributes};
 use crate::types::associated_types::{AssociatedTypes, ItemType, EXEC_TYPE, QUERY_TYPE};
 use crate::types::msg_variant::MsgVariants;
 use crate::utils::emit_bracketed_generics;
@@ -26,8 +26,11 @@ impl<'a> EnumMessage<'a> {
         variants: MsgVariants<'a, Ident>,
         associated_types: &'a AssociatedTypes<'a>,
     ) -> Self {
-        let associated_exec = parse_associated_custom_type(source, EXEC_TYPE);
-        let associated_query = parse_associated_custom_type(source, QUERY_TYPE);
+        let trait_name = &source.ident;
+        let associated_exec =
+            associated_types.emit_contract_custom_type_accessor(trait_name, EXEC_TYPE);
+        let associated_query =
+            associated_types.emit_contract_custom_type_accessor(trait_name, QUERY_TYPE);
 
         let resp_type = custom
             .msg

sylvia-derive/src/interface/communication/executor.rs

@@ -45,7 +45,7 @@ where
             .without_error()
             .map(ItemType::as_name)
             .collect();
-        let all_generics: Vec<_> = associated_types.all_names().collect();
+        let all_generics: Vec<_> = associated_types.as_names().collect();
 
         let accessor = MsgType::Exec.as_accessor_name();
         let executor_api_path = quote! {

sylvia-derive/src/interface/communication/querier.rs

@@ -11,6 +11,7 @@ use crate::types::msg_field::MsgField;
 use crate::types::msg_variant::{MsgVariant, MsgVariants};
 use crate::utils::SvCasing;
 
+/// Emits query helper
 pub struct Querier<'a, Generic> {
     variants: &'a MsgVariants<'a, Generic>,
     associated_types: &'a AssociatedTypes<'a>,
@@ -45,7 +46,7 @@ where
             .without_error()
             .map(ItemType::as_name)
             .collect();
-        let all_generics: Vec<_> = associated_types.all_names().collect();
+        let all_generics: Vec<_> = associated_types.as_names().collect();
         let accessor = MsgType::Query.as_accessor_name();
         let api_path = quote! {
             < dyn #interface_name < Error = (), #(#generics = Self:: #generics,)* > as InterfaceMessagesApi > :: #accessor

sylvia-derive/src/interface/mt.rs

@@ -10,6 +10,7 @@ use crate::types::associated_types::AssociatedTypes;
 use crate::types::msg_variant::{MsgVariant, MsgVariants};
 use crate::utils::SvCasing;
 
+/// Emits helpers for testing interface messages using MultiTest.
 pub struct MtHelpers<'a> {
     source: &'a ItemTrait,
     error_type: Type,

sylvia-derive/src/parser/attributes/attr.rs

@@ -6,6 +6,7 @@ use syn::{Ident, MetaList, Result, Token};
 
 use super::MsgType;
 
+/// Type wrapping data parsed from `sv::msg_attr` attribute.
 #[derive(Clone, Debug)]
 pub struct VariantAttrForwarding {
     pub attrs: TokenStream,
@@ -21,6 +22,7 @@ impl VariantAttrForwarding {
     }
 }
 
+/// Type wrapping data parsed from `sv::attr` attribute.
 #[derive(Clone, Debug)]
 pub struct MsgAttrForwarding {
     pub msg_type: MsgType,

sylvia-derive/src/parser/attributes/custom.rs

@@ -4,6 +4,7 @@ use syn::{parse_quote, Error, Ident, MetaList, Result, Token, Type};
 
 use crate::crate_module;
 
+/// Type wrapping data parsed from `sv::custom` attribute.
 #[derive(Debug, Default)]
 pub struct Custom {
     pub msg: Option<Type>,

sylvia-derive/src/parser/attributes/error.rs

@@ -4,6 +4,7 @@ use syn::{parse_quote, MetaList, Result, Type};
 
 use crate::crate_module;
 
+/// Type wrapping data parsed from `sv::error` attribute.
 #[derive(Debug)]
 pub struct ContractErrorAttr {
     pub error: Type,

sylvia-derive/src/parser/attributes/messages.rs

@@ -9,6 +9,7 @@ use proc_macro_error::emit_error;
 
 use crate::fold::StripGenerics;
 
+/// Type wrapping data parsed from `sv::message` attribute.
 #[derive(Debug)]
 pub struct ContractMessageAttr {
     pub module: Path,
@@ -27,6 +28,11 @@ impl ContractMessageAttr {
     }
 }
 
+/// The `Customs` struct is used to represent the presence of `: custom(msg, query)` parameter
+/// within a `sv::message` attribute.
+///
+/// It is used to determine if an interface implemented on the contract uses `Empty` in place
+/// of custom types.
 #[derive(Debug)]
 pub struct Customs {
     pub has_msg: bool,

sylvia-derive/src/parser/attributes/mod.rs

@@ -1,3 +1,6 @@
+//! Module defining parsing of Sylvia attributes.
+//! Every Sylvia attribute should be prefixed with `sv::`
+
 use proc_macro_error::emit_error;
 use syn::spanned::Spanned;
 use syn::{Attribute, MetaList, PathSegment};
@@ -18,7 +21,6 @@ pub use override_entry_point::{FilteredOverrideEntryPoints, OverrideEntryPoint};
 
 /// This struct represents all possible attributes that
 /// are parsed and utilized by sylvia.
-///
 pub enum SylviaAttribute {
     Custom,
     Error,
@@ -55,7 +57,6 @@ impl SylviaAttribute {
 
 /// The structure parses all attributes provided in `new` method
 /// and stores the one relevant for sylvia.
-///
 #[derive(Default)]
 pub struct ParsedSylviaAttributes {
     pub custom_attr: Option<Custom>,

sylvia-derive/src/parser/attributes/msg.rs

@@ -13,6 +13,7 @@ pub enum MsgType {
     Sudo,
 }
 
+/// ArgumentParser holds `resp` parameter parsed from `sv::msg` attribute.
 #[derive(Default)]
 struct ArgumentParser {
     pub resp_type: Option<Ident>,

sylvia-derive/src/parser/attributes/override_entry_point.rs

@@ -7,6 +7,7 @@ use syn::{parenthesized, Ident, MetaList, Path, Result, Token, Type};
 use crate::crate_module;
 use crate::parser::MsgType;
 
+/// Type wrapping data parsed from `sv::override_entry_points` attribute.
 #[derive(Debug, Clone)]
 pub struct OverrideEntryPoint {
     entry_point: Path,

sylvia-derive/src/parser/mod.rs

@@ -1,3 +1,6 @@
+//! Module defining parsing utilities for Sylvia attributes.
+//! All parsing done for the [crate::types] should be done here.
+
 pub mod attributes;
 pub mod check_generics;
 pub mod entry_point;
@@ -13,10 +16,7 @@ pub use entry_point::EntryPointArgs;
 use proc_macro_error::emit_error;
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{
-    parse_quote, FnArg, GenericArgument, Ident, ImplItem, ItemImpl, ItemTrait, Path, PathArguments,
-    Signature, Token, TraitItem, Type,
-};
+use syn::{FnArg, GenericArgument, ImplItem, ItemImpl, Path, PathArguments, Signature, Token};
 
 use crate::types::msg_field::MsgField;
 
@@ -34,17 +34,8 @@ fn extract_generics_from_path(module: &Path) -> Punctuated<GenericArgument, Toke
     generics
 }
 
-pub fn parse_associated_custom_type(source: &ItemTrait, type_name: &str) -> Option<Type> {
-    let trait_name = &source.ident;
-    source.items.iter().find_map(|item| match item {
-        TraitItem::Type(ty) if ty.ident == type_name => {
-            let type_name = Ident::new(type_name, ty.span());
-            Some(parse_quote! { <ContractT as #trait_name>:: #type_name})
-        }
-        _ => None,
-    })
-}
-
+/// Use to make sure that [contract](crate::contract) is used over implementation containing
+/// mandatory `new` method.
 pub fn assert_new_method_defined(item: &ItemImpl) {
     const ERROR_NOTE: &str = "`sylvia::contract` requires parameterless `new` method to be defined for dispatch to work correctly.";
 
@@ -68,6 +59,7 @@ pub fn assert_new_method_defined(item: &ItemImpl) {
     }
 }
 
+/// Parses method signature and returns a vector of [`MsgField`].
 pub fn process_fields<'s, Generic>(
     sig: &'s Signature,
     generics_checker: &mut CheckGenerics<Generic>,

sylvia-derive/src/parser/variant_descs.rs

@@ -2,6 +2,7 @@ use crate::parser::attributes::VariantAttrForwarding;
 use crate::parser::{MsgAttr, ParsedSylviaAttributes};
 use syn::{Attribute, ImplItem, ItemImpl, ItemTrait, Signature, TraitItem};
 
+/// Type wrapping common data between [ItemImpl] and [ItemTrait].
 pub struct VariantDesc<'a> {
     msg_attr: Option<MsgAttr>,
     attrs_to_forward: Vec<VariantAttrForwarding>,