From 5d54aa678153d0af0edc8b4dd2d74709d10ca66c Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 23 May 2019 20:18:47 +0300
Subject: add union to code_model

---
 crates/ra_hir/src/ty/infer.rs | 21 +++++++++++++--------
 crates/ra_hir/src/ty/lower.rs | 10 ++++++++--
 2 files changed, 21 insertions(+), 10 deletions(-)

(limited to 'crates/ra_hir/src/ty')

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index a48272981..7d8250292 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/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,
-    FnSignature, AdtDef,ConstSignature,
-    HirDatabase,
-    DefWithBody,
-    ImplItem,
+    Function, StructField, Path, Name, FnSignature, AdtDef, ConstSignature, 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 {
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index a1a2d0f6b..7defa7a9b 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/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(),
-- 
cgit v1.2.3