refactor narrow and union type

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs

@@ -7,7 +7,9 @@ use emmylua_parser::{
 use crate::{
     compilation::analyzer::flow::{
         bind_analyze::{
-            bind_block, bind_each_child, bind_node, exprs::{bind_condition_expr, bind_expr}, finish_flow_label
+            bind_block, bind_each_child, bind_node,
+            exprs::{bind_condition_expr, bind_expr},
+            finish_flow_label,
         },
         binder::FlowBinder,
     },

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs

@@ -330,7 +330,7 @@ fn find_union_function_member(
         let result = find_function_type_by_member_key(
             db,
             cache,
-            sub_type,
+            &sub_type,
             index_expr.clone(),
             &mut InferGuard::new(),
             deep_guard,
@@ -692,7 +692,7 @@ fn find_member_by_index_union(
         let result = find_function_type_by_operator(
             db,
             cache,
-            member,
+            &member,
             index_expr.clone(),
             &mut InferGuard::new(),
             deep_guard,

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs

@@ -314,12 +314,12 @@ fn resolve_closure_member_type(
                         multi_function_type.push(func.clone());
                     }
                     LuaType::Ref(ref_id) => {
-                        if infer_guard.check(ref_id).is_err() {
+                        if infer_guard.check(&ref_id).is_err() {
                             continue;
                         }
                         let type_decl = db
                             .get_type_index()
-                            .get_type_decl(ref_id)
+                            .get_type_decl(&ref_id)
                             .ok_or(InferFailReason::None)?;
 
                         if let Some(origin) = type_decl.get_alias_origin(&db, None) {
@@ -492,17 +492,18 @@ fn resolve_doc_function(
     Ok(())
 }
 
-fn filter_signature_type(typ: &LuaType) -> Option<Vec<&Arc<LuaFunctionType>>> {
-    let mut result: Vec<&Arc<LuaFunctionType>> = Vec::new();
+fn filter_signature_type(typ: &LuaType) -> Option<Vec<Arc<LuaFunctionType>>> {
+    let mut result: Vec<Arc<LuaFunctionType>> = Vec::new();
     let mut stack = Vec::new();
-    stack.push(typ);
+    stack.push(typ.clone());
     while let Some(typ) = stack.pop() {
         match typ {
             LuaType::DocFunction(func) => {
-                result.push(func);
+                result.push(func.clone());
             }
             LuaType::Union(union) => {
-                for typ in union.get_types().iter().rev() {
+                let types = union.get_types();
+                for typ in types.into_iter().rev() {
                     stack.push(typ);
                 }
             }

crates/emmylua_code_analysis/src/compilation/test/and_or_test.rs

@@ -52,9 +52,10 @@ mod test {
         );
 
         let a_ty = ws.expr_ty("a");
+        println!("{:?}", a_ty);
         assert_eq!(
             format!("{:?}", a_ty).to_string(),
-            "Union(LuaUnionType { types: [IntegerConst(2), Nil] })"
+            "Union(Multi([IntegerConst(2), Nil]))"
         );
     }
 

crates/emmylua_code_analysis/src/db_index/type/mod.rs

@@ -6,13 +6,12 @@ mod type_owner;
 mod types;
 
 use super::traits::LuaIndex;
-use crate::{FileId, InFiled};
+use crate::{DbIndex, FileId, InFiled};
 pub use humanize_type::{format_union_type, humanize_type, RenderLevel};
 use std::collections::{HashMap, HashSet};
 pub use type_decl::{
     LuaDeclLocation, LuaDeclTypeKind, LuaTypeAttribute, LuaTypeDecl, LuaTypeDeclId,
 };
-pub use type_ops::get_real_type;
 pub use type_ops::TypeOps;
 pub use type_owner::{LuaTypeCache, LuaTypeOwner};
 pub use types::*;
@@ -283,3 +282,30 @@ impl LuaIndex for LuaTypeIndex {
         self.in_filed_type_owner.clear();
     }
 }
+
+pub fn get_real_type<'a>(db: &'a DbIndex, typ: &'a LuaType) -> Option<&'a LuaType> {
+    get_real_type_with_depth(db, typ, 0)
+}
+
+fn get_real_type_with_depth<'a>(
+    db: &'a DbIndex,
+    typ: &'a LuaType,
+    depth: u32,
+) -> Option<&'a LuaType> {
+    const MAX_RECURSION_DEPTH: u32 = 10;
+
+    if depth >= MAX_RECURSION_DEPTH {
+        return Some(typ);
+    }
+
+    match typ {
+        LuaType::Ref(type_decl_id) => {
+            let type_decl = db.get_type_index().get_type_decl(type_decl_id)?;
+            if type_decl.is_alias() {
+                return get_real_type_with_depth(db, type_decl.get_alias_ref()?, depth + 1);
+            }
+            Some(typ)
+        }
+        _ => Some(typ),
+    }
+}

crates/emmylua_code_analysis/src/db_index/type/type_ops/and_type.rs

@@ -1,6 +1,3 @@
-mod and_type;
-mod false_or_nil_type;
-mod narrow_type;
 mod remove_type;
 mod test;
 mod union_type;
@@ -15,14 +12,6 @@ pub enum TypeOps {
     Union,
     /// Remove a type from the source type
     Remove,
-    /// Remove a type from the source type, but keep the source type
-    RemoveNilOrFalse,
-    /// Force a type to the source type
-    Narrow,
-    /// Only keep the false or nil type
-    NarrowFalseOrNil,
-    // /// And operation
-    // And,
 }
 
 impl TypeOps {
@@ -32,45 +21,6 @@ impl TypeOps {
             TypeOps::Remove => {
                 remove_type::remove_type(db, source.clone(), target.clone()).unwrap_or(LuaType::Any)
             }
-            TypeOps::Narrow => narrow_type::narrow_down_type(db, source.clone(), target.clone())
-                .unwrap_or(target.clone()),
-            // TypeOps::And => and_type::and_type(source.clone(), target.clone()),
-            _ => source.clone(),
         }
     }
-
-    pub fn apply_source(&self, db: &DbIndex, source: &LuaType) -> LuaType {
-        match self {
-            TypeOps::NarrowFalseOrNil => false_or_nil_type::narrow_false_or_nil(db, source.clone()),
-            TypeOps::RemoveNilOrFalse => false_or_nil_type::remove_false_or_nil(source.clone()),
-            _ => source.clone(),
-        }
-    }
-}
-
-pub fn get_real_type<'a>(db: &'a DbIndex, typ: &'a LuaType) -> Option<&'a LuaType> {
-    get_real_type_with_depth(db, typ, 0)
-}
-
-fn get_real_type_with_depth<'a>(
-    db: &'a DbIndex,
-    typ: &'a LuaType,
-    depth: u32,
-) -> Option<&'a LuaType> {
-    const MAX_RECURSION_DEPTH: u32 = 100;
-
-    if depth >= MAX_RECURSION_DEPTH {
-        return Some(typ);
-    }
-
-    match typ {
-        LuaType::Ref(type_decl_id) => {
-            let type_decl = db.get_type_index().get_type_decl(type_decl_id)?;
-            if type_decl.is_alias() {
-                return get_real_type_with_depth(db, type_decl.get_alias_ref()?, depth + 1);
-            }
-            Some(typ)
-        }
-        _ => Some(typ),
-    }
 }

crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.rs

@@ -1,6 +1,4 @@
-use crate::{DbIndex, LuaType, LuaUnionType};
-
-use super::get_real_type;
+use crate::{get_real_type, DbIndex, LuaType, LuaUnionType};
 
 pub fn remove_type(db: &DbIndex, source: LuaType, removed_type: LuaType) -> Option<LuaType> {
     if source == removed_type {