bors[bot] [Fri, 6 Dec 2019 14:19:06 +0000 (14:19 +0000)]
Merge #2487
2487: Don't unify within a reference r=matklad a=flodiebold
If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
Florian Diebold [Thu, 5 Dec 2019 22:02:31 +0000 (23:02 +0100)]
Don't unify within a reference
If we are expecting a `&Foo` and get a `&something`, when checking the
`something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever
we get with that expectation, because it could actually be a `&Foo`, and `&&Foo`
coerces to `&Foo`. So this fixes quite a few false type mismatches.
bors[bot] [Thu, 5 Dec 2019 20:00:20 +0000 (20:00 +0000)]
Merge #2479
2479: Add expansion infrastructure for derive macros r=matklad a=flodiebold
I thought I'd experiment a bit with attribute macro/derive expansion, and here's what I've got so far. It has dummy implementations of the Copy / Clone derives, to show that the approach works; it doesn't add any attribute macro support, but I think that fits into the architecture.
Basically, during raw item collection, we look at the attributes and generate macro calls for them if necessary. Currently I only do this for derives, and just add the derive macro calls as separate calls next to the item. I think for derives, it's important that they don't obscure the actual item, since they can't actually change it (e.g. sending the item token tree through macro expansion unnecessarily might make completion within it more complicated).
Attribute macros would have to be recognized at that stage and replace the item (i.e., the raw item collector will just emit an attribute macro call, and not the item). I think when we implement this, we should try to recognize known inert attributes, so that we don't do macro expansion unnecessarily; anything that isn't known needs to be treated as a possible attribute macro call (since the raw item collector can't resolve the macro yet).
There's basically no name resolution for attribute macros implemented, I just hardcoded the built-in derives. In the future, the built-ins should work within the normal name resolution infrastructure; the problem there is that the builtin stubs in `std` use macros 2.0, which we don't support yet (and adding support is outside the scope of this).
One aspect that I don't really have a solution for, but I don't know how important it is, is removing the attribute itself from its input. I'm pretty sure rustc leaves out the attribute macro from the input, but to do that, we'd have to create a completely new syntax node. I guess we could do it when / after converting to a token tree.
bors[bot] [Tue, 3 Dec 2019 17:16:02 +0000 (17:16 +0000)]
Merge #2472
2472: Split up ty tests a bit r=matklad a=flodiebold
`simple` is a bit of a kitchen sink (and not all of them are really about 'simple' features), suggestions for further divisions there are welcome :smile:
bors[bot] [Tue, 3 Dec 2019 14:02:23 +0000 (14:02 +0000)]
Merge #2468
2468: Fix #2467 r=flodiebold a=flodiebold
The stand-alone `unify` requires that the type doesn't contain any type
variables. So we can't share the code here for now (without more refactoring)...
Florian Diebold [Tue, 3 Dec 2019 13:59:29 +0000 (14:59 +0100)]
Fix #2467
The stand-alone `unify` requires that the type doesn't contain any type
variables. So we can't share the code here for now (without more refactoring)...
bors[bot] [Tue, 3 Dec 2019 12:58:44 +0000 (12:58 +0000)]
Merge #2463
2463: More correct method resolution r=flodiebold a=flodiebold
This should fix the order in which candidates for method resolution are considered, i.e. `(&Foo).clone()` should now be of type `Foo` instead of `&Foo`. It also checks for inherent candidates that the self type unifies properly with the self type in the impl (i.e. `impl Foo<u32>` methods will only be considered for `Foo<u32>`).
To be able to get the correct receiver type to check in the method resolution, I needed the unification logic, so I extracted it to the `unify.rs` module.
In particular it is necessary to clone the repository before running the other commands. I also removed the `cargo install` side note because it didn't actually work (running the command just produces an error that --package isn't a recognized flag) and added a tldr code block with the list of commands to run.
Co-authored-by: Jonathan Behrens <fintelia@gmail.com>
In particular it is necessary to clone the repository before running the other commands. I also removed the `cargo install` side note because it didn't actually work (running the command just produces an error that --package isn't a recognized flag) and added a tldr code block with the list of commands to run.
bors[bot] [Sat, 30 Nov 2019 19:19:28 +0000 (19:19 +0000)]
Merge #2451
2451: Use env_logger instead of flexi_logger r=matklad a=AlexanderEkdahl
This fixes https://github.com/rust-analyzer/rust-analyzer/issues/2335
- By default only `error` will be printed. From what I can tell this matches the current behaviour. Configured through `RUST_LOG`.
- I looked through the optional dependencies for `env_logger`and I have only enabled `human_time`. Without this feature no timestamp will be shown for log messages.
- `RA_LOG_DIR` feature is removed
This PR adds 2 new dependencies(`env_logger` and `human_time`) and removes 6 dependencies.
Co-authored-by: Alexander Ekdahl <alexander@ekdahl.io>
bors[bot] [Sat, 30 Nov 2019 14:23:18 +0000 (14:23 +0000)]
Merge #2453
2453: Handle various cycles r=matklad a=flodiebold
- handle `impl Trait<Self> for SomeType`, which is allowed. This necessitated splitting the `impl_ty` query, but I think the result actually makes a lot of code nicer. This should fix #2446.
- add recovery for `impl Trait for SomeType<Self>`
- add recovery for `type Type = Foo<Type>`
- add recovery for cycles in generic param env