Skip to content

Commit 9d28141

Browse files
CppCXYCppCXY
committed
refactor-flow
1 parent c7b0301 commit 9d28141

34 files changed

Lines changed: 1325 additions & 2288 deletions

File tree

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

Lines changed: 58 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -6,15 +6,13 @@ use emmylua_parser::{
66
};
77

88
use crate::{
9-
compilation::analyzer::{
10-
bind_type::bind_type, flow::CastAction, unresolve::UnResolveModuleRef,
11-
},
9+
compilation::analyzer::{bind_type::bind_type, unresolve::UnResolveModuleRef},
1210
db_index::{
1311
LuaDeclId, LuaDocParamInfo, LuaDocReturnInfo, LuaMemberId, LuaOperator, LuaSemanticDeclId,
1412
LuaSignatureId, LuaType,
1513
},
16-
InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, OperatorFunction,
17-
SignatureReturnStatus, TypeAssertion, TypeOps,
14+
InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, LuaTypeOwner, OperatorFunction,
15+
SignatureReturnStatus, TypeOps,
1816
};
1917

2018
use super::{
@@ -188,6 +186,13 @@ pub fn analyze_return(analyzer: &mut DocAnalyzer, tag: LuaDocTagReturn) -> Optio
188186
Some(())
189187
}
190188

189+
enum CastAction {
190+
Add,
191+
Remove,
192+
Force,
193+
}
194+
195+
#[allow(unused)]
191196
pub fn analyze_return_cast(analyzer: &mut DocAnalyzer, tag: LuaDocTagReturnCast) -> Option<()> {
192197
if let Some(LuaSemanticDeclId::Signature(signature_id)) = get_owner_id(analyzer) {
193198
let name_token = tag.get_name_token()?;
@@ -205,48 +210,48 @@ pub fn analyze_return_cast(analyzer: &mut DocAnalyzer, tag: LuaDocTagReturnCast)
205210
};
206211

207212
if cast_op_type.is_nullable() {
208-
match action {
209-
CastAction::Add => {
210-
analyzer.db.get_flow_index_mut().add_call_cast(
211-
signature_id,
212-
name,
213-
TypeAssertion::Add(LuaType::Nil),
214-
);
215-
}
216-
CastAction::Remove => {
217-
analyzer.db.get_flow_index_mut().add_call_cast(
218-
signature_id,
219-
name,
220-
TypeAssertion::Remove(LuaType::Nil),
221-
);
222-
}
223-
_ => {}
224-
}
225-
} else if let Some(doc_type) = cast_op_type.get_type() {
226-
let typ = infer_type(analyzer, doc_type.clone());
227-
match action {
228-
CastAction::Add => {
229-
analyzer.db.get_flow_index_mut().add_call_cast(
230-
signature_id,
231-
name,
232-
TypeAssertion::Add(typ),
233-
);
234-
}
235-
CastAction::Remove => {
236-
analyzer.db.get_flow_index_mut().add_call_cast(
237-
signature_id,
238-
name,
239-
TypeAssertion::Remove(typ),
240-
);
241-
}
242-
CastAction::Force => {
243-
analyzer.db.get_flow_index_mut().add_call_cast(
244-
signature_id,
245-
name,
246-
TypeAssertion::Force(typ),
247-
);
248-
}
249-
}
213+
// match action {
214+
// CastAction::Add => {
215+
// analyzer.db.get_flow_index_mut().add_call_cast(
216+
// signature_id,
217+
// name,
218+
// TypeAssertion::Add(LuaType::Nil),
219+
// );
220+
// }
221+
// CastAction::Remove => {
222+
// analyzer.db.get_flow_index_mut().add_call_cast(
223+
// signature_id,
224+
// name,
225+
// TypeAssertion::Remove(LuaType::Nil),
226+
// );
227+
// }
228+
// _ => {}
229+
// }
230+
// } else if let Some(doc_type) = cast_op_type.get_type() {
231+
// let typ = infer_type(analyzer, doc_type.clone());
232+
// match action {
233+
// CastAction::Add => {
234+
// analyzer.db.get_flow_index_mut().add_call_cast(
235+
// signature_id,
236+
// name,
237+
// TypeAssertion::Add(typ),
238+
// );
239+
// }
240+
// CastAction::Remove => {
241+
// analyzer.db.get_flow_index_mut().add_call_cast(
242+
// signature_id,
243+
// name,
244+
// TypeAssertion::Remove(typ),
245+
// );
246+
// }
247+
// CastAction::Force => {
248+
// analyzer.db.get_flow_index_mut().add_call_cast(
249+
// signature_id,
250+
// name,
251+
// TypeAssertion::Force(typ),
252+
// );
253+
// }
254+
// }
250255
}
251256
}
252257

@@ -354,13 +359,12 @@ pub fn analyze_cast(analyzer: &mut DocAnalyzer, tag: LuaDocTagCast) -> Option<()
354359
for op in tag.get_op_types() {
355360
if let Some(doc_type) = op.get_type() {
356361
let typ = infer_type(analyzer, doc_type.clone());
357-
analyzer.context.cast_flow.insert(
358-
InFiled {
359-
file_id: analyzer.file_id,
360-
value: doc_type.get_syntax_id(),
361-
},
362-
typ,
363-
);
362+
let type_owner =
363+
LuaTypeOwner::SyntaxId(InFiled::new(analyzer.file_id, doc_type.get_syntax_id()));
364+
analyzer
365+
.db
366+
.get_type_index_mut()
367+
.bind_type(type_owner, LuaTypeCache::DocType(typ));
364368
}
365369
}
366370
Some(())

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

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
use emmylua_parser::{LuaAstNode, LuaComment, LuaDocTag};
2+
3+
use crate::{compilation::analyzer::flow::binder::FlowBinder, FlowId, FlowNodeKind};
4+
5+
pub fn bind_comment(binder: &mut FlowBinder, lua_comment: LuaComment, current: FlowId) -> FlowId {
6+
let cast_tags = lua_comment.get_doc_tags().filter_map(|it| match it {
7+
LuaDocTag::Cast(cast) => Some(cast),
8+
_ => None,
9+
});
10+
11+
let mut parent = current;
12+
for cast in cast_tags {
13+
let flow_id = binder.create_node(FlowNodeKind::TagCast(cast.to_ptr()));
14+
binder.add_antecedent(flow_id, parent);
15+
parent = flow_id;
16+
}
17+
18+
parent
19+
}

‎crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_binary_expr.rs‎

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
use emmylua_parser::{BinaryOperator, LuaAst, LuaBinaryExpr, LuaExpr};
2+
3+
use crate::{
4+
compilation::analyzer::flow::{
5+
bind_analyze::{bind_each_child, exprs::bind_condition_expr, finish_flow_label},
6+
binder::FlowBinder,
7+
},
8+
FlowId,
9+
};
10+
11+
pub fn bind_binary_expr(
12+
binder: &mut FlowBinder,
13+
binary_expr: LuaBinaryExpr,
14+
current: FlowId,
15+
) -> Option<()> {
16+
let op_token = binary_expr.get_op_token()?;
17+
18+
match op_token.get_op() {
19+
BinaryOperator::OpAnd => bind_and_expr(binder, binary_expr, current),
20+
BinaryOperator::OpOr => bind_or_expr(binder, binary_expr, current),
21+
_ => {
22+
bind_each_child(binder, LuaAst::LuaBinaryExpr(binary_expr.clone()), current);
23+
Some(())
24+
}
25+
}
26+
}
27+
28+
fn bind_and_expr(
29+
binder: &mut FlowBinder,
30+
binary_expr: LuaBinaryExpr,
31+
current: FlowId,
32+
) -> Option<()> {
33+
let (left, right) = binary_expr.get_exprs()?;
34+
35+
let pre_right = binder.create_branch_label();
36+
bind_condition_expr(binder, left, current, pre_right, binder.false_target);
37+
let current = finish_flow_label(binder, pre_right, current);
38+
bind_condition_expr(
39+
binder,
40+
right,
41+
current,
42+
binder.true_target,
43+
binder.false_target,
44+
);
45+
46+
Some(())
47+
}
48+
49+
fn bind_or_expr(
50+
binder: &mut FlowBinder,
51+
binary_expr: LuaBinaryExpr,
52+
current: FlowId,
53+
) -> Option<()> {
54+
let (left, right) = binary_expr.get_exprs()?;
55+
let pre_right = binder.create_branch_label();
56+
bind_condition_expr(binder, left, current, binder.true_target, pre_right);
57+
let current = finish_flow_label(binder, pre_right, current);
58+
bind_condition_expr(
59+
binder,
60+
right,
61+
current,
62+
binder.true_target,
63+
binder.false_target,
64+
);
65+
Some(())
66+
}
67+
68+
pub fn is_binary_logical(expr: &LuaExpr) -> bool {
69+
if let LuaExpr::BinaryExpr(binary_expr) = expr {
70+
let Some(op_token) = binary_expr.get_op_token() else {
71+
return false;
72+
};
73+
74+
return match op_token.get_op() {
75+
BinaryOperator::OpAnd | BinaryOperator::OpOr => true,
76+
_ => false,
77+
};
78+
}
79+
80+
false
81+
}

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

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
mod bind_binary_expr;
2+
3+
use emmylua_parser::{
4+
LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaIndexExpr, LuaNameExpr,
5+
LuaTableExpr, LuaUnaryExpr,
6+
};
7+
8+
use crate::{
9+
compilation::analyzer::flow::{
10+
bind_analyze::{bind_each_child, exprs::bind_binary_expr::is_binary_logical},
11+
binder::FlowBinder,
12+
},
13+
FlowId, FlowNodeKind,
14+
};
15+
pub use bind_binary_expr::bind_binary_expr;
16+
17+
pub fn bind_condition_expr(
18+
binder: &mut FlowBinder,
19+
condition_expr: LuaExpr,
20+
current: FlowId,
21+
true_target: FlowId,
22+
false_target: FlowId,
23+
) {
24+
let old_true_target = binder.true_target;
25+
let old_false_target = binder.false_target;
26+
27+
binder.true_target = true_target;
28+
binder.false_target = false_target;
29+
bind_expr(binder, condition_expr.clone(), current);
30+
binder.true_target = old_true_target;
31+
binder.false_target = old_false_target;
32+
33+
if !is_binary_logical(&condition_expr) {
34+
let true_condition =
35+
binder.create_node(FlowNodeKind::TrueCondition(condition_expr.to_ptr()));
36+
binder.add_antecedent(true_condition, current);
37+
binder.add_antecedent(true_target, true_condition);
38+
39+
let false_condition =
40+
binder.create_node(FlowNodeKind::FalseCondition(condition_expr.to_ptr()));
41+
binder.add_antecedent(false_condition, current);
42+
binder.add_antecedent(false_target, false_condition);
43+
}
44+
}
45+
46+
pub fn bind_expr(binder: &mut FlowBinder, expr: LuaExpr, current: FlowId) -> FlowId {
47+
match expr {
48+
LuaExpr::NameExpr(name_expr) => bind_name_expr(binder, name_expr, current),
49+
LuaExpr::CallExpr(call_expr) => bind_call_expr(binder, call_expr, current),
50+
LuaExpr::TableExpr(table_expr) => bind_table_expr(binder, table_expr, current),
51+
LuaExpr::LiteralExpr(_) => Some(()), // Literal expressions do not need binding
52+
LuaExpr::ClosureExpr(closure_expr) => bind_closure_expr(binder, closure_expr, current),
53+
LuaExpr::ParenExpr(paren_expr) => bind_paren_expr(binder, paren_expr, current),
54+
LuaExpr::IndexExpr(index_expr) => bind_index_expr(binder, index_expr, current),
55+
LuaExpr::BinaryExpr(binary_expr) => bind_binary_expr(binder, binary_expr, current),
56+
LuaExpr::UnaryExpr(unary_expr) => bind_unary_expr(binder, unary_expr, current),
57+
};
58+
59+
current
60+
}
61+
62+
pub fn bind_name_expr(
63+
binder: &mut FlowBinder,
64+
name_expr: LuaNameExpr,
65+
current: FlowId,
66+
) -> Option<()> {
67+
binder.bind_syntax_node(name_expr.get_syntax_id(), current);
68+
Some(())
69+
}
70+
71+
pub fn bind_table_expr(
72+
binder: &mut FlowBinder,
73+
table_expr: LuaTableExpr,
74+
current: FlowId,
75+
) -> Option<()> {
76+
bind_each_child(binder, LuaAst::LuaTableExpr(table_expr), current);
77+
Some(())
78+
}
79+
80+
pub fn bind_closure_expr(
81+
binder: &mut FlowBinder,
82+
closure_expr: LuaClosureExpr,
83+
current: FlowId,
84+
) -> Option<()> {
85+
bind_each_child(binder, LuaAst::LuaClosureExpr(closure_expr), current);
86+
Some(())
87+
}
88+
89+
pub fn bind_index_expr(
90+
binder: &mut FlowBinder,
91+
index_expr: LuaIndexExpr,
92+
current: FlowId,
93+
) -> Option<()> {
94+
bind_each_child(binder, LuaAst::LuaIndexExpr(index_expr.clone()), current);
95+
Some(())
96+
}
97+
98+
pub fn bind_paren_expr(
99+
binder: &mut FlowBinder,
100+
paren_expr: emmylua_parser::LuaParenExpr,
101+
current: FlowId,
102+
) -> Option<()> {
103+
let Some(inner_expr) = paren_expr.get_expr() else {
104+
return None;
105+
};
106+
107+
bind_expr(binder, inner_expr, current);
108+
Some(())
109+
}
110+
111+
pub fn bind_unary_expr(
112+
binder: &mut FlowBinder,
113+
unary_expr: LuaUnaryExpr,
114+
current: FlowId,
115+
) -> Option<()> {
116+
let Some(inner_expr) = unary_expr.get_expr() else {
117+
return None;
118+
};
119+
bind_expr(binder, inner_expr, current);
120+
Some(())
121+
}
122+
123+
pub fn bind_call_expr(
124+
binder: &mut FlowBinder,
125+
call_expr: LuaCallExpr,
126+
current: FlowId,
127+
) -> Option<()> {
128+
bind_each_child(binder, LuaAst::LuaCallExpr(call_expr.clone()), current);
129+
Some(())
130+
}

0 commit comments

Comments
 (0)