Merge #1290

1290: Add Union to code_model r=matklad a=matklad

@flodiebold I am conflicted about two possible implementation approaches:

* we can add a separate `struct Union` to code model
* we can add `fn is_union(&self)` to existing `Struct`

This PR goes with the former approach, because it seems like Unions are sufficiently different in semantics to warrant a separate types. Which is in contrast to Syntax Tree, where both structs and unions share the same node kind, because their syntax is the same. 

What would be the right thing to do here?

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

crates/ra_hir/src/adt.rs

@@ -10,7 +10,7 @@ use ra_syntax::{
 };
 
 use crate::{
-    Name, AsName, Struct, Enum, EnumVariant, Crate,
+    Name, AsName, Struct, Union, Enum, EnumVariant, Crate,
     HirDatabase, HirFileId, StructField, FieldSource,
     type_ref::TypeRef, DefDatabase,
 };
@@ -18,14 +18,16 @@ use crate::{
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AdtDef {
     Struct(Struct),
+    Union(Union),
     Enum(Enum),
 }
-impl_froms!(AdtDef: Struct, Enum);
+impl_froms!(AdtDef: Struct, Union, Enum);
 
 impl AdtDef {
     pub(crate) fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
         match self {
             AdtDef::Struct(s) => s.module(db),
+            AdtDef::Union(s) => s.module(db),
             AdtDef::Enum(e) => e.module(db),
         }
         .krate(db)
@@ -38,6 +40,7 @@ impl Struct {
     }
 }
 
+/// Note that we use `StructData` for unions as well!
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StructData {
     pub(crate) name: Option<Name>,

crates/ra_hir/src/code_model_api.rs

@@ -71,6 +71,7 @@ pub enum ModuleDef {
     Module(Module),
     Function(Function),
     Struct(Struct),
+    Union(Union),
     Enum(Enum),
     // Can't be directly declared, but can be imported.
     EnumVariant(EnumVariant),
@@ -83,6 +84,7 @@ impl_froms!(
     ModuleDef: Module,
     Function,
     Struct,
+    Union,
     Enum,
     EnumVariant,
     Const,
@@ -325,6 +327,42 @@ impl Docs for Struct {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Union {
+    pub(crate) id: StructId,
+}
+
+impl Union {
+    pub fn source(&self, db: &impl DefDatabase) -> (HirFileId, TreeArc<ast::StructDef>) {
+        self.id.source(db)
+    }
+
+    pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
+        db.struct_data(Struct { id: self.id }).name.clone()
+    }
+
+    pub fn module(&self, db: &impl HirDatabase) -> Module {
+        self.id.module(db)
+    }
+
+    // FIXME move to a more general type
+    /// Builds a resolver for type references inside this union.
+    pub(crate) fn resolver(&self, db: &impl HirDatabase) -> Resolver {
+        // take the outer scope...
+        let r = self.module(db).resolver(db);
+        // ...and add generic params, if present
+        let p = self.generic_params(db);
+        let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
+        r
+    }
+}
+
+impl Docs for Union {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
+        docs_from_ast(&*self.source(db).1)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Enum {
     pub(crate) id: EnumId,

crates/ra_hir/src/generics.rs

@@ -9,7 +9,7 @@ use ra_syntax::ast::{self, NameOwner, TypeParamsOwner, TypeBoundsOwner, DefaultT
 
 use crate::{
     db::{ HirDatabase, DefDatabase},
-    Name, AsName, Function, Struct, Enum, Trait, TypeAlias, ImplBlock, Container, path::Path, type_ref::TypeRef, AdtDef
+    Name, AsName, Function, Struct, Union, Enum, Trait, TypeAlias, ImplBlock, Container, path::Path, type_ref::TypeRef, AdtDef
 };
 
 /// Data about a generic parameter (to a function, struct, impl, ...).
@@ -42,12 +42,13 @@ pub struct WherePredicate {
 pub enum GenericDef {
     Function(Function),
     Struct(Struct),
+    Union(Union),
     Enum(Enum),
     Trait(Trait),
     TypeAlias(TypeAlias),
     ImplBlock(ImplBlock),
 }
-impl_froms!(GenericDef: Function, Struct, Enum, Trait, TypeAlias, ImplBlock);
+impl_froms!(GenericDef: Function, Struct, Union, Enum, Trait, TypeAlias, ImplBlock);
 
 impl GenericParams {
     pub(crate) fn generic_params_query(
@@ -58,7 +59,10 @@ impl GenericParams {
         let parent = match def {
             GenericDef::Function(it) => it.container(db).map(GenericDef::from),
             GenericDef::TypeAlias(it) => it.container(db).map(GenericDef::from),
-            GenericDef::Struct(_) | GenericDef::Enum(_) | GenericDef::Trait(_) => None,
+            GenericDef::Struct(_)
+            | GenericDef::Union(_)
+            | GenericDef::Enum(_)
+            | GenericDef::Trait(_) => None,
             GenericDef::ImplBlock(_) => None,
         };
         generics.parent_params = parent.map(|p| db.generic_params(p));
@@ -66,6 +70,7 @@ impl GenericParams {
         match def {
             GenericDef::Function(it) => generics.fill(&*it.source(db).1, start),
             GenericDef::Struct(it) => generics.fill(&*it.source(db).1, start),
+            GenericDef::Union(it) => generics.fill(&*it.source(db).1, start),
             GenericDef::Enum(it) => generics.fill(&*it.source(db).1, start),
             GenericDef::Trait(it) => {
                 // traits get the Self type as an implicit first type parameter
@@ -171,6 +176,7 @@ impl GenericDef {
         match self {
             GenericDef::Function(inner) => inner.resolver(db),
             GenericDef::Struct(inner) => inner.resolver(db),
+            GenericDef::Union(inner) => inner.resolver(db),
             GenericDef::Enum(inner) => inner.resolver(db),
             GenericDef::Trait(inner) => inner.resolver(db),
             GenericDef::TypeAlias(inner) => inner.resolver(db),
@@ -192,6 +198,7 @@ impl From<crate::adt::AdtDef> for GenericDef {
     fn from(adt: crate::adt::AdtDef) -> Self {
         match adt {
             AdtDef::Struct(s) => s.into(),
+            AdtDef::Union(u) => u.into(),
             AdtDef::Enum(e) => e.into(),
         }
     }

crates/ra_hir/src/lib.rs

@@ -77,7 +77,7 @@ pub use self::code_model_api::{
     Crate, CrateDependency,
     DefWithBody,
     Module, ModuleDef, ModuleSource,
-    Struct, Enum, EnumVariant,
+    Struct, Union, Enum, EnumVariant,
     Function, FnSignature,
     StructField, FieldSource,
     Static, Const, ConstSignature,

crates/ra_hir/src/nameres/collector.rs

@@ -6,7 +6,7 @@ use ra_db::FileId;
 use ra_syntax::ast;
 
 use crate::{
-    Function, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
+    Function, Module, Struct, Union, Enum, Const, Static, Trait, TypeAlias,
     DefDatabase, HirFileId, Name, Path,
     KnownName,
     nameres::{
@@ -495,6 +495,10 @@ where
                 let s = def!(Struct, ast_id);
                 PerNs::both(s, s)
             }
+            raw::DefKind::Union(ast_id) => {
+                let s = def!(Union, ast_id);
+                PerNs::both(s, s)
+            }
             raw::DefKind::Enum(ast_id) => PerNs::types(def!(Enum, ast_id)),
             raw::DefKind::Const(ast_id) => PerNs::values(def!(Const, ast_id)),
             raw::DefKind::Static(ast_id) => PerNs::values(def!(Static, ast_id)),

crates/ra_hir/src/nameres/raw.rs

@@ -1,7 +1,4 @@
-use std::{
+use std::{sync::Arc, ops::Index};
-    sync::Arc,
-    ops::Index,
-};
 
 use test_utils::tested_by;
 use ra_arena::{Arena, impl_arena_id, RawId, map::ArenaMap};
@@ -10,10 +7,7 @@ use ra_syntax::{
     ast::{self, NameOwner, AttrsOwner},
 };
 
-use crate::{
+use crate::{DefDatabase, Name, AsName, Path, HirFileId, ModuleSource, AstIdMap, FileAstId, Either};
-    DefDatabase, Name, AsName, Path, HirFileId, ModuleSource,
-    AstIdMap, FileAstId, Either,
-};
 
 /// `RawItems` is a set of top-level items in a file (except for impls).
 ///
@@ -161,6 +155,7 @@ pub(super) struct DefData {
 pub(super) enum DefKind {
     Function(FileAstId<ast::FnDef>),
     Struct(FileAstId<ast::StructDef>),
+    Union(FileAstId<ast::StructDef>),
     Enum(FileAstId<ast::EnumDef>),
     Const(FileAstId<ast::ConstDef>),
     Static(FileAstId<ast::StaticDef>),
@@ -215,7 +210,13 @@ impl RawItemsCollector {
                 return;
             }
             ast::ModuleItemKind::StructDef(it) => {
-                (DefKind::Struct(self.source_ast_id_map.ast_id(it)), it.name())
+                let id = self.source_ast_id_map.ast_id(it);
+                let name = it.name();
+                if it.is_union() {
+                    (DefKind::Union(id), name)
+                } else {
+                    (DefKind::Struct(id), name)
+                }
             }
             ast::ModuleItemKind::EnumDef(it) => {
                 (DefKind::Enum(self.source_ast_id_map.ast_id(it)), it.name())

crates/ra_hir/src/ty.rs

@@ -536,6 +536,7 @@ impl HirDisplay for ApplicationTy {
             TypeCtor::Adt(def_id) => {
                 let name = match def_id {
                     AdtDef::Struct(s) => s.name(f.db),
+                    AdtDef::Union(u) => u.name(f.db),
                     AdtDef::Enum(e) => e.name(f.db),
                 }
                 .unwrap_or_else(Name::missing);

crates/ra_hir/src/ty/infer.rs

@@ -27,13 +27,13 @@ use ra_prof::profile;
 use test_utils::tested_by;
 
 use crate::{
-    Function, StructField, Path, Name,
+    Function, StructField, Path, Name, FnSignature, AdtDef, ConstSignature, HirDatabase,
-    FnSignature, AdtDef,ConstSignature,
+    DefWithBody, ImplItem,
-    HirDatabase,
-    DefWithBody,
-    ImplItem,
     type_ref::{TypeRef, Mutability},
-    expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat,Array, self},
+    expr::{
+        Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement,
+        FieldPat, Array, self,
+    },
     generics::{GenericParams, HasGenericParams},
     path::{GenericArgs, GenericArg},
     ModuleDef,
@@ -644,7 +644,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 let ty = self.insert_type_vars(ty.apply_substs(substs));
                 (ty, Some(var.into()))
             }
-            TypableDef::TypeAlias(_)
+            TypableDef::Union(_)
+            | TypableDef::TypeAlias(_)
             | TypableDef::Function(_)
             | TypableDef::Enum(_)
             | TypableDef::Const(_)
@@ -1407,7 +1408,11 @@ impl Expectation {
 }
 
 mod diagnostics {
-    use crate::{expr::ExprId, diagnostics::{DiagnosticSink, NoSuchField}, HirDatabase, Function};
+    use crate::{
+        expr::ExprId,
+        diagnostics::{DiagnosticSink, NoSuchField},
+        HirDatabase, Function,
+};
 
     #[derive(Debug, PartialEq, Eq, Clone)]
     pub(super) enum InferenceDiagnostic {

crates/ra_hir/src/ty/lower.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 use std::iter;
 
 use crate::{
-    Function, Struct, StructField, Enum, EnumVariant, Path, ModuleDef, TypeAlias, Const, Static,
+    Function, Struct, Union, StructField, Enum, EnumVariant, Path, ModuleDef, TypeAlias, Const, Static,
     HirDatabase,
     type_ref::TypeRef,
     name::KnownName,
@@ -124,6 +124,7 @@ impl Ty {
         let def_generic: Option<GenericDef> = match resolved {
             TypableDef::Function(func) => Some(func.into()),
             TypableDef::Struct(s) => Some(s.into()),
+            TypableDef::Union(u) => Some(u.into()),
             TypableDef::Enum(e) => Some(e.into()),
             TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
             TypableDef::TypeAlias(t) => Some(t.into()),
@@ -144,6 +145,7 @@ impl Ty {
         let segment = match resolved {
             TypableDef::Function(_)
             | TypableDef::Struct(_)
+            | TypableDef::Union(_)
             | TypableDef::Enum(_)
             | TypableDef::Const(_)
             | TypableDef::Static(_)
@@ -293,12 +295,14 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
         (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s),
         (TypableDef::Enum(e), Namespace::Types) => type_for_adt(db, e),
         (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
+        (TypableDef::Union(u), Namespace::Types) => type_for_adt(db, u),
         (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t),
         (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c),
         (TypableDef::Static(c), Namespace::Values) => type_for_static(db, c),
 
         // 'error' cases:
         (TypableDef::Function(_), Namespace::Types) => Ty::Unknown,
+        (TypableDef::Union(_), Namespace::Values) => Ty::Unknown,
         (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown,
         (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown,
         (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown,
@@ -467,19 +471,21 @@ fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
 pub enum TypableDef {
     Function(Function),
     Struct(Struct),
+    Union(Union),
     Enum(Enum),
     EnumVariant(EnumVariant),
     TypeAlias(TypeAlias),
     Const(Const),
     Static(Static),
 }
-impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant, TypeAlias, Const, Static);
+impl_froms!(TypableDef: Function, Struct, Union, Enum, EnumVariant, TypeAlias, Const, Static);
 
 impl From<ModuleDef> for Option<TypableDef> {
     fn from(def: ModuleDef) -> Option<TypableDef> {
         let res = match def {
             ModuleDef::Function(f) => f.into(),
             ModuleDef::Struct(s) => s.into(),
+            ModuleDef::Union(u) => u.into(),
             ModuleDef::Enum(e) => e.into(),
             ModuleDef::EnumVariant(v) => v.into(),
             ModuleDef::TypeAlias(t) => t.into(),

crates/ra_ide_api/src/completion/complete_struct_literal.rs

@@ -20,6 +20,7 @@ pub(super) fn complete_struct_literal(acc: &mut Completions, ctx: &CompletionCon
         }
 
         // FIXME unions
+        AdtDef::Union(_) => (),
         AdtDef::Enum(_) => (),
     };
 }

crates/ra_ide_api/src/completion/presentation.rs

@@ -63,6 +63,7 @@ impl Completions {
                 return self.add_function_with_name(ctx, Some(local_name), *func);
             }
             Resolution::Def(Struct(it)) => (CompletionItemKind::Struct, it.docs(ctx.db)),
+            Resolution::Def(Union(it)) => (CompletionItemKind::Struct, it.docs(ctx.db)),
             Resolution::Def(Enum(it)) => (CompletionItemKind::Enum, it.docs(ctx.db)),
             Resolution::Def(EnumVariant(it)) => (CompletionItemKind::EnumVariant, it.docs(ctx.db)),
             Resolution::Def(Const(it)) => (CompletionItemKind::Const, it.docs(ctx.db)),

crates/ra_ide_api/src/display/navigation_target.rs

@@ -154,6 +154,10 @@ impl NavigationTarget {
                 let (file_id, node) = s.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
+            hir::AdtDef::Union(s) => {
+                let (file_id, node) = s.source(db);
+                NavigationTarget::from_named(file_id.original_file(db), &*node)
+            }
             hir::AdtDef::Enum(s) => {
                 let (file_id, node) = s.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
@@ -169,6 +173,10 @@ impl NavigationTarget {
                 let (file_id, node) = s.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)
             }
+            hir::ModuleDef::Union(s) => {
+                let (file_id, node) = s.source(db);
+                NavigationTarget::from_named(file_id.original_file(db), &*node)
+            }
             hir::ModuleDef::Const(s) => {
                 let (file_id, node) = s.source(db);
                 NavigationTarget::from_named(file_id.original_file(db), &*node)

crates/ra_ide_api/src/syntax_highlighting.rs

@@ -57,6 +57,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                         Some(Def(ModuleDef::Module(_))) => "module",
                         Some(Def(ModuleDef::Function(_))) => "function",
                         Some(Def(ModuleDef::Struct(_))) => "type",
+                        Some(Def(ModuleDef::Union(_))) => "type",
                         Some(Def(ModuleDef::Enum(_))) => "type",
                         Some(Def(ModuleDef::EnumVariant(_))) => "constant",
                         Some(Def(ModuleDef::Const(_))) => "constant",