recursive use of an object detected which would lead to unsafe aliasing in rust

[RedstoneWizard08]

Summary

When I call a method from JavaScript, it throws the error "recursive use of an object detected which would lead to unsafe aliasing in rust." How can I fix this?

Additional Details

Similar to #1578 (closed)

Here's the code causing this (note that I am using a custom version of anyhow to add wasm support):

//! crates/core/src/services/tasks/save.rs

use anyhow::Result;
use serde_json::Value;

use crate::{impl_save_fn, models::Task, services::POSTGREST};

impl_save_fn!(Task, "tasks");

//! crates/core/src/macros/funcs/save.rs

#[macro_export]
macro_rules! impl_save_fn {
    ($struct_: ident, $table: expr) => {
        impl $struct_ {
            async fn insert(&mut self, token: String) -> Result<()> {
                let client = POSTGREST.from($table).auth(token);
                let encoded = serde_json::to_string(&self)?;
                let res = client.insert(encoded).execute().await?;
                let data = res.text().await?;
                let data = serde_json::from_str::<Value>(&data)?;
                let id = data.get("id");

                if let Some(id) = id {
                    let id = id
                        .as_i64()
                        .ok_or(anyhow!("Cannot convert Value to i64!"))?;

                    self.id = Some(id as i32);

                    return Ok(());
                } else {
                    let data = data
                        .as_array()
                        .ok_or(anyhow!("Cannot convert Value to Vec<Value>!"))?;

                    let data = data
                        .get(0)
                        .ok_or(anyhow!(
                            "Index 0 out of bounds for Vec<Value> of length {}!",
                            data.len()
                        ))?
                        .clone();
                        
                    let id = data
                        .get("id")
                        .ok_or(anyhow!("Cannot get ID from response data!"))?
                        .as_i64()
                        .ok_or(anyhow!("Cannot convert Value to i64!"))?;

                    self.id = Some(id as i32);

                    return Ok(());
                }
            }
        }

        #[wasm_bindgen]
        impl $struct_ {
            pub async fn save(&mut self, token: String) -> Result<()> {
                let client = POSTGREST.from($table).auth(&token);

                let existing = client
                    .clone()
                    .eq("user_id", self.user_id.clone())
                    .select("*")
                    .execute()
                    .await?;

                let data = existing.text().await?;
                let data = serde_json::from_str::<Value>(&data)?;

                let data = data
                    .as_array()
                    .ok_or(anyhow!("Cannot convert Value to Vec<Value>!"));

                let encoded = serde_json::to_string(&self)?;

                if let Ok(data) = data {
                    if data.is_empty() {
                        return self.insert(token).await;
                    }

                    let res = client
                        .eq("user_id", self.user_id.clone())
                        .update(encoded)
                        .execute()
                        .await?;

                    let data = res.text().await?;

                    let data = serde_json::from_str::<Value>(&data)?
                        .as_array()
                        .ok_or(anyhow!("Cannot convert Value to Vec<Value>!"))?
                        .clone();

                    let data = data
                        .get(0)
                        .ok_or(anyhow!(
                            "Index 0 out of bounds for Vec<Value> of length {}!",
                            data.len()
                        ))?
                        .clone();

                    let id = data
                        .get("id")
                        .ok_or(anyhow!("Cannot get ID from response data!"))?
                        .as_i64()
                        .ok_or(anyhow!("Cannot convert Value to i64!"))?;

                    self.id = Some(id as i32);

                    return Ok(());
                }

                self.insert(token).await
            }
        }
    };
}

<!-- apps/planner/src/App.svelte -->

<script lang="ts">
    import init from "...";
    import { initializeAuth, initializeTheme } from "./lib";

    const initialize = async () => {
        await init();
        await initializeAuth();

        initializeTheme();
    };

    initialize();
</script>

<!-- ... -->

// apps/planner/src/lib/auth.ts

export const initializeAuth = async () => {
    // ...

    if (token) {
        // ...

        await postLogin();
    }
};

export const postLogin = async () => {
    // ...

    tasks.subscribe(async (ts) => {
        for (const val of ts.values()) {
            for (const task of val) {
                await task.save(get(accessToken)!);
            }
        }
    });
};

# crates/core/Cargo.toml
# ...
[dependencies]
# ...
serde-wasm-bindgen = "0.6.0"
wasm-bindgen = "0.2.87"
wasm-bindgen-futures = "0.4.37"
# ...

[RedstoneWizard08]

Bump...? Not trying to be rude or anything but I am kind of under a deadline. (This is a school project)

[sezna]

Have you tried eliminating the &mut self, instead rewriting it such that it returns a new instance of Task?

[RedstoneWizard08]

Interesting... maybe I'll try that with a .clone() to keep it in the macro so I reduce code duplication

[RedstoneWizard08]

Just updated it to look like this:

Updated code

#[macro_export]
macro_rules! impl_save_fn {
    ($struct_: ident, $table: expr) => {
        impl $struct_ {
            async fn insert(&mut self, token: String) -> Result<()> {
                let client = POSTGREST.from($table).auth(token);
                let encoded = serde_json::to_string(&self)?;
                let res = client.insert(encoded).execute().await?;
                let data = res.text().await?;
                let data = serde_json::from_str::<Value>(&data)?;
                let id = data.get("id");

                if let Some(id) = id {
                    let id = id.as_i64().ok_or(anyhow!("Cannot convert Value to i64!"))?;

                    self.id = Some(id as i32);

                    return Ok(());
                } else {
                    let data = data
                        .as_array()
                        .ok_or(anyhow!("Cannot convert Value to Vec<Value>!"))?;

                    let data = data
                        .get(0)
                        .ok_or(anyhow!(
                            "Index 0 out of bounds for Vec<Value> of length {}!",
                            data.len()
                        ))?
                        .clone();

                    let id = data
                        .get("id")
                        .ok_or(anyhow!("Cannot get ID from response data!"))?
                        .as_i64()
                        .ok_or(anyhow!("Cannot convert Value to i64!"))?;

                    self.id = Some(id as i32);

                    return Ok(());
                }
            }
        }

        #[wasm_bindgen]
        impl $struct_ {
            pub async fn save(&self, token: String) -> Result<$struct_> {
                let mut me = self.clone();
                let client = POSTGREST.from($table).auth(&token);

                let existing = client
                    .clone()
                    .eq("user_id", me.user_id.clone())
                    .select("*")
                    .execute()
                    .await?;

                let data = existing.text().await?;
                let data = serde_json::from_str::<Value>(&data)?;

                let data = data
                    .as_array()
                    .ok_or(anyhow!("Cannot convert Value to Vec<Value>!"));

                let encoded = serde_json::to_string(&me)?;

                if let Ok(data) = data {
                    if data.is_empty() {
                        me.insert(token).await?;

                        return Ok(self.clone());
                    }

                    let res = client
                        .eq("user_id", me.user_id.clone())
                        .update(encoded)
                        .execute()
                        .await?;

                    let data = res.text().await?;

                    let data = serde_json::from_str::<Value>(&data)?
                        .as_array()
                        .ok_or(anyhow!("Cannot convert Value to Vec<Value>!"))?
                        .clone();

                    let data = data
                        .get(0)
                        .ok_or(anyhow!(
                            "Index 0 out of bounds for Vec<Value> of length {}!",
                            data.len()
                        ))?
                        .clone();

                    let id = data
                        .get("id")
                        .ok_or(anyhow!("Cannot get ID from response data!"))?
                        .as_i64()
                        .ok_or(anyhow!("Cannot convert Value to i64!"))?;

                    me.id = Some(id as i32);

                    return Ok(self.clone());
                }

                me.insert(token).await?;

                Ok(self.clone())
            }
        }
    };
}

Testing it now.

[RedstoneWizard08]

Seems like that fixed it! Thanks!

[AngeloD2022]

I tried your solution but I am getting issues with the self clone.

async fn do_something(&self) -> Result<(), CustomError> {
    let mut me = self.clone();
    let result = me.protocol.request_payload();
    // ...
}

cannot borrow `me.protocol` as mutable, as it is behind a `&` reference