Fix E0062: Expected field literal or dotdot in struct initialization

By Alex Chen
Rust beginner Linux macOS Windows WebAssembly

1. Symptoms

The Rust compiler emits error E0062 when you attempt to initialize a struct using the struct update syntax (..) but provide an expression that the compiler cannot interpret as either a field literal or another struct instance. This error typically manifests during compilation and prevents the program from building successfully.

The compiler output for this error looks similar to the following:

error[E0062]: expected field literal or dotdot, found `y: 20`
  --> src/main.rs:5:24
   |
5  |     let p = Point { x: 10, ..y: 20 };
   |                         -----^^^^ expected field literal or dotdot
   |
   = note: the `..` must always come last
   = help: remove the extra `..`

In some variations of this error, you might see different expressions triggering the same diagnostic:

error[E0062]: expected field literal or dotdot, found `some_value`
  --> src/main.rs:7:29
   |
7  |     let p = Point { ..base, x: 10 };
   |                         -^^^^^^ expected field literal or dotdot
   |
   = note: the `..` must always come last

The error message always includes the phrase “expected field literal or dotdot” and indicates the exact position where the parser encountered unexpected content. The note section clarifies that the struct update syntax must always appear at the end of the field list.

2. Root Cause

Error E0062 stems from a misunderstanding of how the struct update syntax works in Rust. The .. syntax is a special feature that allows you to copy some or all fields from an existing struct instance while overriding specific fields with new values. This mechanism is particularly useful when working with immutable data structures where you want to create a modified copy.

The struct update syntax follows strict rules regarding its position and what can follow it. According to the Rust language reference, the .. syntax must appear only once in a struct literal, and it must always be the last element in the field list. The expression following .. must be a valid expression that evaluates to a struct instance of the same type (or a compatible type for struct update syntax with compatible fields).

When you write something like Point { x: 10, ..y: 20 }, the compiler interprets y: 20 as attempting to define a new field named y with value 20. However, this syntax is invalid because the .. operator has already been used, and Rust only allows either individual field assignments or a struct update expressionβ€”not both in the same position. The parser expects either another field name with its value or the struct update syntax with a reference to an existing struct.

Another common scenario triggering this error involves placing the struct update syntax before regular field assignments:

let p = Point { ..base, x: 10 };

Here, the parser has already consumed the struct update syntax and expects no further field assignments. The x: 10 that follows violates this expectation because the .. must always come last in the initialization expression.

3. Step-by-Step Fix

The fix for E0062 depends on your intended goal. Identify whether you want to initialize a struct from scratch or create a modified copy of an existing struct, then apply the appropriate syntax.

Before:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let base = Point { x: 10, y: 20 };
    
    // Incorrect: mixing field syntax with what looks like field syntax after ..
    let p = Point { x: 10, ..y: 20 };
}

The code above attempts to use .. followed by what appears to be a field definition. This is invalid syntax because the parser cannot distinguish between a struct update and a field definition after the .. operator has been consumed.

After:

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    // Option 1: Initialize all fields explicitly
    let p = Point { x: 10, y: 20 };
}

If you intended to initialize the struct with both fields specified directly, remove the struct update syntax entirely and provide all field values explicitly. This approach works when you have no existing struct to copy from.

Alternative After (with struct update syntax):

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    // Option 2: Use struct update syntax correctly
    let base = Point { x: 10, y: 20 };
    let p = Point { x: 5, ..base };
}

When you have an existing struct instance and want to create a modified copy, place the .. syntax last in the field list, followed by the variable name that holds the source struct. The fields specified before .. will override the corresponding values in the source struct.

Before (struct update in wrong position):

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let base = Point { x: 10, y: 20 };
    let p = Point { ..base, x: 5 };
}

After (struct update at the end):

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let base = Point { x: 10, y: 20 };
    let p = Point { x: 5, ..base };
}

If you placed the .. syntax before other field assignments, move the .. expression to the end of the field list. The struct update syntax must always be the final element in the struct literal.

4. Verification

After applying the fix, compile your Rust project to confirm the error has been resolved. Use the standard compilation workflow for your project setup.

For a simple binary project, run the following command:

cargo build

For a library project, use:

cargo build --lib

If the fix is correct, the build should complete successfully without any E0062 errors. You can also run tests to ensure the functionality remains intact:

cargo test

To verify the compiled code works as expected, execute the binary if you have a runnable program:

cargo run

The successful compilation confirms that the struct initialization syntax is now valid. If you still see E0062 or other errors, review the struct literal carefully to ensure the .. operator appears exactly once and only at the end of the field list.

5. Common Pitfalls

Several recurring mistakes lead to E0062 in practice. Understanding these pitfalls helps you avoid triggering the error and enables faster debugging when it does occur.

The first common pitfall involves attempting to use struct update syntax to assign a simple value to a field. Developers coming from other programming languages sometimes assume that ..field: value would work similarly to other update mechanisms. In Rust, the struct update syntax only accepts a struct instance (or expression evaluating to a struct) after the .., not arbitrary field assignments.

The second pitfall involves incorrect ordering of fields relative to the .. operator. The struct update syntax must always come last, but developers occasionally place it before fields they want to override. Remember that .. is a compact way to say “copy all unspecified fields from this struct,” so the fields specified before .. take precedence.

A third pitfall involves using struct update syntax with incompatible types. The expression following .. must evaluate to a struct of the same type, or at least a struct with compatible field types and names. Attempting to use a struct update with a non-struct type or a struct of a different type produces E0062 or related type mismatch errors.

Finally, some developers forget that the struct update syntax creates a new struct instance rather than modifying the original. When the error occurs with code like Point { ..p, x: p.x + 1 }, the intent might be to mutate p directly. Rust’s ownership system requires creating a new instance in such cases, which is why the struct update syntax exists as a convenience feature.

Error E0063 frequently appears alongside E0062 because it deals with similar struct initialization concerns. E0063 occurs when the struct literal is missing required fields or contains syntax errors in the field list. The relationship exists because both errors relate to struct literal syntax, though E0063 focuses on missing or malformed field definitions rather than incorrect use of the .. operator.

Error E0023 represents another related diagnostic in the Rust compiler. This error occurs when a struct pattern matching expression contains fields that do not exist in the target struct. While the error message and context differ, E0023 often surfaces in similar code patterns involving struct manipulation, making it a useful reference when working with struct initialization and destructuring.

Error E0765 provides additional context for struct initialization issues in newer Rust versions. This error addresses scenarios where the struct update syntax cannot be used due to privacy constraints or lifetime issues. Understanding E0062 first provides a foundation for tackling these more advanced struct initialization challenges when they arise in complex codebases.

These related errors share a common theme: they all involve the struct initialization and pattern matching mechanisms in Rust. Mastering the syntax rules that govern these mechanisms helps you navigate not only E0062 but also the broader landscape of struct-related errors in Rust programming.

struct initialization syntax structs