witx_codegen/doc/
function.rs

1use std::io::Write;
2
3use super::*;
4
5impl DocGenerator {
6    pub fn define_func<T: Write>(
7        w: &mut PrettyWriter<T>,
8        _module_name: &str,
9        func_witx: &witx::Function,
10    ) -> Result<(), Error> {
11        assert_eq!(func_witx.abi, witx::Abi::Preview1);
12        let name = func_witx.name.as_str().to_string();
13        let params_witx = &func_witx.params;
14        let mut params = vec![];
15        for param_witx in params_witx {
16            let param_name = param_witx.name.as_str();
17            let param_type = ASType::from(&param_witx.tref);
18            params.push((param_name.to_string(), param_type));
19        }
20
21        let results_witx = &func_witx.results;
22        assert_eq!(results_witx.len(), 1);
23        let result_witx = &results_witx[0];
24        let result = ASType::from(&result_witx.tref);
25        let result = match result {
26            ASType::Result(result) => result,
27            _ => unreachable!(),
28        };
29
30        let ok_type = result.ok_type.clone();
31
32        let mut results = vec![];
33        // A tuple in a result is expanded into additional parameters, transformed to
34        // pointers
35        if let ASType::Tuple(tuple_members) = ok_type.as_ref().leaf() {
36            for (i, tuple_member) in tuple_members.iter().enumerate() {
37                let name = format!("result{}_ptr", i);
38                results.push((name, tuple_member.type_.clone()));
39            }
40        } else {
41            let name = "result";
42            results.push((name.to_string(), ok_type));
43        }
44
45        w.write_lines(format!(
46            "### {}\nReturned error type: {}",
47            name.as_fn(),
48            result.error_type.as_lang()
49        ))?;
50        w.eob()?;
51        if !params.is_empty() {
52            w.write_line("#### Input:")?.eob()?;
53            {
54                let mut w = w.new_block();
55                for param in &params {
56                    w.write_line(format!("{}: {}", param.0.as_var(), param.1.as_lang()))?;
57                }
58            }
59        }
60        w.eob()?;
61        if !results.is_empty() {
62            match results[0].1.as_ref() {
63                ASType::Void if results.len() == 1 => {
64                    w.write_line("This function has no output.")?;
65                }
66                _ => {
67                    w.write_line("#### Output:")?.eob()?;
68                    {
69                        let mut w = w.new_block();
70                        for result in &results {
71                            let result_as_ptr = ASType::MutPtr(result.1.clone());
72                            w.write_line(result_as_ptr.as_lang())?;
73                        }
74                    }
75                }
76            }
77        }
78
79        let docs = &func_witx.docs;
80        if !docs.is_empty() {
81            Self::write_docs(w, docs)?;
82        }
83
84        w.eob()?.write_line("---")?.eob()?;
85        Ok(())
86    }
87}