Terminals supporting the OSC8 Hyperlink Extension can support inline
anchors where the text is user defineable but clicking on it opens a
browser to a specified URLs, just like `<a href="URL">` does in HTML.

https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda

Co-authored-by: Manish Goregaokar <manishsmail@gmail.com>

…, r=lcnr

Implement `deferred_projection_equality` for erica solver

Somewhat of a revival of rust-lang#96912. When relating projections now emit an `AliasEq` obligation instead of attempting to determine equality of projections that may not be as normalized as possible (i.e. because of lazy norm, or just containing inference variables that prevent us from resolving an impl). Only do this when the new solver is enabled

cast_possible_truncation: issue proper help message

Fixes rust-lang#10325

---

changelog: Sugg: [`cast_possible_truncation`]: Corrected the lint name in help message
[rust-lang#10330](rust-lang/rust-clippy#10330)
<!-- changelog_checked-->

…=flip1995

lintcheck: fix clap panic

clap 4.1.4 panics if `-` is used at the start of an argument:

```
$ cargo lintcheck
[…]
thread 'main' panicked at 'Argument recursive: long "--recursive" must not start with a `-`, that will be handled by the parser', /home/sam/.cargo/registry/src/github.com-1ecc6299db9ec823/clap-4.1.4/src/builder/debug_asserts.rs:82:13
```

changelog: none
<!-- changelog_checked -->

…declarations

[arithmetic_side_effects] Fix rust-lang#10209

Fix rust-lang#10209

---

changelog: Enhancement: [`arithmetic_side_effects`]: No longer lints, if safe constant values are used.
[rust-lang#10310](rust-lang/rust-clippy#10310)
<!-- changelog_checked -->

… r=Manishearth

Add `suspicious_command_arg_space` lint

Fixes rust-lang#10316

---

changelog: New lint: [`suspicious_command_arg_space`]
[rust-lang#10317](rust-lang/rust-clippy#10317)
<!-- changelog_checked -->

…gisa

Introduce `-Zterminal-urls` to use OSC8 for error codes

Terminals supporting the OSC8 Hyperlink Extension can support inline anchors where the text is user defineable but clicking on it opens a browser to a specified URLs, just like `<a href="URL">` does in HTML.

https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda

Almost swapped

Take over from rust-lang/rust-clippy#8945

Fix rust-lang/rust-clippy#8151

---

changelog: enhancement: [`almost_swapped`]: Now detects almost swaps using `let` statements
[rust-lang#10177](rust-lang/rust-clippy#10177)
<!-- changelog_checked -->

…e_lib_with_trait_alias, r=oli-obk

Move folding & visiting traits into type library

This is a rework of rust-lang#107712, following feedback on that PR.

In particular, this version uses trait aliases to reduce the API churn for trait consumers.  Doing so requires a workaround for rust-lang#107747 until its fix in rust-lang#107803 is merged into the stage0 compiler; this workaround, which uses conditional compilation based on the `bootstrap` configuration predicate, sits in dedicated commit b409329 for ease of reversion.

The possibility of the `rustc_middle` crate retaining its own distinct versions of each folding/visiting trait, blanket-implemented on all types that implement the respective trait in the type library, was also explored: however since this would necessitate making each `rustc_middle` trait a subtrait of the respective type library trait (so that such blanket implementations can delegate their generic methods), no benefit would be gained.

r? types

…nishearth

book: move warning to the right place

changelog: none

This lint complains when the question mark operator (try operator)
is used.  This is a restriction lint that can be useful on local
scopes where a custom error handling macro is supposed to be used
to augment the error based on local scope data before returning.

`combine_seq(x, NeverLoopResult::Otherwise)`  always returns `x`

All evaluations now happen in order.

The following code

```
loop {
    'a: {
        { }
        break 'a;
    }
}
```

was detected as a never-looping loop.

It is not sufficient to ignore break from a block inside the loop.
Instructions after the break must be ignored, as they are unreachable.
This is also true for all instructions in outer blocks and loops
until the right block is reached.

…ilstrieb

Use `is_str` instead of string kind comparison

Split out from rust-lang#107939

[never_loop] Fix rust-lang#10304

It is not sufficient to ignore break from a block inside the loop. Instructions after the break must be ignored, as they are unreachable. This is also true for all instructions in outer blocks and loops until the right block is reached.

Fixes rust-lang#10304

---

changelog: FP: [`never_loop`]: No longer lints, for statements following break statements for outer blocks.
[rust-lang#10311](rust-lang/rust-clippy#10311)
<!-- changelog_checked-->

…iaskrgr

Rollup of 9 pull requests

Successful merges:

 - rust-lang#107573 (Update the minimum external LLVM to 14)
 - rust-lang#107626 (Fix `x fix` on the standard library itself)
 - rust-lang#107673 (update ICU4X to 1.1.0)
 - rust-lang#107733 (Store metrics from `metrics.json` to CI PGO timer)
 - rust-lang#108007 (Use `is_str` instead of string kind comparison)
 - rust-lang#108033 (add an unstable `#[rustc_coinductive]` attribute)
 - rust-lang#108039 (Refactor refcounted structural_impls via functors)
 - rust-lang#108040 (Use derive attributes for uninteresting traversals)
 - rust-lang#108044 (interpret: rename Pointer::from_addr → from_addr_invalid)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Do not base map_entry lint suggestion on expanded code

Fixes rust-lang#10331

changelog: [`map_entry`]: do not base suggestion on code expanded by the compiler

…_by_value

The divergent `else` block of a `let`/`else` statement does not make
the `let`/`else` statement itself divergent.

manual_let_else: let/else is not divergent by default

The divergent `else` block of a `let`/`else` statement does not make the `let/else` statement itself divergent.

Fixes rust-lang#10296

changelog: [`manual_let_else`]: do not consider `let`/`else` to be divergent by default

…less_pass_by_value, r=matthiaskrgr

Liberate late-bound regions rather than erasing them in `needless_pass_by_value`

changelog: [`needless_pass_by_value`]: fixes an ICE when there are late-bound regions in function arguments that are needlessly passed by value

Fixes rust-lang#107147
r? `@matthiaskrgr`

The naming of `machine` only makes sense from a mir interpreter internals perspective, but outside users talk about the `target` platform

fix [`needless_return`] incorrect suggestion when returning if sequence

fixes: rust-lang#10049

---

changelog: [`needless_return`]: fix incorrect suggestion  on if sequence

uninlined_format_args: do not inline argument with generic parameters

Fix rust-lang#10339

---

changelog: FP: [`uninlined_format_args`]: No longer lints for arguments with generic parameters
[rust-lang#10343](rust-lang/rust-clippy#10343)
<!-- changelog_checked -->

Fix false positives for `extra_unused_type_parameters`

Don't lint external macros. Also, if the function body is empty, any type parameters with bounds on them are not linted. Note that only the body needs be empty - this rule still applies if the function takes any arguments.

fixes rust-lang#10318
fixes rust-lang#10319
changelog: none
<!-- changelog_checked -->

Ignore synthetic type parameters for `extra_unused_type_parameters`

There was a minor bug around calculating spans when forming the help message. An example:

```rust
fn unused_opaque<A, B>(dummy: impl Default) {}
//               ^^ ^
```

In this case, the entire list of generics should be highlighted, instead of each individual parameter. The culprit is the `impl Default`, which registers as a type parameter but doesn't live within the `<...>`. Because synthetic parameters can't ever be manually created, we just ignore them for this lint.

r? `@flip1995`
changelog: none
<!-- changelog_checked -->

Avoid accessing HIR when it can be avoided

Experiment to see if it helps some incremental cases.

Will be rebased once rust-lang#107942 gets merged.

r? `@ghost`

As this is a lint about "style", and a purely cosmetical choice (using `<A: Trait>` over `impl Trait`), a lot of other files needed to be allowed this lint.

Use `target` instead of `machine` for mir interpreter integer handling.

The naming of `machine` only makes sense from a mir interpreter internals perspective, but outside users talk about the `target` platform. As per rust-lang#108029 (comment)

r? `@RalfJung`

Change unusual_byte_groupings to require byte groupings of equal size

Fixes issue rust-lang#6556

This lint required byte groupings of size 2 or 4 for `Radix::Binary` and `Radix::Hexadecimal`. Since there are good reasons for allowing groups of other sizes, this PR relaxes the restriction. This lint now requires that

- group sizes after the first group be of the same size and
- greater or equal in size to the first group.

---

changelog: [`unusual_byte_groupings`]: reduce false positives by relaxing restriction requiring groups of specific sizes.

[significant_drop_tightening] Add MVP

cc rust-lang#9399

Creates the lint with minimum functionalities, which is a good start IMO.

---

changelog: new lint: [`significant_drop_tightening`]
[rust-lang#10163](rust-lang/rust-clippy#10163)
<!-- changelog_checked -->

…logiq

Add `let_underscore_untyped`

Fixes rust-lang#6842

This adds a new pedantic `let_underscore_untyped` lint which checks for `let _ = <expr>`, and suggests to either provide a type annotation, or to remove the `let` keyword. That way the author is forced to specify the type they intended to ignore, and thus get forced to re-visit the decision should the type of `<expr>` change. Alternatively, they can drop the `let` keyword to truly just ignore the value no matter what.

r? `@llogiq`

changelog: New lint: [let_underscore_untyped]

… r=Alexendoo

Add question-mark-used lint

This lint complains when the question mark operator (try operator) is used.  This is a restriction lint that can be useful on local scopes where a custom error handling macro is supposed to be used to augment the error based on local scope data before returning.

Fixes rust-lang#10340

---

changelog: New lint [`question_mark_used`]
[rust-lang#10342](rust-lang/rust-clippy#10342)
<!-- changelog_checked -->

…ro_wrapper, r=llogiq

Add the `transmute_int_to_non_zero` lint

Fixes rust-lang#10288

This adds a new complexity lint `transmute_int_to_non_zero` which checks for transmutes to any of the `NonZero*` types, and suggests their `new_unchecked` method instead.

r? `@llogiq`

changelog: New lint: [`transmute_int_to_non_zero`]

Stop doc_markdown requiring backticks on links to external websites

Fixes rust-lang#10302

This lint currently checks that any link should be enclosed with `backticks` if the title looks like a lang item. This PR changes the lint to only run on internal links. External links, indicated by `http` or `https`, are skipped.

This PR also reorganises `pulldown_cmark` imports to bypass the clippy lint enforcing 100 line functions.

---

changelog: Stop doc_markdown requiring backticks on links to external websites

Stop bytes_nth from suggesting code that does not compile

Fixes rust-lang#10151

As discussed in the issue, this PR changes the lint in 2 ways

1. Replace `bytes().nth(n).unwrap()` with `as_bytes()[n]`
2. Replace other `bytes().nth(n)` with `as_bytes().get(n).copied()`

---

changelog: Stop bytes_nth from suggesting code that does not compile in some cases

manual_let_else: do not suggest semantically different replacements

The problem is that this lint does not consider the possibility that the divergent branch can come first and that the patterns may overlap. This led to incorrect suggestions, previously registered as correct in the tests themselves:

```rust
let v = match build_enum() {
    _ => continue,
    Variant::Bar(v) | Variant::Baz(v) => v,
};
```

had a `let Variant::Bar(v) | Variant::Baz(v) = v else { continue; }` suggestion, which is obviously wrong as the original code `continue`s in any case. Issue rust-lang#10241 gives another example.

The code now checks that the divergent branch comes second. It could be extended later (I've added a TODO) to check for non-overlapping patterns.

Fixes rust-lang#10241.

changelog: [`manual_let_else`] do not suggest non equivalent replacements in `match`

…rs, r=cjgillot

Implement partial support for non-lifetime binders

This implements support for non-lifetime binders. It's pretty useless currently, but I wanted to put this up so the implementation can be discussed.

Specifically, this piggybacks off of the late-bound lifetime collection code in `rustc_hir_typeck::collect::lifetimes`. This seems like a necessary step given the fact we don't resolve late-bound regions until this point, and binders are sometimes merged.

Q: I'm not sure if I should go along this route, or try to modify the earlier nameres code to compute the right bound var indices for type and const binders eagerly... If so, I'll need to rename all these queries to something more appropriate (I've done this for `resolve_lifetime::Region` -> `resolve_lifetime::ResolvedArg`)

cc rust-lang/types-team#81

r? `@ghost`

…ype_of in metadata

Switch to `EarlyBinder` for `type_of` query

Part of the work to finish rust-lang#105779 and implement rust-lang/types-team#78.

Several queries `X` have a `bound_X` variant that wraps the output in `EarlyBinder`. This adds `EarlyBinder` to the return type of the `type_of` query and removes `bound_type_of`.

r? `@lcnr`

There are several `mk_foo`/`intern_foo` pairs, where the former takes an
iterator and the latter takes a slice. (This naming convention is bad,
but that's a fix for another PR.)

This commit changes several `mk_foo` occurrences into `intern_foo`,
avoiding the need for some `.iter()`/`.into_iter()` calls. Affected
cases:
- mk_type_list
- mk_tup
- mk_substs
- mk_const_list

…rs, r=oli-obk,compiler-errors

Clarify iterator interners

I found the iterator interners very confusing. This PR clarifies things.

r? `@compiler-errors`

[significant_drop_tightening] Ignore inexpensive statements

Not all statements that follow the last use of a lock guard are expensive and can therefore be ignored by the lint.

```rust
pub fn foo() -> i32 {
    let mutex = Mutex::new(1);
    let lock = mutex.lock().unwrap();
    let rslt = *lock;
    let another = rslt;
   another
}
```

---

changelog: [`significant_drop_tightening`]: No longer lints for inexpensive statements after the lock guard
[rust-lang#10363](rust-lang/rust-clippy#10363)
<!-- changelog_checked -->