stash

Author: CppCXY

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

@@ -11,7 +11,7 @@ use crate::{
         LuaDeclId, LuaDocParamInfo, LuaDocReturnInfo, LuaMemberId, LuaOperator, LuaSemanticDeclId,
         LuaSignatureId, LuaType,
     },
-    InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, OperatorFunction,
+    InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, LuaTypeOwner, OperatorFunction,
     SignatureReturnStatus, TypeAssertion, TypeOps,
 };
 
@@ -358,13 +358,12 @@ pub fn analyze_cast(analyzer: &mut DocAnalyzer, tag: LuaDocTagCast) -> Option<()
     for op in tag.get_op_types() {
         if let Some(doc_type) = op.get_type() {
             let typ = infer_type(analyzer, doc_type.clone());
-            analyzer.context.cast_flow.insert(
-                InFiled {
-                    file_id: analyzer.file_id,
-                    value: doc_type.get_syntax_id(),
-                },
-                typ,
-            );
+            let type_owner =
+                LuaTypeOwner::SyntaxId(InFiled::new(analyzer.file_id, doc_type.get_syntax_id()));
+            analyzer
+                .db
+                .get_type_index_mut()
+                .bind_type(type_owner, LuaTypeCache::DocType(typ));
         }
     }
     Some(())

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

@@ -1,11 +1,8 @@
-use emmylua_parser::{BinaryOperator, LuaAstNode, LuaAstToken, LuaComment, LuaDocTag};
+use emmylua_parser::{LuaAstNode, LuaComment, LuaDocTag};
 
-use crate::{
-    compilation::analyzer::flow::{
-        binder::FlowBinder,
-        flow_node::{FlowAssertion, FlowId, FlowNodeKind},
-    },
-    InFiled, LuaType, LuaVarRefId,
+use crate::compilation::analyzer::flow::{
+    binder::FlowBinder,
+    flow_node::{FlowId, FlowNodeKind},
 };
 
 enum CastAction {
@@ -14,84 +11,18 @@ enum CastAction {
     Force,
 }
 
-pub fn bind_comment(
-    binder: &mut FlowBinder,
-    lua_comment: LuaComment,
-    mut current: FlowId,
-) -> FlowId {
+pub fn bind_comment(binder: &mut FlowBinder, lua_comment: LuaComment, current: FlowId) -> FlowId {
     let cast_tags = lua_comment.get_doc_tags().filter_map(|it| match it {
         LuaDocTag::Cast(cast) => Some(cast),
         _ => None,
     });
 
-    for cast_tag in cast_tags {
-        let Some(name_token) = cast_tag.get_name_token() else {
-            continue;
-        };
-        let name = name_token.get_name_text();
-        let decl = binder
-            .db
-            .get_decl_index()
-            .get_decl_tree(&binder.file_id)
-            .and_then(|decl_tree| decl_tree.find_local_decl(&name, name_token.get_position()));
-        let var_ref_id = match decl {
-            Some(decl) => LuaVarRefId::DeclId(decl.get_id()),
-            None => LuaVarRefId::Name(name.into()),
-        };
-
-        let mut assertions = vec![];
-        for cast_op_type in cast_tag.get_op_types() {
-            let action = match cast_op_type.get_op() {
-                Some(op) => {
-                    if op.get_op() == BinaryOperator::OpAdd {
-                        CastAction::Add
-                    } else {
-                        CastAction::Remove
-                    }
-                }
-                None => CastAction::Force,
-            };
-
-            if cast_op_type.is_nullable() {
-                match action {
-                    CastAction::Add => {
-                        assertions.push(FlowAssertion::TypeAdd(var_ref_id.clone(), LuaType::Nil));
-                    }
-                    CastAction::Remove => {
-                        assertions
-                            .push(FlowAssertion::TypeRemove(var_ref_id.clone(), LuaType::Nil));
-                    }
-                    _ => {}
-                }
-            } else if let Some(doc_typ) = cast_op_type.get_type() {
-                let file_id = binder.file_id;
-                let key = InFiled::new(file_id, doc_typ.get_syntax_id());
-                let typ = match binder.context.cast_flow.get(&key) {
-                    Some(t) => t.clone(),
-                    None => continue,
-                };
-
-                match action {
-                    CastAction::Add => {
-                        assertions.push(FlowAssertion::TypeAdd(var_ref_id.clone(), typ.clone()));
-                    }
-                    CastAction::Remove => {
-                        assertions.push(FlowAssertion::TypeRemove(var_ref_id.clone(), typ.clone()));
-                    }
-                    CastAction::Force => {
-                        assertions.push(FlowAssertion::TypeForce(var_ref_id.clone(), typ.clone()));
-                    }
-                }
-            }
-        }
-
-        for assertion in assertions {
-            let flow_assertion = assertion.clone();
-            let flow_id = binder.create_node(FlowNodeKind::Assertion(flow_assertion.into()));
-            binder.add_antecedent(flow_id, current);
-            current = flow_id;
-        }
+    let mut parent = current;
+    for cast in cast_tags {
+        let flow_id = binder.create_node(FlowNodeKind::TagCast(cast.to_ptr()));
+        binder.add_antecedent(flow_id, parent);
+        parent = flow_id;
     }
 
-    current
+    parent
 }

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs

@@ -10,13 +10,24 @@ use crate::{
     compilation::analyzer::flow::{
         bind_analyze::bind_each_child,
         binder::FlowBinder,
-        flow_node::{FlowAssertion, FlowId, FlowNodeKind},
+        flow_node::{FlowId, FlowNodeKind},
     },
     LuaVarRefId,
 };
 pub use bind_binary_expr::bind_binary_expr;
 pub use bind_call_expr::bind_call_expr;
 
+pub fn bind_condition_expr(
+    binder: &mut FlowBinder,
+    condition_expr: LuaExpr,
+    current: FlowId,
+    true_target: FlowId,
+    false_target: FlowId,
+) {
+    let flow_id = bind_expr(binder, condition_expr, current);
+    // todo
+}
+
 pub fn bind_expr(binder: &mut FlowBinder, expr: LuaExpr, current: FlowId) -> FlowId {
     match expr {
         LuaExpr::NameExpr(name_expr) => bind_name_expr(binder, name_expr, current),
@@ -32,27 +43,10 @@ pub fn bind_expr(binder: &mut FlowBinder, expr: LuaExpr, current: FlowId) -> Flo
 }
 
 pub fn bind_name_expr(binder: &mut FlowBinder, name_expr: LuaNameExpr, current: FlowId) -> FlowId {
-    let Some(name_text) = name_expr.get_name_text() else {
-        return current;
-    };
-    let position = name_expr.get_position();
-
-    let Some(decl_tree) = binder.db.get_decl_index().get_decl_tree(&binder.file_id) else {
-        return current;
-    };
-    let var_ref_id = match decl_tree.find_local_decl(&name_text, position) {
-        Some(decl) => LuaVarRefId::DeclId(decl.get_id()),
-        None => LuaVarRefId::Name(name_text.into()),
-    };
-
-    let flow_id = binder.create_node(FlowNodeKind::Assertion(
-        FlowAssertion::Truthy(var_ref_id).into(),
-    ));
-
-    binder.add_antecedent(flow_id, current);
-    binder.bind_syntax_node(name_expr.get_syntax_id(), flow_id);
-
-    flow_id
+    let name_node = binder.create_node(FlowNodeKind::Variable(name_expr.to_ptr()));
+    binder.add_antecedent(name_node, current);
+    binder.bind_syntax_node(name_expr.get_syntax_id(), name_node);
+    name_node
 }
 
 pub fn bind_table_expr(