Python bindings IR -- Implement the pipeline

Added pipeline code and updated the templates to work with the new
system.

My main workflow loop for this was:
 - Commenting out the template code using `{#` and `#}`
 - Running `cargo test py` on one of the examples/fixtures.
 - Uncommenting/upating the template code and implementing any pipeline
   passes needed to make the tests pass.

I also removed some of the redundant fields.  `Function.inputs` field
is redundant when there's `Function.callable.inputs`.

Author: bendk

Cargo.lock

@@ -50,9 +50,10 @@ lower = "{}.toString()"
 
 [bindings.python.custom_types.Url]
 # We're going to be the urllib.parse.ParseResult class, which is the closest
-# thing Python has to a Url class.  No need to specify `type_name` though,
-# since Python is loosely typed.
-# modules to import
+# thing Python has to a Url class. 
+
+# `type_name` is optional, but it improves Python's optional type-checking
+type_name = "urllib.parse.ParseResult"
 imports = ["urllib.parse"]
 # Function to lift a string from Rust into a Python URL.
 lift = "urllib.parse.urlparse({})"

examples/custom-types/uniffi.toml

@@ -25,7 +25,7 @@ fs-err = "2.7.0"
 glob = "0.3"
 goblin = "0.8"
 heck = "0.5"
-indexmap = { version = "2.2" }
+indexmap = { version = "2.2", features = ["serde"] }
 once_cell = "1.12"
 serde = { version = "1", features = ["derive"] }
 tempfile = "3"

uniffi_bindgen/Cargo.toml

@@ -0,0 +1,66 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/// Template filters for Askama
+///
+/// In general, prefer adding fields using a pipeline pass to writing filters.
+/// That's allows devs to use the `pipeline` command to follow what's going on.
+///
+/// We currently only use filter functions for a couple reasons:
+///
+/// * When we want to leverage `AsRef` to implement something for any type that has an `AsRef`
+///   relationship.  This could be done using a pipeline pass, but it could be annoying/distracting
+///   to add fields like `type_name,` `lower_fn`, etc. to so many different Node structs.
+/// * When we want to implement somewhat complex display logic, like in the `docstring` filter.
+///   Implementing this as a pipeline pass means the pass would need to know how much each
+///   docstring gets indented, which doesn't seem right.
+use super::pipeline::nodes::*;
+use askama::Result;
+
+pub fn type_name(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(ty.as_ref().type_name.clone())
+}
+
+pub fn ffi_converter_name(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(ty.as_ref().ffi_converter_name.clone())
+}
+
+pub fn lower_fn(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(format!("{}.lower", ty.as_ref().ffi_converter_name))
+}
+
+pub fn check_lower_fn(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(format!("{}.check_lower", ty.as_ref().ffi_converter_name))
+}
+
+pub fn lift_fn(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(format!("{}.lift", ty.as_ref().ffi_converter_name))
+}
+
+pub fn write_fn(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(format!("{}.write", ty.as_ref().ffi_converter_name))
+}
+
+pub fn read_fn(ty: impl AsRef<TypeNode>) -> Result<String> {
+    Ok(format!("{}.read", ty.as_ref().ffi_converter_name))
+}
+
+/// Get the idiomatic Python rendering of docstring
+///
+/// If the docstring is set, this returns an indented Python docstring with
+/// a trailing newline. If not, it returns the empty string.
+///
+/// This makes it so the template code can use something like
+/// `{{ item.docstring|docstring(4) -}}` to render the correct docstring in both cases.
+pub fn docstring(docstring: &Option<String>, indent: usize) -> Result<String> {
+    let Some(docstring) = docstring.as_deref() else {
+        return Ok("".to_string());
+    };
+    let docstring = textwrap::dedent(docstring);
+    let indent = " ".repeat(indent);
+    // Escape triple quotes to avoid syntax error
+    let escaped = docstring.replace(r#"""""#, r#"\"\"\""#);
+    let indented = textwrap::indent(&escaped, &indent);
+    Ok(format!("\"\"\"\n{indented}\n\"\"\"\n{indent}"))
+}