| Age | Commit message (Collapse) | Author | Lines |
|---|
|
Test that Wrapping arithmetic ops are implemented for all int types
Closes #49660
|
|
remove the unstable rustdoc parameter --linker
use the code generation parameter -Clinker (same parameter as rustc)
to control what linker to use for building the rustdoc test executables.
closes: #63816
|
|
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.
|
|
|
|
Kill borrows from assignments after generating new borrows
Closes #63719
|
|
use the code generation parameter -Clinker (same parameter as rustc)
to control what linker to use for building the rustdoc test executables.
closes: #63816
|
|
|
|
rustdoc: warn on empty doc test
Closes #60319.
A doc test that only contains whitespace should result in a warning.
This PR adds detection of empty doc tests to `check-code-block-syntax`, as having an invalid doc test is mutually exclusive with an empty doc test.
|
|
|
|
|
|
|
|
`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
|
|
Hide trait default methods
Fixes #62499.
However, the question remains: do we want to extend it to this point or not?
r? @QuietMisdreavus
|
|
Small improvement for Ord implementation of integers
Godbolt link: https://godbolt.org/z/tuTDOg
### Before
**asm**
```asm
example::cmp:
mov eax, dword ptr [rdi]
xor ecx, ecx
cmp eax, dword ptr [rsi]
seta cl
mov eax, 255
cmovae eax, ecx
ret
```
**llvm-mca**
```
Iterations: 100
Instructions: 700
Total Cycles: 217
Total uOps: 1100
Dispatch Width: 6
uOps Per Cycle: 5.07
IPC: 3.23
Block RThroughput: 1.8
```
### After
**asm**
```asm
example::cmp:
mov eax, dword ptr [rdi]
xor ecx, ecx
cmp eax, dword ptr [rsi]
setne cl
mov eax, 255
cmovae eax, ecx
ret
```
**llvm-mca**
```
Iterations: 100
Instructions: 700
Total Cycles: 209
Total uOps: 1000
Dispatch Width: 6
uOps Per Cycle: 4.78
IPC: 3.35
Block RThroughput: 1.7
```
r? @nagisa
|
|
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
|
|
Rollup of 11 pull requests
Successful merges:
- #63811 (Correctly suggest adding bounds to `impl Trait` argument)
- #63933 (Resolve some small issues related to #63580)
- #63938 (or-pattern: fix typo in error message)
- #63945 (Recover `mut $pat` and other improvements)
- #63958 (const_prop: only call error_to_const_error if we are actually showing something)
- #63961 (Add Option<Span> to `require_lang_item`)
- #63963 (remove the reference to __cxa_thread_atexit_impl)
- #63965 (Prevent syntax error in LD linker version script)
- #63968 (rustc_apfloat: make the crate #![no_std] explicitly.)
- #63970 (Notify me (flip1995) when Clippy toolstate changes)
- #63980 (add missing `#[repr(C)]` on the Slices union)
Failed merges:
- #63989 (Add Yaah to clippy toolstain notification list)
r? @ghost
|
|
|
|
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.
|
|
Improve Rustdoc's handling of procedural macros
Fixes #58700
Fixes #58696
Fixes #49553
Fixes #52210
This commit removes the special rustdoc handling for proc macros, as we can now
retrieve their span and attributes just like any other item.
A new command-line option is added to rustdoc: `--crate-type`. This takes the same options as rustc's `--crate-type` option. However, all values other than `proc-macro` are treated the same. This allows Rustdoc to enable 'proc macro mode' when handling a proc macro crate.
In compiletest, a new 'rustdoc-flags' option is added. This allows us to
pass in the '--proc-macro-crate' flag in the absence of Cargo.
I've opened [an additional PR to Cargo](https://github.com/rust-lang/cargo/pull/7159) to support passing in this flag.
These two PRS can be merged in any order - the Cargo changes will not
take effect until the 'cargo' submodule is updated in this repository.
|
|
debuginfo: give unique names to closure and generator types
Closure types have been moved to the namespace where they
are defined, and both closure and generator type names now
include the disambiguator.
This fixes an exception when lldb prints nested closures.
Fixes #57822
I haven't included the `DW_AT_artificial` changes discussed in #57822 because they make the output worse IMO, but I can easily add these if still required. For example, for the new test case the output is now:
```
(lldb) p g
(issue_57822::main::closure-1) $1 = closure-1(closure(1))
```
but adding `DW_AT_artificial` changes this to:
```
(lldb) p g
(issue_57822::main::closure-1) $0 = closure-1 {
}
```
Note that nested generators didn't cause the exception. I haven't determined why, but I think it makes sense to add the disambiguator for them too. It feels like we still don't really understand why closures were causing an error though.
r? @michaelwoerister
|
|
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.
|
