INT: disable SubstituteAssociatedTypeIntention for type aliases #6032
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
vlad20012
reviewed
Aug 30, 2020
src/main/kotlin/org/rust/ide/intentions/SubstituteAssociatedTypeIntention.kt
Outdated
Show resolved
Hide resolved
Kobzol
force-pushed
the
int-subst-assoc-type-no-type-alias
branch
from
287d35b
to
d95d9d1
Compare
|
bors r+ |
|
Build succeeded: |
bors bot
added a commit
that referenced
this pull request
Jul 2, 2021
7345: INT: enable SubstituteAssociatedTypeIntention for type aliases r=vlad20012 a=Kobzol This PR adds support for substituting type aliases to `SubstituteAssociatedTypeIntention`. This was previously disabled in #6032 due to problems with generic parameters (#6030). I used the approach hinted by @vlad20012 [here](#6030 (comment)), it seems to work fine. However, there is still a problem with paths using type aliases that are in expression context and that have inferred type arguments (see the commented test). In this situation, the resolved type is just a new type argument placeholder (e.g. `T`), but it's not resolved to the actual type yet (https://github.com/intellij-rust/intellij-rust/blob/master/src/main/kotlin/org/rust/lang/core/resolve/ref/RsPathReferenceImpl.kt#L234). I need a way to somehow get the inferred result of the type from type inference. I can get the type of the function call `Foo::new` (`fn() -> S<i32>`), but I need the type of `Foo` (`S<i32>`). Is there some existing way of doing that? changelog: The intention that enables you to substitute associated types now works on all type aliases. Co-authored-by: Jakub Beránek <berykubik@gmail.com>
bors bot
added a commit
that referenced
this pull request
Jul 2, 2021
7345: INT: enable SubstituteAssociatedTypeIntention for type aliases r=vlad20012 a=Kobzol This PR adds support for substituting type aliases to `SubstituteAssociatedTypeIntention`. This was previously disabled in #6032 due to problems with generic parameters (#6030). I used the approach hinted by @vlad20012 [here](#6030 (comment)), it seems to work fine. However, there is still a problem with paths using type aliases that are in expression context and that have inferred type arguments (see the commented test). In this situation, the resolved type is just a new type argument placeholder (e.g. `T`), but it's not resolved to the actual type yet (https://github.com/intellij-rust/intellij-rust/blob/master/src/main/kotlin/org/rust/lang/core/resolve/ref/RsPathReferenceImpl.kt#L234). I need a way to somehow get the inferred result of the type from type inference. I can get the type of the function call `Foo::new` (`fn() -> S<i32>`), but I need the type of `Foo` (`S<i32>`). Is there some existing way of doing that? changelog: The intention that enables you to substitute associated types now works on all type aliases. Co-authored-by: Jakub Beránek <berykubik@gmail.com>
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
SubstituteAssociatedTypeIntentionhas also worked for type aliases. It is OK in basic cases, but for generic type aliases (which cannot occur currently for associated types on stable - this is the infamous GAT feature) it doesn't work properly. There are some issues with propagating type arguments and also with handling the alias itself - it's only properly supported for ADTs currently. So for now I think that we should disable this intention for type aliases.Fixes: #6030