1pub mod infer;
2mod symbol;
3use dynamic::{Dynamic, Type};
4use parser::{BinaryOp, Expr, ExprKind, Parser, Pattern, PatternKind, Span, Stmt, StmtKind};
5use std::{
6 collections::{BTreeMap, BTreeSet},
7 path::{Path, PathBuf},
8 sync::Arc,
9};
10pub use symbol::{Symbol, SymbolTable, eval_const_int_type, substitute_type};
11
12#[derive(Clone)]
13pub struct Compiler {
14 pub symbols: SymbolTable,
15 pub frames: Vec<usize>,
16 pub tys: Vec<Type>,
17 pub consts: Vec<Dynamic>,
18 names: Vec<SmolStr>,
19 fns: BTreeMap<u32, Vec<(Vec<Type>, Vec<Type>, Type)>>,
20 importing_paths: BTreeSet<PathBuf>,
21}
22
23fn impl_target_name(target: &Type) -> anyhow::Result<SmolStr> {
24 match target {
25 Type::Ident { name, .. } => Ok(name.clone()),
26 _ => anyhow::bail!("impl 目标类型暂不支持: {:?}", target),
27 }
28}
29
30fn has_unresolved_generic_param(ty: &Type) -> bool {
31 match ty {
32 Type::Ident { name, params } => {
33 if params.is_empty() {
34 name.chars().next().map(|ch| ch.is_ascii_uppercase()).unwrap_or(false)
35 } else {
36 params.iter().any(has_unresolved_generic_param)
37 }
38 }
39 Type::Struct { params, fields } => params.iter().any(has_unresolved_generic_param) || fields.iter().any(|(_, ty)| has_unresolved_generic_param(ty)),
40 Type::Tuple(items) => items.iter().any(has_unresolved_generic_param),
41 Type::Vec(elem, _) | Type::Array(elem, _) => has_unresolved_generic_param(elem),
42 Type::ArrayParam(elem, len) => has_unresolved_generic_param(elem) || has_unresolved_generic_param(len),
43 Type::Fn { tys, ret } => tys.iter().any(has_unresolved_generic_param) || has_unresolved_generic_param(ret),
44 Type::Symbol { params, .. } => params.iter().any(has_unresolved_generic_param),
45 Type::ConstBinary { left, right, .. } => has_unresolved_generic_param(left) || has_unresolved_generic_param(right),
46 _ => false,
47 }
48}
49
50fn is_top_level_import_expr(expr: &Expr) -> bool {
51 matches!(
52 &expr.kind,
53 ExprKind::Call { obj, .. } if matches!(&obj.kind, ExprKind::Ident(name) if name.as_str() == "import")
54 )
55}
56
57fn string_value(expr: &Expr) -> Option<&str> {
58 if let ExprKind::Value(Dynamic::String(value)) = &expr.kind { Some(value.as_str()) } else { None }
59}
60
61fn import_decl(stmt: &Stmt) -> Option<(SmolStr, SmolStr)> {
62 let StmtKind::Expr(expr, _) = &stmt.kind else {
63 return None;
64 };
65 let ExprKind::Call { obj, params } = &expr.kind else {
66 return None;
67 };
68 let ExprKind::Ident(name) = &obj.kind else {
69 return None;
70 };
71 if name.as_str() != "import" {
72 return None;
73 }
74
75 match params.as_slice() {
76 [module, path] => Some((string_value(module)?.into(), string_value(path)?.into())),
77 [module] => match &module.kind {
78 ExprKind::Value(Dynamic::String(value)) => Some((value.clone(), format!("{value}.zs").into())),
79 ExprKind::Ident(value) => Some((value.clone(), format!("{value}.zs").into())),
80 _ => None,
81 },
82 _ => None,
83 }
84}
85
86fn generic_arg_for_name<'a>(name: &str, params: &'a [Type], args: &'a [Type]) -> Option<&'a Type> {
87 params.iter().position(|param| matches!(param, Type::Ident { name: param_name, params } if params.is_empty() && param_name == name)).and_then(|idx| args.get(idx))
88}
89
90pub fn infer_generic_args_from_types(generic_params: &[Type], decl_tys: &[Type], arg_tys: &[Type]) -> Vec<Type> {
91 if generic_params.is_empty() {
92 return Vec::new();
93 }
94 let mut inferred = vec![None; generic_params.len()];
95 for (decl, actual) in decl_tys.iter().zip(arg_tys.iter()) {
96 infer_generic_arg_from_type(generic_params, decl, actual, &mut inferred);
97 }
98 if inferred.iter().all(|item| item.is_some()) {
99 return inferred.into_iter().map(Option::unwrap).collect();
100 }
101 if let Some(Type::Struct { params, .. }) = arg_tys.iter().find(|ty| matches!(ty, Type::Struct { params, .. } if params.len() == generic_params.len())) {
102 return params.clone();
103 }
104 for (decl, actual) in decl_tys.iter().zip(arg_tys.iter()) {
105 if let (Type::Ident { params: decl_params, .. }, Type::Ident { params: actual_params, .. }) = (decl, actual)
106 && decl_params.len() == actual_params.len()
107 && decl_params.iter().any(|param| generic_params.contains(param))
108 {
109 return actual_params.clone();
110 }
111 }
112 Vec::new()
113}
114
115fn infer_generic_arg_from_type(generic_params: &[Type], decl: &Type, actual: &Type, inferred: &mut [Option<Type>]) {
116 if let Some(idx) = generic_params.iter().position(|param| param == decl) {
117 inferred[idx] = Some(actual.clone());
118 return;
119 }
120
121 match (decl, actual) {
122 (Type::Vec(decl_elem, decl_len), Type::Vec(actual_elem, actual_len)) | (Type::Array(decl_elem, decl_len), Type::Array(actual_elem, actual_len)) => {
123 infer_generic_arg_from_type(generic_params, decl_elem, actual_elem, inferred);
124 infer_generic_arg_from_type(generic_params, &Type::ConstInt(*decl_len as i64), &Type::ConstInt(*actual_len as i64), inferred);
125 }
126 (Type::ArrayParam(decl_elem, decl_len), Type::Array(actual_elem, actual_len)) => {
127 infer_generic_arg_from_type(generic_params, decl_elem, actual_elem, inferred);
128 infer_generic_arg_from_type(generic_params, decl_len, &Type::ConstInt(*actual_len as i64), inferred);
129 }
130 (Type::Ident { params: decl_params, .. }, Type::Ident { params: actual_params, .. })
131 | (Type::Ident { params: decl_params, .. }, Type::Symbol { params: actual_params, .. })
132 | (Type::Symbol { params: decl_params, .. }, Type::Symbol { params: actual_params, .. })
133 | (Type::Symbol { params: decl_params, .. }, Type::Ident { params: actual_params, .. })
134 | (Type::Struct { params: decl_params, .. }, Type::Struct { params: actual_params, .. }) => {
135 for (decl, actual) in decl_params.iter().zip(actual_params.iter()) {
136 infer_generic_arg_from_type(generic_params, decl, actual, inferred);
137 }
138 }
139 _ => {}
140 }
141}
142
143fn substitute_pattern(pattern: &Pattern, params: &[Type], args: &[Type]) -> Pattern {
144 let kind = match &pattern.kind {
145 PatternKind::Ident { name, ty } => PatternKind::Ident { name: name.clone(), ty: substitute_type(ty, params, args) },
146 PatternKind::Var { idx, ty } => PatternKind::Var { idx: *idx, ty: substitute_type(ty, params, args) },
147 PatternKind::Tuple(items) => PatternKind::Tuple(items.iter().map(|item| substitute_pattern(item, params, args)).collect()),
148 PatternKind::List { elems, has_rest } => PatternKind::List { elems: elems.iter().map(|item| substitute_pattern(item, params, args)).collect(), has_rest: *has_rest },
149 other => other.clone(),
150 };
151 Pattern { kind, span: pattern.span }
152}
153
154fn substitute_expr(expr: &Expr, params: &[Type], args: &[Type]) -> Expr {
155 let kind = match &expr.kind {
156 ExprKind::Ident(name) => match generic_arg_for_name(name, params, args) {
157 Some(Type::ConstInt(value)) => ExprKind::Value(Dynamic::I32(*value as i32)),
158 Some(ty) => eval_const_int_type(ty).map(|value| ExprKind::Value(Dynamic::I32(value as i32))).unwrap_or_else(|| expr.kind.clone()),
159 _ => expr.kind.clone(),
160 },
161 ExprKind::Typed { value, ty } => ExprKind::Typed { value: Box::new(substitute_expr(value, params, args)), ty: substitute_type(ty, params, args) },
162 ExprKind::Unary { op, value } => ExprKind::Unary { op: op.clone(), value: Box::new(substitute_expr(value, params, args)) },
163 ExprKind::Binary { left, op, right } => ExprKind::Binary { left: Box::new(substitute_expr(left, params, args)), op: op.clone(), right: Box::new(substitute_expr(right, params, args)) },
164 ExprKind::Assoc { ty, name } => ExprKind::Assoc { ty: substitute_type(ty, params, args), name: name.clone() },
165 ExprKind::AssocId { id, params: nested } => ExprKind::AssocId { id: *id, params: nested.iter().map(|param| substitute_type(param, params, args)).collect() },
166 ExprKind::Tuple(items) => ExprKind::Tuple(items.iter().map(|item| substitute_expr(item, params, args)).collect()),
167 ExprKind::List(items) => ExprKind::List(items.iter().map(|item| substitute_expr(item, params, args)).collect()),
168 ExprKind::Repeat { value, len } => ExprKind::Repeat { value: Box::new(substitute_expr(value, params, args)), len: substitute_type(len, params, args) },
169 ExprKind::Dict(items) => ExprKind::Dict(items.iter().map(|(name, value)| (name.clone(), substitute_expr(value, params, args))).collect()),
170 ExprKind::Range { start, stop, inclusive } => ExprKind::Range { start: Box::new(substitute_expr(start, params, args)), stop: Box::new(substitute_expr(stop, params, args)), inclusive: *inclusive },
171 ExprKind::Call { obj, params: call_params } => ExprKind::Call { obj: Box::new(substitute_expr(obj, params, args)), params: call_params.iter().map(|param| substitute_expr(param, params, args)).collect() },
172 ExprKind::Stmt(stmt) => ExprKind::Stmt(Box::new(substitute_stmt(stmt, params, args))),
173 ExprKind::Closure { args: closure_args, body } => {
174 ExprKind::Closure { args: closure_args.iter().map(|(name, ty)| (name.clone(), substitute_type(ty, params, args))).collect(), body: Box::new(substitute_stmt(body, params, args)) }
175 }
176 _ => expr.kind.clone(),
177 };
178 Expr::new(kind, expr.span)
179}
180
181pub fn substitute_stmt(stmt: &Stmt, params: &[Type], args: &[Type]) -> Stmt {
182 let kind = match &stmt.kind {
183 StmtKind::Let { pat, value } => StmtKind::Let { pat: substitute_pattern(pat, params, args), value: Box::new(substitute_stmt(value, params, args)) },
184 StmtKind::Expr(expr, close) => StmtKind::Expr(substitute_expr(expr, params, args), *close),
185 StmtKind::Block(stmts) => StmtKind::Block(stmts.iter().map(|stmt| substitute_stmt(stmt, params, args)).collect()),
186 StmtKind::Return(expr) => StmtKind::Return(expr.as_ref().map(|expr| substitute_expr(expr, params, args))),
187 StmtKind::While { cond, body } => StmtKind::While { cond: substitute_expr(cond, params, args), body: Box::new(substitute_stmt(body, params, args)) },
188 StmtKind::Loop(body) => StmtKind::Loop(Box::new(substitute_stmt(body, params, args))),
189 StmtKind::For { pat, range, body } => StmtKind::For { pat: substitute_pattern(pat, params, args), range: substitute_expr(range, params, args), body: Box::new(substitute_stmt(body, params, args)) },
190 StmtKind::Fn { name, generic_params, args: fn_args, body, is_pub } => StmtKind::Fn {
191 name: name.clone(),
192 generic_params: generic_params.iter().map(|param| substitute_type(param, params, args)).collect(),
193 args: fn_args.iter().map(|(name, ty)| (name.clone(), substitute_type(ty, params, args))).collect(),
194 body: Box::new(substitute_stmt(body, params, args)),
195 is_pub: *is_pub,
196 },
197 StmtKind::Struct { name, def, is_pub } => StmtKind::Struct { name: name.clone(), def: substitute_type(def, params, args), is_pub: *is_pub },
198 StmtKind::Impl { target, body } => StmtKind::Impl { target: substitute_type(target, params, args), body: Box::new(substitute_stmt(body, params, args)) },
199 StmtKind::If { cond, then_body, else_body } => StmtKind::If {
200 cond: substitute_expr(cond, params, args),
201 then_body: Box::new(substitute_stmt(then_body, params, args)),
202 else_body: else_body.as_ref().map(|body| Box::new(substitute_stmt(body, params, args))),
203 },
204 StmtKind::Static { name, ty, value, is_pub } => {
205 StmtKind::Static { name: name.clone(), ty: substitute_type(ty, params, args), value: value.as_ref().map(|value| substitute_expr(value, params, args)), is_pub: *is_pub }
206 }
207 StmtKind::Const { name, ty, value, is_pub } => StmtKind::Const { name: name.clone(), ty: substitute_type(ty, params, args), value: substitute_expr(value, params, args), is_pub: *is_pub },
208 other => other.clone(),
209 };
210 Stmt::new(kind, stmt.span)
211}
212
213#[derive(Debug, Clone, Default)]
214pub struct Capture {
215 pub names: Vec<(SmolStr, Type)>,
216 pub vars: Vec<usize>,
217}
218
219impl Capture {
220 pub fn new(names: Vec<(SmolStr, Type)>) -> Self {
221 Self { names, vars: Vec::new() }
222 }
223
224 pub fn get(&mut self, name: &str) -> Option<usize> {
225 if let Some(idx) = self.names.iter().position(|n| n.0 == name) {
226 if let Some(pos) = self.vars.iter().position(|v| *v == idx) {
227 Some(pos)
228 } else {
229 self.vars.push(idx);
230 Some(self.vars.len() - 1)
231 }
232 } else {
233 None
234 }
235 }
236
237 pub fn get_type(&self, idx: u32) -> Option<Type> {
238 self.names.get(idx as usize).map(|(_, ty)| ty.clone())
239 }
240}
241
242use anyhow::{Context, Result, anyhow};
243use smol_str::SmolStr;
244use thiserror::Error;
245
246#[derive(Debug, Error)]
247#[error("{message}")]
248pub struct SpannedCompilerError {
249 pub message: String,
250 pub span: Span,
251}
252
253#[derive(Debug, Clone)]
254pub struct CompilerDiagnostic {
255 pub message: String,
256 pub span: Span,
257}
258
259impl Compiler {
260 pub fn clear(&mut self) {
261 self.frames.clear();
262 self.names.clear();
263 self.tys.clear();
264 }
265
266 pub fn take_local_state(&mut self) -> (Vec<usize>, Vec<SmolStr>, Vec<Type>) {
267 (std::mem::take(&mut self.frames), std::mem::take(&mut self.names), std::mem::take(&mut self.tys))
268 }
269
270 pub fn restore_local_state(&mut self, state: (Vec<usize>, Vec<SmolStr>, Vec<Type>)) {
271 self.frames = state.0;
272 self.names = state.1;
273 self.tys = state.2;
274 }
275
276 pub fn get_value(&self, expr: &Expr) -> Option<Dynamic> {
277 match &expr.kind {
278 ExprKind::Value(v) => Some(v.clone()),
279 ExprKind::Const(idx) => self.consts.get(*idx).cloned(),
280 _ => None,
281 }
282 }
283
284 pub fn get_const(&mut self, value: Dynamic) -> usize {
285 self.consts.iter().position(|c| c == &value).unwrap_or_else(|| {
286 self.consts.push(value);
287 self.consts.len() - 1
288 })
289 }
290
291 pub fn top(&self) -> usize {
292 self.frames.last().copied().unwrap_or(0)
293 }
294
295 fn add_name(&mut self, name: SmolStr) -> u32 {
296 self.names.push(name);
297 (self.names.len() - self.top() - 1) as u32
298 }
299
300 fn add_ty(&mut self, ty: Type) -> u32 {
301 self.tys.push(ty);
302 (self.tys.len() - self.top() - 1) as u32
303 }
304
305 fn set_ty(&mut self, idx: u32, ty: Type) {
306 let pos = idx as usize + self.top();
307 if pos < self.tys.len() {
308 self.tys[pos] = ty;
309 } else if pos == self.tys.len() {
310 self.tys.push(ty);
311 } else {
312 self.tys.resize(pos + 1, Type::Any);
313 self.tys[pos] = ty;
314 }
315 }
316
317 pub fn add_symbol(&mut self, name: &str, s: Symbol) -> u32 {
318 self.symbols.add(name.into(), s)
319 }
320
321 pub fn new() -> Self {
322 let symbols = SymbolTable::default();
323 Self { symbols, tys: Vec::new(), names: Vec::new(), consts: Vec::with_capacity(10240), frames: Vec::new(), fns: BTreeMap::new(), importing_paths: BTreeSet::new() }
324 }
325
326 fn byte_to_line_col(src: &[u8], pos: usize) -> (usize, usize) {
327 let mut line = 1;
328 let mut col = 1;
329 for &b in src.iter().take(pos.min(src.len())) {
330 if b == b'\n' {
331 line += 1;
332 col = 1;
333 } else {
334 col += 1;
335 }
336 }
337 (line, col)
338 }
339
340 fn line_snippet(code: &[u8], span: Span) -> String {
341 let pos = span.start.min(code.len());
342 let line_start = code[..pos].iter().rposition(|&b| b == b'\n').map(|idx| idx + 1).unwrap_or(0);
343 let line_end = code[pos..].iter().position(|&b| b == b'\n').map(|idx| pos + idx).unwrap_or(code.len());
344 String::from_utf8_lossy(&code[line_start..line_end]).into_owned()
345 }
346
347 fn semantic_error(span: Span, message: impl Into<String>) -> anyhow::Error {
348 SpannedCompilerError { message: message.into(), span }.into()
349 }
350
351 fn format_compile_error(code: &[u8], err: anyhow::Error) -> anyhow::Error {
352 if let Some(err) = err.downcast_ref::<SpannedCompilerError>() {
353 let pos = err.span.start.min(code.len());
354 let (line, col) = Self::byte_to_line_col(code, pos);
355 let snippet = Self::line_snippet(code, err.span);
356 anyhow!("语义错误：第 {line} 行，第 {col} 列（字节偏移 {pos}）：{}\n{}", err.message, snippet)
357 } else {
358 err
359 }
360 }
361
362 pub fn parse_code(code: Vec<u8>) -> Result<Vec<Stmt>> {
363 let mut p = Parser::new(code.clone());
364 let mut stmts = Vec::new();
365 loop {
366 match p.stmt(false) {
367 Ok(stmt) => stmts.push(stmt),
368 Err(e) => {
369 if p.is_eof() {
370 return Ok(stmts);
371 }
372 let pos = p.current_pos();
373 let (line, col) = Self::byte_to_line_col(&code, pos);
374 return Err(anyhow!("解析错误：第 {line} 行，第 {col} 列（字节偏移 {pos}）：{e:#}\n{}", p.error_stmt()));
375 }
376 }
377 }
378 }
379
380 pub fn import_code(&mut self, name: &str, code: Vec<u8>) -> Result<Vec<u32>> {
381 self.import_code_with_base_dir(name, code, None)
382 }
383
384 pub fn import_code_from_path(&mut self, name: &str, code: Vec<u8>, path: impl AsRef<Path>) -> Result<Vec<u32>> {
385 self.import_code_with_base_dir(name, code, path.as_ref().parent())
386 }
387
388 pub fn import_file(&mut self, name: &str, path: impl AsRef<Path>) -> Result<Vec<u32>> {
389 let path = path.as_ref();
390 let canonical = std::fs::canonicalize(path).with_context(|| format!("failed to resolve import path {}", path.display()))?;
391 if !self.importing_paths.insert(canonical.clone()) {
392 return Ok(Vec::new());
393 }
394 let code = std::fs::read(&canonical).with_context(|| format!("failed to read import path {}", canonical.display()))?;
395 let result = self.import_code_from_path(name, code, &canonical);
396 self.importing_paths.remove(&canonical);
397 result
398 }
399
400 fn import_code_with_base_dir(&mut self, name: &str, code: Vec<u8>, base_dir: Option<&Path>) -> Result<Vec<u32>> {
401 let stmts = Self::parse_code(code.clone())?;
402 log::info!("func->{}", name);
403 for s in stmts.iter() {
404 log::info!("{}", s);
405 }
406 self.resolve_imports(&stmts, base_dir).map_err(|err| Self::format_compile_error(&code, err))?;
407 self.clear();
408 self.compile(name.into(), stmts).map_err(|err| Self::format_compile_error(&code, err))
409 }
410
411 fn resolve_imports(&mut self, stmts: &[Stmt], base_dir: Option<&Path>) -> Result<()> {
412 for stmt in stmts {
413 let Some((module, path)) = import_decl(stmt) else {
414 continue;
415 };
416 if !self.symbols.symbol(module.as_str()).is_empty() {
417 continue;
418 }
419 let path = Path::new(path.as_str());
420 let resolved = if path.is_absolute() {
421 path.to_path_buf()
422 } else if let Some(base_dir) = base_dir {
423 base_dir.join(path)
424 } else {
425 std::env::current_dir()?.join(path)
426 };
427 self.import_file(module.as_str(), &resolved).with_context(|| format!("failed to import {module} from {}", resolved.display()))?;
428 }
429 Ok(())
430 }
431
432 pub fn check_code(name: &str, code: Vec<u8>) -> Vec<CompilerDiagnostic> {
433 let mut parser = Parser::new(code.clone());
434 let mut stmts = Vec::new();
435 loop {
436 match parser.stmt(false) {
437 Ok(stmt) => stmts.push(stmt),
438 Err(err) => {
439 if parser.is_eof() {
440 break;
441 }
442 return vec![CompilerDiagnostic { message: format!("解析错误：{err:#}"), span: Span::empty(parser.current_pos()) }];
443 }
444 }
445 }
446
447 let mut compiler = Self::new();
448 compiler.clear();
449 match compiler.compile(name.into(), stmts) {
450 Ok(_) => Vec::new(),
451 Err(err) => {
452 if let Some(err) = err.downcast_ref::<SpannedCompilerError>() {
453 vec![CompilerDiagnostic { message: err.message.clone(), span: err.span }]
454 } else {
455 vec![CompilerDiagnostic { message: format!("{err:#}"), span: Span::default() }]
456 }
457 }
458 }
459 }
460
461 pub fn get_field(&self, ty: &Type, name: &str) -> Result<(usize, Type)> {
462 self.symbols.get_field(ty, name)
463 }
464
465 pub fn get_ident(&mut self, ident: &str, span: Span) -> Result<Expr> {
466 for idx in (self.top()..self.names.len()).rev() {
467 if self.names[idx].eq(ident) {
468 return Ok(Expr::new(ExprKind::Var((idx - self.top()) as u32), span));
469 }
470 }
471 let id = self.symbols.get_id(ident).map_err(|_| Self::semantic_error(span, format!("未找到标识符 {}", ident)))?;
472 let s = self.symbols.get_symbol(id).map(|(_, v)| v.clone()).unwrap();
473 if let Symbol::Const { value, ty, .. } = s {
474 let c = self.get_const(value);
475 return Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::Const(c), span)), ty }, span));
476 } else if let Symbol::Static { value, ty, .. } = s
477 && let Some(v) = value
478 {
479 let c = self.get_const(v);
480 return Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::Const(c), span)), ty }, span));
481 }
482 Ok(Expr::new(ExprKind::Id(id, None), span))
483 }
484
485 fn field_access_expr(&mut self, left: Expr, idx: usize, ty: Type, key: &str, span: Span) -> Expr {
486 if let Type::Symbol { id, .. } = ty {
487 Expr::new(ExprKind::Id(id, Some(Box::new(left))), span)
488 } else if ty.is_bool() && idx == usize::MAX {
489 Expr::new(ExprKind::Value(Dynamic::Bool(false)), span)
490 } else if ty.is_any() && idx == usize::MAX {
491 let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(key.into()))), span);
492 Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, span)
493 } else {
494 Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(Expr::new(ExprKind::Value(Dynamic::U32(idx as u32)), span)) }, span)
495 }
496 }
497
498 fn literal_field_access_expr(&mut self, left: Expr, key: &str, span: Span) -> Expr {
499 let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(key.into()))), span);
500 Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, span)
501 }
502
503 fn type_field_access_expr(&mut self, left: Expr, key: &str, span: Span, prefer_dynamic_field: bool) -> Option<Expr> {
504 let ty = self.infer_expr(&left).ok()?;
505 if prefer_dynamic_field && ty.is_any() {
506 return Some(self.literal_field_access_expr(left, key, span));
507 }
508 let (idx, field_ty) = self.get_field(&ty, key).ok()?;
509 Some(self.field_access_expr(left, idx, field_ty, key, span))
510 }
511
512 fn global_method_access_expr(&self, left: Expr, method: &str, span: Span) -> Result<Option<Expr>> {
513 let Ok(id) = self.symbols.get_id(method) else {
514 return Ok(None);
515 };
516 if self.symbols.get_symbol(id)?.1.is_fn() { Ok(Some(Expr::new(ExprKind::Id(id, Some(Box::new(left))), span))) } else { Ok(None) }
517 }
518
519 fn method_call_obj_expr(&mut self, obj: &Expr, stmts: &mut Vec<Stmt>, cap: &mut Capture) -> Result<Option<Expr>> {
520 let ExprKind::Binary { left, op: BinaryOp::Idx, right } = &obj.kind else {
521 return Ok(None);
522 };
523 let Some(method) = self.get_value(right).and_then(|v| if v.is_str() { Some(v.as_str().to_string()) } else { None }) else {
524 return Ok(None);
525 };
526 let left = self.eval(left, stmts, cap)?;
527 if let Some(field) = self.type_field_access_expr(left.clone(), &method, obj.span, false) {
528 return Ok(Some(field));
529 }
530 if let Some(method_fn) = self.global_method_access_expr(left.clone(), &method, obj.span)? {
531 return Ok(Some(method_fn));
532 }
533 Ok(Some(self.literal_field_access_expr(left, &method, obj.span)))
534 }
535
536 pub fn compile_fn(&mut self, args: &[SmolStr], tys: &mut Vec<Type>, body: Stmt, cap: &mut Capture) -> Result<Vec<Stmt>> {
537 let top = self.tys.len();
538 self.frames.push(top);
539 let result = (|| -> Result<Vec<Stmt>> {
540 for (arg, ty) in args.iter().zip(tys.iter_mut()) {
541 *ty = self.symbols.get_type(ty)?;
542 self.add_name(arg.clone());
543 self.add_ty(ty.clone());
544 }
545 let mut compiled = Vec::new();
546 self.compile_stmt(body, &mut compiled, cap)?;
547 if !compiled.last_mut().map(|stmt| stmt.last_return()).unwrap_or(false) {
548 compiled.push(Stmt::new(StmtKind::Return(None), Span::default()));
549 }
550 Ok(compiled)
551 })();
552 if let Some(top) = self.frames.pop() {
553 self.tys.truncate(top);
554 self.names.truncate(top);
555 }
556 result
557 }
558
559 pub fn compile(&mut self, mod_name: SmolStr, stmts: Vec<Stmt>) -> Result<Vec<u32>> {
560 self.symbols.add_module(mod_name.clone());
561 for stmt in stmts {
562 match stmt.kind {
563 StmtKind::Struct { name, def, is_pub } => {
564 self.symbols.add(name, Symbol::Struct(def, is_pub));
565 }
566 StmtKind::Static { name, ty, value, is_pub } => {
567 self.symbols.add(name, Symbol::Static { value: value.and_then(|v| v.value().ok()), ty, is_pub });
568 }
569 StmtKind::Const { name, ty, value, is_pub } => {
570 self.symbols.add(name, Symbol::Const { value: value.value()?, ty, is_pub });
571 }
572 StmtKind::Fn { name, generic_params, args, body, is_pub } => {
573 let (ty, args) = Type::from_args(args);
574 self.symbols.add(name, Symbol::Fn { ty, args, generic_params, cap: Capture::default(), body: Arc::new(*body), is_pub });
575 }
576 StmtKind::Impl { target, body } => {
577 let name = impl_target_name(&target)?;
578 let def_id = match self.symbols.get_id(&name) {
579 Ok(id) => id,
580 Err(_) if name.as_str() == "Vec" => self.symbols.add(name.clone(), Symbol::Struct(Type::Struct { params: Vec::new(), fields: Vec::new() }, true)),
581 Err(err) => return Err(err),
582 };
583 if let StmtKind::Block(fns) = body.kind {
584 for f in fns {
585 if let StmtKind::Fn { name: fn_name, generic_params: fn_generic_params, args, body, is_pub } = f.kind {
586 let (ty, args) = Type::from_args(args);
587 let mut generic_params = if has_unresolved_generic_param(&target) {
588 match &target {
589 Type::Ident { params, .. } => params.clone(),
590 _ => Vec::new(),
591 }
592 } else {
593 Vec::new()
594 };
595 for param in fn_generic_params {
596 if !generic_params.contains(¶m) {
597 generic_params.push(param);
598 }
599 }
600 let fn_id = self.symbols.add(SmolStr::from(format!("{}::{}", name, fn_name)), Symbol::Fn { ty, args, generic_params, cap: Capture::default(), body: Arc::new(*body), is_pub });
601 if let Symbol::Struct(ty, _) = &mut self.symbols.symbols[def_id as usize] {
602 ty.add_field(fn_name.into(), Type::Symbol { id: fn_id, params: Vec::new() })?;
603 }
604 } else {
605 println!("impl 包含非函数语句 {:?}", f);
606 }
607 }
608 }
609 }
610 StmtKind::Expr(expr, _) if is_top_level_import_expr(&expr) => {}
611 _ => {
612 println!("未知的顶层语句 {:?}", stmt);
613 }
614 }
615 }
616 let mut fn_ids = Vec::new();
617 for (name, id) in self.symbols.symbol(&mod_name) {
618 log::info!("compile symbol {:?}[{}]", name, id);
619 if let Some((_, Symbol::Fn { ty, generic_params, .. })) = self.symbols.get_symbol(id).ok() {
620 let resolved_ty = self.symbols.get_type(ty).unwrap_or_else(|_| ty.clone());
621 if has_unresolved_generic_param(&resolved_ty) || !generic_params.is_empty() {
622 continue;
623 }
624 }
625 if let Some(s) = self.symbols.take(id) {
626 match s {
627 Symbol::Fn { ty, args, generic_params, mut cap, body, is_pub } => {
628 if let Type::Fn { mut tys, ret } = ty {
629 let compiled = self.compile_fn(&args, &mut tys, Arc::try_unwrap(body).unwrap(), &mut cap)?;
630 for s in compiled.iter() {
631 log::info!("{}", s);
632 }
633 self.symbols.symbols[id as usize] = Symbol::Fn { ty: Type::Fn { tys, ret }, args, generic_params, cap, body: Arc::new(Stmt::new(StmtKind::Block(compiled), Span::default())), is_pub };
634 fn_ids.push(id);
635 }
636 }
637 _ => {
638 self.symbols.symbols[id as usize] = s;
639 }
640 }
641 }
642 }
643 self.symbols.pop_module();
644 Ok(fn_ids)
645 }
646
647 fn pat_to_var(&mut self, pat: Pattern, expr_ty: Type) -> Result<Pattern> {
648 match pat.kind {
649 PatternKind::Var { idx, ty } => Ok(Pattern { kind: PatternKind::Var { idx, ty }, span: pat.span }),
650 PatternKind::Ident { name, ty } => {
651 let ty = self.symbols.get_type(&ty)?;
652 let ty = if ty.is_any() { expr_ty } else { ty };
653 self.add_ty(ty.clone());
654 Ok(Pattern { kind: PatternKind::Var { idx: self.add_name(name), ty }, span: pat.span })
655 }
656 PatternKind::Tuple(pats) => {
657 if let Type::Tuple(tys) = &expr_ty {
658 let pats: Vec<Pattern> = pats.into_iter().zip(tys).filter_map(|p| self.pat_to_var(p.0, p.1.clone()).ok()).collect();
659 if pats.len() == tys.len() { Ok(Pattern { kind: PatternKind::Tuple(pats), span: pat.span }) } else { Err(Self::semantic_error(pat.span, format!("模式与元组类型不匹配: {:?}", expr_ty))) }
660 } else {
661 let pats = pats.into_iter().filter_map(|p| self.pat_to_var(p, Type::Any).ok()).collect();
662 Ok(Pattern { kind: PatternKind::Tuple(pats), span: pat.span })
663 }
664 }
665 PatternKind::List { elems, has_rest } => {
666 if expr_ty.is_any() {
667 let elems: Vec<Pattern> = elems.into_iter().filter_map(|p| self.pat_to_var(p, Type::Any).ok()).collect();
668 Ok(Pattern { kind: PatternKind::List { elems, has_rest }, span: pat.span })
669 } else {
670 Err(Self::semantic_error(pat.span, format!("列表模式 {:?} 与类型 {:?} 不匹配", elems, expr_ty)))
671 }
672 }
673 PatternKind::Wildcard => {
674 self.add_ty(expr_ty.clone());
675 Ok(Pattern { kind: PatternKind::Var { idx: self.add_name(SmolStr::new_static("")), ty: expr_ty }, span: pat.span })
676 }
677 _ => panic!("未知的模式 {:?}", pat),
678 }
679 }
680
681 fn infer_range_type(&self, range: &Expr) -> Type {
682 if let ExprKind::Range { start, stop, .. } = &range.kind {
683 let start_ty = start.get_type();
684 let stop_ty = stop.get_type();
685 if start_ty.is_any() {
686 stop_ty
687 } else if stop_ty.is_any() {
688 start_ty
689 } else {
690 stop_ty
691 }
692 } else {
693 range.get_type()
694 }
695 }
696
697 fn dyn_init(&mut self, expr: Expr, stmts: &mut Vec<Stmt>, items: Vec<(Expr, Expr)>, ty: Type) -> Expr {
698 self.add_name("".into());
699 let temp = self.add_ty(ty);
700 let span = expr.span;
701 stmts.push(Stmt::new(StmtKind::Expr(Expr::new(ExprKind::Binary { left: Box::new(Expr::new(ExprKind::Var(temp), span)), op: BinaryOp::Assign, right: Box::new(expr) }, span), true), span));
702 for (idx, item) in items {
703 let item_span = idx.span.merge(item.span);
704 let left = Expr::new(ExprKind::Binary { left: Box::new(Expr::new(ExprKind::Var(temp), item_span)), op: BinaryOp::Idx, right: Box::new(idx) }, item_span);
705 stmts.push(Stmt::new(StmtKind::Expr(Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Assign, right: Box::new(item) }, item_span), false), item_span));
706 }
707 Expr::new(ExprKind::Var(temp), span)
708 }
709
710 fn eval_stmt_expr(&mut self, stmt: &Stmt, stmts: &mut Vec<Stmt>, cap: &mut Capture, span: Span) -> Result<Expr> {
711 self.compile_stmt(stmt.clone(), stmts, cap)?;
712 let expr_ty = if let Some(stmt) = stmts.last() { if let StmtKind::Expr(expr, _) = &stmt.kind { self.infer_expr(expr)? } else { self.infer_stmt(stmt)? } } else { Type::Any };
713 self.add_name("".into());
714 let temp = self.add_ty(expr_ty.clone());
715 let pat = Pattern { kind: PatternKind::Var { idx: temp, ty: expr_ty }, span };
716 stmts.last_mut().ok_or_else(|| Self::semantic_error(span, "没有生成可求值语句表达式")).and_then(|stmt| stmt.bind_pattern(pat))?;
717 Ok(Expr::new(ExprKind::Var(temp), span))
718 }
719
720 fn eval(&mut self, expr: &Expr, stmts: &mut Vec<Stmt>, cap: &mut Capture) -> Result<Expr> {
721 match &expr.kind {
722 ExprKind::Stmt(stmt) => self.eval_stmt_expr(stmt, stmts, cap, expr.span),
723 ExprKind::Closure { args, body } => {
724 let (mut names, mut tys): (Vec<SmolStr>, Vec<Type>) = args.clone().into_iter().unzip();
725 let cap_vars: Vec<(SmolStr, Type)> = self.names.iter().zip(self.tys.iter()).map(|(n, ty)| (n.clone(), ty.clone())).collect();
726 let mut local_cap = Capture::new(cap_vars);
727 let _ = self.compile_fn(names.as_slice(), &mut tys.clone(), *body.clone(), &mut local_cap)?;
728 for cap_idx in local_cap.vars.iter() {
729 names.push(local_cap.names[*cap_idx].0.clone());
730 tys.push(local_cap.names[*cap_idx].1.clone());
731 }
732 let mut compiled = self.compile_fn(names.as_slice(), &mut tys.clone(), *body.clone(), &mut Capture::default())?;
733 let (ty, args) = Type::from_args(args.clone());
734 let body_stmt = if compiled.len() == 1 { compiled.pop().unwrap() } else { Stmt::new(StmtKind::Block(compiled), expr.span) };
735 let fn_id = self.symbols.add(SmolStr::from(""), Symbol::Fn { ty, args, generic_params: Vec::new(), cap: local_cap, body: Arc::new(body_stmt), is_pub: false });
736 Ok(Expr::new(ExprKind::Id(fn_id, None), expr.span))
737 }
738 ExprKind::Value(v) => {
739 if v.is_native() {
740 Ok(Expr::new(ExprKind::Value(v.clone()), expr.span))
741 } else {
742 Ok(Expr::new(ExprKind::Const(self.get_const(v.clone())), expr.span))
743 }
744 }
745 ExprKind::Typed { value, ty } => {
746 let ty = self.symbols.get_type(ty)?;
747 if let Type::Struct { fields, .. } = &ty
748 && let ExprKind::Dict(dict) = &value.kind
749 {
750 let mut items = Vec::new();
751 for field in fields {
752 if let Some((_, v)) = dict.iter().find(|(name, _)| name == &field.0) {
753 items.push(self.eval(v, stmts, cap)?);
754 }
755 }
756 Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::List(items), expr.span)), ty }, expr.span))
757 } else if let Type::Struct { .. } = &ty
758 && let ExprKind::List(list) = &value.kind
759 {
760 let items = list.iter().map(|item| self.eval(item, stmts, cap)).collect::<Result<Vec<_>>>()?;
761 Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::List(items), expr.span)), ty }, expr.span))
762 } else if let Type::Array(_, _) = &ty
763 && let ExprKind::List(list) = &value.kind
764 {
765 let items = list.iter().map(|item| self.eval(item, stmts, cap)).collect::<Result<Vec<_>>>()?;
766 Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::List(items), expr.span)), ty }, expr.span))
767 } else if value.is_value() {
768 Ok(Expr::new(ExprKind::Value(ty.force(value.clone().value()?)?), expr.span))
769 } else {
770 Ok(Expr::new(ExprKind::Typed { value: Box::new(self.eval(value, stmts, cap)?), ty }, expr.span))
771 }
772 }
773 ExprKind::Ident(ident) => match self.get_ident(ident, expr.span) {
774 Ok(id) => Ok(id),
775 Err(_) => {
776 if let Some(idx) = cap.get(ident) {
777 Ok(Expr::new(ExprKind::Capture(idx as u32), expr.span))
778 } else {
779 Err(Self::semantic_error(expr.span, format!("未找到标识符 {}", ident)))
780 }
781 }
782 },
783 ExprKind::Assoc { ty, name } => {
784 let base_name = match ty {
785 Type::Ident { name, .. } => name.clone(),
786 Type::Symbol { id, .. } => self.symbols.get_symbol(*id)?.0.clone(),
787 _ => return Err(Self::semantic_error(expr.span, format!("关联函数目标必须是类型: {:?}", ty))),
788 };
789 let id = self.symbols.get_id(&format!("{}::{}", base_name, name)).map_err(|_| Self::semantic_error(expr.span, format!("未找到关联函数 {}::{}", base_name, name)))?;
790 let params = match ty {
791 Type::Ident { params, .. } | Type::Symbol { params, .. } => params.iter().map(|param| self.symbols.get_type(param).unwrap_or_else(|_| param.clone())).collect(),
792 _ => Vec::new(),
793 };
794 Ok(Expr::new(ExprKind::AssocId { id, params }, expr.span))
795 }
796 ExprKind::Unary { op, value } => {
797 let value = Expr::new(ExprKind::Unary { op: op.clone(), value: Box::new(self.eval(value, stmts, cap)?) }, expr.span);
798 if let Some(v) = value.compact() { Ok(Expr::new(ExprKind::Value(v), expr.span)) } else { Ok(value) }
799 }
800 ExprKind::Binary { left, op, right } => {
801 let left = self.eval(left, stmts, cap)?;
802 if *op == BinaryOp::Idx {
803 if let Some(key) = self.get_value(right).and_then(|v| if v.is_str() { Some(v.as_str().to_string()) } else { None }) {
804 if let Some(field) = self.type_field_access_expr(left.clone(), &key, expr.span, true) {
805 return Ok(field);
806 }
807 return Ok(self.literal_field_access_expr(left, &key, expr.span));
808 } else if let Ok(ident) = right.ident() {
809 if let Ok(found) = self.get_ident(ident, right.span) {
810 return Ok(if let Some(id) = found.id() {
811 Expr::new(ExprKind::Id(id, Some(Box::new(left))), expr.span)
812 } else {
813 Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(found) }, expr.span)
814 });
815 }
816 if let Ok(ty) = self.infer_expr(&left)
817 && let Ok((idx, ty)) = self.get_field(&ty, ident)
818 {
819 return Ok(if let Type::Symbol { id, .. } = ty {
820 Expr::new(ExprKind::Id(id, Some(Box::new(left))), expr.span)
821 } else if ty.is_bool() && idx == usize::MAX {
822 Expr::new(ExprKind::Value(Dynamic::Bool(false)), expr.span)
823 } else if ty.is_any() && idx == usize::MAX {
824 let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(ident.into()))), expr.span);
825 Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, expr.span)
826 } else {
827 Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(Expr::new(ExprKind::Value(Dynamic::U32(idx as u32)), expr.span)) }, expr.span)
828 });
829 } else {
830 let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(ident.into()))), expr.span);
831 return Ok(Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, expr.span));
832 }
833 }
834 }
835 let right = Box::new(self.eval(right, stmts, cap)?);
836 let value = Expr::new(ExprKind::Binary { left: Box::new(left), op: op.clone(), right }, expr.span);
837 if let Some(v) = value.compact() { Ok(Expr::new(ExprKind::Value(v), expr.span)) } else { Ok(value) }
838 }
839 ExprKind::Call { obj, params } => {
840 let params: Vec<Expr> = params.iter().map(|p| self.eval(p, stmts, cap)).collect::<Result<Vec<_>>>()?;
841 let obj_result = if let Some(method_obj) = self.method_call_obj_expr(obj, stmts, cap)? { Ok(method_obj) } else { self.eval(obj, stmts, cap) };
842 match obj_result {
843 Ok(obj) if obj.is_value() && params.is_empty() => Ok(obj),
844 Ok(obj) => Ok(Expr::new(ExprKind::Call { obj: Box::new(obj), params }, expr.span)),
845 Err(e) => {
846 if let ExprKind::Ident(ident) = &obj.kind {
847 let fn_id = if ident.contains("::") { self.symbols.add_global(ident.clone(), Symbol::Null) } else { self.symbols.add(ident.clone(), Symbol::Null) };
848 Ok(Expr::new(ExprKind::Call { obj: Box::new(Expr::new(ExprKind::Id(fn_id, None), obj.span)), params }, expr.span))
849 } else {
850 Err(e)
851 }
852 }
853 }
854 }
855 ExprKind::Range { start, stop, inclusive } => {
856 let start = Box::new(self.eval(start, stmts, cap)?);
857 let stop = Box::new(self.eval(stop, stmts, cap)?);
858 Ok(Expr::new(ExprKind::Range { start, stop, inclusive: *inclusive }, expr.span))
859 }
860 ExprKind::List(list) | ExprKind::Tuple(list) => {
861 let mut v = Vec::new();
862 let mut items = Vec::new();
863 for (idx, item) in list.iter().enumerate() {
864 if item.is_value() {
865 v.push(item.clone().value().unwrap());
866 } else {
867 items.push((Expr::new(ExprKind::Value((idx as u32).into()), item.span), self.eval(item, stmts, cap)?));
868 v.push(Dynamic::Null);
869 }
870 }
871 let list = Expr::new(ExprKind::Const(self.get_const(Dynamic::list(v))), expr.span);
872 Ok(self.dyn_init(list, stmts, items, Type::Any))
873 }
874 ExprKind::Repeat { value, len } => {
875 let len = self.symbols.get_type(len)?;
876 let Type::ConstInt(len) = len else {
877 return Err(Self::semantic_error(expr.span, format!("重复数组长度必须是编译期整数: {:?}", len)));
878 };
879 if len < 0 {
880 return Err(Self::semantic_error(expr.span, "重复数组长度不能为负数"));
881 }
882 Ok(Expr::new(ExprKind::Repeat { value: Box::new(self.eval(value, stmts, cap)?), len: Type::ConstInt(len) }, expr.span))
883 }
884 ExprKind::Dict(dict) => {
885 let mut dyn_kv = Vec::new();
886 let mut m = BTreeMap::new();
887 for (k, v) in dict {
888 if v.is_value() {
889 m.insert(k.clone(), v.clone().value()?);
890 } else {
891 let key = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(k.clone()))), v.span);
892 dyn_kv.push((key, self.eval(v, stmts, cap)?));
893 m.insert(k.clone(), Dynamic::Null);
894 }
895 }
896 let dict = Expr::new(ExprKind::Const(self.get_const(Dynamic::map(m))), expr.span);
897 Ok(self.dyn_init(dict, stmts, dyn_kv, Type::Any))
898 }
899 ExprKind::Id(_, _) | ExprKind::AssocId { .. } => Ok(expr.clone()),
900 _ => Ok(expr.clone()),
901 }
902 }
903
904 fn get_stmt(&mut self, stmt: Stmt, cap: &mut Capture) -> Result<Stmt> {
905 let span = stmt.span;
906 let mut stmts = Vec::new();
907 self.compile_stmt(stmt, &mut stmts, cap)?;
908 Ok(Stmt::new(StmtKind::Block(stmts), span))
909 }
910
911 fn compile_stmt(&mut self, stmt: Stmt, compiled: &mut Vec<Stmt>, cap: &mut Capture) -> Result<()> {
912 let stmt_span = stmt.span;
913 match stmt.kind {
914 StmtKind::Let { pat, value } => {
915 let annotated_ty = if let PatternKind::Ident { ty, .. } = &pat.kind {
916 let ty = self.symbols.get_type(ty)?;
917 if ty.is_any() { None } else { Some(ty) }
918 } else {
919 None
920 };
921 let value = *value;
922 if let Some(ty) = annotated_ty {
923 if let StmtKind::Expr(expr, close) = value.kind {
924 let span = expr.span;
925 let typed = Expr::new(ExprKind::Typed { value: Box::new(expr), ty }, span);
926 self.compile_stmt(Stmt::new(StmtKind::Expr(typed, close), value.span), compiled, cap)?;
927 } else {
928 self.compile_stmt(value, compiled, cap)?;
929 }
930 } else {
931 self.compile_stmt(value, compiled, cap)?;
932 }
933 let expr_ty = if let Some(stmt) = compiled.last() { if let StmtKind::Expr(expr, _) = &stmt.kind { self.infer_expr(expr)? } else { self.infer_stmt(stmt)? } } else { Type::Any };
934 let pat = self.pat_to_var(pat, expr_ty)?;
935 compiled.last_mut().ok_or_else(|| Self::semantic_error(stmt_span, "没有生成可绑定模式的编译语句")).and_then(|stmt| stmt.bind_pattern(pat))?;
936 }
937 StmtKind::Expr(expr, close) => {
938 let e = self.eval(&expr, compiled, cap)?;
939 compiled.push(Stmt::new(StmtKind::Expr(e, close), stmt_span));
940 }
941 StmtKind::Block(stmts) => {
942 let mut block = Vec::new();
943 for stmt in stmts {
944 self.compile_stmt(stmt, &mut block, cap)?;
945 }
946 compiled.push(Stmt::new(StmtKind::Block(block), stmt_span));
947 }
948 StmtKind::Fn { name, generic_params, args, body, is_pub } => {
949 let (ty, args) = Type::from_args(args);
950 if let Type::Fn { mut tys, ret } = ty {
951 let mut fn_cap = Capture::default();
952 let compiled_body = self.compile_fn(&args, &mut tys, *body, &mut fn_cap)?;
953 self.symbols.add(name, Symbol::Fn { ty: Type::Fn { tys, ret }, args, generic_params, cap: fn_cap, body: Arc::new(Stmt::new(StmtKind::Block(compiled_body), stmt_span)), is_pub });
954 } else {
955 panic!("nested functions are not supported here")
956 }
957 }
958 StmtKind::Return(expr) => {
959 let expr = expr.and_then(|e| self.eval(&e, compiled, cap).ok());
960 compiled.push(Stmt::new(StmtKind::Return(expr), stmt_span));
961 }
962 StmtKind::If { cond, then_body, else_body } => {
963 let cond = self.eval(&cond, compiled, cap)?;
964 if let Some(cond_value) = cond.compact()
965 && let Some(cond_bool) = cond_value.as_bool()
966 {
967 if cond_bool {
968 self.compile_stmt(*then_body, compiled, cap)?;
969 } else if let Some(body) = else_body {
970 self.compile_stmt(*body, compiled, cap)?;
971 }
972 } else {
973 let then_body = Box::new(self.get_stmt(*then_body, cap)?);
974 let else_body = if let Some(body) = else_body { Some(Box::new(self.get_stmt(*body, cap)?)) } else { None };
975 compiled.push(Stmt::new(StmtKind::If { cond, then_body, else_body }, stmt_span));
976 }
977 }
978 StmtKind::Loop(body) => {
979 compiled.push(Stmt::new(StmtKind::Loop(Box::new(self.get_stmt(*body, cap)?)), stmt_span));
980 }
981 StmtKind::While { cond, body } => {
982 let cond = self.eval(&cond, compiled, cap)?;
983 compiled.push(Stmt::new(StmtKind::While { cond, body: Box::new(self.get_stmt(*body, cap)?) }, stmt_span));
984 }
985 StmtKind::For { pat, range, body } => {
986 let range = self.eval(&range, compiled, cap)?;
987 let range_ty = self.infer_range_type(&range);
988 let pat = self.pat_to_var(pat, range_ty)?;
989 compiled.push(Stmt::new(StmtKind::For { pat, range, body: Box::new(self.get_stmt(*body, cap)?) }, stmt_span));
990 }
991 stmt_kind => {
992 compiled.push(Stmt::new(stmt_kind, stmt_span));
993 }
994 }
995 Ok(())
996 }
997}