Merge remote-tracking branch 'CppCXY/main' into dev

Author: xuhuanzy

crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs

@@ -313,7 +313,7 @@ fn analyze_cast_with_name_token(
                     flow_chain.add_type_assert(TypeAssertion::Remove(typ), effect_range);
                 }
                 CastAction::Force => {
-                    flow_chain.add_type_assert(TypeAssertion::Force(typ), effect_range);
+                    flow_chain.add_type_assert(TypeAssertion::Narrow(typ), effect_range);
                 }
             }
         }

crates/emmylua_code_analysis/src/compilation/analyzer/flow/assign_stats.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-#[allow(unused_imports)]
 use emmylua_parser::{LuaAssignStat, LuaAstNode, LuaNameExpr, LuaSyntaxId, LuaSyntaxKind};
 use emmylua_parser::{LuaAst, LuaBlock, LuaExpr, LuaIfStat, LuaSyntaxNode};
 use rowan::TextRange;

crates/emmylua_code_analysis/src/compilation/analyzer/flow/name_ref.rs

@@ -114,8 +114,8 @@ fn broadcast_up(
                                     TypeAssertion::NotExist
                                 }
                             }
-                            LuaLiteralToken::Number(_) => TypeAssertion::Force(LuaType::Number),
-                            LuaLiteralToken::String(_) => TypeAssertion::Force(LuaType::String),
+                            LuaLiteralToken::Number(_) => TypeAssertion::Narrow(LuaType::Number),
+                            LuaLiteralToken::String(_) => TypeAssertion::Narrow(LuaType::String),
                             _ => return None,
                         };
 
@@ -206,14 +206,14 @@ fn infer_lua_type_assert(
     };
 
     let type_assert = match type_literal.as_str() {
-        "number" => TypeAssertion::Force(LuaType::Number),
-        "string" => TypeAssertion::Force(LuaType::String),
-        "boolean" => TypeAssertion::Force(LuaType::Boolean),
-        "table" => TypeAssertion::Force(LuaType::Table),
-        "function" => TypeAssertion::Force(LuaType::Function),
-        "thread" => TypeAssertion::Force(LuaType::Thread),
-        "userdata" => TypeAssertion::Force(LuaType::Userdata),
-        "nil" => TypeAssertion::Force(LuaType::Nil),
+        "number" => TypeAssertion::Narrow(LuaType::Number),
+        "string" => TypeAssertion::Narrow(LuaType::String),
+        "boolean" => TypeAssertion::Narrow(LuaType::Boolean),
+        "table" => TypeAssertion::Narrow(LuaType::Table),
+        "function" => TypeAssertion::Narrow(LuaType::Function),
+        "thread" => TypeAssertion::Narrow(LuaType::Thread),
+        "userdata" => TypeAssertion::Narrow(LuaType::Userdata),
+        "nil" => TypeAssertion::Narrow(LuaType::Nil),
         _ => {
             return None;
         }

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

@@ -17,6 +17,7 @@ pub use type_decl::{
     LuaDeclLocation, LuaDeclTypeKind, LuaTypeAttribute, LuaTypeDecl, LuaTypeDeclId,
 };
 pub use types::*;
+pub use type_ops::TypeOps;
 
 #[derive(Debug)]
 pub struct LuaTypeIndex {

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

@@ -3,13 +3,13 @@ use std::{ops::Deref, sync::Arc};
 use crate::{infer_expr, DbIndex, LuaInferConfig};
 use emmylua_parser::{LuaAstNode, LuaExpr, LuaSyntaxId, LuaSyntaxNode};
 
-use super::{LuaMemberPathExistType, LuaType, LuaUnionType};
+use super::{type_ops::TypeOps, LuaMemberPathExistType, LuaType};
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum TypeAssertion {
     Exist,
     NotExist,
-    Force(LuaType),
+    Narrow(LuaType),
     MemberPathExist(Arc<String>),
     Add(LuaType),
     Remove(LuaType),
@@ -21,14 +21,14 @@ pub enum TypeAssertion {
 impl TypeAssertion {
     pub fn simple_tighten_type(&self, source: LuaType) -> LuaType {
         match self {
-            TypeAssertion::Exist => remove_nil_and_not_false(source),
+            TypeAssertion::Exist => TypeOps::Remove.apply(&source, &LuaType::Nil),
             TypeAssertion::NotExist => force_nil_or_false(source),
-            TypeAssertion::Force(t) => narrow_down_type(source, t.clone()),
+            TypeAssertion::Narrow(t) => TypeOps::Narrow.apply(&source, t),
             TypeAssertion::MemberPathExist(key) => LuaType::MemberPathExist(
                 LuaMemberPathExistType::new(&key.deref(), source, 0).into(),
             ),
-            TypeAssertion::Add(lua_type) => add_type(source, lua_type.clone()),
-            TypeAssertion::Remove(lua_type) => remove_type(source, lua_type.clone()),
+            TypeAssertion::Add(lua_type) => TypeOps::Union.apply(&source, lua_type),
+            TypeAssertion::Remove(lua_type) => TypeOps::Remove.apply(&source, lua_type),
             _ => source,
         }
     }
@@ -37,7 +37,7 @@ impl TypeAssertion {
         match self {
             TypeAssertion::Exist => Some(TypeAssertion::NotExist),
             TypeAssertion::NotExist => Some(TypeAssertion::Exist),
-            TypeAssertion::Force(t) => Some(TypeAssertion::Remove(t.clone())),
+            TypeAssertion::Narrow(t) => Some(TypeAssertion::Remove(t.clone())),
             _ => None,
         }
     }
@@ -50,25 +50,25 @@ impl TypeAssertion {
         source: LuaType,
     ) -> Option<LuaType> {
         match self {
-            TypeAssertion::Exist => Some(remove_nil_and_not_false(source)),
+            TypeAssertion::Exist => Some(TypeOps::Remove.apply(&source, &LuaType::Nil)),
             TypeAssertion::NotExist => Some(force_nil_or_false(source)),
-            TypeAssertion::Force(t) => Some(narrow_down_type(source, t.clone())),
+            TypeAssertion::Narrow(t) => Some(TypeOps::Narrow.apply(&source, t)),
             TypeAssertion::MemberPathExist(key) => Some(LuaType::MemberPathExist(
                 LuaMemberPathExistType::new(&key.deref(), source, 0).into(),
             )),
-            TypeAssertion::Add(lua_type) => Some(add_type(source, lua_type.clone())),
-            TypeAssertion::Remove(lua_type) => Some(remove_type(source, lua_type.clone())),
+            TypeAssertion::Add(lua_type) => Some(TypeOps::Union.apply(&source, lua_type)),
+            TypeAssertion::Remove(lua_type) => Some(TypeOps::Remove.apply(&source, lua_type)),
             TypeAssertion::Reassign(syntax_id) => {
                 let expr = LuaExpr::cast(syntax_id.to_node_from_root(root)?)?;
                 let expr_type = infer_expr(db, config, expr)?;
-                Some(narrow_down_type(source, expr_type))
+                Some(TypeOps::Narrow.apply(&source, &expr_type))
             }
             TypeAssertion::AddUnion(syntax_ids) => {
                 let mut typ = source;
                 for syntax_id in syntax_ids {
                     let expr = LuaExpr::cast(syntax_id.to_node_from_root(root)?)?;
                     let expr_type = infer_expr(db, config, expr)?;
-                    typ = add_type(typ, expr_type);
+                    typ = TypeOps::Union.apply(&typ, &expr_type);
                 }
 
                 Some(typ)
@@ -78,27 +78,6 @@ impl TypeAssertion {
     }
 }
 
-fn remove_nil_and_not_false(t: LuaType) -> LuaType {
-    match t {
-        LuaType::Nil => LuaType::Unknown,
-        LuaType::Union(types) => {
-            let mut new_types = Vec::new();
-            for t in types.get_types() {
-                let t = remove_nil_and_not_false(t.clone());
-                if t != LuaType::Unknown {
-                    new_types.push(t);
-                }
-            }
-            if new_types.len() == 1 {
-                new_types.pop().unwrap()
-            } else {
-                LuaType::Union(LuaUnionType::new(new_types).into())
-            }
-        }
-        LuaType::Nullable(t) => remove_nil_and_not_false((*t).clone()),
-        t => t,
-    }
-}
 
 fn force_nil_or_false(t: LuaType) -> LuaType {
     if t.is_boolean() {
@@ -108,169 +87,3 @@ fn force_nil_or_false(t: LuaType) -> LuaType {
     return LuaType::Nil;
 }
 
-// need to be optimized
-fn narrow_down_type(source: LuaType, target: LuaType) -> LuaType {
-    match &source {
-        LuaType::Union(union) => {
-            let mut types = union.get_types().to_vec();
-            match target {
-                LuaType::Number | LuaType::FloatConst(_) | LuaType::IntegerConst(_) => {
-                    types.retain(|t| t.is_number());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::String | LuaType::StringConst(_) => {
-                    types.retain(|t| t.is_string());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::Boolean | LuaType::BooleanConst(_) => {
-                    types.retain(|t| t.is_boolean());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::Table | LuaType::TableConst(_) => {
-                    types.retain(|t| t.is_table());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::Function => {
-                    types.retain(|t| t.is_function());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::Thread => {
-                    types.retain(|t| t.is_thread());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::Userdata => {
-                    types.retain(|t| t.is_userdata());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                LuaType::Nil => {
-                    types.retain(|t| t.is_nil());
-                    if types.len() == 1 {
-                        types.pop().unwrap()
-                    } else {
-                        LuaType::Union(LuaUnionType::new(types).into())
-                    }
-                }
-                _ => target,
-            }
-        }
-        LuaType::Nullable(inner) => {
-            if !target.is_nullable() {
-                narrow_down_type(target, (**inner).clone())
-            } else {
-                LuaType::Nil
-            }
-        }
-        LuaType::BooleanConst(_) => {
-            if target.is_boolean() {
-                return LuaType::Boolean;
-            }
-
-            target
-        }
-        LuaType::FloatConst(_) => {
-            if target.is_number() {
-                return LuaType::Number;
-            }
-
-            target
-        }
-        LuaType::IntegerConst(_) => {
-            if target.is_number() {
-                return LuaType::Number;
-            }
-
-            target
-        }
-        LuaType::StringConst(_) => {
-            if target.is_string() {
-                return LuaType::String;
-            }
-
-            target
-        }
-        _ => target,
-    }
-}
-
-fn add_type(source: LuaType, added_typ: LuaType) -> LuaType {
-    if added_typ.is_nil() {
-        return LuaType::Nullable(source.into());
-    }
-
-    match source {
-        LuaType::Union(union) => {
-            let mut types = union.get_types().to_vec();
-            types.push(added_typ);
-            LuaType::Union(LuaUnionType::new(types).into())
-        }
-        LuaType::Nullable(inner) => {
-            let inner = add_type((*inner).clone(), added_typ);
-            LuaType::Nullable(inner.into())
-        }
-        LuaType::Unknown | LuaType::Any => added_typ,
-        _ => {
-            if source.is_number() && added_typ.is_number() {
-                return LuaType::Number;
-            } else if source.is_string() && added_typ.is_string() {
-                return LuaType::String;
-            } else if source.is_boolean() && added_typ.is_boolean() {
-                return LuaType::Boolean;
-            } else if source.is_table() && added_typ.is_table() {
-                return LuaType::Table;
-            } 
-            
-            LuaType::Union(LuaUnionType::new(vec![source, added_typ]).into())
-        },
-    }
-}
-
-fn remove_type(source: LuaType, removed_type: LuaType) -> LuaType {
-    if removed_type.is_nil() {
-        return remove_nil_and_not_false(source);
-    }
-
-    match source {
-        LuaType::Union(union) => {
-            let mut types = union.get_types().to_vec();
-            types.retain(|t| t != &removed_type);
-            if types.len() == 1 {
-                types.pop().unwrap()
-            } else {
-                LuaType::Union(LuaUnionType::new(types).into())
-            }
-        }
-        LuaType::Nullable(inner) => {
-            let inner = remove_type((*inner).clone(), removed_type);
-            LuaType::Nullable(inner.into())
-        }
-        _ => source,
-    }
-}

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

@@ -1,4 +1,6 @@
 mod union_type;
+mod remove_type;
+mod narrow_type;
 
 use super::LuaType;
 
@@ -16,9 +18,8 @@ impl TypeOps {
     pub fn apply(&self, source: &LuaType, target: &LuaType) -> LuaType {
         match self {
             TypeOps::Union => union_type::union_type(source.clone(), target.clone()),
-            // TypeOps::Remove => remove_type(source, target),
-            // TypeOps::Narrow => narrow_down_type(source, target),
-            _ => source.clone(),
+            TypeOps::Remove => remove_type::remove_type(source.clone(), target.clone()),
+            TypeOps::Narrow => narrow_type::narrow_down_type(source.clone(), target.clone()),
         }
     }
 }