feat(mling): add linter framework with async support and registry

generation

1 files changed, 1121 insertions, 0 deletions

diff --git a/mingling_cli/expand.rs b/mingling_cli/expand.rs
new file mode 100644
index 0000000..2e8bc4f
--- /dev/null
+++ b/mingling_cli/expand.rs
@@ -0,0 +1,1121 @@
+#![feature(prelude_import)]
+extern crate std;
+#[prelude_import]
+use std::prelude::rust_2024::*;
+use crate::{linter::MinglingLinterSetup, metadata::MinglingMetadataSetup};
+use mingling::{
+    macros::gen_program,
+    setup::{ExitCodeSetup, picker::{HelpFlagSetup, StructuralRendererSetup}},
+};
+pub mod errors {
+    pub mod serde_json {
+        use mingling::macros::{buffer, group, r_println, renderer};
+        pub type ErrorSerdeJson = serde_json::Error;
+        #[allow(non_camel_case_types)]
+        mod internal_group_serde_json_error {
+            use crate::ThisProgram as __MinglingProgram;
+            #[allow(unused_imports)]
+            use serde_json::Error;
+            use super::ErrorSerdeJson;
+            impl ::mingling::Grouped<__MinglingProgram> for ErrorSerdeJson {
+                fn member_id() -> __MinglingProgram {
+                    __MinglingProgram::ErrorSerdeJson
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[allow(non_camel_case_types)]
+        pub struct __internal_renderer_render_error_serde_json;
+        impl ::mingling::Renderer for __internal_renderer_render_error_serde_json {
+            type Previous = ErrorSerdeJson;
+            fn render(prev: Self::Previous) -> ::mingling::RenderResult {
+                let __renderer_result = { render_error_serde_json(prev) };
+                ::std::convert::Into::into(__renderer_result)
+            }
+        }
+        pub fn render_error_serde_json(
+            _err: ErrorSerdeJson,
+        ) -> ::mingling::RenderResult {
+            let mut __render_result_buffer = ::mingling::RenderResult::new();
+            {
+                __render_result_buffer
+                    .println(
+                        ::alloc::__export::must_use({
+                            ::alloc::fmt::format(format_args!("serde"))
+                        }),
+                    );
+            }
+            __render_result_buffer
+        }
+    }
+}
+pub mod linter {
+    use mingling::{Program, macros::program_setup};
+    use crate::linter::cmd_mlint::CMDMinglingLinter;
+    pub mod cmd_mlint {
+        use mingling::macros::{chain, dispatcher};
+        pub struct CMDMinglingLinter;
+        #[automatically_derived]
+        impl ::core::fmt::Debug for CMDMinglingLinter {
+            #[inline]
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                ::core::fmt::Formatter::write_str(f, "CMDMinglingLinter")
+            }
+        }
+        #[automatically_derived]
+        impl ::core::default::Default for CMDMinglingLinter {
+            #[inline]
+            fn default() -> CMDMinglingLinter {
+                CMDMinglingLinter {}
+            }
+        }
+        pub struct EntryMinglingLinter {
+            pub(crate) inner: Vec<String>,
+        }
+        impl EntryMinglingLinter {
+            /// Creates a new instance of the wrapper type
+            pub fn new(inner: Vec<String>) -> Self {
+                Self { inner }
+            }
+        }
+        impl From<Vec<String>> for EntryMinglingLinter {
+            fn from(inner: Vec<String>) -> Self {
+                Self::new(inner)
+            }
+        }
+        impl From<EntryMinglingLinter> for Vec<String> {
+            fn from(wrapper: EntryMinglingLinter) -> Vec<String> {
+                wrapper.inner
+            }
+        }
+        impl ::std::convert::AsRef<Vec<String>> for EntryMinglingLinter {
+            fn as_ref(&self) -> &Vec<String> {
+                &self.inner
+            }
+        }
+        impl ::std::convert::AsMut<Vec<String>> for EntryMinglingLinter {
+            fn as_mut(&mut self) -> &mut Vec<String> {
+                &mut self.inner
+            }
+        }
+        impl ::std::ops::Deref for EntryMinglingLinter {
+            type Target = Vec<String>;
+            fn deref(&self) -> &Self::Target {
+                &self.inner
+            }
+        }
+        impl ::std::ops::DerefMut for EntryMinglingLinter {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.inner
+            }
+        }
+        impl ::std::default::Default for EntryMinglingLinter
+        where
+            Vec<String>: ::std::default::Default,
+        {
+            fn default() -> Self {
+                Self::new(::std::default::Default::default())
+            }
+        }
+        impl Into<mingling::AnyOutput<crate::ThisProgram>> for EntryMinglingLinter {
+            fn into(self) -> mingling::AnyOutput<crate::ThisProgram> {
+                mingling::AnyOutput::new(self)
+            }
+        }
+        impl Into<mingling::ChainProcess<crate::ThisProgram>> for EntryMinglingLinter {
+            fn into(self) -> mingling::ChainProcess<crate::ThisProgram> {
+                mingling::AnyOutput::new(self).route_chain()
+            }
+        }
+        impl ::mingling::Grouped<crate::ThisProgram> for EntryMinglingLinter {
+            fn member_id() -> crate::ThisProgram {
+                crate::ThisProgram::EntryMinglingLinter
+            }
+        }
+        impl ::mingling::Dispatcher<crate::ThisProgram> for CMDMinglingLinter {
+            fn node(&self) -> ::mingling::Node {
+                mingling::Node::default().join("mlint")
+            }
+            fn begin(
+                &self,
+                args: Vec<String>,
+            ) -> ::mingling::ChainProcess<crate::ThisProgram> {
+                use ::mingling::Grouped;
+                ::mingling::Routable::to_chain(EntryMinglingLinter::new(args))
+            }
+            fn clone_dispatcher(
+                &self,
+            ) -> Box<dyn ::mingling::Dispatcher<crate::ThisProgram>> {
+                Box::new(CMDMinglingLinter)
+            }
+        }
+        #[doc(hidden)]
+        #[allow(non_camel_case_types)]
+        pub struct __internal_chain_handle_mlint;
+        impl ::mingling::Chain<crate::ThisProgram> for __internal_chain_handle_mlint {
+            type Previous = EntryMinglingLinter;
+            fn proc(
+                prev: EntryMinglingLinter,
+            ) -> ::mingling::ChainProcess<crate::ThisProgram> {
+                handle_mlint(prev);
+                <crate::ResultEmpty as ::mingling::Routable<
+                    crate::ThisProgram,
+                >>::to_chain(crate::ResultEmpty)
+            }
+        }
+        pub fn handle_mlint(_args: EntryMinglingLinter) {}
+    }
+    #[doc(hidden)]
+    pub struct MinglingLinterSetup;
+    impl ::mingling::setup::ProgramSetup<crate::ThisProgram> for MinglingLinterSetup {
+        fn setup(self, program: &mut ::mingling::Program<crate::ThisProgram>) {
+            mingling_linter_setup(program);
+        }
+    }
+    pub fn mingling_linter_setup(program: &mut Program<crate::ThisProgram>) {
+        {
+            program.with_setup(MinglingLinterCommandSetup);
+        }
+    }
+    #[doc(hidden)]
+    pub struct MinglingLinterCommandSetup;
+    impl ::mingling::setup::ProgramSetup<crate::ThisProgram>
+    for MinglingLinterCommandSetup {
+        fn setup(self, program: &mut ::mingling::Program<crate::ThisProgram>) {
+            mingling_linter_command_setup(program);
+        }
+    }
+    pub fn mingling_linter_command_setup(program: &mut Program<crate::ThisProgram>) {
+        {
+            program.with_dispatcher(CMDMinglingLinter);
+        }
+    }
+}
+pub mod metadata {
+    use cargo_metadata::Metadata;
+    use mingling::{
+        AnyOutput, Program, ProgramCollect, RenderResult,
+        macros::{buffer, group_structural, program_setup, r_println, renderer, routeify},
+    };
+    use crate::metadata::{cmd_metadata::CMDMetadata, setup::CargoMetadataSetup};
+    pub mod cmd_metadata {
+        use cargo_metadata::Metadata;
+        use mingling::{LazyRes, macros::{chain, dispatcher, pack_structural}};
+        use crate::metadata::setup::ResMetadata;
+        pub struct CMDMetadata;
+        #[automatically_derived]
+        impl ::core::fmt::Debug for CMDMetadata {
+            #[inline]
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                ::core::fmt::Formatter::write_str(f, "CMDMetadata")
+            }
+        }
+        #[automatically_derived]
+        impl ::core::default::Default for CMDMetadata {
+            #[inline]
+            fn default() -> CMDMetadata {
+                CMDMetadata {}
+            }
+        }
+        pub struct EntryMetadata {
+            pub(crate) inner: Vec<String>,
+        }
+        impl EntryMetadata {
+            /// Creates a new instance of the wrapper type
+            pub fn new(inner: Vec<String>) -> Self {
+                Self { inner }
+            }
+        }
+        impl From<Vec<String>> for EntryMetadata {
+            fn from(inner: Vec<String>) -> Self {
+                Self::new(inner)
+            }
+        }
+        impl From<EntryMetadata> for Vec<String> {
+            fn from(wrapper: EntryMetadata) -> Vec<String> {
+                wrapper.inner
+            }
+        }
+        impl ::std::convert::AsRef<Vec<String>> for EntryMetadata {
+            fn as_ref(&self) -> &Vec<String> {
+                &self.inner
+            }
+        }
+        impl ::std::convert::AsMut<Vec<String>> for EntryMetadata {
+            fn as_mut(&mut self) -> &mut Vec<String> {
+                &mut self.inner
+            }
+        }
+        impl ::std::ops::Deref for EntryMetadata {
+            type Target = Vec<String>;
+            fn deref(&self) -> &Self::Target {
+                &self.inner
+            }
+        }
+        impl ::std::ops::DerefMut for EntryMetadata {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.inner
+            }
+        }
+        impl ::std::default::Default for EntryMetadata
+        where
+            Vec<String>: ::std::default::Default,
+        {
+            fn default() -> Self {
+                Self::new(::std::default::Default::default())
+            }
+        }
+        impl Into<mingling::AnyOutput<crate::ThisProgram>> for EntryMetadata {
+            fn into(self) -> mingling::AnyOutput<crate::ThisProgram> {
+                mingling::AnyOutput::new(self)
+            }
+        }
+        impl Into<mingling::ChainProcess<crate::ThisProgram>> for EntryMetadata {
+            fn into(self) -> mingling::ChainProcess<crate::ThisProgram> {
+                mingling::AnyOutput::new(self).route_chain()
+            }
+        }
+        impl ::mingling::Grouped<crate::ThisProgram> for EntryMetadata {
+            fn member_id() -> crate::ThisProgram {
+                crate::ThisProgram::EntryMetadata
+            }
+        }
+        impl ::mingling::Dispatcher<crate::ThisProgram> for CMDMetadata {
+            fn node(&self) -> ::mingling::Node {
+                mingling::Node::default().join("metadata")
+            }
+            fn begin(
+                &self,
+                args: Vec<String>,
+            ) -> ::mingling::ChainProcess<crate::ThisProgram> {
+                use ::mingling::Grouped;
+                ::mingling::Routable::to_chain(EntryMetadata::new(args))
+            }
+            fn clone_dispatcher(
+                &self,
+            ) -> Box<dyn ::mingling::Dispatcher<crate::ThisProgram>> {
+                Box::new(CMDMetadata)
+            }
+        }
+        pub struct ResultMetadata {
+            pub inner: ResMetadata,
+        }
+        #[doc(hidden)]
+        #[allow(
+            non_upper_case_globals,
+            unused_attributes,
+            unused_qualifications,
+            clippy::absolute_paths,
+        )]
+        const _: () = {
+            #[allow(unused_extern_crates, clippy::useless_attribute)]
+            extern crate serde as _serde;
+            #[automatically_derived]
+            impl _serde::Serialize for ResultMetadata {
+                fn serialize<__S>(
+                    &self,
+                    __serializer: __S,
+                ) -> _serde::__private229::Result<__S::Ok, __S::Error>
+                where
+                    __S: _serde::Serializer,
+                {
+                    let mut __serde_state = _serde::Serializer::serialize_struct(
+                        __serializer,
+                        "ResultMetadata",
+                        false as usize + 1,
+                    )?;
+                    _serde::ser::SerializeStruct::serialize_field(
+                        &mut __serde_state,
+                        "inner",
+                        &self.inner,
+                    )?;
+                    _serde::ser::SerializeStruct::end(__serde_state)
+                }
+            }
+        };
+        impl ResultMetadata {
+            pub fn new(inner: ResMetadata) -> Self {
+                Self { inner }
+            }
+        }
+        impl From<ResMetadata> for ResultMetadata {
+            fn from(inner: ResMetadata) -> Self {
+                Self::new(inner)
+            }
+        }
+        impl From<ResultMetadata> for ResMetadata {
+            fn from(wrapper: ResultMetadata) -> ResMetadata {
+                wrapper.inner
+            }
+        }
+        impl ::std::convert::AsRef<ResMetadata> for ResultMetadata {
+            fn as_ref(&self) -> &ResMetadata {
+                &self.inner
+            }
+        }
+        impl ::std::convert::AsMut<ResMetadata> for ResultMetadata {
+            fn as_mut(&mut self) -> &mut ResMetadata {
+                &mut self.inner
+            }
+        }
+        impl ::std::ops::Deref for ResultMetadata {
+            type Target = ResMetadata;
+            fn deref(&self) -> &Self::Target {
+                &self.inner
+            }
+        }
+        impl ::std::ops::DerefMut for ResultMetadata {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                &mut self.inner
+            }
+        }
+        impl ::std::default::Default for ResultMetadata
+        where
+            ResMetadata: ::std::default::Default,
+        {
+            fn default() -> Self {
+                Self::new(::std::default::Default::default())
+            }
+        }
+        impl ::mingling::__private::StructuralDataSealed<crate::ThisProgram>
+        for ResultMetadata {}
+        impl ::mingling::__private::StructuralData<crate::ThisProgram>
+        for ResultMetadata {}
+        impl Into<::mingling::AnyOutput<crate::ThisProgram>> for ResultMetadata {
+            fn into(self) -> ::mingling::AnyOutput<crate::ThisProgram> {
+                ::mingling::AnyOutput::new(self)
+            }
+        }
+        impl Into<::mingling::ChainProcess<crate::ThisProgram>> for ResultMetadata {
+            fn into(self) -> ::mingling::ChainProcess<crate::ThisProgram> {
+                ::mingling::AnyOutput::new(self).route_chain()
+            }
+        }
+        impl ::mingling::Grouped<crate::ThisProgram> for ResultMetadata {
+            fn member_id() -> crate::ThisProgram {
+                crate::ThisProgram::ResultMetadata
+            }
+        }
+        #[doc(hidden)]
+        #[allow(non_camel_case_types)]
+        pub struct __internal_chain_handle_metadata;
+        impl ::mingling::Chain<crate::ThisProgram> for __internal_chain_handle_metadata {
+            type Previous = EntryMetadata;
+            fn proc(
+                prev: EntryMetadata,
+            ) -> ::mingling::ChainProcess<crate::ThisProgram> {
+                let __chain_result = {
+                    ::mingling::this::<crate::ThisProgram>()
+                        .__modify_res_and_return_route(|
+                            metadata: &mut LazyRes<ResMetadata>|
+                        {
+                            ::mingling::Routable::<
+                                crate::ThisProgram,
+                            >::to_chain(handle_metadata(prev, metadata))
+                        })
+                };
+                ::mingling::Routable::<crate::ThisProgram>::to_chain(__chain_result)
+            }
+        }
+        pub fn handle_metadata(
+            _: EntryMetadata,
+            metadata: &mut LazyRes<ResMetadata>,
+        ) -> Metadata {
+            let metadata = metadata.get_ref().clone();
+            metadata.data().clone()
+        }
+    }
+    pub mod setup {
+        use std::{env::current_dir, path::PathBuf};
+        use cargo_metadata::{CargoOpt, MetadataCommand};
+        use mingling::{
+            LazyInit, Program, consts::REMAINS, macros::program_setup,
+            picker::{IntoPicker, value::Flag},
+            prelude::*, res::ResCurrentDir,
+        };
+        /// Name of Cargo manifest file
+        pub const CARGO_TOML: &str = "Cargo.toml";
+        use cargo_metadata::Metadata;
+        use serde::Serialize;
+        pub struct ResMetadata {
+            data: Option<Metadata>,
+        }
+        #[automatically_derived]
+        impl ::core::default::Default for ResMetadata {
+            #[inline]
+            fn default() -> ResMetadata {
+                ResMetadata {
+                    data: ::core::default::Default::default(),
+                }
+            }
+        }
+        #[automatically_derived]
+        impl ::core::clone::Clone for ResMetadata {
+            #[inline]
+            fn clone(&self) -> ResMetadata {
+                ResMetadata {
+                    data: ::core::clone::Clone::clone(&self.data),
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[allow(
+            non_upper_case_globals,
+            unused_attributes,
+            unused_qualifications,
+            clippy::absolute_paths,
+        )]
+        const _: () = {
+            #[allow(unused_extern_crates, clippy::useless_attribute)]
+            extern crate serde as _serde;
+            #[automatically_derived]
+            impl _serde::Serialize for ResMetadata {
+                fn serialize<__S>(
+                    &self,
+                    __serializer: __S,
+                ) -> _serde::__private229::Result<__S::Ok, __S::Error>
+                where
+                    __S: _serde::Serializer,
+                {
+                    let mut __serde_state = _serde::Serializer::serialize_struct(
+                        __serializer,
+                        "ResMetadata",
+                        false as usize + 1,
+                    )?;
+                    _serde::ser::SerializeStruct::serialize_field(
+                        &mut __serde_state,
+                        "data",
+                        &self.data,
+                    )?;
+                    _serde::ser::SerializeStruct::end(__serde_state)
+                }
+            }
+        };
+        impl ResMetadata {
+            /// Returns a reference to the parsed `cargo metadata`.
+            ///
+            /// # Panics
+            ///
+            /// This function does **not** panic in practice, because `ResMetadata` is
+            /// always initialized via [`LazyInit`] inside the program setup, and the
+            /// initialization either succeeds (setting `data` to `Some(...)`) or fails
+            /// by propagating the error from `cmd.exec().unwrap()`. Therefore, by the
+            /// time this getter is called, `self.data` is guaranteed to be `Some`.
+            pub fn data(&self) -> &Metadata {
+                self.data.as_ref().unwrap()
+            }
+        }
+        #[doc(hidden)]
+        pub struct CargoMetadataSetup;
+        impl ::mingling::setup::ProgramSetup<crate::ThisProgram> for CargoMetadataSetup {
+            fn setup(self, program: &mut ::mingling::Program<crate::ThisProgram>) {
+                cargo_metadata_setup(program);
+            }
+        }
+        pub fn cargo_metadata_setup(program: &mut Program<crate::ThisProgram>) {
+            {
+                let args = program.take_args();
+                let (
+                    feature_args,
+                    manifest_path,
+                    message_format,
+                    enable_all_features,
+                    no_default_features,
+                    no_deps,
+                    args,
+                ) = args
+                    .pick(
+                        &::mingling::picker::PickerArg::<Vec<String>> {
+                            full: &["features"],
+                            short: ::std::option::Option::None,
+                            positional: false,
+                            internal_type: ::std::marker::PhantomData,
+                        },
+                    )
+                    .pick(
+                        &::mingling::picker::PickerArg::<Option<String>> {
+                            full: &["manifest_path"],
+                            short: ::std::option::Option::None,
+                            positional: false,
+                            internal_type: ::std::marker::PhantomData,
+                        },
+                    )
+                    .pick_or(
+                        &::mingling::picker::PickerArg::<String> {
+                            full: &["message_format"],
+                            short: ::std::option::Option::None,
+                            positional: false,
+                            internal_type: ::std::marker::PhantomData,
+                        },
+                        || "disable".to_string(),
+                    )
+                    .pick(
+                        &::mingling::picker::PickerArg::<Flag> {
+                            full: &["all_features"],
+                            short: ::std::option::Option::None,
+                            positional: false,
+                            internal_type: ::std::marker::PhantomData,
+                        },
+                    )
+                    .pick(
+                        &::mingling::picker::PickerArg::<Flag> {
+                            full: &["no_default_features"],
+                            short: ::std::option::Option::None,
+                            positional: false,
+                            internal_type: ::std::marker::PhantomData,
+                        },
+                    )
+                    .pick(
+                        &::mingling::picker::PickerArg::<Flag> {
+                            full: &["no_deps"],
+                            short: ::std::option::Option::None,
+                            positional: false,
+                            internal_type: ::std::marker::PhantomData,
+                        },
+                    )
+                    .pick(&REMAINS)
+                    .unwrap();
+                program.replace_args(args.into());
+                program.structural_renderer_name = message_format.into();
+                let current_dir = current_dir().unwrap();
+                let feature_args_leaked: &[String] = Box::leak(
+                    feature_args.into_boxed_slice(),
+                );
+                let manifest_path_clone = manifest_path.clone();
+                let current_dir_clone = current_dir.clone();
+                program
+                    .with_resource(
+                        ResMetadata::lazy_init(move || {
+                            let metadata_path = match manifest_path_clone {
+                                Some(ref path_str) => PathBuf::from(path_str),
+                                None => find_manifest().unwrap(),
+                            };
+                            let mut cmd = MetadataCommand::new();
+                            cmd.manifest_path(metadata_path)
+                                .current_dir(&current_dir_clone);
+                            if *enable_all_features {
+                                cmd.features(CargoOpt::AllFeatures);
+                            }
+                            if *no_default_features {
+                                cmd.features(CargoOpt::NoDefaultFeatures);
+                            }
+                            if *no_deps {
+                                cmd.no_deps();
+                            }
+                            cmd.features(
+                                CargoOpt::SomeFeatures(feature_args_leaked.to_vec()),
+                            );
+                            ResMetadata {
+                                data: Some(cmd.exec().unwrap()),
+                            }
+                        }),
+                    );
+                program.with_resource(ResCurrentDir::from(current_dir));
+            }
+        }
+        /// Find `Cargo.toml` by searching upward from `current_dir`.
+        fn find_manifest() -> Option<PathBuf> {
+            let mut dir = current_dir().ok()?;
+            loop {
+                let candidate = dir.join(CARGO_TOML);
+                if candidate.is_file() {
+                    return Some(candidate);
+                }
+                if !dir.pop() {
+                    return None;
+                }
+            }
+        }
+    }
+    #[doc(hidden)]
+    pub struct MinglingMetadataSetup;
+    impl ::mingling::setup::ProgramSetup<crate::ThisProgram> for MinglingMetadataSetup {
+        fn setup(self, program: &mut ::mingling::Program<crate::ThisProgram>) {
+            mingling_metadata_setup(program);
+        }
+    }
+    pub fn mingling_metadata_setup(program: &mut Program<crate::ThisProgram>) {
+        {
+            program.with_setup(CargoMetadataSetup);
+            program.with_dispatcher(CMDMetadata);
+        }
+    }
+    #[allow(non_camel_case_types)]
+    mod internal_group_metadata {
+        use crate::ThisProgram as __MinglingProgram;
+        #[allow(unused_imports)]
+        use super::Metadata;
+        impl ::mingling::Grouped<__MinglingProgram> for Metadata {
+            fn member_id() -> __MinglingProgram {
+                __MinglingProgram::Metadata
+            }
+        }
+        impl ::mingling::__private::StructuralDataSealed<crate::ThisProgram>
+        for Metadata {}
+        impl ::mingling::__private::StructuralData<crate::ThisProgram> for Metadata {}
+    }
+    #[doc(hidden)]
+    #[allow(non_camel_case_types)]
+    pub struct __internal_renderer_render_metadata;
+    impl ::mingling::Renderer for __internal_renderer_render_metadata {
+        type Previous = Metadata;
+        fn render(prev: Self::Previous) -> ::mingling::RenderResult {
+            let __renderer_result = { render_metadata(prev) };
+            ::std::convert::Into::into(__renderer_result)
+        }
+    }
+    pub fn render_metadata(metadata: Metadata) -> RenderResult {
+        let mut r = RenderResult::new();
+        r.println(
+            ::alloc::__export::must_use({
+                ::alloc::fmt::format(
+                    format_args!("{0}", serde_json::to_string(&metadata)?),
+                )
+            }),
+        );
+        r
+    }
+}
+fn main() {
+    let mut program = ThisProgram::new();
+    program.with_setup(HelpFlagSetup::default());
+    program.with_setup(ExitCodeSetup::default());
+    program.with_setup(StructuralRendererSetup);
+    program.with_setup(MinglingMetadataSetup);
+    program.with_setup(MinglingLinterSetup);
+    program.exec_and_exit();
+}
+/// Alias for the current program type `crate::ThisProgram`
+pub type Next = ::mingling::ChainProcess<crate::ThisProgram>;
+impl ::mingling::Routable<crate::ThisProgram>
+for ::mingling::ChainProcess<crate::ThisProgram> {
+    fn to_chain(self) -> ::mingling::ChainProcess<crate::ThisProgram> {
+        match self {
+            ::mingling::ChainProcess::Ok((any, _)) => {
+                ::mingling::ChainProcess::Ok((any, mingling::NextProcess::Chain))
+            }
+            other => other,
+        }
+    }
+    fn to_render(self) -> ::mingling::ChainProcess<crate::ThisProgram> {
+        match self {
+            ::mingling::ChainProcess::Ok((any, _)) => {
+                ::mingling::ChainProcess::Ok((any, mingling::NextProcess::Renderer))
+            }
+            other => other,
+        }
+    }
+}
+pub struct ErrorRendererNotFound {
+    pub(crate) inner: String,
+}
+impl ErrorRendererNotFound {
+    /// Creates a new instance of the wrapper type
+    pub fn new(inner: String) -> Self {
+        Self { inner }
+    }
+}
+impl From<String> for ErrorRendererNotFound {
+    fn from(inner: String) -> Self {
+        Self::new(inner)
+    }
+}
+impl From<ErrorRendererNotFound> for String {
+    fn from(wrapper: ErrorRendererNotFound) -> String {
+        wrapper.inner
+    }
+}
+impl ::std::convert::AsRef<String> for ErrorRendererNotFound {
+    fn as_ref(&self) -> &String {
+        &self.inner
+    }
+}
+impl ::std::convert::AsMut<String> for ErrorRendererNotFound {
+    fn as_mut(&mut self) -> &mut String {
+        &mut self.inner
+    }
+}
+impl ::std::ops::Deref for ErrorRendererNotFound {
+    type Target = String;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl ::std::ops::DerefMut for ErrorRendererNotFound {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl ::std::default::Default for ErrorRendererNotFound
+where
+    String: ::std::default::Default,
+{
+    fn default() -> Self {
+        Self::new(::std::default::Default::default())
+    }
+}
+impl Into<mingling::AnyOutput<crate::ThisProgram>> for ErrorRendererNotFound {
+    fn into(self) -> mingling::AnyOutput<crate::ThisProgram> {
+        mingling::AnyOutput::new(self)
+    }
+}
+impl Into<mingling::ChainProcess<crate::ThisProgram>> for ErrorRendererNotFound {
+    fn into(self) -> mingling::ChainProcess<crate::ThisProgram> {
+        mingling::AnyOutput::new(self).route_chain()
+    }
+}
+impl ::mingling::Grouped<crate::ThisProgram> for ErrorRendererNotFound {
+    fn member_id() -> crate::ThisProgram {
+        crate::ThisProgram::ErrorRendererNotFound
+    }
+}
+pub struct ErrorDispatcherNotFound {
+    pub(crate) inner: Vec<String>,
+}
+impl ErrorDispatcherNotFound {
+    /// Creates a new instance of the wrapper type
+    pub fn new(inner: Vec<String>) -> Self {
+        Self { inner }
+    }
+}
+impl From<Vec<String>> for ErrorDispatcherNotFound {
+    fn from(inner: Vec<String>) -> Self {
+        Self::new(inner)
+    }
+}
+impl From<ErrorDispatcherNotFound> for Vec<String> {
+    fn from(wrapper: ErrorDispatcherNotFound) -> Vec<String> {
+        wrapper.inner
+    }
+}
+impl ::std::convert::AsRef<Vec<String>> for ErrorDispatcherNotFound {
+    fn as_ref(&self) -> &Vec<String> {
+        &self.inner
+    }
+}
+impl ::std::convert::AsMut<Vec<String>> for ErrorDispatcherNotFound {
+    fn as_mut(&mut self) -> &mut Vec<String> {
+        &mut self.inner
+    }
+}
+impl ::std::ops::Deref for ErrorDispatcherNotFound {
+    type Target = Vec<String>;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl ::std::ops::DerefMut for ErrorDispatcherNotFound {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl ::std::default::Default for ErrorDispatcherNotFound
+where
+    Vec<String>: ::std::default::Default,
+{
+    fn default() -> Self {
+        Self::new(::std::default::Default::default())
+    }
+}
+impl Into<mingling::AnyOutput<crate::ThisProgram>> for ErrorDispatcherNotFound {
+    fn into(self) -> mingling::AnyOutput<crate::ThisProgram> {
+        mingling::AnyOutput::new(self)
+    }
+}
+impl Into<mingling::ChainProcess<crate::ThisProgram>> for ErrorDispatcherNotFound {
+    fn into(self) -> mingling::ChainProcess<crate::ThisProgram> {
+        mingling::AnyOutput::new(self).route_chain()
+    }
+}
+impl ::mingling::Grouped<crate::ThisProgram> for ErrorDispatcherNotFound {
+    fn member_id() -> crate::ThisProgram {
+        crate::ThisProgram::ErrorDispatcherNotFound
+    }
+}
+pub struct ResultEmpty;
+#[doc(hidden)]
+#[allow(
+    non_upper_case_globals,
+    unused_attributes,
+    unused_qualifications,
+    clippy::absolute_paths,
+)]
+const _: () = {
+    #[allow(unused_extern_crates, clippy::useless_attribute)]
+    extern crate serde as _serde;
+    #[automatically_derived]
+    impl _serde::Serialize for ResultEmpty {
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private229::Result<__S::Ok, __S::Error>
+        where
+            __S: _serde::Serializer,
+        {
+            _serde::Serializer::serialize_unit_struct(__serializer, "ResultEmpty")
+        }
+    }
+};
+impl ::mingling::__private::StructuralDataSealed<crate::ThisProgram> for ResultEmpty {}
+impl ::mingling::__private::StructuralData<crate::ThisProgram> for ResultEmpty {}
+impl ::mingling::Grouped<crate::ThisProgram> for ResultEmpty {
+    fn member_id() -> crate::ThisProgram {
+        crate::ThisProgram::ResultEmpty
+    }
+}
+impl ::std::convert::Into<::mingling::AnyOutput<crate::ThisProgram>> for ResultEmpty {
+    fn into(self) -> ::mingling::AnyOutput<crate::ThisProgram> {
+        ::mingling::AnyOutput::new(self)
+    }
+}
+impl ::std::convert::Into<::mingling::ChainProcess<crate::ThisProgram>> for ResultEmpty {
+    fn into(self) -> ::mingling::ChainProcess<crate::ThisProgram> {
+        ::mingling::AnyOutput::new(self).route_chain()
+    }
+}
+#[automatically_derived]
+impl ::core::default::Default for ResultEmpty {
+    #[inline]
+    fn default() -> ResultEmpty {
+        ResultEmpty {}
+    }
+}
+#[repr(u8)]
+#[allow(nonstandard_style)]
+pub enum ThisProgram {
+    EntryMetadata,
+    EntryMinglingLinter,
+    ErrorDispatcherNotFound,
+    ErrorRendererNotFound,
+    ErrorSerdeJson,
+    Metadata,
+    ResultEmpty,
+    ResultMetadata,
+}
+#[automatically_derived]
+#[allow(nonstandard_style)]
+impl ::core::fmt::Debug for ThisProgram {
+    #[inline]
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        ::core::fmt::Formatter::write_str(
+            f,
+            match self {
+                ThisProgram::EntryMetadata => "EntryMetadata",
+                ThisProgram::EntryMinglingLinter => "EntryMinglingLinter",
+                ThisProgram::ErrorDispatcherNotFound => "ErrorDispatcherNotFound",
+                ThisProgram::ErrorRendererNotFound => "ErrorRendererNotFound",
+                ThisProgram::ErrorSerdeJson => "ErrorSerdeJson",
+                ThisProgram::Metadata => "Metadata",
+                ThisProgram::ResultEmpty => "ResultEmpty",
+                ThisProgram::ResultMetadata => "ResultMetadata",
+            },
+        )
+    }
+}
+#[automatically_derived]
+#[allow(nonstandard_style)]
+impl ::core::marker::StructuralPartialEq for ThisProgram {}
+#[automatically_derived]
+#[allow(nonstandard_style)]
+impl ::core::cmp::PartialEq for ThisProgram {
+    #[inline]
+    fn eq(&self, other: &ThisProgram) -> bool {
+        let __self_discr = ::core::intrinsics::discriminant_value(self);
+        let __arg1_discr = ::core::intrinsics::discriminant_value(other);
+        __self_discr == __arg1_discr
+    }
+}
+#[automatically_derived]
+#[allow(nonstandard_style)]
+impl ::core::cmp::Eq for ThisProgram {
+    #[doc(hidden)]
+    #[coverage(off)]
+    fn assert_fields_are_eq(&self) {}
+}
+#[automatically_derived]
+#[allow(nonstandard_style)]
+impl ::core::clone::Clone for ThisProgram {
+    #[inline]
+    fn clone(&self) -> ThisProgram {
+        match self {
+            ThisProgram::EntryMetadata => ThisProgram::EntryMetadata,
+            ThisProgram::EntryMinglingLinter => ThisProgram::EntryMinglingLinter,
+            ThisProgram::ErrorDispatcherNotFound => ThisProgram::ErrorDispatcherNotFound,
+            ThisProgram::ErrorRendererNotFound => ThisProgram::ErrorRendererNotFound,
+            ThisProgram::ErrorSerdeJson => ThisProgram::ErrorSerdeJson,
+            ThisProgram::Metadata => ThisProgram::Metadata,
+            ThisProgram::ResultEmpty => ThisProgram::ResultEmpty,
+            ThisProgram::ResultMetadata => ThisProgram::ResultMetadata,
+        }
+    }
+}
+impl ::std::fmt::Display for ThisProgram {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        match self {
+            ThisProgram::EntryMetadata => f.write_fmt(format_args!("EntryMetadata")),
+            ThisProgram::EntryMinglingLinter => {
+                f.write_fmt(format_args!("EntryMinglingLinter"))
+            }
+            ThisProgram::ErrorDispatcherNotFound => {
+                f.write_fmt(format_args!("ErrorDispatcherNotFound"))
+            }
+            ThisProgram::ErrorRendererNotFound => {
+                f.write_fmt(format_args!("ErrorRendererNotFound"))
+            }
+            ThisProgram::ErrorSerdeJson => f.write_fmt(format_args!("ErrorSerdeJson")),
+            ThisProgram::Metadata => f.write_fmt(format_args!("Metadata")),
+            ThisProgram::ResultEmpty => f.write_fmt(format_args!("ResultEmpty")),
+            ThisProgram::ResultMetadata => f.write_fmt(format_args!("ResultMetadata")),
+        }
+    }
+}
+impl ::mingling::ProgramCollect for ThisProgram {
+    type Enum = ThisProgram;
+    type ErrorDispatcherNotFound = ErrorDispatcherNotFound;
+    type ErrorRendererNotFound = ErrorRendererNotFound;
+    type ResultEmpty = ResultEmpty;
+    fn build_renderer_not_found(
+        member_id: Self::Enum,
+    ) -> ::mingling::AnyOutput<Self::Enum> {
+        ::mingling::AnyOutput::new(ErrorRendererNotFound::new(member_id.to_string()))
+    }
+    fn build_dispatcher_not_found(
+        args: Vec<String>,
+    ) -> ::mingling::AnyOutput<Self::Enum> {
+        ::mingling::AnyOutput::new(ErrorDispatcherNotFound::new(args))
+    }
+    fn build_empty_result() -> ::mingling::AnyOutput<Self::Enum> {
+        ::mingling::AnyOutput::new(ResultEmpty)
+    }
+    fn render(any: ::mingling::AnyOutput<Self::Enum>) -> ::mingling::RenderResult {
+        match any.member_id {
+            Self::ErrorSerdeJson => {
+                let value = unsafe {
+                    any.downcast::<crate::errors::serde_json::ErrorSerdeJson>()
+                        .unwrap_unchecked()
+                };
+                <crate::errors::serde_json::__internal_renderer_render_error_serde_json as ::mingling::Renderer>::render(
+                    value,
+                )
+            }
+            Self::Metadata => {
+                let value = unsafe {
+                    any.downcast::<cargo_metadata::Metadata>().unwrap_unchecked()
+                };
+                <crate::metadata::__internal_renderer_render_metadata as ::mingling::Renderer>::render(
+                    value,
+                )
+            }
+            _ => ::mingling::RenderResult::default(),
+        }
+    }
+    fn do_chain(
+        any: ::mingling::AnyOutput<Self::Enum>,
+    ) -> ::mingling::ChainProcess<Self::Enum> {
+        match any.member_id {
+            Self::EntryMetadata => {
+                let value = unsafe {
+                    any.downcast::<crate::metadata::cmd_metadata::EntryMetadata>()
+                        .unwrap_unchecked()
+                };
+                <crate::metadata::cmd_metadata::__internal_chain_handle_metadata as ::mingling::Chain<
+                    Self::Enum,
+                >>::proc(value)
+            }
+            Self::EntryMinglingLinter => {
+                let value = unsafe {
+                    any.downcast::<crate::linter::cmd_mlint::EntryMinglingLinter>()
+                        .unwrap_unchecked()
+                };
+                <crate::linter::cmd_mlint::__internal_chain_handle_mlint as ::mingling::Chain<
+                    Self::Enum,
+                >>::proc(value)
+            }
+            _ => {
+                ::core::panicking::panic_fmt(
+                    format_args!("No chain found for type id: {0:?}", any.type_id),
+                );
+            }
+        }
+    }
+    fn render_help(any: ::mingling::AnyOutput<Self::Enum>) -> ::mingling::RenderResult {
+        #[allow(unused_imports)]
+        use crate::metadata::cmd_metadata::__internal_chain_handle_metadata;
+        use crate::metadata::cmd_metadata::ResultMetadata;
+        use crate::linter::cmd_mlint::__internal_chain_handle_mlint;
+        use crate::metadata::__internal_renderer_render_metadata;
+        use crate::metadata::cmd_metadata::CMDMetadata;
+        use crate::metadata::setup::ResMetadata;
+        use crate::metadata::cmd_metadata::EntryMetadata;
+        use crate::linter::cmd_mlint::CMDMinglingLinter;
+        use crate::errors::serde_json::ErrorSerdeJson;
+        use cargo_metadata::Metadata;
+        use crate::errors::serde_json::__internal_renderer_render_error_serde_json;
+        use crate::linter::cmd_mlint::EntryMinglingLinter;
+        match any.member_id {
+            _ => ::mingling::RenderResult::default(),
+        }
+    }
+    fn has_renderer(any: &::mingling::AnyOutput<Self::Enum>) -> bool {
+        match any.member_id {
+            Self::ErrorSerdeJson => true,
+            Self::Metadata => true,
+            _ => false,
+        }
+    }
+    fn has_chain(any: &::mingling::AnyOutput<Self::Enum>) -> bool {
+        match any.member_id {
+            Self::EntryMetadata => true,
+            Self::EntryMinglingLinter => true,
+            _ => false,
+        }
+    }
+    fn structural_render(
+        any: ::mingling::AnyOutput<Self::Enum>,
+        setting: &::mingling::StructuralRendererSetting,
+    ) -> Result<
+        ::mingling::RenderResult,
+        ::mingling::error::StructuralRendererSerializeError,
+    > {
+        #[allow(unused_imports)]
+        use crate::metadata::cmd_metadata::__internal_chain_handle_metadata;
+        use crate::metadata::cmd_metadata::ResultMetadata;
+        use crate::linter::cmd_mlint::__internal_chain_handle_mlint;
+        use crate::metadata::__internal_renderer_render_metadata;
+        use crate::metadata::cmd_metadata::CMDMetadata;
+        use crate::metadata::setup::ResMetadata;
+        use crate::metadata::cmd_metadata::EntryMetadata;
+        use crate::linter::cmd_mlint::CMDMinglingLinter;
+        use crate::errors::serde_json::ErrorSerdeJson;
+        use cargo_metadata::Metadata;
+        use crate::errors::serde_json::__internal_renderer_render_error_serde_json;
+        use crate::linter::cmd_mlint::EntryMinglingLinter;
+        match any.member_id {
+            Self::Metadata => {
+                let raw = unsafe { any.restore::<Metadata>().unwrap_unchecked() };
+                let mut __renderer_inner_result = ::mingling::RenderResult::default();
+                ::mingling::StructuralRenderer::render(
+                    &raw,
+                    setting,
+                    &mut __renderer_inner_result,
+                )?;
+                Ok(__renderer_inner_result)
+            }
+            _ => {
+                let mut r = ::mingling::RenderResult::default();
+                ::mingling::StructuralRenderer::render(&ResultEmpty, setting, &mut r)?;
+                Ok(r)
+            }
+        }
+    }
+}
+impl ThisProgram {
+    /// Creates a new `Program<#name>` instance with default configuration.
+    pub fn new() -> ::mingling::Program<ThisProgram> {
+        ::mingling::Program::new()
+    }
+    /// Returns a static reference to the global `Program<#name>` singleton.
+    pub fn this() -> &'static ::mingling::Program<ThisProgram> {
+        &::mingling::this::<ThisProgram>()
+    }
+}