Simplify and re-export the IDL import macro; compat with latest rust nightly; restore the modules for generated clusters

Author: ivmarkov

examples/onoff_light/src/main.rs

@@ -26,11 +26,11 @@ use embassy_time::{Duration, Timer};
 use log::info;
 
 use rs_matter::core::{BasicCommData, Matter, MATTER_PORT};
-use rs_matter::data_model::cluster_basic_information::BasicInfoConfig;
-use rs_matter::data_model::cluster_on_off::{self, OnOffAdaptor};
+use rs_matter::data_model::basic_info::BasicInfoConfig;
 use rs_matter::data_model::core::IMBuffer;
 use rs_matter::data_model::device_types::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter::data_model::objects::*;
+use rs_matter::data_model::on_off;
 use rs_matter::data_model::root_endpoint;
 use rs_matter::data_model::subscriptions::Subscriptions;
 use rs_matter::data_model::system_model::descriptor;
@@ -136,7 +136,7 @@ fn run() -> Result<(), Error> {
 
     info!("IM buffers initialized");
 
-    let on_off = cluster_on_off::OnOffCluster::new(Dataver::new_rand(matter.rand()));
+    let on_off = on_off::OnOffHandler::new(Dataver::new_rand(matter.rand()));
 
     let subscriptions = SUBSCRIPTIONS.uninit().init_with(Subscriptions::init());
 
@@ -231,14 +231,14 @@ const NODE: Node<'static> = Node {
         Endpoint {
             id: 1,
             device_types: &[DEV_TYPE_ON_OFF_LIGHT],
-            clusters: &[descriptor::CLUSTER, cluster_on_off::CLUSTER],
+            clusters: &[descriptor::CLUSTER, on_off::CLUSTER],
         },
     ],
 };
 
 fn dm_handler<'a>(
     matter: &'a Matter<'a>,
-    on_off: &'a cluster_on_off::OnOffCluster,
+    on_off: &'a on_off::OnOffHandler,
 ) -> impl Metadata + NonBlockingHandler + 'a {
     (
         NODE,
@@ -250,7 +250,7 @@ fn dm_handler<'a>(
                     matter.rand(),
                 ))),
             )
-            .chain(1, cluster_on_off::ID, Async(OnOffAdaptor(on_off))),
+            .chain(1, on_off::ID, Async(on_off::HandlerAdaptor(on_off))),
     )
 }
 

examples/onoff_light_bt/src/main.rs

@@ -43,11 +43,11 @@ use embassy_time::{Duration, Timer};
 use log::{info, warn};
 
 use rs_matter::core::{BasicCommData, Matter};
-use rs_matter::data_model::cluster_basic_information::BasicInfoConfig;
-use rs_matter::data_model::cluster_on_off::{self, OnOffAdaptor};
+use rs_matter::data_model::basic_info::BasicInfoConfig;
 use rs_matter::data_model::core::IMBuffer;
 use rs_matter::data_model::device_types::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter::data_model::objects::*;
+use rs_matter::data_model::on_off;
 use rs_matter::data_model::root_endpoint;
 use rs_matter::data_model::sdm::wifi_nw_diagnostics::{
     self, WiFiSecurity, WiFiVersion, WifiNwDiagCluster, WifiNwDiagData,
@@ -144,7 +144,7 @@ fn run() -> Result<(), Error> {
 
     let mut mdns = pin!(run_mdns(&matter));
 
-    let on_off = cluster_on_off::OnOffCluster::new(Dataver::new_rand(matter.rand()));
+    let on_off = on_off::OnOffHandler::new(Dataver::new_rand(matter.rand()));
 
     let subscriptions = Subscriptions::<3>::new();
 
@@ -251,14 +251,14 @@ const NODE: Node<'static> = Node {
         Endpoint {
             id: 1,
             device_types: &[DEV_TYPE_ON_OFF_LIGHT],
-            clusters: &[descriptor::CLUSTER, cluster_on_off::CLUSTER],
+            clusters: &[descriptor::CLUSTER, on_off::CLUSTER],
         },
     ],
 };
 
 fn dm_handler<'a>(
     matter: &'a Matter<'a>,
-    on_off: &'a cluster_on_off::OnOffCluster,
+    on_off: &'a on_off::OnOffHandler,
     wifi_complete: &'a Notification<NoopRawMutex>,
 ) -> impl Metadata + NonBlockingHandler + 'a {
     (
@@ -290,7 +290,7 @@ fn dm_handler<'a>(
                 matter.rand(),
             ))),
         )
-        .chain(1, cluster_on_off::ID, Async(OnOffAdaptor(on_off))),
+        .chain(1, on_off::ID, Async(on_off::HandlerAdaptor(on_off))),
     )
 }
 

rs-matter-macros-impl/src/idl.rs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-use proc_macro2::{Ident, Literal, Span, TokenStream};
+use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 
 use rs_matter_data_model::Cluster;
@@ -57,7 +57,10 @@ fn cluster_internal(
     with_async: bool,
     context: &IdlGenerateContext,
 ) -> TokenStream {
-    //let cluster_module_name = Ident::new(&cluster.id.to_case(Case::Snake), Span::call_site());
+    let cluster_module_name = Ident::new(
+        &id::idl_field_name_to_rs_name(&cluster.id),
+        Span::call_site(),
+    );
 
     let bitmaps = bitmap::bitmaps(cluster, context);
     let enums = enumeration::enums(cluster, context);
@@ -74,11 +77,7 @@ fn cluster_internal(
     let handler_inherent_impl = handler::handler(false, true, cluster, context);
     let handler_adaptor = handler::handler_adaptor(false, cluster, context);
 
-    let cluster_code = Literal::u32_unsuffixed(cluster.code as u32);
-
     let quote = quote!(
-        pub const ID: u32 = #cluster_code;
-
         #bitmaps
 
         #enums
@@ -104,7 +103,7 @@ fn cluster_internal(
         #handler_adaptor
     );
 
-    if with_async {
+    let quote = if with_async {
         let async_handler = handler::handler(true, false, cluster, context);
         let async_handler_inherent_impl = handler::handler(true, true, cluster, context);
         let async_handler_adaptor = handler::handler_adaptor(true, cluster, context);
@@ -120,7 +119,16 @@ fn cluster_internal(
         )
     } else {
         quote
-    }
+    };
+
+    quote!(
+        #[allow(async_fn_in_trait)]
+        #[allow(unknown_lints)]
+        #[allow(clippy::uninlined_format_args)]
+        pub mod #cluster_module_name {
+            #quote
+        }
+    )
 }
 
 #[cfg(test)]

rs-matter-macros-impl/src/idl/bitmap.rs

@@ -41,7 +41,7 @@ fn bitmap(b: &Bitmap, context: &IdlGenerateContext) -> TokenStream {
         "bitmap16" => quote!(u16),
         "bitmap32" => quote!(u32),
         "bitmap64" => quote!(u64),
-        other => panic!("Unknown bitmap base type {}", other),
+        other => panic!("Unknown bitmap base type {other}"),
     };
     let name = Ident::new(&b.id, Span::call_site());
 

rs-matter-macros-impl/src/idl/cluster.rs

@@ -495,10 +495,12 @@ pub fn cluster(cluster: &Cluster, context: &IdlGenerateContext) -> TokenStream {
         )
     });
 
+    let cluster_id = Literal::u32_unsuffixed(cluster.code as u32);
     let cluster_revision = Literal::u16_unsuffixed(cluster.revision as u16);
 
     quote!(
-        const CLUSTER_REVISION: u16 = #cluster_revision;
+        pub const ID: u32 = #cluster_id;
+        pub const REVISION: u16 = #cluster_revision;
 
         // TODO: Think if to continue supporting this
         pub const CLUSTER: #krate::data_model::objects::Cluster<'static> = ClusterConf::Default.cluster();
@@ -532,7 +534,7 @@ pub fn cluster(cluster: &Cluster, context: &IdlGenerateContext) -> TokenStream {
                     id: ID as _,
                     attributes_access: ATTRIBUTES_ACCESS,
                     revision: match self {
-                        ClusterConf::Default => CLUSTER_REVISION,
+                        ClusterConf::Default => REVISION,
                         ClusterConf::Mandatory { revision, .. } => *revision,
                         ClusterConf::All { revision, .. } => *revision,
                         ClusterConf::Custom { revision, .. } => *revision,

rs-matter-macros-impl/src/idl/enumeration.rs

@@ -40,7 +40,7 @@ fn enumeration(e: &Enum, context: &IdlGenerateContext) -> TokenStream {
     let base_type = match e.base_type.as_ref() {
         "enum8" => quote!(u8),
         "enum16" => quote!(u16),
-        other => panic!("Unknown enumeration base type {}", other),
+        other => panic!("Unknown enumeration base type {other}"),
     };
     let name = Ident::new(&e.id, Span::call_site());
 

rs-matter-macros-impl/src/idl/handler.rs

@@ -53,7 +53,7 @@ pub fn handler(
     let krate = context.rs_matter_crate.clone();
 
     let handler_name = Ident::new(
-        &format!("{}{}Handler", if asynch { "Async" } else { "" }, cluster.id),
+        &format!("Cluster{}Handler", if asynch { "Async" } else { "" }),
         Span::call_site(),
     );
 
@@ -126,6 +126,21 @@ pub fn handler_adaptor(
 ) -> TokenStream {
     let krate = context.rs_matter_crate.clone();
 
+    let handler_name = Ident::new(
+        &format!("Cluster{}Handler", if asynch { "Async" } else { "" }),
+        Span::call_site(),
+    );
+
+    let handler_adaptor_name = Ident::new(
+        &format!("Handler{}Adaptor", if asynch { "Async" } else { "" }),
+        Span::call_site(),
+    );
+
+    let generic_handler_name = Ident::new(
+        &format!("{}Handler", if asynch { "Async" } else { "" }),
+        Span::call_site(),
+    );
+
     let handler_adaptor_attribute_match = cluster
         .attributes
         .iter()
@@ -186,21 +201,6 @@ pub fn handler_adaptor(
         )
     };
 
-    let handler_name = Ident::new(
-        &format!("{}{}Handler", if asynch { "Async" } else { "" }, cluster.id),
-        Span::call_site(),
-    );
-
-    let handler_adaptor_name = Ident::new(
-        &format!("{}{}Adaptor", if asynch { "Async" } else { "" }, cluster.id),
-        Span::call_site(),
-    );
-
-    let generic_handler_name = Ident::new(
-        &format!("{}Handler", if asynch { "Async" } else { "" }),
-        Span::call_site(),
-    );
-
     let pasync = if asynch { quote!(async) } else { quote!() };
 
     let stream = quote!(

rs-matter-macros-impl/src/idl/id.rs

@@ -35,7 +35,7 @@ pub fn idl_id_to_constant_name(s: &str) -> String {
     let str = s.strip_prefix('k').unwrap_or(s).to_case(Case::UpperSnake);
     let char = str.chars().next().unwrap();
     if !char.is_alphabetic() {
-        format!("C{}", str)
+        format!("C{str}")
     } else {
         str
     }
@@ -57,7 +57,7 @@ pub fn idl_id_to_enum_variant_name(s: &str) -> String {
     let str = s.strip_prefix('k').unwrap_or(s).to_string();
     let char = str.chars().next().unwrap();
     if !char.is_alphabetic() {
-        format!("V{}", str)
+        format!("V{str}")
     } else {
         str
     }

rs-matter-macros-impl/src/tlv.rs

@@ -124,10 +124,7 @@ fn get_unit_enum_func_and_tags(
         // "struct" is the default, so we make it equivalent to u8 for convenience
         "struct" | "u8" => {
             if tags.iter().any(|v| *v > 0xFF) {
-                panic!(
-                    "Enum discriminator value larger that 0xFF for {:?}",
-                    enum_name
-                )
+                panic!("Enum discriminator value larger that 0xFF for {enum_name:?}")
             }
             (
                 Ident::new("u8", Span::call_site()),
@@ -140,7 +137,7 @@ fn get_unit_enum_func_and_tags(
             Ident::new("u16", Span::call_site()),
             tags.into_iter().map(Literal::u16_suffixed).collect(),
         ),
-        _ => panic!("Invalid data type {:?} for enum {:?}", data_type, enum_name),
+        _ => panic!("Invalid data type {data_type:?} for enum {enum_name:?}"),
     }
 }
 
@@ -328,14 +325,11 @@ fn gen_totlv_for_enum(
     } else {
         // tags MUST be context-tags (up to u8 range)
         if tags.iter().any(|v| *v > u8::MAX as _) {
-            panic!(
-                "Enum discriminator value larger that 0xFF for {:?}",
-                enum_name
-            )
+            panic!("Enum discriminator value larger that 0xFF for {enum_name:?}")
         }
 
         if tags.len() > 6 {
-            panic!("More than 6 enum variants for {:?}", enum_name)
+            panic!("More than 6 enum variants for {enum_name:?}")
         }
 
         let either_ident = if tags.len() != 2 {
@@ -702,10 +696,7 @@ fn gen_fromtlv_for_enum(
     } else {
         // tags MUST be context-tags (up to u8 range)
         if tags.iter().any(|v| *v > 0xFF) {
-            panic!(
-                "Enum discriminator value larger that 0xFF for {:?}",
-                enum_name
-            )
+            panic!("Enum discriminator value larger that 0xFF for {enum_name:?}")
         }
         let tags = tags
             .into_iter()
@@ -770,7 +761,7 @@ fn gen_fromtlv_for_enum(
 
 fn normalize_fromtlv_type(ty: &syn::Type) -> TokenStream {
     let Type::Path(type_path) = ty else {
-        panic!("Don't know what to do {:?}", ty);
+        panic!("Don't know what to do {ty:?}");
     };
 
     // When paths are like `matter_rs::tlv::Nullable<u32>`