| Age | Commit message (Collapse) | Author | Lines |
|---|
|
Example
---
```rust
struct Foo { num: u32 }
struct Bar(Foo);
fn foo(Bar($0)) {}
```
**Before this PR**:
```rust
struct Foo { num: u32 }
struct Bar(Foo);
fn foo(Bar(Foo { num$1 }: Foo$0)) {}
```
**After this PR**:
```rust
struct Foo { num: u32 }
struct Bar(Foo);
fn foo(Bar(Foo { num$1 }$0)) {}
```
|
|
Fix extra semicolon before else in let-stmt
|
|
Example
---
```rust
fn main() {
let x = if true {
()
} $0 else {};
}
```
**Before this PR**:
```rust
fn main() {
let x = if true {
()
} else if $1 {
$0
}; else {};
}
```
**After this PR**:
```rust
fn main() {
let x = if true {
()
} else if $1 {
$0
} else {};
}
```
|
|
fix: Make `#[target_feature]` always safe on WASM
|
|
Fix empty generic param list for generate_function
|
|
Example
---
```rust
struct Foo<S>(S);
impl<S> Foo<S> {
fn foo(&self) {
self.bar()$0;
}
}
```
**Before this PR**:
```rust
struct Foo<S>(S);
impl<S> Foo<S> {
fn foo(&self) {
self.bar();
}
fn bar<>(&self) ${0:-> _} {
todo!()
}
}
```
**After this PR**:
```rust
struct Foo<S>(S);
impl<S> Foo<S> {
fn foo(&self) {
self.bar();
}
fn bar(&self) ${0:-> _} {
todo!()
}
}
```
|
|
fix: Always coerce in a cast, even when there are unknown types
|
|
This cause the relationships between inference vars to get recorded.
|
|
internal: Upgrade rustc crates
|
|
fix: Fix normalization in the new solver
|
|
Previously normalization was broken, which caused a lot of fake errors.
This fix most type mismatches of the new solver, and it also reverts many test regressions.
The downside is that now `chalk_ir::TyKind::AssociatedType`/`chalk_ir::TyKind::Alias` cannot be trusted anymore with their roles, namely: `AssociatedType` is always fully normalized and `Alias` only if it can possibly be normalized further. That seems okay as the new solver does not have this distinction at all (due to it being a lazy normalizer), so this will only hold for the migration time. This does mean we have to change some APIs, notably `hir::Type::walk()` and `TyFingerprint`, to treat `Alias` the same as `AssociatedType`.
Another small thing this commit does is to isolate processing of user-written types (currently involving replacing error types and normalizing, but in the future validation will also be needed) to separate functions.
|
|
More correctly, a `TyKind::AssociatedType` is not the same as `TyKind::Projection`.
We used to map next-solver `TyKind::Alias` to Chalk's `TyKind::AssociatedType`. This is very incorrect, as `AssociatedType` is assumed to be fully normalized, and caused a lot of type mismatches.
Unfortunately fixing this causes a lot of stack overflows, because the next solver doesn't have something akin to `AssociatedType` so we normalize again and again. The reason is that is the lazy-normalization nature of the next solver, which means we need to stop normalizing everything. This will be fixed in the next commit.
|
|
A lot of simplification and fun.
|
|
They have to do with diagnostics, we could probably not support them but we will also someday want good diagnostics.
The code is mostly copied from rustc.
|
|
Fix indent for unresolved_field fixes
|
|
fix: Resolve paths to snapshot test libraries absolutely
|
|
Migrate `InferenceTable` into next-solver
|
|
|
|
|
|
Even when the feature isn't enabled, as it's not UB to invoke an undefined feature in WASM (just a trap).
|
|
And make it easier to expand it more in the future, if needed.
|
|
That is, resolve them globally, not from the test's location.
This *should* result in more robust resolution; for example, previously the code failed to detect the presence of snapshot testing if the snapshot library was renamed in the dependency or was an indirect dependency.
|
|
Fix LifetimeParam::lifetime_bounds invalid implement
|
|
Add a FAQ entry about RA and Cargo build lock/cache conflicts
|
|
Lifetime node example:
```
LIFETIME_PARAM@15..21
LIFETIME@15..17
LIFETIME_IDENT@15..17 "'a"
COLON@17..18 ":"
WHITESPACE@18..19 " "
TYPE_BOUND_LIST@19..21
TYPE_BOUND@19..21
LIFETIME@19..21
LIFETIME_IDENT@19..21 "'b"
```
|
|
|
|
|
|
feat: support navigation on primitives
|
|
|
|
|
|
|
|
Clarify intro in README and manual
|
|
The first sentence a new user should see should ideally answer the
questions:
* What is rust-analyzer?
* Why might I want to use it?
The vast majority of users will be interested in using rust-analyzer
inside their favourite editor. We should clarify that rust-analyzer is
an LSP implementation and that it supports all the classic IDE
features.
Whilst it's also true that rust-analyzer is modular and organised into
libraries, the first impression should (I think) focus on an overview
and the primary use case.
|
|
Remove support for register_attr
|
|
|
|
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
|
|
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
|
|
fix: Fix typo in config
|
|
Not sure what exactly fixed it, but why not.
|
|
To make it backwards-compatible.
|
|
fix: Make sense of the mess that were (are) different kind of generics in the solver
|
|
fix: Deduplicate methods in completion by function ID and not by name
|
|
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.
|
