Skip to content

Commit 3484aa2

Browse files
Tcode-MotionTcode-Motion
authored
Merge pull request #114 from Tcode-Motion/refactor-resolve-statement-13893757812891092637
🧹 [Refactor excessively long function resolve_statement in resolve.rs]
2 parents d6373fb + e4cbbc6 commit 3484aa2

1 file changed

Lines changed: 178 additions & 156 deletions

File tree

‎compiler/semantic/src/passes/resolve.rs‎

Lines changed: 178 additions & 156 deletions
Original file line numberDiff line numberDiff line change
@@ -43,41 +43,8 @@ impl ResolveSymbols {
4343
Statement::ModelDecl(decl) => self.resolve_model_decl(decl, context),
4444
Statement::ExportDecl(decl) => self.resolve_statement(&decl.declaration, context),
4545
Statement::Block(block) => self.resolve_block(block, context),
46-
Statement::If(stmt) => {
47-
let _ = self.resolve_expression(&stmt.condition, context);
48-
let _ = self.resolve_block(&stmt.body, context);
49-
for (cond, body) in &stmt.else_ifs {
50-
let _ = self.resolve_expression(cond, context);
51-
let _ = self.resolve_block(body, context);
52-
}
53-
if let Some(ref else_body) = stmt.else_body {
54-
let _ = self.resolve_block(else_body, context);
55-
}
56-
Ok(())
57-
}
58-
Statement::For(stmt) => {
59-
let _ = self.resolve_expression(&stmt.iterable, context);
60-
context.loop_depth += 1;
61-
context.symbol_table.push_scope();
62-
63-
// Register loop variable
64-
let symbol = Symbol::new(
65-
stmt.item.name.clone(),
66-
false,
67-
false,
68-
false,
69-
context.interner.any(),
70-
);
71-
context
72-
.symbol_table
73-
.register(stmt.item.name.clone(), symbol);
74-
75-
let _ = self.resolve_block(&stmt.body, context);
76-
77-
context.symbol_table.pop_scope();
78-
context.loop_depth -= 1;
79-
Ok(())
80-
}
46+
Statement::If(stmt) => self.resolve_if(stmt, context),
47+
Statement::For(stmt) => self.resolve_for(stmt, context),
8148
Statement::While(stmt) => {
8249
let _ = self.resolve_expression(&stmt.condition, context);
8350
context.loop_depth += 1;
@@ -92,26 +59,7 @@ impl ResolveSymbols {
9259
context.loop_depth -= 1;
9360
Ok(())
9461
}
95-
Statement::Try(stmt) => {
96-
let _ = self.resolve_block(&stmt.body, context);
97-
context.symbol_table.push_scope();
98-
99-
// Register catch variable
100-
let symbol = Symbol::new(
101-
stmt.catch_var.name.clone(),
102-
false,
103-
false,
104-
false,
105-
context.interner.any(),
106-
);
107-
context
108-
.symbol_table
109-
.register(stmt.catch_var.name.clone(), symbol);
110-
111-
let _ = self.resolve_block(&stmt.catch_body, context);
112-
context.symbol_table.pop_scope();
113-
Ok(())
114-
}
62+
Statement::Try(stmt) => self.resolve_try(stmt, context),
11563
Statement::Say(stmt) => {
11664
let _ = self.resolve_expression(&stmt.value, context);
11765
Ok(())
@@ -162,34 +110,153 @@ impl ResolveSymbols {
162110
}
163111
Ok(())
164112
}
165-
Statement::Import(stmt) => {
166-
if stmt.path.is_empty() {
167-
let diag = Diagnostic::new(
168-
DiagnosticLevel::Error,
169-
ErrorCode::E0340,
170-
"Empty module import path".to_string(),
171-
stmt.span,
172-
);
173-
context.diagnostics.push(diag);
174-
return Err(());
175-
}
113+
Statement::Import(stmt) => self.resolve_import(stmt, context),
114+
Statement::Expression(stmt) => {
115+
let _ = self.resolve_expression(&stmt.expression, context);
116+
Ok(())
117+
}
118+
Statement::DSL(stmt) => {
119+
self.resolve_dsl_block(stmt, context);
120+
Ok(())
121+
}
122+
}
123+
}
124+
125+
fn resolve_try(
126+
&self,
127+
stmt: &techscript_ast::TryStmt,
128+
context: &mut SemanticContext,
129+
) -> Result<(), ()> {
130+
let _ = self.resolve_block(&stmt.body, context);
131+
context.symbol_table.push_scope();
132+
133+
// Register catch variable
134+
let symbol = Symbol::new(
135+
stmt.catch_var.name.clone(),
136+
false,
137+
false,
138+
false,
139+
context.interner.any(),
140+
);
141+
context
142+
.symbol_table
143+
.register(stmt.catch_var.name.clone(), symbol);
176144

177-
let path_strs = stmt
178-
.path
179-
.iter()
180-
.map(|ident| ident.name.clone())
181-
.collect::<Vec<_>>();
182-
let resolver = techscript_module_resolver::DefaultModuleResolver::new();
183-
use techscript_module_resolver::ModuleResolver;
184-
match resolver.resolve(&path_strs) {
185-
Ok(_) => {
186-
if let Some(symbols) = &stmt.symbols {
187-
if stmt.path.len() > 1
188-
&& symbols.len() == 1
189-
&& !symbols[0].name.contains(':')
190-
&& symbols[0].name != "*"
191-
{
192-
let alias_name = symbols[0].name.clone();
145+
let _ = self.resolve_block(&stmt.catch_body, context);
146+
context.symbol_table.pop_scope();
147+
Ok(())
148+
}
149+
150+
fn resolve_for(
151+
&self,
152+
stmt: &techscript_ast::ForStmt,
153+
context: &mut SemanticContext,
154+
) -> Result<(), ()> {
155+
let _ = self.resolve_expression(&stmt.iterable, context);
156+
context.loop_depth += 1;
157+
context.symbol_table.push_scope();
158+
159+
// Register loop variable
160+
let symbol = Symbol::new(
161+
stmt.item.name.clone(),
162+
false,
163+
false,
164+
false,
165+
context.interner.any(),
166+
);
167+
context
168+
.symbol_table
169+
.register(stmt.item.name.clone(), symbol);
170+
171+
let _ = self.resolve_block(&stmt.body, context);
172+
173+
context.symbol_table.pop_scope();
174+
context.loop_depth -= 1;
175+
Ok(())
176+
}
177+
178+
fn resolve_if(
179+
&self,
180+
stmt: &techscript_ast::IfStmt,
181+
context: &mut SemanticContext,
182+
) -> Result<(), ()> {
183+
let _ = self.resolve_expression(&stmt.condition, context);
184+
let _ = self.resolve_block(&stmt.body, context);
185+
for (cond, body) in &stmt.else_ifs {
186+
let _ = self.resolve_expression(cond, context);
187+
let _ = self.resolve_block(body, context);
188+
}
189+
if let Some(ref else_body) = stmt.else_body {
190+
let _ = self.resolve_block(else_body, context);
191+
}
192+
Ok(())
193+
}
194+
195+
fn resolve_import(
196+
&self,
197+
stmt: &techscript_ast::ImportStmt,
198+
context: &mut SemanticContext,
199+
) -> Result<(), ()> {
200+
if stmt.path.is_empty() {
201+
let diag = Diagnostic::new(
202+
DiagnosticLevel::Error,
203+
ErrorCode::E0340,
204+
"Empty module import path".to_string(),
205+
stmt.span,
206+
);
207+
context.diagnostics.push(diag);
208+
return Err(());
209+
}
210+
211+
let path_strs = stmt
212+
.path
213+
.iter()
214+
.map(|ident| ident.name.clone())
215+
.collect::<Vec<_>>();
216+
let resolver = techscript_module_resolver::DefaultModuleResolver::new();
217+
use techscript_module_resolver::ModuleResolver;
218+
match resolver.resolve(&path_strs) {
219+
Ok(_) => {
220+
if let Some(symbols) = &stmt.symbols {
221+
if stmt.path.len() > 1
222+
&& symbols.len() == 1
223+
&& !symbols[0].name.contains(':')
224+
&& symbols[0].name != "*"
225+
{
226+
let alias_name = symbols[0].name.clone();
227+
let symbol = Symbol::new(
228+
alias_name.clone(),
229+
false,
230+
true,
231+
false,
232+
context.interner.any(),
233+
);
234+
context.symbol_table.register(alias_name, symbol);
235+
} else {
236+
for sym in symbols {
237+
if sym.name == "*" {
238+
let module_path = stmt
239+
.path
240+
.iter()
241+
.map(|i| i.name.clone())
242+
.collect::<Vec<_>>()
243+
.join(".");
244+
let registry = techscript_stdlib::StdlibRegistry::new();
245+
if let Some(module) = registry.get_module(&module_path) {
246+
for func_name in module.exports.keys() {
247+
let symbol = Symbol::new(
248+
func_name.clone(),
249+
false,
250+
true,
251+
false,
252+
context.interner.any(),
253+
);
254+
context.symbol_table.register(func_name.clone(), symbol);
255+
}
256+
}
257+
} else if sym.name.contains(':') {
258+
let parts: Vec<&str> = sym.name.split(':').collect();
259+
let alias_name = parts[1].to_string();
193260
let symbol = Symbol::new(
194261
alias_name.clone(),
195262
false,
@@ -199,87 +266,42 @@ impl ResolveSymbols {
199266
);
200267
context.symbol_table.register(alias_name, symbol);
201268
} else {
202-
for sym in symbols {
203-
if sym.name == "*" {
204-
let module_path = stmt
205-
.path
206-
.iter()
207-
.map(|i| i.name.clone())
208-
.collect::<Vec<_>>()
209-
.join(".");
210-
let registry = techscript_stdlib::StdlibRegistry::new();
211-
if let Some(module) = registry.get_module(&module_path) {
212-
for func_name in module.exports.keys() {
213-
let symbol = Symbol::new(
214-
func_name.clone(),
215-
false,
216-
true,
217-
false,
218-
context.interner.any(),
219-
);
220-
context
221-
.symbol_table
222-
.register(func_name.clone(), symbol);
223-
}
224-
}
225-
} else if sym.name.contains(':') {
226-
let parts: Vec<&str> = sym.name.split(':').collect();
227-
let alias_name = parts[1].to_string();
228-
let symbol = Symbol::new(
229-
alias_name.clone(),
230-
false,
231-
true,
232-
false,
233-
context.interner.any(),
234-
);
235-
context.symbol_table.register(alias_name, symbol);
236-
} else {
237-
let sym_name = sym.name.clone();
238-
let symbol = Symbol::new(
239-
sym_name.clone(),
240-
false,
241-
true,
242-
false,
243-
context.interner.any(),
244-
);
245-
context.symbol_table.register(sym_name, symbol);
246-
}
247-
}
269+
let sym_name = sym.name.clone();
270+
let symbol = Symbol::new(
271+
sym_name.clone(),
272+
false,
273+
true,
274+
false,
275+
context.interner.any(),
276+
);
277+
context.symbol_table.register(sym_name, symbol);
248278
}
249-
} else {
250-
let root_name = stmt.path[0].name.clone();
251-
let symbol = Symbol::new(
252-
root_name.clone(),
253-
false,
254-
true,
255-
false,
256-
context.interner.any(),
257-
);
258-
context.symbol_table.register(root_name, symbol);
259279
}
260280
}
261-
Err(e) => {
262-
let diag = Diagnostic::new(
263-
DiagnosticLevel::Error,
264-
ErrorCode::E0340,
265-
format!("Failed to resolve module: {}", e),
266-
stmt.span,
267-
);
268-
context.diagnostics.push(diag);
269-
return Err(());
270-
}
281+
} else {
282+
let root_name = stmt.path[0].name.clone();
283+
let symbol = Symbol::new(
284+
root_name.clone(),
285+
false,
286+
true,
287+
false,
288+
context.interner.any(),
289+
);
290+
context.symbol_table.register(root_name, symbol);
271291
}
272-
Ok(())
273292
}
274-
Statement::Expression(stmt) => {
275-
let _ = self.resolve_expression(&stmt.expression, context);
276-
Ok(())
277-
}
278-
Statement::DSL(stmt) => {
279-
self.resolve_dsl_block(stmt, context);
280-
Ok(())
293+
Err(e) => {
294+
let diag = Diagnostic::new(
295+
DiagnosticLevel::Error,
296+
ErrorCode::E0340,
297+
format!("Failed to resolve module: {}", e),
298+
stmt.span,
299+
);
300+
context.diagnostics.push(diag);
301+
return Err(());
281302
}
282303
}
304+
Ok(())
283305
}
284306

285307
fn resolve_dsl_block(&self, block: &DSLBlock, context: &mut SemanticContext) {

0 commit comments

Comments
 (0)