waybackend_scanner/

lib.rs

use std::{fs::File, io::BufReader, num::NonZeroU32, path::Path};

use proc_macro2::TokenStream;
use quick_xml::{Reader, events::attributes::Attributes};
use quote::quote;

use quick_xml::events::Event as Ev;

#[derive(Debug)]
pub struct Protocol {
    _name: String,
    interfaces: Vec<Interface>,
    _summary: String,
    _description: String,
}

impl Protocol {
    pub fn new<P: AsRef<Path>>(file: P) -> Self {
        let mut reader = Reader::from_file(file).unwrap();
        let mut name = None;
        let mut interfaces = Vec::new();
        let mut summary = "".to_string();
        let mut description = "".to_string();

        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                // exits the loop when reaching end of file
                Ok(Ev::Eof) => break,
                Ok(Ev::Start(e)) => match e.name().as_ref() {
                    b"protocol" => {
                        for attr in e.attributes() {
                            match attr {
                                Ok(attr) => {
                                    if attr.key.0 == b"name" {
                                        name = Some(
                                            std::str::from_utf8(&attr.value).unwrap().to_string(),
                                        );
                                    }
                                }
                                Err(e) => panic!("failed to read xml: {e}"),
                            }
                        }
                    }

                    b"interface" => interfaces.push(Interface::new(&mut reader, e.attributes())),

                    b"copyright" => {
                        // ignore the text
                        let _ = reader.read_event_into(&mut buf);
                        // ignore the closing </copyright>
                        let _ = reader.read_event_into(&mut buf);
                    }

                    b"description" => {
                        (summary, description) = parse_description(&mut reader, e.attributes())
                    }
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Text(_)) | Ok(Ev::Comment(_)) => continue,
                Ok(Ev::Decl(decl)) => {
                    if let Some(Ok(enc)) = decl.encoding()
                        && *enc != *b"UTF-8"
                        && *enc != *b"utf-8"
                    {
                        panic!("xml file is not encoded with utf-8");
                    }
                }
                Ok(Ev::End(end)) => match end.name().as_ref() {
                    b"protocol" => break,
                    b"description" => continue,
                    _ => panic!("bad xml file: {}", reader.buffer_position()),
                },
                e => panic!("unprocessed xml event: {e:?}"),
            }
        }

        Self {
            _name: name.unwrap(),
            interfaces,
            _summary: summary,
            _description: description,
        }
    }

    pub fn generate(self) -> TokenStream {
        self.interfaces
            .into_iter()
            .map(Interface::generate)
            .collect()
    }
}

#[derive(Debug)]
struct Interface {
    name: String,
    summary: String,
    description: String,
    version: NonZeroU32,
    requests: Vec<Request>,
    events: Vec<Event>,
    enums: Vec<Enum>,
}

impl Interface {
    fn new(reader: &mut Reader<BufReader<File>>, attrs: Attributes) -> Self {
        let (name, version) = {
            let mut name = "".to_string();
            let mut version = 0;
            for attr in attrs.flatten() {
                match attr.key.as_ref() {
                    b"name" => name = attr.unescape_value().unwrap().to_string(),
                    b"version" => version = attr.unescape_value().unwrap().parse::<u32>().unwrap(),

                    e => panic!(
                        "unrecognized attribute in interface: {}",
                        String::from_utf8_lossy(e)
                    ),
                }
            }
            assert!(!name.is_empty());
            (name, NonZeroU32::new(version).unwrap())
        };

        let mut summary = "".to_string();
        let mut description = "".to_string();
        let mut requests = Vec::new();
        let mut events = Vec::new();
        let mut enums = Vec::new();

        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                Ok(Ev::Start(e)) => match e.name().as_ref() {
                    b"description" => {
                        (summary, description) = parse_description(reader, e.attributes())
                    }
                    b"request" => requests.push(Request::new(reader, e.attributes())),
                    b"event" => events.push(Event::new(reader, e.attributes())),
                    b"enum" => enums.push(Enum::new(reader, e.attributes())),
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Text(_)) | Ok(Ev::Comment(_)) => continue,
                Ok(Ev::End(end)) => match end.name().as_ref() {
                    b"description" => continue,
                    b"interface" => break,
                    _ => panic!("bad xml file: {end:?} at {}", reader.buffer_position()),
                },
                e => panic!("unprocessed xml event: {e:?}"),
            }
        }

        Self {
            name,
            summary,
            description,
            version,
            requests,
            events,
            enums,
        }
    }

    fn generate(self) -> TokenStream {
        let name = &self.name;
        let name_ident = ident(name);
        let mut doc = self.summary;
        for line in self.description.lines() {
            doc.push('\n');
            doc += line.trim();
        }
        let version = self.version.get();

        let events = self.events.iter().map(|ev| {
            let mut doc = ev.summary.clone();
            for line in ev.description.lines() {
                doc.push('\n');
                doc += line.trim();
            }

            if ev.destructor {
                doc += "\nTHIS IS A DESTRUCTOR"
            }

            // note: we cannot issue a proper deprecation warning because we will be using this
            // function in the event handler implementation
            if let Some(d) = ev.deprecated_since {
                doc.push_str(&format!("\nDeprecated since interface version {d}"));
            }

            let args = ev.args.iter().map(|arg| arg.gen_fn_args(false));

            let fn_name = ident(&ev.name);
            quote! {
                #[doc = #doc]
                fn #fn_name(&mut self, sender_id: waybackend::types::ObjectId, #(#args),*);
            }
        });

        let requests = self.requests.iter().enumerate().map(|(i, req)| {
            let ident = ident(&req.name.to_uppercase());
            let mut doc = req.summary.clone();
            if let Some(desc) = req.description.as_ref() {
                for line in desc.lines() {
                    doc.push('\n');
                    doc += line.trim();
                }
            }

            if req.destructor {
                doc += "\nTHIS IS A DESTRUCTOR"
            }

            let deprecation_warning = if let Some(d) = req.deprecated_since {
                let note = format!("deprecation since interface version {d}");
                quote! {#[deprecated(note=#note)]}
            } else {
                TokenStream::new()
            };

            let i = i as u16;
            let function = req.generate();
            quote! {
                pub const #ident : u16 = #i;
                #[doc = #doc]
                #deprecation_warning
                #function
            }
        });

        let events_dispatch = self
            .events
            .iter()
            .enumerate()
            .map(|(i, ev)| ev.generate(i as u16));
        let enums = self.enums.into_iter().map(|i| i.generate());

        let event = quote! {
            pub fn event<T: EvHandler>(
                state: &mut T,
                wire_msg: &mut waybackend::wire::Messages<'_>,
            ) -> Result<(), waybackend::wire::Error> {
                match wire_msg.op() {
                    #(#events_dispatch)*
                    otherwise => Err(waybackend::wire::Error::UnrecognizedEventOpCode(#name, otherwise))
                }
            }
        };

        quote! {
            #[doc = #doc]
            #[allow(
                non_upper_case_globals,
                non_camel_case_types,
                unused_imports,
                unused,
                clippy::too_many_arguments,
                clippy::match_single_binding,
                clippy::empty_docs,
                clippy::just_underscores_and_digits
            )]
            pub mod #name_ident {
                use super::*;

                pub const MAX_VERSION: u32 = #version;
                pub const NAME: &str = #name;

                #[doc = "Events for this interface"]
                pub trait EvHandler {
                    #(#events)*
                }

                #event

                #[doc = "Requests for this interface"]
                pub mod req {
                    use super::*;
                    #(#requests)*
                }

                #(#enums)*
            }
        }
    }
}

/// Returns the summary and the description
fn parse_description(reader: &mut Reader<BufReader<File>>, attrs: Attributes) -> (String, String) {
    if let Some(attr) = attrs.flatten().next() {
        match attr.key.as_ref() {
            b"summary" => {
                let summary = std::str::from_utf8(&attr.value).unwrap().to_string();
                let mut buf = Vec::new();
                loop {
                    match reader.read_event_into(&mut buf) {
                        Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                        Ok(Ev::Text(text)) => return (summary, text.decode().unwrap().into()),
                        Ok(Ev::Comment(_)) => continue,
                        Ok(ev) => {
                            panic!(
                                "Unexpected xml tag {:?} at: {}",
                                ev,
                                reader.buffer_position()
                            )
                        }
                    }
                }
            }
            other => panic!("found unexpected attribute in description: {:?}", other),
        }
    }
    unreachable!("failed to parse description's summary and description")
}

#[derive(Debug)]
struct Request {
    name: String,
    summary: String,
    destructor: bool,
    deprecated_since: Option<u16>,
    description: Option<String>,
    args: Vec<Arg>,
}

impl Request {
    fn new(reader: &mut Reader<BufReader<File>>, attrs: Attributes) -> Self {
        let mut destructor = false;
        let mut deprecated_since = None;
        let name = {
            let mut name = "".to_string();
            for attr in attrs.flatten() {
                match attr.key.as_ref() {
                    b"name" => name = attr.unescape_value().unwrap().to_string(),
                    b"deprecated-since" => {
                        deprecated_since = Some(attr.unescape_value().unwrap().parse().unwrap())
                    }
                    b"since" => continue, // do not do anything for now
                    b"type" => match attr.unescape_value().unwrap().as_ref() {
                        "destructor" => destructor = true,
                        e => panic!("unrecognized request type: {e:?}"),
                    },
                    e => panic!(
                        "unrecognized attribute in interface request: {}",
                        String::from_utf8_lossy(e)
                    ),
                }
            }
            assert!(!name.is_empty());
            name
        };

        let mut summary = "".to_string();
        let mut description = None;
        let mut args = Vec::new();

        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                Ok(Ev::Start(e)) => match e.name().as_ref() {
                    b"description" => {
                        let parsed = parse_description(reader, e.attributes());
                        summary = parsed.0;
                        description = Some(parsed.1);
                    }
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Empty(e)) => match e.name().as_ref() {
                    b"arg" => args.push(Arg::new(e.attributes())),
                    b"description" => {
                        if let Some(attr) = e.attributes().flatten().next() {
                            match attr.key.as_ref() {
                                b"summary" => {
                                    summary = std::str::from_utf8(&attr.value).unwrap().to_string()
                                }
                                e => panic!("unrecognized description attribute: {e:?}"),
                            }
                        }
                    }
                    e => panic!(
                        "unrecognized tag: {:?} at: {}",
                        std::str::from_utf8(e),
                        reader.buffer_position()
                    ),
                },
                Ok(Ev::Text(_)) | Ok(Ev::Comment(_)) => continue,
                Ok(Ev::End(end)) => match end.name().as_ref() {
                    b"description" => continue,
                    b"request" => break,
                    _ => panic!("bad xml file: {end:?} at {}", reader.buffer_position()),
                },
                e => panic!("unprocessed xml event: {e:?}"),
            }
        }

        Self {
            name,
            summary,
            description,
            deprecated_since,
            destructor,
            args,
        }
    }

    fn generate(&self) -> TokenStream {
        let name = ident(&self.name);

        let opcode = ident(&self.name.to_uppercase());

        let args = self.args.iter().map(|arg| arg.gen_fn_args(true));
        let args_builder = self.args.iter().map(|arg| arg.gen_builder());

        let mut fds = 0usize;
        let sizes = self.args.iter().filter_map(|arg| match arg.arg_type {
            ArgType::String => {
                let ident = ident(&arg.name);
                Some(quote! { 1 + (#ident.len() + 1).div_ceil(4) })
            }
            ArgType::Array => {
                let ident = ident(&arg.name);
                Some(quote! { 1 + #ident.len().div_ceil(4) })
            }
            ArgType::NewId if arg.interface.is_none() => {
                Some(quote! { 2 + 1 + (interface.len() + 1).div_ceil(4) })
            }
            ArgType::Fd => {
                fds += 1;
                None
            }
            _ => Some(quote! { 1 }),
        });

        quote! {
            pub fn #name(
                backend: &mut waybackend::Waybackend,
                sender_id: waybackend::types::ObjectId,
                #(#args),*
            ) -> Result<(), waybackend::Errno> {
                let waybackend::Waybackend {wire_msg_builder, wayland_fd, ..} = backend;
                {
                    let byte_size = 2 #(+ #sizes)*;
                    wire_msg_builder.ensure_space(wayland_fd, byte_size, #fds)?;
                    unsafe { wire_msg_builder.add_header(sender_id, #opcode, (byte_size * 4) as u16) };
                }
                unsafe { #(#args_builder)* }
                Ok(())
            }
        }
    }
}

#[derive(Debug)]
struct Event {
    name: String,
    summary: String,
    destructor: bool,
    deprecated_since: Option<u16>,
    description: String,
    args: Vec<Arg>,
}

impl Event {
    fn new(reader: &mut Reader<BufReader<File>>, attrs: Attributes) -> Self {
        let mut destructor = false;
        let mut deprecated_since = None;
        let name = {
            let mut name = "".to_string();
            for attr in attrs.flatten() {
                match attr.key.as_ref() {
                    b"name" => name = attr.unescape_value().unwrap().to_string(),
                    b"deprecated-since" => {
                        deprecated_since = Some(attr.unescape_value().unwrap().parse().unwrap())
                    }
                    b"since" => continue, // do not do anything for now
                    b"type" => match attr.unescape_value().unwrap().as_ref() {
                        "destructor" => destructor = true,
                        e => panic!("unrecognized event type: {e:?}"),
                    },
                    e => panic!(
                        "unrecognized attribute in interface event: {}",
                        String::from_utf8_lossy(e)
                    ),
                }
            }
            assert!(!name.is_empty());
            name
        };

        let mut summary = "".to_string();
        let mut description = "".to_string();
        let mut args = Vec::new();

        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                Ok(Ev::Start(e)) => match e.name().as_ref() {
                    b"description" => {
                        (summary, description) = parse_description(reader, e.attributes())
                    }
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Empty(e)) => match e.name().as_ref() {
                    b"arg" => args.push(Arg::new(e.attributes())),
                    b"description" => {
                        if let Some(attr) = e.attributes().flatten().next() {
                            match attr.key.as_ref() {
                                b"summary" => {
                                    summary = std::str::from_utf8(&attr.value).unwrap().to_string()
                                }
                                e => panic!("unrecognized description attribute: {e:?}"),
                            }
                        }
                    }
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Text(_)) | Ok(Ev::Comment(_)) => continue,
                Ok(Ev::End(end)) => match end.name().as_ref() {
                    b"description" => continue,
                    b"event" => break,
                    _ => panic!("bad xml file: {end:?} at {}", reader.buffer_position()),
                },
                e => panic!("unprocessed xml event: {e:?}"),
            }
        }

        Self {
            name,
            summary,
            description,
            deprecated_since,
            destructor,
            args,
        }
    }

    fn generate(&self, opcode: u16) -> TokenStream {
        let arg_idents = self.args.iter().map(|arg| ident(&arg.name));
        let args = self.args.iter().map(|arg| arg.gen_recv());

        let function = ident(&self.name);

        if self.args.iter().any(|arg| {
            matches!(
                arg.arg_type,
                ArgType::String | ArgType::Array | ArgType::NewId if arg.interface.is_none()
            )
        }) {
            // we only need to do a more expensive check when we'll be receiving an array or string
            // type
            let boolean_array = self.args.iter().filter_map(|arg| match arg.arg_type {
                ArgType::String | ArgType::Array => Some(quote!(true)),
                ArgType::NewId if arg.interface.is_none() => Some(quote!(false, true, false)),
                ArgType::Fd => None,
                _ => Some(quote!(false)),
            });
            quote! {
                #opcode => {
                    wire_msg.validate_len([#(#boolean_array),*])?;
                    //parse args
                    #(#args)*

                    // call function
                    state.#function(wire_msg.sender_id(), #(#arg_idents),*);
                    Ok(())
                },
            }
        } else {
            quote! {
                #opcode => {
                    //parse args
                    #(#args)*

                    // call function
                    state.#function(wire_msg.sender_id(), #(#arg_idents),*);
                    Ok(())
                },
            }
        }
    }
}

#[derive(Debug)]
struct EnumEntry {
    name: String,
    summary: Option<String>,
    description: Option<String>,
    value: u32,
}

impl EnumEntry {
    fn new(reader: &mut Reader<BufReader<File>>, attrs: Attributes) -> Self {
        let mut name = "".to_string();
        let mut summary = None;
        let mut description = None;
        let mut value = None;

        for attr in attrs.flatten() {
            match attr.key.as_ref() {
                b"name" => name = name_to_pascal_case(&attr.unescape_value().unwrap()),
                b"value" => {
                    let s = attr.unescape_value().unwrap();
                    value = if let Some(s) = s.as_ref().strip_prefix("0x") {
                        Some(u32::from_str_radix(s, 16).unwrap())
                    } else {
                        Some(s.as_ref().parse::<u32>().unwrap())
                    };
                }
                b"since" => continue, // do not do anything for now
                b"summary" => summary = Some(attr.unescape_value().unwrap().to_string()),
                e => panic!(
                    "unrecognized attribute in interface: {}",
                    std::str::from_utf8(e).unwrap()
                ),
            }
        }
        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                Ok(Ev::Start(e)) => match e.name().as_ref() {
                    b"description" => {
                        let parsed = parse_description(reader, e.attributes());
                        summary = Some(parsed.0);
                        description = Some(parsed.1);
                    }
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Text(_)) | Ok(Ev::Comment(_)) => continue,
                Ok(Ev::End(end)) => match end.name().as_ref() {
                    b"entry" => break,
                    b"description" => continue,
                    _ => panic!("bad xml file: {end:?} at {}", reader.buffer_position()),
                },
                e => panic!("unprocessed xml event: {e:?}"),
            }
        }

        assert!(!name.is_empty());
        assert!(value.is_some());

        Self {
            name,
            summary,
            description,
            value: value.unwrap(),
        }
    }
    fn new_from_empty_tag(attrs: Attributes) -> Self {
        let mut name = "".to_string();
        let mut summary = None;
        let mut value = None;

        for attr in attrs.flatten() {
            match attr.key.as_ref() {
                b"name" => name = attr.unescape_value().unwrap().to_string(),
                b"value" => {
                    let s = attr.unescape_value().unwrap();
                    value = if let Some(s) = s.as_ref().strip_prefix("0x") {
                        Some(u32::from_str_radix(s, 16).unwrap())
                    } else {
                        Some(s.as_ref().parse::<u32>().unwrap())
                    };
                }
                b"since" => continue, // do not do anything for now
                b"summary" => summary = Some(attr.unescape_value().unwrap().to_string()),
                e => panic!(
                    "unrecognized attribute in interface: {}",
                    std::str::from_utf8(e).unwrap()
                ),
            }
        }

        assert!(!name.is_empty());
        assert!(value.is_some());

        Self {
            name,
            summary,
            description: None,
            value: value.unwrap(),
        }
    }

    fn generate(&self) -> TokenStream {
        let name = ident(&self.name);

        let mut doc = self.summary.as_ref().cloned().unwrap_or_default();
        if let Some(desc) = self.description.as_ref() {
            for line in desc.lines() {
                doc.push('\n');
                doc += line.trim();
            }
        }

        let value = self.value;

        quote! {
            #[doc = #doc]
            #name = #value
        }
    }

    fn generate_as_consts(&self) -> TokenStream {
        let name = ident(&self.name);

        let mut doc = self.summary.as_ref().cloned().unwrap_or_default();
        if let Some(desc) = self.description.as_ref() {
            for line in desc.lines() {
                doc.push('\n');
                doc += line.trim();
            }
        }

        let value = self.value;

        quote! {
            #[doc = #doc]
            const #name = #value
        }
    }
}

#[derive(Debug)]
struct Enum {
    name: String,
    description: Option<String>,
    summary: Option<String>,
    is_bitfield: bool,
    variants: Vec<EnumEntry>,
}

impl Enum {
    fn new(reader: &mut Reader<BufReader<File>>, attrs: Attributes) -> Self {
        let mut is_bitfield = false;

        let name = {
            let mut name = "".to_string();
            for attr in attrs.flatten() {
                match attr.key.as_ref() {
                    b"name" => name = name_to_pascal_case(&attr.unescape_value().unwrap()),
                    b"since" => continue, // do not do anything for now
                    b"bitfield" => is_bitfield = attr.unescape_value().unwrap().as_ref().eq("true"),
                    e => panic!("unrecognized attribute in interface: {e:?}"),
                }
            }
            assert!(!name.is_empty());
            name
        };

        let mut summary = None;
        let mut description = None;
        let mut variants = Vec::new();

        let mut buf = Vec::new();
        loop {
            match reader.read_event_into(&mut buf) {
                Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
                Ok(Ev::Start(e)) => match e.name().as_ref() {
                    b"description" => {
                        let parsed = parse_description(reader, e.attributes());
                        summary = Some(parsed.0);
                        description = Some(parsed.1);
                    }
                    b"entry" => variants.push(EnumEntry::new(reader, e.attributes())),
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Empty(e)) => match e.name().as_ref() {
                    b"entry" => variants.push(EnumEntry::new_from_empty_tag(e.attributes())),
                    e => panic!("unrecognized tag: {:?}", std::str::from_utf8(e)),
                },
                Ok(Ev::Text(_)) | Ok(Ev::Comment(_)) => continue,
                Ok(Ev::End(end)) => match end.name().as_ref() {
                    b"description" => continue,
                    b"enum" => break,
                    _ => panic!("bad xml file: {end:?} at {}", reader.buffer_position()),
                },
                e => panic!("unprocessed xml event: {e:?}"),
            }
        }

        if is_bitfield {
            for var in variants.iter_mut() {
                var.name = var.name.to_uppercase();
            }
        }

        Self {
            name,
            is_bitfield,
            summary,
            description,
            variants,
        }
    }

    fn generate(self) -> TokenStream {
        let name = ident(&self.name);
        let name_str = &self.name;
        let mut doc = String::new();
        doc.push_str(&self.summary.unwrap_or_default());
        if let Some(desc) = self.description {
            for line in desc.lines() {
                doc.push('\n');
                doc += line.trim();
            }
        }
        if self.is_bitfield {
            let variants = self.variants.iter().map(|v| v.generate_as_consts());
            quote! {
                waybackend::bitflags::bitflags! {
                    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
                    #[doc = #doc]
                    pub struct #name : u32 {
                        #(#variants ;)*
                        const _ = !0;
                    }
                }

                impl core::convert::TryFrom<u32> for #name {
                    type Error = waybackend::wire::Error;
                    fn try_from(value: u32) -> Result<Self, Self::Error> {
                        Ok(Self::from_bits_retain(value))
                    }
                }

                impl core::convert::From<#name> for u32 {
                    fn from(value: #name) -> u32 {
                        value.bits()
                    }
                }
            }
        } else {
            let variants = self.variants.iter().map(|v| v.generate());
            let variants2 = self.variants.iter().map(|v| ident(&v.name));
            let variants3 = self.variants.iter().map(|v| ident(&v.name));
            quote! {
                #[doc = #doc]
                #[repr(u32)]
                #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
                pub enum #name {
                    #(#variants,)*
                }

                impl core::convert::TryFrom<u32> for #name {
                    type Error = waybackend::wire::Error;

                    #[allow(non_upper_case_globals)]
                    fn try_from(value: u32) -> Result<Self, Self::Error> {
                        #(const #variants2: u32 = #name::#variants2 as u32;)*
                        match value {
                            #(#variants3 => Ok(Self::#variants3),)*
                            otherwise => Err(waybackend::wire::Error::InvalidEnumDiscriminant(#name_str, otherwise)),
                        }
                    }
                }

                impl core::convert::From<#name> for u32 {
                    fn from(value: #name) -> u32 {
                        value as u32
                    }
                }
            }
        }
    }
}

#[derive(Debug)]
struct Arg {
    name: String,
    arg_type: ArgType,
    #[allow(unused)]
    summary: String,
    interface: Option<String>,
    r#enum: Option<String>,
    allow_null: bool,
}

#[derive(Debug, PartialEq, Eq)]
enum ArgType {
    Uint,
    Int,
    Fixed,
    String,
    Object,
    NewId,
    Array,
    Fd,
}

impl ArgType {
    fn from_raw(raw: &str) -> Self {
        match raw {
            "uint" => Self::Uint,
            "int" => Self::Int,
            "fixed" => Self::Fixed,
            "string" => Self::String,
            "object" => Self::Object,
            "new_id" => Self::NewId,
            "array" => Self::Array,
            "fd" => Self::Fd,
            e => panic!("unrecognized type: {e}"),
        }
    }
}

impl Arg {
    fn new(attrs: Attributes) -> Self {
        let mut name = "".to_string();
        let mut summary = "".to_string();
        let mut arg_type = None;
        let mut interface = None;
        let mut r#enum = None;
        let mut allow_null = false;
        for attr in attrs.flatten() {
            match attr.key.as_ref() {
                b"name" => name = attr.unescape_value().unwrap().to_string(),
                b"summary" => summary = attr.unescape_value().unwrap().to_string(),
                b"type" => arg_type = Some(ArgType::from_raw(&attr.unescape_value().unwrap())),
                b"interface" => interface = Some(attr.unescape_value().unwrap().to_string()),
                b"enum" => r#enum = Some(attr.unescape_value().unwrap().to_string()),
                b"allow-null" => allow_null = attr.unescape_value().unwrap().eq("true"),
                e => panic!(
                    "unrecognized attribute in interface: {}",
                    std::str::from_utf8(e).unwrap()
                ),
            }
        }

        assert!(!name.is_empty());
        assert!(arg_type.is_some());

        Self {
            name,
            arg_type: arg_type.unwrap(),
            summary,
            interface,
            r#enum,
            allow_null,
        }
    }

    fn gen_enum_type(&self, e: &str) -> TokenStream {
        let mut t = TokenStream::new();
        let mut i = 0;
        while let Some(j) = e[i..].find(".") {
            let id = ident(&e[i..i + j]);
            t = if t.is_empty() {
                quote! {#id}
            } else {
                quote! {#t :: #id}
            };
            i += j + 1;
        }
        let id = ident(&name_to_pascal_case(&e[i..]));
        if t.is_empty() {
            quote! {#id}
        } else {
            quote! {#t :: #id}
        }
    }

    fn gen_recv(&self) -> TokenStream {
        let name = ident(&self.name);

        if let Some(e) = &self.r#enum {
            let enum_ident = self.gen_enum_type(e);
            return quote! { let #name: #enum_ident = wire_msg.next_u32().try_into()?; };
        }

        match self.arg_type {
            ArgType::Uint => quote! { let #name = wire_msg.next_u32(); },
            ArgType::Int => quote! { let #name = wire_msg.next_i32(); },
            ArgType::Fixed => quote! { let #name = wire_msg.next_fixed(); },
            ArgType::String => quote! { let #name = wire_msg.next_string()?; },
            ArgType::Object => {
                if self.allow_null {
                    quote! { let #name = wire_msg.next_object(); }
                } else {
                    quote! { let #name = wire_msg.next_object().ok_or(waybackend::wire::Error::NullObjectId)?; }
                }
            }
            ArgType::NewId => {
                if self.interface.is_some() {
                    quote! { let #name = wire_msg.next_new_specified_id()?; }
                } else {
                    quote! { let #name = wire_msg.next_new_unspecified_id()?; }
                }
            }
            ArgType::Array => quote! { let #name = wire_msg.next_array(); },
            ArgType::Fd => quote! { let #name = wire_msg.next_fd(); },
        }
    }

    fn gen_fn_args(&self, is_request: bool) -> TokenStream {
        let name = ident(&self.name);

        if let Some(e) = &self.r#enum {
            let enum_ident = self.gen_enum_type(e);
            return quote! { #name: #enum_ident };
        }

        match self.arg_type {
            ArgType::Uint => quote! {  #name: u32 },
            ArgType::Int => quote! {  #name: i32 },
            ArgType::Fixed => quote! {  #name: waybackend::types::WlFixed },
            ArgType::String => quote! {  #name: &str },
            ArgType::Object => {
                if self.allow_null {
                    quote! {  #name: Option<waybackend::types::ObjectId> }
                } else {
                    quote! {  #name: waybackend::types::ObjectId }
                }
            }
            ArgType::NewId => {
                if self.interface.is_some() {
                    quote! {  #name: waybackend::types::ObjectId }
                } else {
                    quote! {  #name: waybackend::types::ObjectId, interface: &str, version: u32 }
                }
            }
            ArgType::Array => quote! {  #name: &[u8] },
            ArgType::Fd => {
                if is_request {
                    quote! { #name: &impl waybackend::rustix::fd::AsRawFd }
                } else {
                    quote! { #name: waybackend::rustix::fd::OwnedFd }
                }
            }
        }
    }

    fn gen_builder(&self) -> TokenStream {
        let name = ident(&self.name);

        if self.r#enum.is_some() {
            return quote! { wire_msg_builder.add_u32(#name.into()); };
        }

        match self.arg_type {
            ArgType::Uint => quote! { wire_msg_builder.add_u32(#name); },
            ArgType::Int => quote! { wire_msg_builder.add_i32(#name); },
            ArgType::Fixed => quote! {  wire_msg_builder.add_fixed(#name);  },
            ArgType::String => quote! { wire_msg_builder.add_string(#name); },
            ArgType::Object => {
                if self.allow_null {
                    quote! { wire_msg_builder.add_object(#name); }
                } else {
                    quote! { wire_msg_builder.add_object(Some(#name)); }
                }
            }
            ArgType::NewId => {
                if self.interface.is_some() {
                    quote! { wire_msg_builder.add_new_specified_id(#name); }
                } else {
                    quote! { wire_msg_builder.add_new_unspecified_id(#name, interface, version); }
                }
            }
            ArgType::Array => quote! {  wire_msg_builder.add_array(#name); },
            ArgType::Fd => quote! {   wire_msg_builder.add_fd(#name)?; },
        }
    }
}

fn ident(name: &str) -> proc_macro2::Ident {
    if name == "state" {
        return proc_macro2::Ident::new("_state", proc_macro2::Span::mixed_site());
    }
    syn::parse_str(name).unwrap_or_else(|_| syn::parse_str(&format!("_{name}")).unwrap())
}

fn name_to_pascal_case(name: &str) -> String {
    let mut s = String::new();
    let mut capitalize = true;
    for ch in name.chars() {
        if capitalize {
            capitalize = false;
            s.extend(ch.to_uppercase());
        } else if ch == '_' || ch == '-' {
            capitalize = true;
        } else {
            s.push(ch);
        }
    }
    s
}

#[cfg(feature = "build-script")]
/// Which Wayland protocol to generate
pub enum WaylandProtocol {
    /// Generate wayland-client bindinds.
    ///
    /// You will pretty much always want this
    Client,
    /// Generate bindings to a global wayland protocol that is expected to be found through
    /// `pkg-config`
    ///
    /// We will prepend `pkg-config`'s `wayland-prococol` variable value to this path. So, for
    /// example, if you want to use `xdg-output`, you would have to specify:
    /// `unstable/xdg-output/xdg-output-unstable-v1.xml`.
    System(std::path::PathBuf),
    /// Generate bindings to a local wayland protocol in a path relative to the build script's
    /// current working directory
    Local(std::path::PathBuf),
}

#[cfg(feature = "build-script")]
/// Generate the wayland code for every protocol in `protocols`. The code will be outputted to
/// `out_file`.
///
/// NOTE: we currently panic if:
///   * the file was not found; or
///   * we failed to write to `out_file`
pub fn build_script_generate(protocols: &[WaylandProtocol], out_file: &std::fs::File) {
    use std::io::{BufWriter, Write};
    let mut writer = BufWriter::new(out_file);

    let wayland_protocols = pkg_config::get_variable("wayland-protocols", "pkgdatadir")
        .expect("failed to find wayland-protocols directory");
    let wayland_protocols = std::path::PathBuf::from(&wayland_protocols);
    let cwd = std::env::current_dir().expect("failed to get current working directory");

    for protocol in protocols {
        let path = match protocol {
            WaylandProtocol::Client => 'brk: {
                // In nix-os, the `wayland.xml` file is actually in the directory pointed by the
                // `wayland-scanner` variable. This means we need to check that directory as a
                // fallback
                if let Ok(wayland_client) = pkg_config::get_variable("wayland-client", "pkgdatadir")
                {
                    let mut path = std::path::PathBuf::from(&wayland_client);
                    path.push("wayland.xml");
                    if path.is_file() {
                        break 'brk path;
                    }
                }

                if let Ok(wayland_scanner) =
                    pkg_config::get_variable("wayland-scanner", "pkgdatadir")
                {
                    let mut path = std::path::PathBuf::from(&wayland_scanner);
                    path.push("wayland.xml");
                    if path.is_file() {
                        break 'brk path;
                    }
                }

                panic!("could not find wayland.xml file");
            }
            WaylandProtocol::System(path) => wayland_protocols.join(path),
            WaylandProtocol::Local(path) => cwd.join(path),
        };

        if !path.is_file() {
            panic!("could not find wayland protocol file {}", path.display());
        }

        let code = Protocol::new(&path).generate();
        println!("cargo::rerun-if-changed={}", path.display());
        writeln!(writer, "{code}").unwrap();
    }
}