From f4b9841590f93dc20249115c3041ec1646084c5c Mon Sep 17 00:00:00 2001
From: Jonas Platte <jplatte+git@posteo.de>
Date: Fri, 24 Apr 2020 22:30:22 +0200
Subject: [PATCH] Fix json escaping breaking login endpoint

---
 src/r0/session/login.rs            | 23 +++-------------
 src/r0/session/login/user_serde.rs | 42 ++++++++++++------------------
 2 files changed, 19 insertions(+), 46 deletions(-)

diff --git a/src/r0/session/login.rs b/src/r0/session/login.rs
index ab7af74d..0028318f 100644
--- a/src/r0/session/login.rs
+++ b/src/r0/session/login.rs
@@ -2,7 +2,7 @@
 
 use ruma_api::ruma_api;
 use ruma_identifiers::{DeviceId, UserId};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 
 use crate::r0::thirdparty::Medium;
 
@@ -58,7 +58,8 @@ ruma_api! {
 }
 
 /// Identification information for the user.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(from = "user_serde::UserInfo", into = "user_serde::UserInfo")]
 pub enum UserInfo {
     /// Either a fully qualified Matrix user ID, or just the localpart (as part of the 'identifier'
     /// field).
@@ -125,24 +126,6 @@ pub struct IdentityServerInfo {
 
 mod user_serde;
 
-impl Serialize for UserInfo {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        user_serde::UserInfo::from(self).serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for UserInfo {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        user_serde::UserInfo::deserialize(deserializer).map(Into::into)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::convert::TryInto;
diff --git a/src/r0/session/login/user_serde.rs b/src/r0/session/login/user_serde.rs
index f7568789..9673f8d1 100644
--- a/src/r0/session/login/user_serde.rs
+++ b/src/r0/session/login/user_serde.rs
@@ -8,35 +8,31 @@ use super::Medium;
 // The following three structs could just be used in place of the one in the parent module, but
 // that one is arguably much easier to deal with.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-pub(crate) struct UserInfo<'a> {
-    #[serde(borrow)]
-    pub identifier: UserIdentifier<'a>,
+pub(crate) struct UserInfo {
+    pub identifier: UserIdentifier,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(tag = "type")]
-pub(crate) enum UserIdentifier<'a> {
+pub(crate) enum UserIdentifier {
     #[serde(rename = "m.id.user")]
-    MatrixId { user: &'a str },
+    MatrixId { user: String },
     #[serde(rename = "m.id.thirdparty")]
-    ThirdPartyId { medium: Medium, address: &'a str },
+    ThirdPartyId { medium: Medium, address: String },
     #[serde(rename = "m.id.phone")]
-    PhoneNumber { country: &'a str, phone: &'a str },
+    PhoneNumber { country: String, phone: String },
 }
 
-impl<'a> From<&'a super::UserInfo> for UserInfo<'a> {
-    fn from(su: &'a super::UserInfo) -> Self {
+impl From<super::UserInfo> for UserInfo {
+    fn from(info: super::UserInfo) -> Self {
         use super::UserInfo::*;
 
-        match su {
+        match info {
             MatrixId(user) => UserInfo {
                 identifier: UserIdentifier::MatrixId { user },
             },
             ThirdPartyId { address, medium } => UserInfo {
-                identifier: UserIdentifier::ThirdPartyId {
-                    address,
-                    medium: *medium,
-                },
+                identifier: UserIdentifier::ThirdPartyId { address, medium },
             },
             PhoneNumber { country, phone } => UserInfo {
                 identifier: UserIdentifier::PhoneNumber { country, phone },
@@ -45,20 +41,14 @@ impl<'a> From<&'a super::UserInfo> for UserInfo<'a> {
     }
 }
 
-impl Into<super::UserInfo> for UserInfo<'_> {
-    fn into(self) -> super::UserInfo {
+impl From<UserInfo> for super::UserInfo {
+    fn from(info: UserInfo) -> super::UserInfo {
         use super::UserInfo::*;
 
-        match self.identifier {
-            UserIdentifier::MatrixId { user } => MatrixId(user.to_owned()),
-            UserIdentifier::ThirdPartyId { address, medium } => ThirdPartyId {
-                address: address.to_owned(),
-                medium: medium.to_owned(),
-            },
-            UserIdentifier::PhoneNumber { country, phone } => PhoneNumber {
-                country: country.to_owned(),
-                phone: phone.to_owned(),
-            },
+        match info.identifier {
+            UserIdentifier::MatrixId { user } => MatrixId(user),
+            UserIdentifier::ThirdPartyId { address, medium } => ThirdPartyId { address, medium },
+            UserIdentifier::PhoneNumber { country, phone } => PhoneNumber { country, phone },
         }
     }
 }