From 7e227907fe5d293b2d7620602d48ffba94e35dc5 Mon Sep 17 00:00:00 2001
From: René Kijewski <kijewski@library.vetmed.fu-berlin.de>
Date: Thu, 1 Jul 2021 18:29:48 +0200
Subject: Implement destructoring of structs

This PR implements the destructoring of structs on the lhs of "let" and
"for" statements.
---
 testing/tests/let_destructoring.rs | 107 +++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 testing/tests/let_destructoring.rs

(limited to 'testing/tests')

diff --git a/testing/tests/let_destructoring.rs b/testing/tests/let_destructoring.rs
new file mode 100644
index 0000000..20f7fff
--- /dev/null
+++ b/testing/tests/let_destructoring.rs
@@ -0,0 +1,107 @@
+use askama::Template;
+
+#[derive(Template)]
+#[template(source = "{% let (a, b, c) = v %}{{a}}{{b}}{{c}}", ext = "txt")]
+struct LetDestructoringTuple {
+    v: (i32, i32, i32),
+}
+
+#[test]
+fn test_let_destruct_tuple() {
+    let t = LetDestructoringTuple { v: (1, 2, 3) };
+    assert_eq!(t.render().unwrap(), "123");
+}
+
+struct UnnamedStruct(i32, i32, i32);
+
+#[derive(Template)]
+#[template(
+    source = "{% let UnnamedStruct(a, b, c) = v %}{{a}}{{b}}{{c}}",
+    ext = "txt"
+)]
+struct LetDestructoringUnnamedStruct {
+    v: UnnamedStruct,
+}
+
+#[test]
+fn test_let_destruct_unnamed_struct() {
+    let t = LetDestructoringUnnamedStruct {
+        v: UnnamedStruct(1, 2, 3),
+    };
+    assert_eq!(t.render().unwrap(), "123");
+}
+
+#[derive(Template)]
+#[template(
+    source = "{% let UnnamedStruct(a, b, c) = v %}{{a}}{{b}}{{c}}",
+    ext = "txt"
+)]
+struct LetDestructoringUnnamedStructRef<'a> {
+    v: &'a UnnamedStruct,
+}
+
+#[test]
+fn test_let_destruct_unnamed_struct_ref() {
+    let v = UnnamedStruct(1, 2, 3);
+    let t = LetDestructoringUnnamedStructRef { v: &v };
+    assert_eq!(t.render().unwrap(), "123");
+}
+
+struct NamedStruct {
+    a: i32,
+    b: i32,
+    c: i32,
+}
+
+#[derive(Template)]
+#[template(
+    source = "{% let NamedStruct { a, b: d, c } = v %}{{a}}{{d}}{{c}}",
+    ext = "txt"
+)]
+struct LetDestructoringNamedStruct {
+    v: NamedStruct,
+}
+
+#[test]
+fn test_let_destruct_named_struct() {
+    let t = LetDestructoringNamedStruct {
+        v: NamedStruct { a: 1, b: 2, c: 3 },
+    };
+    assert_eq!(t.render().unwrap(), "123");
+}
+
+#[derive(Template)]
+#[template(
+    source = "{% let NamedStruct { a, b: d, c } = v %}{{a}}{{d}}{{c}}",
+    ext = "txt"
+)]
+struct LetDestructoringNamedStructRef<'a> {
+    v: &'a NamedStruct,
+}
+
+#[test]
+fn test_let_destruct_named_struct_ref() {
+    let v = NamedStruct { a: 1, b: 2, c: 3 };
+    let t = LetDestructoringNamedStructRef { v: &v };
+    assert_eq!(t.render().unwrap(), "123");
+}
+
+mod some {
+    pub mod path {
+        pub struct Struct<'a>(pub &'a str);
+    }
+}
+
+#[derive(Template)]
+#[template(source = "{% let some::path::Struct(v) = v %}{{v}}", ext = "txt")]
+struct LetDestructoringWithPath<'a> {
+    v: some::path::Struct<'a>,
+}
+
+#[test]
+fn test_let_destruct_with_path() {
+    let t = LetDestructoringWithPath {
+        v: some::path::Struct("hello"),
+    };
+    assert_eq!(t.render().unwrap(), "hello");
+}
-- 
cgit