no unnecessary line-breaks in new text

Author: BatmanAoD

src/behavior-considered-undefined.md

@@ -77,9 +77,7 @@ r[undefined.target-feature]
   does not support (see [`target_feature`]), *except* if the platform explicitly documents this to be safe.
 
 r[undefined.call]
-* Calling a function with the wrong [call ABI][abi], or unwinding past a stack
-  frame that does not allow unwinding (e.g. by calling a `"C-unwind"` function
-  imported or transmuted as a `"C"` function or function pointer).
+* Calling a function with the wrong [call ABI][abi], or unwinding past a stack frame that does not allow unwinding (e.g. by calling a `"C-unwind"` function imported or transmuted as a `"C"` function or function pointer).
 
 r[undefined.invalid]
 * Producing an [invalid value][invalid-values]. "Producing" a
@@ -99,13 +97,9 @@ r[undefined.const-transmute-ptr2int]
   cast, e.g. by doing raw pointer casts or using a union.
 
 r[undefined.runtime]
-* Violating assumptions of the Rust runtime. Most assumptions of the Rust
-  runtime are currently not explicitly documented.
-  * For assumptions specifically related to unwinding, see the [panic
-    documentation][unwinding-ffi].
-  * The runtime assumes that a Rust stack frame is not deallocated without
-    executing destructors for local variables owned by the stack frame. This assumption
-    can be violated by C functions like `longjmp`.
+* Violating assumptions of the Rust runtime. Most assumptions of the Rust runtime are currently not explicitly documented.
+  * For assumptions specifically related to unwinding, see the [panic documentation][unwinding-ffi].
+  * The runtime assumes that a Rust stack frame is not deallocated without executing destructors for local variables owned by the stack frame. This assumption can be violated by C functions like `longjmp`.
 
 > **Note**: Undefined behavior affects the entire program. For example, calling
 > a function in C that exhibits undefined behavior of C means your entire

src/crates-and-source-files.md

@@ -125,21 +125,14 @@ use foo::bar as main;
 r[crate.uncaught-foreign-unwinding]
 ### Uncaught foreign unwinding
 
-When a "foreign" unwind (e.g. an exception thrown from C++ code, or a `panic!`
-in Rust code using a different panic handler) propagates beyond
-the `main` function, the process will be safely terminated. This may
-take the form of an abort, in which case it is not guaranteed that any `Drop`
-calls will be executed, and the error output may be less informative than if the
-runtime had been terminated by a "native" Rust `panic`.
+When a "foreign" unwind (e.g. an exception thrown from C++ code, or a `panic!` in Rust code using a different panic handler) propagates beyond the `main` function, the process will be safely terminated. This may take the form of an abort, in which case it is not guaranteed that any `Drop` calls will be executed, and the error output may be less informative than if the runtime had been terminated by a "native" Rust `panic`.
 
 For more information, see the [panic documentation][panic-docs].
 
 r[crate.no_main]
 ### The `no_main` attribute
 
-The *`no_main` [attribute]* may be applied at the crate level to disable
-emitting the `main` symbol for an executable binary. This is useful when some
-other object being linked to defines `main`.
+The *`no_main` [attribute]* may be applied at the crate level to disable emitting the `main` symbol for an executable binary. This is useful when some other object being linked to defines `main`.
 
 r[crate.crate_name]
 ## The `crate_name` attribute

src/destructors.md

@@ -274,8 +274,7 @@ Temporaries are also created to hold the result of operands to an expression
 while the other operands are evaluated. The temporaries are associated to the
 scope of the expression with that operand. Since the temporaries are moved from
 once the expression is evaluated, dropping them has no effect unless one of the
-operands to an expression breaks out of the expression, returns, or
-[panics][panic].
+operands to an expression breaks out of the expression, returns, or [panics][panic].
 
 ```rust
 # struct PrintOnDrop(&'static str);
@@ -439,17 +438,11 @@ variable or field from being dropped automatically.
 r[destructors.process-termination]
 ### Process termination without unwinding
 
-There are some ways to terminate the process without [unwinding], in which case
-destructors will not be run.
+There are some ways to terminate the process without [unwinding], in which case destructors will not be run.
 
-The standard library provides [`std::process::exit`] and
-[`std::process::abort`] to do this explicitly. Additionally, if the
-[panic handler][panic.panic_handler.std] is set to `abort`, panicking will always terminate the process
-without destructors being run.
+The standard library provides [`std::process::exit`] and [`std::process::abort`] to do this explicitly. Additionally, if the [panic handler][panic.panic_handler.std] is set to `abort`, panicking will always terminate the process without destructors being run.
 
-There is one additional case to be aware of: when a panic reaches a
-[non-unwinding ABI boundary], either no destructors will run, or all
-destructors up until the ABI boundary will run.
+There is one additional case to be aware of: when a panic reaches a [non-unwinding ABI boundary], either no destructors will run, or all destructors up until the ABI boundary will run.
 
 [Assignment]: expressions/operator-expr.md#assignment-expressions
 [binding modes]: patterns.md#binding-modes

src/items/external-blocks.md

@@ -122,9 +122,7 @@ r[items.extern.abi.system]
   API itself
 
 r[items.extern.abi.unwind]
-* `extern "C-unwind"` and `extern "system-unwind"` -- identical to `"C"` and
-  `"system"`, respectively, but with [different behavior][unwind-behavior] when
-  the callee unwinds (by panicking or throwing a C++ style exception).
+* `extern "C-unwind"` and `extern "system-unwind"` -- identical to `"C"` and `"system"`, respectively, but with [different behavior][unwind-behavior] when the callee unwinds (by panicking or throwing a C++ style exception).
 
 r[items.extern.abi.platform]
 There are also some platform-specific ABI strings:
@@ -156,8 +154,7 @@ r[items.extern.abi.efiapi]
 * `unsafe extern "efiapi"` -- The ABI used for [UEFI] functions.
 
 r[items.extern.abi.platform-unwind-variants]
-Like `"C"` and `"system"`, most platform-specific ABI strings also have a
-[corresponding `-unwind` variant][unwind-behavior]; specifically, these are:
+Like `"C"` and `"system"`, most platform-specific ABI strings also have a [corresponding `-unwind` variant][unwind-behavior]; specifically, these are:
 
 * `"aapcs-unwind"`
 * `"cdecl-unwind"`

src/items/functions.md

@@ -257,34 +257,16 @@ r[items.fn.extern.unwind]
 ### Unwinding
 
 r[items.fn.extern.unwind.intro]
-Most ABI strings come in two variants, one with an `-unwind` suffix and one without.
-The `Rust` ABI always permits unwinding, so there is no `Rust-unwind` ABI. The
-choice of ABI, together with the runtime [panic handler], determines
-the behavior when unwinding out of a function.
+Most ABI strings come in two variants, one with an `-unwind` suffix and one without. The `Rust` ABI always permits unwinding, so there is no `Rust-unwind` ABI. The choice of ABI, together with the runtime [panic handler], determines the behavior when unwinding out of a function.
 
 r[items.fn.extern.unwind.behavior]
-The table below indicates the behavior of an unwinding operation reaching each
-type of ABI boundary (function declaration or definition using the
-corresponding ABI string). Note that the Rust runtime is not affected by, and
-cannot have an effect on, any unwinding that occurs entirely within another
-language's runtime, that is, unwinds that are thrown and caught without
-reaching a Rust ABI boundary.
-
-The `panic`-unwind column refers to [panicking] via the `panic!` macro and
-similar standard library mechanisms, as well as to any other Rust operations
-that cause a panic, such as out-of-bounds array indexing or integer overflow.
-
-The "unwinding" ABI category refers to `"Rust"` (the implicit ABI of Rust
-functions not marked `extern`), `"C-unwind"`, and any other ABI with `-unwind`
-in its name. The "non-unwinding" ABI category refers to all other ABI strings,
-including `"C"` and `"stdcall"`.
-
-Native unwinding is defined per-target. On targets that support throwing and
-catching C++ exceptions, it refers to the mechanism used to implement this
-feature. Some platforms implement a form of unwinding referred to as ["forced
-unwinding"][forced-unwinding]; `longjmp` on Windows and `pthread_exit` in
-`glibc` are implemented this way. Forced unwinding is explicitly excluded
-from the "Native unwind" column in the table.
+The table below indicates the behavior of an unwinding operation reaching each type of ABI boundary (function declaration or definition using the corresponding ABI string). Note that the Rust runtime is not affected by, and cannot have an effect on, any unwinding that occurs entirely within another language's runtime, that is, unwinds that are thrown and caught without reaching a Rust ABI boundary.
+
+The `panic`-unwind column refers to [panicking] via the `panic!` macro and similar standard library mechanisms, as well as to any other Rust operations that cause a panic, such as out-of-bounds array indexing or integer overflow.
+
+The "unwinding" ABI category refers to `"Rust"` (the implicit ABI of Rust functions not marked `extern`), `"C-unwind"`, and any other ABI with `-unwind` in its name. The "non-unwinding" ABI category refers to all other ABI strings, including `"C"` and `"stdcall"`.
+
+Native unwinding is defined per-target. On targets that support throwing and catching C++ exceptions, it refers to the mechanism used to implement this feature. Some platforms implement a form of unwinding referred to as ["forced unwinding"][forced-unwinding]; `longjmp` on Windows and `pthread_exit` in `glibc` are implemented this way. Forced unwinding is explicitly excluded from the "Native unwind" column in the table.
 
 | panic runtime  | ABI           | `panic`-unwind                        | Native unwind (unforced) |
 | -------------- | ------------  | ------------------------------------- | -----------------------  |
@@ -294,11 +276,9 @@ from the "Native unwind" column in the table.
 | `panic=abort`  | non-unwinding | `panic` aborts without unwinding      | [undefined behavior]     |
 
 r[items.fn.extern.abort]
-With `panic=unwind`, when a `panic` is turned into an abort by a non-unwinding ABI boundary, either no destructors (`Drop` calls) will run, or all destructors
-up until the ABI boundary will run. It is unspecified which of those two behaviors will happen.
+With `panic=unwind`, when a `panic` is turned into an abort by a non-unwinding ABI boundary, either no destructors (`Drop` calls) will run, or all destructors up until the ABI boundary will run. It is unspecified which of those two behaviors will happen.
 
-For other considerations and limitations regarding unwinding across FFI
-boundaries, see the [relevant section in the Panic documentation][panic-ffi].
+For other considerations and limitations regarding unwinding across FFI boundaries, see the [relevant section in the Panic documentation][panic-ffi].
 
 [forced-unwinding]: https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html#forced-unwinding
 [panic handler]: ../panic.md#the-panic_handler-attribute
@@ -310,9 +290,7 @@ r[items.fn.const]
 ## Const functions
 
 r[items.fn.const.intro]
-Functions qualified with the `const` keyword are [const functions], as are
-[tuple struct] and [tuple variant] constructors. _Const functions_  can be
-called from within [const contexts].
+Functions qualified with the `const` keyword are [const functions], as are [tuple struct] and [tuple variant] constructors. _Const functions_  can be called from within [const contexts].
 
 r[items.fn.const.extern]
 Const functions may use the [`extern`] function qualifier.

src/linkage.md

@@ -272,8 +272,7 @@ binary link:
 Passing `rlib`s directly into your foreign linker is currently unsupported.
 
 > [!NOTE]
->  Rust code compiled or linked with a different instance of the Rust runtime counts as a
-> "foreign code" for the purpose of this section.
+>  Rust code compiled or linked with a different instance of the Rust runtime counts as "foreign code" for the purpose of this section.
 
 r[link.unwinding]
 ### Prohibited linkage and unwinding
@@ -284,31 +283,20 @@ Panic unwinding can only be used if the binary is built consistently according t
 r[link.unwinding.potential]
 A Rust artifact is called *potentially unwinding* if any of the following conditions is met:
 - The artifact uses the [`unwind` panic handler][panic.panic_handler].
-- The artifact contains a crate built with the `unwind` [panic strategy] that makes a call
-  to a function using a `-unwind` ABI.
-- The artifact makes a `"Rust"` ABI call to code running in another Rust
-  artifact that has a separate copy of the Rust runtime, and that other artifact is
-  potentially unwinding.
+- The artifact contains a crate built with the `unwind` [panic strategy] that makes a call to a function using a `-unwind` ABI.
+- The artifact makes a `"Rust"` ABI call to code running in another Rust artifact that has a separate copy of the Rust runtime, and that other artifact is potentially unwinding.
 
 > [!NOTE]
-> This definition captures whether a `"Rust"` ABI call inside a Rust artifact can ever
-> unwind.
+> This definition captures whether a `"Rust"` ABI call inside a Rust artifact can ever unwind.
 
 r[link.unwinding.prohibited]
-If a Rust artifact is potentially unwinding, then all its crates must be built with the `unwind` [panic strategy].
-Otherwise, unwinding can cause undefined behavior.
+If a Rust artifact is potentially unwinding, then all its crates must be built with the `unwind` [panic strategy]. Otherwise, unwinding can cause undefined behavior.
 
 > [!NOTE]
-> If you are using `rustc` to link, these rules are enforced automatically.
-> If you are *not* using `rustc` to link, you must take care to ensure that unwinding is handled consistently across the entire binary. Linking without `rustc` includes using `dlopen` or similar facilities where linking is done by the system runtime without `rustc` being involved.
->
-> This can only happen when mixing code with different [`-C panic`] flags, so most users do not have to be concerned about this.
+> If you are using `rustc` to link, these rules are enforced automatically. If you are *not* using `rustc` to link, you must take care to ensure that unwinding is handled consistently across the entire binary. Linking without `rustc` includes using `dlopen` or similar facilities where linking is done by the system runtime without `rustc` being involved. This can only happen when mixing code with different [`-C panic`] flags, so most users do not have to be concerned about this.
 
 > [!NOTE]
-> To guarantee that a library will be sound (and linkable with `rustc`)
-> regardless of the panic runtime used at link-time, the [`ffi_unwind_calls` lint]
-> may be used. The lint flags any calls to `-unwind` foreign functions or
-> function pointers.
+> To guarantee that a library will be sound (and linkable with `rustc`) regardless of the panic runtime used at link-time, the [`ffi_unwind_calls` lint] may be used. The lint flags any calls to `-unwind` foreign functions or function pointers.
 
 [`cfg` attribute `target_feature` option]: conditional-compilation.md#target_feature
 [`ffi_unwind_calls` lint]: ../rustc/lints/listing/allowed-by-default.html#ffi-unwind-calls