Rename NameDefinition -> Definition

2 files changed, 21 insertions, 21 deletions

diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index 571236fdc..0bbf893f8 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,22 +1,22 @@
 //! Functions that are used to classify an element from its definition or reference.
 
 use hir::{Local, PathResolution, Semantics};
-use ra_ide_db::defs::NameDefinition;
+use ra_ide_db::defs::Definition;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
 
 pub enum NameRefClass {
-    NameDefinition(NameDefinition),
-    FieldShorthand { local: Local, field: NameDefinition },
+    Definition(Definition),
+    FieldShorthand { local: Local, field: Definition },
 }
 
 impl NameRefClass {
-    pub fn definition(self) -> NameDefinition {
+    pub fn definition(self) -> Definition {
         match self {
-            NameRefClass::NameDefinition(def) => def,
-            NameRefClass::FieldShorthand { local, field: _ } => NameDefinition::Local(local),
+            NameRefClass::Definition(def) => def,
+            NameRefClass::FieldShorthand { local, field: _ } => Definition::Local(local),
         }
     }
 }
@@ -32,14 +32,14 @@ pub(crate) fn classify_name_ref(
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_methods);
         if let Some(func) = sema.resolve_method_call(&method_call) {
-            return Some(NameRefClass::NameDefinition(NameDefinition::ModuleDef(func.into())));
+            return Some(NameRefClass::Definition(Definition::ModuleDef(func.into())));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_fields);
         if let Some(field) = sema.resolve_field(&field_expr) {
-            return Some(NameRefClass::NameDefinition(NameDefinition::StructField(field)));
+            return Some(NameRefClass::Definition(Definition::StructField(field)));
         }
     }
 
@@ -47,9 +47,9 @@ pub(crate) fn classify_name_ref(
         tested_by!(goto_def_for_record_fields);
         tested_by!(goto_def_for_field_init_shorthand);
         if let Some((field, local)) = sema.resolve_record_field(&record_field) {
-            let field = NameDefinition::StructField(field);
+            let field = Definition::StructField(field);
             let res = match local {
-                None => NameRefClass::NameDefinition(field),
+                None => NameRefClass::Definition(field),
                 Some(local) => NameRefClass::FieldShorthand { field, local },
             };
             return Some(res);
@@ -59,26 +59,26 @@ pub(crate) fn classify_name_ref(
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
         tested_by!(goto_def_for_macros);
         if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
-            return Some(NameRefClass::NameDefinition(NameDefinition::Macro(macro_def)));
+            return Some(NameRefClass::Definition(Definition::Macro(macro_def)));
         }
     }
 
     let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = sema.resolve_path(&path)?;
     let res = match resolved {
-        PathResolution::Def(def) => NameDefinition::ModuleDef(def),
+        PathResolution::Def(def) => Definition::ModuleDef(def),
         PathResolution::AssocItem(item) => {
             let def = match item {
                 hir::AssocItem::Function(it) => it.into(),
                 hir::AssocItem::Const(it) => it.into(),
                 hir::AssocItem::TypeAlias(it) => it.into(),
             };
-            NameDefinition::ModuleDef(def)
+            Definition::ModuleDef(def)
         }
-        PathResolution::Local(local) => NameDefinition::Local(local),
-        PathResolution::TypeParam(par) => NameDefinition::TypeParam(par),
-        PathResolution::Macro(def) => NameDefinition::Macro(def),
-        PathResolution::SelfType(impl_def) => NameDefinition::SelfType(impl_def),
+        PathResolution::Local(local) => Definition::Local(local),
+        PathResolution::TypeParam(par) => Definition::TypeParam(par),
+        PathResolution::Macro(def) => Definition::Macro(def),
+        PathResolution::SelfType(impl_def) => Definition::SelfType(impl_def),
     };
-    Some(NameRefClass::NameDefinition(res))
+    Some(NameRefClass::Definition(res))
 }
diff --git a/crates/ra_ide/src/references/search_scope.rs b/crates/ra_ide/src/references/search_scope.rs
index 27d483233..d98c84d91 100644
--- a/crates/ra_ide/src/references/search_scope.rs
+++ b/crates/ra_ide/src/references/search_scope.rs
@@ -12,7 +12,7 @@ use rustc_hash::FxHashMap;
 
 use ra_ide_db::RootDatabase;
 
-use super::NameDefinition;
+use super::Definition;
 
 pub struct SearchScope {
     entries: FxHashMap<FileId, Option<TextRange>>,
@@ -23,7 +23,7 @@ impl SearchScope {
         SearchScope { entries: FxHashMap::default() }
     }
 
-    pub(crate) fn for_def(def: &NameDefinition, db: &RootDatabase) -> SearchScope {
+    pub(crate) fn for_def(def: &Definition, db: &RootDatabase) -> SearchScope {
         let _p = profile("search_scope");
         let module = match def.module(db) {
             Some(it) => it,
@@ -32,7 +32,7 @@ impl SearchScope {
         let module_src = module.definition_source(db);
         let file_id = module_src.file_id.original_file(db);
 
-        if let NameDefinition::Local(var) = def {
+        if let Definition::Local(var) = def {
             let range = match var.parent(db) {
                 DefWithBody::Function(f) => f.source(db).value.syntax().text_range(),
                 DefWithBody::Const(c) => c.source(db).value.syntax().text_range(),