Update error message on compile
Single curly braces instead of double are being used
Add example of estimating pi using Monte Carlo simulation to std::rand
Add division by zero case to the `CheckedDiv` comment
Remove the dist function; it is more efficient to compare squared distances
Replace all references to "Win32" with "Windows".

For historical reasons, "Win32" has been used in Rust codebase to mean "Windows OS in general".
This is confusing, especially now, that Rust supports Win64 builds.

[breaking-change]
Replace #[cfg(target_os = "win32")] with #[cfg(target_os = "windows")]
Replace "ignore-win32" in tests with "ignore-windows"
Guide: patterns.

Fixes #4417.
Introduce the cargo run command earlier (squashed)
Fix handling of ignored arguments in FFI wrappers for rust functions

Fixes #16441.
vim: Stop setting conceallevel in the syntax file

We shouldn't be setting conceallevel in the syntax file. Besides not
being able to undo this if we switch to another syntax later, it also
interferes with embedding rust in other filetypes (such as markdown).

Instead, set it in the ftplugin, where it belongs.
Make it pass the pretty-printer test.
Followup to PR #16477: a run-pass regression test for Issue #15750.
Add a test for complex divide by zero.
auto merge of #16484 : dotdash/rust/empty_struct_wrapper_arg, r=luqmana

Fixes #16441.
librustc: Tie up loose ends in unboxed closures.

This patch primarily does two things: (1) it prevents lifetimes from
leaking out of unboxed closures; (2) it allows unboxed closure type
notation, call notation, and construction notation to construct closures
matching any of the three traits.

This breaks code that looked like:

    let mut f;
    {
        let x = &5i;
        f = |&mut:| *x + 10;
    }

Change this code to avoid having a reference escape. For example:

    {
        let x = &5i;
        let mut f; // <-- move here to avoid dangling reference
        f = |&mut:| *x + 10;
    }

I believe this is enough to consider unboxed closures essentially
implemented. Further issues (for example, higher-rank lifetimes) should
be filed as followups.

Closes #14449.

[breaking-change]
auto merge of #16122 : pcwalton/rust/lifetimes-in-unboxed-closures, r=pnkfelix

This patch primarily does two things: (1) it prevents lifetimes from
leaking out of unboxed closures; (2) it allows unboxed closure type
notation, call notation, and construction notation to construct closures
matching any of the three traits.

This breaks code that looked like:

    let mut f;
    {
        let x = &5i;
        f = |&mut:| *x + 10;
    }

Change this code to avoid having a reference escape. For example:

    {
        let x = &5i;
        let mut f; // <-- move here to avoid dangling reference
        f = |&mut:| *x + 10;
    }

I believe this is enough to consider unboxed closures essentially
implemented. Further issues (for example, higher-rank lifetimes) should
be filed as followups.

Closes #14449.

[breaking-change]

r? @pnkfelix
librustc: Stop assuming that implementations and traits only contain
methods.

This paves the way to associated items by introducing an extra level of
abstraction ("impl-or-trait item") between traits/implementations and
methods. This new abstraction is encoded in the metadata and used
throughout the compiler where appropriate.

There are no functional changes; this is purely a refactoring.
auto merge of #16286 : pcwalton/rust/associated-items-groundwork, r=nikomatsakis

methods.

This paves the way to associated items by introducing an extra level of
abstraction ("impl-or-trait item") between traits/implementations and
methods. This new abstraction is encoded in the metadata and used
throughout the compiler where appropriate.

There are no functional changes; this is purely a refactoring.

r? @nick29581