| Age | Commit message (Collapse) | Author | Lines |
|---|
|
Test that Wrapping arithmetic ops are implemented for all int types
Closes #49660
|
|
Suggest call fn ctor passed as arg to fn with type param bounds
_Reviewer note: the relevant changes are in the second commit, the first is simple and mechanical, but verbose._
When forgetting to call a fn in an argument position to an fn that has a generic bound:
```rust
async fn foo() {}
fn bar(f: impl Future<Output=()>) {}
fn main() {
bar(foo); // <- should be `bar(foo());`
}
```
suggest calling it:
```
error[E0277]: the trait bound `fn() -> impl std::future::Future {foo}: std::future::Future` is not satisfied
--> $DIR/async-fn-ctor-passed-as-arg-where-it-should-have-been-called.rs:9:5
|
LL | fn bar(f: impl Future<Output=()>) {}
| --------------------------------- required by `bar`
...
LL | bar(foo);
| ^^^ the trait `std::future::Future` is not implemented for `fn() -> impl std::future::Future {foo}`
|
= help: it looks like you forgot to use parentheses to call the function: `foo()`
```
Fix #63100. Follow up to #63833 and #63337.
|
|
|
|
|
|
|
|
|
|
|
|
`improper_ctypes`: guard against accidental change to `Unique<T>`
r? @eddyb
|
|
|
|
Rollup of 7 pull requests
Successful merges:
- #62957 (Match the loop examples)
- #63600 (Merge oli-obk mail addresses)
- #63684 (Constify LinkedList new function)
- #63847 ([rustdoc] Fix system theme detection)
- #63999 (Add missing links on AsRef trait)
- #64014 ( miri: detect too large dynamically sized objects )
- #64015 (some const-eval test tweaks)
Failed merges:
r? @ghost
|
|
some const-eval test tweaks
Best reviewed commit-by-commit.
r? @oli-obk
|
|
miri: detect too large dynamically sized objects
Needed to make https://github.com/rust-lang/miri/pull/929 pass.
r? @oli-obk
|
|
When accessing private field of union, do not misidentify it as a struct
Fix incorrect error message when accessing private field of union.
Fixes #63976.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Strip code to the left and right in diagnostics for long lines
Fix #62999.
|
|
|
|
|
|
This allows lints and other diagnostics to refer to items
by a unique ID instead of relying on whacky path
resolution schemes that may break when items are
relocated.
|
|
|
|
|
|
rustc: Handle modules in "fat" LTO more robustly
When performing a "fat" LTO the compiler has a whole mess of codegen
units that it links together. To do this it needs to select one module
as a "base" module and then link everything else into this module.
Previously LTO passes assume that there's at least one module in-memory
to link into, but nowadays that's not always true! With incremental
compilation modules may actually largely be cached and it may be
possible that there's no in-memory modules to work with.
This commit updates the logic of the LTO backend to handle modules a bit
more uniformly during a fat LTO. This commit immediately splits them
into two lists, one serialized and one in-memory. The in-memory list is
then searched for the largest module and failing that we simply
deserialize the first serialized module and link into that. This
refactoring avoids juggling three lists, two of which are serialized
modules and one of which is half serialized and half in-memory.
Closes #63349
|
|
Validation: check raw wide pointer metadata
While I was at it, I also added a missing check for slices not to be too big.
r? @oli-obk
Fixes https://github.com/rust-lang/miri/issues/918
|
|
resolve: Block expansion of a derive container until all its derives are resolved
So, it turns out there's one more reason to block expansion of a `#[derive]` container until all the derives inside it are resolved, beside `Copy` (https://github.com/rust-lang/rust/pull/63248).
The set of derive helper attributes registered by derives in the container also has to be known before the derives themselves are expanded, otherwise it may be too late (see https://github.com/rust-lang/rust/pull/63468#issuecomment-524550872 and the `#[stable_hasher]`-related test failures in https://github.com/rust-lang/rust/pull/63468).
So, we stop our attempts to unblock the container earlier, as soon as the `Copy` status is known, and just block until all its derives are resolved.
After all the derives are resolved we immediately go and process their helper attributes in the item, without delaying it until expansion of the individual derives.
Unblocks https://github.com/rust-lang/rust/pull/63468
r? @matthewjasper (as a reviewer of https://github.com/rust-lang/rust/pull/63248)
cc @c410-f3r
|
|
Add Option<Span> to `require_lang_item`
Fixes #63954
I'm not sure where to take `Some(span)` or something so I use `None` in many places.
r? @estebank
|
|
Recover `mut $pat` and other improvements
- Recover on e.g. `mut Foo(x, y)` and suggest `Foo(mut x, mut y)`. Fixes https://github.com/rust-lang/rust/issues/63764.
- Recover on e.g. `let mut mut x;`
- Recover on e.g. `let keyword` and `let keyword(...)`.
- Cleanups in `token.rs` with `fn is_non_raw_ident_where` and friends.
|
|
or-pattern: fix typo in error message
cc https://github.com/rust-lang/rust/issues/54883.
|
|
Correctly suggest adding bounds to `impl Trait` argument
Fix #63706.
|
|
Add default serialization for `Ident`s
Also add tests for `-Zast-json` and `-Zast-json-noexpand`
closes #63728
|
|
Simplify eager normalization of constants
r? @nikomatsakis
|
|
Cleanup: Consistently use `Param` instead of `Arg` #62426
Fixes #62426
|
|
|
|
|
|
|
|
|
|
Add tests for -Zast-json and -Zast-json-noexpand, which need this impl.
|
|
|
|
When performing a "fat" LTO the compiler has a whole mess of codegen
units that it links together. To do this it needs to select one module
as a "base" module and then link everything else into this module.
Previously LTO passes assume that there's at least one module in-memory
to link into, but nowadays that's not always true! With incremental
compilation modules may actually largely be cached and it may be
possible that there's no in-memory modules to work with.
This commit updates the logic of the LTO backend to handle modules a bit
more uniformly during a fat LTO. This commit immediately splits them
into two lists, one serialized and one in-memory. The in-memory list is
then searched for the largest module and failing that we simply
deserialize the first serialized module and link into that. This
refactoring avoids juggling three lists, two of which are serialized
modules and one of which is half serialized and half in-memory.
Closes #63349
|
|
|
|
`async-await/no-args-non-move-async-closure`
`generator/no-arguments-on-generators`
|
|
|
|
|
|
Error when generator trait is not found
Closes #63912
|
|
Propagate spans and attributes from proc macro definitions
Thanks to https://github.com/rust-lang/rust/pull/63269 we now have spans and attributes from proc macro definitions available in metadata.
However, that PR didn't actually put them into use! This PR finishes that work.
Attributes `rustc_macro_transparency`, `allow_internal_unstable`, `allow_internal_unsafe`, `local_inner_macros`, `rustc_builtin_macro`, `stable`, `unstable`, `rustc_deprecated`, `deprecated` now have effect when applied to proc macro definition functions.
From those attributes only `deprecated` is both stable and supposed to be used in new code.
(`#![staged_api]` still cannot be used in proc macro crates for unrelated reasons though.)
`Span::def_site` from the proc macro API now returns the correct location of the proc macro definition.
Also, I made a mistake in https://github.com/rust-lang/rust/pull/63269#discussion_r312702919, loaded proc macros didn't actually use the resolver cache.
This PR fixes the caching issue, now proc macros go through the `Resolver::macro_map` cache as well.
(Also, the first commit turns `proc_macro::quote` into a regular built-in macro to reduce the number of places where `SyntaxExtension`s need to be manually created.)
|
|
Which is no longer dummy and is available from metadata now.
|
|
|
