| Age | Commit message (Collapse) | Author | Lines |
|---|
|
|
|
feat: support navigation on primitives
|
|
|
|
|
|
|
|
|
|
This was removed in rustc in 2022: https://github.com/rust-lang/rust/pull/101123
Closes #20525.
|
|
fix: add `else` keyword completion after `let` statements
|
|
Improve make::struct_ field_list whitespace
|
|
Example
---
**Before this PR**:
```rust
struct Variant{
field: u32
}
```
**After this PR**:
```rust
struct Variant {
field: u32
}
```
|
|
Example
---
```rust
fn foo() {
let _ = 2 el$0
}
```
->
```rust
fn foo() {
let _ = 2 else {
$0
};
}
```
|
|
Examples
---
```rust
mod indent {
struct Foo {}
fn foo() {
let foo = Foo{};
foo.bar$0;
}
}
```
**Before this PR**:
```rust
mod indent {
struct Foo { bar: ()
}
fn foo() {
let foo = Foo{};
foo.bar;
}
}
```
**After this PR**:
```rust
mod indent {
struct Foo {
bar: ()
}
fn foo() {
let foo = Foo{};
foo.bar;
}
}
```
---
New field list add newline
```rust
mod indent {
struct Foo;
fn foo() {
Foo.bar$0;
}
}
```
**Before this PR**:
```rust
mod indent {
struct Foo{ bar: () }
fn foo() {
Foo.bar;
}
}
```
**After this PR**:
```rust
mod indent {
struct Foo {
bar: (),
}
fn foo() {
Foo.bar;
}
}
```
|
|
internal: Upgrade rustc crates
|
|
Example
---
```rust
fn main() {
let x = 1*x $0+ 2;
}
```
**Before this PR**:
```rust
fn main() {
let x = 1*x.wrapping_add(2);
}
```
**After this PR**:
```rust
fn main() {
let x = (1*x).wrapping_add(2);
}
```
|
|
The main changes are (there are some other small changes):
- Using a specific type for trait IDs in the new solver, allowing us to simplify a lot of code.
- Add `BoundConst` similar to `BoundTy` and `BoundRegion` (previously consts used `BoundVar` directly), due to a new trait requirement.
|
|
internal: Add a regression test for a fixed new trait solver bug
|
|
Not sure what exactly fixed it, but why not.
|
|
To make it backwards-compatible.
|
|
Example
---
```rust
#[cfg_attr($0, must_use)]
struct Foo;
```
|
|
Example
---
```rust
fn f() { $0!(1 || 3 && 4 || 5) }
```
->
```rust
fn f() { !1 && !(3 && 4) && !5 }
```
|
|
fix: Make sense of the mess that were (are) different kind of generics in the solver
|
|
Example
---
**Not applicable**:
```rust
fn foo() {
match () {
() => {
t(|n|$0 n + 100);
}
}
}
```
|
|
Because duplicates can be found with traits. Worse, the inherent methods could be private, and we'll discover that only later. But even if they're not they're different methods, and its seems worthy to present them all to the user.
|
|
To the extent possible.
Previously they were confused. Sometimes generic params were treated as `Param` and sometimes as `Placeholder`. A completely redundant (in the new solver) mapping of salsa::Id to ints to intern some info where we could just store it uninterned (not in Chalk though, for some weird reason).
Plus fix a cute bug in closure substitution that was caught by the assertions of Chalk but the next solver did not have such assertions. Do we need more assertions?
|
|
|
|
fix: When mapping next-solver's `dyn` type, add `Self` (aka. bound var ^1.0) to auto traits' substitutions
|
|
fix: Add progress bars to more places in analysis-stats
|
|
auto traits' substitutions
Chalk represents dyn types as a list of predicate, the self type should be there. The next solver represents them quite differently. The `Self` was forgotten for the auto trait case.
|
|
A DB is enough.
|
|
Namely, mir lowering, const eval and IDE things.
|
|
|
|
fix: In highlight_related, when on an unsafe block, don't highlight unsafe operations of other unsafe blocks
|
|
perf: Cache trait solving across queries in the same revision
|
|
operations of other unsafe blocks
|
|
Replace it with normal `SolverDefId::TypeAliasId`.
The split caused a very funny bug where code was getting `TypeAliasId` where it expected `ForeignId`, because `TypeAliasId` had a `From` impl from `hir_def::TypeAliasId` and `ForeignId` had not, plus a careless `into()`.
I could've fixed this specific bug but opted to remove the split instead; currently, it just provides more room for bugs, as we don't have typed IDs for the solver anyway, and even when we'll have (hopefully), that doesn't seem like a very useful distinction, for example in hir-def foreign types are just `TypeAliasId` with some flags.
Constructing a test for this isn't trivial; the trivial test (creating a foreign type, even proving a trait bound for it) fails to fail before the change, probably because we don't use the new solver everywhere yet so we don't trigger this specific code path.
|
|
|
|
Enable warning logs by default
|
|
Fix ExprStmt delete semicolon for toggle_macro_delimiter
|
|
Fix indent for move_guard_to_arm_body
|
|
feat: Add an option to remove reborrows from adjustment inlay hints
|
|
fix: Normalize all types when finishing inference
|
|
Make import sorting order follow 2024 edition style
|
|
`NormalizesTo` is a private predicate that should not be used outside the solver. For normalization, rustc uses `AliasRelate`, so replace with that.
|
|
The new solver does not eagerly normalize, but things after inference expect types to be normalized. rustc does the same.
Also, I'm afraid other things in r-a don't expect results of the solver to be unnormalized. We'll need to handle that.
|
|
Caching trait solving can do a lot to speed. Unfortunately it also consume a huge amount of memory. Therefore, as part of the migration to the new solver Jack Huey disabled caching of trait solving (he made the query transparent).
The PR proposes a middle ground: do cache trait solving, but only for the same revision. This allows us to be safe because during a revision the inputs cannot change.
The result is hopefully much better performance to features that tend to do a bulk of trait solving, and also repeat the same query (e.g. inference then IDE features).
There is another limitation: results are only cached in the same thread, to remove the need for synchronization which will be expensive. More measurements are required to check whether it's better to use a synchronized global cache, or maybe stay with a thread-local cache but batch multiple feature requests (highlighting, inlay hints etc.) of the same file to the same thread.
Alongside the actual cache we store the revision, because we need to verify it (we can't eagerly clear caches when incrementing the revision), and also the address of the db to prevent multiple dbs from interleaving (this is mostly relevant in tests, although injected highlighting also uses a new db, therefore maybe it's better to move it to a separate thread).
This "games" analysis-stats to both be way faster and use way more memory; the former is because analysis-stats doesn't increment revisions, therefore all queries share the cache and hit ratio is way too good, the latter is because analysis-stats doesn't increment revisions and therefore the cache isn't cleared. Both are not representative of a typical IDE scenario.
|
|
|
|
|
|
fix: Fix opaque generics
|
|
The parent generics were incorrectly not considered for TAIT.
I'm not convinced we should follow rustc here, also there are items (opaques) with more than 1 parent (opaque -> fn/type alias -> impl/trait) and I'm not sure we properly account for that in all places, but for now I left it as-is.
Also fix a bug where lifetimes' indices were incorrect when there is a self param (they started from 0 instead of 1).
|
|
Add ReturnExpr completion suggest
|
