Change the way that underline positions are calculated by delaying using
the "visual" column position until the last possible moment, instead
using the "file"/byte position in the file, and then calculating visual
positioning as late as possible. This should make the underlines more
resilient to non-1-width unicode chars.
Unfortunately, as part of this change (which fixes some visual bugs)
comes with the loss of some eager tab codepoint handling, but the output
remains legible despite some minor regression on the "margin trimming"
logic.
When encountering a single line span that is wider than the terminal, we keep context at the start and end of the span but otherwise remove the code from the middle. This is somewhat independent from whether the left and right margins of the output have been trimmed as well.
```
error[E0308]: mismatched types
--> $DIR/long-span.rs:6:15
|
LL | ... = [0, 0, 0, 0, ..., 0, 0];
| ^^^^^^^^^^^^^...^^^^^^^ expected `u8`, found `[{integer}; 1681]`
```
Address part of #137680 (missing handling of the long suggestion). Fix#125581.
`-Zteach` is perma-unstable, barely used, the highlighting logic buggy and the flag being passed around is tech-debt. We should likely remove `-Zteach` in its entirely.
use target compiler on llvm-bitcode-linker
The build compiler is already resolved inside the `ToolBuild` step, so we should pass only the target compilers for `Mode::ToolRustc` tools.
Fixes https://github.com/rust-lang/rust/issues/138123
r? ghost
try-job: dist-powerpc64le-linux
Rollup of 6 pull requests
Successful merges:
- #137674 (Enable `f16` for LoongArch)
- #138034 (library: Use `size_of` from the prelude instead of imported)
- #138060 (Revert #138019 after further discussion about how hir-pretty printing should work)
- #138073 (Break critical edges in inline asm before code generation)
- #138107 (`librustdoc`: clippy fixes)
- #138111 (Use `default_field_values` for `rustc_errors::Context`, `rustc_session::config::NextSolverConfig` and `rustc_session::config::ErrorOutputType`)
r? `@ghost`
`@rustbot` modify labels: rollup
Rollup of 8 pull requests
Successful merges:
- #136667 (Revert vita's c_char back to i8)
- #137107 (Override default `Write` methods for cursor-like types)
- #137777 (Specialize `OsString::push` and `OsString as From` for UTF-8)
- #137832 (Fix crash in BufReader::peek())
- #137904 (Improve the generic MIR in the default `PartialOrd::le` and friends)
- #138115 (Suggest typo fix for static lifetime)
- #138125 (Simplify `printf` and shell format suggestions)
- #138129 (Stabilize const_char_classify, const_sockaddr_setters)
r? `@ghost`
`@rustbot` modify labels: rollup
Currently it relies on special treatment of `kw::Empty`, which is really
easy to get wrong. This commit makes the special case clearer in the
type system by using `Option`. It's a bit clumsy, but the synthetic name
handling itself is a bit clumsy; better to make it explicit than sneak
it in.
Fixes#133426.
Use `default_field_values` for `rustc_errors::Context`, `rustc_session::config::NextSolverConfig` and `rustc_session::config::ErrorOutputType`
Wanted to see where `#![feature(default_field_values)]` could be used in the codebase. These three seemed like no-brainers. There are a bunch of more places where we could remove manual `Default` impls, but they `derive` other traits that rely on `syn`, which [doesn't yet support `default_field_values`](https://github.com/dtolnay/syn/issues/1774).
Break critical edges in inline asm before code generation
An inline asm terminator defines outputs along its target edges -- a
fallthrough target and labeled targets. Code generation implements this
by inserting code directly into the target blocks. This approach works
only if the target blocks don't have other predecessors.
Establish required invariant by extending existing code that breaks
critical edges before code generation.
Fixes#137867.
r? ``@bjorn3``
Revert #138019 after further discussion about how hir-pretty printing should work
After some more discussion, #138019 was probably merged a little fast. Though there probably is a real bug in pretty printing, it is not feasible to add similar pretty printing routines for all attributes, and making this specific exception is likely not desired either. For more context, see post-merge comments on #138019
I kept the tests around, but reverted the hir-pretty change.
r? ```@compiler-errors```
library: Use `size_of` from the prelude instead of imported
Use `std::mem::{size_of, size_of_val, align_of, align_of_val}` from the prelude instead of importing or qualifying them.
These functions were added to all preludes in Rust 1.80.
try-job: test-various
try-job: x86_64-gnu
try-job: x86_64-msvc-1
Stabilize const_char_classify, const_sockaddr_setters
FCP for const_char_classify: #132241
FCP for const_sockaddr_setters: #131714Fixes#132241Fixes#131714
Cc ``@rust-lang/wg-const-eval``
Simplify `printf` and shell format suggestions
Simplify tracking `printf` and shell format suggestions. Although allocations could be deferred until after checking that they aren't already in the map, this style is simpler.
Improve the generic MIR in the default `PartialOrd::le` and friends
It looks like I regressed this accidentally in #137197 due to #137901
So this PR does two things:
1. Tweaks the way we're calling `is_some_and` so that it optimizes in the generic MIR (rather than needing to optimize it in every monomorphization) -- the first commit adds a MIR test, so you can see the difference in the second commit.
2. Updates the implementations of `is_le` and friends to be slightly simpler, and parallel how clang does them.
Fix crash in BufReader::peek()
`bufreader_peek` tracking issue: #128405
This fixes a logic error in `Buffer::read_more()` that would make `BufReader::peek()` expose uninitialized data and/or segfault if `read_more()` was called with a partially-full buffer and a non-empty inner reader.
Specialize `OsString::push` and `OsString as From` for UTF-8
When concatenating two WTF-8 strings, surrogate pairs at the boundaries need to be joined. However, since UTF-8 strings cannot contain surrogate halves, this check can be skipped when one string is UTF-8. Specialize `OsString::push` to use a more efficient concatenation in this case.
The WTF-8 version of `OsString` tracks whether it is known to be valid UTF-8 with its `is_known_utf8` field. Specialize `From<AsRef<OsStr>>` so this can be set for UTF-8 string types.
Unfortunately, a specialization for `T: AsRef<str>` conflicts with `T: AsRef<OsStr>`, so stamp out string types with a macro.
r? ``@ChrisDenton``
Override default `Write` methods for cursor-like types
Override the default `io::Write` methods for cursor-like types to provide more efficient versions.
Writes to resizable containers already write everything, so implement `write_all` and `write_all_vectored` in terms of those. For fixed-sized containers, cut out unnecessary error checking and looping for those same methods.
| `impl Write for T` | `vectored` | `all` | `all_vectored` | `fmt` |
| ------------------------------- | ---------- | ----- | -------------- | ------- |
| `&mut [u8]` | Y | Y | new | |
| `Vec<u8>` | Y | Y | new | #137762 |
| `VecDeque<u8>` | Y | Y | new | #137762 |
| `std::io::Cursor<&mut [u8]>` | Y | new | new | |
| `std::io::Cursor<&mut Vec<u8>>` | Y | new | new | #137762 |
| `std::io::Cursor<Vec<u8>>` | Y | new | new | #137762 |
| `std::io::Cursor<Box<[u8]>>` | Y | new | new | |
| `std::io::Cursor<[u8; N]>` | Y | new | new | |
| `core::io::BorrowedCursor<'_>` | new | new | new | |
Tracked in https://github.com/rust-lang/rust/issues/136756.
# Open questions
Is it guaranteed by `Write::write_all` that the maximal write is performed when not everything can be written? Its documentation describes the behavior of the default implementation, which writes until a 0-length write is encountered, thus implying that a maximal write is expected. In contrast, `Read::read_exact` declares that the contents of the buffer are unspecified for short reads. If it were allowed, these cursor-like types could bail on the write altogether if it has insufficient capacity.
Revert vita's c_char back to i8
# Description
Hi!
https://github.com/rust-lang/rust/pull/132975 changed the definition of `c_char` from i8 to u8 for most ARM targets. While that would usually be correct, [VITASDK uses signed chars by default](https://github.com/vitasdk/buildscripts/blob/master/patches/gcc/0001-gcc-10.patch#L33-L34). The Clang definitions are incorrect because Clang is not (yet?) supported by the vita commmunity / `VITADSK`, On the Rust side, the pre-compiled libraries the user can link to are all compiled using vita's `gcc` and [we set `TARGET_CC` and `TARGET_CXX`](d564a132cb/src/commands/build.rs (L230)) in `cargo vita` for build scripts using `cc`.
I'm creating it as a draft PR so that we can discuss it and possibly get it approved here, but wait to merge the [libc side](https://github.com/rust-lang/libc/pull/4258) and get a libc version first, as having the definitions out of sync breaks std. As a nightly-only target it can be confusing/frustrating for new users when the latest nightly, which is the default, is broken.
In `walk_item`, we call `visit_id` on every item kind. For most of them
we do it directly in `walk_item`. But for `ItemKind::Mod`,
`ItemKind::Enum`, and `ItemKind::Use` we instead do it in the `walk_*`
function called (via the `visit_*` function) from `walk_item`.
I can see no reason for this inconsistency, so this commit makes those
three cases like all the other cases, moving the `visit_id` calls into
`walk_item`. This also avoids the need for a few `HirId` arguments.
The build compiler is already resolved inside the `ToolBuild` step,
so we should pass only the target compilers for `Mode::ToolRustc` tools.
Signed-off-by: onur-ozkan <work@onurozkan.dev>
