Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 21:43:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix highlighting of const patterns

Browse source
This commit is contained in:
Aleksey Kladov 2020-02-28 16:36:14 +01:00
parent 209eb32796
commit 5ebfcb9cb7
5 changed files with 60 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
crates/ra_hir/src/semantics.rs
View file

@ -18,8 +18,8 @@ use crate::{
db::HirDatabase, db::HirDatabase,
source_analyzer::{resolve_hir_path, ReferenceDescriptor, SourceAnalyzer}, source_analyzer::{resolve_hir_path, ReferenceDescriptor, SourceAnalyzer},
source_binder::{ChildContainer, SourceBinder}, source_binder::{ChildContainer, SourceBinder},
Function, HirFileId, InFile, Local, MacroDef, Module, Name, Origin, Path, PathResolution, Function, HirFileId, InFile, Local, MacroDef, Module, ModuleDef, Name, Origin, Path,
ScopeDef, StructField, Trait, Type, TypeParam, VariantDef, PathResolution, ScopeDef, StructField, Trait, Type, TypeParam, VariantDef,
}; };
use ra_prof::profile; use ra_prof::profile;
@ -129,6 +129,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
self.analyze(path.syntax()).resolve_path(self.db, path) self.analyze(path.syntax()).resolve_path(self.db, path)
} }
pub fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option<ModuleDef> {
self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
}
// FIXME: use this instead? // FIXME: use this instead?
// pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>; // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;

31
crates/ra_hir/src/source_analyzer.rs
View file

@ -11,9 +11,9 @@ use either::Either;
use hir_def::{ use hir_def::{
body::{ body::{
scope::{ExprScopes, ScopeId}, scope::{ExprScopes, ScopeId},
BodySourceMap, Body, BodySourceMap,
}, },
expr::{ExprId, PatId}, expr::{ExprId, Pat, PatId},
resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs}, resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
AsMacroCall, DefWithBodyId, AsMacroCall, DefWithBodyId,
}; };
@ -25,8 +25,8 @@ use ra_syntax::{
}; };
use crate::{ use crate::{
db::HirDatabase, Adt, Const, EnumVariant, Function, Local, MacroDef, Path, Static, Struct, db::HirDatabase, Adt, Const, EnumVariant, Function, Local, MacroDef, ModuleDef, Path, Static,
Trait, Type, TypeAlias, TypeParam, Struct, Trait, Type, TypeAlias, TypeParam,
}; };
/// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
@ -35,6 +35,7 @@ use crate::{
pub(crate) struct SourceAnalyzer { pub(crate) struct SourceAnalyzer {
file_id: HirFileId, file_id: HirFileId,
pub(crate) resolver: Resolver, pub(crate) resolver: Resolver,
body: Option<Arc<Body>>,
body_source_map: Option<Arc<BodySourceMap>>, body_source_map: Option<Arc<BodySourceMap>>,
infer: Option<Arc<InferenceResult>>, infer: Option<Arc<InferenceResult>>,
scopes: Option<Arc<ExprScopes>>, scopes: Option<Arc<ExprScopes>>,
@ -66,7 +67,7 @@ impl SourceAnalyzer {
node: InFile<&SyntaxNode>, node: InFile<&SyntaxNode>,
offset: Option<TextUnit>, offset: Option<TextUnit>,
) -> SourceAnalyzer { ) -> SourceAnalyzer {
let (_body, source_map) = db.body_with_source_map(def); let (body, source_map) = db.body_with_source_map(def);
let scopes = db.expr_scopes(def); let scopes = db.expr_scopes(def);
let scope = match offset { let scope = match offset {
None => scope_for(&scopes, &source_map, node), None => scope_for(&scopes, &source_map, node),
@ -75,6 +76,7 @@ impl SourceAnalyzer {
let resolver = resolver_for_scope(db, def, scope); let resolver = resolver_for_scope(db, def, scope);
SourceAnalyzer { SourceAnalyzer {
resolver, resolver,
body: Some(body),
body_source_map: Some(source_map), body_source_map: Some(source_map),
infer: Some(db.infer(def)), infer: Some(db.infer(def)),
scopes: Some(scopes), scopes: Some(scopes),
@ -88,6 +90,7 @@ impl SourceAnalyzer {
) -> SourceAnalyzer { ) -> SourceAnalyzer {
SourceAnalyzer { SourceAnalyzer {
resolver, resolver,
body: None,
body_source_map: None, body_source_map: None,
infer: None, infer: None,
scopes: None, scopes: None,
@ -197,6 +200,24 @@ impl SourceAnalyzer {
self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into()) self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into())
} }
pub(crate) fn resolve_bind_pat_to_const(
&self,
db: &impl HirDatabase,
pat: &ast::BindPat,
) -> Option<ModuleDef> {
let pat_id = self.pat_id(&pat.clone().into())?;
let body = self.body.as_ref()?;
let path = match &body[pat_id] {
Pat::Path(path) => path,
_ => return None,
};
let res = resolve_hir_path(db, &self.resolver, &path)?;
match res {
PathResolution::Def(def) => Some(def),
_ => None,
}
}
pub(crate) fn resolve_path( pub(crate) fn resolve_path(
&self, &self,
db: &impl HirDatabase, db: &impl HirDatabase,

15
crates/ra_ide/src/snapshots/highlighting.html
View file

@ -65,10 +65,17 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
<span class="variable mutable">y</span>; <span class="variable mutable">y</span>;
} }
<span class="keyword">enum</span> <span class="enum">E</span>&lt;<span class="type_param">X</span>&gt; { <span class="keyword">enum</span> <span class="enum">Option</span>&lt;<span class="type_param">T</span>&gt; {
<span class="enum_variant">V</span>(<span class="type_param">X</span>) <span class="enum_variant">Some</span>(<span class="type_param">T</span>),
<span class="enum_variant">None</span>,
} }
<span class="keyword">use</span> <span class="enum">Option</span>::*;
<span class="keyword">impl</span>&lt;<span class="type_param">X</span>&gt; <span class="enum">E</span>&lt;<span class="type_param">X</span>&gt; { <span class="keyword">impl</span>&lt;<span class="type_param">T</span>&gt; <span class="enum">Option</span>&lt;<span class="type_param">T</span>&gt; {
<span class="keyword">fn</span> <span class="function">new</span>&lt;<span class="type_param">T</span>&gt;() -&gt; <span class="enum">E</span>&lt;<span class="type_param">T</span>&gt; {} <span class="keyword">fn</span> <span class="function">and</span>&lt;<span class="type_param">U</span>&gt;(<span class="keyword">self</span>, <span class="variable">other</span>: <span class="enum">Option</span>&lt;<span class="type_param">U</span>&gt;) -&gt; <span class="enum">Option</span>&lt;(<span class="type_param">T</span>, <span class="type_param">U</span>)&gt; {
<span class="keyword control">match</span> <span class="variable">other</span> {
<span class="enum_variant">None</span> =&gt; <span class="macro">todo</span><span class="macro">!</span>(),
<span class="variable">Nope</span> =&gt; <span class="variable">Nope</span>,
}
}
}</code></pre> }</code></pre>

15
crates/ra_ide/src/syntax_highlighting/tests.rs
View file

@ -50,12 +50,19 @@ fn main() {
y; y;
} }
enum E<X> { enum Option<T> {
V(X) Some(T),
None,
} }
use Option::*;
impl<X> E<X> { impl<T> Option<T> {
fn new<T>() -> E<T> {} fn and<U>(self, other: Option<U>) -> Option<(T, U)> {
match other {
None => todo!(),
Nope => Nope,
}
}
} }
"# "#
.trim(), .trim(),

6
crates/ra_ide_db/src/defs.rs
View file

@ -90,6 +90,12 @@ impl NameClass {
} }
pub fn classify_name(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<NameClass> { pub fn classify_name(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Option<NameClass> {
if let Some(bind_pat) = name.syntax().parent().and_then(ast::BindPat::cast) {
if let Some(def) = sema.resolve_bind_pat_to_const(&bind_pat) {
return Some(NameClass::ConstReference(NameDefinition::ModuleDef(def)));
}
}
classify_name_inner(sema, name).map(NameClass::NameDefinition) classify_name_inner(sema, name).map(NameClass::NameDefinition)
} }