| Age | Commit message (Collapse) | Author | Lines |
|---|
|
Exempt extern "Rust" from improper_ctypes
It should be fine for Rust ABIs to involve any Rust type.
Fixes #64593.
|
|
No home directory on vxWorks
r? @alexcrichton
|
|
remove the extra comma after the match arm
This would follow the same coding style as all the other match arms in this file.
|
|
Add long error explanation for E0312
Part of #61137.
|
|
factor out pluralisation remains after #64280
there are two case that doesn't not match the original macro pattern at [here](https://github.com/rust-lang/rust/blob/master/src/librustc_lint/unused.rs#L146) and [here](https://github.com/rust-lang/rust/blob/master/src/libsyntax/parse/diagnostics.rs#L539) as the provided param is already a bool or the check condition is not `x != 1`, so I change the macro accept a boolean expr instead of number to fit all the cases.
@Centril please review
Fixes #64238.
|
|
Document From trait for LhsExpr in parser
Add doc for From trait for converting P<Expr> and Option<ThinVec<Attribute>> to LhsExpr
As part of issue rust-lang#51430 (cc @skade).
Both of these should just be moving an address and setting a discriminant in an enum. The main thing I'm not sure about is whether it's worth documenting the branch in the From<Option<ThinVec<Attribute>>. As far as I can tell it doesn't seem like it is optimized away (although if the discriminant happened to work out you could just copy the pointer and the discriminant which might be cheaper, but that's not guaranteed). So it seems like if it's being called often, it's doubling the number of possible branch mispredictions on this Option, which could be a significant cost.
Let me know if there's anything that needs fixing and I'll get to it as soon as possible!
|
|
Stabilize `param_attrs` in Rust 1.39.0
# Stabilization proposal
I propose that we stabilize `#![feature(param_attrs)]`.
Tracking issue: #60406
Version: 1.39 (2019-09-26 => beta, 2019-11-07 => stable).
## What is stabilized
It is now possible to add outer attributes like `#[cfg(..)]` on formal parameters of functions, closures, and function pointer types. For example:
```rust
fn len(
#[cfg(windows)] slice: &[u16],
#[cfg(not(windows))] slice: &[u8],
) -> usize {
slice.len()
}
```
## What isn't stabilized
* Documentation comments like `/// Doc` on parameters.
* Code expansion of a user-defined `#[proc_macro_attribute]` macro used on parameters.
* Built-in attributes other than `cfg`, `cfg_attr`, `allow`, `warn`, `deny`, and `forbid`. Currently, only the lints `unused_variables` and `unused_mut` have effect and may be controlled on parameters.
## Motivation
The chief motivations for stabilizing `param_attrs` include:
* Finer conditional compilation with `#[cfg(..)]` and linting control of variables.
* Richer macro DSLs created by users.
* External tools and compiler internals can take advantage of the additional information that the parameters provide.
For more examples, see the [RFC][rfc motivation].
## Reference guide
In the grammar of function and function pointer, the grammar of variadic tails (`...`) and parameters are changed respectively from:
```rust
FnParam = { pat:Pat ":" }? ty:Type;
VaradicTail = "...";
```
into:
```rust
FnParam = OuterAttr* { pat:Pat ":" }? ty:Type;
VaradicTail = OuterAttr* "...";
```
The grammar of a closure parameter is changed from:
```rust
ClosureParam = pat:Pat { ":" ty:Type }?;
```
into:
```rust
ClosureParam = OuterAttr* pat:Pat { ":" ty:Type }?;
```
More generally, where there's a list of formal (value) parameters separated or terminated by `,` and delimited by `(` and `)`. Each parameter in that list may optionally be prefixed by `OuterAttr+`.
Note that in all cases, `OuterAttr*` applies to the whole parameter and not just the pattern. This distinction matters in pretty printing and in turn for macros.
## History
* On 2018-10-15, @Robbepop proposes [RFC 2565][rfc], "Attributes in formal function parameter position".
* On 2019-04-30, [RFC 2565][rfc] is merged and the tracking issue is made.
* On 2019-06-12, a partial implementation was completed. The implementation was done in [#60669][60669] by @c410-f3r and the PR was reviewed by @petrochenkov and @Centril.
* On 2019-07-29, [#61238][61238] was fixed in [#61856][61856]. The issue fixed was that lint attributes on function args had no effect. The PR was written by @c410-f3r and reviewed by @matthewjasper, @petrochenkov, and @oli-obk.
* On 2019-08-02, a bug [#63210][63210] was filed wherein the attributes on formal parameters would not be passed to macros. The issue was about forgetting to call the relevant method in `fn print_arg` in the pretty printer. In [#63212][63212], written by @Centril on 2019-08-02 and reviewed by @davidtwco, the issue aforementioned was fixed.
* This PR stabilizes `param_attrs`.
## Tests
* [On Rust 2018, attributes aren't permitted on function parameters without a pattern in trait definitions.](https://github.com/rust-lang/rust/blob/master/src/test/ui/rfc-2565-param-attrs/param-attrs-2018.rs)
* [All attributes that should be allowed. This includes `cfg`, `cfg_attr`, and lints check attributes.](https://github.com/rust-lang/rust/blob/master/src/test/ui/rfc-2565-param-attrs/param-attrs-allowed.rs)
* [Built-in attributes, which should be forbidden, e.g., `#[test]`, are.](https://github.com/rust-lang/rust/blob/master/src/test/ui/rfc-2565-param-attrs/param-attrs-builtin-attrs.rs)
* [`cfg` and `cfg_attr` are properly evaluated.](https://github.com/rust-lang/rust/blob/master/src/test/ui/rfc-2565-param-attrs/param-attrs-cfg.rs)
* [`unused_mut`](https://github.com/rust-lang/rust/blob/46f405ec4d7c6bf16fc2eaafe7541019f1da2996/src/test/ui/rfc-2565-param-attrs/param-attrs-cfg.rs) and [`unused_variables`](https://github.com/rust-lang/rust/blob/master/src/test/ui/lint/lint-unused-variables.rs) are correctly applied to parameter patterns.
* [Pretty printing takes formal parameter attributes into account.](https://github.com/rust-lang/rust/blob/master/src/test/ui/rfc-2565-param-attrs/param-attrs-pretty.rs)
## Possible future work
* Custom attributes inside function parameters aren't currently supported but it is something being worked on internally.
* Since documentation comments are syntactic sugar for `#[doc(...)]`, it is possible to allow literal `/// Foo` comments on function parameters.
[rfc motivation]: https://github.com/rust-lang/rfcs/blob/master/text/2565-formal-function-parameter-attributes.md#motivation
[rfc]: https://github.com/rust-lang/rfcs/pull/2565
[60669]: https://github.com/rust-lang/rust/pull/60669
[61856]: https://github.com/rust-lang/rust/pull/61856
[63210]: https://github.com/rust-lang/rust/issues/63210
[61238]: https://github.com/rust-lang/rust/issues/61238
[63212]: https://github.com/rust-lang/rust/pull/63212
This report is a collaborative work with @Centril.
|
|
Also tweak walkers on `Pat`.
|
|
|
|
Add `cmp::{min_by, min_by_key, max_by, max_by_key}`
This adds the following functions to `core::cmp`:
- `min_by`
- `min_by_key`
- `max_by`
- `max_by_key`
`min_by` and `max_by` are somewhat trivial to implement, but not entirely because `min_by` returns the first value in case the two are equal (and `max_by` the second). `min` and `max` can be implemented in terms of `min_by` and `max_by`, but not as easily the other way around.
To give an example of why I think these functions could be useful: the `Iterator::{min_by, min_by_key, max_by, max_by_key}` methods all currently hard-code the behavior mentioned above which is an ever so small duplication of logic. If we delegate them to `cmp::{min_by, max_by}` methods instead, we get the correct behavior for free. (edit: this is now included in the PR)
I added `min_by_key` / `max_by_key` for consistency's sake but I wouldn't mind removing them. I don't have a particular use case in mind for them, and `min_by` / `max_by` seem to be more useful.
Tracking issue: #64460
|
|
|
|
rust stat should call libc stat
|
|
It was using the snippet from the "use" span, which often renders the
same, but with closures that snippet is on the start of the closure
where the value is captured. We should be using the snippet from the
span where it was moved into the `for` loop, which is `move_span`.
|
|
|
|
It should be fine for Rust ABIs to involve any Rust type.
|
|
|
|
|
|
|
|
This would follow the same coding style as all the other match arms in this file.
|
|
record fewer adjustment types in generator witnesses, avoid spurious drops in MIR construction
Don't record all intermediate adjustment types -- That's way more than is needed, and winds up recording types that will never appear in MIR.
Note: I'm like 90% sure that this logic is correct, but this stuff is subtle and can be hard to keep straight. However, the risk of this PR is fairly low -- if we miss types here, I believe the most common outcome is an ICE.
This fixes the original issue cited by #64477, but I'm leaving the issue open for now since there may be other cases we can detect and improve in a targeted way.
r? @Zoxc
|
|
r=Mark-Simulacrum
azure: Convert Windows installations scripts to `bash`
Looks like `script`, which uses `cmd.exe`, doesn't have fail-fast
behavior and if a leading command fails the script doesn't actually fail
so long as the last command succeeds. We instead want the opposite
behavior where if any step fails the whole script fails.
I don't really know `cmd.exe` that well, nor powershell, so I've opted
to move everything to `bash` which should be a good common denominator
amongst all platforms to work with. Additionally I know that `set -e`
works to cause scripts to fail fast.
Closes #64551
|
|
|
|
When possible point at argument causing item obligation failure
Fix https://github.com/rust-lang/rust/issues/41781, fix https://github.com/rust-lang/rust/issues/42855, fix https://github.com/rust-lang/rust/issues/46658, fix https://github.com/rust-lang/rust/issues/48099, fix https://github.com/rust-lang/rust/issues/63143.
|
|
Because the meaning of this `index` variable is quite different to all
the other `index` variables in this file.
|
|
ci: split aws credentials in two separate users with scoped perms
This commit changes our CI to use two separate IAM users to authenticate with AWS:
* `ci--rust-lang--rust--sccache`: has access to the `rust-lang-ci-sccache2` S3 bucket and its credentials are available during the whole build.
* `ci--rust-lang--rust--upload`: has access to the `rust-lang-ci2` S3 bucket and its credentials are available just during the upload step.
The new tokens are available in the `prod-credentials` library.
r? @alexcrichton
|
|
The name `waiting_cache` sounds like it is related to the states
`NodeState::Waiting`, but it's not; the cache holds nodes of various
states.
This commit changes it to `active_state`.
|
|
We normally use `index` for indices to `ObligationForest::nodes`, but
this is a `Nodes::dependents` index.
|
|
|
|
This is a big speed win for `keccak` and `inflate`.
|
|
Optimizing for the common numbers of entries in `stalled_on` wins about
4% on `keccak` and `inflate`.
|
|
|
|
This gives a slight speed-up.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* Pass `/Q` to `iscc` on Windows to supress the thousands of lines of
output about compressing documentation.
* Print out what's happening before long steps
* Use `timeit` to print out timing information for long-running
installer assemblies.
|
|
|
|
|
|
This is the same as #64615 except applied to our MSI installers. The
same fix is applied effectively bringing these installers in line with
the gz tarball installers, which are about 3x faster to produce locally
and likely much faster to produce on CI.
|
|
rustbuild: Copy crate doc files fewer times
Previously when building documentation for the standard library we'd
copy all the files 5 times, and these files include libcore/libstd docs
which are huge! This commit instead only copies the files after rustdoc
has been run for each crate, reducing the number of redundant copies
we're making.
|
|
rustbuild: Don't package libstd twice
Looks like the packaging step for the standard library was happening
twice on CI, but it only needs to happen once! The `Analysis` packaging
step accidentally packaged `Std` instead of relying on compiling `Std`,
which meant that we ended up packaging it twice erroneously.
|
|
Remove unnecessary `mut` in doc example
|
|
Fix backticks in documentation
Fix a few typos in comments/documentation where backticks were doubled-up on one side.
|
