update

Author: CppCXY

crates/emmylua_code_analysis/src/db_index/declaration/decl_tree.rs

@@ -376,8 +376,31 @@ impl LuaDeclarationTree {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum LuaDeclOrMemberId {
     Decl(LuaDeclId),
     Member(LuaMemberId),
 }
+
+impl LuaDeclOrMemberId {
+    pub fn as_decl_id(&self) -> Option<LuaDeclId> {
+        match self {
+            LuaDeclOrMemberId::Decl(decl_id) => Some(*decl_id),
+            LuaDeclOrMemberId::Member(_) => None,
+        }
+    }
+
+    pub fn as_member_id(&self) -> Option<LuaMemberId> {
+        match self {
+            LuaDeclOrMemberId::Decl(_) => None,
+            LuaDeclOrMemberId::Member(member_id) => Some(*member_id),
+        }
+    }
+
+    pub fn get_position(&self) -> TextSize {
+        match self {
+            LuaDeclOrMemberId::Decl(decl_id) => decl_id.position,
+            LuaDeclOrMemberId::Member(member_id) => member_id.get_position(),
+        }
+    }
+}

crates/emmylua_code_analysis/src/semantic/cache/mod.rs

@@ -4,19 +4,20 @@ pub use cache_options::{CacheOptions, LuaAnalysisPhase};
 use emmylua_parser::LuaSyntaxId;
 use std::{collections::HashMap, sync::Arc};
 
-use crate::{db_index::LuaType, FileId, FlowId, LuaDeclId, LuaFunctionType};
+use crate::{db_index::LuaType, semantic::infer::VarRefId, FileId, FlowId, LuaFunctionType};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum CacheKey {
     Expr(LuaSyntaxId),
     Call(LuaSyntaxId, Option<usize>, LuaType),
-    FlowNode(LuaDeclId, FlowId),
+    FlowNode(VarRefId, FlowId),
+    IndexRefOriginType(VarRefId),
 }
 
 #[derive(Debug)]
 pub enum CacheEntry {
     ReadyCache,
-    ExprCache(LuaType),
+    TypeCache(LuaType),
     CallCache(Arc<LuaFunctionType>),
 }
 

crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs

@@ -1,6 +1,7 @@
 use std::collections::HashSet;
 
-use emmylua_parser::{LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr};
+use emmylua_parser::{LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, PathTrait};
+use internment::ArcIntern;
 use rowan::TextRange;
 use smol_str::SmolStr;
 
@@ -12,11 +13,15 @@ use crate::{
     enum_variable_is_param,
     semantic::{
         generic::{instantiate_type_generic, TypeSubstitutor},
+        infer::{
+            infer_name::get_name_expr_var_ref_d, narrow::infer_var_expr_narrow_type, VarRefId,
+        },
         member::get_buildin_type_map_type_id,
         type_check::{self, check_type_compact},
         InferGuard,
     },
-    InFiled, LuaInferCache, LuaInstanceType, LuaMemberOwner, LuaOperatorOwner, TypeOps,
+    CacheEntry, CacheKey, InFiled, LuaDeclOrMemberId, LuaInferCache, LuaInstanceType,
+    LuaMemberOwner, LuaOperatorOwner, TypeOps,
 };
 
 use super::{infer_expr, infer_name::infer_global_type, InferFailReason, InferResult};
@@ -85,55 +90,89 @@ fn infer_member_type_pass_flow(
     cache: &mut LuaInferCache,
     index_expr: LuaIndexExpr,
     prefix_type: &LuaType,
-    mut member_type: LuaType,
+    member_type: LuaType,
 ) -> InferResult {
-    let mut allow_reassign = true;
+    // let mut allow_reassign = true;
     match &prefix_type {
         // TODO: flow analysis should not generate corresponding `flow_chain` if the prefix type is an array
         LuaType::Array(_) => {
             return Ok(member_type.clone());
         }
-        LuaType::Ref(decl_id) => {
-            let index_key = index_expr.get_index_key().ok_or(InferFailReason::None)?;
-            let key = LuaMemberKey::from_index_key(db, cache, &index_key)?;
-            let member_index = db.get_member_index();
-            if member_index
-                .get_member_item(&LuaMemberOwner::Type(decl_id.clone()), &key)
-                .is_some()
-            {
-                allow_reassign = false;
-            }
-        }
+        // LuaType::Ref(decl_id) => {
+        //     let index_key = index_expr.get_index_key().ok_or(InferFailReason::None)?;
+        //     let key = LuaMemberKey::from_index_key(db, cache, &index_key)?;
+        //     let member_index = db.get_member_index();
+        //     if member_index
+        //         .get_member_item(&LuaMemberOwner::Type(decl_id.clone()), &key)
+        //         .is_some()
+        //     {
+        //         allow_reassign = false;
+        //     }
+        // }
         _ => {}
     }
 
-    // let access_path = match index_expr.get_access_path() {
-    //     Some(path) => path,
-    //     None => return Ok(member_type.clone()),
-    // };
-    // let var_ref_id = LuaVarRefId::Name(SmolStr::new(&access_path));
-    // let flow_id = LuaClosureId::from_node(index_expr.syntax());
-    // let flow_chain = db
-    //     .get_flow_index()
-    //     .get_flow_chain(cache.get_file_id(), var_ref_id);
-    // if let Some(flow_chain) = flow_chain {
-    //     let root = index_expr.get_root();
-    //     for type_assert in flow_chain.get_type_asserts(index_expr.get_position(), flow_id) {
-    //         let new_type = type_assert.tighten_type(db, cache, &root, member_type.clone())?;
-    //         if type_assert.is_reassign() && !allow_reassign {
-    //             // 允许仅去除 nil
-    //             if member_type.is_nullable() && !new_type.is_nullable() {
-    //                 member_type = new_type;
-    //             }
-    //             continue;
-    //         }
-    //         member_type = new_type;
-    //     }
-    // }
+    let access_path = match index_expr.get_access_path() {
+        Some(path) => ArcIntern::new(SmolStr::new(&path)),
+        None => return Ok(member_type.clone()),
+    };
+
+    let mut prefix_expr = index_expr.get_prefix_expr().ok_or(InferFailReason::None)?;
+    while let LuaExpr::IndexExpr(index_expr) = prefix_expr {
+        prefix_expr = index_expr.get_prefix_expr().ok_or(InferFailReason::None)?;
+    }
+
+    if let LuaExpr::NameExpr(name_expr) = prefix_expr {
+        let decl_or_member_id = match get_name_expr_var_ref_d(db, cache, &name_expr) {
+            Some(VarRefId::SelfRef(decl_or_id)) => decl_or_id,
+            Some(VarRefId::VarRef(decl_id)) => LuaDeclOrMemberId::Decl(decl_id),
+            _ => return Ok(member_type.clone()),
+        };
+
+        let var_ref_id = VarRefId::IndexRef(decl_or_member_id, access_path);
+        let key = CacheKey::IndexRefOriginType(var_ref_id.clone());
+        cache.add_cache(&key, CacheEntry::TypeCache(member_type.clone()));
+        let result = infer_var_expr_narrow_type(db, cache, name_expr, var_ref_id);
+        match &result {
+            Err(InferFailReason::None) => return Ok(member_type.clone()),
+            _ => {}
+        }
+
+        return result;
+    }
 
     Ok(member_type)
 }
 
+pub fn get_index_expr_var_ref_id(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    index_expr: LuaIndexExpr,
+) -> Option<VarRefId> {
+    let access_path = match index_expr.get_access_path() {
+        Some(path) => ArcIntern::new(SmolStr::new(&path)),
+        None => return None,
+    };
+
+    let mut prefix_expr = index_expr.get_prefix_expr()?;
+    while let LuaExpr::IndexExpr(index_expr) = prefix_expr {
+        prefix_expr = index_expr.get_prefix_expr()?;
+    }
+
+    if let LuaExpr::NameExpr(name_expr) = prefix_expr {
+        let decl_or_member_id = match get_name_expr_var_ref_d(db, cache, &name_expr) {
+            Some(VarRefId::SelfRef(decl_or_id)) => decl_or_id,
+            Some(VarRefId::VarRef(decl_id)) => LuaDeclOrMemberId::Decl(decl_id),
+            _ => return None,
+        };
+
+        let var_ref_id = VarRefId::IndexRef(decl_or_member_id, access_path);
+        return Some(var_ref_id);
+    }
+
+    None
+}
+
 pub fn infer_member_by_member_key(
     db: &DbIndex,
     cache: &mut LuaInferCache,

…sis/src/semantic/infer/infer_name/mod.rs …nalysis/src/semantic/infer/infer_name.rscrates/emmylua_code_analysis/src/semantic/infer/infer_name/mod.rs renamed to crates/emmylua_code_analysis/src/semantic/infer/infer_name.rs crates/emmylua_code_analysis/src/semantic/infer/infer_name/mod.rs renamed to crates/emmylua_code_analysis/src/semantic/infer/infer_name.rs

@@ -1,15 +1,12 @@
-mod narrow;
-
 use emmylua_parser::{LuaAstNode, LuaNameExpr};
 
+use super::{InferFailReason, InferResult};
 use crate::{
     db_index::{DbIndex, LuaDeclOrMemberId},
-    semantic::infer::infer_name::narrow::infer_name_expr_narrow_type,
+    semantic::infer::narrow::{infer_var_expr_narrow_type, VarRefId},
     LuaDecl, LuaDeclExtra, LuaInferCache, LuaMemberId, LuaType, TypeOps,
 };
 
-use super::{InferFailReason, InferResult};
-
 pub fn infer_name_expr(
     db: &DbIndex,
     cache: &mut LuaInferCache,
@@ -31,20 +28,39 @@ pub fn infer_name_expr(
         .ok_or(InferFailReason::None)?;
     let decl_id = file_ref.get_decl_id(&range);
     if let Some(decl_id) = decl_id {
-        infer_name_expr_narrow_type(db, cache, name_expr, decl_id)
+        infer_var_expr_narrow_type(db, cache, name_expr, VarRefId::VarRef(decl_id))
     } else {
         infer_global_type(db, name)
     }
 }
 
 fn infer_self(db: &DbIndex, cache: &mut LuaInferCache, name_expr: LuaNameExpr) -> InferResult {
-    let semantic_id =
+    let decl_or_member_id =
         find_self_decl_or_member_id(db, cache, &name_expr).ok_or(InferFailReason::None)?;
-    match semantic_id {
-        LuaDeclOrMemberId::Decl(decl_id) => {
-            infer_name_expr_narrow_type(db, cache, name_expr, decl_id)
+    // LuaDeclOrMemberId::Member(member_id) => find_decl_member_type(db, member_id),
+    infer_var_expr_narrow_type(db, cache, name_expr, VarRefId::SelfRef(decl_or_member_id))
+}
+
+pub fn get_name_expr_var_ref_d(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    name_expr: &LuaNameExpr,
+) -> Option<VarRefId> {
+    let name_token = name_expr.get_name_token()?;
+    let name = name_token.get_name_text();
+    match name {
+        "self" => {
+            let decl_or_id = find_self_decl_or_member_id(db, cache, name_expr)?;
+            Some(VarRefId::SelfRef(decl_or_id))
+        }
+        _ => {
+            let file_id = cache.get_file_id();
+            let references_index = db.get_reference_index();
+            let range = name_expr.get_range();
+            let file_ref = references_index.get_local_reference(&file_id)?;
+            let decl_id = file_ref.get_decl_id(&range)?;
+            Some(VarRefId::VarRef(decl_id))
         }
-        LuaDeclOrMemberId::Member(member_id) => find_decl_member_type(db, member_id),
     }
 }
 
@@ -89,7 +105,7 @@ pub fn infer_param(db: &DbIndex, decl: &LuaDecl) -> InferResult {
     Err(InferFailReason::UnResolveDeclType(decl.get_id()))
 }
 
-fn find_decl_member_type(db: &DbIndex, member_id: LuaMemberId) -> InferResult {
+pub fn find_decl_member_type(db: &DbIndex, member_id: LuaMemberId) -> InferResult {
     let item = db
         .get_member_index()
         .get_member_item_by_member_id(member_id)

crates/emmylua_code_analysis/src/semantic/infer/infer_name/narrow/condition_flow/index_flow.rs

@@ -5,6 +5,7 @@ mod infer_index;
 mod infer_name;
 mod infer_table;
 mod infer_unary;
+mod narrow;
 mod test;
 
 use std::ops::Deref;
@@ -23,6 +24,7 @@ pub use infer_name::{find_self_decl_or_member_id, infer_param};
 use infer_table::infer_table_expr;
 pub use infer_table::{infer_table_field_value_should_be, infer_table_should_be};
 use infer_unary::infer_unary_expr;
+pub use narrow::VarRefId;
 
 use rowan::TextRange;
 use smol_str::SmolStr;
@@ -42,7 +44,7 @@ pub fn infer_expr(db: &DbIndex, cache: &mut LuaInferCache, expr: LuaExpr) -> Inf
     let key = CacheKey::Expr(syntax_id);
     match cache.get(&key) {
         Some(cache) => match cache {
-            CacheEntry::ExprCache(ty) => return Ok(ty.clone()),
+            CacheEntry::TypeCache(ty) => return Ok(ty.clone()),
             _ => return Err(InferFailReason::RecursiveInfer),
         },
         None => {}
@@ -57,7 +59,7 @@ pub fn infer_expr(db: &DbIndex, cache: &mut LuaInferCache, expr: LuaExpr) -> Inf
     {
         cache.add_cache(
             &key,
-            CacheEntry::ExprCache(bind_type_cache.as_type().clone()),
+            CacheEntry::TypeCache(bind_type_cache.as_type().clone()),
         );
         return Ok(bind_type_cache.as_type().clone());
     }
@@ -80,14 +82,14 @@ pub fn infer_expr(db: &DbIndex, cache: &mut LuaInferCache, expr: LuaExpr) -> Inf
     };
 
     match &result_type {
-        Ok(result_type) => cache.add_cache(&key, CacheEntry::ExprCache(result_type.clone())),
+        Ok(result_type) => cache.add_cache(&key, CacheEntry::TypeCache(result_type.clone())),
         Err(InferFailReason::None) | Err(InferFailReason::RecursiveInfer) => {
-            cache.add_cache(&key, CacheEntry::ExprCache(LuaType::Unknown));
+            cache.add_cache(&key, CacheEntry::TypeCache(LuaType::Unknown));
             return Ok(LuaType::Unknown);
         }
         Err(InferFailReason::FieldNotFound) => {
             if cache.get_config().analysis_phase.is_force() {
-                cache.add_cache(&key, CacheEntry::ExprCache(LuaType::Nil));
+                cache.add_cache(&key, CacheEntry::TypeCache(LuaType::Nil));
                 return Ok(LuaType::Nil);
             } else {
                 cache.ready_cache(&key);