}
impl_from!(TypeParam, LifetimeParam, ConstParam for GenericParam);
+impl GenericParam {
+ pub fn module(self, db: &dyn HirDatabase) -> Module {
+ match self {
+ GenericParam::TypeParam(it) => it.module(db),
+ GenericParam::LifetimeParam(it) => it.module(db),
+ GenericParam::ConstParam(it) => it.module(db),
+ }
+ }
+
+ pub fn name(self, db: &dyn HirDatabase) -> Name {
+ match self {
+ GenericParam::TypeParam(it) => it.name(db),
+ GenericParam::LifetimeParam(it) => it.name(db),
+ GenericParam::ConstParam(it) => it.name(db),
+ }
+ }
+}
+
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct TypeParam {
pub(crate) id: TypeParamId,
Definition::ModuleDef(it) => it.try_to_nav(db),
Definition::SelfType(it) => it.try_to_nav(db),
Definition::Local(it) => Some(it.to_nav(db)),
- Definition::TypeParam(it) => it.try_to_nav(db),
- Definition::LifetimeParam(it) => it.try_to_nav(db),
+ Definition::GenericParam(it) => it.try_to_nav(db),
Definition::Label(it) => Some(it.to_nav(db)),
- Definition::ConstParam(it) => it.try_to_nav(db),
}
}
}
}
}
+impl TryToNav for hir::GenericParam {
+ fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
+ match self {
+ hir::GenericParam::TypeParam(it) => it.try_to_nav(db),
+ hir::GenericParam::ConstParam(it) => it.try_to_nav(db),
+ hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),
+ }
+ }
+}
+
impl ToNav for hir::Local {
fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
let src = self.source(db);
Definition::Field(it) => it.resolve_doc_path(db, link, ns),
Definition::SelfType(_)
| Definition::Local(_)
- | Definition::TypeParam(_)
- | Definition::ConstParam(_)
- | Definition::LifetimeParam(_)
+ | Definition::GenericParam(_)
| Definition::Label(_) => return None,
}?;
let krate = resolved.module(db)?.krate();
Definition::Field(it) => it.resolve_doc_path(db, link, ns),
Definition::SelfType(_)
| Definition::Local(_)
- | Definition::TypeParam(_)
- | Definition::LifetimeParam(_)
- | Definition::ConstParam(_)
+ | Definition::GenericParam(_)
| Definition::Label(_) => return None,
}
}
use hir::{
- Adt, AsAssocItem, AssocItemContainer, FieldSource, HasAttrs, HasSource, HirDisplay, Module,
- ModuleDef, ModuleSource, Semantics,
+ Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
+ HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
};
use ide_db::base_db::SourceDatabase;
use ide_db::{
}
};
- if let Definition::TypeParam(it) = def {
+ if let Definition::GenericParam(GenericParam::TypeParam(it)) = def {
it.trait_bounds(db).into_iter().for_each(|it| push_new_def(it.into()));
} else {
let ty = match def {
Definition::Local(it) => it.ty(db),
- Definition::ConstParam(it) => it.ty(db),
+ Definition::GenericParam(GenericParam::ConstParam(it)) => it.ty(db),
_ => return None,
};
})
}
Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
- Definition::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
- Definition::TypeParam(type_param) => Some(Markup::fenced_block(&type_param.display(db))),
- Definition::ConstParam(it) => from_def_source(db, it, None),
+ Definition::GenericParam(it) => match it {
+ GenericParam::TypeParam(it) => Some(Markup::fenced_block(&it.display(db))),
+ GenericParam::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
+ GenericParam::ConstParam(it) => from_def_source(db, it, None),
+ },
};
fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
kind = ReferenceKind::FieldShorthandForLocal;
}
}
- } else if matches!(def, Definition::LifetimeParam(_) | Definition::Label(_)) {
+ } else if matches!(
+ def,
+ Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+ ) {
kind = ReferenceKind::Lifetime;
};
}
},
Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
- Definition::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
- Definition::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+ Definition::GenericParam(it) => match it {
+ hir::GenericParam::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
+ hir::GenericParam::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+ hir::GenericParam::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
+ },
Definition::Local(local) => {
let tag = if local.is_param(db) {
HlTag::Symbol(SymbolKind::ValueParam)
}
return h;
}
- Definition::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
}
.into()
// FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
use hir::{
- db::HirDatabase, ConstParam, Crate, Field, HasVisibility, Impl, Label, LifetimeParam, Local,
- MacroDef, Module, ModuleDef, Name, PathResolution, Semantics, TypeParam, Visibility,
+ db::HirDatabase, Crate, Field, GenericParam, HasVisibility, Impl, Label, Local, MacroDef,
+ Module, ModuleDef, Name, PathResolution, Semantics, Visibility,
};
use syntax::{
ast::{self, AstNode},
ModuleDef(ModuleDef),
SelfType(Impl),
Local(Local),
- TypeParam(TypeParam),
- LifetimeParam(LifetimeParam),
- ConstParam(ConstParam),
+ GenericParam(GenericParam),
Label(Label),
}
Definition::ModuleDef(it) => it.module(db),
Definition::SelfType(it) => Some(it.module(db)),
Definition::Local(it) => Some(it.module(db)),
- Definition::TypeParam(it) => Some(it.module(db)),
- Definition::LifetimeParam(it) => Some(it.module(db)),
- Definition::ConstParam(it) => Some(it.module(db)),
+ Definition::GenericParam(it) => Some(it.module(db)),
Definition::Label(it) => Some(it.module(db)),
}
}
Definition::ModuleDef(def) => def.definition_visibility(db),
Definition::SelfType(_) => None,
Definition::Local(_) => None,
- Definition::TypeParam(_) => None,
- Definition::LifetimeParam(_) => None,
- Definition::ConstParam(_) => None,
+ Definition::GenericParam(_) => None,
Definition::Label(_) => None,
}
}
},
Definition::SelfType(_) => return None,
Definition::Local(it) => it.name(db)?,
- Definition::TypeParam(it) => it.name(db),
- Definition::LifetimeParam(it) => it.name(db),
- Definition::ConstParam(it) => it.name(db),
+ Definition::GenericParam(it) => it.name(db),
Definition::Label(it) => it.name(db),
};
Some(name)
},
ast::TypeParam(it) => {
let def = sema.to_def(&it)?;
- Some(NameClass::Definition(Definition::TypeParam(def)))
+ Some(NameClass::Definition(Definition::GenericParam(def.into())))
},
ast::ConstParam(it) => {
let def = sema.to_def(&it)?;
- Some(NameClass::Definition(Definition::ConstParam(def)))
+ Some(NameClass::Definition(Definition::GenericParam(def.into())))
},
_ => None,
}
match parent {
ast::LifetimeParam(it) => {
let def = sema.to_def(&it)?;
- Some(NameClass::Definition(Definition::LifetimeParam(def)))
+ Some(NameClass::Definition(Definition::GenericParam(def.into())))
},
ast::Label(it) => {
let def = sema.to_def(&it)?;
| SyntaxKind::WHERE_PRED
| SyntaxKind::REF_TYPE => sema
.resolve_lifetime_param(lifetime)
- .map(Definition::LifetimeParam)
+ .map(GenericParam::LifetimeParam)
+ .map(Definition::GenericParam)
.map(NameRefClass::Definition),
// lifetime bounds, as in the 'b in 'a: 'b aren't wrapped in TypeBound nodes so we gotta check
// if our lifetime is in a LifetimeParam without being the constrained lifetime
!= Some(lifetime) =>
{
sema.resolve_lifetime_param(lifetime)
- .map(Definition::LifetimeParam)
+ .map(GenericParam::LifetimeParam)
+ .map(Definition::GenericParam)
.map(NameRefClass::Definition)
}
_ => None,
Definition::ModuleDef(def)
}
PathResolution::Local(local) => Definition::Local(local),
- PathResolution::TypeParam(par) => Definition::TypeParam(par),
+ PathResolution::TypeParam(par) => Definition::GenericParam(par.into()),
PathResolution::Macro(def) => Definition::Macro(def),
PathResolution::SelfType(impl_def) => Definition::SelfType(impl_def),
- PathResolution::ConstParam(par) => Definition::ConstParam(par),
+ PathResolution::ConstParam(par) => Definition::GenericParam(par.into()),
}
}
}
return SearchScope::new(res);
}
- if let Definition::LifetimeParam(param) = self {
+ if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {
let range = match param.parent(db) {
hir::GenericDef::Function(it) => {
it.source(db).and_then(|src| Some(src.value.syntax().text_range()))