refactor: use inline completion snapshots (#580)

Author: baszalmstra

Cargo.lock

@@ -2,6 +2,7 @@ mod function;
 mod r#impl;
 mod module;
 mod package;
+mod primitive_type;
 pub(crate) mod src;
 pub(crate) mod r#struct;
 mod type_alias;
@@ -12,6 +13,7 @@ pub use self::{
     function::{Function, FunctionData},
     module::{Module, ModuleDef},
     package::Package,
+    primitive_type::PrimitiveType,
     r#impl::{AssocItem, ImplData},
     r#struct::{Field, Struct, StructData, StructKind, StructMemoryKind},
     src::HasSource,

crates/mun_hir/src/code_model.rs

@@ -1,7 +1,7 @@
 use mun_hir_input::{FileId, ModuleId};
 
-use super::{r#impl::Impl, AssocItem, Function, Package, Struct, TypeAlias};
-use crate::{ids::ItemDefinitionId, primitive_type::PrimitiveType, DiagnosticSink, HirDatabase};
+use super::{r#impl::Impl, AssocItem, Function, Package, PrimitiveType, Struct, TypeAlias};
+use crate::{ids::ItemDefinitionId, DiagnosticSink, HirDatabase};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct Module {
@@ -203,7 +203,7 @@ impl From<ItemDefinitionId> for ModuleDef {
             ItemDefinitionId::FunctionId(id) => Function { id }.into(),
             ItemDefinitionId::StructId(id) => Struct { id }.into(),
             ItemDefinitionId::TypeAliasId(id) => TypeAlias { id }.into(),
-            ItemDefinitionId::PrimitiveType(id) => id.into(),
+            ItemDefinitionId::PrimitiveType(ty) => PrimitiveType { inner: ty }.into(),
         }
     }
 }

crates/mun_hir/src/code_model/module.rs

@@ -0,0 +1,24 @@
+use crate::{name::AsName, ty::lower::type_for_primitive, Name, Ty};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct PrimitiveType {
+    pub(crate) inner: crate::primitive_type::PrimitiveType,
+}
+
+impl PrimitiveType {
+    /// Returns the type of the primitive
+    pub fn ty(self, _db: &dyn crate::HirDatabase) -> Ty {
+        type_for_primitive(self)
+    }
+
+    /// Returns the name of the primitive
+    pub fn name(self) -> Name {
+        self.inner.as_name()
+    }
+}
+
+impl From<crate::primitive_type::PrimitiveType> for PrimitiveType {
+    fn from(inner: crate::primitive_type::PrimitiveType) -> Self {
+        PrimitiveType { inner }
+    }
+}

crates/mun_hir/src/code_model/primitive_type.rs

@@ -11,8 +11,8 @@ pub use mun_hir_input::ModuleId;
 pub use salsa;
 
 pub use self::code_model::{
-    Field, Function, FunctionData, HasSource, Module, ModuleDef, Package, Struct, StructMemoryKind,
-    TypeAlias,
+    Field, Function, FunctionData, HasSource, Module, ModuleDef, Package, PrimitiveType, Struct,
+    StructMemoryKind, TypeAlias,
 };
 pub use crate::{
     db::{

crates/mun_hir/src/lib.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::name::{name, Name};
+use crate::name::{name, AsName, Name};
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum Signedness {
@@ -74,7 +74,13 @@ impl PrimitiveType {
 
 impl fmt::Display for PrimitiveType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let type_name = match self {
+        f.write_str(self.as_str())
+    }
+}
+
+impl PrimitiveType {
+    pub fn as_str(self) -> &'static str {
+        match self {
             PrimitiveType::Bool => "bool",
             PrimitiveType::Int(PrimitiveInt {
                 signedness,
@@ -98,8 +104,13 @@ impl fmt::Display for PrimitiveType {
                 FloatBitness::X32 => "f32",
                 FloatBitness::X64 => "f64",
             },
-        };
-        f.write_str(type_name)
+        }
+    }
+}
+
+impl AsName for PrimitiveType {
+    fn as_name(&self) -> Name {
+        Name::new(self.as_str())
     }
 }
 

crates/mun_hir/src/primitive_type.rs

@@ -8,8 +8,8 @@ use crate::{
     ids::DefWithBodyId,
     resolver_for_scope,
     semantics::PathResolution,
-    Body, ExprId, ExprScopes, HirDatabase, InFile, InferenceResult, Path, Resolver, Struct, Ty,
-    TypeAlias, TypeNs,
+    Body, ExprId, ExprScopes, HirDatabase, InFile, InferenceResult, Path, PrimitiveType, Resolver,
+    Struct, Ty, TypeAlias, TypeNs,
 };
 
 /// A `SourceAnalyzer` is a wrapper which exposes the HIR API in terms of the
@@ -215,7 +215,7 @@ fn resolve_hir_path_qualifier(
         TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
         TypeNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
         TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
-        TypeNs::PrimitiveType(it) => PathResolution::Def(it.into()),
+        TypeNs::PrimitiveType(it) => PathResolution::Def(PrimitiveType::from(it).into()),
     };
 
     Some(res)

crates/mun_hir/src/source_analyzer.rs

@@ -880,7 +880,7 @@ impl InferenceResultBuilder<'_> {
             TypeNs::SelfType(id) => self.db.type_for_impl_self(id),
             TypeNs::StructId(id) => type_for_def_fn(TypableDef::Struct(id.into())),
             TypeNs::TypeAliasId(id) => type_for_def_fn(TypableDef::TypeAlias(id.into())),
-            TypeNs::PrimitiveType(id) => type_for_def_fn(TypableDef::PrimitiveType(id)),
+            TypeNs::PrimitiveType(id) => type_for_def_fn(TypableDef::PrimitiveType(id.into())),
         };
 
         // Resolve the value.

crates/mun_hir/src/ty/infer.rs

@@ -11,11 +11,11 @@ use crate::{
     diagnostics::DiagnosticSink,
     ids::ImplId,
     name_resolution::Namespace,
-    primitive_type::PrimitiveType,
     resolve::{HasResolver, Resolver, TypeNs},
     ty::{FnSig, Substitution, Ty, TyKind},
     type_ref::{LocalTypeRefId, TypeRef, TypeRefMap, TypeRefSourceMap},
-    Function, HasVisibility, HirDatabase, ModuleDef, Path, Struct, TypeAlias, Visibility,
+    Function, HasVisibility, HirDatabase, ModuleDef, Path, PrimitiveType, Struct, TypeAlias,
+    Visibility,
 };
 
 /// A struct which holds resolved type references to `Ty`s.
@@ -138,7 +138,7 @@ impl Ty {
             TypeNs::SelfType(id) => Some(db.type_for_impl_self(id)),
             TypeNs::StructId(id) => type_for_def_fn(TypableDef::Struct(id.into())),
             TypeNs::TypeAliasId(id) => type_for_def_fn(TypableDef::TypeAlias(id.into())),
-            TypeNs::PrimitiveType(id) => type_for_def_fn(TypableDef::PrimitiveType(id)),
+            TypeNs::PrimitiveType(id) => type_for_def_fn(TypableDef::PrimitiveType(id.into())),
         }
     }
 }
@@ -260,11 +260,11 @@ pub(crate) fn type_for_impl_self(db: &dyn HirDatabase, i: ImplId) -> Ty {
 }
 
 /// Build the declared type of a static.
-fn type_for_primitive(def: PrimitiveType) -> Ty {
-    match def {
-        PrimitiveType::Float(f) => TyKind::Float(f.into()),
-        PrimitiveType::Int(i) => TyKind::Int(i.into()),
-        PrimitiveType::Bool => TyKind::Bool,
+pub(crate) fn type_for_primitive(def: PrimitiveType) -> Ty {
+    match def.inner {
+        crate::primitive_type::PrimitiveType::Float(f) => TyKind::Float(f.into()),
+        crate::primitive_type::PrimitiveType::Int(i) => TyKind::Int(i.into()),
+        crate::primitive_type::PrimitiveType::Bool => TyKind::Bool,
     }
     .intern()
 }

crates/mun_hir/src/ty/lower.rs

@@ -14,12 +14,13 @@ mod expr;
 mod name_ref;
 #[cfg(test)]
 mod test_utils;
+mod tests;
 
 use context::{
     CompletionAnalysis, CompletionContext, DotAccess, NameRefContext, NameRefKind,
     PathCompletionContext, PathExprContext, PathKind, Qualified,
 };
-pub use item::{CompletionItem, CompletionItemKind, CompletionKind};
+pub use item::{CompletionItem, CompletionItemKind};
 use mun_hir::semantics::ScopeDef;
 
 use crate::{
@@ -52,8 +53,6 @@ pub(crate) fn completions(db: &AnalysisDatabase, position: FilePosition) -> Opti
         }
     }
 
-    // unqualified_path::complete_unqualified_path(&mut result, &context);
-    // dot::complete_dot(&mut result, &context);
     Some(result)
 }