Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 05:23:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
32609 commits 3 branches 270 tags 150 MiB
Commit graph

32609 commits

This branch
This branch
All branches
Author SHA1 Message Date
Lukas Wirth
8ffa5ecb76
Merge pull request #18667 from 1hakusai1/generate_custom_imple_with_no_snippet 
fix: Generate implementation with items even if snippet text edit is disabled
 2024-12-12 10:51:44 +00:00
1hakusai1
fc2b70132f Generate implementation with items even if snippet text edit is disabled 2024-12-12 18:55:14 +09:00
bors
67dcb7a3c3 Auto merge of #129181 - beetrees:asm-spans, r=pnkfelix,compiler-errors 
Pass end position of span through inline ASM cookie

Before this PR, only the start position of the span was passed though the inline ASM cookie to diagnostics. LLVM 19 has full support for 64-bit inline ASM cookies; this PR uses that to pass the end position of the span in the upper 32 bits, meaning inline ASM diagnostics now point at the entire line the error occurred on, not just the first character of it.
 2024-12-12 02:34:06 +00:00
bors
ead998e6de Auto merge of #128004 - folkertdev:naked-fn-asm, r=Amanieu 
codegen `#[naked]` functions using global asm

tracking issue: https://github.com/rust-lang/rust/issues/90957

Fixes #124375

This implements the approach suggested in the tracking issue: use the existing global assembly infrastructure to emit the body of `#[naked]` functions. The main advantage is that we now have full control over what gets generated, and are no longer dependent on LLVM not sneakily messing with our output (inlining, adding extra instructions, etc).

I discussed this approach with `@Amanieu` and while I think the general direction is correct, there is probably a bunch of stuff that needs to change or move around here. I'll leave some inline comments on things that I'm not sure about.

Combined with https://github.com/rust-lang/rust/pull/127853, if both accepted, I think that resolves all steps from the tracking issue.

r? `@Amanieu`
 2024-12-11 21:51:07 +00:00
Laurențiu Nicola
b707b5a117
Merge pull request #18466 from ChayimFriedman2/proper-lint-severity 
Properly handle different defaults for severity of lints
 2024-12-11 20:05:39 +00:00
Laurențiu Nicola
547be42074
Merge pull request #18666 from samestep/manual-autopublish-link 
Fix publish workflow link in manual
 2024-12-11 19:50:55 +00:00
Sam Estep
33f7d1dae1 Fix publish workflow link in manual 2024-12-11 14:35:36 -05:00
Giga Bowser
21782b9a8d minor: Group extract_function with other extraction assists 2024-12-11 14:11:20 -05:00
bors
8e244991f9 Auto merge of #134177 - matthiaskrgr:rollup-hgp8q60, r=matthiaskrgr 
Rollup of 6 pull requests

Successful merges:

 - #132975 (De-duplicate and improve definition of core::ffi::c_char)
 - #133598 (Change `GetManyMutError` to match T-libs-api decision)
 - #134148 (add comments in check_expr_field)
 - #134163 (coverage: Rearrange the code for embedding per-function coverage metadata)
 - #134165 (wasm(32|64): update alignment string)
 - #134170 (Subtree update of `rust-analyzer`)

r? `@ghost`
`@rustbot` modify labels: rollup
 2024-12-11 19:06:46 +00:00
Giga Bowser
0cad614b3b feat: Add an assist to extract an expression into a static 2024-12-11 14:04:54 -05:00
Matthias Krüger
48f34bb639
Rollup merge of #134170 - lnicola:sync-from-ra, r=lnicola 
Subtree update of `rust-analyzer`

r? `@ghost`
 2024-12-11 20:00:22 +01:00
Matthias Krüger
d41a896908
Rollup merge of #133598 - ChayimFriedman2:get-many-mut-detailed-err, r=scottmcm 
Change `GetManyMutError` to match T-libs-api decision

That is, differentiate between out-of-bounds and overlapping indices, and remove the generic parameter `N`.

I also exported `GetManyMutError` from `alloc` (and `std`), which was apparently forgotten.

Changing the error to carry additional details means LLVM no longer generates separate short-circuiting branches for the checks, instead it generates one branch at the end. I therefore changed the  code to use early returns to make LLVM generate jumps. Benchmark results between the approaches are somewhat mixed, but I chose this approach because it is significantly faster with ranges and also faster with `unwrap()`.

Benchmark (`jumps` refer to short-circuiting, `acc` is not short-circuiting):
```rust
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use my_crate::{get_many_check_valid_acc, get_many_check_valid_jumps, GetManyMutError};

mod externs {
    #[unsafe(no_mangle)]
    fn foo() {}
    #[unsafe(no_mangle)]
    fn bar() {}
    #[unsafe(no_mangle)]
    fn baz() {}
}

unsafe extern "C" {
    safe fn foo();
    safe fn bar();
    safe fn baz();
}

fn bench_method(c: &mut Criterion) {
    c.bench_function("jumps two usize", |b| {
        b.iter(|| get_many_check_valid_jumps(&[black_box(1), black_box(5)], black_box(10)))
    });
    c.bench_function("jumps two usize unwrap", |b| {
        b.iter(|| get_many_check_valid_jumps(&[black_box(1), black_box(5)], black_box(10)).unwrap())
    });
    c.bench_function("jumps two usize ok", |b| {
        b.iter(|| get_many_check_valid_jumps(&[black_box(1), black_box(5)], black_box(10)).ok())
    });
    c.bench_function("jumps three usize", |b| {
        b.iter(|| {
            get_many_check_valid_jumps(&[black_box(1), black_box(5), black_box(7)], black_box(10))
        })
    });
    c.bench_function("jumps three usize match", |b| {
        b.iter(|| {
            match get_many_check_valid_jumps(
                &[black_box(1), black_box(5), black_box(7)],
                black_box(10),
            ) {
                Err(GetManyMutError::IndexOutOfBounds) => foo(),
                Err(GetManyMutError::OverlappingIndices) => bar(),
                Ok(()) => baz(),
            }
        })
    });
    c.bench_function("jumps two Range", |b| {
        b.iter(|| {
            get_many_check_valid_jumps(
                &[black_box(1)..black_box(5), black_box(7)..black_box(8)],
                black_box(10),
            )
        })
    });
    c.bench_function("jumps two RangeInclusive", |b| {
        b.iter(|| {
            get_many_check_valid_jumps(
                &[black_box(1)..=black_box(5), black_box(7)..=black_box(8)],
                black_box(10),
            )
        })
    });

    c.bench_function("acc two usize", |b| {
        b.iter(|| get_many_check_valid_acc(&[black_box(1), black_box(5)], black_box(10)))
    });
    c.bench_function("acc two usize unwrap", |b| {
        b.iter(|| get_many_check_valid_acc(&[black_box(1), black_box(5)], black_box(10)).unwrap())
    });
    c.bench_function("acc two usize ok", |b| {
        b.iter(|| get_many_check_valid_acc(&[black_box(1), black_box(5)], black_box(10)).ok())
    });
    c.bench_function("acc three usize", |b| {
        b.iter(|| {
            get_many_check_valid_acc(&[black_box(1), black_box(5), black_box(7)], black_box(10))
        })
    });
    c.bench_function("acc three usize match", |b| {
        b.iter(|| {
            match get_many_check_valid_jumps(
                &[black_box(1), black_box(5), black_box(7)],
                black_box(10),
            ) {
                Err(GetManyMutError::IndexOutOfBounds) => foo(),
                Err(GetManyMutError::OverlappingIndices) => bar(),
                Ok(()) => baz(),
            }
        })
    });
    c.bench_function("acc two Range", |b| {
        b.iter(|| {
            get_many_check_valid_acc(
                &[black_box(1)..black_box(5), black_box(7)..black_box(8)],
                black_box(10),
            )
        })
    });
    c.bench_function("acc two RangeInclusive", |b| {
        b.iter(|| {
            get_many_check_valid_acc(
                &[black_box(1)..=black_box(5), black_box(7)..=black_box(8)],
                black_box(10),
            )
        })
    });
}

criterion_group!(benches, bench_method);
criterion_main!(benches);
```
Benchmark results:
```none
jumps two usize          time:   [586.44 ps 590.20 ps 594.50 ps]
jumps two usize unwrap   time:   [390.44 ps 393.63 ps 397.44 ps]
jumps two usize ok       time:   [585.52 ps 591.74 ps 599.38 ps]
jumps three usize        time:   [976.51 ps 983.79 ps 991.51 ps]
jumps three usize match  time:   [390.82 ps 393.80 ps 397.07 ps]
jumps two Range          time:   [1.2583 ns 1.2640 ns 1.2695 ns]
jumps two RangeInclusive time:   [1.2673 ns 1.2770 ns 1.2877 ns]
acc two usize            time:   [592.63 ps 596.44 ps 600.52 ps]
acc two usize unwrap     time:   [582.65 ps 587.07 ps 591.90 ps]
acc two usize ok         time:   [581.59 ps 587.82 ps 595.71 ps]
acc three usize          time:   [894.69 ps 901.23 ps 908.24 ps]
acc three usize match    time:   [392.68 ps 395.73 ps 399.17 ps]
acc two Range            time:   [1.5531 ns 1.5617 ns 1.5711 ns]
acc two RangeInclusive   time:   [1.5746 ns 1.5840 ns 1.5939 ns]
```
 2024-12-11 20:00:14 +01:00
Chayim Refael Friedman
0b7a6f38d7 Properly handle different defaults for severity of lints 
Previously all lints were assumed to be `#[warn]`, and we had a hand-coded list of `#[allow]` exceptions. Now the severity is autogenerated from rustdoc output.

Also support lints that change status between editions, and the `warnings` lint group.
 2024-12-11 20:48:41 +02:00
Giga Bowser
135e71fcb3 minor: Add item_static constructor to SyntaxFactory 2024-12-11 10:32:32 -05:00
Giga Bowser
1979d3f9b5 feat: Add an assist to extract an expression into a constant 2024-12-11 09:52:03 -05:00
Giga Bowser
17e482b1a9 internal: Move is_body_const to ide_assists::utils 2024-12-11 09:52:03 -05:00
Giga Bowser
27a2f9d594 minor: Add item_const constructor to SyntaxFactory 2024-12-11 09:52:03 -05:00
Lukas Wirth
e7a4c99ce3
Merge pull request #18663 from Veykril/push-syoklzkntykn 
fix: Swallow rustfmt parsing panics
 2024-12-11 10:06:28 +00:00
Laurențiu Nicola
b248e53859
Merge pull request #18662 from lnicola/sync-from-rust 
internal: Sync from downstream
 2024-12-11 10:05:39 +00:00
Lukas Wirth
8963e9736b fix: Swallow rustfmt parsing panics 2024-12-11 10:52:04 +01:00
Laurențiu Nicola
c1433e9742 Bump rustc crates 2024-12-11 11:50:19 +02:00
Laurențiu Nicola
30262281eb Merge from rust-lang/rust 2024-12-11 11:49:08 +02:00
Laurențiu Nicola
b19be7dcfe Preparing for merge from rust-lang/rust 2024-12-11 11:48:46 +02:00
Lukas Wirth
16c0f25579 Fix copied proc-macros not being cleaned up on exit 2024-12-11 10:17:33 +01:00
Lukas Wirth
f370550b0a Unload proc-macro dlls on changed timestamp 2024-12-11 09:34:27 +01:00
Lukas Wirth
41f3319173
Merge pull request #18458 from Giga-Bowser/master 
feat: Add diagnostic fix to remove unnecessary wrapper in type mismatch
 2024-12-11 07:09:15 +00:00
Lukas Wirth
087cb629be
Merge pull request #18653 from SomeoneToIgnore/hash-completions 
Hash completion items to properly match them during /resolve
 2024-12-11 07:08:33 +00:00
Lukas Wirth
002fcea441
Merge pull request #18657 from Giga-Bowser/generate-enum-variant 
minor: Migrate `generate_enum_variant` to `SyntaxEditor`
 2024-12-11 07:07:22 +00:00
Lukas Wirth
b0c82c974d
Merge pull request #18656 from roife/fix-issue-18639 
feat: preserve order of parameters in extract_functions
 2024-12-11 07:00:17 +00:00
roife
78fb0e47ca feat: preserve order of parameters in extract_functions 2024-12-11 02:26:58 +08:00
Giga Bowser
547f75a2ce minor: Migrate generate_enum_variant to SyntaxEditor 2024-12-10 13:11:33 -05:00
Giga Bowser
21b376583a minor: Add ty_infer constructor to SyntaxFactory 2024-12-10 12:33:32 -05:00
Giga Bowser
d7d68310c0 minor: Add whitespace constructor to SyntaxFactory 2024-12-10 12:25:13 -05:00
Giga Bowser
c70bf568bb minor: Add item_enum constructor to SyntaxFactory 
I recursively added all constructors it depends on. I also changed the old `make::` constructors to support more of the grammar.
 2024-12-10 11:12:44 -05:00
Kirill Bulatov
4169926b3f Address the feedback from pascalkuthe 
* Use Base64 to minify the hash representation in the JSON data
* Do hash checks only for items with similar labels
 2024-12-10 13:01:23 +02:00
Kirill Bulatov
2529e9e1e1 Address the feedback from Veykril 
* Exclude documentation field from hashing
* Do less cloning during initial completion list generation
 2024-12-10 12:33:30 +02:00
bors
4c05bc75bb Auto merge of #133902 - Kobzol:ci-dist-arm-runner, r=MarcoIeni 
CI: move `dist-arm-linux` to an ARM runner

First, I want to test whether we could actually move this to a free runner, vs moving to the 8-core ARM runner.

Fixes: https://github.com/rust-lang/infra-team/issues/181

r? `@MarcoIeni`

try-job: dist-arm-linux
 2024-12-10 07:44:46 +00:00
Laurențiu Nicola
7b4b83ba91
Merge pull request #18649 from roife/fix-issue-18648 
minor: enhance name suggestion for `Arc<T>` and `Rc<T>`
 2024-12-10 07:05:36 +00:00
Laurențiu Nicola
54879d9ae4
Merge pull request #18650 from yuki0iq/fix-typo 
crates/r-a: Fix typo in debug message
 2024-12-10 05:08:21 +00:00
Giga Bowser
68b85ce66f minor: Migrate remove_unnecessary_wrapper to SyntaxEditor 2024-12-09 21:16:31 -05:00
Giga Bowser
59cd717602 fix: Handle the final statement in SyntaxFactory::block_expr properly 
This caused a bug that was rather tricky to hunt down!
 2024-12-09 21:15:15 -05:00
Giga Bowser
d881208d1b Add diagnostic fix to remove unnecessary wrapper in type mismatch 
I also reorganized the tests in a more logical order, and removed the redundant `test_` prefix from their names.
 2024-12-09 21:15:15 -05:00
Kirill Bulatov
d8d35dbfcc Clippy fixes 2024-12-10 01:04:02 +02:00
Kirill Bulatov
89c2aaed8c Avoid hashing completion-related ranges as those may change during /resolve query 2024-12-10 00:45:57 +02:00
Yuki Sireneva
dff827741d
crates/r-a: Fix typo in debug message 2024-12-10 00:13:17 +03:00
Kirill Bulatov
b59b2fb469 Unite more bool hashing 2024-12-09 22:38:55 +02:00
Kirill Bulatov
5906bda975 Stop excluding Helix from the general resolve path 2024-12-09 22:26:00 +02:00
Kirill Bulatov
d348ffb480 Always compute the hash when r-a wants the imports to be resolved 2024-12-09 22:26:00 +02:00
Kirill Bulatov
62d97d9ba7 Draft completion hashing 2024-12-09 22:26:00 +02:00
roife
9c03cbb499 minor: enhance name suggestion for Arc<T> and Rc<T> 2024-12-10 02:47:52 +08:00