From d706173dbb2a0072a597d88fb9dbfeaec425f63b Mon Sep 17 00:00:00 2001 From: CppCXY <812125110@qq.com> Date: Tue, 8 Jul 2025 15:37:39 +0800 Subject: [PATCH] refactor-flow --- .../compilation/analyzer/doc/type_ref_tags.rs | 93 +--- .../analyzer/flow/bind_analyze/comment.rs | 37 ++ .../bind_analyze/exprs/bind_binary_expr.rs | 88 ++++ .../analyzer/flow/bind_analyze/exprs/mod.rs | 131 ++++++ .../analyzer/flow/bind_analyze/mod.rs | 127 +++++ .../analyzer/flow/bind_analyze/stats.rs | 377 +++++++++++++++ .../src/compilation/analyzer/flow/binder.rs | 188 ++++++++ .../analyzer/flow/build_flow_tree.rs | 438 ------------------ .../compilation/analyzer/flow/cast_analyze.rs | 75 --- .../compilation/analyzer/flow/flow_node.rs | 119 ----- .../src/compilation/analyzer/flow/mod.rs | 146 +----- .../flow/var_analyze/broadcast_down.rs | 62 --- .../flow/var_analyze/broadcast_inside.rs | 65 --- .../flow/var_analyze/broadcast_outside.rs | 31 -- .../analyzer/flow/var_analyze/broadcast_up.rs | 436 ----------------- .../analyzer/flow/var_analyze/mod.rs | 122 ----- .../flow/var_analyze/unresolve_trace.rs | 48 -- .../analyzer/flow/var_analyze/var_trace.rs | 151 ------ .../flow/var_analyze/var_trace_info.rs | 84 ---- .../src/compilation/analyzer/lua/stats.rs | 2 +- .../src/compilation/analyzer/mod.rs | 8 +- .../analyzer/unresolve/find_decl_function.rs | 4 +- .../analyzer/unresolve/resolve_closure.rs | 15 +- .../src/compilation/test/and_or_test.rs | 3 +- .../src/compilation/test/flow.rs | 2 +- .../src/compilation/test/static_cal_cmp.rs | 2 +- .../src/db_index/declaration/decl_tree.rs | 25 +- .../src/db_index/flow/flow_chain.rs | 78 ---- .../src/db_index/flow/flow_node.rs | 128 +++++ .../src/db_index/flow/flow_tree.rs | 47 ++ .../src/db_index/flow/flow_var_ref_id.rs | 46 -- .../src/db_index/flow/mod.rs | 82 ++-- .../src/db_index/flow/signature_cast.rs | 7 + .../src/db_index/flow/type_assert.rs | 211 --------- .../src/db_index/reference/mod.rs | 4 + .../src/db_index/type/mod.rs | 30 +- .../src/db_index/type/type_ops/and_type.rs | 51 -- .../src/db_index/type/type_ops/mod.rs | 50 -- .../src/db_index/type/type_ops/remove_type.rs | 4 +- .../src/db_index/type/type_ops/test.rs | 144 +++--- .../src/db_index/type/types.rs | 128 +++-- .../diagnostic/checker/cast_type_mismatch.rs | 6 +- .../diagnostic/checker/check_param_count.rs | 14 +- .../test/unnecessary_assert_test.rs | 3 - .../src/semantic/cache/mod.rs | 51 +- .../generic/instantiate_type_generic.rs | 2 +- .../src/semantic/generic/tpl_pattern.rs | 2 +- .../infer/infer_binary/infer_binary_or.rs | 18 +- .../src/semantic/infer/infer_binary/mod.rs | 13 +- .../src/semantic/infer/infer_call/mod.rs | 45 +- .../src/semantic/infer/infer_index.rs | 101 ++-- .../src/semantic/infer/infer_name.rs | 102 ++-- .../src/semantic/infer/mod.rs | 37 +- .../narrow/condition_flow/binary_flow.rs | 304 ++++++++++++ .../infer/narrow/condition_flow/call_flow.rs | 251 ++++++++++ .../infer/narrow/condition_flow/index_flow.rs | 45 ++ .../infer/narrow/condition_flow/mod.rs | 198 ++++++++ .../infer/narrow/get_type_at_cast_flow.rs | 195 ++++++++ .../semantic/infer/narrow/get_type_at_flow.rs | 288 ++++++++++++ .../src/semantic/infer/narrow/mod.rs | 115 +++++ .../narrow/narrow_type}/false_or_nil_type.rs | 8 +- .../infer/narrow/narrow_type/mod.rs} | 41 +- .../src/semantic/infer/narrow/var_ref_id.rs | 64 +++ .../src/semantic/member/find_index.rs | 2 +- .../emmylua_code_analysis/src/semantic/mod.rs | 2 +- .../semantic_info/infer_expr_semantic_decl.rs | 2 +- .../src/semantic/semantic_info/mod.rs | 4 +- .../semantic/type_check/complex_type/mod.rs | 6 +- .../complex_type/table_generic_check.rs | 2 +- .../src/semantic/type_check/func_type.rs | 2 +- .../src/semantic/type_check/ref_type.rs | 4 +- .../src/semantic/type_check/simple_type.rs | 4 +- .../completion/providers/env_provider.rs | 44 +- .../completion/providers/function_provider.rs | 2 +- .../src/handlers/hover/find_origin.rs | 2 +- .../src/handlers/hover/function_humanize.rs | 6 +- .../inlay_hint/build_function_hint.rs | 2 +- .../build_signature_helper.rs | 4 +- .../src/handlers/test/hover_test.rs | 34 +- crates/emmylua_parser/src/syntax/mod.rs | 32 ++ .../src/syntax/node/lua/expr.rs | 9 + .../emmylua_parser/src/syntax/traits/mod.rs | 16 +- 82 files changed, 3238 insertions(+), 2733 deletions(-) create mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/comment.rs create mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_binary_expr.rs create mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs create mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs create mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs create mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/build_flow_tree.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/cast_analyze.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/flow_node.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_down.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_inside.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_outside.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_up.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/mod.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/unresolve_trace.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace.rs delete mode 100644 crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace_info.rs delete mode 100644 crates/emmylua_code_analysis/src/db_index/flow/flow_chain.rs create mode 100644 crates/emmylua_code_analysis/src/db_index/flow/flow_node.rs create mode 100644 crates/emmylua_code_analysis/src/db_index/flow/flow_tree.rs delete mode 100644 crates/emmylua_code_analysis/src/db_index/flow/flow_var_ref_id.rs create mode 100644 crates/emmylua_code_analysis/src/db_index/flow/signature_cast.rs delete mode 100644 crates/emmylua_code_analysis/src/db_index/flow/type_assert.rs delete mode 100644 crates/emmylua_code_analysis/src/db_index/type/type_ops/and_type.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/binary_flow.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/call_flow.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/index_flow.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/mod.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_cast_flow.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/mod.rs rename crates/emmylua_code_analysis/src/{db_index/type/type_ops => semantic/infer/narrow/narrow_type}/false_or_nil_type.rs (87%) rename crates/emmylua_code_analysis/src/{db_index/type/type_ops/narrow_type.rs => semantic/infer/narrow/narrow_type/mod.rs} (81%) create mode 100644 crates/emmylua_code_analysis/src/semantic/infer/narrow/var_ref_id.rs diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs index bdd2e4a94..0d28df5a0 100644 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs @@ -1,20 +1,18 @@ use emmylua_parser::{ - BinaryOperator, LuaAst, LuaAstNode, LuaAstToken, LuaBlock, LuaDocDescriptionOwner, LuaDocTagAs, - LuaDocTagCast, LuaDocTagModule, LuaDocTagOther, LuaDocTagOverload, LuaDocTagParam, - LuaDocTagReturn, LuaDocTagReturnCast, LuaDocTagSee, LuaDocTagType, LuaExpr, LuaLocalName, - LuaTokenKind, LuaVarExpr, + LuaAst, LuaAstNode, LuaAstToken, LuaBlock, LuaDocDescriptionOwner, LuaDocTagAs, LuaDocTagCast, + LuaDocTagModule, LuaDocTagOther, LuaDocTagOverload, LuaDocTagParam, LuaDocTagReturn, + LuaDocTagReturnCast, LuaDocTagSee, LuaDocTagType, LuaExpr, LuaLocalName, LuaTokenKind, + LuaVarExpr, }; use crate::{ - compilation::analyzer::{ - bind_type::bind_type, flow::CastAction, unresolve::UnResolveModuleRef, - }, + compilation::analyzer::{bind_type::bind_type, unresolve::UnResolveModuleRef}, db_index::{ LuaDeclId, LuaDocParamInfo, LuaDocReturnInfo, LuaMemberId, LuaOperator, LuaSemanticDeclId, LuaSignatureId, LuaType, }, - InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, OperatorFunction, - SignatureReturnStatus, TypeAssertion, TypeOps, + InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, LuaTypeOwner, OperatorFunction, + SignatureReturnStatus, TypeOps, }; use super::{ @@ -193,61 +191,19 @@ pub fn analyze_return_cast(analyzer: &mut DocAnalyzer, tag: LuaDocTagReturnCast) let name_token = tag.get_name_token()?; let name = name_token.get_name_text(); let cast_op_type = tag.get_op_type()?; - 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 let Some(node_type) = cast_op_type.get_type() { + let typ = infer_type(analyzer, node_type.clone()); + let infiled_syntax_id = InFiled::new(analyzer.file_id, node_type.get_syntax_id()); + let type_owner = LuaTypeOwner::SyntaxId(infiled_syntax_id); + bind_type(analyzer.db, type_owner, LuaTypeCache::DocType(typ)); }; - if cast_op_type.is_nullable() { - match action { - CastAction::Add => { - analyzer.db.get_flow_index_mut().add_call_cast( - signature_id, - name, - TypeAssertion::Add(LuaType::Nil), - ); - } - CastAction::Remove => { - analyzer.db.get_flow_index_mut().add_call_cast( - signature_id, - name, - TypeAssertion::Remove(LuaType::Nil), - ); - } - _ => {} - } - } else if let Some(doc_type) = cast_op_type.get_type() { - let typ = infer_type(analyzer, doc_type.clone()); - match action { - CastAction::Add => { - analyzer.db.get_flow_index_mut().add_call_cast( - signature_id, - name, - TypeAssertion::Add(typ), - ); - } - CastAction::Remove => { - analyzer.db.get_flow_index_mut().add_call_cast( - signature_id, - name, - TypeAssertion::Remove(typ), - ); - } - CastAction::Force => { - analyzer.db.get_flow_index_mut().add_call_cast( - signature_id, - name, - TypeAssertion::Force(typ), - ); - } - } - } + analyzer.db.get_flow_index_mut().add_signature_cast( + analyzer.file_id, + signature_id, + name.to_string(), + cast_op_type.to_ptr(), + ); } Some(()) @@ -354,13 +310,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(()) diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/comment.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/comment.rs new file mode 100644 index 000000000..7276bc0ca --- /dev/null +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/comment.rs @@ -0,0 +1,37 @@ +use emmylua_parser::{LuaAstNode, LuaComment, LuaDocTag}; + +use crate::{compilation::analyzer::flow::binder::FlowBinder, FlowId, FlowNodeKind}; + +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, + }); + + let mut parent = current; + for cast in cast_tags { + let expr = cast.get_key_expr(); + if expr.is_some() { + let flow_id = binder.create_node(FlowNodeKind::TagCast(cast.to_ptr())); + binder.add_antecedent(flow_id, parent); + parent = flow_id; + } else { + // inline cast + let Some(owner) = lua_comment.get_owner() else { + continue; + }; + + let flow_id = binder.create_node(FlowNodeKind::TagCast(cast.to_ptr())); + let bind_flow_id = binder.get_bind_flow(owner.get_syntax_id()); + if let Some(bind_flow) = bind_flow_id { + binder.add_antecedent(flow_id, bind_flow); + binder.bind_syntax_node(owner.get_syntax_id(), flow_id); + } else { + binder.add_antecedent(flow_id, parent); + binder.bind_syntax_node(owner.get_syntax_id(), flow_id); + } + } + } + + parent +} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_binary_expr.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_binary_expr.rs new file mode 100644 index 000000000..7210de211 --- /dev/null +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_binary_expr.rs @@ -0,0 +1,88 @@ +use emmylua_parser::{BinaryOperator, LuaAst, LuaBinaryExpr, LuaExpr}; + +use crate::{ + compilation::analyzer::flow::{ + bind_analyze::{bind_each_child, exprs::bind_condition_expr, finish_flow_label}, + binder::FlowBinder, + }, + FlowId, +}; + +pub fn bind_binary_expr( + binder: &mut FlowBinder, + binary_expr: LuaBinaryExpr, + current: FlowId, +) -> Option<()> { + let op_token = binary_expr.get_op_token()?; + + match op_token.get_op() { + BinaryOperator::OpAnd => bind_and_expr(binder, binary_expr, current), + BinaryOperator::OpOr => bind_or_expr(binder, binary_expr, current), + _ => { + bind_each_child(binder, LuaAst::LuaBinaryExpr(binary_expr.clone()), current); + Some(()) + } + } +} + +fn bind_and_expr( + binder: &mut FlowBinder, + binary_expr: LuaBinaryExpr, + current: FlowId, +) -> Option<()> { + let (left, right) = binary_expr.get_exprs()?; + + let pre_right = binder.create_branch_label(); + bind_condition_expr(binder, left, current, pre_right, binder.false_target); + let current = finish_flow_label(binder, pre_right, current); + bind_condition_expr( + binder, + right, + current, + binder.true_target, + binder.false_target, + ); + + Some(()) +} + +fn bind_or_expr( + binder: &mut FlowBinder, + binary_expr: LuaBinaryExpr, + current: FlowId, +) -> Option<()> { + let (left, right) = binary_expr.get_exprs()?; + let pre_right = binder.create_branch_label(); + bind_condition_expr(binder, left, current, binder.true_target, pre_right); + let current = finish_flow_label(binder, pre_right, current); + bind_condition_expr( + binder, + right, + current, + binder.true_target, + binder.false_target, + ); + Some(()) +} + +pub fn is_binary_logical(expr: &LuaExpr) -> bool { + match expr { + LuaExpr::BinaryExpr(binary_expr) => { + let Some(op_token) = binary_expr.get_op_token() else { + return false; + }; + + return match op_token.get_op() { + BinaryOperator::OpAnd | BinaryOperator::OpOr => true, + _ => false, + }; + } + LuaExpr::ParenExpr(paren_expr) => { + if let Some(inner_expr) = paren_expr.get_expr() { + return is_binary_logical(&inner_expr); + } + } + _ => {} + } + false +} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs new file mode 100644 index 000000000..a7ed8d9f4 --- /dev/null +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs @@ -0,0 +1,131 @@ +mod bind_binary_expr; + +use emmylua_parser::{ + LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaIndexExpr, LuaNameExpr, + LuaTableExpr, LuaUnaryExpr, +}; + +use crate::{ + compilation::analyzer::flow::{ + bind_analyze::{bind_each_child, exprs::bind_binary_expr::is_binary_logical}, + binder::FlowBinder, + }, + FlowId, FlowNodeKind, +}; +pub use bind_binary_expr::bind_binary_expr; + +pub fn bind_condition_expr( + binder: &mut FlowBinder, + condition_expr: LuaExpr, + current: FlowId, + true_target: FlowId, + false_target: FlowId, +) { + let old_true_target = binder.true_target; + let old_false_target = binder.false_target; + + binder.true_target = true_target; + binder.false_target = false_target; + bind_expr(binder, condition_expr.clone(), current); + binder.true_target = old_true_target; + binder.false_target = old_false_target; + + if !is_binary_logical(&condition_expr) { + let true_condition = + binder.create_node(FlowNodeKind::TrueCondition(condition_expr.to_ptr())); + binder.add_antecedent(true_condition, current); + binder.add_antecedent(true_target, true_condition); + + let false_condition = + binder.create_node(FlowNodeKind::FalseCondition(condition_expr.to_ptr())); + binder.add_antecedent(false_condition, current); + binder.add_antecedent(false_target, false_condition); + } +} + +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), + LuaExpr::CallExpr(call_expr) => bind_call_expr(binder, call_expr, current), + LuaExpr::TableExpr(table_expr) => bind_table_expr(binder, table_expr, current), + LuaExpr::LiteralExpr(_) => Some(()), // Literal expressions do not need binding + LuaExpr::ClosureExpr(closure_expr) => bind_closure_expr(binder, closure_expr, current), + LuaExpr::ParenExpr(paren_expr) => bind_paren_expr(binder, paren_expr, current), + LuaExpr::IndexExpr(index_expr) => bind_index_expr(binder, index_expr, current), + LuaExpr::BinaryExpr(binary_expr) => bind_binary_expr(binder, binary_expr, current), + LuaExpr::UnaryExpr(unary_expr) => bind_unary_expr(binder, unary_expr, current), + }; + + current +} + +pub fn bind_name_expr( + binder: &mut FlowBinder, + name_expr: LuaNameExpr, + current: FlowId, +) -> Option<()> { + binder.bind_syntax_node(name_expr.get_syntax_id(), current); + Some(()) +} + +pub fn bind_table_expr( + binder: &mut FlowBinder, + table_expr: LuaTableExpr, + current: FlowId, +) -> Option<()> { + bind_each_child(binder, LuaAst::LuaTableExpr(table_expr), current); + Some(()) +} + +pub fn bind_closure_expr( + binder: &mut FlowBinder, + closure_expr: LuaClosureExpr, + current: FlowId, +) -> Option<()> { + bind_each_child(binder, LuaAst::LuaClosureExpr(closure_expr), current); + Some(()) +} + +pub fn bind_index_expr( + binder: &mut FlowBinder, + index_expr: LuaIndexExpr, + current: FlowId, +) -> Option<()> { + binder.bind_syntax_node(index_expr.get_syntax_id(), current); + bind_each_child(binder, LuaAst::LuaIndexExpr(index_expr.clone()), current); + Some(()) +} + +pub fn bind_paren_expr( + binder: &mut FlowBinder, + paren_expr: emmylua_parser::LuaParenExpr, + current: FlowId, +) -> Option<()> { + let Some(inner_expr) = paren_expr.get_expr() else { + return None; + }; + + bind_expr(binder, inner_expr, current); + Some(()) +} + +pub fn bind_unary_expr( + binder: &mut FlowBinder, + unary_expr: LuaUnaryExpr, + current: FlowId, +) -> Option<()> { + let Some(inner_expr) = unary_expr.get_expr() else { + return None; + }; + bind_expr(binder, inner_expr, current); + Some(()) +} + +pub fn bind_call_expr( + binder: &mut FlowBinder, + call_expr: LuaCallExpr, + current: FlowId, +) -> Option<()> { + bind_each_child(binder, LuaAst::LuaCallExpr(call_expr.clone()), current); + Some(()) +} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs new file mode 100644 index 000000000..5e53bf151 --- /dev/null +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs @@ -0,0 +1,127 @@ +mod comment; +mod exprs; +mod stats; + +use emmylua_parser::{LuaAst, LuaAstNode, LuaBlock, LuaChunk, LuaExpr}; + +use crate::{ + compilation::analyzer::flow::{ + bind_analyze::{ + comment::bind_comment, + exprs::bind_expr, + stats::{ + bind_assign_stat, bind_break_stat, bind_call_expr_stat, bind_do_stat, + bind_for_range_stat, bind_for_stat, bind_func_stat, bind_goto_stat, bind_if_stat, + bind_label_stat, bind_local_func_stat, bind_local_stat, bind_repeat_stat, + bind_return_stat, bind_while_stat, + }, + }, + binder::FlowBinder, + }, + FlowAntecedent, FlowId, FlowNodeKind, +}; + +#[allow(unused)] +pub fn bind_analyze(binder: &mut FlowBinder, chunk: LuaChunk) -> Option<()> { + let block = chunk.get_block()?; + let start = binder.start; + bind_block(binder, block, start); + Some(()) +} + +fn bind_block(binder: &mut FlowBinder, block: LuaBlock, current: FlowId) -> FlowId { + let mut return_flow_id = current; + for node in block.children::() { + return_flow_id = bind_node(binder, node, return_flow_id); + if let Some(flow_node) = binder.get_flow(return_flow_id) { + match &flow_node.kind { + FlowNodeKind::Return | FlowNodeKind::Break => { + return_flow_id = binder.unreachable; + break; + } + _ => {} + } + } + } + + return_flow_id +} + +fn bind_each_child(binder: &mut FlowBinder, ast_node: LuaAst, mut current: FlowId) -> FlowId { + for node in ast_node.children::() { + current = bind_node(binder, node, current); + } + + current +} + +fn bind_node(binder: &mut FlowBinder, node: LuaAst, current: FlowId) -> FlowId { + match node { + LuaAst::LuaBlock(block) => bind_block(binder, block, current), + // stat + LuaAst::LuaAssignStat(assign_stat) => bind_assign_stat(binder, assign_stat, current), + LuaAst::LuaLocalStat(local_stat) => bind_local_stat(binder, local_stat, current), + LuaAst::LuaCallExprStat(call_expr_stat) => { + bind_call_expr_stat(binder, call_expr_stat, current) + } + LuaAst::LuaLabelStat(label_stat) => bind_label_stat(binder, label_stat, current), + LuaAst::LuaBreakStat(break_stat) => bind_break_stat(binder, break_stat, current), + LuaAst::LuaGotoStat(goto_stat) => bind_goto_stat(binder, goto_stat, current), + LuaAst::LuaReturnStat(return_stat) => bind_return_stat(binder, return_stat, current), + LuaAst::LuaDoStat(do_stat) => bind_do_stat(binder, do_stat, current), + LuaAst::LuaWhileStat(while_stat) => bind_while_stat(binder, while_stat, current), + LuaAst::LuaRepeatStat(repeat_stat) => bind_repeat_stat(binder, repeat_stat, current), + LuaAst::LuaIfStat(if_stat) => bind_if_stat(binder, if_stat, current), + LuaAst::LuaForStat(for_stat) => bind_for_stat(binder, for_stat, current), + LuaAst::LuaForRangeStat(for_range_stat) => { + bind_for_range_stat(binder, for_range_stat, current) + } + LuaAst::LuaFuncStat(func_stat) => bind_func_stat(binder, func_stat, current), + LuaAst::LuaLocalFuncStat(local_func_stat) => { + bind_local_func_stat(binder, local_func_stat, current) + } + // LuaAst::LuaElseIfClauseStat(else_if_clause_stat) => todo!(), + // LuaAst::LuaElseClauseStat(else_clause_stat) => todo!(), + + // exprs + LuaAst::LuaNameExpr(_) + | LuaAst::LuaIndexExpr(_) + | LuaAst::LuaTableExpr(_) + | LuaAst::LuaBinaryExpr(_) + | LuaAst::LuaUnaryExpr(_) + | LuaAst::LuaParenExpr(_) + | LuaAst::LuaCallExpr(_) + | LuaAst::LuaLiteralExpr(_) + | LuaAst::LuaClosureExpr(_) => bind_expr( + binder, + LuaExpr::cast(node.syntax().clone()).unwrap(), + current, + ), + + LuaAst::LuaComment(comment) => bind_comment(binder, comment, current), + LuaAst::LuaTableField(_) + | LuaAst::LuaParamList(_) + | LuaAst::LuaParamName(_) + | LuaAst::LuaCallArgList(_) + | LuaAst::LuaLocalName(_) => bind_each_child(binder, node, current), + + _ => current, + } +} + +fn finish_flow_label(binder: &mut FlowBinder, label: FlowId, default: FlowId) -> FlowId { + if let Some(flow_node) = binder.get_flow(label) { + if let Some(antecedent) = &flow_node.antecedent { + if let FlowAntecedent::Single(existing_id) = antecedent { + return *existing_id; + } + } else { + return default; + } + } else { + // This should not happen, but if it does, we can safely ignore it. + // It means that the label was never used. + return binder.unreachable; + } + label +} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs new file mode 100644 index 000000000..1e2002a4a --- /dev/null +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs @@ -0,0 +1,377 @@ +use emmylua_parser::{ + LuaAssignStat, LuaAst, LuaAstNode, LuaBlock, LuaBreakStat, LuaCallExprStat, LuaDoStat, + LuaForRangeStat, LuaForStat, LuaFuncStat, LuaGotoStat, LuaIfStat, LuaLabelStat, LuaLocalStat, + LuaRepeatStat, LuaReturnStat, LuaWhileStat, +}; + +use crate::{ + compilation::analyzer::flow::{ + bind_analyze::{ + bind_block, bind_each_child, bind_node, + exprs::{bind_condition_expr, bind_expr}, + finish_flow_label, + }, + binder::FlowBinder, + }, + AnalyzeError, DiagnosticCode, FlowId, FlowNodeKind, LuaClosureId, LuaDeclId, +}; + +pub fn bind_local_stat( + binder: &mut FlowBinder, + local_stat: LuaLocalStat, + current: FlowId, +) -> FlowId { + let local_names = local_stat.get_local_name_list().collect::>(); + let values = local_stat.get_value_exprs().collect::>(); + let min_len = local_names.len().min(values.len()); + for i in 0..min_len { + let name = &local_names[i]; + let value = &values[i]; + let decl_id = LuaDeclId::new(binder.file_id, name.get_position()); + let flow_id = bind_expr(binder, value.clone(), current); + binder.decl_bind_flow_ref.insert(decl_id, flow_id); + } + + for value in values { + // If there are more values than names, we still need to bind the values + bind_expr(binder, value.clone(), current); + } + + let local_flow_id = binder.create_decl(local_stat.get_position()); + binder.add_antecedent(local_flow_id, current); + local_flow_id +} + +pub fn bind_assign_stat( + binder: &mut FlowBinder, + assign_stat: LuaAssignStat, + current: FlowId, +) -> FlowId { + let (vars, values) = assign_stat.get_var_and_expr_list(); + // First bind the right-hand side expressions + for expr in &values { + if let Some(ast) = LuaAst::cast(expr.syntax().clone()) { + bind_node(binder, ast, current); + } + } + + for var in &vars { + if let Some(ast) = LuaAst::cast(var.syntax().clone()) { + bind_node(binder, ast, current); + } + } + + let assignment_kind = FlowNodeKind::Assignment(assign_stat.to_ptr()); + let flow_id = binder.create_node(assignment_kind); + binder.add_antecedent(flow_id, current); + + flow_id +} + +pub fn bind_call_expr_stat( + binder: &mut FlowBinder, + call_expr_stat: LuaCallExprStat, + current: FlowId, +) -> FlowId { + let call_expr = match call_expr_stat.get_call_expr() { + Some(expr) => expr, + None => return current, // If there's no call expression, just return the current flow + }; + + if let Some(ast) = LuaAst::cast(call_expr.syntax().clone()) { + bind_each_child(binder, ast, current); + } + + if call_expr.is_assert() { + let assert_flow_id = binder.create_node(FlowNodeKind::AssertCall(call_expr.to_ptr())); + binder.add_antecedent(assert_flow_id, current); + assert_flow_id + } else if call_expr.is_error() { + let return_flow_id = binder.create_return(); + binder.add_antecedent(return_flow_id, current); + return_flow_id + } else { + current + } +} + +pub fn bind_label_stat( + binder: &mut FlowBinder, + label_stat: LuaLabelStat, + current: FlowId, +) -> FlowId { + let Some(label_name_token) = label_stat.get_label_name_token() else { + return current; // If there's no label token, just return the current flow + }; + let label_name = label_name_token.get_name_text(); + let closure_id = LuaClosureId::from_node(label_stat.syntax()); + let name_label = binder.create_name_label(label_name, closure_id); + binder.add_antecedent(name_label, current); + + name_label +} + +pub fn bind_break_stat( + binder: &mut FlowBinder, + break_stat: LuaBreakStat, + current: FlowId, +) -> FlowId { + let break_flow_id = binder.create_break(); + if let Some(loop_flow) = binder.get_flow(binder.loop_label) { + if loop_flow.kind.is_unreachable() { + // report a error if we are trying to break outside a loop + binder.report_error(AnalyzeError::new( + DiagnosticCode::SyntaxError, + &t!("Break outside loop"), + break_stat.get_range(), + )); + return current; + } + } + + binder.add_antecedent(break_flow_id, current); + binder.add_antecedent(binder.break_target_label, break_flow_id); + break_flow_id +} + +pub fn bind_goto_stat(binder: &mut FlowBinder, goto_stat: LuaGotoStat, current: FlowId) -> FlowId { + // Goto statements are handled separately in the flow analysis + // They will be processed when we analyze the labels + // For now, we just return None to indicate no flow node is created + let closure_id = LuaClosureId::from_node(goto_stat.syntax()); + let Some(label_token) = goto_stat.get_label_name_token() else { + return current; // If there's no label token, just return the current flow + }; + + let label_name = label_token.get_name_text(); + let return_flow_id = binder.create_return(); + binder.cache_goto_flow(closure_id, label_name, return_flow_id); + binder.add_antecedent(return_flow_id, current); + return_flow_id +} + +pub fn bind_return_stat( + binder: &mut FlowBinder, + return_stat: LuaReturnStat, + current: FlowId, +) -> FlowId { + // If there are expressions in the return statement, bind them + for expr in return_stat.get_expr_list() { + bind_expr(binder, expr.clone(), current); + } + + // Return statements are typically used to exit a function + // We can treat them as a flow node that indicates the end of the current flow + let return_flow_id = binder.create_return(); + binder.add_antecedent(return_flow_id, current); + + return_flow_id +} + +pub fn bind_do_stat(binder: &mut FlowBinder, do_stat: LuaDoStat, mut current: FlowId) -> FlowId { + // Do statements are typically used for blocks of code + // We can treat them as a block and bind their contents + if let Some(do_block) = do_stat.get_block() { + current = bind_block(binder, do_block, current); + } + + current +} + +fn bind_iter_block( + binder: &mut FlowBinder, + iter_block: LuaBlock, + current: FlowId, + loop_label: FlowId, + break_target_label: FlowId, +) -> FlowId { + let old_loop_label = binder.loop_label; + let old_loop_post_label = binder.break_target_label; + + binder.loop_label = loop_label; + binder.break_target_label = break_target_label; + // Bind the block of code inside the iterator + let flow_id = bind_block(binder, iter_block, current); + + // Restore the previous loop labels + binder.loop_label = old_loop_label; + binder.break_target_label = old_loop_post_label; + + flow_id +} + +pub fn bind_while_stat( + binder: &mut FlowBinder, + while_stat: LuaWhileStat, + current: FlowId, +) -> FlowId { + let pre_while_label = binder.create_loop_label(); + let post_while_label = binder.create_branch_label(); + let pre_block_label = binder.create_branch_label(); + binder.add_antecedent(pre_while_label, current); + let Some(condition_expr) = while_stat.get_condition_expr() else { + return current; + }; + + bind_condition_expr( + binder, + condition_expr, + current, + pre_block_label, + post_while_label, + ); + + let block_current = finish_flow_label(binder, pre_block_label, current); + + if let Some(iter_block) = while_stat.get_block() { + // Bind the block of code inside the while loop + bind_iter_block( + binder, + iter_block, + block_current, + pre_while_label, + post_while_label, + ); + } + + finish_flow_label(binder, post_while_label, current) +} + +pub fn bind_repeat_stat( + binder: &mut FlowBinder, + repeat_stat: LuaRepeatStat, + current: FlowId, +) -> FlowId { + let pre_repeat_label = binder.create_loop_label(); + let post_repeat_label = binder.create_branch_label(); + binder.add_antecedent(pre_repeat_label, current); + + let mut block_flow_id = pre_repeat_label; + // Bind the block of code inside the repeat statement + if let Some(iter_block) = repeat_stat.get_block() { + block_flow_id = bind_iter_block( + binder, + iter_block, + pre_repeat_label, + pre_repeat_label, + post_repeat_label, + ); + } + + // Bind the condition expression + if let Some(condition_expr) = repeat_stat.get_condition_expr() { + bind_expr(binder, condition_expr, block_flow_id); + } + + finish_flow_label(binder, post_repeat_label, block_flow_id) +} + +pub fn bind_if_stat(binder: &mut FlowBinder, if_stat: LuaIfStat, current: FlowId) -> FlowId { + let post_if_label = binder.create_branch_label(); + let mut else_label = binder.create_branch_label(); + let then_label = binder.create_branch_label(); + if let Some(condition_expr) = if_stat.get_condition_expr() { + bind_condition_expr(binder, condition_expr, current, then_label, else_label); + } + + if let Some(then_block) = if_stat.get_block() { + let then_label = finish_flow_label(binder, then_label, current); + let block_id = bind_block(binder, then_block, then_label); + binder.add_antecedent(post_if_label, block_id); + } + + for elseif_clause in if_stat.get_else_if_clause_list() { + let pre_elseif_label = finish_flow_label(binder, else_label, current); + let post_elseif_label = binder.create_branch_label(); + let elseif_then_label = binder.create_branch_label(); + if let Some(condition_expr) = elseif_clause.get_condition_expr() { + bind_condition_expr( + binder, + condition_expr, + pre_elseif_label, + elseif_then_label, + post_elseif_label, + ); + } + else_label = finish_flow_label(binder, post_elseif_label, current); + if let Some(elseif_block) = elseif_clause.get_block() { + let current = finish_flow_label(binder, elseif_then_label, current); + let block_id = bind_block(binder, elseif_block, current); + binder.add_antecedent(post_if_label, block_id); + } + } + + if let Some(else_clause) = if_stat.get_else_clause() { + let else_block = else_clause.get_block(); + if let Some(else_block) = else_block { + let block_id = bind_block(binder, else_block, else_label); + binder.add_antecedent(post_if_label, block_id); + } + } + + finish_flow_label(binder, post_if_label, else_label) +} + +pub fn bind_func_stat(binder: &mut FlowBinder, func_stat: LuaFuncStat, current: FlowId) -> FlowId { + bind_each_child(binder, LuaAst::LuaFuncStat(func_stat), current); + current +} + +pub fn bind_local_func_stat( + binder: &mut FlowBinder, + local_func_stat: emmylua_parser::LuaLocalFuncStat, + current: FlowId, +) -> FlowId { + bind_each_child(binder, LuaAst::LuaLocalFuncStat(local_func_stat), current); + current +} + +pub fn bind_for_range_stat( + binder: &mut FlowBinder, + for_range_stat: LuaForRangeStat, + current: FlowId, +) -> FlowId { + let pre_for_range_label = binder.create_loop_label(); + let post_for_range_label = binder.create_branch_label(); + binder.add_antecedent(pre_for_range_label, current); + + for expr in for_range_stat.get_expr_list() { + bind_expr(binder, expr.clone(), current); + } + + let decl_flow = binder.create_decl(for_range_stat.get_position()); + binder.add_antecedent(decl_flow, pre_for_range_label); + + if let Some(iter_block) = for_range_stat.get_block() { + // Bind the block of code inside the for loop + bind_iter_block( + binder, + iter_block, + decl_flow, + pre_for_range_label, + post_for_range_label, + ); + } + + finish_flow_label(binder, post_for_range_label, current) +} + +pub fn bind_for_stat(binder: &mut FlowBinder, for_stat: LuaForStat, current: FlowId) -> FlowId { + let pre_for_label = binder.create_loop_label(); + let post_for_label = binder.create_branch_label(); + binder.add_antecedent(pre_for_label, current); + + for var_expr in for_stat.get_iter_expr() { + bind_expr(binder, var_expr.clone(), current); + } + + let for_node = binder.create_node(FlowNodeKind::ForIStat(for_stat.to_ptr())); + binder.add_antecedent(for_node, pre_for_label); + + if let Some(iter_block) = for_stat.get_block() { + // Bind the block of code inside the for loop + bind_iter_block(binder, iter_block, for_node, pre_for_label, post_for_label); + } + + finish_flow_label(binder, post_for_label, current) +} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs new file mode 100644 index 000000000..41ef4f378 --- /dev/null +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs @@ -0,0 +1,188 @@ +use std::collections::HashMap; + +use emmylua_parser::LuaSyntaxId; +use internment::ArcIntern; +use rowan::TextSize; +use smol_str::SmolStr; + +use crate::{ + AnalyzeError, DbIndex, FileId, FlowAntecedent, FlowId, FlowNode, FlowNodeKind, FlowTree, + LuaClosureId, LuaDeclId, +}; + +#[derive(Debug)] +pub struct FlowBinder<'a> { + pub db: &'a mut DbIndex, + pub file_id: FileId, + pub decl_bind_flow_ref: HashMap, + pub start: FlowId, + pub unreachable: FlowId, + pub loop_label: FlowId, + pub break_target_label: FlowId, + pub true_target: FlowId, + pub false_target: FlowId, + flow_nodes: Vec, + multiple_antecedents: Vec>, + labels: HashMap>, + goto_stats: Vec, + bindings: HashMap, +} + +impl<'a> FlowBinder<'a> { + pub fn new(db: &'a mut DbIndex, file_id: FileId) -> Self { + let mut binder = FlowBinder { + db, + file_id, + flow_nodes: Vec::new(), + multiple_antecedents: Vec::new(), + decl_bind_flow_ref: HashMap::new(), + labels: HashMap::new(), + start: FlowId::default(), + unreachable: FlowId::default(), + break_target_label: FlowId::default(), + bindings: HashMap::new(), + goto_stats: Vec::new(), + loop_label: FlowId::default(), + true_target: FlowId::default(), + false_target: FlowId::default(), + }; + + binder.start = binder.create_start(); + binder.unreachable = binder.create_unreachable(); + binder.break_target_label = binder.unreachable; + binder.loop_label = binder.unreachable; + binder.true_target = binder.unreachable; + binder.false_target = binder.unreachable; + + binder + } + + pub fn create_node(&mut self, kind: FlowNodeKind) -> FlowId { + let id = FlowId(self.flow_nodes.len() as u32); + let flow_node = FlowNode { + id, + kind, + antecedent: None, + }; + self.flow_nodes.push(flow_node); + id + } + + pub fn create_branch_label(&mut self) -> FlowId { + self.create_node(FlowNodeKind::BranchLabel) + } + + pub fn create_loop_label(&mut self) -> FlowId { + self.create_node(FlowNodeKind::LoopLabel) + } + + pub fn create_name_label(&mut self, name: &str, closure_id: LuaClosureId) -> FlowId { + let label_id = self.create_node(FlowNodeKind::NamedLabel(ArcIntern::from(SmolStr::new( + name, + )))); + self.labels + .entry(closure_id) + .or_default() + .insert(SmolStr::new(name), label_id); + + label_id + } + + pub fn create_start(&mut self) -> FlowId { + self.create_node(FlowNodeKind::Start) + } + + pub fn create_unreachable(&mut self) -> FlowId { + self.create_node(FlowNodeKind::Unreachable) + } + + pub fn create_break(&mut self) -> FlowId { + self.create_node(FlowNodeKind::Break) + } + + pub fn create_return(&mut self) -> FlowId { + self.create_node(FlowNodeKind::Return) + } + + pub fn create_decl(&mut self, position: TextSize) -> FlowId { + self.create_node(FlowNodeKind::DeclPosition(position)) + } + + pub fn add_antecedent(&mut self, node_id: FlowId, antecedent: FlowId) { + if antecedent == self.unreachable || node_id == self.unreachable { + // If the antecedent is the unreachable node, we don't need to add it + return; + } + + if let Some(existing) = self.flow_nodes.get_mut(node_id.0 as usize) { + match existing.antecedent { + Some(FlowAntecedent::Single(existing_id)) => { + // If the existing antecedent is a single node, convert it to multiple + if existing_id == antecedent { + return; // No change needed if it's the same antecedent + } + existing.antecedent = Some(FlowAntecedent::Multiple( + self.multiple_antecedents.len() as u32, + )); + self.multiple_antecedents + .push(vec![existing_id, antecedent]); + } + Some(FlowAntecedent::Multiple(index)) => { + // Add to multiple antecedents + if let Some(multiple) = self.multiple_antecedents.get_mut(index as usize) { + multiple.push(antecedent); + } else { + self.multiple_antecedents.push(vec![antecedent]); + } + } + _ => { + // Set new antecedent + existing.antecedent = Some(FlowAntecedent::Single(antecedent)); + } + }; + } + } + + pub fn bind_syntax_node(&mut self, syntax_id: LuaSyntaxId, flow_id: FlowId) { + self.bindings.insert(syntax_id, flow_id); + } + + pub fn get_bind_flow(&self, syntax_id: LuaSyntaxId) -> Option { + self.bindings.get(&syntax_id).copied() + } + + pub fn cache_goto_flow(&mut self, closure_id: LuaClosureId, label: &str, flow_id: FlowId) { + self.goto_stats.push(GotoCache { + closure_id, + label: SmolStr::new(label), + flow_id, + }); + } + + pub fn get_flow(&self, flow_id: FlowId) -> Option<&FlowNode> { + self.flow_nodes.get(flow_id.0 as usize) + } + + pub fn report_error(&mut self, error: AnalyzeError) { + self.db + .get_diagnostic_index_mut() + .add_diagnostic(self.file_id, error); + } + + pub fn finish(self) -> FlowTree { + FlowTree::new( + self.decl_bind_flow_ref, + self.flow_nodes, + self.multiple_antecedents, + // self.labels, + self.bindings, + ) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GotoCache { + pub closure_id: LuaClosureId, + pub label: SmolStr, + pub flow_id: FlowId, +} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/build_flow_tree.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/build_flow_tree.rs deleted file mode 100644 index df6885e42..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/build_flow_tree.rs +++ /dev/null @@ -1,438 +0,0 @@ -use std::collections::HashMap; - -use emmylua_parser::{ - LuaAst, LuaAstNode, LuaAstToken, LuaBlock, LuaBreakStat, LuaChunk, LuaComment, LuaDocTagCast, - LuaExpr, LuaGotoStat, LuaIndexExpr, LuaLabelStat, LuaLoopStat, LuaNameExpr, LuaStat, - LuaSyntaxKind, LuaTokenKind, PathTrait, -}; -use rowan::{TextRange, TextSize, WalkEvent}; -use smol_str::SmolStr; - -use crate::{ - AnalyzeError, DbIndex, DiagnosticCode, FileId, InFiled, LuaDeclId, LuaFlowId, LuaVarRefId, - LuaVarRefNode, -}; - -use super::flow_node::{BlockId, FlowNode}; - -#[derive(Debug)] -pub struct LuaFlowTreeBuilder { - current_flow_id: LuaFlowId, - flow_id_stack: Vec, - flow_nodes: HashMap, - var_flow_ref: HashMap>, - root_flow_id: LuaFlowId, -} - -#[allow(unused)] -impl LuaFlowTreeBuilder { - pub fn new(root: LuaChunk) -> LuaFlowTreeBuilder { - let current_flow_id = LuaFlowId::from_chunk(root.clone()); - let mut builder = LuaFlowTreeBuilder { - current_flow_id, - flow_id_stack: Vec::new(), - flow_nodes: HashMap::new(), - var_flow_ref: HashMap::new(), - root_flow_id: current_flow_id, - }; - - builder.flow_nodes.insert( - current_flow_id, - FlowNode::new(current_flow_id, current_flow_id.get_range(), None), - ); - builder - } - - pub fn enter_flow(&mut self, flow_id: LuaFlowId, range: TextRange) { - let parent = self.current_flow_id; - self.flow_id_stack.push(flow_id); - self.current_flow_id = flow_id; - self.flow_nodes - .insert(flow_id, FlowNode::new(flow_id, range, Some(parent))); - if let Some(parent_tree) = self.flow_nodes.get_mut(&parent) { - parent_tree.add_child(flow_id); - } - } - - pub fn pop_flow(&mut self) { - self.flow_id_stack.pop(); - self.current_flow_id = self - .flow_id_stack - .last() - .unwrap_or(&self.root_flow_id) - .clone(); - } - - pub fn add_flow_node(&mut self, ref_id: LuaVarRefId, ref_node: LuaVarRefNode) -> Option<()> { - let flow_id = self.current_flow_id; - self.var_flow_ref - .entry(ref_id.clone()) - .or_insert_with(Vec::new) - .push((ref_node.clone(), flow_id)); - - Some(()) - } - - pub fn get_flow_node(&self, flow_id: LuaFlowId) -> Option<&FlowNode> { - self.flow_nodes.get(&flow_id) - } - - pub fn get_flow_node_mut(&mut self, flow_id: LuaFlowId) -> Option<&mut FlowNode> { - self.flow_nodes.get_mut(&flow_id) - } - - pub fn get_current_flow_node(&self) -> Option<&FlowNode> { - self.flow_nodes.get(&self.current_flow_id) - } - - pub fn get_current_flow_node_mut(&mut self) -> Option<&mut FlowNode> { - self.flow_nodes.get_mut(&self.current_flow_id) - } - - pub fn get_current_flow_id(&self) -> LuaFlowId { - self.current_flow_id - } - - pub fn get_var_ref_ids(&self) -> Vec { - self.var_flow_ref.keys().cloned().collect() - } - - pub fn get_flow_id_from_position(&self, position: TextSize) -> LuaFlowId { - let mut result = self.root_flow_id; - let mut stack = vec![self.root_flow_id]; - - while let Some(flow_id) = stack.pop() { - if let Some(node) = self.flow_nodes.get(&flow_id) { - if node.get_range().contains(position) { - result = flow_id; - if node.get_children().is_empty() { - break; - } - - stack.extend(node.get_children().iter().rev().copied()); - } - } - } - - result - } - - pub fn get_var_ref_nodes( - &self, - var_ref_id: &LuaVarRefId, - ) -> Option<&Vec<(LuaVarRefNode, LuaFlowId)>> { - self.var_flow_ref.get(var_ref_id) - } -} - -pub fn build_flow_tree(db: &mut DbIndex, file_id: FileId, root: LuaChunk) -> LuaFlowTreeBuilder { - let mut flow_tree = LuaFlowTreeBuilder::new(root.clone()); - let mut goto_vecs: Vec<(LuaFlowId, LuaGotoStat)> = vec![]; - for walk_node in root.walk_descendants::() { - match walk_node { - WalkEvent::Enter(node) => match node { - LuaAst::LuaClosureExpr(closure) => { - flow_tree.enter_flow( - LuaFlowId::from_closure(closure.clone()), - closure.get_range(), - ); - } - LuaAst::LuaNameExpr(name_expr) => { - build_name_expr_flow(db, &mut flow_tree, file_id, name_expr); - } - LuaAst::LuaIndexExpr(index_expr) => { - build_index_expr_flow(db, &mut flow_tree, file_id, index_expr); - } - LuaAst::LuaDocTagCast(cast) => { - build_cast_flow(db, &mut flow_tree, file_id, cast); - } - LuaAst::LuaLabelStat(label) => { - build_label_flow(db, &mut flow_tree, file_id, label); - } - LuaAst::LuaGotoStat(goto_stat) => { - let current_flow_id = flow_tree.get_current_flow_id(); - goto_vecs.push((current_flow_id, goto_stat.clone())); - } - LuaAst::LuaBreakStat(break_stat) => { - build_break_flow(db, &mut flow_tree, file_id, break_stat); - } - _ => {} - }, - WalkEvent::Leave(node) => match node { - LuaAst::LuaClosureExpr(_) => flow_tree.pop_flow(), - _ => {} - }, - } - } - - for (flow_id, goto_stat) in goto_vecs { - build_goto_flow(db, &mut flow_tree, file_id, goto_stat, flow_id); - } - - flow_tree -} - -fn build_name_expr_flow( - db: &DbIndex, - builder: &mut LuaFlowTreeBuilder, - file_id: FileId, - name_expr: LuaNameExpr, -) -> Option<()> { - let parent = name_expr.get_parent::()?; - let mut is_assign = false; - match &parent { - LuaAst::LuaIndexExpr(index_expr) => { - let parent = index_expr.get_parent::()?; - if parent.syntax().kind() != LuaSyntaxKind::CallExpr.into() { - return None; - } - } - LuaAst::LuaCallExpr(_) | LuaAst::LuaFuncStat(_) => return None, - LuaAst::LuaAssignStat(assign_stat) => { - let eq_pos = assign_stat - .token_by_kind(LuaTokenKind::TkAssign)? - .get_position(); - let decl_id = LuaDeclId::new(file_id, name_expr.get_position()); - if db.get_decl_index().get_decl(&decl_id).is_some() { - return None; - } - - if name_expr.get_position() < eq_pos { - is_assign = true; - } - } - _ => {} - } - let mut ref_id: Option = None; - if let Some(local_refs) = db.get_reference_index().get_local_reference(&file_id) { - if let Some(decl_id) = local_refs.get_decl_id(&name_expr.get_range()) { - if let Some(decl) = db.get_decl_index().get_decl(&decl_id) { - // 处理`self`作为参数传入的特殊情况 - if decl.is_param() - && name_expr - .get_name_text() - .map_or(false, |name| name == "self") - { - ref_id = Some(LuaVarRefId::Name(SmolStr::new("self"))); - } else { - ref_id = Some(LuaVarRefId::DeclId(decl_id.clone())); - } - } else { - ref_id = Some(LuaVarRefId::DeclId(decl_id.clone())); - } - } - } - - if ref_id.is_none() { - ref_id = Some(LuaVarRefId::Name(SmolStr::new(&name_expr.get_name_text()?))); - } - - let ref_id = ref_id?; - if is_assign { - builder.add_flow_node(ref_id, LuaVarRefNode::AssignRef(name_expr.into())); - } else { - builder.add_flow_node(ref_id, LuaVarRefNode::UseRef(name_expr.into())); - } - - Some(()) -} - -fn build_index_expr_flow( - db: &DbIndex, - builder: &mut LuaFlowTreeBuilder, - file_id: FileId, - index_expr: LuaIndexExpr, -) -> Option<()> { - let parent = index_expr.get_parent::()?; - let mut is_assign = false; - match parent { - LuaAst::LuaIndexExpr(index_expr) => { - let parent = index_expr.get_parent::()?; - if parent.syntax().kind() != LuaSyntaxKind::CallExpr.into() { - return None; - } - } - LuaAst::LuaCallExpr(_) | LuaAst::LuaFuncStat(_) => return None, - LuaAst::LuaAssignStat(assign_stat) => { - let eq_pos = assign_stat - .token_by_kind(LuaTokenKind::TkAssign)? - .get_position(); - - let decl_id = LuaDeclId::new(file_id, index_expr.get_position()); - if db.get_decl_index().get_decl(&decl_id).is_some() { - return None; - } - - if index_expr.get_position() < eq_pos { - is_assign = true; - } - } - _ => {} - } - - let ref_id = LuaVarRefId::Name(SmolStr::new(&index_expr.get_access_path()?)); - if is_assign { - builder.add_flow_node(ref_id, LuaVarRefNode::AssignRef(index_expr.into())); - } else { - builder.add_flow_node(ref_id, LuaVarRefNode::UseRef(index_expr.into())); - } - - Some(()) -} - -fn build_cast_flow( - db: &DbIndex, - builder: &mut LuaFlowTreeBuilder, - file_id: FileId, - tag_cast: LuaDocTagCast, -) -> Option<()> { - match tag_cast.get_key_expr() { - Some(target_expr) => { - let text = match &target_expr { - LuaExpr::NameExpr(name_expr) => name_expr.get_name_text()?, - LuaExpr::IndexExpr(index_expr) => index_expr.get_access_path()?, - _ => { - return None; - } - }; - - let decl_tree = db.get_decl_index().get_decl_tree(&file_id)?; - if let Some(decl) = decl_tree.find_local_decl(&text, target_expr.get_position()) { - let decl_id = decl.get_id(); - builder.add_flow_node( - LuaVarRefId::DeclId(decl_id), - LuaVarRefNode::CastRef(tag_cast.clone()), - ); - } else { - let ref_id = LuaVarRefId::Name(SmolStr::new(text)); - if db - .get_decl_index() - .get_decl(&LuaDeclId::new(file_id, target_expr.get_position())) - .is_none() - { - builder.add_flow_node(ref_id, LuaVarRefNode::CastRef(tag_cast.clone())); - } - } - } - None => { - // 没有指定名称, 则附加到最近的表达式上 - let comment = tag_cast.get_parent::()?; - let mut left_token = comment.syntax().first_token()?.prev_token()?; - if left_token.kind() == LuaTokenKind::TkWhitespace.into() { - left_token = left_token.prev_token()?; - } - - let mut ast_node = left_token.parent()?; - loop { - if LuaExpr::can_cast(ast_node.kind().into()) { - break; - } else if LuaBlock::can_cast(ast_node.kind().into()) { - return None; - } - ast_node = ast_node.parent()?; - } - let expr = LuaExpr::cast(ast_node)?; - let in_filed_syntax_id = InFiled::new(file_id, expr.get_syntax_id()); - builder.add_flow_node( - LuaVarRefId::SyntaxId(in_filed_syntax_id), - LuaVarRefNode::CastRef(tag_cast.clone()), - ); - } - } - Some(()) -} - -fn build_label_flow( - db: &mut DbIndex, - builder: &mut LuaFlowTreeBuilder, - file_id: FileId, - label: LuaLabelStat, -) -> Option<()> { - let decl_id = LuaDeclId::new(file_id, label.get_position()); - if db.get_decl_index().get_decl(&decl_id).is_some() { - return None; - } - - let flow_tree = builder.get_current_flow_node_mut()?; - let label_token = label.get_label_name_token()?; - let label_name = label_token.get_name_text(); - let block = label.get_parent::()?; - let block_id = BlockId::from_block(block); - if flow_tree.is_exist_label_in_same_block(label_name, block_id) { - db.get_diagnostic_index_mut().add_diagnostic( - file_id, - AnalyzeError::new( - DiagnosticCode::SyntaxError, - &t!( - "Label `%{name}` already exists in the same block", - name = label_name - ), - label.get_range(), - ), - ); - return None; - } - - flow_tree.add_label_ref(label_name, label); - Some(()) -} - -fn build_goto_flow( - db: &mut DbIndex, - builder: &mut LuaFlowTreeBuilder, - file_id: FileId, - goto_stat: LuaGotoStat, - flow_id: LuaFlowId, -) -> Option<()> { - let flow_node = builder.get_flow_node_mut(flow_id)?; - let label_token = goto_stat.get_label_name_token()?; - let label_name = label_token.get_name_text(); - let label = flow_node.find_label(label_name, goto_stat.clone()); - if label.is_none() { - db.get_diagnostic_index_mut().add_diagnostic( - file_id, - AnalyzeError::new( - DiagnosticCode::SyntaxError, - &t!("Label `%{name}` not found", name = label_name), - label_token.get_range(), - ), - ); - } - - let label = label?; - - flow_node.add_jump_to_stat( - goto_stat.get_syntax_id(), - LuaStat::cast(label.syntax().clone())?, - ); - - Some(()) -} - -fn build_break_flow( - db: &mut DbIndex, - builder: &mut LuaFlowTreeBuilder, - file_id: FileId, - break_stat: LuaBreakStat, -) -> Option<()> { - let flow_tree = builder.get_current_flow_node_mut()?; - let first_loop_stat = break_stat.ancestors::().next(); - if first_loop_stat.is_none() { - db.get_diagnostic_index_mut().add_diagnostic( - file_id, - AnalyzeError::new( - DiagnosticCode::SyntaxError, - &t!("`break` statement not in a loop"), - break_stat.get_range(), - ), - ); - return None; - } - let loop_stat = first_loop_stat?; - flow_tree.add_jump_to_stat( - break_stat.get_syntax_id(), - LuaStat::cast(loop_stat.syntax().clone())?, - ); - - Some(()) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/cast_analyze.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/cast_analyze.rs deleted file mode 100644 index 7c1ac0147..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/cast_analyze.rs +++ /dev/null @@ -1,75 +0,0 @@ -use emmylua_parser::{BinaryOperator, LuaAstNode, LuaBlock, LuaDocTagCast}; -use rowan::TextRange; - -use crate::{compilation::analyzer::AnalyzeContext, FileId, InFiled, LuaType, TypeAssertion}; - -use super::var_analyze::VarTrace; - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum CastAction { - Force, - Add, - Remove, -} - -pub fn analyze_cast( - var_trace: &mut VarTrace, - file_id: FileId, - tag: LuaDocTagCast, - context: &AnalyzeContext, -) -> Option<()> { - let block_range = tag.ancestors::().next()?.get_range(); - let cast_range = tag.get_range(); - - let cast_end = cast_range.end(); - let block_end = block_range.end(); - - if block_end <= cast_end { - return Some(()); - } - let effect_range = TextRange::new(cast_end, block_end); - for cast_op_type in 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 => { - var_trace.add_assert(TypeAssertion::Add(LuaType::Nil), effect_range); - } - CastAction::Remove => { - var_trace.add_assert(TypeAssertion::Remove(LuaType::Nil), effect_range); - } - _ => {} - } - } else if let Some(doc_typ) = cast_op_type.get_type() { - let key = InFiled::new(file_id, doc_typ.get_syntax_id()); - let typ = match context.cast_flow.get(&key) { - Some(t) => t.clone(), - None => continue, - }; - - match action { - CastAction::Add => { - var_trace.add_assert(TypeAssertion::Add(typ), effect_range); - } - CastAction::Remove => { - var_trace.add_assert(TypeAssertion::Remove(typ), effect_range); - } - CastAction::Force => { - var_trace.add_assert(TypeAssertion::Force(typ), effect_range); - } - } - } - } - - Some(()) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/flow_node.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/flow_node.rs deleted file mode 100644 index ea97fed34..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/flow_node.rs +++ /dev/null @@ -1,119 +0,0 @@ -use std::collections::HashMap; - -use emmylua_parser::{ - LuaAst, LuaAstNode, LuaBlock, LuaGotoStat, LuaLabelStat, LuaStat, LuaSyntaxId, -}; -use rowan::{TextRange, TextSize}; -use smol_str::SmolStr; - -use crate::LuaFlowId; - -#[derive(Debug)] -pub struct FlowNode { - flow_id: LuaFlowId, - parent_id: Option, - label_ref: HashMap>, - jump_to_stat_end: HashMap, - children: Vec, - range: TextRange, -} - -#[allow(unused)] -impl FlowNode { - pub fn new(flow_id: LuaFlowId, range: TextRange, parent_id: Option) -> FlowNode { - FlowNode { - flow_id, - parent_id, - children: Vec::new(), - label_ref: HashMap::new(), - jump_to_stat_end: HashMap::new(), - range, - } - } - - pub fn get_range(&self) -> TextRange { - self.range - } - - pub fn get_flow_id(&self) -> LuaFlowId { - self.flow_id - } - - pub fn get_parent_id(&self) -> Option { - self.parent_id - } - - pub fn get_children(&self) -> &Vec { - &self.children - } - - pub fn add_child(&mut self, child: LuaFlowId) { - self.children.push(child); - } - - pub fn add_label_ref(&mut self, name: &str, label: LuaLabelStat) -> Option<()> { - let block = label.get_parent::()?; - let block_id = BlockId::from_block(block); - let name = SmolStr::new(name); - - self.label_ref - .entry(block_id) - .or_insert_with(Vec::new) - .push((name, label)); - - Some(()) - } - - pub fn is_exist_label_in_same_block(&self, name: &str, block_id: BlockId) -> bool { - let name = SmolStr::new(name); - self.label_ref - .get(&block_id) - .map_or(false, |labels| labels.iter().any(|(n, _)| n == &name)) - } - - pub fn find_label(&self, name: &str, goto: LuaGotoStat) -> Option<&LuaLabelStat> { - let name = SmolStr::new(name); - for block in goto.ancestors::() { - let block_id = BlockId::from_block(block); - if block_id.0 < self.flow_id.get_position() { - break; - } - - if let Some(labels) = self.label_ref.get(&block_id) { - for (label_name, label) in labels { - if label_name == &name { - return Some(label); - } - } - } - } - - None - } - - pub fn add_jump_to_stat(&mut self, jump_syntax_id: LuaSyntaxId, stat: LuaStat) { - self.jump_to_stat_end.insert(jump_syntax_id, stat); - } - - pub fn get_jump_to_stat(&self, jump_syntax_id: LuaSyntaxId) -> Option { - self.jump_to_stat_end.get(&jump_syntax_id).cloned() - } -} - -#[derive(Debug, Eq, PartialEq, Clone, Hash)] -pub struct BlockId(TextSize); - -impl BlockId { - pub fn from_block(block: LuaBlock) -> BlockId { - BlockId(block.get_position()) - } - - pub fn from_ast(ast: LuaAst) -> Option { - if LuaBlock::can_cast(ast.syntax().kind().into()) { - Some(BlockId(ast.get_position())) - } else { - let block = ast.ancestors::().next()?; - Some(BlockId(block.get_position())) - } - } -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/mod.rs index 384d5ed87..8ccadefa9 100644 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/mod.rs +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/mod.rs @@ -1,21 +1,10 @@ -mod build_flow_tree; -mod cast_analyze; -mod flow_node; -mod var_analyze; - -use std::collections::HashMap; +mod bind_analyze; +mod binder; use crate::{ - db_index::DbIndex, profile::Profile, FileId, LuaVarRefId, LuaVarRefNode, TypeAssertion, -}; -use build_flow_tree::{build_flow_tree, LuaFlowTreeBuilder}; -use cast_analyze::analyze_cast; -pub use cast_analyze::CastAction; -use emmylua_parser::{BinaryOperator, LuaAst, LuaAstNode, LuaBinaryExpr, LuaBlock}; -use flow_node::BlockId; -use rowan::TextRange; -use var_analyze::{ - analyze_ref_assign, analyze_ref_expr, broadcast_up, UnResolveTraceId, VarTrace, VarTraceInfo, + compilation::analyzer::flow::{bind_analyze::bind_analyze, binder::FlowBinder}, + db_index::DbIndex, + profile::Profile, }; use super::AnalyzeContext; @@ -25,124 +14,11 @@ pub(crate) fn analyze(db: &mut DbIndex, context: &mut AnalyzeContext) { let tree_list = context.tree_list.clone(); // build decl and ref flow chain for in_filed_tree in &tree_list { - let flow_tree = build_flow_tree(db, in_filed_tree.file_id, in_filed_tree.value.clone()); - analyze_flow(db, in_filed_tree.file_id, flow_tree, context); - } -} - -fn analyze_flow( - db: &mut DbIndex, - file_id: FileId, - flow_tree: LuaFlowTreeBuilder, - context: &mut AnalyzeContext, -) { - let var_ref_ids = flow_tree.get_var_ref_ids(); - let mut var_trace_map: HashMap = HashMap::new(); - for var_ref_id in var_ref_ids { - let var_ref_nodes = match flow_tree.get_var_ref_nodes(&var_ref_id) { - Some(nodes) => nodes, - None => continue, - }; - - let mut var_trace = var_trace_map.entry(var_ref_id.clone()).or_insert_with(|| { - VarTrace::new(var_ref_id.clone(), var_ref_nodes.clone(), &flow_tree) - }); - for (var_ref_node, flow_id) in var_ref_nodes { - var_trace.set_current_flow_id(*flow_id); - match var_ref_node { - LuaVarRefNode::UseRef(var_expr) => { - analyze_ref_expr(db, &mut var_trace, &var_expr); - } - LuaVarRefNode::AssignRef(var_expr) => { - analyze_ref_assign(db, &mut var_trace, &var_expr, file_id); - } - LuaVarRefNode::CastRef(tag_cast) => { - analyze_cast(&mut var_trace, file_id, tag_cast.clone(), context); - } - } - } - let last_flow_id = var_trace.get_current_flow_id(); - let mut guard_count = 0; - while var_trace.has_unresolve_traces() { - resolve_flow_analyze(db, &mut var_trace); - guard_count += 1; - if guard_count > 10 { - break; - } - } - if let Some(last_flow_id) = last_flow_id { - var_trace.set_current_flow_id(last_flow_id); - } - } - - for (_, var_trace) in var_trace_map { - db.get_flow_index_mut() - .add_flow_chain(file_id, var_trace.finish()); + let chunk = in_filed_tree.value.clone(); + let file_id = in_filed_tree.file_id; + let mut binder = FlowBinder::new(db, file_id); + bind_analyze(&mut binder, chunk); + let flow_tree = binder.finish(); + db.get_flow_index_mut().add_flow_tree(file_id, flow_tree); } } - -fn resolve_flow_analyze(db: &mut DbIndex, var_trace: &mut VarTrace) -> Option<()> { - let all_trace = var_trace.pop_all_unresolve_traces(); - for (trace_id, uresolve_trace_info) in all_trace { - var_trace.set_current_flow_id(uresolve_trace_info.0); - match trace_id { - UnResolveTraceId::Expr(expr) => { - let binary_expr = expr.get_parent::()?; - let op = binary_expr.get_op_token()?.get_op(); - let trace_info = uresolve_trace_info.1.get_trace_info()?; - if op == BinaryOperator::OpAnd || op == BinaryOperator::OpOr { - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - trace_info.type_assertion.clone(), - LuaAst::cast(binary_expr.syntax().clone())?, - ) - .into(), - binary_expr.get_parent::()?, - ); - } - } - UnResolveTraceId::If(if_stat) => { - let var_trace_infos = uresolve_trace_info.1.get_trace_infos()?; - let mut trace_map = HashMap::new(); - for trace_info in var_trace_infos { - let block_id = BlockId::from_ast(trace_info.node.clone())?; - trace_map - .entry(block_id) - .or_insert_with(Vec::new) - .push(trace_info); - } - - let mut or_asserts = Vec::new(); - for (_, mut trace_infos) in trace_map { - match trace_infos.len() { - 0 => {} - 1 => { - or_asserts.push(trace_infos[0].type_assertion.clone()); - } - _ => { - trace_infos - .sort_by(|a, b| a.node.get_position().cmp(&b.node.get_position())); - let and_asserts = trace_infos - .iter() - .map(|x| x.type_assertion.clone()) - .collect::>(); - or_asserts.push(TypeAssertion::And(and_asserts.into())); - } - } - } - - let block = if_stat.get_parent::()?; - let block_end = block.get_range().end(); - let if_end = if_stat.get_range().end(); - if if_end < block_end { - let range = TextRange::new(if_end, block_end); - var_trace.add_assert(TypeAssertion::Or(or_asserts.into()), range); - } - } - } - } - - Some(()) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_down.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_down.rs deleted file mode 100644 index eda5a5115..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_down.rs +++ /dev/null @@ -1,62 +0,0 @@ -use std::sync::Arc; - -use emmylua_parser::{LuaAst, LuaAstNode, LuaBlock, LuaStat}; -use rowan::TextRange; - -use crate::DbIndex; - -use super::{broadcast_outside::broadcast_outside_block, var_trace_info::VarTraceInfo, VarTrace}; - -pub fn broadcast_down_after_node( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - node: LuaAst, - continue_broadcast_outside: bool, -) -> Option<()> { - let parent_block = node.get_parent::()?; - let parent_block_range = parent_block.get_range(); - let range = node.get_range(); - if range.end() < parent_block_range.end() { - let range = TextRange::new(range.end(), parent_block_range.end()); - var_trace.add_assert(trace_info.type_assertion.clone(), range); - } - - if is_block_has_return(Some(parent_block.clone())).unwrap_or(false) { - return Some(()); - } - - if continue_broadcast_outside { - broadcast_outside_block(db, var_trace, trace_info, parent_block); - } - - Some(()) -} - -fn is_block_has_return(block: Option) -> Option { - if let Some(block) = block { - for stat in block.get_stats() { - if is_stat_change_flow(stat.clone()).unwrap_or(false) { - return Some(true); - } - } - } - - Some(false) -} - -fn is_stat_change_flow(stat: LuaStat) -> Option { - match stat { - LuaStat::CallExprStat(call_stat) => { - let call_expr = call_stat.get_call_expr()?; - if call_expr.is_error() { - return Some(true); - } - Some(false) - } - LuaStat::ReturnStat(_) => Some(true), - LuaStat::DoStat(do_stat) => Some(is_block_has_return(do_stat.get_block()).unwrap_or(false)), - LuaStat::BreakStat(_) => Some(true), - _ => Some(false), - } -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_inside.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_inside.rs deleted file mode 100644 index 0ea57bb09..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_inside.rs +++ /dev/null @@ -1,65 +0,0 @@ -use std::sync::Arc; - -use emmylua_parser::{LuaAstNode, LuaBlock, LuaStat}; - -use crate::DbIndex; - -use super::{broadcast_outside::broadcast_outside_block, var_trace_info::VarTraceInfo, VarTrace}; - -pub fn broadcast_inside_condition_block( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - block: LuaBlock, - check_broadcast_outside: bool, -) -> Option<()> { - var_trace.add_assert(trace_info.type_assertion.clone(), block.get_range()); - if check_broadcast_outside { - if !trace_info.check_cover_all_branch() { - return Some(()); - } - - analyze_block_inside_condition(db, var_trace, trace_info, block.clone(), block); - } - - Some(()) -} - -fn analyze_block_inside_condition( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - block: LuaBlock, - origin_block: LuaBlock, -) -> Option<()> { - for stat in block.get_stats() { - match stat { - LuaStat::CallExprStat(call_stat) => { - let call_expr = call_stat.get_call_expr()?; - if call_expr.is_error() { - let ne_type_assert = trace_info.type_assertion.get_negation()?; - let ne_trace_info = trace_info.with_type_assertion(ne_type_assert); - broadcast_outside_block(db, var_trace, ne_trace_info, origin_block.clone()); - return Some(()); - } - } - LuaStat::ReturnStat(_) | LuaStat::BreakStat(_) => { - let ne_type_assert = trace_info.type_assertion.get_negation()?; - let ne_trace_info = trace_info.with_type_assertion(ne_type_assert); - broadcast_outside_block(db, var_trace, ne_trace_info, origin_block.clone()); - return Some(()); - } - LuaStat::DoStat(do_stat) => { - analyze_block_inside_condition( - db, - var_trace, - trace_info.clone(), - do_stat.get_block()?, - origin_block.clone(), - ); - } - _ => {} - } - } - Some(()) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_outside.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_outside.rs deleted file mode 100644 index d1b7d8eb2..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_outside.rs +++ /dev/null @@ -1,31 +0,0 @@ -use std::sync::Arc; - -use emmylua_parser::{LuaAst, LuaAstNode, LuaBlock, LuaIfStat}; - -use crate::DbIndex; - -use super::{unresolve_trace::UnResolveTraceId, VarTrace, VarTraceInfo}; - -pub fn broadcast_outside_block( - _: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - block: LuaBlock, -) -> Option<()> { - let parent = block.get_parent::()?; - match &parent { - LuaAst::LuaIfStat(if_stat) => { - let trace_id = UnResolveTraceId::If(if_stat.clone()); - var_trace.add_unresolve_trace(trace_id, trace_info); - } - LuaAst::LuaElseIfClauseStat(_) | LuaAst::LuaElseClauseStat(_) => { - if let Some(if_stat) = parent.get_parent::() { - let trace_id = UnResolveTraceId::If(if_stat.clone()); - var_trace.add_unresolve_trace(trace_id, trace_info); - } - } - _ => {} - } - - Some(()) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_up.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_up.rs deleted file mode 100644 index 328f579d5..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/broadcast_up.rs +++ /dev/null @@ -1,436 +0,0 @@ -use std::sync::Arc; - -use emmylua_parser::{ - BinaryOperator, LuaAst, LuaAstNode, LuaBinaryExpr, LuaCallArgList, LuaCallExpr, - LuaCallExprStat, LuaExpr, LuaLiteralToken, UnaryOperator, -}; -use smol_str::SmolStr; - -use crate::{DbIndex, LuaType, TypeAssertion}; - -use super::{ - broadcast_down::broadcast_down_after_node, broadcast_inside::broadcast_inside_condition_block, - unresolve_trace::UnResolveTraceId, var_trace_info::VarTraceInfo, VarTrace, -}; - -pub fn broadcast_up( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - current: LuaAst, -) -> Option<()> { - match current { - LuaAst::LuaIfStat(if_stat) => { - if let Some(block) = if_stat.get_block() { - broadcast_inside_condition_block(db, var_trace, trace_info.clone(), block, true); - } - - // todo - if !trace_info.check_cover_all_branch() { - return Some(()); - } - - if let Some(ne_type_assert) = trace_info.type_assertion.get_negation() { - if let Some(else_stat) = if_stat.get_else_clause() { - broadcast_inside_condition_block( - db, - var_trace, - trace_info.with_type_assertion(ne_type_assert.clone()), - else_stat.get_block()?, - true, - ); - } - - for else_if_clause in if_stat.get_else_if_clause_list() { - let range = else_if_clause.get_range(); - var_trace.add_assert(ne_type_assert.clone(), range); - } - } - } - LuaAst::LuaWhileStat(while_stat) => { - // this mean the name_expr is a condition and the name_expr is not nil and is not false - let block = while_stat.get_block()?; - broadcast_inside_condition_block(db, var_trace, trace_info, block, false); - } - LuaAst::LuaElseIfClauseStat(else_if_clause_stat) => { - // this mean the name_expr is a condition and the name_expr is not nil and is not false - if let Some(block) = else_if_clause_stat.get_block() { - broadcast_inside_condition_block(db, var_trace, trace_info, block, false); - } - } - LuaAst::LuaParenExpr(paren_expr) => { - broadcast_up( - db, - var_trace, - trace_info, - paren_expr.get_parent::()?, - ); - } - LuaAst::LuaBinaryExpr(binary_expr) => { - let op = binary_expr.get_op_token()?; - match op.get_op() { - BinaryOperator::OpAnd => { - broadcast_up_and(db, var_trace, trace_info, binary_expr.clone()); - } - BinaryOperator::OpOr => { - broadcast_up_or(db, var_trace, trace_info, binary_expr.clone()); - } - BinaryOperator::OpEq => { - if !trace_info.type_assertion.is_exist() { - return None; - } - - let (left, right) = binary_expr.get_exprs()?; - let expr = if left.get_position() == trace_info.node.get_position() { - right - } else { - left - }; - - if let LuaExpr::LiteralExpr(literal) = expr { - let type_assert = match literal.get_literal()? { - LuaLiteralToken::Nil(_) => TypeAssertion::Force(LuaType::Nil), - LuaLiteralToken::Bool(b) => { - if b.is_true() { - TypeAssertion::Force(LuaType::BooleanConst(true)) - } else { - TypeAssertion::Force(LuaType::BooleanConst(false)) - } - } - LuaLiteralToken::Number(i) => { - if i.is_int() { - TypeAssertion::Force(LuaType::IntegerConst(i.get_int_value())) - } else { - TypeAssertion::Force(LuaType::Number) - } - } - LuaLiteralToken::String(s) => TypeAssertion::Force( - LuaType::StringConst(SmolStr::new(s.get_value()).into()), - ), - _ => return None, - }; - - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - type_assert, - LuaAst::cast(binary_expr.syntax().clone())?, - ) - .into(), - binary_expr.get_parent::()?, - ); - } - } - BinaryOperator::OpNe => { - if !trace_info.type_assertion.is_exist() { - return None; - } - - let (left, right) = binary_expr.get_exprs()?; - let expr = if left.get_position() == trace_info.node.get_position() { - right - } else { - left - }; - - if let LuaExpr::LiteralExpr(literal) = expr { - let type_assert = match literal.get_literal()? { - LuaLiteralToken::Nil(_) => TypeAssertion::Remove(LuaType::Nil), - LuaLiteralToken::Bool(b) => { - if b.is_true() { - TypeAssertion::Remove(LuaType::BooleanConst(true)) - } else { - TypeAssertion::Remove(LuaType::BooleanConst(false)) - } - } - LuaLiteralToken::Number(i) => { - if i.is_int() { - TypeAssertion::Remove(LuaType::IntegerConst(i.get_int_value())) - } else { - TypeAssertion::Remove(LuaType::Number) - } - } - LuaLiteralToken::String(s) => TypeAssertion::Remove( - LuaType::StringConst(SmolStr::new(s.get_value()).into()), - ), - _ => return None, - }; - - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - type_assert, - LuaAst::cast(binary_expr.syntax().clone())?, - ) - .into(), - binary_expr.get_parent::()?, - ); - } - } - - _ => {} - } - } - LuaAst::LuaCallArgList(call_args_list) => { - broadcast_up_call_arg_list(db, var_trace, trace_info, call_args_list)?; - } - // self:IsXXX() - LuaAst::LuaIndexExpr(index_expr) => { - if !trace_info.type_assertion.is_exist() { - return None; - } - - let call_expr = index_expr.get_parent::()?; - let param_idx = -1; - - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - TypeAssertion::Call { - id: call_expr.get_syntax_id(), - param_idx, - }, - LuaAst::cast(call_expr.syntax().clone())?, - ) - .into(), - call_expr.get_parent::()?, - ); - } - LuaAst::LuaUnaryExpr(unary_expr) => { - let op = unary_expr.get_op_token()?; - match op.get_op() { - UnaryOperator::OpNot => { - if let Some(ne_type_assert) = trace_info.type_assertion.get_negation() { - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - ne_type_assert, - LuaAst::cast(unary_expr.syntax().clone())?, - ) - .into(), - unary_expr.get_parent::()?, - ); - } - } - _ => {} - } - } - _ => {} - } - Some(()) -} - -pub fn broadcast_up_and( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - binary_expr: LuaBinaryExpr, -) -> Option<()> { - let (left, right) = binary_expr.get_exprs()?; - if left.get_range().contains(trace_info.node.get_position()) { - var_trace.add_assert(trace_info.type_assertion.clone(), right.get_range()); - - if var_trace.check_var_use_in_range(right.get_range()) { - let trace_id = UnResolveTraceId::Expr(LuaExpr::cast(trace_info.node.syntax().clone())?); - var_trace.add_unresolve_trace(trace_id, trace_info); - return Some(()); - } - } else { - // disable b broadcast_up in `a and or c`` - if let Some(parent_binary) = binary_expr.get_parent::() { - let op = parent_binary.get_op_token()?; - match op.get_op() { - BinaryOperator::OpOr => { - return None; - } - _ => {} - } - } - - let left_id = UnResolveTraceId::Expr(left); - if let Some(left_unresolve_trace_info) = var_trace.pop_unresolve_trace(&left_id) { - let left_trace_info = left_unresolve_trace_info.1.get_trace_info()?; - let new_assert = left_trace_info - .type_assertion - .and_assert(trace_info.type_assertion.clone()); - - broadcast_up( - db, - var_trace, - VarTraceInfo::new(new_assert, LuaAst::cast(binary_expr.syntax().clone())?).into(), - binary_expr.get_parent::()?, - ); - - return Some(()); - } - } - - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - trace_info.type_assertion.clone(), - LuaAst::cast(binary_expr.syntax().clone())?, - ) - .into(), - binary_expr.get_parent::()?, - ); - - Some(()) -} - -pub fn broadcast_up_or( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - binary_expr: LuaBinaryExpr, -) -> Option<()> { - let (left, right) = binary_expr.get_exprs()?; - if left.get_range().contains(trace_info.node.get_position()) { - if let Some(ne) = trace_info.type_assertion.get_negation() { - var_trace.add_assert(ne, right.get_range()); - } - - if var_trace.check_var_use_in_range(right.get_range()) { - let trace_id = UnResolveTraceId::Expr(LuaExpr::cast(trace_info.node.syntax().clone())?); - var_trace.add_unresolve_trace(trace_id, trace_info); - return Some(()); - } - } else { - let left_id = UnResolveTraceId::Expr(left); - if let Some(left_unresolve_trace_info) = var_trace.pop_unresolve_trace(&left_id) { - let left_trace_info = left_unresolve_trace_info.1.get_trace_info()?; - let new_assert = left_trace_info - .type_assertion - .or_assert(trace_info.type_assertion.clone()); - broadcast_up( - db, - var_trace, - VarTraceInfo::new(new_assert, LuaAst::cast(binary_expr.syntax().clone())?).into(), - binary_expr.get_parent::()?, - ); - - return Some(()); - } - } - - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - trace_info.type_assertion.clone(), - LuaAst::cast(binary_expr.syntax().clone())?, - ) - .into(), - binary_expr.get_parent::()?, - ); - - Some(()) -} - -fn broadcast_up_call_arg_list( - db: &mut DbIndex, - var_trace: &mut VarTrace, - trace_info: Arc, - call_arg: LuaCallArgList, -) -> Option<()> { - let parent = call_arg.get_parent::()?; - match parent { - LuaAst::LuaCallExpr(call_expr) => { - if call_expr.is_type() && trace_info.type_assertion.is_exist() { - broadcast_up_type_assert(db, var_trace, call_expr); - } else if call_expr.is_assert() { - broadcast_down_after_node( - db, - var_trace, - trace_info, - LuaAst::LuaCallExprStat(call_expr.get_parent::()?), - true, - ); - } else if trace_info.type_assertion.is_exist() { - let current_pos = trace_info.node.get_position(); - let param_idx = call_arg - .get_args() - .position(|it| it.get_position() == current_pos)? - as i32; - - broadcast_up( - db, - var_trace, - VarTraceInfo::new( - TypeAssertion::Call { - id: call_expr.get_syntax_id(), - param_idx, - }, - LuaAst::cast(call_expr.syntax().clone())?, - ) - .into(), - call_expr.get_parent::()?, - ); - } - } - _ => {} - } - - Some(()) -} - -fn broadcast_up_type_assert( - db: &mut DbIndex, - var_trace: &mut VarTrace, - call_expr: LuaCallExpr, -) -> Option<()> { - let binary_expr = call_expr.get_parent::()?; - let op = binary_expr.get_op_token()?; - let mut is_eq = true; - match op.get_op() { - BinaryOperator::OpEq => {} - BinaryOperator::OpNe => { - is_eq = false; - } - _ => return None, - }; - - let operands = binary_expr.get_exprs()?; - let literal_expr = if let LuaExpr::LiteralExpr(literal) = operands.0 { - literal - } else if let LuaExpr::LiteralExpr(literal) = operands.1 { - literal - } else { - return None; - }; - - let type_literal = match literal_expr.get_literal()? { - LuaLiteralToken::String(string) => string.get_value(), - _ => return None, - }; - - let mut type_assert = match type_literal.as_str() { - "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, - }; - - if !is_eq { - type_assert = type_assert.get_negation()?; - } - - broadcast_up( - db, - var_trace, - VarTraceInfo::new(type_assert, LuaAst::cast(binary_expr.syntax().clone())?).into(), - binary_expr.get_parent::()?, - ); - - Some(()) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/mod.rs deleted file mode 100644 index fbd58c54c..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/mod.rs +++ /dev/null @@ -1,122 +0,0 @@ -mod broadcast_down; -mod broadcast_inside; -mod broadcast_outside; -mod broadcast_up; -mod unresolve_trace; -mod var_trace; -mod var_trace_info; - -use std::sync::Arc; - -use broadcast_down::broadcast_down_after_node; -pub use broadcast_up::broadcast_up; -use emmylua_parser::{LuaAssignStat, LuaAst, LuaAstNode, LuaCommentOwner, LuaDocTag, LuaVarExpr}; - -use crate::{db_index::TypeAssertion, DbIndex, FileId, LuaDeclId, LuaMemberId, LuaTypeOwner}; -#[allow(unused)] -pub use unresolve_trace::{UnResolveTraceId, UnResolveTraceInfo}; -pub use var_trace::VarTrace; -pub use var_trace_info::VarTraceInfo; - -pub fn analyze_ref_expr( - db: &mut DbIndex, - var_trace: &mut VarTrace, - var_expr: &LuaVarExpr, -) -> Option<()> { - let parent = var_expr.get_parent::()?; - let trace_info = Arc::new(VarTraceInfo::new( - TypeAssertion::Exist, - LuaAst::cast(var_expr.syntax().clone())?, - )); - broadcast_up(db, var_trace, trace_info, parent); - - Some(()) -} - -pub fn analyze_ref_assign( - db: &mut DbIndex, - var_trace: &mut VarTrace, - var_expr: &LuaVarExpr, - file_id: FileId, -) -> Option<()> { - let assign_stat = var_expr.get_parent::()?; - if is_decl_assign_stat(assign_stat.clone()).unwrap_or(false) { - let type_owner = match var_expr { - LuaVarExpr::IndexExpr(index_expr) => { - let member_id = LuaMemberId::new(index_expr.get_syntax_id(), file_id); - LuaTypeOwner::Member(member_id) - } - LuaVarExpr::NameExpr(name_expr) => { - let decl_id = LuaDeclId::new(file_id, name_expr.get_position()); - LuaTypeOwner::Decl(decl_id) - } - }; - if let Some(type_cache) = db.get_type_index().get_type_cache(&type_owner) { - let type_assert = TypeAssertion::Narrow(type_cache.as_type().clone()); - broadcast_down_after_node( - db, - var_trace, - Arc::new(VarTraceInfo::new( - type_assert, - LuaAst::cast(var_expr.syntax().clone())?, - )), - LuaAst::LuaAssignStat(assign_stat), - true, - ); - } - - return None; - } - - let (var_exprs, value_exprs) = assign_stat.get_var_and_expr_list(); - let var_index = var_exprs - .iter() - .position(|it| it.get_position() == var_expr.get_position())?; - - if value_exprs.len() == 0 { - return None; - } - - let (value_expr, idx) = if let Some(expr) = value_exprs.get(var_index) { - (expr.clone(), 0) - } else { - ( - value_exprs.last()?.clone(), - (var_index - (value_exprs.len() - 1)) as i32, - ) - }; - - let type_assert = TypeAssertion::Reassign { - id: value_expr.get_syntax_id(), - idx, - }; - broadcast_down_after_node( - db, - var_trace, - Arc::new(VarTraceInfo::new( - type_assert, - LuaAst::cast(value_expr.syntax().clone())?, - )), - LuaAst::LuaAssignStat(assign_stat), - true, - ); - - Some(()) -} - -fn is_decl_assign_stat(assign_stat: LuaAssignStat) -> Option { - for comment in assign_stat.get_comments() { - for tag in comment.get_doc_tags() { - match tag { - LuaDocTag::Type(_) - | LuaDocTag::Class(_) - | LuaDocTag::Module(_) - | LuaDocTag::Enum(_) => { - return Some(true); - } - _ => {} - } - } - } - Some(false) -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/unresolve_trace.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/unresolve_trace.rs deleted file mode 100644 index e238c62e3..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/unresolve_trace.rs +++ /dev/null @@ -1,48 +0,0 @@ -use std::sync::Arc; - -use emmylua_parser::{LuaExpr, LuaIfStat}; - -use super::var_trace_info::VarTraceInfo; - -#[derive(Debug, Hash, Clone, PartialEq, Eq)] -pub enum UnResolveTraceId { - Expr(LuaExpr), - If(LuaIfStat), -} - -#[derive(Debug, Clone)] -pub enum UnResolveTraceInfo { - Trace(Arc), - MultipleTraces(Vec>), -} - -#[allow(unused)] -impl UnResolveTraceInfo { - pub fn get_trace_info(&self) -> Option> { - match self { - UnResolveTraceInfo::Trace(assertion) => Some(assertion.clone()), - UnResolveTraceInfo::MultipleTraces(assertions) => assertions.get(0).cloned(), - } - } - - pub fn get_trace_infos(&self) -> Option>> { - match self { - UnResolveTraceInfo::Trace(assertion) => Some(vec![assertion.clone()]), - UnResolveTraceInfo::MultipleTraces(assertions) => Some(assertions.clone()), - } - } - - pub fn add_trace_info(&mut self, trace_info: Arc) { - match self { - UnResolveTraceInfo::Trace(existing_assertion) => { - *self = UnResolveTraceInfo::MultipleTraces(vec![ - existing_assertion.clone(), - trace_info, - ]); - } - UnResolveTraceInfo::MultipleTraces(assertions) => { - assertions.push(trace_info); - } - } - } -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace.rs deleted file mode 100644 index d549e011b..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace.rs +++ /dev/null @@ -1,151 +0,0 @@ -use std::{collections::HashMap, sync::Arc, vec}; - -use rowan::TextRange; - -use crate::{ - compilation::analyzer::flow::build_flow_tree::LuaFlowTreeBuilder, LuaFlowChain, - LuaFlowChainInfo, LuaFlowId, LuaVarRefId, LuaVarRefNode, TypeAssertion, -}; - -use super::{ - unresolve_trace::{UnResolveTraceId, UnResolveTraceInfo}, - var_trace_info::VarTraceInfo, -}; - -#[derive(Debug, Clone)] -pub struct VarTrace<'a> { - var_ref_id: LuaVarRefId, - var_refs: Vec<(LuaVarRefNode, LuaFlowId)>, - assertions: Vec, - current_flow_id: Option, - unresolve_traces: HashMap, - flow_tree: &'a LuaFlowTreeBuilder, -} - -#[allow(unused)] -impl<'a> VarTrace<'a> { - pub fn new( - var_ref_id: LuaVarRefId, - var_refs: Vec<(LuaVarRefNode, LuaFlowId)>, - flow_tree: &'a LuaFlowTreeBuilder, - ) -> Self { - Self { - var_ref_id, - var_refs, - assertions: Vec::new(), - current_flow_id: None, - unresolve_traces: HashMap::new(), - flow_tree, - } - } - - pub fn set_current_flow_id(&mut self, flow_id: LuaFlowId) { - self.current_flow_id = Some(flow_id); - } - - pub fn get_current_flow_id(&self) -> Option { - self.current_flow_id.clone() - } - - pub fn get_var_ref_id(&self) -> &LuaVarRefId { - &self.var_ref_id - } - - pub fn add_assert(&mut self, assertion: TypeAssertion, effect_range: TextRange) -> Option<()> { - let current_flow_id = self.current_flow_id?; - let mut allow_add_flow = vec![current_flow_id]; - self.collect_allow_flow_id(current_flow_id, &mut allow_add_flow); - let mut assert_info = LuaFlowChainInfo { - range: effect_range, - type_assert: assertion.clone(), - allow_flow_id: allow_add_flow, - }; - - self.assertions.push(assert_info); - Some(()) - } - - fn collect_allow_flow_id( - &self, - current_flow_id: LuaFlowId, - allow_flow_ids: &mut Vec, - ) -> Option<()> { - if let Some(flow_node) = self.flow_tree.get_flow_node(current_flow_id) { - let children = flow_node.get_children(); - for child in children { - let range = child.get_range(); - let mut allow_add_flow_id = true; - for (var_ref, flow_id) in &self.var_refs { - if flow_id == ¤t_flow_id - && var_ref.is_assign_ref() - && var_ref.get_position() > range.end() - { - allow_add_flow_id = false; - break; - } - } - if allow_add_flow_id { - allow_flow_ids.push(*child); - let mut stack = vec![*child]; - while let Some(node) = stack.pop() { - for child in self.flow_tree.get_flow_node(node)?.get_children() { - stack.push(*child); - allow_flow_ids.push(*child); - } - } - } - } - } - Some(()) - } - - pub fn add_unresolve_trace( - &mut self, - trace_id: UnResolveTraceId, - trace_info: Arc, - ) { - if let Some(old_info) = self.unresolve_traces.get_mut(&trace_id) { - old_info.1.add_trace_info(trace_info); - } else { - let trace_info = UnResolveTraceInfo::Trace(trace_info); - if let Some(flow_id) = self.current_flow_id { - self.unresolve_traces - .insert(trace_id, (flow_id, trace_info)); - } - } - } - - pub fn check_var_use_in_range(&self, range: TextRange) -> bool { - for (node, _) in &self.var_refs { - if node.is_use_ref() && range.contains(node.get_position()) { - return true; - } - } - - false - } - - pub fn pop_unresolve_trace( - &mut self, - trace_id: &UnResolveTraceId, - ) -> Option<(LuaFlowId, UnResolveTraceInfo)> { - self.unresolve_traces.remove(trace_id) - } - - pub fn pop_all_unresolve_traces( - &mut self, - ) -> HashMap { - std::mem::take(&mut self.unresolve_traces) - } - - pub fn has_unresolve_traces(&self) -> bool { - !self.unresolve_traces.is_empty() - } - - pub fn finish(self) -> LuaFlowChain { - let mut asserts = self.assertions; - asserts.sort_by(|a, b| a.range.start().cmp(&b.range.start())); - - LuaFlowChain::new(self.var_ref_id, asserts) - } -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace_info.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace_info.rs deleted file mode 100644 index bdd481f75..000000000 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/var_analyze/var_trace_info.rs +++ /dev/null @@ -1,84 +0,0 @@ -use std::sync::Arc; - -use emmylua_parser::{BinaryOperator, LuaAst, LuaBinaryExpr, LuaExpr}; - -use crate::TypeAssertion; - -#[derive(Debug, Clone)] -pub struct VarTraceInfo { - pub type_assertion: TypeAssertion, - pub node: LuaAst, -} - -impl VarTraceInfo { - pub fn new(type_assertion: TypeAssertion, node: LuaAst) -> Self { - Self { - type_assertion, - node, - } - } - - pub fn with_type_assertion(&self, type_assertion: TypeAssertion) -> Arc { - Arc::new(VarTraceInfo { - type_assertion, - node: self.node.clone(), - }) - } - - pub fn check_cover_all_branch(&self) -> bool { - match &self.node { - LuaAst::LuaBinaryExpr(binary_expr) => { - if let Some(op) = binary_expr.get_op_token() { - match op.get_op() { - BinaryOperator::OpAnd => { - let count = count_binary_all_branch(binary_expr); - if let TypeAssertion::And(a) = &self.type_assertion { - return count == a.len(); - } else { - return count == 1; - } - } - _ => {} - } - } - } - _ => {} - } - - true - } -} - -fn count_binary_all_branch(binary_expr: &LuaBinaryExpr) -> usize { - let mut count = 0; - if let Some(op) = binary_expr.get_op_token() { - match op.get_op() { - BinaryOperator::OpAnd => { - let exprs = binary_expr.get_exprs(); - if let Some(exprs) = exprs { - count += count_expr_all_branch(&exprs.0); - count += count_expr_all_branch(&exprs.1); - } - - return count; - } - _ => return 1, - } - } - - 0 -} - -fn count_expr_all_branch(expr: &LuaExpr) -> usize { - match expr { - LuaExpr::BinaryExpr(binary_expr) => count_binary_all_branch(binary_expr), - LuaExpr::CallExpr(call_expr) => { - if call_expr.is_error() { - return 0; - } else { - return 1; - } - } - _ => 1, - } -} diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs index a7c19c770..12fb86a3b 100644 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs @@ -27,7 +27,7 @@ pub fn analyze_local_stat(analyzer: &mut LuaAnalyzer, local_stat: LuaLocalStat) analyzer .db .get_type_index_mut() - .bind_type(decl_id.into(), LuaTypeCache::InferType(LuaType::Unknown)); + .bind_type(decl_id.into(), LuaTypeCache::InferType(LuaType::Nil)); } return Some(()); diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/mod.rs index 199bdf273..88877eb50 100644 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/mod.rs +++ b/crates/emmylua_code_analysis/src/compilation/analyzer/mod.rs @@ -8,10 +8,8 @@ mod unresolve; use std::{collections::HashMap, sync::Arc}; -use crate::{ - db_index::DbIndex, profile::Profile, Emmyrc, InFiled, InferFailReason, LuaType, WorkspaceId, -}; -use emmylua_parser::{LuaChunk, LuaSyntaxId}; +use crate::{db_index::DbIndex, profile::Profile, Emmyrc, InFiled, InferFailReason, WorkspaceId}; +use emmylua_parser::LuaChunk; use infer_manager::InferCacheManager; use unresolve::UnResolve; @@ -100,7 +98,6 @@ pub struct AnalyzeContext { tree_list: Vec>, #[allow(unused)] config: Arc, - cast_flow: HashMap, LuaType>, unresolves: Vec<(UnResolve, InferFailReason)>, infer_manager: InferCacheManager, } @@ -110,7 +107,6 @@ impl AnalyzeContext { Self { tree_list: Vec::new(), config: emmyrc, - cast_flow: HashMap::new(), unresolves: Vec::new(), infer_manager: InferCacheManager::new(), } diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs index 62c35d4e8..df10054a8 100644 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs +++ b/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, diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs index 35748d9aa..9ba4dd221 100644 --- a/crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs +++ b/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>> { - let mut result: Vec<&Arc> = Vec::new(); +fn filter_signature_type(typ: &LuaType) -> Option>> { + let mut result: Vec> = 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); } } diff --git a/crates/emmylua_code_analysis/src/compilation/test/and_or_test.rs b/crates/emmylua_code_analysis/src/compilation/test/and_or_test.rs index ef6ad0244..c6c9baa12 100644 --- a/crates/emmylua_code_analysis/src/compilation/test/and_or_test.rs +++ b/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]))" ); } diff --git a/crates/emmylua_code_analysis/src/compilation/test/flow.rs b/crates/emmylua_code_analysis/src/compilation/test/flow.rs index 7f47cc889..fa0a654ea 100644 --- a/crates/emmylua_code_analysis/src/compilation/test/flow.rs +++ b/crates/emmylua_code_analysis/src/compilation/test/flow.rs @@ -461,7 +461,7 @@ end ); let b = ws.expr_ty("b"); - let b_expected = ws.ty("unknown"); + let b_expected = ws.ty("nil"); assert_eq!(b, b_expected); } diff --git a/crates/emmylua_code_analysis/src/compilation/test/static_cal_cmp.rs b/crates/emmylua_code_analysis/src/compilation/test/static_cal_cmp.rs index 0495bda60..1dffcfdeb 100644 --- a/crates/emmylua_code_analysis/src/compilation/test/static_cal_cmp.rs +++ b/crates/emmylua_code_analysis/src/compilation/test/static_cal_cmp.rs @@ -47,7 +47,7 @@ mod test { "#, ); let left = ws.expr_ty("d"); - assert_eq!(ws.humanize_type(left), "1?"); + assert_eq!(ws.humanize_type(left), "nil"); } #[test] diff --git a/crates/emmylua_code_analysis/src/db_index/declaration/decl_tree.rs b/crates/emmylua_code_analysis/src/db_index/declaration/decl_tree.rs index 5ea599aa0..d6e1d82e0 100644 --- a/crates/emmylua_code_analysis/src/db_index/declaration/decl_tree.rs +++ b/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 { + match self { + LuaDeclOrMemberId::Decl(decl_id) => Some(*decl_id), + LuaDeclOrMemberId::Member(_) => None, + } + } + + pub fn as_member_id(&self) -> Option { + 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(), + } + } +} diff --git a/crates/emmylua_code_analysis/src/db_index/flow/flow_chain.rs b/crates/emmylua_code_analysis/src/db_index/flow/flow_chain.rs deleted file mode 100644 index e601f4ee6..000000000 --- a/crates/emmylua_code_analysis/src/db_index/flow/flow_chain.rs +++ /dev/null @@ -1,78 +0,0 @@ -use emmylua_parser::{LuaAstNode, LuaChunk, LuaClosureExpr, LuaSyntaxKind, LuaSyntaxNode}; -use rowan::{TextRange, TextSize}; - -use super::{type_assert::TypeAssertion, LuaVarRefId}; - -#[derive(Debug)] -pub struct LuaFlowChain { - var_ref_id: LuaVarRefId, - type_asserts: Vec, -} - -#[derive(Debug, Clone)] -pub struct LuaFlowChainInfo { - pub range: TextRange, - pub type_assert: TypeAssertion, - pub allow_flow_id: Vec, -} - -impl LuaFlowChain { - pub fn new(var_ref_id: LuaVarRefId, asserts: Vec) -> Self { - Self { - var_ref_id, - type_asserts: asserts, - } - } - - pub fn get_var_ref_id(&self) -> LuaVarRefId { - self.var_ref_id.clone() - } - - pub fn get_type_asserts( - &self, - position: TextSize, - flow_id: LuaFlowId, - ) -> impl Iterator { - self.type_asserts - .iter() - .filter(move |assert| { - assert.allow_flow_id.contains(&flow_id) && assert.range.contains(position) - }) - .map(|assert| &assert.type_assert) - } - - pub fn get_all_type_asserts(&self) -> impl Iterator { - self.type_asserts.iter().map(|assert| &assert.type_assert) - } -} - -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -pub struct LuaFlowId(TextRange); - -impl LuaFlowId { - pub fn from_closure(closure_expr: LuaClosureExpr) -> Self { - Self(closure_expr.get_range()) - } - - pub fn from_chunk(chunk: LuaChunk) -> Self { - Self(chunk.get_range()) - } - - pub fn from_node(node: &LuaSyntaxNode) -> Self { - let flow_id = node.ancestors().find_map(|node| match node.kind().into() { - LuaSyntaxKind::ClosureExpr => LuaClosureExpr::cast(node).map(LuaFlowId::from_closure), - LuaSyntaxKind::Chunk => LuaChunk::cast(node).map(LuaFlowId::from_chunk), - _ => None, - }); - - flow_id.unwrap_or_else(|| LuaFlowId(TextRange::default())) - } - - pub fn get_position(&self) -> TextSize { - self.0.start() - } - - pub fn get_range(&self) -> TextRange { - self.0 - } -} diff --git a/crates/emmylua_code_analysis/src/db_index/flow/flow_node.rs b/crates/emmylua_code_analysis/src/db_index/flow/flow_node.rs new file mode 100644 index 000000000..2e361fe23 --- /dev/null +++ b/crates/emmylua_code_analysis/src/db_index/flow/flow_node.rs @@ -0,0 +1,128 @@ +use emmylua_parser::{ + LuaAssignStat, LuaAstNode, LuaAstPtr, LuaCallExpr, LuaChunk, LuaClosureExpr, LuaDocTagCast, + LuaExpr, LuaForStat, LuaSyntaxKind, LuaSyntaxNode, +}; +use internment::ArcIntern; +use rowan::{TextRange, TextSize}; +use smol_str::SmolStr; + +/// Unique identifier for flow nodes +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)] +pub struct FlowId(pub u32); + +/// Represents how flow nodes are connected +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum FlowAntecedent { + /// Single predecessor node + Single(FlowId), + /// Multiple predecessor nodes (stored externally by index) + Multiple(u32), +} + +/// Main flow node structure containing all flow analysis information +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FlowNode { + pub id: FlowId, + pub kind: FlowNodeKind, + pub antecedent: Option, +} + +/// Different types of flow nodes in the control flow graph +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum FlowNodeKind { + /// Entry point of the flow + Start, + /// Unreachable code + Unreachable, + /// Label for branching (if/else, switch cases) + BranchLabel, + /// Label for loops (while, for, repeat) + LoopLabel, + /// Named label (goto target) + NamedLabel(ArcIntern), + /// Declaration position + DeclPosition(TextSize), + /// Variable assignment + Assignment(LuaAstPtr), + /// Conditional flow (type guards, existence checks) + TrueCondition(LuaAstPtr), + /// Conditional flow (type guards, existence checks) + FalseCondition(LuaAstPtr), + /// For loop initialization + ForIStat(LuaAstPtr), + /// Tag cast comment + TagCast(LuaAstPtr), + /// Assert call + AssertCall(LuaAstPtr), + /// Break statement + Break, + /// Return statement + Return, +} + +#[allow(unused)] +impl FlowNodeKind { + pub fn is_branch_label(&self) -> bool { + matches!(self, FlowNodeKind::BranchLabel) + } + + pub fn is_loop_label(&self) -> bool { + matches!(self, FlowNodeKind::LoopLabel) + } + + pub fn is_named_label(&self) -> bool { + matches!(self, FlowNodeKind::NamedLabel(_)) + } + + pub fn is_change_flow(&self) -> bool { + matches!(self, FlowNodeKind::Break | FlowNodeKind::Return) + } + + pub fn is_assignment(&self) -> bool { + matches!(self, FlowNodeKind::Assignment(_)) + } + + pub fn is_conditional(&self) -> bool { + matches!( + self, + FlowNodeKind::TrueCondition(_) | FlowNodeKind::FalseCondition(_) + ) + } + + pub fn is_unreachable(&self) -> bool { + matches!(self, FlowNodeKind::Unreachable) + } +} + +#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] +pub struct LuaClosureId(TextRange); + +impl LuaClosureId { + pub fn from_closure(closure_expr: LuaClosureExpr) -> Self { + Self(closure_expr.get_range()) + } + + pub fn from_chunk(chunk: LuaChunk) -> Self { + Self(chunk.get_range()) + } + + pub fn from_node(node: &LuaSyntaxNode) -> Self { + let flow_id = node.ancestors().find_map(|node| match node.kind().into() { + LuaSyntaxKind::ClosureExpr => { + LuaClosureExpr::cast(node).map(LuaClosureId::from_closure) + } + LuaSyntaxKind::Chunk => LuaChunk::cast(node).map(LuaClosureId::from_chunk), + _ => None, + }); + + flow_id.unwrap_or_else(|| LuaClosureId(TextRange::default())) + } + + pub fn get_position(&self) -> TextSize { + self.0.start() + } + + pub fn get_range(&self) -> TextRange { + self.0 + } +} diff --git a/crates/emmylua_code_analysis/src/db_index/flow/flow_tree.rs b/crates/emmylua_code_analysis/src/db_index/flow/flow_tree.rs new file mode 100644 index 000000000..0d7203ea9 --- /dev/null +++ b/crates/emmylua_code_analysis/src/db_index/flow/flow_tree.rs @@ -0,0 +1,47 @@ +use std::collections::HashMap; + +use emmylua_parser::LuaSyntaxId; + +use crate::{FlowId, FlowNode, LuaDeclId}; + +#[derive(Debug)] +pub struct FlowTree { + #[allow(unused)] + decl_bind_flow_ref: HashMap, + flow_nodes: Vec, + multiple_antecedents: Vec>, + // labels: HashMap>, + bindings: HashMap, +} + +impl FlowTree { + pub fn new( + decl_bind_flow_ref: HashMap, + flow_nodes: Vec, + multiple_antecedents: Vec>, + // labels: HashMap>, + bindings: HashMap, + ) -> Self { + Self { + decl_bind_flow_ref, + flow_nodes, + multiple_antecedents, + // labels, + bindings, + } + } + + pub fn get_flow_id(&self, syntax_id: LuaSyntaxId) -> Option { + self.bindings.get(&syntax_id).cloned() + } + + pub fn get_flow_node(&self, flow_id: FlowId) -> Option<&FlowNode> { + self.flow_nodes.get(flow_id.0 as usize) + } + + pub fn get_multi_antecedents(&self, id: u32) -> Option<&[FlowId]> { + self.multiple_antecedents + .get(id as usize) + .map(|v| v.as_slice()) + } +} diff --git a/crates/emmylua_code_analysis/src/db_index/flow/flow_var_ref_id.rs b/crates/emmylua_code_analysis/src/db_index/flow/flow_var_ref_id.rs deleted file mode 100644 index 37654887e..000000000 --- a/crates/emmylua_code_analysis/src/db_index/flow/flow_var_ref_id.rs +++ /dev/null @@ -1,46 +0,0 @@ -use emmylua_parser::{LuaAstNode, LuaDocTagCast, LuaSyntaxId, LuaVarExpr}; -use rowan::{TextRange, TextSize}; -use smol_str::SmolStr; - -use crate::{InFiled, LuaDeclId}; - -#[derive(Debug, Eq, PartialEq, Clone, Hash)] -pub enum LuaVarRefId { - DeclId(LuaDeclId), - Name(SmolStr), - SyntaxId(InFiled), -} - -#[derive(Debug, Eq, PartialEq, Clone, Hash)] -pub enum LuaVarRefNode { - UseRef(LuaVarExpr), - AssignRef(LuaVarExpr), - CastRef(LuaDocTagCast), -} - -#[allow(unused)] -impl LuaVarRefNode { - pub fn get_range(&self) -> TextRange { - match self { - LuaVarRefNode::UseRef(id) => id.get_range(), - LuaVarRefNode::AssignRef(id) => id.get_range(), - LuaVarRefNode::CastRef(id) => id.get_range(), - } - } - - pub fn get_position(&self) -> TextSize { - self.get_range().start() - } - - pub fn is_use_ref(&self) -> bool { - matches!(self, LuaVarRefNode::UseRef(_)) - } - - pub fn is_assign_ref(&self) -> bool { - matches!(self, LuaVarRefNode::AssignRef(_)) - } - - pub fn is_cast_ref(&self) -> bool { - matches!(self, LuaVarRefNode::CastRef(_)) - } -} diff --git a/crates/emmylua_code_analysis/src/db_index/flow/mod.rs b/crates/emmylua_code_analysis/src/db_index/flow/mod.rs index 46394e14d..56bf1f4f9 100644 --- a/crates/emmylua_code_analysis/src/db_index/flow/mod.rs +++ b/crates/emmylua_code_analysis/src/db_index/flow/mod.rs @@ -1,81 +1,69 @@ -mod flow_chain; -mod flow_var_ref_id; -mod type_assert; +mod flow_node; +mod flow_tree; +mod signature_cast; use std::collections::HashMap; -pub use flow_chain::{LuaFlowChain, LuaFlowChainInfo, LuaFlowId}; -pub use flow_var_ref_id::{LuaVarRefId, LuaVarRefNode}; -pub use type_assert::TypeAssertion; +use crate::{FileId, LuaSignatureId}; +use emmylua_parser::{LuaAstPtr, LuaDocOpType}; +pub use flow_node::*; +pub use flow_tree::FlowTree; +pub use signature_cast::LuaSignatureCast; -use crate::FileId; - -use super::{traits::LuaIndex, LuaSignatureId}; +use super::traits::LuaIndex; #[derive(Debug)] pub struct LuaFlowIndex { - chains_map: HashMap>, - call_cast: HashMap>>, + file_flow_tree: HashMap, + signature_cast_cache: HashMap>, } impl LuaFlowIndex { pub fn new() -> Self { Self { - chains_map: HashMap::new(), - call_cast: HashMap::new(), + file_flow_tree: HashMap::new(), + signature_cast_cache: HashMap::new(), } } - pub fn add_flow_chain(&mut self, file_id: FileId, chain: LuaFlowChain) { - self.chains_map - .entry(file_id) - .or_insert_with(HashMap::new) - .insert(chain.get_var_ref_id(), chain); + pub fn add_flow_tree(&mut self, file_id: FileId, flow_tree: FlowTree) { + self.file_flow_tree.insert(file_id, flow_tree); } - pub fn get_flow_chain( + pub fn get_flow_tree(&self, file_id: &FileId) -> Option<&FlowTree> { + self.file_flow_tree.get(file_id) + } + + pub fn get_signature_cast( &self, - file_id: FileId, - var_ref_id: LuaVarRefId, - ) -> Option<&LuaFlowChain> { - self.chains_map - .get(&file_id) - .and_then(|map| map.get(&var_ref_id)) + file_id: &FileId, + signature_id: &LuaSignatureId, + ) -> Option<&LuaSignatureCast> { + self.signature_cast_cache.get(file_id)?.get(signature_id) } - pub fn add_call_cast( + pub fn add_signature_cast( &mut self, + file_id: FileId, signature_id: LuaSignatureId, - name: &str, - assertion: TypeAssertion, + name: String, + cast: LuaAstPtr, ) { - let file_id = signature_id.get_file_id(); - self.call_cast + self.signature_cast_cache .entry(file_id) .or_insert_with(HashMap::new) - .entry(signature_id) - .or_insert_with(HashMap::new) - .insert(name.to_string(), assertion); - } - - pub fn get_call_cast( - &self, - signature_id: LuaSignatureId, - ) -> Option<&HashMap> { - let file_id = signature_id.get_file_id(); - self.call_cast - .get(&file_id) - .and_then(|map| map.get(&signature_id)) + .insert(signature_id, LuaSignatureCast { name, cast }); } } impl LuaIndex for LuaFlowIndex { - fn remove(&mut self, file_id: crate::FileId) { - self.chains_map.remove(&file_id); - self.call_cast.remove(&file_id); + fn remove(&mut self, file_id: FileId) { + self.file_flow_tree.remove(&file_id); + self.signature_cast_cache.remove(&file_id); } fn clear(&mut self) { - self.chains_map.clear(); + self.file_flow_tree.clear(); + self.signature_cast_cache.clear(); } } diff --git a/crates/emmylua_code_analysis/src/db_index/flow/signature_cast.rs b/crates/emmylua_code_analysis/src/db_index/flow/signature_cast.rs new file mode 100644 index 000000000..f8d206747 --- /dev/null +++ b/crates/emmylua_code_analysis/src/db_index/flow/signature_cast.rs @@ -0,0 +1,7 @@ +use emmylua_parser::{LuaAstPtr, LuaDocOpType}; + +#[derive(Debug, Clone)] +pub struct LuaSignatureCast { + pub name: String, + pub cast: LuaAstPtr, +} diff --git a/crates/emmylua_code_analysis/src/db_index/flow/type_assert.rs b/crates/emmylua_code_analysis/src/db_index/flow/type_assert.rs deleted file mode 100644 index 532d9de98..000000000 --- a/crates/emmylua_code_analysis/src/db_index/flow/type_assert.rs +++ /dev/null @@ -1,211 +0,0 @@ -use std::{ops::Deref, sync::Arc}; - -use crate::{infer_expr, DbIndex, InferFailReason, LuaInferCache, LuaType, TypeOps}; -use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr, LuaSyntaxId, LuaSyntaxNode}; - -#[derive(Debug, Clone, Hash, PartialEq, Eq)] -pub enum TypeAssertion { - Exist, - NotExist, - Narrow(LuaType), - Add(LuaType), - Remove(LuaType), - Reassign { id: LuaSyntaxId, idx: i32 }, - Force(LuaType), - And(Arc>), - Or(Arc>), - Call { id: LuaSyntaxId, param_idx: i32 }, - NeCall { id: LuaSyntaxId, param_idx: i32 }, -} - -#[allow(unused)] -impl TypeAssertion { - pub fn get_negation(&self) -> Option { - match self { - TypeAssertion::Exist => Some(TypeAssertion::NotExist), - TypeAssertion::NotExist => Some(TypeAssertion::Exist), - TypeAssertion::Narrow(t) => Some(TypeAssertion::Remove(t.clone())), - TypeAssertion::Force(t) => Some(TypeAssertion::Remove(t.clone())), - TypeAssertion::Remove(t) => Some(TypeAssertion::Narrow(t.clone())), - TypeAssertion::Add(t) => Some(TypeAssertion::Remove(t.clone())), - TypeAssertion::And(a) => { - let negations: Vec<_> = a.iter().filter_map(|x| x.get_negation()).collect(); - Some(TypeAssertion::Or(negations.into())) - } - TypeAssertion::Or(a) => { - let negations: Vec<_> = a.iter().filter_map(|x| x.get_negation()).collect(); - Some(TypeAssertion::And(negations.into())) - } - TypeAssertion::Call { id, param_idx } => Some(TypeAssertion::NeCall { - id: *id, - param_idx: *param_idx, - }), - TypeAssertion::NeCall { id, param_idx } => Some(TypeAssertion::Call { - id: *id, - param_idx: *param_idx, - }), - _ => None, - } - } - - pub fn tighten_type( - &self, - db: &DbIndex, - cache: &mut LuaInferCache, - root: &LuaSyntaxNode, - source: LuaType, - ) -> Result { - match self { - TypeAssertion::Exist => Ok(TypeOps::RemoveNilOrFalse.apply_source(db, &source)), - TypeAssertion::NotExist => Ok(TypeOps::NarrowFalseOrNil.apply_source(db, &source)), - TypeAssertion::Narrow(t) => Ok(TypeOps::Narrow.apply(db, &source, t)), - TypeAssertion::Add(lua_type) => Ok(TypeOps::Union.apply(db, &source, lua_type)), - TypeAssertion::Remove(lua_type) => Ok(TypeOps::Remove.apply(db, &source, lua_type)), - TypeAssertion::Force(t) => Ok(t.clone()), - TypeAssertion::Reassign { id, idx } => { - let expr = LuaExpr::cast(id.to_node_from_root(root).ok_or(InferFailReason::None)?) - .ok_or(InferFailReason::None)?; - let expr_type = infer_expr(db, cache, expr)?; - let expr_type = match &expr_type { - LuaType::Variadic(multi) => { - multi.get_type(*idx as usize).unwrap_or(&LuaType::Nil) - } - t => t, - }; - Ok(TypeOps::Narrow.apply(db, &source, &expr_type)) - } - TypeAssertion::And(a) => { - let mut result = source; - for assertion in a.iter() { - result = assertion.tighten_type(db, cache, root, result.clone())?; - } - - Ok(result) - } - TypeAssertion::Or(a) => { - let mut result = vec![]; - for assertion in a.iter() { - result.push(assertion.tighten_type(db, cache, root, source.clone())?); - } - - match result.len() { - 0 => Ok(source), - 1 => Ok(result.remove(0)), - _ => { - let mut result_type = result.remove(0); - for t in result { - result_type = TypeOps::Union.apply(db, &result_type, &t); - } - - Ok(result_type) - } - } - } - TypeAssertion::Call { id, param_idx } => { - let call_expr = - LuaCallExpr::cast(id.to_node_from_root(root).ok_or(InferFailReason::None)?) - .ok_or(InferFailReason::None)?; - match call_assertion(db, cache, &call_expr, *param_idx) { - Ok(assert) => Ok(assert.tighten_type(db, cache, root, source.clone())?), - Err(InferFailReason::None) => Ok(source.clone()), - Err(e) => Err(e), - } - } - TypeAssertion::NeCall { id, param_idx } => { - let call_expr = - LuaCallExpr::cast(id.to_node_from_root(root).ok_or(InferFailReason::None)?) - .ok_or(InferFailReason::None)?; - match call_assertion(db, cache, &call_expr, *param_idx) { - Ok(assert) => Ok(assert - .get_negation() - .ok_or(InferFailReason::None)? - .tighten_type(db, cache, root, source.clone())?), - Err(InferFailReason::None) => Ok(source.clone()), - Err(e) => Err(e), - } - } - _ => Ok(source), - } - } - - pub fn is_reassign(&self) -> bool { - matches!(self, TypeAssertion::Reassign { .. }) - } - - pub fn is_and(&self) -> bool { - matches!(self, TypeAssertion::And(_)) - } - - pub fn is_or(&self) -> bool { - matches!(self, TypeAssertion::Or(_)) - } - - pub fn is_exist(&self) -> bool { - matches!(self, TypeAssertion::Exist) - } - - pub fn and_assert(&self, assertion: TypeAssertion) -> TypeAssertion { - if let TypeAssertion::And(a) = self { - let mut vecs = a.as_ref().clone(); - vecs.push(assertion); - TypeAssertion::And(Arc::new(vecs)) - } else { - TypeAssertion::And(Arc::new(vec![self.clone(), assertion])) - } - } - - pub fn or_assert(&self, assertion: TypeAssertion) -> TypeAssertion { - if let TypeAssertion::Or(a) = self { - let mut vecs = a.as_ref().clone(); - vecs.push(assertion); - TypeAssertion::Or(Arc::new(vecs)) - } else { - TypeAssertion::Or(Arc::new(vec![self.clone(), assertion])) - } - } -} - -fn call_assertion( - db: &DbIndex, - cache: &mut LuaInferCache, - call_expr: &LuaCallExpr, - param_idx: i32, -) -> Result { - let prefix = call_expr.get_prefix_expr().ok_or(InferFailReason::None)?; - let prefix_type = infer_expr(db, cache, prefix)?; - let LuaType::Signature(signature_id) = prefix_type else { - return Err(InferFailReason::None); - }; - - let Some(signature) = db.get_signature_index().get(&signature_id) else { - return Err(InferFailReason::None); - }; - - let return_type = signature.get_return_type(); - // donot change the condition - match return_type { - LuaType::Boolean => { - let Some(cast) = db.get_flow_index().get_call_cast(signature_id) else { - return Err(InferFailReason::None); - }; - - let param_name = if param_idx >= 0 { - let Some(param_name) = signature.get_param_name_by_id(param_idx as usize) else { - return Err(InferFailReason::None); - }; - - param_name - } else { - "self".to_string() - }; - - let Some(typeassert) = cast.get(¶m_name) else { - return Err(InferFailReason::None); - }; - - Ok(typeassert.clone()) - } - LuaType::TypeGuard(inner) => Ok(TypeAssertion::Force(inner.deref().clone())), - _ => return Err(InferFailReason::None), - } -} diff --git a/crates/emmylua_code_analysis/src/db_index/reference/mod.rs b/crates/emmylua_code_analysis/src/db_index/reference/mod.rs index 7b56d2e70..68a649ccd 100644 --- a/crates/emmylua_code_analysis/src/db_index/reference/mod.rs +++ b/crates/emmylua_code_analysis/src/db_index/reference/mod.rs @@ -111,6 +111,10 @@ impl LuaReferenceIndex { .get_decl_references(decl_id) } + pub fn get_var_reference_decl(&self, file_id: &FileId, range: TextRange) -> Option { + self.file_references.get(file_id)?.get_decl_id(&range) + } + pub fn get_decl_references_map( &self, file_id: &FileId, diff --git a/crates/emmylua_code_analysis/src/db_index/type/mod.rs b/crates/emmylua_code_analysis/src/db_index/type/mod.rs index 7994ef4dd..48074f70a 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/mod.rs +++ b/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), + } +} diff --git a/crates/emmylua_code_analysis/src/db_index/type/type_ops/and_type.rs b/crates/emmylua_code_analysis/src/db_index/type/type_ops/and_type.rs deleted file mode 100644 index 89d139201..000000000 --- a/crates/emmylua_code_analysis/src/db_index/type/type_ops/and_type.rs +++ /dev/null @@ -1,51 +0,0 @@ -// use std::ops::Deref; -// -// use crate::{LuaType, LuaUnionType}; -// -// pub fn and_type(left_type: LuaType, right_type: LuaType) -> LuaType { -// match (&left_type, &right_type) { -// (LuaType::Any | LuaType::Unknown, _) => return right_type, -// (_, LuaType::Any | LuaType::Unknown) => return left_type, -// // union -// (LuaType::Union(left), right) if !right.is_union() => { -// let left = left.deref().clone(); -// if left.get_types().iter().any(|it| it == right) { -// return right_type; -// } -// } -// (left, LuaType::Union(right)) if !left.is_union() => { -// let right = right.deref().clone(); -// if right.get_types().iter().any(|it| it == left) { -// return left_type; -// } -// } -// // two union -// (LuaType::Union(left), LuaType::Union(right)) => { -// let left = left.deref().clone(); -// let right = right.deref().clone(); -// let left_types = left.get_types(); -// let right_types = right.get_types(); -// let mut types = left_types -// .iter() -// .filter(|it| right_types.iter().any(|t| it == &t)) -// .map(|it| it.clone()) -// .collect::>(); -// types.dedup(); -// -// if types.is_empty() { -// return LuaType::Nil; -// } else if types.len() == 1 { -// return types[0].clone(); -// } else { -// return LuaType::Union(LuaUnionType::new(types).into()); -// } -// } -// -// // same type -// (left, right) if left == right => return left_type.clone(), -// _ => {} -// } -// -// // or maybe never -// LuaType::Nil -// } diff --git a/crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.rs b/crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.rs index f4ae1f1ef..aa05a9eaf 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.rs +++ b/crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.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), - } } diff --git a/crates/emmylua_code_analysis/src/db_index/type/type_ops/remove_type.rs b/crates/emmylua_code_analysis/src/db_index/type/type_ops/remove_type.rs index 4a2fb601e..167466612 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/type_ops/remove_type.rs +++ b/crates/emmylua_code_analysis/src/db_index/type/type_ops/remove_type.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 { if source == removed_type { diff --git a/crates/emmylua_code_analysis/src/db_index/type/type_ops/test.rs b/crates/emmylua_code_analysis/src/db_index/type/type_ops/test.rs index 6401f737b..6dac797c2 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/type_ops/test.rs +++ b/crates/emmylua_code_analysis/src/db_index/type/type_ops/test.rs @@ -52,30 +52,30 @@ mod tests { ws.ty("a") ); } - { - let type_ab = ws.ty("a | b"); - let type_a = ws.ty("a"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_ab, &type_a), - ws.ty("a") - ); - } - { - let type_a_opt = ws.ty("a?"); - let type_a = ws.ty("a"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_a_opt, &type_a), - ws.ty("a") - ); - } - { - let type_ab = ws.ty("a | b"); - let type_ab2 = ws.ty("a | b"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_ab, &type_ab2), - ws.ty("a | b") - ); - } + // { + // let type_ab = ws.ty("a | b"); + // let type_a = ws.ty("a"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_ab, &type_a), + // ws.ty("a") + // ); + // } + // { + // let type_a_opt = ws.ty("a?"); + // let type_a = ws.ty("a"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_a_opt, &type_a), + // ws.ty("a") + // ); + // } + // { + // let type_ab = ws.ty("a | b"); + // let type_ab2 = ws.ty("a | b"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_ab, &type_ab2), + // ws.ty("a | b") + // ); + // } } #[test] @@ -130,53 +130,53 @@ mod tests { ws.ty("number") ); } - { - let type_string_number = ws.ty("string | number"); - let type_string = ws.ty("string"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_number, &type_string), - ws.ty("string") - ); - } - { - let type_string_number = ws.ty("string | number"); - let type_number = ws.ty("number"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_number, &type_number), - ws.ty("number") - ); - } - { - let type_string_nil = ws.ty("string | nil"); - let type_string = ws.ty("string"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_nil, &type_string), - ws.ty("string") - ); - } - { - let type_number_nil = ws.ty("number | nil"); - let type_number = ws.ty("number"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_number_nil, &type_number), - ws.ty("number") - ); - } - { - let type_one_nil = ws.ty("1 | nil"); - let type_integer = ws.ty("integer"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_one_nil, &type_integer), - ws.ty("1") - ); - } - { - let type_string_array_opt = ws.ty("string[]?"); - let type_empty_table = ws.expr_ty("{}"); - assert_eq!( - TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_array_opt, &type_empty_table), - ws.ty("string[]") - ); - } + // { + // let type_string_number = ws.ty("string | number"); + // let type_string = ws.ty("string"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_number, &type_string), + // ws.ty("string") + // ); + // } + // { + // let type_string_number = ws.ty("string | number"); + // let type_number = ws.ty("number"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_number, &type_number), + // ws.ty("number") + // ); + // } + // { + // let type_string_nil = ws.ty("string | nil"); + // let type_string = ws.ty("string"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_nil, &type_string), + // ws.ty("string") + // ); + // } + // { + // let type_number_nil = ws.ty("number | nil"); + // let type_number = ws.ty("number"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_number_nil, &type_number), + // ws.ty("number") + // ); + // } + // { + // let type_one_nil = ws.ty("1 | nil"); + // let type_integer = ws.ty("integer"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_one_nil, &type_integer), + // ws.ty("1") + // ); + // } + // { + // let type_string_array_opt = ws.ty("string[]?"); + // let type_empty_table = ws.expr_ty("{}"); + // assert_eq!( + // TypeOps::Narrow.apply(ws.get_db_mut(), &type_string_array_opt, &type_empty_table), + // ws.ty("string[]") + // ); + // } } } diff --git a/crates/emmylua_code_analysis/src/db_index/type/types.rs b/crates/emmylua_code_analysis/src/db_index/type/types.rs index 38f058348..14130c56d 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/types.rs +++ b/crates/emmylua_code_analysis/src/db_index/type/types.rs @@ -1,6 +1,6 @@ use std::{ collections::HashMap, - hash::{Hash, Hasher}, + hash::{DefaultHasher, Hash, Hasher}, ops::Deref, sync::Arc, }; @@ -272,7 +272,7 @@ impl LuaType { pub fn is_nullable(&self) -> bool { match self { LuaType::Nil => true, - LuaType::Union(u) => u.types.iter().any(|t| t.is_nullable()), + LuaType::Union(u) => u.is_nullable(), _ => false, } } @@ -280,7 +280,7 @@ impl LuaType { pub fn is_optional(&self) -> bool { match self { LuaType::Nil | LuaType::Any | LuaType::Unknown => true, - LuaType::Union(u) => u.types.iter().any(|t| t.is_optional()), + LuaType::Union(u) => u.is_optional(), LuaType::Variadic(_) => true, _ => false, } @@ -290,7 +290,7 @@ impl LuaType { match self { LuaType::Nil | LuaType::Boolean | LuaType::Any | LuaType::Unknown => false, LuaType::BooleanConst(boolean) | LuaType::DocBooleanConst(boolean) => boolean.clone(), - LuaType::Union(u) => u.types.iter().all(|t| t.is_always_truthy()), + LuaType::Union(u) => u.is_always_truthy(), _ => true, } } @@ -298,7 +298,7 @@ impl LuaType { pub fn is_always_falsy(&self) -> bool { match self { LuaType::Nil | LuaType::BooleanConst(false) | LuaType::DocBooleanConst(false) => true, - LuaType::Union(u) => u.types.iter().all(|t| t.is_always_falsy()), + LuaType::Union(u) => u.is_always_falsy(), _ => false, } } @@ -709,46 +709,92 @@ impl From for LuaType { } } #[derive(Debug, Clone)] -pub struct LuaUnionType { - types: Vec, +pub enum LuaUnionType { + Nullable(LuaType), + Multi(Vec), } impl LuaUnionType { pub fn new(types: Vec) -> Self { - Self { types } + LuaUnionType::Multi(types) } - pub fn get_types(&self) -> &[LuaType] { - &self.types + pub fn new_nullable(ty: LuaType) -> Self { + LuaUnionType::Nullable(ty) + } + + pub fn get_types(&self) -> Vec { + match self { + LuaUnionType::Nullable(ty) => vec![ty.clone(), LuaType::Nil], + LuaUnionType::Multi(types) => types.clone(), + } } pub(crate) fn into_types(&self) -> Vec { - self.types.clone() + match self { + LuaUnionType::Nullable(ty) => vec![ty.clone(), LuaType::Nil], + LuaUnionType::Multi(types) => types.clone(), + } } pub fn contain_tpl(&self) -> bool { - self.types.iter().any(|t| t.contain_tpl()) + match self { + LuaUnionType::Nullable(ty) => ty.contain_tpl(), + LuaUnionType::Multi(types) => types.iter().any(|t| t.contain_tpl()), + } + } + + pub fn is_nullable(&self) -> bool { + match self { + LuaUnionType::Nullable(_) => true, + LuaUnionType::Multi(types) => types.iter().any(|t| t.is_nullable()), + } + } + + pub fn is_optional(&self) -> bool { + match self { + LuaUnionType::Nullable(_) => true, + LuaUnionType::Multi(types) => types.iter().any(|t| t.is_optional()), + } + } + + pub fn is_always_truthy(&self) -> bool { + match self { + LuaUnionType::Nullable(_) => false, + LuaUnionType::Multi(types) => types.iter().all(|t| t.is_always_truthy()), + } + } + + pub fn is_always_falsy(&self) -> bool { + match self { + LuaUnionType::Nullable(f) => f.is_always_falsy(), + LuaUnionType::Multi(types) => types.iter().all(|t| t.is_always_falsy()), + } } } impl PartialEq for LuaUnionType { fn eq(&self, other: &Self) -> bool { - if self.types.len() != other.types.len() { - return false; - } - let mut counts = HashMap::new(); - // Count occurrences in self.types - for t in &self.types { - *counts.entry(t).or_insert(0) += 1; - } - // Decrease counts for other.types - for t in &other.types { - match counts.get_mut(t) { - Some(count) if *count > 0 => *count -= 1, - _ => return false, + match (self, other) { + (LuaUnionType::Nullable(a), LuaUnionType::Nullable(b)) => a == b, + (LuaUnionType::Multi(a), LuaUnionType::Multi(b)) => { + if a.len() != b.len() { + return false; + } + let mut counts = HashMap::new(); + for t in a { + *counts.entry(t).or_insert(0) += 1; + } + for t in b { + match counts.get_mut(t) { + Some(count) if *count > 0 => *count -= 1, + _ => return false, + } + } + true } + _ => false, } - true } } @@ -760,18 +806,26 @@ impl std::hash::Hash for LuaUnionType { // - the number of elements // - the sum and product of the hashes of individual elements. // This is a simple and fast commutative hash. - let mut sum: u64 = 0; - let mut prod: u64 = 1; - for t in &self.types { - let mut hasher = std::collections::hash_map::DefaultHasher::new(); - t.hash(&mut hasher); - let h = hasher.finish(); - sum = sum.wrapping_add(h); - prod = prod.wrapping_mul(h.wrapping_add(1)); + match self { + LuaUnionType::Nullable(ty) => { + 0.hash(state); + ty.hash(state); + } + LuaUnionType::Multi(types) => { + types.len().hash(state); + let mut sum = 0; + let mut product = 1; + for t in types { + let mut hasher = DefaultHasher::new(); + t.hash(&mut hasher); + let hash = hasher.finish(); + sum += hash; + product *= hash; + } + sum.hash(state); + product.hash(state); + } } - self.types.len().hash(state); - sum.hash(state); - prod.hash(state); } } diff --git a/crates/emmylua_code_analysis/src/diagnostic/checker/cast_type_mismatch.rs b/crates/emmylua_code_analysis/src/diagnostic/checker/cast_type_mismatch.rs index c73398bae..c53353db7 100644 --- a/crates/emmylua_code_analysis/src/diagnostic/checker/cast_type_mismatch.rs +++ b/crates/emmylua_code_analysis/src/diagnostic/checker/cast_type_mismatch.rs @@ -80,7 +80,7 @@ fn check_cast_compatibility( if member_type.is_nil() { continue; } - if cast_type_check(semantic_model, member_type, target_type, 0).is_ok() { + if cast_type_check(semantic_model, &member_type, target_type, 0).is_ok() { return Some(()); } } @@ -169,7 +169,7 @@ fn cast_type_check( match cast_type_check( semantic_model, origin_type, - member_type, + &member_type, recursion_depth + 1, ) { Ok(_) => {} @@ -243,7 +243,7 @@ fn expand_type_recursive( // 递归展开 union 中的每个类型 let mut expanded_types = Vec::new(); for inner_type in union_type.get_types() { - if let Some(expanded) = expand_type_recursive(db, inner_type, visited) { + if let Some(expanded) = expand_type_recursive(db, &inner_type, visited) { match expanded { LuaType::Union(inner_union) => { // 如果展开后还是 union，则将其成员类型添加到结果中 diff --git a/crates/emmylua_code_analysis/src/diagnostic/checker/check_param_count.rs b/crates/emmylua_code_analysis/src/diagnostic/checker/check_param_count.rs index 89161f4a0..1a3844913 100644 --- a/crates/emmylua_code_analysis/src/diagnostic/checker/check_param_count.rs +++ b/crates/emmylua_code_analysis/src/diagnostic/checker/check_param_count.rs @@ -232,21 +232,21 @@ fn get_params_len(params: &[(String, Option)]) -> Option { } fn is_nullable(db: &DbIndex, typ: &LuaType) -> bool { - let mut stack: Vec<&LuaType> = Vec::new(); - stack.push(typ); + let mut stack: Vec = Vec::new(); + stack.push(typ.clone()); let mut visited = HashSet::new(); while let Some(typ) = stack.pop() { - if visited.contains(typ) { + if visited.contains(&typ) { continue; } - visited.insert(typ); + visited.insert(typ.clone()); match typ { LuaType::Any | LuaType::Unknown | LuaType::Nil => return true, LuaType::Ref(decl_id) => { - if let Some(decl) = db.get_type_index().get_type_decl(decl_id) { + if let Some(decl) = db.get_type_index().get_type_decl(&decl_id) { if decl.is_alias() { if let Some(alias_origin) = decl.get_alias_ref() { - stack.push(alias_origin); + stack.push(alias_origin.clone()); } } } @@ -258,7 +258,7 @@ fn is_nullable(db: &DbIndex, typ: &LuaType) -> bool { } LuaType::MultiLineUnion(m) => { for (t, _) in m.get_unions() { - stack.push(t); + stack.push(t.clone()); } } _ => {} diff --git a/crates/emmylua_code_analysis/src/diagnostic/test/unnecessary_assert_test.rs b/crates/emmylua_code_analysis/src/diagnostic/test/unnecessary_assert_test.rs index 4a5dea95f..1706d87e3 100644 --- a/crates/emmylua_code_analysis/src/diagnostic/test/unnecessary_assert_test.rs +++ b/crates/emmylua_code_analysis/src/diagnostic/test/unnecessary_assert_test.rs @@ -12,9 +12,6 @@ mod test { assert!(ws.check_code_for( DiagnosticCode::UnnecessaryAssert, r#" - local a - assert(a) - ---@type boolean local b assert(b) diff --git a/crates/emmylua_code_analysis/src/semantic/cache/mod.rs b/crates/emmylua_code_analysis/src/semantic/cache/mod.rs index 1689b8daf..13e87935b 100644 --- a/crates/emmylua_code_analysis/src/semantic/cache/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/cache/mod.rs @@ -4,26 +4,24 @@ pub use cache_options::{CacheOptions, LuaAnalysisPhase}; use emmylua_parser::LuaSyntaxId; use std::{collections::HashMap, sync::Arc}; -use crate::{db_index::LuaType, FileId, LuaFunctionType}; - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum CacheKey { - Expr(LuaSyntaxId), - Call(LuaSyntaxId, Option, LuaType), -} +use crate::{db_index::LuaType, semantic::infer::VarRefId, FileId, FlowId, LuaFunctionType}; #[derive(Debug)] -pub enum CacheEntry { - ReadyCache, - ExprCache(LuaType), - CallCache(Arc), +pub enum CacheEntry { + Ready, + Cache(T), } #[derive(Debug)] pub struct LuaInferCache { file_id: FileId, config: CacheOptions, - cache: HashMap, + pub expr_cache: HashMap>, + pub call_cache: + HashMap<(LuaSyntaxId, Option, LuaType), CacheEntry>>, + pub flow_node_cache: HashMap<(VarRefId, FlowId), CacheEntry>, + pub index_ref_origin_type_cache: HashMap>, + pub expr_var_ref_id_cache: HashMap, } impl LuaInferCache { @@ -31,7 +29,11 @@ impl LuaInferCache { Self { file_id, config, - cache: HashMap::new(), + expr_cache: HashMap::new(), + call_cache: HashMap::new(), + flow_node_cache: HashMap::new(), + index_ref_origin_type_cache: HashMap::new(), + expr_var_ref_id_cache: HashMap::new(), } } @@ -43,28 +45,15 @@ impl LuaInferCache { self.file_id } - // 表达式缓存相关方法 - pub fn ready_cache(&mut self, key: &CacheKey) { - self.cache.insert(key.clone(), CacheEntry::ReadyCache); - } - - pub fn add_cache(&mut self, key: &CacheKey, value: CacheEntry) { - self.cache.insert(key.clone(), value); - } - - pub fn get(&self, key: &CacheKey) -> Option<&CacheEntry> { - self.cache.get(key) - } - - pub fn remove(&mut self, key: &CacheKey) { - self.cache.remove(key); - } - pub fn set_phase(&mut self, phase: LuaAnalysisPhase) { self.config.analysis_phase = phase; } pub fn clear(&mut self) { - self.cache.clear(); + self.expr_cache.clear(); + self.call_cache.clear(); + self.flow_node_cache.clear(); + self.index_ref_origin_type_cache.clear(); + self.expr_var_ref_id_cache.clear(); } } diff --git a/crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs b/crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs index fff1fde23..6aa5dbd15 100644 --- a/crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs +++ b/crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs @@ -175,7 +175,7 @@ fn instantiate_union(db: &DbIndex, union: &LuaUnionType, substitutor: &TypeSubst let types = union.get_types(); let mut new_types = Vec::new(); for t in types { - let t = instantiate_type_generic(db, t, substitutor); + let t = instantiate_type_generic(db, &t, substitutor); new_types.push(t); } diff --git a/crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs b/crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs index 6e2eb0912..36c85fc7c 100644 --- a/crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs +++ b/crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs @@ -613,7 +613,7 @@ fn union_tpl_pattern_match( substitutor: &mut TypeSubstitutor, ) -> TplPatternMatchResult { for u in union.get_types() { - tpl_pattern_match(db, cache, root, u, target, substitutor)?; + tpl_pattern_match(db, cache, root, &u, target, substitutor)?; } Ok(()) diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/infer_binary_or.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/infer_binary_or.rs index c120d2381..c3bbb92fc 100644 --- a/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/infer_binary_or.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/infer_binary_or.rs @@ -1,6 +1,10 @@ use emmylua_parser::LuaExpr; -use crate::{check_type_compact, semantic::infer::InferResult, DbIndex, LuaType, TypeOps}; +use crate::{ + check_type_compact, + semantic::infer::{narrow::remove_false_or_nil, InferResult}, + DbIndex, LuaType, TypeOps, +}; pub fn special_or_rule( db: &DbIndex, @@ -13,13 +17,13 @@ pub fn special_or_rule( // workaround for x or error('') LuaExpr::CallExpr(call_expr) => { if call_expr.is_error() { - return Some(TypeOps::RemoveNilOrFalse.apply_source(db, &left_type)); + return Some(remove_false_or_nil(left_type.clone())); } } LuaExpr::TableExpr(table_expr) => { if table_expr.is_empty() && check_type_compact(db, &left_type, &LuaType::Table).is_ok() { - return Some(TypeOps::RemoveNilOrFalse.apply_source(db, &left_type)); + return Some(remove_false_or_nil(left_type.clone())); } } LuaExpr::LiteralExpr(_) => { @@ -33,7 +37,7 @@ pub fn special_or_rule( } if check_type_compact(db, &left_type, &right_type).is_ok() { - return Some(TypeOps::RemoveNilOrFalse.apply_source(db, &left_type)); + return Some(remove_false_or_nil(left_type.clone())); } } @@ -50,9 +54,5 @@ pub fn infer_binary_expr_or(db: &DbIndex, left: LuaType, right: LuaType) -> Infe return Ok(right); } - Ok(TypeOps::Union.apply( - db, - &TypeOps::RemoveNilOrFalse.apply_source(db, &left), - &right, - )) + Ok(TypeOps::Union.apply(db, &remove_false_or_nil(left), &right)) } diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/mod.rs index e8bf6570d..293c004cc 100644 --- a/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/infer_binary/mod.rs @@ -7,6 +7,7 @@ use smol_str::SmolStr; use crate::{ check_type_compact, db_index::{DbIndex, LuaOperatorMetaMethod, LuaType}, + semantic::infer::narrow::narrow_false_or_nil, LuaInferCache, TypeOps, }; @@ -238,7 +239,11 @@ fn infer_binary_expr_div(db: &DbIndex, left: LuaType, right: LuaType) -> InferRe return match (&left, &right) { (LuaType::IntegerConst(int1), LuaType::IntegerConst(int2)) => { if *int2 != 0 { - return Ok(LuaType::FloatConst((*int1 as f64 / *int2 as f64).into())); + if int1 % int2 != 0 { + return Ok(LuaType::FloatConst((*int1 as f64 / *int2 as f64).into())); + } else { + return Ok(LuaType::IntegerConst(int1 / int2)); + } } Ok(LuaType::Number) } @@ -416,11 +421,7 @@ fn infer_binary_expr_and(db: &DbIndex, left: LuaType, right: LuaType) -> InferRe return Ok(right); } - Ok(TypeOps::Union.apply( - db, - &TypeOps::NarrowFalseOrNil.apply_source(db, &left), - &right, - )) + Ok(TypeOps::Union.apply(db, &narrow_false_or_nil(db, left), &right)) } fn infer_cmp_expr(_: &DbIndex, left: LuaType, right: LuaType, op: BinaryOperator) -> InferResult { diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs index a40a5bc6f..873df5e7d 100644 --- a/crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs @@ -11,9 +11,11 @@ use super::{ InferFailReason, InferResult, }; use crate::semantic::infer_expr; -use crate::{semantic::generic::instantiate_doc_function, LuaVarRefId}; +use crate::semantic::{ + generic::instantiate_doc_function, infer::narrow::get_type_at_call_expr_inline_cast, +}; use crate::{ - CacheEntry, CacheKey, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType, + CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignatureId, LuaType, LuaTypeDeclId, LuaUnionType, }; use infer_require::infer_require_call; @@ -33,16 +35,16 @@ pub fn infer_call_expr_func( args_count: Option, ) -> InferCallFuncResult { let syntax_id = call_expr.get_syntax_id(); - let key = CacheKey::Call(syntax_id, args_count, call_expr_type.clone()); - match cache.get(&key) { + let key = (syntax_id, args_count, call_expr_type.clone()); + match cache.call_cache.get(&key) { Some(cache) => match cache { - CacheEntry::CallCache(ty) => return Ok(ty.clone()), + CacheEntry::Cache(ty) => return Ok(ty.clone()), _ => return Err(InferFailReason::RecursiveInfer), }, None => {} } - cache.ready_cache(&key); + cache.call_cache.insert(key.clone(), CacheEntry::Ready); let result = match &call_expr_type { LuaType::DocFunction(func) => { infer_doc_function(db, cache, &func, call_expr.clone(), args_count) @@ -120,10 +122,12 @@ pub fn infer_call_expr_func( match &result { Ok(func_ty) => { - cache.add_cache(&key, CacheEntry::CallCache(func_ty.clone())); + cache + .call_cache + .insert(key, CacheEntry::Cache(func_ty.clone())); } Err(r) if r.is_need_resolve() => { - cache.remove(&key); + cache.call_cache.remove(&key); } _ => {} } @@ -440,7 +444,7 @@ fn infer_union( for ty in union.get_types() { match ty { LuaType::Signature(signature_id) => { - if let Some(signature) = db.get_signature_index().get(signature_id) { + if let Some(signature) = db.get_signature_index().get(&signature_id) { // 处理 overloads let overloads = if signature.is_generic() { signature @@ -483,7 +487,7 @@ fn infer_union( Arc::new(instantiate_func_generic( db, cache, - func, + &func, call_expr.clone(), )?) } else { @@ -625,7 +629,7 @@ pub fn infer_call_expr( let prefix_expr = call_expr.get_prefix_expr().ok_or(InferFailReason::None)?; let prefix_type = infer_expr(db, cache, prefix_expr)?; - let mut ret_type = infer_call_expr_func( + let ret_type = infer_call_expr_func( db, cache, call_expr.clone(), @@ -636,13 +640,18 @@ pub fn infer_call_expr( .get_ret() .clone(); - let file_id = cache.get_file_id(); - let var_ref_id = LuaVarRefId::SyntaxId(InFiled::new(file_id, call_expr.get_syntax_id())); - let flow_chain = db.get_flow_index().get_flow_chain(file_id, var_ref_id); - if let Some(flow_chain) = flow_chain { - let root = call_expr.get_root(); - for type_assert in flow_chain.get_all_type_asserts() { - ret_type = type_assert.tighten_type(db, cache, &root, ret_type)?; + if let Some(tree) = db.get_flow_index().get_flow_tree(&cache.get_file_id()) { + if let Some(flow_id) = tree.get_flow_id(call_expr.get_syntax_id()) { + if let Some(flow_ret_type) = get_type_at_call_expr_inline_cast( + db, + cache, + tree, + call_expr, + flow_id, + ret_type.clone(), + ) { + return Ok(flow_ret_type); + } } } diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs index 439a7b3fe..74fa0883a 100644 --- a/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs @@ -1,8 +1,7 @@ use std::collections::HashSet; -use emmylua_parser::{ - LuaAstNode, LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, PathTrait, -}; +use emmylua_parser::{LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, PathTrait}; +use internment::ArcIntern; use rowan::TextRange; use smol_str::SmolStr; @@ -14,12 +13,13 @@ use crate::{ enum_variable_is_param, semantic::{ generic::{instantiate_type_generic, TypeSubstitutor}, + infer::{infer_name::get_name_expr_var_ref_id, narrow::infer_expr_narrow_type, VarRefId}, member::get_buildin_type_map_type_id, type_check::{self, check_type_compact}, InferGuard, }, - InFiled, LuaFlowId, LuaInferCache, LuaInstanceType, LuaMemberOwner, LuaOperatorOwner, - LuaVarRefId, TypeOps, + CacheEntry, InFiled, LuaDeclOrMemberId, LuaInferCache, LuaInstanceType, LuaMemberOwner, + LuaOperatorOwner, TypeOps, }; use super::{infer_expr, infer_name::infer_global_type, InferFailReason, InferResult}; @@ -88,53 +88,57 @@ 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; 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; - } - } _ => {} } + let Some(var_ref_id) = get_index_expr_var_ref_id(db, cache, &index_expr) else { + return Ok(member_type.clone()); + }; + + cache + .index_ref_origin_type_cache + .insert(var_ref_id.clone(), CacheEntry::Cache(member_type.clone())); + let result = infer_expr_narrow_type(db, cache, LuaExpr::IndexExpr(index_expr), var_ref_id); + match &result { + Err(InferFailReason::None) => Ok(member_type.clone()), + _ => result, + } +} + +pub fn get_index_expr_var_ref_id( + db: &DbIndex, + cache: &mut LuaInferCache, + index_expr: &LuaIndexExpr, +) -> Option { let access_path = match index_expr.get_access_path() { - Some(path) => path, - None => return Ok(member_type.clone()), + Some(path) => ArcIntern::new(SmolStr::new(&path)), + None => return None, }; - let var_ref_id = LuaVarRefId::Name(SmolStr::new(&access_path)); - let flow_id = LuaFlowId::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 mut prefix_expr = index_expr.get_prefix_expr()?; + while let LuaExpr::IndexExpr(index_expr) = prefix_expr { + prefix_expr = index_expr.get_prefix_expr()?; } - Ok(member_type) + if let LuaExpr::NameExpr(name_expr) = prefix_expr { + let decl_or_member_id = match get_name_expr_var_ref_id(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( @@ -182,7 +186,10 @@ fn infer_array_member( ) -> Result { let key = index_expr.get_index_key().ok_or(InferFailReason::None)?; let expression_type = if db.get_emmyrc().strict.array_index { - TypeOps::Union.apply(db, array_type, &LuaType::Nil) + match &array_type { + LuaType::Any | LuaType::Unknown => array_type.clone(), + _ => TypeOps::Union.apply(db, array_type, &LuaType::Nil), + } } else { array_type.clone() }; @@ -353,11 +360,11 @@ fn get_expr_key_members( fn get_all_member_key(db: &DbIndex, origin_type: &LuaType) -> Option> { let mut result = Vec::new(); - let mut stack = vec![origin_type]; // 堆栈用于迭代处理 + let mut stack = vec![origin_type.clone()]; // 堆栈用于迭代处理 let mut visited = HashSet::new(); while let Some(current_type) = stack.pop() { - if visited.contains(current_type) { + if visited.contains(¤t_type) { continue; } visited.insert(current_type.clone()); @@ -372,7 +379,7 @@ fn get_all_member_key(db: &DbIndex, origin_type: &LuaType) -> Option { - stack.push(typ); // 将 Ref 类型推入堆栈进一步处理 + stack.push(typ.clone()); // 将 Ref 类型推入堆栈进一步处理 } _ => {} } @@ -381,12 +388,12 @@ fn get_all_member_key(db: &DbIndex, origin_type: &LuaType) -> Option { for typ in union_type.get_types() { if let LuaType::Ref(_) = typ { - stack.push(typ); // 推入堆栈 + stack.push(typ.clone()); // 推入堆栈 } } } LuaType::Ref(id) => { - if let Some(type_decl) = db.get_type_index().get_type_decl(id) { + if let Some(type_decl) = db.get_type_index().get_type_decl(&id) { if type_decl.is_enum() { let owner = LuaMemberOwner::Type(id.clone()); if let Some(members) = db.get_member_index().get_members(&owner) { @@ -528,7 +535,7 @@ fn infer_union_member( let result = infer_member_by_member_key( db, cache, - sub_type, + &sub_type, index_expr.clone(), &mut InferGuard::new(), ); @@ -891,7 +898,7 @@ fn infer_member_by_index_union( let result = infer_member_by_operator( db, cache, - member, + &member, index_expr.clone(), &mut InferGuard::new(), ); diff --git a/crates/emmylua_code_analysis/src/semantic/infer/infer_name.rs b/crates/emmylua_code_analysis/src/semantic/infer/infer_name.rs index 8e7ba7044..d8a281b2d 100644 --- a/crates/emmylua_code_analysis/src/semantic/infer/infer_name.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/infer_name.rs @@ -1,13 +1,12 @@ -use emmylua_parser::{LuaAstNode, LuaNameExpr}; -use smol_str::SmolStr; +use emmylua_parser::{LuaAstNode, LuaExpr, LuaNameExpr}; +use super::{InferFailReason, InferResult}; use crate::{ db_index::{DbIndex, LuaDeclOrMemberId}, - LuaDecl, LuaDeclExtra, LuaFlowId, LuaInferCache, LuaMemberId, LuaType, LuaVarRefId, TypeOps, + semantic::infer::narrow::{infer_expr_narrow_type, VarRefId}, + LuaDecl, LuaDeclExtra, LuaInferCache, LuaMemberId, LuaType, TypeOps, }; -use super::{InferFailReason, InferResult}; - pub fn infer_name_expr( db: &DbIndex, cache: &mut LuaInferCache, @@ -29,72 +28,49 @@ 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 { - let decl = db - .get_decl_index() - .get_decl(&decl_id) - .ok_or(InferFailReason::None)?; - let mut decl_type = get_decl_type(db, decl)?; - let var_ref_id = LuaVarRefId::DeclId(decl_id); - let flow_chain = db.get_flow_index().get_flow_chain(file_id, var_ref_id); - let root = name_expr.get_root(); - if let Some(flow_chain) = flow_chain { - let flow_id = LuaFlowId::from_node(name_expr.syntax()); - for type_assert in flow_chain.get_type_asserts(name_expr.get_position(), flow_id) { - decl_type = type_assert.tighten_type(db, cache, &root, decl_type)?; - } - } - Ok(decl_type) + infer_expr_narrow_type( + db, + cache, + LuaExpr::NameExpr(name_expr), + VarRefId::VarRef(decl_id), + ) } else { infer_global_type(db, name) } } -fn get_decl_type(db: &DbIndex, decl: &LuaDecl) -> InferResult { - if decl.is_global() { - let name = decl.get_name(); - return infer_global_type(db, name); - } - - if let Some(type_cache) = db.get_type_index().get_type_cache(&decl.get_id().into()) { - return Ok(type_cache.as_type().clone()); - } - - if decl.is_param() { - return infer_param(db, decl); - } - - Err(InferFailReason::UnResolveDeclType(decl.get_id())) -} - fn infer_self(db: &DbIndex, cache: &mut LuaInferCache, name_expr: LuaNameExpr) -> InferResult { - let file_id = cache.get_file_id(); - 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) => { - let decl = db - .get_decl_index() - .get_decl(&decl_id) - .ok_or(InferFailReason::None)?; - let mut decl_type = get_decl_type(db, decl)?; - if let LuaType::Ref(id) = decl_type { - decl_type = LuaType::Def(id); - } - - // let flow_id = LuaFlowId::from_node(name_expr.syntax()); - let var_ref_id = LuaVarRefId::Name(SmolStr::new("self")); - let flow_chain = db.get_flow_index().get_flow_chain(file_id, var_ref_id); - let root = name_expr.get_root(); - if let Some(flow_chain) = flow_chain { - let flow_id = LuaFlowId::from_node(name_expr.syntax()); - for type_assert in flow_chain.get_type_asserts(name_expr.get_position(), flow_id) { - decl_type = type_assert.tighten_type(db, cache, &root, decl_type)?; - } - } + // LuaDeclOrMemberId::Member(member_id) => find_decl_member_type(db, member_id), + infer_expr_narrow_type( + db, + cache, + LuaExpr::NameExpr(name_expr), + VarRefId::SelfRef(decl_or_member_id), + ) +} - Ok(decl_type) +pub fn get_name_expr_var_ref_id( + db: &DbIndex, + cache: &mut LuaInferCache, + name_expr: &LuaNameExpr, +) -> Option { + 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), } } @@ -139,7 +115,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) diff --git a/crates/emmylua_code_analysis/src/semantic/infer/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/mod.rs index 9ddd91bf0..1ce8500ad 100644 --- a/crates/emmylua_code_analysis/src/semantic/infer/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/mod.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; @@ -32,17 +34,17 @@ use crate::{ InFiled, InferGuard, LuaMemberKey, VariadicType, }; -use super::{member::infer_raw_member_type, CacheEntry, CacheKey, LuaInferCache}; +use super::{member::infer_raw_member_type, CacheEntry, LuaInferCache}; pub type InferResult = Result; pub use infer_call::InferCallFuncResult; pub fn infer_expr(db: &DbIndex, cache: &mut LuaInferCache, expr: LuaExpr) -> InferResult { let syntax_id = expr.get_syntax_id(); - let key = CacheKey::Expr(syntax_id); - match cache.get(&key) { + let key = syntax_id; + match cache.expr_cache.get(&key) { Some(cache) => match cache { - CacheEntry::ExprCache(ty) => return Ok(ty.clone()), + CacheEntry::Cache(ty) => return Ok(ty.clone()), _ => return Err(InferFailReason::RecursiveInfer), }, None => {} @@ -55,14 +57,13 @@ pub fn infer_expr(db: &DbIndex, cache: &mut LuaInferCache, expr: LuaExpr) -> Inf .get_type_index() .get_type_cache(&in_filed_syntax_id.into()) { - cache.add_cache( - &key, - CacheEntry::ExprCache(bind_type_cache.as_type().clone()), - ); + cache + .expr_cache + .insert(key, CacheEntry::Cache(bind_type_cache.as_type().clone())); return Ok(bind_type_cache.as_type().clone()); } - cache.ready_cache(&key); + cache.expr_cache.insert(key, CacheEntry::Ready); let result_type = match expr { LuaExpr::CallExpr(call_expr) => infer_call_expr(db, cache, call_expr), LuaExpr::TableExpr(table_expr) => infer_table_expr(db, cache, table_expr), @@ -80,21 +81,29 @@ 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 + .expr_cache + .insert(key, CacheEntry::Cache(result_type.clone())); + } Err(InferFailReason::None) | Err(InferFailReason::RecursiveInfer) => { - cache.add_cache(&key, CacheEntry::ExprCache(LuaType::Unknown)); + cache + .expr_cache + .insert(key, CacheEntry::Cache(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 + .expr_cache + .insert(key, CacheEntry::Cache(LuaType::Nil)); return Ok(LuaType::Nil); } else { - cache.ready_cache(&key); + cache.expr_cache.insert(key, CacheEntry::Ready); } } _ => { - cache.remove(&key); + cache.expr_cache.remove(&key); } } diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/binary_flow.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/binary_flow.rs new file mode 100644 index 000000000..f88e79ff3 --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/binary_flow.rs @@ -0,0 +1,304 @@ +use emmylua_parser::{ + BinaryOperator, LuaBinaryExpr, LuaCallExpr, LuaChunk, LuaExpr, LuaLiteralToken, +}; + +use crate::{ + infer_expr, + semantic::infer::{ + narrow::{ + condition_flow::{call_flow::get_type_at_call_expr, InferConditionFlow}, + get_single_antecedent, + get_type_at_flow::get_type_at_flow, + narrow_down_type, + var_ref_id::get_var_expr_var_ref_id, + ResultTypeOrContinue, + }, + VarRefId, + }, + DbIndex, FlowNode, FlowTree, InferFailReason, LuaInferCache, LuaType, TypeOps, +}; + +pub fn get_type_at_binary_expr( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + binary_expr: LuaBinaryExpr, + condition_flow: InferConditionFlow, +) -> Result { + let Some(op_token) = binary_expr.get_op_token() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some((left_expr, right_expr)) = binary_expr.get_exprs() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + match op_token.get_op() { + BinaryOperator::OpLt + | BinaryOperator::OpLe + | BinaryOperator::OpGt + | BinaryOperator::OpGe => { + // todo check number range + } + BinaryOperator::OpEq => { + let result_type = maybe_type_guard_binary( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + left_expr.clone(), + right_expr.clone(), + condition_flow, + )?; + if let ResultTypeOrContinue::Result(result_type) = result_type { + return Ok(ResultTypeOrContinue::Result(result_type)); + } + + return maybe_var_eq_narrow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + left_expr, + right_expr, + condition_flow, + ); + } + BinaryOperator::OpNe => { + let result_type = maybe_type_guard_binary( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + left_expr.clone(), + right_expr.clone(), + condition_flow.get_negated(), + )?; + if let ResultTypeOrContinue::Result(result_type) = result_type { + return Ok(ResultTypeOrContinue::Result(result_type)); + } + + return maybe_var_eq_narrow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + left_expr, + right_expr, + condition_flow.get_negated(), + ); + } + _ => {} + } + + Ok(ResultTypeOrContinue::Continue) +} + +fn maybe_type_guard_binary( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + left_expr: LuaExpr, + right_expr: LuaExpr, + condition_flow: InferConditionFlow, +) -> Result { + let mut type_guard_expr: Option = None; + let mut literal_string = String::new(); + if let LuaExpr::CallExpr(call_expr) = left_expr { + if call_expr.is_type() { + type_guard_expr = Some(call_expr); + if let LuaExpr::LiteralExpr(literal_expr) = right_expr { + match literal_expr.get_literal() { + Some(LuaLiteralToken::String(s)) => { + literal_string = s.get_value(); + } + _ => return Ok(ResultTypeOrContinue::Continue), + } + } + } + } else if let LuaExpr::CallExpr(call_expr) = right_expr { + if call_expr.is_type() { + type_guard_expr = Some(call_expr); + if let LuaExpr::LiteralExpr(literal_expr) = left_expr { + match literal_expr.get_literal() { + Some(LuaLiteralToken::String(s)) => { + literal_string = s.get_value(); + } + _ => return Ok(ResultTypeOrContinue::Continue), + } + } + } + } + + if type_guard_expr.is_none() || literal_string.is_empty() { + return Ok(ResultTypeOrContinue::Continue); + } + + let Some(arg_list) = type_guard_expr.unwrap().get_args_list() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(arg) = arg_list.get_args().next() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let LuaExpr::NameExpr(name_expr) = arg else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(maybe_var_ref_id) = + get_var_expr_var_ref_id(db, cache, LuaExpr::NameExpr(name_expr.clone())) + else { + // If we cannot find a reference declaration ID, we cannot narrow it + return Ok(ResultTypeOrContinue::Continue); + }; + + if maybe_var_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + let anatecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = get_type_at_flow(db, tree, cache, root, var_ref_id, anatecedent_flow_id)?; + + let narrow = match literal_string.as_str() { + "number" => LuaType::Number, + "string" => LuaType::String, + "boolean" => LuaType::Boolean, + "table" => LuaType::Table, + "function" => LuaType::Function, + "thread" => LuaType::Thread, + "userdata" => LuaType::Userdata, + "nil" => LuaType::Nil, + _ => { + // If the type is not recognized, we cannot narrow it + return Ok(ResultTypeOrContinue::Continue); + } + }; + + let result_type = match condition_flow { + InferConditionFlow::TrueCondition => { + narrow_down_type(db, antecedent_type.clone(), narrow.clone()).unwrap_or(narrow) + } + InferConditionFlow::FalseCondition => TypeOps::Remove.apply(db, &antecedent_type, &narrow), + }; + + Ok(ResultTypeOrContinue::Result(result_type)) +} + +fn maybe_var_eq_narrow( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + left_expr: LuaExpr, + right_expr: LuaExpr, + condition_flow: InferConditionFlow, +) -> Result { + // only check left as need narrow + match left_expr { + LuaExpr::NameExpr(left_name_expr) => { + let Some(maybe_ref_id) = + get_var_expr_var_ref_id(db, cache, LuaExpr::NameExpr(left_name_expr.clone())) + else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if maybe_ref_id != *var_ref_id { + // If the reference declaration ID does not match, we cannot narrow it + return Ok(ResultTypeOrContinue::Continue); + } + + let right_expr_type = infer_expr(db, cache, right_expr)?; + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = + get_type_at_flow(db, tree, cache, root, &var_ref_id, antecedent_flow_id)?; + + let result_type = match condition_flow { + InferConditionFlow::TrueCondition => { + narrow_down_type(db, antecedent_type, right_expr_type.clone()) + .unwrap_or(right_expr_type) + } + InferConditionFlow::FalseCondition => { + TypeOps::Remove.apply(db, &antecedent_type, &right_expr_type) + } + }; + Ok(ResultTypeOrContinue::Result(result_type)) + } + LuaExpr::CallExpr(left_call_expr) => { + match right_expr { + LuaExpr::LiteralExpr(literal_expr) => match literal_expr.get_literal() { + Some(LuaLiteralToken::Bool(b)) => { + let flow = if b.is_true() { + condition_flow + } else { + condition_flow.get_negated() + }; + + return get_type_at_call_expr( + db, + tree, + cache, + root, + &var_ref_id, + flow_node, + left_call_expr, + flow, + ); + } + _ => return Ok(ResultTypeOrContinue::Continue), + }, + _ => {} + }; + + Ok(ResultTypeOrContinue::Continue) + } + LuaExpr::IndexExpr(left_index_expr) => { + let Some(maybe_ref_id) = + get_var_expr_var_ref_id(db, cache, LuaExpr::IndexExpr(left_index_expr.clone())) + else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if maybe_ref_id != *var_ref_id { + // If the reference declaration ID does not match, we cannot narrow it + return Ok(ResultTypeOrContinue::Continue); + } + + let right_expr_type = infer_expr(db, cache, right_expr)?; + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = + get_type_at_flow(db, tree, cache, root, &var_ref_id, antecedent_flow_id)?; + + let result_type = match condition_flow { + InferConditionFlow::TrueCondition => { + narrow_down_type(db, antecedent_type, right_expr_type.clone()) + .unwrap_or(right_expr_type) + } + InferConditionFlow::FalseCondition => { + TypeOps::Remove.apply(db, &antecedent_type, &right_expr_type) + } + }; + Ok(ResultTypeOrContinue::Result(result_type)) + } + _ => { + // If the left expression is not a name or call expression, we cannot narrow it + Ok(ResultTypeOrContinue::Continue) + } + } +} diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/call_flow.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/call_flow.rs new file mode 100644 index 000000000..5479ee458 --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/call_flow.rs @@ -0,0 +1,251 @@ +use std::ops::Deref; + +use emmylua_parser::{LuaCallExpr, LuaChunk, LuaExpr}; + +use crate::{ + infer_expr, + semantic::infer::{ + narrow::{ + condition_flow::InferConditionFlow, get_single_antecedent, + get_type_at_cast_flow::cast_type, get_type_at_flow::get_type_at_flow, + var_ref_id::get_var_expr_var_ref_id, ResultTypeOrContinue, + }, + VarRefId, + }, + DbIndex, FlowNode, FlowTree, InferFailReason, LuaInferCache, LuaSignatureCast, LuaSignatureId, + LuaType, TypeOps, +}; + +pub fn get_type_at_call_expr( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + call_expr: LuaCallExpr, + condition_flow: InferConditionFlow, +) -> Result { + let Some(prefix_expr) = call_expr.get_prefix_expr() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let maybe_func = infer_expr(db, cache, prefix_expr.clone())?; + match maybe_func { + LuaType::DocFunction(f) => { + let return_type = f.get_ret(); + match return_type { + LuaType::TypeGuard(guard_type) => get_type_at_call_expr_by_type_guard( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + call_expr, + guard_type.deref().clone(), + condition_flow, + ), + _ => { + // If the return type is not a type guard, we cannot infer the type cast. + Ok(ResultTypeOrContinue::Continue) + } + } + } + LuaType::Signature(signature_id) => { + let Some(signature_cast) = db + .get_flow_index() + .get_signature_cast(&cache.get_file_id(), &signature_id) + else { + return Ok(ResultTypeOrContinue::Continue); + }; + + match signature_cast.name.as_str() { + "self" => get_type_at_call_expr_by_signature_self( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + prefix_expr, + signature_cast, + condition_flow, + ), + name => get_type_at_call_expr_by_signature_param_name( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + call_expr, + signature_cast, + signature_id, + name, + condition_flow, + ), + } + } + _ => { + // If the prefix expression is not a function, we cannot infer the type cast. + Ok(ResultTypeOrContinue::Continue) + } + } +} + +fn get_type_at_call_expr_by_type_guard( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + call_expr: LuaCallExpr, + guard_type: LuaType, + condition_flow: InferConditionFlow, +) -> Result { + let Some(arg_list) = call_expr.get_args_list() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(first_arg) = arg_list.get_args().next() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(maybe_ref_id) = get_var_expr_var_ref_id(db, cache, first_arg) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if maybe_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + match condition_flow { + InferConditionFlow::TrueCondition => Ok(ResultTypeOrContinue::Result(guard_type)), + InferConditionFlow::FalseCondition => { + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = + get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + Ok(ResultTypeOrContinue::Result(TypeOps::Remove.apply( + db, + &antecedent_type, + &guard_type, + ))) + } + } +} + +fn get_type_at_call_expr_by_signature_self( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + call_prefix: LuaExpr, + signature_cast: &LuaSignatureCast, + condition_flow: InferConditionFlow, +) -> Result { + let LuaExpr::IndexExpr(call_prefix_index) = call_prefix else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(self_expr) = call_prefix_index.get_prefix_expr() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(name_var_ref_id) = get_var_expr_var_ref_id(db, cache, self_expr) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if name_var_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + + let Some(cast_op_type) = signature_cast.cast.to_node(root) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let result_type = cast_type( + db, + cache.get_file_id(), + cast_op_type, + antecedent_type, + condition_flow, + )?; + Ok(ResultTypeOrContinue::Result(result_type)) +} + +fn get_type_at_call_expr_by_signature_param_name( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + call_expr: LuaCallExpr, + signature_cast: &LuaSignatureCast, + signature_id: LuaSignatureId, + name: &str, + condition_flow: InferConditionFlow, +) -> Result { + let colon_call = call_expr.is_colon_call(); + let Some(arg_list) = call_expr.get_args_list() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(signature) = db.get_signature_index().get(&signature_id) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(mut param_idx) = signature.find_param_idx(name) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let colon_define = signature.is_colon_define; + match (colon_call, colon_define) { + (true, false) => { + if param_idx == 0 { + return Ok(ResultTypeOrContinue::Continue); + } + + param_idx -= 1; + } + (false, true) => { + param_idx += 1; + } + _ => {} + } + + let Some(expr) = arg_list.get_args().nth(param_idx) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(name_var_ref_id) = get_var_expr_var_ref_id(db, cache, expr) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if name_var_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + + let Some(cast_op_type) = signature_cast.cast.to_node(root) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let result_type = cast_type( + db, + cache.get_file_id(), + cast_op_type, + antecedent_type, + condition_flow, + )?; + Ok(ResultTypeOrContinue::Result(result_type)) +} diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/index_flow.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/index_flow.rs new file mode 100644 index 000000000..1a46d762f --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/index_flow.rs @@ -0,0 +1,45 @@ +use emmylua_parser::{LuaChunk, LuaExpr, LuaIndexExpr}; + +use crate::{ + semantic::infer::{ + narrow::{ + condition_flow::InferConditionFlow, get_single_antecedent, + get_type_at_flow::get_type_at_flow, narrow_false_or_nil, remove_false_or_nil, + var_ref_id::get_var_expr_var_ref_id, ResultTypeOrContinue, + }, + VarRefId, + }, + DbIndex, FlowNode, FlowTree, InferFailReason, LuaInferCache, +}; + +#[allow(unused)] +pub fn get_type_at_index_expr( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + index_expr: LuaIndexExpr, + condition_flow: InferConditionFlow, +) -> Result { + let Some(name_var_ref_id) = + get_var_expr_var_ref_id(db, cache, LuaExpr::IndexExpr(index_expr.clone())) + else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if name_var_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + + let result_type = match condition_flow { + InferConditionFlow::FalseCondition => narrow_false_or_nil(db, antecedent_type), + InferConditionFlow::TrueCondition => remove_false_or_nil(antecedent_type), + }; + + Ok(ResultTypeOrContinue::Result(result_type)) +} diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/mod.rs new file mode 100644 index 000000000..c7c7bc390 --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/condition_flow/mod.rs @@ -0,0 +1,198 @@ +mod binary_flow; +mod call_flow; +mod index_flow; + +use emmylua_parser::{LuaChunk, LuaExpr, LuaNameExpr, LuaUnaryExpr, UnaryOperator}; + +use crate::{ + semantic::infer::{ + narrow::{ + condition_flow::{ + binary_flow::get_type_at_binary_expr, call_flow::get_type_at_call_expr, + index_flow::get_type_at_index_expr, + }, + get_single_antecedent, + get_type_at_flow::get_type_at_flow, + narrow_false_or_nil, remove_false_or_nil, + var_ref_id::get_var_expr_var_ref_id, + ResultTypeOrContinue, + }, + VarRefId, + }, + DbIndex, FlowNode, FlowTree, InferFailReason, LuaInferCache, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum InferConditionFlow { + TrueCondition, + FalseCondition, +} + +impl InferConditionFlow { + pub fn get_negated(&self) -> Self { + match self { + InferConditionFlow::TrueCondition => InferConditionFlow::FalseCondition, + InferConditionFlow::FalseCondition => InferConditionFlow::TrueCondition, + } + } + + #[allow(unused)] + pub fn is_true(&self) -> bool { + matches!(self, InferConditionFlow::TrueCondition) + } + + pub fn is_false(&self) -> bool { + matches!(self, InferConditionFlow::FalseCondition) + } +} + +pub fn get_type_at_condition_flow( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + condition: LuaExpr, + condition_flow: InferConditionFlow, +) -> Result { + match condition { + LuaExpr::NameExpr(name_expr) => get_type_at_name_expr( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + name_expr, + condition_flow, + ), + LuaExpr::CallExpr(call_expr) => get_type_at_call_expr( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + call_expr, + condition_flow, + ), + LuaExpr::IndexExpr(index_expr) => get_type_at_index_expr( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + index_expr, + condition_flow, + ), + LuaExpr::TableExpr(_) | LuaExpr::LiteralExpr(_) | LuaExpr::ClosureExpr(_) => { + Ok(ResultTypeOrContinue::Continue) + } + LuaExpr::BinaryExpr(binary_expr) => get_type_at_binary_expr( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + binary_expr, + condition_flow, + ), + LuaExpr::UnaryExpr(unary_expr) => get_type_at_unary_flow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + unary_expr, + condition_flow, + ), + LuaExpr::ParenExpr(paren_expr) => { + let Some(inner_expr) = paren_expr.get_expr() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + get_type_at_condition_flow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + inner_expr, + condition_flow, + ) + } + } +} + +fn get_type_at_name_expr( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + name_expr: LuaNameExpr, + condition_flow: InferConditionFlow, +) -> Result { + let Some(name_var_ref_id) = + get_var_expr_var_ref_id(db, cache, LuaExpr::NameExpr(name_expr.clone())) + else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if name_var_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + + let result_type = match condition_flow { + InferConditionFlow::FalseCondition => narrow_false_or_nil(db, antecedent_type), + InferConditionFlow::TrueCondition => remove_false_or_nil(antecedent_type), + }; + + Ok(ResultTypeOrContinue::Result(result_type)) +} + +fn get_type_at_unary_flow( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + unary_expr: LuaUnaryExpr, + condition_flow: InferConditionFlow, +) -> Result { + let Some(inner_expr) = unary_expr.get_expr() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + let Some(op) = unary_expr.get_op_token() else { + return Ok(ResultTypeOrContinue::Continue); + }; + + match op.get_op() { + UnaryOperator::OpNot => {} + _ => { + return Ok(ResultTypeOrContinue::Continue); + } + } + + get_type_at_condition_flow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + inner_expr, + condition_flow.get_negated(), + ) +} diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_cast_flow.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_cast_flow.rs new file mode 100644 index 000000000..433b0b11c --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_cast_flow.rs @@ -0,0 +1,195 @@ +use emmylua_parser::{ + BinaryOperator, LuaAstNode, LuaCallExpr, LuaChunk, LuaDocOpType, LuaDocTagCast, LuaExpr, +}; + +use crate::{ + semantic::infer::{ + narrow::{ + condition_flow::InferConditionFlow, get_single_antecedent, + get_type_at_flow::get_type_at_flow, var_ref_id::get_var_expr_var_ref_id, + ResultTypeOrContinue, + }, + VarRefId, + }, + DbIndex, FileId, FlowId, FlowNode, FlowNodeKind, FlowTree, InFiled, InferFailReason, + LuaInferCache, LuaType, LuaTypeOwner, TypeOps, +}; + +pub fn get_type_at_cast_flow( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + tag_cast: LuaDocTagCast, +) -> Result { + match tag_cast.get_key_expr() { + Some(expr) => { + get_type_at_cast_expr(db, tree, cache, root, var_ref_id, flow_node, tag_cast, expr) + } + None => get_type_at_inline_cast(db, tree, cache, root, var_ref_id, flow_node, tag_cast), + } +} + +fn get_type_at_cast_expr( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + tag_cast: LuaDocTagCast, + key_expr: LuaExpr, +) -> Result { + let Some(maybe_ref_id) = get_var_expr_var_ref_id(db, cache, key_expr) else { + return Ok(ResultTypeOrContinue::Continue); + }; + + if maybe_ref_id != *var_ref_id { + return Ok(ResultTypeOrContinue::Continue); + } + + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let mut antecedent_type = + get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + for cast_op_type in tag_cast.get_op_types() { + antecedent_type = cast_type( + db, + cache.get_file_id(), + cast_op_type, + antecedent_type, + InferConditionFlow::TrueCondition, + )?; + } + Ok(ResultTypeOrContinue::Result(antecedent_type)) +} + +fn get_type_at_inline_cast( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + tag_cast: LuaDocTagCast, +) -> Result { + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let mut antecedent_type = + get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + for cast_op_type in tag_cast.get_op_types() { + antecedent_type = cast_type( + db, + cache.get_file_id(), + cast_op_type, + antecedent_type, + InferConditionFlow::TrueCondition, + )?; + } + Ok(ResultTypeOrContinue::Result(antecedent_type)) +} + +pub fn get_type_at_call_expr_inline_cast( + db: &DbIndex, + cache: &mut LuaInferCache, + tree: &FlowTree, + call_expr: LuaCallExpr, + flow_id: FlowId, + mut return_type: LuaType, +) -> Option { + let flow_node = tree.get_flow_node(flow_id)?; + let FlowNodeKind::TagCast(tag_cast_ptr) = &flow_node.kind else { + return None; + }; + + let root = LuaChunk::cast(call_expr.get_root())?; + let tag_cast = tag_cast_ptr.to_node(&root)?; + + for cast_op_type in tag_cast.get_op_types() { + return_type = match cast_type( + db, + cache.get_file_id(), + cast_op_type, + return_type, + InferConditionFlow::TrueCondition, + ) { + Ok(typ) => typ, + Err(_) => return None, + }; + } + + Some(return_type) +} + +enum CastAction { + Add, + Remove, + Force, +} + +impl CastAction { + fn get_negative(&self) -> Self { + match self { + CastAction::Add => CastAction::Remove, + CastAction::Remove => CastAction::Add, + CastAction::Force => CastAction::Remove, + } + } +} + +pub fn cast_type( + db: &DbIndex, + file_id: FileId, + cast_op_type: LuaDocOpType, + mut source_type: LuaType, + condition_flow: InferConditionFlow, +) -> Result { + let mut action = match cast_op_type.get_op() { + Some(op) => { + if op.get_op() == BinaryOperator::OpAdd { + CastAction::Add + } else { + CastAction::Remove + } + } + None => CastAction::Force, + }; + + if condition_flow.is_false() { + action = action.get_negative(); + } + + if cast_op_type.is_nullable() { + match action { + CastAction::Add => { + source_type = TypeOps::Union.apply(db, &source_type, &LuaType::Nil); + } + CastAction::Remove => { + source_type = TypeOps::Remove.apply(db, &source_type, &LuaType::Nil); + } + _ => {} + } + } else if let Some(doc_type) = cast_op_type.get_type() { + let type_owner = LuaTypeOwner::SyntaxId(InFiled { + file_id, + value: doc_type.get_syntax_id(), + }); + let typ = match db.get_type_index().get_type_cache(&type_owner) { + Some(type_cache) => type_cache.as_type().clone(), + None => return Ok(source_type), + }; + match action { + CastAction::Add => { + source_type = TypeOps::Union.apply(db, &source_type, &typ); + } + CastAction::Remove => { + source_type = TypeOps::Remove.apply(db, &source_type, &typ); + } + CastAction::Force => { + source_type = typ; + } + } + } + + Ok(source_type) +} diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs new file mode 100644 index 000000000..cf5a5e96e --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs @@ -0,0 +1,288 @@ +use emmylua_parser::{LuaAssignStat, LuaAstNode, LuaCallExpr, LuaChunk, LuaVarExpr}; + +use crate::{ + infer_expr, + semantic::infer::{ + narrow::{ + condition_flow::{get_type_at_condition_flow, InferConditionFlow}, + get_multi_antecedents, get_single_antecedent, + get_type_at_cast_flow::get_type_at_cast_flow, + get_var_ref_type, + narrow_type::{narrow_down_type, remove_false_or_nil}, + var_ref_id::get_var_expr_var_ref_id, + ResultTypeOrContinue, + }, + InferResult, VarRefId, + }, + CacheEntry, DbIndex, FlowId, FlowNode, FlowNodeKind, FlowTree, InferFailReason, LuaDeclId, + LuaInferCache, LuaMemberId, LuaType, TypeOps, +}; + +pub fn get_type_at_flow( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_id: FlowId, +) -> InferResult { + let key = (var_ref_id.clone(), flow_id); + if let Some(cache_entry) = cache.flow_node_cache.get(&key) { + if let CacheEntry::Cache(narrow_type) = cache_entry { + return Ok(narrow_type.clone()); + } + } + + let mut result_type = LuaType::Unknown; + let mut antecedent_flow_id = flow_id; + loop { + let flow_node = tree + .get_flow_node(antecedent_flow_id) + .ok_or(InferFailReason::None)?; + match &flow_node.kind { + FlowNodeKind::Start | FlowNodeKind::Unreachable => { + result_type = get_var_ref_type(db, cache, var_ref_id)?; + break; + } + FlowNodeKind::LoopLabel | FlowNodeKind::Break | FlowNodeKind::Return => { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + FlowNodeKind::BranchLabel | FlowNodeKind::NamedLabel(_) => { + let multi_antecedents = get_multi_antecedents(tree, flow_node)?; + for flow_id in multi_antecedents { + let branch_type = get_type_at_flow(db, tree, cache, root, var_ref_id, flow_id)?; + result_type = TypeOps::Union.apply(db, &result_type, &branch_type); + } + break; + } + FlowNodeKind::DeclPosition(position) => { + if *position <= var_ref_id.get_position() { + result_type = get_var_ref_type(db, cache, var_ref_id)?; + break; + } else { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + } + FlowNodeKind::Assignment(assign_ptr) => { + let assign_stat = assign_ptr.to_node(root).ok_or(InferFailReason::None)?; + let result_or_continue = get_type_at_assign_stat( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + assign_stat, + )?; + + if let ResultTypeOrContinue::Result(assign_type) = result_or_continue { + result_type = assign_type; + break; + } else { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + } + FlowNodeKind::TrueCondition(condition_ptr) => { + let condition = condition_ptr.to_node(root).ok_or(InferFailReason::None)?; + let result_or_continue = get_type_at_condition_flow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + condition, + InferConditionFlow::TrueCondition, + )?; + + if let ResultTypeOrContinue::Result(condition_type) = result_or_continue { + result_type = condition_type; + break; + } else { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + } + FlowNodeKind::FalseCondition(condition_ptr) => { + let condition = condition_ptr.to_node(root).ok_or(InferFailReason::None)?; + let result_or_continue = get_type_at_condition_flow( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + condition, + InferConditionFlow::FalseCondition, + )?; + + if let ResultTypeOrContinue::Result(condition_type) = result_or_continue { + result_type = condition_type; + break; + } else { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + } + FlowNodeKind::ForIStat(_) => { + // todo check for `for i = 1, 10 do end` + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + FlowNodeKind::TagCast(cast_ast_ptr) => { + let tag_cast = cast_ast_ptr.to_node(root).ok_or(InferFailReason::None)?; + let cast_or_continue = + get_type_at_cast_flow(db, tree, cache, root, var_ref_id, flow_node, tag_cast)?; + + if let ResultTypeOrContinue::Result(cast_type) = cast_or_continue { + result_type = cast_type; + break; + } else { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + } + FlowNodeKind::AssertCall(lua_ast_ptr) => { + let assert_call = lua_ast_ptr.to_node(root).ok_or(InferFailReason::None)?; + let result_or_continue = get_type_at_assert_call( + db, + tree, + cache, + root, + var_ref_id, + flow_node, + assert_call, + )?; + + if let ResultTypeOrContinue::Result(assert_type) = result_or_continue { + result_type = assert_type; + break; + } else { + antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + } + } + } + } + + cache + .flow_node_cache + .insert(key, CacheEntry::Cache(result_type.clone())); + Ok(result_type) +} + +fn get_type_at_assign_stat( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + assign_stat: LuaAssignStat, +) -> Result { + let (vars, exprs) = assign_stat.get_var_and_expr_list(); + for i in 0..vars.len() { + let var = vars[i].clone(); + let Some(maybe_ref_id) = get_var_expr_var_ref_id(db, cache, var.to_expr()) else { + continue; + }; + + if maybe_ref_id != *var_ref_id { + // let typ = get_var_ref_type(db, cache, var_ref_id)?; + continue; + } + + // maybe use type force type + let var_type = match var { + LuaVarExpr::NameExpr(name_expr) => { + let decl_id = LuaDeclId::new(cache.get_file_id(), name_expr.get_position()); + let type_cache = db.get_type_index().get_type_cache(&decl_id.into()); + if let Some(typ_cache) = type_cache { + Some(typ_cache.as_type().clone()) + } else { + None + } + } + LuaVarExpr::IndexExpr(index_expr) => { + let member_id = LuaMemberId::new(index_expr.get_syntax_id(), cache.get_file_id()); + let type_cache = db.get_type_index().get_type_cache(&member_id.into()); + if let Some(typ_cache) = type_cache { + Some(typ_cache.as_type().clone()) + } else { + None + } + } + }; + + if let Some(var_type) = var_type { + return Ok(ResultTypeOrContinue::Result(var_type)); + } + + // infer from expr + let expr_type = match exprs.get(i) { + Some(expr) => { + let expr_type = infer_expr(db, cache, expr.clone())?; + match &expr_type { + LuaType::Variadic(variadic) => match variadic.get_type(0) { + Some(typ) => typ.clone(), + None => return Ok(ResultTypeOrContinue::Continue), + }, + _ => expr_type, + } + } + None => { + let expr_len = exprs.len(); + if expr_len == 0 { + return Ok(ResultTypeOrContinue::Continue); + } + + let last_expr = exprs[expr_len - 1].clone(); + let last_expr_type = infer_expr(db, cache, last_expr)?; + if let LuaType::Variadic(variadic) = last_expr_type { + let idx = i - expr_len + 1; + match variadic.get_type(idx) { + Some(typ) => typ.clone(), + None => return Ok(ResultTypeOrContinue::Continue), + } + } else { + return Ok(ResultTypeOrContinue::Continue); + } + } + }; + + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = + get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + + return Ok(ResultTypeOrContinue::Result( + narrow_down_type(db, antecedent_type, expr_type.clone()).unwrap_or(expr_type), + )); + } + + Ok(ResultTypeOrContinue::Continue) +} + +fn get_type_at_assert_call( + db: &DbIndex, + tree: &FlowTree, + cache: &mut LuaInferCache, + root: &LuaChunk, + var_ref_id: &VarRefId, + flow_node: &FlowNode, + assert_call: LuaCallExpr, +) -> Result { + let call_arg_list = match assert_call.get_args_list() { + Some(args) => args, + None => return Ok(ResultTypeOrContinue::Continue), + }; + + for arg in call_arg_list.get_args() { + if let Some(ref_decl_id) = get_var_expr_var_ref_id(db, cache, arg.clone()) { + if ref_decl_id == *var_ref_id { + let antecedent_flow_id = get_single_antecedent(tree, flow_node)?; + let antecedent_type = + get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?; + let result_type = remove_false_or_nil(antecedent_type); + + return Ok(ResultTypeOrContinue::Result(result_type)); + } + } + } + + Ok(ResultTypeOrContinue::Continue) +} diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/mod.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/mod.rs new file mode 100644 index 000000000..0d691936b --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/mod.rs @@ -0,0 +1,115 @@ +mod condition_flow; +mod get_type_at_cast_flow; +mod get_type_at_flow; +mod narrow_type; +mod var_ref_id; + +use crate::{ + infer_param, + semantic::infer::{ + infer_name::{find_decl_member_type, infer_global_type}, + InferResult, + }, + CacheEntry, DbIndex, FlowAntecedent, FlowId, FlowNode, FlowTree, InferFailReason, + LuaInferCache, LuaType, +}; +use emmylua_parser::{LuaAstNode, LuaChunk, LuaExpr}; +pub use get_type_at_cast_flow::get_type_at_call_expr_inline_cast; +pub use narrow_type::{narrow_down_type, narrow_false_or_nil, remove_false_or_nil}; +pub use var_ref_id::VarRefId; + +pub fn infer_expr_narrow_type( + db: &DbIndex, + cache: &mut LuaInferCache, + expr: LuaExpr, + var_ref_id: VarRefId, +) -> InferResult { + let file_id = cache.get_file_id(); + let Some(flow_tree) = db.get_flow_index().get_flow_tree(&file_id) else { + return get_var_ref_type(db, cache, &var_ref_id); + }; + + let Some(flow_id) = flow_tree.get_flow_id(expr.get_syntax_id()) else { + return get_var_ref_type(db, cache, &var_ref_id); + }; + + let root = LuaChunk::cast(expr.get_root()).ok_or(InferFailReason::None)?; + get_type_at_flow::get_type_at_flow(db, flow_tree, cache, &root, &var_ref_id, flow_id) +} + +fn get_var_ref_type(db: &DbIndex, cache: &mut LuaInferCache, var_ref_id: &VarRefId) -> InferResult { + if let Some(decl_id) = var_ref_id.get_decl_id_ref() { + let decl = db + .get_decl_index() + .get_decl(&decl_id) + .ok_or(InferFailReason::None)?; + + if decl.is_global() { + let name = decl.get_name(); + return infer_global_type(db, name); + } + + if let Some(type_cache) = db.get_type_index().get_type_cache(&decl.get_id().into()) { + return Ok(type_cache.as_type().clone()); + } + + if decl.is_param() { + return infer_param(db, decl); + } + + Err(InferFailReason::UnResolveDeclType(decl.get_id())) + } else if let Some(member_id) = var_ref_id.get_member_id_ref() { + find_decl_member_type(db, member_id) + } else { + if let Some(type_cache) = cache.index_ref_origin_type_cache.get(&var_ref_id) { + match type_cache { + CacheEntry::Cache(ty) => return Ok(ty.clone()), + _ => {} + } + } + + Err(InferFailReason::None) + } +} + +fn get_single_antecedent(tree: &FlowTree, flow: &FlowNode) -> Result { + match &flow.antecedent { + Some(antecedent) => match antecedent { + FlowAntecedent::Single(id) => Ok(*id), + FlowAntecedent::Multiple(multi_id) => { + let multi_flow = tree + .get_multi_antecedents(*multi_id) + .ok_or(InferFailReason::None)?; + if multi_flow.len() > 0 { + // If there are multiple antecedents, we need to handle them separately + // For now, we just return the first one + Ok(multi_flow[0]) + } else { + Err(InferFailReason::None) + } + } + }, + None => Err(InferFailReason::None), + } +} + +fn get_multi_antecedents(tree: &FlowTree, flow: &FlowNode) -> Result, InferFailReason> { + match &flow.antecedent { + Some(antecedent) => match antecedent { + FlowAntecedent::Single(id) => Ok(vec![*id]), + FlowAntecedent::Multiple(multi_id) => { + let multi_flow = tree + .get_multi_antecedents(*multi_id) + .ok_or(InferFailReason::None)?; + Ok(multi_flow.to_vec()) + } + }, + None => Err(InferFailReason::None), + } +} + +#[derive(Debug)] +pub enum ResultTypeOrContinue { + Result(LuaType), + Continue, +} diff --git a/crates/emmylua_code_analysis/src/db_index/type/type_ops/false_or_nil_type.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/narrow_type/false_or_nil_type.rs similarity index 87% rename from crates/emmylua_code_analysis/src/db_index/type/type_ops/false_or_nil_type.rs rename to crates/emmylua_code_analysis/src/semantic/infer/narrow/narrow_type/false_or_nil_type.rs index 25ee5aea3..0eda59030 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/type_ops/false_or_nil_type.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/narrow_type/false_or_nil_type.rs @@ -1,13 +1,13 @@ -use crate::{DbIndex, LuaType, LuaUnionType}; - -use super::TypeOps; +use crate::{ + semantic::infer::narrow::narrow_type::narrow_down_type, DbIndex, LuaType, LuaUnionType, +}; pub fn narrow_false_or_nil(db: &DbIndex, t: LuaType) -> LuaType { if t.is_boolean() { return LuaType::BooleanConst(false); } - return TypeOps::Narrow.apply(db, &t, &LuaType::Nil); + return narrow_down_type(db, t.clone(), LuaType::Nil).unwrap_or(t); } pub fn remove_false_or_nil(t: LuaType) -> LuaType { diff --git a/crates/emmylua_code_analysis/src/db_index/type/type_ops/narrow_type.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/narrow_type/mod.rs similarity index 81% rename from crates/emmylua_code_analysis/src/db_index/type/type_ops/narrow_type.rs rename to crates/emmylua_code_analysis/src/semantic/infer/narrow/narrow_type/mod.rs index fac7f8a11..a3501bc3d 100644 --- a/crates/emmylua_code_analysis/src/db_index/type/type_ops/narrow_type.rs +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/narrow_type/mod.rs @@ -1,6 +1,9 @@ -use crate::{DbIndex, LuaType, LuaUnionType}; +mod false_or_nil_type; -use super::get_real_type; +use crate::{ + get_real_type, semantic::type_check::is_sub_type_of, DbIndex, LuaType, LuaUnionType, TypeOps, +}; +pub use false_or_nil_type::{narrow_false_or_nil, remove_false_or_nil}; // need to be optimized pub fn narrow_down_type(db: &DbIndex, source: LuaType, target: LuaType) -> Option { @@ -9,7 +12,6 @@ pub fn narrow_down_type(db: &DbIndex, source: LuaType, target: LuaType) -> Optio } let real_source_ref = get_real_type(db, &source).unwrap_or(&source); - match &target { LuaType::Number => { if real_source_ref.is_number() { @@ -86,7 +88,7 @@ pub fn narrow_down_type(db: &DbIndex, source: LuaType, target: LuaType) -> Optio return Some(source); } } - LuaType::Any => { + LuaType::Any | LuaType::Unknown => { return Some(source); } LuaType::FloatConst(f) => { @@ -139,7 +141,6 @@ pub fn narrow_down_type(db: &DbIndex, source: LuaType, target: LuaType) -> Optio _ => {} }, LuaType::Instance(base) => return narrow_down_type(db, source, base.get_base().clone()), - LuaType::Unknown => return Some(source), LuaType::BooleanConst(_) => { if real_source_ref.is_boolean() { return Some(LuaType::Boolean); @@ -147,21 +148,37 @@ pub fn narrow_down_type(db: &DbIndex, source: LuaType, target: LuaType) -> Optio return Some(LuaType::BooleanConst(true)); } } - _ => { - if target.is_unknown() { - return Some(source); + LuaType::Union(target_u) => { + let source_types = target_u + .get_types() + .into_iter() + .filter_map(|t| narrow_down_type(db, real_source_ref.clone(), t)) + .collect::>(); + let mut result_type = LuaType::Unknown; + for source_type in source_types { + result_type = TypeOps::Union.apply(db, &result_type, &source_type); } - - return Some(target); + return Some(result_type); } + LuaType::Variadic(_) => return Some(source), + LuaType::Def(type_id) | LuaType::Ref(type_id) => match real_source_ref { + LuaType::Def(ref_id) | LuaType::Ref(ref_id) => { + if is_sub_type_of(db, ref_id, type_id) || is_sub_type_of(db, type_id, ref_id) { + return Some(source); + } + } + _ => {} + }, + + _ => {} } match real_source_ref { LuaType::Union(union) => { let mut union_types = union .get_types() - .iter() - .filter_map(|t| narrow_down_type(db, t.clone(), target.clone())) + .into_iter() + .filter_map(|t| narrow_down_type(db, t, target.clone())) .collect::>(); union_types.dedup(); diff --git a/crates/emmylua_code_analysis/src/semantic/infer/narrow/var_ref_id.rs b/crates/emmylua_code_analysis/src/semantic/infer/narrow/var_ref_id.rs new file mode 100644 index 000000000..d4cfc77ab --- /dev/null +++ b/crates/emmylua_code_analysis/src/semantic/infer/narrow/var_ref_id.rs @@ -0,0 +1,64 @@ +use emmylua_parser::{LuaAstNode, LuaExpr}; +use internment::ArcIntern; +use rowan::TextSize; +use smol_str::SmolStr; + +use crate::{ + semantic::infer::{ + infer_index::get_index_expr_var_ref_id, infer_name::get_name_expr_var_ref_id, + }, + DbIndex, LuaDeclId, LuaDeclOrMemberId, LuaInferCache, LuaMemberId, +}; + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum VarRefId { + VarRef(LuaDeclId), + SelfRef(LuaDeclOrMemberId), + IndexRef(LuaDeclOrMemberId, ArcIntern), +} + +impl VarRefId { + pub fn get_decl_id_ref(&self) -> Option { + match self { + VarRefId::VarRef(decl_id) => Some(*decl_id), + VarRefId::SelfRef(decl_or_member_id) => decl_or_member_id.as_decl_id(), + _ => None, + } + } + + pub fn get_member_id_ref(&self) -> Option { + match self { + VarRefId::SelfRef(decl_or_member_id) => decl_or_member_id.as_member_id(), + _ => None, + } + } + + pub fn get_position(&self) -> TextSize { + match self { + VarRefId::VarRef(decl_id) => decl_id.position, + VarRefId::SelfRef(decl_or_member_id) => decl_or_member_id.get_position(), + VarRefId::IndexRef(decl_or_member_id, _) => decl_or_member_id.get_position(), + } + } +} + +pub fn get_var_expr_var_ref_id( + db: &DbIndex, + cache: &mut LuaInferCache, + var_expr: LuaExpr, +) -> Option { + if let Some(var_ref_id) = cache.expr_var_ref_id_cache.get(&var_expr.get_syntax_id()) { + return Some(var_ref_id.clone()); + } + + let ref_id = match &var_expr { + LuaExpr::NameExpr(name_expr) => get_name_expr_var_ref_id(db, cache, name_expr), + LuaExpr::IndexExpr(index_expr) => get_index_expr_var_ref_id(db, cache, index_expr), + _ => None, + }?; + + cache + .expr_var_ref_id_cache + .insert(var_expr.get_syntax_id(), ref_id.clone()); + Some(ref_id) +} diff --git a/crates/emmylua_code_analysis/src/semantic/member/find_index.rs b/crates/emmylua_code_analysis/src/semantic/member/find_index.rs index 9ec3f518b..c6234aa58 100644 --- a/crates/emmylua_code_analysis/src/semantic/member/find_index.rs +++ b/crates/emmylua_code_analysis/src/semantic/member/find_index.rs @@ -222,7 +222,7 @@ fn find_index_union( let mut members = Vec::new(); for member in union.get_types() { - if let Some(sub_members) = find_index_operations_guard(db, member, infer_guard) { + if let Some(sub_members) = find_index_operations_guard(db, &member, infer_guard) { members.extend(sub_members); } } diff --git a/crates/emmylua_code_analysis/src/semantic/mod.rs b/crates/emmylua_code_analysis/src/semantic/mod.rs index 49101b655..ff9497732 100644 --- a/crates/emmylua_code_analysis/src/semantic/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/mod.rs @@ -13,7 +13,7 @@ use std::cell::RefCell; use std::collections::HashMap; use std::{collections::HashSet, sync::Arc}; -pub use cache::{CacheEntry, CacheKey, CacheOptions, LuaAnalysisPhase, LuaInferCache}; +pub use cache::{CacheEntry, CacheOptions, LuaAnalysisPhase, LuaInferCache}; pub use decl::enum_variable_is_param; use emmylua_parser::{ LuaCallExpr, LuaChunk, LuaExpr, LuaIndexKey, LuaParseError, LuaSyntaxNode, LuaSyntaxToken, diff --git a/crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs b/crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs index 852e7b874..14d2e7f75 100644 --- a/crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs +++ b/crates/emmylua_code_analysis/src/semantic/semantic_info/infer_expr_semantic_decl.rs @@ -327,7 +327,7 @@ fn infer_union_member_semantic_info( if let Some(property_owner_id) = infer_member_semantic_decl_by_member_key( db, cache, - typ, + &typ, member_key, semantic_guard.next_level()?, ) { diff --git a/crates/emmylua_code_analysis/src/semantic/semantic_info/mod.rs b/crates/emmylua_code_analysis/src/semantic/semantic_info/mod.rs index d56511ed6..b4251608b 100644 --- a/crates/emmylua_code_analysis/src/semantic/semantic_info/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/semantic_info/mod.rs @@ -10,9 +10,9 @@ use emmylua_parser::{ LuaAstNode, LuaAstToken, LuaDocNameType, LuaDocTag, LuaExpr, LuaLocalName, LuaSyntaxKind, LuaSyntaxNode, LuaSyntaxToken, LuaTableField, }; -use infer_expr_semantic_decl::infer_expr_semantic_decl; +pub use infer_expr_semantic_decl::infer_expr_semantic_decl; pub use semantic_decl_level::SemanticDeclLevel; -use semantic_guard::SemanticDeclGuard; +pub use semantic_guard::SemanticDeclGuard; use super::{infer_expr, LuaInferCache}; diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs b/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs index 841303fda..b0a67b232 100644 --- a/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs +++ b/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs @@ -67,7 +67,7 @@ pub fn check_complex_type_compact( for sub_type in union_type.get_types() { match check_general_type_compact( db, - sub_type, + &sub_type, compact_type, check_guard.next_level()?, ) { @@ -100,7 +100,7 @@ pub fn check_complex_type_compact( // Do I need to check union types? if let LuaType::Union(union) = compact_type { for sub_compact in union.get_types() { - match check_complex_type_compact(db, source, sub_compact, check_guard.next_level()?) { + match check_complex_type_compact(db, source, &sub_compact, check_guard.next_level()?) { Ok(_) => {} Err(e) => return Err(e), } @@ -121,7 +121,7 @@ fn check_union_type_compact_union( ) -> TypeCheckResult { let compact_types = compact_union.get_types(); for compact_sub_type in compact_types { - check_general_type_compact(db, source, compact_sub_type, check_guard.next_level()?)?; + check_general_type_compact(db, source, &compact_sub_type, check_guard.next_level()?)?; } Ok(()) diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/table_generic_check.rs b/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/table_generic_check.rs index 5b0f7b617..7ddc47de9 100644 --- a/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/table_generic_check.rs +++ b/crates/emmylua_code_analysis/src/semantic/type_check/complex_type/table_generic_check.rs @@ -76,7 +76,7 @@ pub fn check_table_generic_type_compact( check_table_generic_type_compact( db, source_generic_param, - union_type, + &union_type, check_guard, )?; } diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs b/crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs index 7cdc1a591..d2b4aa735 100644 --- a/crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs +++ b/crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs @@ -31,7 +31,7 @@ pub fn check_doc_func_type_compact( check_doc_func_type_compact( db, source_func, - union_type, + &union_type, check_guard.next_level()?, )?; } diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/ref_type.rs b/crates/emmylua_code_analysis/src/semantic/type_check/ref_type.rs index 9b7abb2a1..acae2749f 100644 --- a/crates/emmylua_code_analysis/src/semantic/type_check/ref_type.rs +++ b/crates/emmylua_code_analysis/src/semantic/type_check/ref_type.rs @@ -138,7 +138,7 @@ fn check_ref_class( check_general_type_compact( db, &source, - field, + &field, check_guard.next_level()?, )?; } @@ -164,7 +164,7 @@ fn check_ref_class( check_general_type_compact( db, &LuaType::Ref(source_id.clone()), - typ, + &typ, check_guard.next_level()?, )?; } diff --git a/crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs b/crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs index 5647e4f4b..da6ee150f 100644 --- a/crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs +++ b/crates/emmylua_code_analysis/src/semantic/type_check/simple_type.rs @@ -220,7 +220,7 @@ pub fn check_simple_type_compact( if let LuaType::Union(union) = compact_type { for sub_compact in union.get_types() { - match check_simple_type_compact(db, source, sub_compact, check_guard.next_level()?) { + match check_simple_type_compact(db, source, &sub_compact, check_guard.next_level()?) { Ok(_) => {} Err(err) => return Err(err), } @@ -318,7 +318,7 @@ fn check_enum_fields_match_source( if let Some(decl) = db.get_type_index().get_type_decl(enum_type_decl_id) { if let Some(LuaType::Union(enum_fields)) = decl.get_enum_field_type(db) { for field in enum_fields.get_types() { - check_general_type_compact(db, source, field, check_guard.next_level()?)?; + check_general_type_compact(db, source, &field, check_guard.next_level()?)?; } return Ok(()); diff --git a/crates/emmylua_ls/src/handlers/completion/providers/env_provider.rs b/crates/emmylua_ls/src/handlers/completion/providers/env_provider.rs index 70f3d5e4b..387eb303c 100644 --- a/crates/emmylua_ls/src/handlers/completion/providers/env_provider.rs +++ b/crates/emmylua_ls/src/handlers/completion/providers/env_provider.rs @@ -1,6 +1,6 @@ use std::collections::HashSet; -use emmylua_code_analysis::{LuaFlowId, LuaSignatureId, LuaType, LuaVarRefId}; +use emmylua_code_analysis::{LuaSignatureId, LuaType}; use emmylua_parser::{ LuaAst, LuaAstNode, LuaCallArgList, LuaClosureExpr, LuaParamList, LuaTokenKind, }; @@ -109,7 +109,7 @@ fn add_self( fn add_local_env( builder: &mut CompletionBuilder, duplicated_name: &mut HashSet, - node: &LuaAst, + _: &LuaAst, ) -> Option<()> { let file_id = builder.semantic_model.get_file_id(); let decl_tree = builder @@ -123,7 +123,7 @@ fn add_local_env( for decl_id in local_env.iter() { // 获取变量名和类型 - let (name, mut typ) = { + let (name, typ) = { let decl = builder .semantic_model .get_db() @@ -150,25 +150,25 @@ fn add_local_env( continue; } - let flow_id = LuaFlowId::from_node(node.syntax()); - let var_ref_id = LuaVarRefId::DeclId(*decl_id); - // 类型缩窄 - if let Some(chain) = builder - .semantic_model - .get_db() - .get_flow_index() - .get_flow_chain(file_id, var_ref_id) - { - let semantic_model = &builder.semantic_model; - let db = semantic_model.get_db(); - let root = semantic_model.get_root().syntax(); - let config = semantic_model.get_config(); - for type_assert in chain.get_type_asserts(node.get_position(), flow_id) { - typ = type_assert - .tighten_type(db, &mut config.borrow_mut(), root, typ) - .unwrap_or(LuaType::Unknown); - } - } + // let flow_id = LuaClosureId::from_node(node.syntax()); + // let var_ref_id = LuaVarRefId::DeclId(*decl_id); + // // 类型缩窄 + // if let Some(chain) = builder + // .semantic_model + // .get_db() + // .get_flow_index() + // .get_flow_chain(file_id, var_ref_id) + // { + // let semantic_model = &builder.semantic_model; + // let db = semantic_model.get_db(); + // let root = semantic_model.get_root().syntax(); + // let config = semantic_model.get_config(); + // for type_assert in chain.get_type_asserts(node.get_position(), flow_id) { + // typ = type_assert + // .tighten_type(db, &mut config.borrow_mut(), root, typ) + // .unwrap_or(LuaType::Unknown); + // } + // } duplicated_name.insert(name.clone()); add_decl_completion(builder, decl_id.clone(), &name, &typ); diff --git a/crates/emmylua_ls/src/handlers/completion/providers/function_provider.rs b/crates/emmylua_ls/src/handlers/completion/providers/function_provider.rs index 5bda5088f..ab1e19e6f 100644 --- a/crates/emmylua_ls/src/handlers/completion/providers/function_provider.rs +++ b/crates/emmylua_ls/src/handlers/completion/providers/function_provider.rs @@ -182,7 +182,7 @@ fn add_union_member_completion( ) -> Option<()> { for union_sub_typ in union_typ.get_types() { let name = match union_sub_typ { - LuaType::DocStringConst(s) => to_enum_label(builder, s), + LuaType::DocStringConst(s) => to_enum_label(builder, s.as_str()), LuaType::DocIntegerConst(i) => i.to_string(), _ => { dispatch_type(builder, union_sub_typ.clone(), infer_guard); diff --git a/crates/emmylua_ls/src/handlers/hover/find_origin.rs b/crates/emmylua_ls/src/handlers/hover/find_origin.rs index b716da063..e30c48c74 100644 --- a/crates/emmylua_ls/src/handlers/hover/find_origin.rs +++ b/crates/emmylua_ls/src/handlers/hover/find_origin.rs @@ -269,7 +269,7 @@ pub fn replace_semantic_type( } } _ => { - type_vec.push(origin_type); + type_vec.push(origin_type.clone()); } } if type_vec.len() != semantic_decls.len() { diff --git a/crates/emmylua_ls/src/handlers/hover/function_humanize.rs b/crates/emmylua_ls/src/handlers/hover/function_humanize.rs index 4dc527c8c..b64df1d73 100644 --- a/crates/emmylua_ls/src/handlers/hover/function_humanize.rs +++ b/crates/emmylua_ls/src/handlers/hover/function_humanize.rs @@ -643,7 +643,7 @@ fn process_single_function_type( match process_single_function_type( builder, db, - union_type, + &union_type, function_member, name, is_local, @@ -689,14 +689,14 @@ fn process_single_function_type_with_exclusions( let mut results = Vec::new(); for union_type in union.get_types() { // 跳过已经处理过的类型 - if processed_types.contains(union_type) { + if processed_types.contains(&union_type) { continue; } match process_single_function_type_with_exclusions( builder, db, - union_type, + &union_type, function_member, name, is_local, diff --git a/crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs b/crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs index e7d371826..97eb47111 100644 --- a/crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs +++ b/crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs @@ -84,7 +84,7 @@ pub fn build_label_parts(semantic_model: &SemanticModel, typ: &LuaType) -> Vec { for typ in union.get_types() { - if let Some(part) = get_part(semantic_model, typ) { + if let Some(part) = get_part(semantic_model, &typ) { parts.push(part); } } diff --git a/crates/emmylua_ls/src/handlers/signature_helper/build_signature_helper.rs b/crates/emmylua_ls/src/handlers/signature_helper/build_signature_helper.rs index 3cec89a67..e857dc492 100644 --- a/crates/emmylua_ls/src/handlers/signature_helper/build_signature_helper.rs +++ b/crates/emmylua_ls/src/handlers/signature_helper/build_signature_helper.rs @@ -359,7 +359,7 @@ fn build_table_call_signature_help( fn build_union_type_signature_help( builder: &SignatureHelperBuilder, - union_types: &[LuaType], + union_types: Vec, colon_call: bool, current_idx: usize, ) -> Option { @@ -378,7 +378,7 @@ fn build_union_type_signature_help( LuaType::Signature(signature_id) => { let sig = build_sig_id_signature_help( builder, - *signature_id, + signature_id, colon_call, current_idx, false, diff --git a/crates/emmylua_ls/src/handlers/test/hover_test.rs b/crates/emmylua_ls/src/handlers/test/hover_test.rs index 7cd08662c..bf585bbf0 100644 --- a/crates/emmylua_ls/src/handlers/test/hover_test.rs +++ b/crates/emmylua_ls/src/handlers/test/hover_test.rs @@ -23,23 +23,23 @@ mod tests { #[test] fn test_right_to_left() { let mut ws = ProviderVirtualWorkspace::new(); - assert!(ws.check_hover( - r#" - ---@class H4 - local m = { - x = 1 - } - - ---@type H4 - local m1 - - m1.x = {} - m1.x = {} - "#, - VirtualHoverResult { - value: "```lua\n(field) x: integer = 1\n```".to_string(), - }, - )); + // assert!(ws.check_hover( + // r#" + // ---@class H4 + // local m = { + // x = 1 + // } + + // ---@type H4 + // local m1 + + // m1.x = {} + // m1.x = {} + // "#, + // VirtualHoverResult { + // value: "```lua\n(field) x: integer = 1\n```".to_string(), + // }, + // )); assert!(ws.check_hover( r#" diff --git a/crates/emmylua_parser/src/syntax/mod.rs b/crates/emmylua_parser/src/syntax/mod.rs index 97807b61c..b65e0398c 100644 --- a/crates/emmylua_parser/src/syntax/mod.rs +++ b/crates/emmylua_parser/src/syntax/mod.rs @@ -6,6 +6,7 @@ use serde::de::{self, Visitor}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::fmt; use std::iter::successors; +use std::marker::PhantomData; use rowan::{Language, TextRange, TextSize}; @@ -219,3 +220,34 @@ impl<'de> Deserialize<'de> for LuaSyntaxId { deserializer.deserialize_str(LuaSyntaxIdVisitor) } } + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct LuaAstPtr { + pub syntax_id: LuaSyntaxId, + _phantom: PhantomData, +} + +impl LuaAstPtr { + pub fn new(node: &T) -> Self { + LuaAstPtr { + syntax_id: node.get_syntax_id(), + _phantom: PhantomData, + } + } + + pub fn get_syntax_id(&self) -> LuaSyntaxId { + self.syntax_id + } + + pub fn to_node(&self, root: &LuaChunk) -> Option { + let syntax_node = self.syntax_id.to_node_from_root(root.syntax()); + if let Some(node) = syntax_node { + T::cast(node) + } else { + None + } + } +} + +unsafe impl Send for LuaAstPtr {} +unsafe impl Sync for LuaAstPtr {} diff --git a/crates/emmylua_parser/src/syntax/node/lua/expr.rs b/crates/emmylua_parser/src/syntax/node/lua/expr.rs index ecd38aa7c..6b93b3322 100644 --- a/crates/emmylua_parser/src/syntax/node/lua/expr.rs +++ b/crates/emmylua_parser/src/syntax/node/lua/expr.rs @@ -129,6 +129,15 @@ impl LuaAstNode for LuaVarExpr { } } +impl LuaVarExpr { + pub fn to_expr(&self) -> LuaExpr { + match self { + LuaVarExpr::NameExpr(node) => LuaExpr::NameExpr(node.clone()), + LuaVarExpr::IndexExpr(node) => LuaExpr::IndexExpr(node.clone()), + } + } +} + impl From for LuaExpr { fn from(expr: LuaVarExpr) -> Self { match expr { diff --git a/crates/emmylua_parser/src/syntax/traits/mod.rs b/crates/emmylua_parser/src/syntax/traits/mod.rs index 0b7bdfee8..9975069b4 100644 --- a/crates/emmylua_parser/src/syntax/traits/mod.rs +++ b/crates/emmylua_parser/src/syntax/traits/mod.rs @@ -5,7 +5,10 @@ use std::marker::PhantomData; use rowan::{TextRange, TextSize, WalkEvent}; -use crate::kind::{LuaSyntaxKind, LuaTokenKind}; +use crate::{ + kind::{LuaSyntaxKind, LuaTokenKind}, + LuaAstPtr, +}; use super::LuaSyntaxId; pub use super::{ @@ -94,9 +97,20 @@ pub trait LuaAstNode { LuaSyntaxId::from_node(self.syntax()) } + fn get_text(&self) -> String { + format!("{}", self.syntax().text()) + } + fn dump(&self) -> String { format!("{:#?}", self.syntax()) } + + fn to_ptr(&self) -> LuaAstPtr + where + Self: Sized, + { + LuaAstPtr::new(&self) + } } /// An iterator over `SyntaxNode` children of a particular AST type.