Commit Graph

85 Commits

Author SHA1 Message Date
Jesús Rubio
8fbdd2d15e
Update compiler/rustc_error_codes/src/error_codes/E0547.md
Co-authored-by: Guillaume Gomez <guillaume1.gomez@gmail.com>
2021-02-09 14:13:40 +01:00
Jesus Rubio
7b84b62d29 Lost text re-added 2021-02-09 14:09:19 +01:00
Jesus Rubio
4d33d41ef3 Add long explanation for E0547 2021-02-08 18:25:05 +01:00
bors
bb587b1a17 Auto merge of #80652 - calebzulawski:simd-lanes, r=nagisa
Improve SIMD type element count validation

Resolves rust-lang/stdsimd#53.

These changes are motivated by `stdsimd` moving in the direction of const generic vectors, e.g.:
```rust
#[repr(simd)]
struct SimdF32<const N: usize>([f32; N]);
```

This makes a few changes:
* Establishes a maximum SIMD lane count of 2^16 (65536).  This value is arbitrary, but attempts to validate lane count before hitting potential errors in the backend.  It's not clear what LLVM's maximum lane count is, but cranelift's appears to be much less than `usize::MAX`, at least.
* Expands some SIMD intrinsics to support arbitrary lane counts.  This resolves the ICE in the linked issue.
* Attempts to catch invalid-sized vectors during typeck when possible.

Unresolved questions:
* Generic-length vectors can't be validated in typeck and are only validated after monomorphization while computing layout.  This "works", but the errors simply bail out with no context beyond the name of the type.  Should these errors instead return `LayoutError` or otherwise provide context in some way?  As it stands, users of `stdsimd` could trivially produce monomorphization errors by making zero-length vectors.

cc `@bjorn3`
2021-02-07 22:25:14 +00:00
Guillaume Gomez
b2beb67fac
Rollup merge of #81835 - jesusprubio:improve-long-eplanation-e0546, r=GuillaumeGomez
Improve long explanation for E0546

Helps with #61137
2021-02-07 14:45:54 +01:00
Jesus Rubio
ac6c09a980 Typo fix 2021-02-06 19:45:43 +01:00
Jesus Rubio
777582228c References added 2021-02-06 19:44:09 +01:00
Jesus Rubio
023c6d2e04 Comments updated to keep the consistency 2021-02-06 19:41:03 +01:00
Jesus Rubio
0d8a071f98 Improve long explanation for E0546 2021-02-06 18:27:19 +01:00
Jesus Rubio
9be5d2d01f Format fixes 2021-02-06 18:05:21 +01:00
Jesús Rubio
956c81355a
Update compiler/rustc_error_codes/src/error_codes/E0542.md
Co-authored-by: Guillaume Gomez <guillaume1.gomez@gmail.com>
2021-02-06 17:39:11 +01:00
Jesus Rubio
be159379f6 Add long error explanation for E0542 2021-02-06 16:42:34 +01:00
Mara Bos
29371c2504
Rollup merge of #81676 - jyn514:crate-not-found, r=oli-obk
Add more information to the error code for 'crate not found'

This comes up a lot when bootstrapping.
2021-02-05 12:26:02 +01:00
Joshua Nelson
82914a5031 Add more information to the error code for 'crate not found'
This comes up a lot when bootstrapping.
2021-02-03 11:51:42 -05:00
bors
b593389edb Auto merge of #81346 - hug-dev:nonsecure-call-abi, r=jonas-schievink
Add a new ABI to support cmse_nonsecure_call

This adds support for the `cmse_nonsecure_call` feature to be able to perform non-secure function call.

See the discussion on Zulip [here](https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/Support.20for.20callsite.20attributes/near/223054928).

This is a followup to #75810 which added `cmse_nonsecure_entry`. As for that PR, I assume that the changes are small enough to not have to go through a RFC but I don't mind doing one if needed 😃
I did not yet create a tracking issue, but if most of it is fine, I can create one and update the various files accordingly (they refer to the other tracking issue now).

On the Zulip chat, I believe `@jonas-schievink` volunteered to be a reviewer 💯
2021-02-03 06:00:43 +00:00
Hugues de Valon
ce9818f2b7 Add a new ABI to support cmse_nonsecure_call
This commit adds a new ABI to be selected via `extern
"C-cmse-nonsecure-call"` on function pointers in order for the compiler to
apply the corresponding cmse_nonsecure_call callsite attribute.
For Armv8-M targets supporting TrustZone-M, this will perform a
non-secure function call by saving, clearing and calling a non-secure
function pointer using the BLXNS instruction.

See the page on the unstable book for details.

Signed-off-by: Hugues de Valon <hugues.devalon@arm.com>
2021-02-02 13:04:31 +00:00
Jesus Rubio
ee5ea24d36 Add long error explanation for E0521 2021-02-01 18:22:13 +01:00
Jonas Schievink
36af32a740
Rollup merge of #81572 - pierwill:edit-error-codes-1, r=jonas-schievink
Edit multiple error code Markdown files

Makes small edits to several error code files. Fixes some missing punctuation. Changes some wording, grammar, and formatting for clarity and readability.

Adds a link to the rustup book in E0658.
2021-01-31 16:36:54 +01:00
pierwill
fabb332c1a Edit multiple error code Markdown files
Makes small edits to several error code files. Fixes some
missing punctuation. Changes some wording, grammar, and formatting
for clarity and readability.

Adds a link to the rustup book in E0658.
2021-01-30 15:57:46 -08:00
Steve Heindel
642d27d40a Fix typo in E0759 2021-01-30 09:48:37 -05:00
Joakim Åkerblom
1d03648e67 Fix spelling in documentation for error E0207
I have trouble parsing the the wording "type parameter parameter".
2021-01-24 20:31:42 +01:00
Caleb Zulawski
a4bab7c6fa Update docs with powers-of-two 2021-01-24 00:17:40 -05:00
Mara Bos
af5b0d9883
Rollup merge of #80614 - 1000teslas:issue-78938-fix, r=tmandry
Explain why borrows can't be held across yield point in async blocks

For https://github.com/rust-lang/rust/issues/78938.
2021-01-16 17:29:49 +00:00
1000teslas
5468d9805a Simplify E0373 async code example 2021-01-15 16:50:48 +11:00
1000teslas
63deae5e25 Fix E0373 code example 2021-01-14 21:52:38 +11:00
1000teslas
174135fb3b Fix error E0373 documentation 2021-01-14 17:15:04 +11:00
1000teslas
a9ead34371 Fix whitespace 2021-01-14 01:21:27 +11:00
Mark Rousskov
4614671cae Update code to account for extern ABI requirement 2021-01-13 07:49:45 -05:00
Mark Rousskov
8a3edb1d66 Update tests for extern block linting 2021-01-13 07:49:16 -05:00
1000teslas
7f41465f6d Move help link to error index 2021-01-13 23:37:49 +11:00
Daiki Ihara
c71348a9c6 Refine E0435 description 2021-01-07 20:20:58 +09:00
oli
3ed14033f7 Reinstate the error-code error over the feature gate error 2021-01-01 16:59:12 +00:00
oli
0b841846ba Allow references to interior mutable data behind a feature gate 2021-01-01 16:59:12 +00:00
bors
a6bd5246da Auto merge of #80267 - 0urobor0s:ouro/61592, r=jyn514
Rustdoc render public underscore_imports as Re-exports

Fixes #61592
2020-12-31 09:07:52 +00:00
bors
cb4553bdae Rustdoc render public underscore_imports as Re-exports
Fixes #61592
2020-12-31 09:07:51 +00:00
Bastian Kauschke
18fa7789cd update error codes 2020-12-26 18:24:10 +01:00
Tyler Mandry
f3a3fc900c
Rollup merge of #79639 - sasurau4:feature/add-long-explanation-E0212, r=GuillaumeGomez
Add long explanation for E0212

Helps with #61137
2020-12-10 21:33:04 -08:00
Ethan Brierley
0c13a9c020 smarter E0390 2020-12-06 20:30:07 +00:00
Daiki Ihara
a1e94cdcd5 Add long explanation for E0212
Update compiler/rustc_error_codes/src/error_codes/E0212.md

Co-authored-by: Joshua Nelson <joshua@yottadb.com>
2020-12-04 22:17:06 +09:00
bors
c7cff213e9 Auto merge of #79533 - sasurau4:feature/add-long-explanation-E0546, r=GuillaumeGomez
Add long explanation of E0546

Helps with #61137
2020-12-03 05:18:36 +00:00
Daiki Ihara
f2f3a8e645 Add long explanation of E0546 2020-12-02 00:18:36 +09:00
Camelid
1b846bfbcc Slightly improve code samples in E0591
* Improve formatting
* Don't hide `unsafe` block - it's important!
2020-11-27 19:07:14 -08:00
Camelid
810324d1f3 Rename optin_builtin_traits to auto_traits
They were originally called "opt-in, built-in traits" (OIBITs), but
people realized that the name was too confusing and a mouthful, and so
they were renamed to just "auto traits". The feature flag's name wasn't
updated, though, so that's what this PR does.

There are some other spots in the compiler that still refer to OIBITs,
but I don't think changing those now is worth it since they are internal
and not particularly relevant to this PR.

Also see <https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/opt-in.2C.20built-in.20traits.20(auto.20traits).20feature.20name>.
2020-11-23 14:14:06 -08:00
James
0bc04e327c
Update E0744 about control flow in const contexts to reflect the current status of const fn.
This is a squash of these commits:
- Update E0744 about control flow in `const` contexts to reflect current status of `const fn`.
- E0744 isn't just about `for` loops or control flow
- Fix formatting on E0744 cause my editor decided to not copy it well
- Improve wording
- Fix a markdown formatting error
- Fix E0744's description as I interpreted some code wrong
- Fix a minor wording issue again
- Add a few more links to blocking issues
- Improve links to tracking issues
2020-11-16 09:30:29 -06:00
Joshua Nelson
9d9292cfda deny(invalid_codeblock_attributes) 2020-11-05 12:13:28 -05:00
Yuki Okushi
0b72ca6ea6
Rollup merge of #78332 - PoignardAzur:doc_E0308, r=camelid
Update description for error E0308

Fixes #76462

r? @camelid
2020-10-27 08:44:54 +09:00
Olivier FAURE
666afba684 Update description for error E0308
As per #76462
2020-10-25 12:20:25 +01:00
Yuki Okushi
050eb4d7e4
Rollup merge of #77971 - jyn514:broken-intra-doc-links, r=mark-simulacrum
Deny broken intra-doc links in linkchecker

Since rustdoc isn't warning about these links, check for them manually.

This also fixes the broken links that popped up from the lint.
2020-10-17 05:36:49 +09:00
Joshua Nelson
65835d1059 Deny broken intra-doc links in linkchecker
Since rustdoc isn't warning about these links, check for them manually.
2020-10-15 20:22:16 -04:00
Dylan DPC
85dbb03490
Rollup merge of #76119 - Amjad50:stabilizing-move_ref_pattern, r=nikomatsakis
Stabilize move_ref_pattern

# Implementation
- Initially the rule was added in the run-up to 1.0. The AST-based borrow checker was having difficulty correctly enforcing match expressions that combined ref and move bindings, and so it was decided to simplify forbid the combination out right.
- The move to MIR-based borrow checking made it possible to enforce the rules in a finer-grained level, but we kept the rule in place in an effort to be conservative in our changes.
- In #68376, @Centril lifted the restriction but required a feature-gate.
- This PR removes the feature-gate.

Tracking issue: #68354.

# Description
This PR is to stabilize the feature `move_ref_pattern`, which allows patterns
containing both `by-ref` and `by-move` bindings at the same time.

For example: `Foo(ref x, y)`, where `x` is `by-ref`,
and `y` is `by-move`.

The rules of moving a variable also apply here when moving *part* of a variable,
such as it can't be referenced or moved before.

If this pattern is used, it would result in *partial move*, which means that
part of the variable is moved. The variable that was partially moved from
cannot be used as a whole in this case, only the parts that are still
not moved can be used.

## Documentation
- The reference (rust-lang/reference#881)
- Rust by example (rust-lang/rust-by-example#1377)

## Tests
There are many tests, but I think one of the comperhensive ones:
- [borrowck-move-ref-pattern-pass.rs](85fbf49ce0/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs)
- [borrowck-move-ref-pattern.rs](85fbf49ce0/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs)

# Examples

```rust
#[derive(PartialEq, Eq)]
struct Finished {}

#[derive(PartialEq, Eq)]
struct Processing {
    status: ProcessStatus,
}

#[derive(PartialEq, Eq)]
enum ProcessStatus {
    One,
    Two,
    Three,
}

#[derive(PartialEq, Eq)]
enum Status {
    Finished(Finished),
    Processing(Processing),
}

fn check_result(_url: &str) -> Status {
    // fetch status from some server
    Status::Processing(Processing {
        status: ProcessStatus::One,
    })
}

fn wait_for_result(url: &str) -> Finished {
    let mut previous_status = None;
    loop {
        match check_result(url) {
            Status::Finished(f) => return f,
            Status::Processing(p) => {
                match (&mut previous_status, p.status) {
                    (None, status) => previous_status = Some(status), // first status
                    (Some(previous), status) if *previous == status => {} // no change, ignore
                    (Some(previous), status) => { // Now it can be used
                        // new status
                        *previous = status;
                    }
                }
            }
        }
    }
}
```

Before, we would have used:
```rust
                match (&previous_status, p.status) {
                    (Some(previous), status) if *previous == status => {} // no change, ignore
                    (_, status) => {
                        // new status
                        previous_status = Some(status);
                    }
                }
```

Demonstrating *partial move*
```rust
fn main() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: u8,
    }

    let person = Person {
        name: String::from("Alice"),
        age: 20,
    };

    // `name` is moved out of person, but `age` is referenced
    let Person { name, ref age } = person;

    println!("The person's age is {}", age);

    println!("The person's name is {}", name);

    // Error! borrow of partially moved value: `person` partial move occurs
    //println!("The person struct is {:?}", person);

    // `person` cannot be used but `person.age` can be used as it is not moved
    println!("The person's age from person struct is {}", person.age);
}
```
2020-10-16 02:10:07 +02:00