Introduce DiplomatStr16 (#368)

core/src/ast/mod.rs

@@ -19,7 +19,8 @@ pub use enums::Enum;
 
 mod types;
 pub use types::{
-    CustomType, LifetimeOrigin, ModSymbol, Mutability, PathType, PrimitiveType, TypeName,
+    CustomType, LifetimeOrigin, ModSymbol, Mutability, PathType, PrimitiveType, StringEncoding,
+    TypeName,
 };
 
 mod lifetimes;

core/src/ast/types.rs

@@ -382,7 +382,7 @@ pub enum TypeName {
     Result(Box<TypeName>, Box<TypeName>, bool),
     Writeable,
     /// A `&DiplomatStr` type.
-    StrReference(Lifetime),
+    StrReference(Lifetime, StringEncoding),
     /// A `&[T]` type, where `T` is a primitive.
     PrimitiveSlice(Lifetime, Mutability, PrimitiveType),
     /// The `()` type.
@@ -391,6 +391,13 @@ pub enum TypeName {
     SelfType(PathType),
 }
 
+#[derive(Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Debug, Copy)]
+#[non_exhaustive]
+pub enum StringEncoding {
+    UnvalidatedUtf8,
+    UnvalidatedUtf16,
+}
+
 impl TypeName {
     /// Converts the [`TypeName`] back into an AST node that can be spliced into a program.
     pub fn to_syn(&self) -> syn::Type {
@@ -493,11 +500,20 @@ impl TypeName {
             TypeName::Writeable => syn::parse_quote! {
                 diplomat_runtime::DiplomatWriteable
             },
-            TypeName::StrReference(lifetime) => syn::parse_str(&format!(
-                "{}DiplomatStr",
-                ReferenceDisplay(lifetime, &Mutability::Immutable)
-            ))
-            .unwrap(),
+            TypeName::StrReference(lifetime, StringEncoding::UnvalidatedUtf8) => {
+                syn::parse_str(&format!(
+                    "{}DiplomatStr",
+                    ReferenceDisplay(lifetime, &Mutability::Immutable)
+                ))
+                .unwrap()
+            }
+            TypeName::StrReference(lifetime, StringEncoding::UnvalidatedUtf16) => {
+                syn::parse_str(&format!(
+                    "{}DiplomatStr16",
+                    ReferenceDisplay(lifetime, &Mutability::Immutable)
+                ))
+                .unwrap()
+            }
             TypeName::PrimitiveSlice(lifetime, mutability, name) => {
                 let primitive_name = PRIMITIVE_TO_STRING.get(name).unwrap();
                 let formatted_str = format!(
@@ -532,11 +548,16 @@ impl TypeName {
                 let lifetime = Lifetime::from(&r.lifetime);
                 let mutability = Mutability::from_syn(&r.mutability);
 
-                if r.elem.to_token_stream().to_string() == "DiplomatStr" {
+                let name = r.elem.to_token_stream().to_string();
+                if name.starts_with("DiplomatStr") {
                     if mutability.is_mutable() {
-                        panic!("mutable `DiplomatStr` references are disallowed");
+                        panic!("mutable `DiplomatStr*` references are disallowed");
+                    }
+                    if name == "DiplomatStr" {
+                        return TypeName::StrReference(lifetime, StringEncoding::UnvalidatedUtf8);
+                    } else if name == "DiplomatStr16" {
+                        return TypeName::StrReference(lifetime, StringEncoding::UnvalidatedUtf16);
                     }
-                    return TypeName::StrReference(lifetime);
                 }
                 if let syn::Type::Slice(slice) = &*r.elem {
                     if let syn::Type::Path(p) = &*slice.elem {
@@ -657,7 +678,7 @@ impl TypeName {
                 ok.visit_lifetimes(visit)?;
                 err.visit_lifetimes(visit)
             }
-            TypeName::StrReference(lt) => visit(lt, LifetimeOrigin::StrReference),
+            TypeName::StrReference(lt, ..) => visit(lt, LifetimeOrigin::StrReference),
             TypeName::PrimitiveSlice(lt, ..) => visit(lt, LifetimeOrigin::PrimitiveSlice),
             _ => ControlFlow::Continue(()),
         }
@@ -866,7 +887,7 @@ impl TypeName {
                 ok.check_lifetime_elision(full_type, in_path, env, errors);
                 err.check_lifetime_elision(full_type, in_path, env, errors);
             }
-            TypeName::StrReference(Lifetime::Anonymous)
+            TypeName::StrReference(Lifetime::Anonymous, ..)
             | TypeName::PrimitiveSlice(Lifetime::Anonymous, ..) => {
                 errors.push(ValidityError::LifetimeElisionInReturn {
                     full_type: full_type.clone(),
@@ -916,13 +937,20 @@ impl fmt::Display for TypeName {
                 write!(f, "Result<{ok}, {err}>")
             }
             TypeName::Writeable => "DiplomatWriteable".fmt(f),
-            TypeName::StrReference(lifetime) => {
+            TypeName::StrReference(lifetime, StringEncoding::UnvalidatedUtf8) => {
                 write!(
                     f,
                     "{}DiplomatStr",
                     ReferenceDisplay(lifetime, &Mutability::Immutable)
                 )
             }
+            TypeName::StrReference(lifetime, StringEncoding::UnvalidatedUtf16) => {
+                write!(
+                    f,
+                    "{}DiplomatStr16",
+                    ReferenceDisplay(lifetime, &Mutability::Immutable)
+                )
+            }
             TypeName::PrimitiveSlice(lifetime, mutability, typ) => {
                 write!(f, "{}[{typ}]", ReferenceDisplay(lifetime, mutability))
             }

core/src/hir/lowering.rs

@@ -466,9 +466,10 @@ impl<'ast, 'errors> LoweringContext<'ast, 'errors> {
                 ));
                 None
             }
-            ast::TypeName::StrReference(lifetime) => {
-                Some(Type::Slice(Slice::Str(ltl?.lower_lifetime(lifetime))))
-            }
+            ast::TypeName::StrReference(lifetime, encoding) => Some(Type::Slice(Slice::Str(
+                ltl?.lower_lifetime(lifetime),
+                *encoding,
+            ))),
             ast::TypeName::PrimitiveSlice(lifetime, mutability, prim) => {
                 let borrow = Borrow::new(ltl?.lower_lifetime(lifetime), *mutability);
                 let prim = PrimitiveType::from_ast(*prim);
@@ -658,9 +659,10 @@ impl<'ast, 'errors> LoweringContext<'ast, 'errors> {
                 ));
                 None
             }
-            ast::TypeName::StrReference(lifetime) => {
-                Some(OutType::Slice(Slice::Str(ltl?.lower_lifetime(lifetime))))
-            }
+            ast::TypeName::StrReference(lifetime, encoding) => Some(OutType::Slice(Slice::Str(
+                ltl?.lower_lifetime(lifetime),
+                *encoding,
+            ))),
             ast::TypeName::PrimitiveSlice(lifetime, mutability, prim) => {
                 let borrow = Borrow::new(ltl?.lower_lifetime(lifetime), *mutability);
                 let prim = PrimitiveType::from_ast(*prim);

core/src/hir/snapshots/diplomat_core__hir__elision__tests__simple_mod.snap

@@ -67,6 +67,7 @@ TypeContext {
                                             0,
                                         ),
                                     ),
+                                    UnvalidatedUtf8,
                                 ),
                             ),
                         },
@@ -128,6 +129,7 @@ TypeContext {
                                     0,
                                 ),
                             ),
+                            UnvalidatedUtf8,
                         ),
                     ),
                 },
@@ -179,6 +181,7 @@ TypeContext {
                                             1,
                                         ),
                                     ),
+                                    UnvalidatedUtf8,
                                 ),
                             ),
                         },
@@ -193,6 +196,7 @@ TypeContext {
                                                 1,
                                             ),
                                         ),
+                                        UnvalidatedUtf8,
                                     ),
                                 ),
                             ),

core/src/hir/types.rs

@@ -6,6 +6,7 @@ use super::{
 };
 use crate::ast;
 pub use ast::Mutability;
+pub use ast::StringEncoding;
 
 /// Type that can only be used as an output.
 pub type OutType = Type<OutputOnly>;
@@ -34,7 +35,7 @@ pub enum SelfType {
 #[non_exhaustive]
 pub enum Slice {
     /// A string slice, e.g. `&DiplomatStr`.
-    Str(MaybeStatic<TypeLifetime>),
+    Str(MaybeStatic<TypeLifetime>, StringEncoding),
 
     /// A primitive slice, e.g. `&mut [u8]`.
     Primitive(Borrow, PrimitiveType),
@@ -89,8 +90,8 @@ impl Slice {
     /// variant.
     pub fn lifetime(&self) -> &MaybeStatic<TypeLifetime> {
         match self {
-            Slice::Str(lifetime) => lifetime,
-            Slice::Primitive(reference, _) => &reference.lifetime,
+            Slice::Str(lifetime, ..) => lifetime,
+            Slice::Primitive(reference, ..) => &reference.lifetime,
         }
     }
 }