What causes "keyword argument repeated: `server`" in leptos-rs/leptos?

Remove the duplicate `server = ...` entry, keeping the intended override.

keyword argument repeated: `server`

Error message

keyword argument repeated: `server`

What it means

The #[server] macro parser throws this when the `server` keyword argument appears more than once. `server` overrides the server-side function/block used to run the handler; duplicates are ambiguous, so the attribute parser rejects them at compile time.

Source

Thrown at server_fn_macro/src/lib.rs:1141

                        }
                        input = Some(stream.parse()?);
                    } else if key == "input_derive" {
                        if input_derive.is_some() {
                            return Err(syn::Error::new(
                                key.span(),
                                "keyword argument repeated: `input_derive`",
                            ));
                        }
                        input_derive = Some(stream.parse()?);
                    } else if key == "output" {
                        if encoding.is_some() {
                            return Err(syn::Error::new(
                                key.span(),
                                "`encoding` and `output` should not both be \
                                 specified",
                            ));
                        } else if output.is_some() {
                            return Err(syn::Error::new(
                                key.span(),
                                "keyword argument repeated: `output`",
                            ));
                        }
                        output = Some(stream.parse()?);
                    } else if key == "server" {
                        if server.is_some() {
                            return Err(syn::Error::new(
                                key.span(),
                                "keyword argument repeated: `server`",
                            ));
                        }
                        server = Some(stream.parse()?);
                    } else if key == "client" {
                        if client.is_some() {
                            return Err(syn::Error::new(
                                key.span(),
                                "keyword argument repeated: `client`",

View on GitHub (pinned to 32d20f6c9d)

Solutions

Remove the duplicate `server = ...` entry, keeping the intended override.
If no override is needed, drop all `server` args to use the default behavior.
Adjust macro wrappers to emit `server` only when the caller did not.

Example fix

// before
#[server(server = crate::custom_server, server = crate::other_server)]
async fn save(data: String) -> Result<(), ServerFnError> { todo!() }

// after
#[server(server = crate::custom_server)]
async fn save(data: String) -> Result<(), ServerFnError> { todo!() }

Defensive patterns

Strategy: validation

Validate before calling

// Pre-commit check for duplicate `server` args:
// grep -rnE '#\[server\([^)\n]*server\s*=[^)\n]*server\s*=' src/ && exit 1 || exit 0

Prevention

Only one `server = ...` override per attribute.
Centralize the server override path in a constant to avoid divergent copies.
When changing overrides, delete the old entry in the same commit.
Run cargo check locally and in CI; these errors are compile-time only.

When it happens

Trigger: Writing #[server(server = path1, server = path2)] in one attribute, or a macro wrapper adding a `server` override on top of a user-supplied one.

Common situations: Copy-pasting args, refactoring where the server override path changed and both lines stayed, layered macro_rules! wrappers each injecting `server`.

Related errors

AI-assisted analysis of leptos-rs/leptos@32d20f6c9d (2026-09-01). Data as JSON: /api/errors/4b229116f7dcd21d. Report an issue: GitHub.