Merge pull request mozilla#1185 from bendk/askama-0.11

Update to Askama 0.11

.circleci/config.yml

@@ -22,7 +22,7 @@ commands:
   # Our minimum supported rust version is specified here.
   prepare-rust-min-version:
     steps:
-      - run: rustup override set 1.47.0
+      - run: rustup override set 1.57.0
       - run: rustup update
   build-api-docs:
     steps:

fixtures/coverall/src/lib.rs

@@ -212,9 +212,7 @@ impl Coveralls {
     }
 
     fn get_other(&self) -> Option<Arc<Self>> {
-        (*self.other.lock().unwrap())
-            .as_ref()
-            .map(|other| Arc::clone(other))
+        (*self.other.lock().unwrap()).as_ref().map(Arc::clone)
     }
 
     fn take_other_fallible(self: Arc<Self>) -> Result<()> {

fixtures/regressions/kotlin-experimental-unsigned-types/src/lib.rs

@@ -34,12 +34,12 @@ pub struct RecursivelyUsesU8 {
 
 #[derive(Debug)]
 pub struct InterfaceUsingUnsigned {
-    member: u64,
+    _member: u64,
 }
 
 impl InterfaceUsingUnsigned {
     pub fn new(new: u64) -> Self {
-        Self { member: new }
+        Self { _member: new }
     }
 
     fn uses_unsigned_struct(&self, mut p1: RecursivelyUsesU8) {

fixtures/uitests/tests/ui/interface_not_sync_and_send.stderr

@@ -2,28 +2,43 @@ error[E0277]: `Cell<u32>` cannot be shared between threads safely
   --> $OUT_DIR[uniffi_uitests]/counter.uniffi.rs
    |
    | uniffi::deps::static_assertions::assert_impl_all!(Counter: Sync, Send);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   | |
-   | `Cell<u32>` cannot be shared between threads safely
-   | required by this bound in `assert_impl_all`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Cell<u32>` cannot be shared between threads safely
    |
    = help: within `Counter`, the trait `Sync` is not implemented for `Cell<u32>`
 note: required because it appears within the type `Counter`
   --> tests/ui/interface_not_sync_and_send.rs:9:12
    |
 9  | pub struct Counter {
    |            ^^^^^^^
+note: required by a bound in `assert_impl_all`
+  --> $OUT_DIR[uniffi_uitests]/counter.uniffi.rs
+   |
+   | uniffi::deps::static_assertions::assert_impl_all!(Counter: Sync, Send);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `assert_impl_all`
    = note: this error originates in the macro `uniffi::deps::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error[E0277]: the trait bound `Arc<Counter>: FfiConverter` is not satisfied
+   --> $OUT_DIR[uniffi_uitests]/counter.uniffi.rs
+    |
+    |         <std::sync::Arc<Counter> as uniffi::FfiConverter>::lower(_arc)
+    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `FfiConverter` is not implemented for `Arc<Counter>`
+    |
+    = help: the following implementations were found:
+              <Arc<T> as FfiConverter>
+note: required by `lower`
+   --> $WORKSPACE/uniffi/src/lib.rs
+    |
+    |     fn lower(obj: Self::RustType) -> Self::FfiType;
+    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0277]: the trait bound `Arc<Counter>: FfiConverter` is not satisfied
   --> $OUT_DIR[uniffi_uitests]/counter.uniffi.rs
    |
    |         <std::sync::Arc<Counter> as uniffi::FfiConverter>::lower(_arc)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `FfiConverter` is not implemented for `Arc<Counter>`
+   |                                                                  ^^^^ the trait `FfiConverter` is not implemented for `Arc<Counter>`
    |
    = help: the following implementations were found:
              <Arc<T> as FfiConverter>
-   = note: required by `lower`
 
 error[E0277]: the trait bound `Arc<Counter>: FfiConverter` is not satisfied
    --> $OUT_DIR[uniffi_uitests]/counter.uniffi.rs
@@ -33,4 +48,17 @@ error[E0277]: the trait bound `Arc<Counter>: FfiConverter` is not satisfied
     |
     = help: the following implementations were found:
               <Arc<T> as FfiConverter>
-    = note: required by `try_lift`
+note: required by `try_lift`
+   --> $WORKSPACE/uniffi/src/lib.rs
+    |
+    |     fn try_lift(v: Self::FfiType) -> Result<Self::RustType>;
+    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `Arc<Counter>: FfiConverter` is not satisfied
+   --> $OUT_DIR[uniffi_uitests]/counter.uniffi.rs
+    |
+    |         match<std::sync::Arc<Counter> as uniffi::FfiConverter>::try_lift(ptr) {
+    |                                                                          ^^^ the trait `FfiConverter` is not implemented for `Arc<Counter>`
+    |
+    = help: the following implementations were found:
+              <Arc<T> as FfiConverter>

rust-toolchain.toml

@@ -5,7 +5,7 @@
 # * ./.circleci/config.yml which also specifies the rust versions used in CI.
 
 [toolchain]
-channel = "1.54.0"
+channel = "1.57.0"
 targets = [
     "aarch64-linux-android",
     "armv7-linux-androideabi",

uniffi/tests/ui/version_mismatch.stderr

@@ -1,7 +1,7 @@
 error[E0080]: evaluation of constant value failed
- --> $DIR/version_mismatch.rs:2:1
+ --> tests/ui/version_mismatch.rs:2:1
   |
 2 | uniffi::assert_compatible_version!("0.0.1"); // An error message would go here.
-  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
   |
   = note: this error originates in the macro `uniffi::deps::static_assertions::const_assert` (in Nightly builds, run with -Z macro-backtrace for more info)

uniffi_bindgen/Cargo.toml

@@ -18,7 +18,7 @@ path = "src/main.rs"
 cargo_metadata = "0.13"
 weedle = "0.12"
 anyhow = "1"
-askama = { version = "0.10", default-features = false, features = ["config"] }
+askama = { version = "0.11", default-features = false, features = ["config"] }
 heck = "0.3"
 clap = { version = "2", default-features = false }
 paste = "1.0"

uniffi_bindgen/src/backend/oracle.rs

@@ -4,7 +4,6 @@
 
 use super::{CodeType, TypeIdentifier};
 use crate::interface::FFIType;
-use std::fmt;
 
 /// An object to look up a foreign language code specific renderer for a given type used.
 /// Every `Type` referred to in the `ComponentInterface` should map to a corresponding
@@ -18,19 +17,19 @@ pub trait CodeOracle {
     fn find(&self, type_: &TypeIdentifier) -> Box<dyn CodeType>;
 
     /// Get the idiomatic rendering of a class name (for enums, records, errors, etc).
-    fn class_name(&self, nm: &dyn fmt::Display) -> String;
+    fn class_name(&self, nm: &str) -> String;
 
     /// Get the idiomatic rendering of a function name.
-    fn fn_name(&self, nm: &dyn fmt::Display) -> String;
+    fn fn_name(&self, nm: &str) -> String;
 
     /// Get the idiomatic rendering of a variable name.
-    fn var_name(&self, nm: &dyn fmt::Display) -> String;
+    fn var_name(&self, nm: &str) -> String;
 
     /// Get the idiomatic rendering of an individual enum variant.
-    fn enum_variant_name(&self, nm: &dyn fmt::Display) -> String;
+    fn enum_variant_name(&self, nm: &str) -> String;
 
     /// Get the idiomatic rendering of an error name.
-    fn error_name(&self, nm: &dyn fmt::Display) -> String;
+    fn error_name(&self, nm: &str) -> String;
 
     fn ffi_type_label(&self, ffi_type: &FFIType) -> String;
 }

uniffi_bindgen/src/backend/types.rs

@@ -32,7 +32,6 @@
 
 use super::{CodeOracle, Literal};
 use crate::interface::*;
-use std::fmt;
 
 /// A Trait to emit foreign language code to handle referenced types.
 /// A type which is specified in the UDL (i.e. a member of the component interface)
@@ -73,33 +72,28 @@ pub trait CodeType {
     /// An expression for lowering a value into something we can pass over the FFI.
     ///
     /// N.B. This should align with the `helper_code` generated by this `CodeType`.
-    fn lower(&self, oracle: &dyn CodeOracle, _nm: &dyn fmt::Display) -> String {
+    fn lower(&self, oracle: &dyn CodeOracle, _nm: &str) -> String {
         unimplemented!("Unimplemented for {}", self.type_label(oracle))
     }
 
     /// An expression for writing a value into a byte buffer.
     ///
     /// N.B. This should align with the `helper_code` generated by this `CodeType`.
-    fn write(
-        &self,
-        oracle: &dyn CodeOracle,
-        _nm: &dyn fmt::Display,
-        _target: &dyn fmt::Display,
-    ) -> String {
+    fn write(&self, oracle: &dyn CodeOracle, _nm: &str, _target: &str) -> String {
         unimplemented!("Unimplemented for {}", self.type_label(oracle))
     }
 
     /// An expression for lifting a value from something we received over the FFI.
     ///
     /// N.B. This should align with the `helper_code` generated by this `CodeType`.
-    fn lift(&self, oracle: &dyn CodeOracle, _nm: &dyn fmt::Display) -> String {
+    fn lift(&self, oracle: &dyn CodeOracle, _nm: &str) -> String {
         unimplemented!("Unimplemented for {}", self.type_label(oracle))
     }
 
     /// An expression for reading a value from a byte buffer.
     ///
     /// N.B. This should align with the `helper_code` generated by this `CodeType`.
-    fn read(&self, oracle: &dyn CodeOracle, _nm: &dyn fmt::Display) -> String {
+    fn read(&self, oracle: &dyn CodeOracle, _nm: &str) -> String {
         unimplemented!("Unimplemented for {}", self.type_label(oracle))
     }
 
@@ -119,7 +113,7 @@ pub trait CodeType {
     }
 
     /// An expression to coerce the given variable to the expected type.
-    fn coerce(&self, oracle: &dyn CodeOracle, _nm: &dyn fmt::Display) -> String {
+    fn coerce(&self, oracle: &dyn CodeOracle, _nm: &str) -> String {
         panic!("Unimplemented for {}", self.type_label(oracle));
     }
 }
@@ -206,24 +200,19 @@ impl<T: CodeTypeDispatch> CodeType for T {
         self.code_type_impl(oracle).literal(oracle, literal)
     }
 
-    fn lower(&self, oracle: &dyn CodeOracle, nm: &dyn fmt::Display) -> String {
+    fn lower(&self, oracle: &dyn CodeOracle, nm: &str) -> String {
         self.code_type_impl(oracle).lower(oracle, nm)
     }
 
-    fn write(
-        &self,
-        oracle: &dyn CodeOracle,
-        nm: &dyn fmt::Display,
-        target: &dyn fmt::Display,
-    ) -> String {
+    fn write(&self, oracle: &dyn CodeOracle, nm: &str, target: &str) -> String {
         self.code_type_impl(oracle).write(oracle, nm, target)
     }
 
-    fn lift(&self, oracle: &dyn CodeOracle, nm: &dyn fmt::Display) -> String {
+    fn lift(&self, oracle: &dyn CodeOracle, nm: &str) -> String {
         self.code_type_impl(oracle).lift(oracle, nm)
     }
 
-    fn read(&self, oracle: &dyn CodeOracle, nm: &dyn fmt::Display) -> String {
+    fn read(&self, oracle: &dyn CodeOracle, nm: &str) -> String {
         self.code_type_impl(oracle).read(oracle, nm)
     }
 

uniffi_bindgen/src/bindings/kotlin/gen_kotlin/compounds.rs

@@ -6,6 +6,7 @@ use super::filters;
 use crate::backend::{CodeOracle, CodeType, Literal, TypeIdentifier};
 use askama::Template;
 use paste::paste;
+use std::borrow::Borrow;
 
 fn render_literal(oracle: &dyn CodeOracle, literal: &Literal, inner: &TypeIdentifier) -> String {
     match literal {

uniffi_bindgen/src/bindings/kotlin/gen_kotlin/custom.rs

@@ -6,6 +6,7 @@ use super::{filters, CustomTypeConfig};
 use crate::backend::{CodeDeclaration, CodeOracle, CodeType, Literal};
 use crate::interface::{FFIType, Type};
 use askama::Template;
+use std::borrow::Borrow;
 
 pub struct CustomCodeType {
     name: String,

uniffi_bindgen/src/bindings/kotlin/gen_kotlin/error.rs

@@ -5,6 +5,7 @@
 use crate::backend::{CodeDeclaration, CodeOracle, CodeType, Literal, TypeIdentifier};
 use crate::interface::{ComponentInterface, Error};
 use askama::Template;
+use std::borrow::Borrow;
 
 use super::filters;
 pub struct ErrorCodeType {

uniffi_bindgen/src/bindings/kotlin/gen_kotlin/mod.rs

@@ -2,8 +2,8 @@
  * 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/. */
 
+use std::borrow::Borrow;
 use std::collections::{HashMap, HashSet};
-use std::fmt;
 
 use anyhow::Result;
 use askama::Template;
@@ -271,22 +271,22 @@ impl CodeOracle for KotlinCodeOracle {
     }
 
     /// Get the idiomatic Kotlin rendering of a class name (for enums, records, errors, etc).
-    fn class_name(&self, nm: &dyn fmt::Display) -> String {
+    fn class_name(&self, nm: &str) -> String {
         nm.to_string().to_camel_case()
     }
 
     /// Get the idiomatic Kotlin rendering of a function name.
-    fn fn_name(&self, nm: &dyn fmt::Display) -> String {
+    fn fn_name(&self, nm: &str) -> String {
         nm.to_string().to_mixed_case()
     }
 
     /// Get the idiomatic Kotlin rendering of a variable name.
-    fn var_name(&self, nm: &dyn fmt::Display) -> String {
+    fn var_name(&self, nm: &str) -> String {
         nm.to_string().to_mixed_case()
     }
 
     /// Get the idiomatic Kotlin rendering of an individual enum variant.
-    fn enum_variant_name(&self, nm: &dyn fmt::Display) -> String {
+    fn enum_variant_name(&self, nm: &str) -> String {
         nm.to_string().to_shouty_snake_case()
     }
 
@@ -295,7 +295,7 @@ impl CodeOracle for KotlinCodeOracle {
     /// This replaces "Error" at the end of the name with "Exception".  Rust code typically uses
     /// "Error" for any type of error but in the Java world, "Error" means a non-recoverable error
     /// and is distinguished from an "Exception".
-    fn error_name(&self, nm: &dyn fmt::Display) -> String {
+    fn error_name(&self, nm: &str) -> String {
         let name = nm.to_string();
         match name.strip_suffix("Error") {
             None => name,
@@ -328,7 +328,6 @@ impl CodeOracle for KotlinCodeOracle {
 
 pub mod filters {
     use super::*;
-    use std::fmt;
 
     // This code is a bit unfortunate.  We want to have a `KotlinCodeOracle` instance available for
     // the filter functions, so that we don't always need to pass as an argument in the template
@@ -397,22 +396,22 @@ pub mod filters {
     }
 
     /// Get the idiomatic Kotlin rendering of a class name (for enums, records, errors, etc).
-    pub fn class_name(nm: &dyn fmt::Display) -> Result<String, askama::Error> {
+    pub fn class_name(nm: &str) -> Result<String, askama::Error> {
         Ok(oracle().class_name(nm))
     }
 
     /// Get the idiomatic Kotlin rendering of a function name.
-    pub fn fn_name(nm: &dyn fmt::Display) -> Result<String, askama::Error> {
+    pub fn fn_name(nm: &str) -> Result<String, askama::Error> {
         Ok(oracle().fn_name(nm))
     }
 
     /// Get the idiomatic Kotlin rendering of a variable name.
-    pub fn var_name(nm: &dyn fmt::Display) -> Result<String, askama::Error> {
+    pub fn var_name(nm: &str) -> Result<String, askama::Error> {
         Ok(oracle().var_name(nm))
     }
 
     /// Get the idiomatic Kotlin rendering of an individual enum variant.
-    pub fn enum_variant(nm: &dyn fmt::Display) -> Result<String, askama::Error> {
+    pub fn enum_variant(nm: &str) -> Result<String, askama::Error> {
         Ok(oracle().enum_variant_name(nm))
     }
 
@@ -421,7 +420,7 @@ pub mod filters {
     /// This replaces "Error" at the end of the name with "Exception".  Rust code typically uses
     /// "Error" for any type of error but in the Java world, "Error" means a non-recoverable error
     /// and is distinguished from an "Exception".
-    pub fn exception_name(nm: &dyn fmt::Display) -> Result<String, askama::Error> {
+    pub fn exception_name(nm: &str) -> Result<String, askama::Error> {
         Ok(oracle().error_name(nm))
     }
 }

uniffi_bindgen/src/bindings/kotlin/templates/CustomTypeTemplate.kt

@@ -8,7 +8,7 @@ public typealias {{ name }} = {{ builtin|type_name }}
 
 {%- when Some with (config) %}
 {%- let type_name=self.type_name(config) %}
-{%- let ffi_type_name=self.builtin_ffi_type()|ffi_type_name %}
+{%- let ffi_type_name=self.builtin_ffi_type().borrow()|ffi_type_name %}
 
 {#- Create a typealias so that this type can be imported when used as an external type #}
 public typealias {{ name }} = {{ type_name }}

uniffi_bindgen/src/bindings/kotlin/templates/ErrorTemplate.kt

@@ -57,7 +57,7 @@ public object {{ e|ffi_converter_name }} : FfiConverterRustBuffer<{{ type_name }
         {% if e.is_flat() %}
             return when(buf.getInt()) {
             {%- for variant in e.variants() %}
-            {{ loop.index }} -> {{ type_name }}.{{ variant.name()|exception_name }}({{ TypeIdentifier::String|read_fn }}(buf))
+            {{ loop.index }} -> {{ type_name }}.{{ variant.name()|exception_name }}({{ TypeIdentifier::String.borrow()|read_fn }}(buf))
             {%- endfor %}
             else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
         }

uniffi_bindgen/src/bindings/kotlin/templates/Helpers.kt

@@ -43,7 +43,7 @@ private inline fun <U, E: Exception> rustCallWithError(errorHandler: CallStatusE
         // with the message.  but if that code panics, then it just sends back
         // an empty buffer.
         if (status.error_buf.len > 0) {
-            throw InternalException({{ TypeIdentifier::String|lift_fn }}(status.error_buf))
+            throw InternalException({{ TypeIdentifier::String.borrow()|lift_fn }}(status.error_buf))
         } else {
             throw InternalException("Rust panic")
         }