Skip to main content

compiler/
lib.rs

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)]
13enum FnInferRet {
14    Pending(Option<Type>),
15    Done(Type),
16}
17
18#[derive(Clone)]
19pub enum ListElemState {
20    Unknown,
21    Known(Type),
22    Mixed,
23}
24
25#[derive(Clone)]
26pub struct Compiler {
27    pub symbols: SymbolTable,
28    pub frames: Vec<usize>,
29    pub tys: Vec<Type>,
30    pub consts: Vec<Dynamic>,
31    names: Vec<SmolStr>,
32    list_elem_states: Vec<Option<ListElemState>>,
33    arg_counts: Vec<usize>,
34    fns: BTreeMap<u32, Vec<(Vec<Type>, Vec<Type>, FnInferRet)>>,
35    local_type_hints: BTreeMap<u32, Vec<(Vec<Type>, Vec<Type>, Vec<Option<Type>>)>>,
36    infer_stack: Vec<(u32, Vec<Type>, Vec<Type>)>,
37    importing_paths: BTreeSet<PathBuf>,
38}
39
40fn impl_target_name(target: &Type) -> anyhow::Result<SmolStr> {
41    match target {
42        Type::Ident { name, .. } => Ok(name.clone()),
43        _ => anyhow::bail!("impl 目标类型暂不支持: {:?}", target),
44    }
45}
46
47#[cfg(test)]
48mod tests {
49    use super::{Compiler, Symbol};
50    use dynamic::Type;
51
52    #[test]
53    fn inferred_function_return_type_is_written_back_to_symbol() -> anyhow::Result<()> {
54        let mut compiler = Compiler::new();
55        compiler.import_code(
56            "compiler_infer_return",
57            br#"
58            pub fn is_alive() {
59                true
60            }
61
62            pub fn can_act() {
63                is_alive() && true && is_alive()
64            }
65            "#
66            .to_vec(),
67        )?;
68
69        let is_alive = compiler.symbols.get_id("compiler_infer_return::is_alive")?;
70        assert_eq!(compiler.infer_fn(is_alive, &[])?, Type::Bool);
71
72        let (_, symbol) = compiler.symbols.get_symbol(is_alive)?;
73        let Symbol::Fn { ty: Type::Fn { ret, .. }, .. } = symbol else {
74            panic!("is_alive should be a function symbol");
75        };
76        assert_eq!(ret.as_ref(), &Type::Bool);
77
78        let can_act = compiler.symbols.get_id("compiler_infer_return::can_act")?;
79        assert_eq!(compiler.infer_fn(can_act, &[])?, Type::Bool);
80        Ok(())
81    }
82
83    #[test]
84    fn top_level_const_composite_resolves_const_idents() -> anyhow::Result<()> {
85        let mut compiler = Compiler::new();
86        compiler.import_code(
87            "compiler_const_table",
88            br#"
89            pub const GEM_ATK = "atk";
90            pub const GEM_DEF = "def";
91            pub const GEM_TABLE = [
92                { key: GEM_ATK, score: 3i32 },
93                { key: GEM_DEF, score: 1i32 },
94            ];
95            "#
96            .to_vec(),
97        )?;
98
99        let table = compiler.symbols.get_id("compiler_const_table::GEM_TABLE")?;
100        let (_, symbol) = compiler.symbols.get_symbol(table)?;
101        let Symbol::Const { value, .. } = symbol else {
102            panic!("GEM_TABLE should be a const symbol");
103        };
104
105        let first = value.get_idx(0).expect("first table row");
106        assert_eq!(first.get_dynamic("key").expect("key").as_str(), "atk");
107        assert_eq!(first.get_dynamic("score").expect("score").as_int(), Some(3));
108        Ok(())
109    }
110
111    #[test]
112    fn const_unary_neg_handles_min_integer_literal() -> anyhow::Result<()> {
113        let mut compiler = Compiler::new();
114        compiler.import_code(
115            "compiler_const_min_int",
116            br#"
117            pub const MIN_I32: i32 = -2147483648i32;
118            "#
119            .to_vec(),
120        )?;
121
122        let id = compiler.symbols.get_id("compiler_const_min_int::MIN_I32")?;
123        let (_, symbol) = compiler.symbols.get_symbol(id)?;
124        let Symbol::Const { value, .. } = symbol else {
125            panic!("MIN_I32 should be a const symbol");
126        };
127        assert_eq!(value.as_int(), Some(i32::MIN as i64));
128        Ok(())
129    }
130
131    #[test]
132    fn return_check_resolves_function_args_before_body_compile() -> anyhow::Result<()> {
133        let mut compiler = Compiler::new();
134        compiler.import_code(
135            "compiler_return_check_args",
136            br#"
137            pub fn no_value_return(flag: bool) {
138                if flag {
139                    return;
140                }
141            }
142
143            pub fn tail_if(flag: bool) {
144                if flag {
145                    1
146                } else {
147                    2
148                }
149            }
150
151            pub fn loop_index(low: i64, high: i64) {
152                let total = 0i64;
153                for i in low..high {
154                    total += i;
155                }
156                total
157            }
158
159            pub fn closure_capture() {
160                let base = 10i32;
161                let add_base = |value: i32| {
162                    value + base
163                };
164                add_base(1i32)
165            }
166
167            pub fn destructured_names() {
168                let (left, right) = (3i32, 4i32);
169                let [first, second] = [5i32, 6i32];
170                let _ = first;
171                left + right + second
172            }
173            "#
174            .to_vec(),
175        )?;
176
177        let no_value_return = compiler.symbols.get_id("compiler_return_check_args::no_value_return")?;
178        assert_eq!(compiler.infer_fn(no_value_return, &[Type::Bool])?, Type::Void);
179
180        let tail_if = compiler.symbols.get_id("compiler_return_check_args::tail_if")?;
181        assert_eq!(compiler.infer_fn(tail_if, &[Type::Bool])?, Type::I32);
182
183        let loop_index = compiler.symbols.get_id("compiler_return_check_args::loop_index")?;
184        assert_eq!(compiler.infer_fn(loop_index, &[Type::I64, Type::I64])?, Type::I64);
185
186        Ok(())
187    }
188
189    #[test]
190    fn return_check_infers_raw_assoc_calls_before_body_compile() -> anyhow::Result<()> {
191        let mut compiler = Compiler::new();
192        compiler.import_code(
193            "compiler_return_check_assoc",
194            br#"
195            pub struct Box<N> {
196                data: [u32; N],
197            }
198
199            impl Box<N> {
200                pub fn make() {
201                    Box<N>{ data: [0u32; N] }
202                }
203
204                pub fn ok(self: Box<N>) {
205                    true
206                }
207            }
208
209            pub fn main() {
210                let item = Box<2>::make();
211                if item.ok() {
212                    1i32
213                } else {
214                    0i32
215                }
216            }
217            "#
218            .to_vec(),
219        )?;
220
221        let main_id = compiler.symbols.get_id("compiler_return_check_assoc::main")?;
222        assert_eq!(compiler.infer_fn(main_id, &[])?, Type::I32);
223        Ok(())
224    }
225
226    #[test]
227    fn forward_function_call_in_bool_condition_infers_callee_first() -> anyhow::Result<()> {
228        let mut compiler = Compiler::new();
229        compiler.import_code(
230            "compiler_forward_bool",
231            br#"
232            pub fn can_start() {
233                if is_ready() {
234                    return true;
235                }
236                false
237            }
238
239            pub fn is_ready() {
240                true
241            }
242            "#
243            .to_vec(),
244        )?;
245
246        let can_start = compiler.symbols.get_id("compiler_forward_bool::can_start")?;
247        assert_eq!(compiler.infer_fn(can_start, &[])?, Type::Bool);
248
249        let is_ready = compiler.symbols.get_id("compiler_forward_bool::is_ready")?;
250        assert_eq!(compiler.infer_fn(is_ready, &[])?, Type::Bool);
251        Ok(())
252    }
253
254    #[test]
255    fn inferred_return_cache_keeps_pending_separate_from_any() -> anyhow::Result<()> {
256        let mut compiler = Compiler::new();
257        compiler.import_code(
258            "compiler_pending_any",
259            br#"
260            pub fn dynamic_value(value) {
261                value
262            }
263
264            pub fn bool_value() {
265                true
266            }
267            "#
268            .to_vec(),
269        )?;
270
271        let dynamic_value = compiler.symbols.get_id("compiler_pending_any::dynamic_value")?;
272        assert_eq!(compiler.infer_fn(dynamic_value, &[Type::Any])?, Type::Any);
273
274        let bool_value = compiler.symbols.get_id("compiler_pending_any::bool_value")?;
275        assert_eq!(compiler.infer_fn(bool_value, &[])?, Type::Bool);
276        Ok(())
277    }
278
279    #[test]
280    fn recursive_function_uses_inferred_return_seed() -> anyhow::Result<()> {
281        let mut compiler = Compiler::new();
282        compiler.import_code(
283            "compiler_recursive_return",
284            br#"
285            pub fn factorial(n: i64) {
286                if n <= 1 {
287                    return 1;
288                }
289                n * factorial(n - 1)
290            }
291
292            pub fn factorial_reversed(n: i64) {
293                if n > 1 {
294                    return n * factorial_reversed(n - 1);
295                }
296                1
297            }
298            "#
299            .to_vec(),
300        )?;
301
302        let factorial = compiler.symbols.get_id("compiler_recursive_return::factorial")?;
303        assert_eq!(compiler.infer_fn(factorial, &[Type::I64])?, Type::I64);
304
305        let factorial_reversed = compiler.symbols.get_id("compiler_recursive_return::factorial_reversed")?;
306        assert_eq!(compiler.infer_fn(factorial_reversed, &[Type::I64])?, Type::I64);
307        Ok(())
308    }
309
310    #[test]
311    fn generic_function_infers_type_param_from_arg() -> anyhow::Result<()> {
312        let mut compiler = Compiler::new();
313        compiler.import_code(
314            "compiler_generic_identity",
315            br#"
316            pub fn identity<T>(value: T) {
317                value
318            }
319            "#
320            .to_vec(),
321        )?;
322
323        let identity = compiler.symbols.get_id("compiler_generic_identity::identity")?;
324        assert_eq!(compiler.infer_fn(identity, &[Type::I64])?, Type::I64);
325        assert_eq!(compiler.infer_fn(identity, &[Type::Bool])?, Type::Bool);
326        Ok(())
327    }
328
329    #[test]
330    fn generic_function_uses_explicit_const_param() -> anyhow::Result<()> {
331        let mut compiler = Compiler::new();
332        compiler.import_code(
333            "compiler_generic_const",
334            br#"
335            pub fn value<N>() {
336                N
337            }
338            "#
339            .to_vec(),
340        )?;
341
342        let value = compiler.symbols.get_id("compiler_generic_const::value")?;
343        assert_eq!(compiler.infer_fn_with_params(value, &[], &[Type::ConstInt(7)])?, Type::I32);
344        Ok(())
345    }
346
347    #[test]
348    fn generic_function_infers_const_param_from_array_len() -> anyhow::Result<()> {
349        let mut compiler = Compiler::new();
350        compiler.import_code(
351            "compiler_generic_array_len",
352            br#"
353            pub fn len<N>(items: [i32; N]) {
354                N
355            }
356            "#
357            .to_vec(),
358        )?;
359
360        let len = compiler.symbols.get_id("compiler_generic_array_len::len")?;
361        assert_eq!(compiler.infer_fn(len, &[Type::Array(std::rc::Rc::new(Type::I32), 3)])?, Type::I32);
362        Ok(())
363    }
364
365    #[test]
366    fn generic_function_reports_uninferred_param() -> anyhow::Result<()> {
367        let mut compiler = Compiler::new();
368        compiler.import_code(
369            "compiler_generic_uninferred",
370            br#"
371            pub fn value<T>() {
372                1i32
373            }
374            "#
375            .to_vec(),
376        )?;
377
378        let value = compiler.symbols.get_id("compiler_generic_uninferred::value")?;
379        let err = compiler.infer_fn(value, &[]).expect_err("generic parameter should not be inferred");
380        assert!(format!("{err:#}").contains("无法从实参类型推断函数范型参数"));
381        Ok(())
382    }
383
384    #[test]
385    fn assignment_target_type_keeps_dynamic_index_sum_static() -> anyhow::Result<()> {
386        let mut compiler = Compiler::new();
387        compiler.import_code(
388            "compiler_dynamic_index_sum",
389            br#"
390            pub fn sum_list(n: i64) {
391                let l = [];
392                for i in 0..n {
393                    l.push(i);
394                }
395                let sum = 0i64;
396                for i in 0..n {
397                    sum = sum + l[i];
398                }
399                sum
400            }
401            "#
402            .to_vec(),
403        )?;
404
405        let sum_list = compiler.symbols.get_id("compiler_dynamic_index_sum::sum_list")?;
406        assert_eq!(compiler.infer_fn(sum_list, &[Type::I64])?, Type::I64);
407        Ok(())
408    }
409
410    #[test]
411    fn list_literal_infers_element_type() -> anyhow::Result<()> {
412        let mut compiler = Compiler::new();
413        compiler.import_code(
414            "compiler_list_elem_type",
415            br#"
416            pub fn pushed_empty() {
417                let items = [];
418                items.push(1i64);
419                items[0]
420            }
421
422            pub fn ints() {
423                [1i64, 2i64]
424            }
425
426            pub fn mixed_then_int() {
427                let items = [];
428                items.push(1i64);
429                items.push("aaa");
430                items.push(2i64);
431                items[0]
432            }
433
434            "#
435            .to_vec(),
436        )?;
437
438        let pushed_empty = compiler.symbols.get_id("compiler_list_elem_type::pushed_empty")?;
439        assert_eq!(compiler.infer_fn(pushed_empty, &[])?, Type::I64);
440        let hints = compiler.inferred_local_type_hints(pushed_empty, &[], &[]);
441        assert_eq!(hints.first().cloned().flatten(), Some(Type::List(std::rc::Rc::new(Type::I64))));
442
443        let ints = compiler.symbols.get_id("compiler_list_elem_type::ints")?;
444        assert_eq!(compiler.infer_fn(ints, &[])?, Type::Any);
445
446        let mixed_then_int = compiler.symbols.get_id("compiler_list_elem_type::mixed_then_int")?;
447        assert_eq!(compiler.infer_fn(mixed_then_int, &[])?, Type::Any);
448        let hints = compiler.inferred_local_type_hints(mixed_then_int, &[], &[]);
449        assert_eq!(hints.first().cloned().flatten(), None);
450        Ok(())
451    }
452
453    #[test]
454    fn return_map_and_struct_is_type_error() -> anyhow::Result<()> {
455        let mut compiler = Compiler::new();
456        let err = match compiler.import_code(
457            "compiler_return_map_struct",
458            br#"
459            struct S {
460                hp: i32,
461            }
462
463            pub fn make_s_or_error(flag: i32) {
464                if flag == 0 {
465                    return { error: "bad" };
466                }
467                S{hp: 123}
468            }
469            "#
470            .to_vec(),
471        ) {
472            Ok(_) => panic!("expected mismatched return types to fail"),
473            Err(err) => err,
474        };
475
476        assert!(format!("{err:#}").contains("返回类型不一致"));
477        Ok(())
478    }
479}
480
481fn has_unresolved_generic_param(ty: &Type) -> bool {
482    match ty {
483        Type::Ident { name, params } => {
484            if params.is_empty() {
485                name.chars().next().map(|ch| ch.is_ascii_uppercase()).unwrap_or(false)
486            } else {
487                params.iter().any(has_unresolved_generic_param)
488            }
489        }
490        Type::Struct { params, fields } => params.iter().any(has_unresolved_generic_param) || fields.iter().any(|(_, ty)| has_unresolved_generic_param(ty)),
491        Type::Tuple(items) => items.iter().any(has_unresolved_generic_param),
492        Type::List(elem) | Type::Vec(elem, _) | Type::Array(elem, _) => has_unresolved_generic_param(elem),
493        Type::ArrayParam(elem, len) => has_unresolved_generic_param(elem) || has_unresolved_generic_param(len),
494        Type::Fn { tys, ret } => tys.iter().any(has_unresolved_generic_param) || has_unresolved_generic_param(ret),
495        Type::Symbol { params, .. } => params.iter().any(has_unresolved_generic_param),
496        Type::ConstBinary { left, right, .. } => has_unresolved_generic_param(left) || has_unresolved_generic_param(right),
497        _ => false,
498    }
499}
500
501fn is_top_level_import_expr(expr: &Expr) -> bool {
502    matches!(
503        &expr.kind,
504        ExprKind::Call { obj, .. } if matches!(&obj.kind, ExprKind::Ident(name) if name.as_str() == "import")
505    )
506}
507
508fn string_value(expr: &Expr) -> Option<&str> {
509    if let ExprKind::Value(Dynamic::String(value)) = &expr.kind { Some(value.as_str()) } else { None }
510}
511
512fn import_decl(stmt: &Stmt) -> Option<(SmolStr, SmolStr)> {
513    let StmtKind::Expr(expr, _) = &stmt.kind else {
514        return None;
515    };
516    let ExprKind::Call { obj, params } = &expr.kind else {
517        return None;
518    };
519    let ExprKind::Ident(name) = &obj.kind else {
520        return None;
521    };
522    if name.as_str() != "import" {
523        return None;
524    }
525
526    match params.as_slice() {
527        [module, path] => Some((string_value(module)?.into(), string_value(path)?.into())),
528        [module] => match &module.kind {
529            ExprKind::Value(Dynamic::String(value)) => Some((value.clone(), format!("{value}.zs").into())),
530            ExprKind::Ident(value) => Some((value.clone(), format!("{value}.zs").into())),
531            _ => None,
532        },
533        _ => None,
534    }
535}
536
537fn generic_arg_for_name<'a>(name: &str, params: &'a [Type], args: &'a [Type]) -> Option<&'a Type> {
538    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))
539}
540
541pub fn infer_generic_args_from_types(generic_params: &[Type], decl_tys: &[Type], arg_tys: &[Type]) -> Vec<Type> {
542    if generic_params.is_empty() {
543        return Vec::new();
544    }
545    let mut inferred = vec![None; generic_params.len()];
546    for (decl, actual) in decl_tys.iter().zip(arg_tys.iter()) {
547        infer_generic_arg_from_type(generic_params, decl, actual, &mut inferred);
548    }
549    if inferred.iter().all(|item| item.is_some()) {
550        return inferred.into_iter().map(Option::unwrap).collect();
551    }
552    if let Some(Type::Struct { params, .. }) = arg_tys.iter().find(|ty| matches!(ty, Type::Struct { params, .. } if params.len() == generic_params.len())) {
553        return params.clone();
554    }
555    for (decl, actual) in decl_tys.iter().zip(arg_tys.iter()) {
556        if let (Type::Ident { params: decl_params, .. }, Type::Ident { params: actual_params, .. }) = (decl, actual)
557            && decl_params.len() == actual_params.len()
558            && decl_params.iter().any(|param| generic_params.contains(param))
559        {
560            return actual_params.clone();
561        }
562    }
563    Vec::new()
564}
565
566pub fn resolve_generic_args_from_types(generic_params: &[Type], decl_tys: &[Type], arg_tys: &[Type], explicit_args: &[Type]) -> Result<Vec<Type>> {
567    if generic_params.is_empty() {
568        if explicit_args.is_empty() {
569            return Ok(Vec::new());
570        }
571        return Err(anyhow!("函数不接受范型参数，但传入了 {}", explicit_args.len()));
572    }
573    if !explicit_args.is_empty() {
574        if explicit_args.len() == generic_params.len() {
575            return Ok(explicit_args.to_vec());
576        }
577        return Err(anyhow!("函数范型参数数量不匹配，期望 {} 个，实际 {} 个", generic_params.len(), explicit_args.len()));
578    }
579
580    let inferred = infer_generic_args_from_types(generic_params, decl_tys, arg_tys);
581    if inferred.len() == generic_params.len() {
582        Ok(inferred)
583    } else if generic_params.len() == 1
584        && let Some(Type::List(elem) | Type::Vec(elem, _) | Type::Array(elem, _)) = arg_tys.first()
585    {
586        Ok(vec![elem.as_ref().clone()])
587    } else {
588        Err(anyhow!("无法从实参类型推断函数范型参数 {:?}", generic_params))
589    }
590}
591
592fn infer_generic_arg_from_type(generic_params: &[Type], decl: &Type, actual: &Type, inferred: &mut [Option<Type>]) {
593    if let Some(idx) = generic_params.iter().position(|param| param == decl) {
594        inferred[idx] = Some(actual.clone());
595        return;
596    }
597
598    match (decl, actual) {
599        (Type::List(decl_elem), Type::List(actual_elem)) => {
600            infer_generic_arg_from_type(generic_params, decl_elem, actual_elem, inferred);
601        }
602        (Type::Vec(decl_elem, decl_len), Type::Vec(actual_elem, actual_len)) | (Type::Array(decl_elem, decl_len), Type::Array(actual_elem, actual_len)) => {
603            infer_generic_arg_from_type(generic_params, decl_elem, actual_elem, inferred);
604            infer_generic_arg_from_type(generic_params, &Type::ConstInt(*decl_len as i64), &Type::ConstInt(*actual_len as i64), inferred);
605        }
606        (Type::ArrayParam(decl_elem, decl_len), Type::Array(actual_elem, actual_len)) => {
607            infer_generic_arg_from_type(generic_params, decl_elem, actual_elem, inferred);
608            infer_generic_arg_from_type(generic_params, decl_len, &Type::ConstInt(*actual_len as i64), inferred);
609        }
610        (Type::Ident { params: decl_params, .. }, Type::Ident { params: actual_params, .. })
611        | (Type::Ident { params: decl_params, .. }, Type::Symbol { params: actual_params, .. })
612        | (Type::Symbol { params: decl_params, .. }, Type::Symbol { params: actual_params, .. })
613        | (Type::Symbol { params: decl_params, .. }, Type::Ident { params: actual_params, .. })
614        | (Type::Struct { params: decl_params, .. }, Type::Struct { params: actual_params, .. }) => {
615            for (decl, actual) in decl_params.iter().zip(actual_params.iter()) {
616                infer_generic_arg_from_type(generic_params, decl, actual, inferred);
617            }
618        }
619        _ => {}
620    }
621}
622
623fn substitute_pattern(pattern: &Pattern, params: &[Type], args: &[Type]) -> Pattern {
624    let kind = match &pattern.kind {
625        PatternKind::Ident { name, ty } => PatternKind::Ident { name: name.clone(), ty: substitute_type(ty, params, args) },
626        PatternKind::Var { idx, ty } => PatternKind::Var { idx: *idx, ty: substitute_type(ty, params, args) },
627        PatternKind::Tuple(items) => PatternKind::Tuple(items.iter().map(|item| substitute_pattern(item, params, args)).collect()),
628        PatternKind::List { elems, has_rest } => PatternKind::List { elems: elems.iter().map(|item| substitute_pattern(item, params, args)).collect(), has_rest: *has_rest },
629        other => other.clone(),
630    };
631    Pattern { kind, span: pattern.span }
632}
633
634fn substitute_expr(expr: &Expr, params: &[Type], args: &[Type]) -> Expr {
635    let kind = match &expr.kind {
636        ExprKind::Ident(name) => match generic_arg_for_name(name, params, args) {
637            Some(Type::ConstInt(value)) => ExprKind::Value(Dynamic::I32(*value as i32)),
638            Some(ty) => eval_const_int_type(ty).map(|value| ExprKind::Value(Dynamic::I32(value as i32))).unwrap_or_else(|| expr.kind.clone()),
639            _ => expr.kind.clone(),
640        },
641        ExprKind::Typed { value, ty } => ExprKind::Typed { value: Box::new(substitute_expr(value, params, args)), ty: substitute_type(ty, params, args) },
642        ExprKind::Unary { op, value } => ExprKind::Unary { op: op.clone(), value: Box::new(substitute_expr(value, params, args)) },
643        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)) },
644        ExprKind::Generic { obj, params: nested } => ExprKind::Generic { obj: Box::new(substitute_expr(obj, params, args)), params: nested.iter().map(|param| substitute_type(param, params, args)).collect() },
645        ExprKind::Assoc { ty, name } => ExprKind::Assoc { ty: substitute_type(ty, params, args), name: name.clone() },
646        ExprKind::TypedMethod { obj, ty, name } => ExprKind::TypedMethod { obj: Box::new(substitute_expr(obj, params, args)), ty: substitute_type(ty, params, args), name: name.clone() },
647        ExprKind::AssocId { id, params: nested } => ExprKind::AssocId { id: *id, params: nested.iter().map(|param| substitute_type(param, params, args)).collect() },
648        ExprKind::Tuple(items) => ExprKind::Tuple(items.iter().map(|item| substitute_expr(item, params, args)).collect()),
649        ExprKind::List(items) => ExprKind::List(items.iter().map(|item| substitute_expr(item, params, args)).collect()),
650        ExprKind::Repeat { value, len } => ExprKind::Repeat { value: Box::new(substitute_expr(value, params, args)), len: substitute_type(len, params, args) },
651        ExprKind::Dict(items) => ExprKind::Dict(items.iter().map(|(name, value)| (name.clone(), substitute_expr(value, params, args))).collect()),
652        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 },
653        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() },
654        ExprKind::Stmt(stmt) => ExprKind::Stmt(Box::new(substitute_stmt(stmt, params, args))),
655        ExprKind::Closure { args: closure_args, body } => {
656            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)) }
657        }
658        _ => expr.kind.clone(),
659    };
660    Expr::new(kind, expr.span)
661}
662
663pub fn substitute_stmt(stmt: &Stmt, params: &[Type], args: &[Type]) -> Stmt {
664    let kind = match &stmt.kind {
665        StmtKind::Let { pat, value } => StmtKind::Let { pat: substitute_pattern(pat, params, args), value: Box::new(substitute_stmt(value, params, args)) },
666        StmtKind::Expr(expr, close) => StmtKind::Expr(substitute_expr(expr, params, args), *close),
667        StmtKind::Block(stmts) => StmtKind::Block(stmts.iter().map(|stmt| substitute_stmt(stmt, params, args)).collect()),
668        StmtKind::Return(expr) => StmtKind::Return(expr.as_ref().map(|expr| substitute_expr(expr, params, args))),
669        StmtKind::While { cond, body } => StmtKind::While { cond: substitute_expr(cond, params, args), body: Box::new(substitute_stmt(body, params, args)) },
670        StmtKind::Loop(body) => StmtKind::Loop(Box::new(substitute_stmt(body, params, args))),
671        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)) },
672        StmtKind::Fn { name, generic_params, args: fn_args, body, is_pub } => StmtKind::Fn {
673            name: name.clone(),
674            generic_params: generic_params.iter().map(|param| substitute_type(param, params, args)).collect(),
675            args: fn_args.iter().map(|(name, ty)| (name.clone(), substitute_type(ty, params, args))).collect(),
676            body: Box::new(substitute_stmt(body, params, args)),
677            is_pub: *is_pub,
678        },
679        StmtKind::Struct { name, def, is_pub } => StmtKind::Struct { name: name.clone(), def: substitute_type(def, params, args), is_pub: *is_pub },
680        StmtKind::Impl { target, body } => StmtKind::Impl { target: substitute_type(target, params, args), body: Box::new(substitute_stmt(body, params, args)) },
681        StmtKind::If { cond, then_body, else_body } => StmtKind::If {
682            cond: substitute_expr(cond, params, args),
683            then_body: Box::new(substitute_stmt(then_body, params, args)),
684            else_body: else_body.as_ref().map(|body| Box::new(substitute_stmt(body, params, args))),
685        },
686        StmtKind::Static { name, ty, value, is_pub } => {
687            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 }
688        }
689        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 },
690        other => other.clone(),
691    };
692    Stmt::new(kind, stmt.span)
693}
694
695#[derive(Debug, Clone, Default)]
696pub struct Capture {
697    pub names: Vec<(SmolStr, Type)>,
698    pub vars: Vec<usize>,
699}
700
701impl Capture {
702    pub fn new(names: Vec<(SmolStr, Type)>) -> Self {
703        Self { names, vars: Vec::new() }
704    }
705
706    pub fn get(&mut self, name: &str) -> Option<usize> {
707        if let Some(idx) = self.names.iter().position(|n| n.0 == name) {
708            if let Some(pos) = self.vars.iter().position(|v| *v == idx) {
709                Some(pos)
710            } else {
711                self.vars.push(idx);
712                Some(self.vars.len() - 1)
713            }
714        } else {
715            None
716        }
717    }
718
719    pub fn get_type(&self, idx: u32) -> Option<Type> {
720        self.names.get(idx as usize).map(|(_, ty)| ty.clone())
721    }
722}
723
724use anyhow::{Context, Result, anyhow};
725use smol_str::SmolStr;
726use thiserror::Error;
727
728#[derive(Debug, Error)]
729#[error("{message}")]
730pub struct SpannedCompilerError {
731    pub message: String,
732    pub span: Span,
733}
734
735#[derive(Debug, Clone)]
736pub struct CompilerDiagnostic {
737    pub message: String,
738    pub span: Span,
739}
740
741impl Compiler {
742    pub fn clear(&mut self) {
743        self.frames.clear();
744        self.names.clear();
745        self.tys.clear();
746        self.list_elem_states.clear();
747        self.arg_counts.clear();
748    }
749
750    pub fn take_local_state(&mut self) -> (Vec<usize>, Vec<SmolStr>, Vec<Type>, Vec<Option<ListElemState>>, Vec<usize>) {
751        (std::mem::take(&mut self.frames), std::mem::take(&mut self.names), std::mem::take(&mut self.tys), std::mem::take(&mut self.list_elem_states), std::mem::take(&mut self.arg_counts))
752    }
753
754    pub fn restore_local_state(&mut self, state: (Vec<usize>, Vec<SmolStr>, Vec<Type>, Vec<Option<ListElemState>>, Vec<usize>)) {
755        self.frames = state.0;
756        self.names = state.1;
757        self.tys = state.2;
758        self.list_elem_states = state.3;
759        self.arg_counts = state.4;
760    }
761
762    pub fn get_value(&self, expr: &Expr) -> Option<Dynamic> {
763        match &expr.kind {
764            ExprKind::Value(v) => Some(v.clone()),
765            ExprKind::Const(idx) => self.consts.get(*idx).cloned(),
766            _ => None,
767        }
768    }
769
770    pub fn get_const(&mut self, value: Dynamic) -> usize {
771        self.consts.iter().position(|c| c == &value).unwrap_or_else(|| {
772            self.consts.push(value);
773            self.consts.len() - 1
774        })
775    }
776
777    fn normalize_self_assign(left: Expr, op: BinaryOp, right: Expr, span: Span, arg_count: usize) -> Expr {
778        if let Some(idx) = left.var()
779            && (idx as usize) < arg_count
780        {
781            let base_op = match op {
782                BinaryOp::AddAssign => Some(BinaryOp::Add),
783                BinaryOp::SubAssign => Some(BinaryOp::Sub),
784                BinaryOp::MulAssign => Some(BinaryOp::Mul),
785                BinaryOp::DivAssign => Some(BinaryOp::Div),
786                BinaryOp::ModAssign => Some(BinaryOp::Mod),
787                BinaryOp::ShlAssign => Some(BinaryOp::Shl),
788                BinaryOp::ShrAssign => Some(BinaryOp::Shr),
789                BinaryOp::BitAndAssign => Some(BinaryOp::BitAnd),
790                BinaryOp::BitOrAssign => Some(BinaryOp::BitOr),
791                BinaryOp::BitXorAssign => Some(BinaryOp::BitXor),
792                _ => None,
793            };
794            if let Some(op) = base_op {
795                let right = Expr::new(ExprKind::Binary { left: Box::new(left.clone()), op, right: Box::new(right) }, span);
796                return Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Assign, right: Box::new(right) }, span);
797            }
798        }
799        if op == BinaryOp::Assign
800            && let Some(idx) = left.var()
801            && idx as usize >= arg_count
802            && let ExprKind::Binary { left: rhs_left, op: rhs_op, right: rhs_right } = &right.kind
803            && rhs_left.var() == Some(idx)
804        {
805            let compound_op = match rhs_op {
806                BinaryOp::Add => Some(BinaryOp::AddAssign),
807                BinaryOp::Sub => Some(BinaryOp::SubAssign),
808                BinaryOp::Mul => Some(BinaryOp::MulAssign),
809                BinaryOp::Div => Some(BinaryOp::DivAssign),
810                BinaryOp::Mod => Some(BinaryOp::ModAssign),
811                BinaryOp::Shl => Some(BinaryOp::ShlAssign),
812                BinaryOp::Shr => Some(BinaryOp::ShrAssign),
813                BinaryOp::BitAnd => Some(BinaryOp::BitAndAssign),
814                BinaryOp::BitOr => Some(BinaryOp::BitOrAssign),
815                BinaryOp::BitXor => Some(BinaryOp::BitXorAssign),
816                _ => None,
817            };
818            if let Some(op) = compound_op {
819                return Expr::new(ExprKind::Binary { left: Box::new(left), op, right: Box::new((**rhs_right).clone()) }, span);
820            }
821        }
822        Expr::new(ExprKind::Binary { left: Box::new(left), op, right: Box::new(right) }, span)
823    }
824
825    pub fn top(&self) -> usize {
826        self.frames.last().copied().unwrap_or(0)
827    }
828
829    fn add_name(&mut self, name: SmolStr) -> u32 {
830        self.names.push(name);
831        (self.names.len() - self.top() - 1) as u32
832    }
833
834    fn list_elem_state_for_ty(ty: &Type) -> Option<ListElemState> {
835        match ty {
836            Type::List(elem) if elem.is_any() => Some(ListElemState::Unknown),
837            Type::List(elem) => Some(ListElemState::Known(elem.as_ref().clone())),
838            _ => None,
839        }
840    }
841
842    pub(crate) fn list_elem_state(&self, idx: u32) -> Option<ListElemState> {
843        self.list_elem_states.get(self.top() + idx as usize).cloned().flatten()
844    }
845
846    pub(crate) fn set_list_elem_state(&mut self, idx: u32, state: Option<ListElemState>) {
847        let pos = idx as usize + self.top();
848        if self.list_elem_states.len() <= pos {
849            self.list_elem_states.resize(pos + 1, None);
850        }
851        self.list_elem_states[pos] = state;
852    }
853
854    fn add_ty(&mut self, ty: Type) -> u32 {
855        self.list_elem_states.push(Self::list_elem_state_for_ty(&ty));
856        self.tys.push(ty);
857        (self.tys.len() - self.top() - 1) as u32
858    }
859
860    fn set_ty(&mut self, idx: u32, ty: Type) {
861        let pos = idx as usize + self.top();
862        if self.list_elem_states.len() <= pos {
863            self.list_elem_states.resize(pos + 1, None);
864        }
865        self.list_elem_states[pos] = Self::list_elem_state_for_ty(&ty);
866        if pos < self.tys.len() {
867            self.tys[pos] = ty;
868        } else if pos == self.tys.len() {
869            self.tys.push(ty);
870        } else {
871            self.tys.resize(pos + 1, Type::Any);
872            self.tys[pos] = ty;
873        }
874    }
875
876    pub fn add_symbol(&mut self, name: &str, s: Symbol) -> u32 {
877        self.symbols.add(name.into(), s)
878    }
879
880    pub fn new() -> Self {
881        let symbols = SymbolTable::default();
882        Self {
883            symbols,
884            tys: Vec::new(),
885            names: Vec::new(),
886            consts: Vec::with_capacity(10240),
887            frames: Vec::new(),
888            list_elem_states: Vec::new(),
889            arg_counts: Vec::new(),
890            fns: BTreeMap::new(),
891            local_type_hints: BTreeMap::new(),
892            infer_stack: Vec::new(),
893            importing_paths: BTreeSet::new(),
894        }
895    }
896
897    fn byte_to_line_col(src: &[u8], pos: usize) -> (usize, usize) {
898        let mut line = 1;
899        let mut col = 1;
900        for &b in src.iter().take(pos.min(src.len())) {
901            if b == b'\n' {
902                line += 1;
903                col = 1;
904            } else {
905                col += 1;
906            }
907        }
908        (line, col)
909    }
910
911    fn line_snippet(code: &[u8], span: Span) -> String {
912        let pos = span.start.min(code.len());
913        let line_start = code[..pos].iter().rposition(|&b| b == b'\n').map(|idx| idx + 1).unwrap_or(0);
914        let line_end = code[pos..].iter().position(|&b| b == b'\n').map(|idx| pos + idx).unwrap_or(code.len());
915        String::from_utf8_lossy(&code[line_start..line_end]).into_owned()
916    }
917
918    fn semantic_error(span: Span, message: impl Into<String>) -> anyhow::Error {
919        SpannedCompilerError { message: message.into(), span }.into()
920    }
921
922    fn format_compile_error(code: &[u8], err: anyhow::Error) -> anyhow::Error {
923        if let Some(err) = err.downcast_ref::<SpannedCompilerError>() {
924            let pos = err.span.start.min(code.len());
925            let (line, col) = Self::byte_to_line_col(code, pos);
926            let snippet = Self::line_snippet(code, err.span);
927            anyhow!("语义错误：第 {line} 行，第 {col} 列（字节偏移 {pos}）：{}\n{}", err.message, snippet)
928        } else {
929            err
930        }
931    }
932
933    pub fn parse_code(code: Vec<u8>) -> Result<Vec<Stmt>> {
934        let mut p = Parser::new(code.clone());
935        let mut stmts = Vec::new();
936        loop {
937            match p.stmt(false) {
938                Ok(stmt) => stmts.push(stmt),
939                Err(e) => {
940                    if p.is_eof() {
941                        return Ok(stmts);
942                    }
943                    let pos = p.current_pos();
944                    let (line, col) = Self::byte_to_line_col(&code, pos);
945                    return Err(anyhow!("解析错误：第 {line} 行，第 {col} 列（字节偏移 {pos}）：{e:#}\n{}", p.error_stmt()));
946                }
947            }
948        }
949    }
950
951    pub fn import_code(&mut self, name: &str, code: Vec<u8>) -> Result<Vec<u32>> {
952        self.import_code_with_base_dir(name, code, None)
953    }
954
955    pub fn import_code_from_path(&mut self, name: &str, code: Vec<u8>, path: impl AsRef<Path>) -> Result<Vec<u32>> {
956        self.import_code_with_base_dir(name, code, path.as_ref().parent())
957    }
958
959    pub fn import_file(&mut self, name: &str, path: impl AsRef<Path>) -> Result<Vec<u32>> {
960        let path = path.as_ref();
961        let canonical = std::fs::canonicalize(path).with_context(|| format!("failed to resolve import path {}", path.display()))?;
962        if !self.importing_paths.insert(canonical.clone()) {
963            return Ok(Vec::new());
964        }
965        let code = std::fs::read(&canonical).with_context(|| format!("failed to read import path {}", canonical.display()))?;
966        let result = self.import_code_from_path(name, code, &canonical);
967        self.importing_paths.remove(&canonical);
968        result
969    }
970
971    fn import_code_with_base_dir(&mut self, name: &str, code: Vec<u8>, base_dir: Option<&Path>) -> Result<Vec<u32>> {
972        let stmts = Self::parse_code(code.clone())?;
973        log::debug!("func->{}", name);
974        for s in stmts.iter() {
975            log::debug!("{}", s);
976        }
977        self.resolve_imports(&stmts, base_dir).map_err(|err| Self::format_compile_error(&code, err))?;
978        self.clear();
979        self.compile(name.into(), stmts).map_err(|err| Self::format_compile_error(&code, err))
980    }
981
982    pub fn resolve_imports(&mut self, stmts: &[Stmt], base_dir: Option<&Path>) -> Result<()> {
983        for stmt in stmts {
984            let Some((module, path)) = import_decl(stmt) else {
985                continue;
986            };
987            if !self.symbols.symbol(module.as_str()).is_empty() {
988                continue;
989            }
990            let path = Path::new(path.as_str());
991            let resolved = if path.is_absolute() {
992                path.to_path_buf()
993            } else if let Some(base_dir) = base_dir {
994                base_dir.join(path)
995            } else {
996                std::env::current_dir()?.join(path)
997            };
998            self.import_file(module.as_str(), &resolved).with_context(|| format!("failed to import {module} from {}", resolved.display()))?;
999        }
1000        Ok(())
1001    }
1002
1003    pub fn check_code(name: &str, code: Vec<u8>) -> Vec<CompilerDiagnostic> {
1004        let mut parser = Parser::new(code.clone());
1005        let mut stmts = Vec::new();
1006        loop {
1007            match parser.stmt(false) {
1008                Ok(stmt) => stmts.push(stmt),
1009                Err(err) => {
1010                    if parser.is_eof() {
1011                        break;
1012                    }
1013                    return vec![CompilerDiagnostic { message: format!("解析错误：{err:#}"), span: Span::empty(parser.current_pos()) }];
1014                }
1015            }
1016        }
1017
1018        let mut compiler = Self::new();
1019        compiler.clear();
1020        match compiler.compile(name.into(), stmts) {
1021            Ok(_) => Vec::new(),
1022            Err(err) => {
1023                if let Some(err) = err.downcast_ref::<SpannedCompilerError>() {
1024                    vec![CompilerDiagnostic { message: err.message.clone(), span: err.span }]
1025                } else {
1026                    vec![CompilerDiagnostic { message: format!("{err:#}"), span: Span::default() }]
1027                }
1028            }
1029        }
1030    }
1031
1032    pub fn get_field(&self, ty: &Type, name: &str) -> Result<(usize, Type)> {
1033        self.symbols.get_field(ty, name)
1034    }
1035
1036    pub fn get_ident(&mut self, ident: &str, span: Span) -> Result<Expr> {
1037        for idx in (self.top()..self.names.len()).rev() {
1038            if self.names[idx].eq(ident) {
1039                return Ok(Expr::new(ExprKind::Var((idx - self.top()) as u32), span));
1040            }
1041        }
1042        let id = self.symbols.get_id(ident).map_err(|_| Self::semantic_error(span, format!("未找到标识符 {}", ident)))?;
1043        let s = self.symbols.get_symbol(id).map(|(_, v)| v.clone()).unwrap();
1044        if let Symbol::Const { value, ty, .. } = s {
1045            let c = self.get_const(value);
1046            return Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::Const(c), span)), ty }, span));
1047        } else if let Symbol::Static { value, ty, .. } = s
1048            && let Some(v) = value
1049        {
1050            let c = self.get_const(v);
1051            return Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::Const(c), span)), ty }, span));
1052        }
1053        Ok(Expr::new(ExprKind::Id(id, None), span))
1054    }
1055
1056    fn field_access_expr(&mut self, left: Expr, idx: usize, ty: Type, key: &str, span: Span) -> Expr {
1057        if let Type::Symbol { id, .. } = ty {
1058            Expr::new(ExprKind::Id(id, Some(Box::new(left))), span)
1059        } else if ty.is_bool() && idx == usize::MAX {
1060            Expr::new(ExprKind::Value(Dynamic::Bool(false)), span)
1061        } else if ty.is_any() && idx == usize::MAX {
1062            let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(key.into()))), span);
1063            Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, span)
1064        } else {
1065            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)
1066        }
1067    }
1068
1069    fn literal_field_access_expr(&mut self, left: Expr, key: &str, span: Span) -> Expr {
1070        let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(key.into()))), span);
1071        Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, span)
1072    }
1073
1074    fn type_field_access_expr(&mut self, left: Expr, key: &str, span: Span, prefer_dynamic_field: bool) -> Option<Expr> {
1075        let ty = self.infer_expr(&left).ok()?;
1076        if prefer_dynamic_field && ty.is_any() {
1077            return Some(self.literal_field_access_expr(left, key, span));
1078        }
1079        let (idx, field_ty) = self.get_field(&ty, key).ok()?;
1080        Some(self.field_access_expr(left, idx, field_ty, key, span))
1081    }
1082
1083    fn global_method_access_expr(&self, left: Expr, method: &str, span: Span) -> Result<Option<Expr>> {
1084        let Ok(id) = self.symbols.get_id(method) else {
1085            return Ok(None);
1086        };
1087        if self.symbols.get_symbol(id)?.1.is_fn() { Ok(Some(Expr::new(ExprKind::Id(id, Some(Box::new(left))), span))) } else { Ok(None) }
1088    }
1089
1090    fn method_call_obj_expr(&mut self, obj: &Expr, stmts: &mut Vec<Stmt>, cap: &mut Capture) -> Result<Option<Expr>> {
1091        if let ExprKind::TypedMethod { obj: left, ty, name } = &obj.kind {
1092            let left = self.eval(left, stmts, cap)?;
1093            let base_name = match ty {
1094                Type::Ident { name, .. } => name.clone(),
1095                Type::Symbol { id, .. } => self.symbols.get_symbol(*id)?.0.clone(),
1096                _ => return Err(Self::semantic_error(obj.span, format!("方法调用类型提示必须是类型: {:?}", ty))),
1097            };
1098            let method = format!("{}::{}", base_name, name);
1099            let id = self.symbols.get_id(&method).map_err(|_| Self::semantic_error(obj.span, format!("未找到类型方法 {}", method)))?;
1100            return Ok(Some(Expr::new(ExprKind::Id(id, Some(Box::new(left))), obj.span)));
1101        }
1102
1103        let ExprKind::Binary { left, op: BinaryOp::Idx, right } = &obj.kind else {
1104            return Ok(None);
1105        };
1106        let Some(method) = self.get_value(right).and_then(|v| if v.is_str() { Some(v.as_str().to_string()) } else { None }) else {
1107            return Ok(None);
1108        };
1109        let left = self.eval(left, stmts, cap)?;
1110        if let Some(field) = self.type_field_access_expr(left.clone(), &method, obj.span, false) {
1111            return Ok(Some(field));
1112        }
1113        if let Some(method_fn) = self.global_method_access_expr(left.clone(), &method, obj.span)? {
1114            return Ok(Some(method_fn));
1115        }
1116        Ok(Some(self.literal_field_access_expr(left, &method, obj.span)))
1117    }
1118
1119    pub fn compile_fn(&mut self, args: &[SmolStr], tys: &mut Vec<Type>, body: Stmt, cap: &mut Capture) -> Result<Vec<Stmt>> {
1120        let top = self.tys.len();
1121        self.frames.push(top);
1122        self.arg_counts.push(args.len());
1123        let result = (|| -> Result<Vec<Stmt>> {
1124            for (arg, ty) in args.iter().zip(tys.iter_mut()) {
1125                *ty = self.symbols.get_type(ty)?;
1126                self.add_name(arg.clone());
1127                self.add_ty(ty.clone());
1128            }
1129            if cap.names.is_empty() && tys.iter().all(|ty| !ty.is_any()) {
1130                let saved_state = (self.frames.clone(), self.names.clone(), self.tys.clone(), self.list_elem_states.clone(), self.arg_counts.clone());
1131                let result = self.check_return_type(&body);
1132                self.restore_local_state(saved_state);
1133                result?;
1134            }
1135            let mut compiled = Vec::new();
1136            self.compile_stmt(body, &mut compiled, cap)?;
1137            if !compiled.last_mut().map(|stmt| stmt.last_return()).unwrap_or(false) {
1138                compiled.push(Stmt::new(StmtKind::Return(None), Span::default()));
1139            }
1140            Ok(compiled)
1141        })();
1142        if let Some(top) = self.frames.pop() {
1143            self.tys.truncate(top);
1144            self.names.truncate(top);
1145            self.list_elem_states.truncate(top);
1146        }
1147        self.arg_counts.pop();
1148        result
1149    }
1150
1151    pub fn compile(&mut self, mod_name: SmolStr, stmts: Vec<Stmt>) -> Result<Vec<u32>> {
1152        self.symbols.add_module(mod_name.clone());
1153        for stmt in stmts {
1154            match stmt.kind {
1155                StmtKind::Struct { name, def, is_pub } => {
1156                    self.symbols.add(name, Symbol::Struct(def, is_pub));
1157                }
1158                StmtKind::Static { name, ty, value, is_pub } => {
1159                    self.symbols.add(name, Symbol::Static { value: value.and_then(|v| v.value().ok()), ty, is_pub });
1160                }
1161                StmtKind::Const { name, ty, value, is_pub } => {
1162                    let value = self.const_expr_value(&value)?;
1163                    self.symbols.add(name, Symbol::Const { value, ty, is_pub });
1164                }
1165                StmtKind::Fn { name, generic_params, args, body, is_pub } => {
1166                    let (ty, args) = Type::from_args(args);
1167                    self.symbols.add(name, Symbol::Fn { ty, args, generic_params, cap: Capture::default(), body: Arc::new(*body), is_pub });
1168                }
1169                StmtKind::Impl { target, body } => {
1170                    let name = impl_target_name(&target)?;
1171                    let def_id = match self.symbols.get_id(&name) {
1172                        Ok(id) => id,
1173                        Err(_) if name.as_str() == "Vec" => self.symbols.add(name.clone(), Symbol::Struct(Type::Struct { params: Vec::new(), fields: Vec::new() }, true)),
1174                        Err(err) => return Err(err),
1175                    };
1176                    if let StmtKind::Block(fns) = body.kind {
1177                        for f in fns {
1178                            if let StmtKind::Fn { name: fn_name, generic_params: fn_generic_params, args, body, is_pub } = f.kind {
1179                                let (ty, args) = Type::from_args(args);
1180                                let mut generic_params = if has_unresolved_generic_param(&target) {
1181                                    match &target {
1182                                        Type::Ident { params, .. } => params.clone(),
1183                                        _ => Vec::new(),
1184                                    }
1185                                } else {
1186                                    Vec::new()
1187                                };
1188                                for param in fn_generic_params {
1189                                    if !generic_params.contains(&param) {
1190                                        generic_params.push(param);
1191                                    }
1192                                }
1193                                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 });
1194                                if let Symbol::Struct(ty, _) = &mut self.symbols.symbols[def_id as usize] {
1195                                    ty.add_field(fn_name.into(), Type::Symbol { id: fn_id, params: Vec::new() })?;
1196                                }
1197                            } else {
1198                                log::debug!("impl 包含非函数语句 {:?}", f);
1199                            }
1200                        }
1201                    }
1202                }
1203                StmtKind::Expr(expr, _) if is_top_level_import_expr(&expr) => {}
1204                _ => {
1205                    log::debug!("未知的顶层语句 {:?}", stmt);
1206                }
1207            }
1208        }
1209        let mut fn_ids = Vec::new();
1210        for (name, id) in self.symbols.symbol(&mod_name) {
1211            log::debug!("compile symbol {:?}[{}]", name, id);
1212            if let Some((_, Symbol::Fn { ty, generic_params, .. })) = self.symbols.get_symbol(id).ok() {
1213                let resolved_ty = self.symbols.get_type(ty).unwrap_or_else(|_| ty.clone());
1214                if has_unresolved_generic_param(&resolved_ty) || !generic_params.is_empty() {
1215                    continue;
1216                }
1217            }
1218            if let Some(s) = self.symbols.get_symbol(id).ok().map(|(_, symbol)| symbol.clone()) {
1219                if let Symbol::Fn { ty, args, generic_params, mut cap, body, is_pub } = s {
1220                    if let Type::Fn { mut tys, ret } = ty {
1221                        let compiled = self.compile_fn(&args, &mut tys, body.as_ref().clone(), &mut cap)?;
1222                        for s in compiled.iter() {
1223                            log::debug!("{}", s);
1224                        }
1225                        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 };
1226                        fn_ids.push(id);
1227                    }
1228                }
1229            }
1230        }
1231        self.symbols.pop_module();
1232        Ok(fn_ids)
1233    }
1234
1235    fn pat_to_var(&mut self, pat: Pattern, expr_ty: Type) -> Result<Pattern> {
1236        match pat.kind {
1237            PatternKind::Var { idx, ty } => Ok(Pattern { kind: PatternKind::Var { idx, ty }, span: pat.span }),
1238            PatternKind::Ident { name, ty } => {
1239                let ty = self.symbols.get_type(&ty)?;
1240                let ty = if ty.is_any() { expr_ty } else { ty };
1241                self.add_ty(ty.clone());
1242                Ok(Pattern { kind: PatternKind::Var { idx: self.add_name(name), ty }, span: pat.span })
1243            }
1244            PatternKind::Tuple(pats) => {
1245                if let Type::Tuple(tys) = &expr_ty {
1246                    let pats: Vec<Pattern> = pats.into_iter().zip(tys).filter_map(|p| self.pat_to_var(p.0, p.1.clone()).ok()).collect();
1247                    if pats.len() == tys.len() { Ok(Pattern { kind: PatternKind::Tuple(pats), span: pat.span }) } else { Err(Self::semantic_error(pat.span, format!("模式与元组类型不匹配: {:?}", expr_ty))) }
1248                } else {
1249                    let pats = pats.into_iter().filter_map(|p| self.pat_to_var(p, Type::Any).ok()).collect();
1250                    Ok(Pattern { kind: PatternKind::Tuple(pats), span: pat.span })
1251                }
1252            }
1253            PatternKind::List { elems, has_rest } => {
1254                if expr_ty.is_any() {
1255                    let elems: Vec<Pattern> = elems.into_iter().filter_map(|p| self.pat_to_var(p, Type::Any).ok()).collect();
1256                    Ok(Pattern { kind: PatternKind::List { elems, has_rest }, span: pat.span })
1257                } else if let Type::List(elem_ty) | Type::Array(elem_ty, _) | Type::Vec(elem_ty, _) = &expr_ty {
1258                    let elems: Vec<Pattern> = elems.into_iter().filter_map(|p| self.pat_to_var(p, elem_ty.as_ref().clone()).ok()).collect();
1259                    Ok(Pattern { kind: PatternKind::List { elems, has_rest }, span: pat.span })
1260                } else {
1261                    Err(Self::semantic_error(pat.span, format!("列表模式 {:?} 与类型 {:?} 不匹配", elems, expr_ty)))
1262                }
1263            }
1264            PatternKind::Wildcard => {
1265                self.add_ty(expr_ty.clone());
1266                Ok(Pattern { kind: PatternKind::Var { idx: self.add_name(SmolStr::new_static("")), ty: expr_ty }, span: pat.span })
1267            }
1268            _ => panic!("未知的模式 {:?}", pat),
1269        }
1270    }
1271
1272    fn infer_range_type(&self, range: &Expr) -> Type {
1273        if let ExprKind::Range { start, stop, .. } = &range.kind {
1274            let start_ty = start.get_type();
1275            let stop_ty = stop.get_type();
1276            if start_ty.is_any() {
1277                stop_ty
1278            } else if stop_ty.is_any() {
1279                start_ty
1280            } else if start_ty == Type::I32 && stop_ty.is_uint() {
1281                stop_ty
1282            } else if stop_ty == Type::I32 && start_ty.is_uint() {
1283                start_ty
1284            } else {
1285                start_ty + stop_ty
1286            }
1287        } else {
1288            range.get_type()
1289        }
1290    }
1291
1292    fn dyn_init(&mut self, expr: Expr, stmts: &mut Vec<Stmt>, items: Vec<(Expr, Expr)>, ty: Type) -> Expr {
1293        self.add_name("".into());
1294        let temp = self.add_ty(ty);
1295        let span = expr.span;
1296        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));
1297        for (idx, item) in items {
1298            let item_span = idx.span.merge(item.span);
1299            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);
1300            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));
1301        }
1302        Expr::new(ExprKind::Var(temp), span)
1303    }
1304
1305    fn is_spawn_closure_call(obj: &Expr, params: &[Expr]) -> bool {
1306        params.len() == 2 && matches!(&obj.kind, ExprKind::Ident(name) if name.as_str() == "spawn") && matches!(&params[0].kind, ExprKind::Closure { .. })
1307    }
1308
1309    fn eval_spawn_arg_pack(&mut self, expr: &Expr, stmts: &mut Vec<Stmt>, cap: &mut Capture) -> Result<Expr> {
1310        match &expr.kind {
1311            ExprKind::Tuple(items) | ExprKind::List(items) => Ok(Expr::new(ExprKind::Tuple(items.iter().map(|item| self.eval(item, stmts, cap)).collect::<Result<Vec<_>>>()?), expr.span)),
1312            _ => Err(Self::semantic_error(expr.span, "spawn closure args must be tuple")),
1313        }
1314    }
1315
1316    fn is_multi_assign_target(expr: &Expr) -> bool {
1317        matches!(expr.kind, ExprKind::Tuple(_) | ExprKind::List(_))
1318    }
1319
1320    fn push_assign(stmts: &mut Vec<Stmt>, left: Expr, right: Expr, span: Span) {
1321        stmts.push(Stmt::new(StmtKind::Expr(Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Assign, right: Box::new(right) }, span), true), span));
1322    }
1323
1324    fn temp_var(&mut self, ty: Type, span: Span) -> Expr {
1325        self.add_name("".into());
1326        let idx = self.add_ty(ty);
1327        Expr::new(ExprKind::Var(idx), span)
1328    }
1329
1330    fn typed_expr(value: Expr, ty: &Type) -> Expr {
1331        if ty.is_any() {
1332            value
1333        } else {
1334            let span = value.span;
1335            Expr::new(ExprKind::Typed { value: Box::new(value), ty: ty.clone() }, span)
1336        }
1337    }
1338
1339    fn lower_multi_assign(&mut self, left: &Expr, right: &Expr, stmts: &mut Vec<Stmt>, cap: &mut Capture, span: Span) -> Result<Expr> {
1340        let left_items = match &left.kind {
1341            ExprKind::Tuple(items) | ExprKind::List(items) => items,
1342            _ => return Err(Self::semantic_error(left.span, "多重赋值左侧必须是 tuple 或 list")),
1343        };
1344        if left_items.is_empty() {
1345            return Err(Self::semantic_error(left.span, "多重赋值左侧不能为空"));
1346        }
1347
1348        let mut temps = Vec::with_capacity(left_items.len());
1349        if let ExprKind::Tuple(right_items) | ExprKind::List(right_items) = &right.kind {
1350            if left_items.len() != right_items.len() {
1351                return Err(Self::semantic_error(span, format!("多重赋值数量不匹配: 左侧 {} 个，右侧 {} 个", left_items.len(), right_items.len())));
1352            }
1353            for item in right_items {
1354                let value = self.eval(item, stmts, cap)?;
1355                let ty = self.infer_expr(&value)?;
1356                let temp = self.temp_var(ty.clone(), item.span);
1357                Self::push_assign(stmts, temp.clone(), Self::typed_expr(value, &ty), item.span);
1358                temps.push((temp, ty));
1359            }
1360        } else {
1361            let value = self.eval(right, stmts, cap)?;
1362            let ty = self.infer_expr(&value)?;
1363            let source = self.temp_var(ty.clone(), right.span);
1364            Self::push_assign(stmts, source.clone(), Self::typed_expr(value, &ty), right.span);
1365            for idx in 0..left_items.len() {
1366                let item_span = left_items[idx].span;
1367                let item = Expr::new(ExprKind::Binary { left: Box::new(source.clone()), op: BinaryOp::Idx, right: Box::new(Expr::new(ExprKind::Value((idx as u32).into()), item_span)) }, item_span);
1368                let value = self.eval(&item, stmts, cap)?;
1369                let ty = self.infer_expr(&value)?;
1370                let temp = self.temp_var(ty.clone(), item_span);
1371                Self::push_assign(stmts, temp.clone(), Self::typed_expr(value, &ty), item_span);
1372                temps.push((temp, ty));
1373            }
1374        }
1375
1376        for (target, (temp, ty)) in left_items.iter().zip(temps.iter()) {
1377            let target = self.eval(target, stmts, cap)?;
1378            let assign_span = target.span.merge(temp.span);
1379            Self::push_assign(stmts, target, Self::typed_expr(temp.clone(), ty), assign_span);
1380        }
1381
1382        Ok(temps.last().map(|(temp, ty)| Self::typed_expr(temp.clone(), ty)).unwrap_or_else(|| Expr::new(ExprKind::Value(Dynamic::Null), span)))
1383    }
1384
1385    fn static_composite_literal(&self, expr: &Expr) -> Result<Option<Dynamic>> {
1386        match &expr.kind {
1387            ExprKind::List(items) | ExprKind::Tuple(items) => {
1388                let mut values = Vec::with_capacity(items.len());
1389                for item in items {
1390                    let Some(value) = self.static_literal_value(item)? else {
1391                        return Ok(None);
1392                    };
1393                    values.push(value);
1394                }
1395                Ok(Some(Dynamic::list(values)))
1396            }
1397            ExprKind::Dict(items) => {
1398                let mut values = BTreeMap::new();
1399                for (key, item) in items {
1400                    let Some(value) = self.static_literal_value(item)? else {
1401                        return Ok(None);
1402                    };
1403                    values.insert(key.clone(), value);
1404                }
1405                Ok(Some(Dynamic::map(values)))
1406            }
1407            _ => Ok(None),
1408        }
1409    }
1410
1411    fn static_literal_value(&self, expr: &Expr) -> Result<Option<Dynamic>> {
1412        match &expr.kind {
1413            ExprKind::Value(value) => Ok(Some(value.clone())),
1414            ExprKind::Const(idx) => Ok(self.consts.get(*idx).cloned()),
1415            ExprKind::Typed { value, ty } if ty.is_native() => Ok(self.static_literal_value(value)?.map(|value| ty.force(value)).transpose()?),
1416            _ => self.static_composite_literal(expr),
1417        }
1418    }
1419
1420    fn const_expr_value(&self, expr: &Expr) -> Result<Dynamic> {
1421        match &expr.kind {
1422            ExprKind::Value(value) => Ok(value.clone()),
1423            ExprKind::Const(idx) => self.consts.get(*idx).cloned().ok_or_else(|| Self::semantic_error(expr.span, format!("常量索引 {} 不存在", idx))),
1424            ExprKind::Ident(ident) => {
1425                let id = self.symbols.get_id(ident).map_err(|_| Self::semantic_error(expr.span, format!("未找到常量 {}", ident)))?;
1426                match self.symbols.get_symbol(id).map(|(_, symbol)| symbol) {
1427                    Ok(Symbol::Const { value, .. }) => Ok(value.clone()),
1428                    Ok(Symbol::Static { value: Some(value), .. }) => Ok(value.clone()),
1429                    _ => Err(Self::semantic_error(expr.span, format!("{} 不是可用于 const 的静态值", ident))),
1430                }
1431            }
1432            ExprKind::Typed { value, ty } if ty.is_native() => Ok(ty.force(self.const_expr_value(value)?)?),
1433            ExprKind::Typed { value, .. } => self.const_expr_value(value),
1434            ExprKind::List(items) | ExprKind::Tuple(items) => {
1435                let values = items.iter().map(|item| self.const_expr_value(item)).collect::<Result<Vec<_>>>()?;
1436                Ok(Dynamic::list(values))
1437            }
1438            ExprKind::Dict(items) => {
1439                let mut values = BTreeMap::new();
1440                for (key, item) in items {
1441                    values.insert(key.clone(), self.const_expr_value(item)?);
1442                }
1443                Ok(Dynamic::map(values))
1444            }
1445            ExprKind::Unary { op, value } => {
1446                let value = self.const_expr_value(value)?;
1447                match op {
1448                    parser::UnaryOp::Neg => Ok(-value),
1449                    parser::UnaryOp::Not => Ok(!value),
1450                    parser::UnaryOp::Unknow => Err(Self::semantic_error(expr.span, "const 一元表达式无法在编译期求值")),
1451                }
1452            }
1453            ExprKind::Binary { left, op, right } => {
1454                let left = Expr::new(ExprKind::Value(self.const_expr_value(left)?), left.span);
1455                let right = Expr::new(ExprKind::Value(self.const_expr_value(right)?), right.span);
1456                Expr::new(ExprKind::Binary { left: Box::new(left), op: op.clone(), right: Box::new(right) }, expr.span).compact().ok_or_else(|| Self::semantic_error(expr.span, "const 二元表达式无法在编译期求值"))
1457            }
1458            _ => Err(Self::semantic_error(expr.span, "const 只能使用字面量、已声明常量和静态 composite literal")),
1459        }
1460    }
1461
1462    fn eval_stmt_expr(&mut self, stmt: &Stmt, stmts: &mut Vec<Stmt>, cap: &mut Capture, span: Span) -> Result<Expr> {
1463        self.compile_stmt(stmt.clone(), stmts, cap)?;
1464        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 };
1465        self.add_name("".into());
1466        let temp = self.add_ty(expr_ty.clone());
1467        let pat = Pattern { kind: PatternKind::Var { idx: temp, ty: expr_ty }, span };
1468        stmts.last_mut().ok_or_else(|| Self::semantic_error(span, "没有生成可求值语句表达式")).and_then(|stmt| stmt.bind_pattern(pat))?;
1469        Ok(Expr::new(ExprKind::Var(temp), span))
1470    }
1471
1472    fn eval(&mut self, expr: &Expr, stmts: &mut Vec<Stmt>, cap: &mut Capture) -> Result<Expr> {
1473        match &expr.kind {
1474            ExprKind::Stmt(stmt) => self.eval_stmt_expr(stmt, stmts, cap, expr.span),
1475            ExprKind::Closure { args, body } => {
1476                let (mut names, mut tys): (Vec<SmolStr>, Vec<Type>) = args.clone().into_iter().unzip();
1477                let top = self.top();
1478                let mut cap_vars: Vec<(SmolStr, Type)> = self.names[top..].iter().zip(self.tys[top..].iter()).map(|(n, ty)| (n.clone(), ty.clone())).collect();
1479                let parent_cap_start = cap_vars.len();
1480                cap_vars.extend(cap.names.iter().cloned());
1481                let mut local_cap = Capture::new(cap_vars);
1482                let _ = self.compile_fn(names.as_slice(), &mut tys.clone(), *body.clone(), &mut local_cap)?;
1483                for cap_idx in local_cap.vars.iter() {
1484                    if *cap_idx >= parent_cap_start {
1485                        let _ = cap.get(&local_cap.names[*cap_idx].0);
1486                    }
1487                    names.push(local_cap.names[*cap_idx].0.clone());
1488                    tys.push(local_cap.names[*cap_idx].1.clone());
1489                }
1490                let mut compiled = self.compile_fn(names.as_slice(), &mut tys.clone(), *body.clone(), &mut Capture::default())?;
1491                let (ty, args) = Type::from_args(args.clone());
1492                let body_stmt = if compiled.len() == 1 { compiled.pop().unwrap() } else { Stmt::new(StmtKind::Block(compiled), expr.span) };
1493                let name = SmolStr::from(format!("__closure_{}_{}", expr.span.start, expr.span.end));
1494                let fn_id = self.symbols.add(name, Symbol::Fn { ty, args, generic_params: Vec::new(), cap: local_cap, body: Arc::new(body_stmt), is_pub: false });
1495                Ok(Expr::new(ExprKind::Id(fn_id, None), expr.span))
1496            }
1497            ExprKind::Value(v) => {
1498                if v.is_native() {
1499                    Ok(Expr::new(ExprKind::Value(v.clone()), expr.span))
1500                } else {
1501                    Ok(Expr::new(ExprKind::Const(self.get_const(v.clone())), expr.span))
1502                }
1503            }
1504            ExprKind::Typed { value, ty } => {
1505                let ty = self.symbols.get_type(ty)?;
1506                if let Type::Struct { fields, .. } = &ty
1507                    && let ExprKind::Dict(dict) = &value.kind
1508                {
1509                    let mut items = Vec::new();
1510                    for field in fields {
1511                        if let Some((_, v)) = dict.iter().find(|(name, _)| name == &field.0) {
1512                            items.push(self.eval(v, stmts, cap)?);
1513                        }
1514                    }
1515                    Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::List(items), expr.span)), ty }, expr.span))
1516                } else if let Type::Struct { .. } = &ty
1517                    && let ExprKind::List(list) = &value.kind
1518                {
1519                    let items = list.iter().map(|item| self.eval(item, stmts, cap)).collect::<Result<Vec<_>>>()?;
1520                    Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::List(items), expr.span)), ty }, expr.span))
1521                } else if let Type::Array(_, _) = &ty
1522                    && let ExprKind::List(list) = &value.kind
1523                {
1524                    let items = list.iter().map(|item| self.eval(item, stmts, cap)).collect::<Result<Vec<_>>>()?;
1525                    Ok(Expr::new(ExprKind::Typed { value: Box::new(Expr::new(ExprKind::List(items), expr.span)), ty }, expr.span))
1526                } else if value.is_value() {
1527                    let value = value.clone().value()?;
1528                    if ty.is_str() && value.is_str() {
1529                        log::warn!("常量 String 只能作为动态值使用，已忽略 string 类型约束");
1530                        Ok(Expr::new(ExprKind::Const(self.get_const(value)), expr.span))
1531                    } else {
1532                        Ok(Expr::new(ExprKind::Value(ty.force(value)?), expr.span))
1533                    }
1534                } else {
1535                    Ok(Expr::new(ExprKind::Typed { value: Box::new(self.eval(value, stmts, cap)?), ty }, expr.span))
1536                }
1537            }
1538            ExprKind::Ident(ident) => match self.get_ident(ident, expr.span) {
1539                Ok(id) => Ok(id),
1540                Err(_) => {
1541                    if let Some(idx) = cap.get(ident) {
1542                        Ok(Expr::new(ExprKind::Capture(idx as u32), expr.span))
1543                    } else {
1544                        Err(Self::semantic_error(expr.span, format!("未找到标识符 {}", ident)))
1545                    }
1546                }
1547            },
1548            ExprKind::Generic { obj, params } => {
1549                let obj = self.eval(obj, stmts, cap)?;
1550                let params = params.iter().map(|param| self.symbols.get_type(param).unwrap_or_else(|_| param.clone())).collect();
1551                match obj.kind {
1552                    ExprKind::Id(id, None) | ExprKind::AssocId { id, .. } => Ok(Expr::new(ExprKind::AssocId { id, params }, expr.span)),
1553                    _ => Err(Self::semantic_error(expr.span, format!("范型参数只能用于函数或关联函数调用: {:?}", obj))),
1554                }
1555            }
1556            ExprKind::Assoc { ty, name } => {
1557                let base_name = match ty {
1558                    Type::Ident { name, .. } => name.clone(),
1559                    Type::Symbol { id, .. } => self.symbols.get_symbol(*id)?.0.clone(),
1560                    _ => return Err(Self::semantic_error(expr.span, format!("关联函数目标必须是类型: {:?}", ty))),
1561                };
1562                let id = self.symbols.get_id(&format!("{}::{}", base_name, name)).map_err(|_| Self::semantic_error(expr.span, format!("未找到关联函数 {}::{}", base_name, name)))?;
1563                let params = match ty {
1564                    Type::Ident { params, .. } | Type::Symbol { params, .. } => params.iter().map(|param| self.symbols.get_type(param).unwrap_or_else(|_| param.clone())).collect(),
1565                    _ => Vec::new(),
1566                };
1567                Ok(Expr::new(ExprKind::AssocId { id, params }, expr.span))
1568            }
1569            ExprKind::Unary { op, value } => {
1570                let value = Expr::new(ExprKind::Unary { op: op.clone(), value: Box::new(self.eval(value, stmts, cap)?) }, expr.span);
1571                if let Some(v) = value.compact() { Ok(Expr::new(ExprKind::Value(v), expr.span)) } else { Ok(value) }
1572            }
1573            ExprKind::Binary { left, op, right } => {
1574                if *op == BinaryOp::Assign && Self::is_multi_assign_target(left) {
1575                    return self.lower_multi_assign(left, right, stmts, cap, expr.span);
1576                }
1577                let left = self.eval(left, stmts, cap)?;
1578                if *op == BinaryOp::Idx {
1579                    if let Some(key) = self.get_value(right).and_then(|v| if v.is_str() { Some(v.as_str().to_string()) } else { None }) {
1580                        if let Some(field) = self.type_field_access_expr(left.clone(), &key, expr.span, true) {
1581                            return Ok(field);
1582                        }
1583                        return Ok(self.literal_field_access_expr(left, &key, expr.span));
1584                    } else if let Ok(ident) = right.ident() {
1585                        if let Ok(found) = self.get_ident(ident, right.span) {
1586                            return Ok(if let Some(id) = found.id() {
1587                                Expr::new(ExprKind::Id(id, Some(Box::new(left))), expr.span)
1588                            } else {
1589                                Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(found) }, expr.span)
1590                            });
1591                        }
1592                        if let Ok(ty) = self.infer_expr(&left)
1593                            && let Ok((idx, ty)) = self.get_field(&ty, ident)
1594                        {
1595                            return Ok(if let Type::Symbol { id, .. } = ty {
1596                                Expr::new(ExprKind::Id(id, Some(Box::new(left))), expr.span)
1597                            } else if ty.is_bool() && idx == usize::MAX {
1598                                Expr::new(ExprKind::Value(Dynamic::Bool(false)), expr.span)
1599                            } else if ty.is_any() && idx == usize::MAX {
1600                                let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(ident.into()))), expr.span);
1601                                Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, expr.span)
1602                            } else {
1603                                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)
1604                            });
1605                        } else {
1606                            let right = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(ident.into()))), expr.span);
1607                            return Ok(Expr::new(ExprKind::Binary { left: Box::new(left), op: BinaryOp::Idx, right: Box::new(right) }, expr.span));
1608                        }
1609                    }
1610                }
1611                let right = self.eval(right, stmts, cap)?;
1612                let value = Self::normalize_self_assign(left, op.clone(), right, expr.span, self.arg_counts.last().copied().unwrap_or(0));
1613                if let Some(v) = value.compact() { Ok(Expr::new(ExprKind::Value(v), expr.span)) } else { Ok(value) }
1614            }
1615            ExprKind::Call { obj, params } => {
1616                let params: Vec<Expr> = if Self::is_spawn_closure_call(obj, params) {
1617                    vec![self.eval(&params[0], stmts, cap)?, self.eval_spawn_arg_pack(&params[1], stmts, cap)?]
1618                } else {
1619                    params.iter().map(|p| self.eval(p, stmts, cap)).collect::<Result<Vec<_>>>()?
1620                };
1621                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) };
1622                match obj_result {
1623                    Ok(obj) if obj.is_value() && params.is_empty() => Ok(obj),
1624                    Ok(obj) => Ok(Expr::new(ExprKind::Call { obj: Box::new(obj), params }, expr.span)),
1625                    Err(e) => {
1626                        if let ExprKind::Ident(ident) = &obj.kind {
1627                            let fn_id = if ident.contains("::") { self.symbols.add_global(ident.clone(), Symbol::Null) } else { self.symbols.add(ident.clone(), Symbol::Null) };
1628                            Ok(Expr::new(ExprKind::Call { obj: Box::new(Expr::new(ExprKind::Id(fn_id, None), obj.span)), params }, expr.span))
1629                        } else {
1630                            Err(e)
1631                        }
1632                    }
1633                }
1634            }
1635            ExprKind::Range { start, stop, inclusive } => {
1636                let start = Box::new(self.eval(start, stmts, cap)?);
1637                let stop = Box::new(self.eval(stop, stmts, cap)?);
1638                Ok(Expr::new(ExprKind::Range { start, stop, inclusive: *inclusive }, expr.span))
1639            }
1640            ExprKind::List(list) | ExprKind::Tuple(list) => {
1641                if let Some(value) = self.static_composite_literal(expr)? {
1642                    let idx = self.get_const(value);
1643                    return Ok(Expr::new(ExprKind::Const(idx), expr.span));
1644                }
1645                let mut v = Vec::new();
1646                let mut items = Vec::new();
1647                for (idx, item) in list.iter().enumerate() {
1648                    if item.is_value() {
1649                        v.push(item.clone().value().unwrap());
1650                    } else {
1651                        items.push((Expr::new(ExprKind::Value((idx as u32).into()), item.span), self.eval(item, stmts, cap)?));
1652                        v.push(Dynamic::Null);
1653                    }
1654                }
1655                let list = Expr::new(ExprKind::Const(self.get_const(Dynamic::list(v))), expr.span);
1656                Ok(self.dyn_init(list, stmts, items, Type::Any))
1657            }
1658            ExprKind::Repeat { value, len } => {
1659                let len = self.symbols.get_type(len)?;
1660                let Type::ConstInt(len) = len else {
1661                    return Err(Self::semantic_error(expr.span, format!("重复数组长度必须是编译期整数: {:?}", len)));
1662                };
1663                if len < 0 {
1664                    return Err(Self::semantic_error(expr.span, "重复数组长度不能为负数"));
1665                }
1666                Ok(Expr::new(ExprKind::Repeat { value: Box::new(self.eval(value, stmts, cap)?), len: Type::ConstInt(len) }, expr.span))
1667            }
1668            ExprKind::Dict(dict) => {
1669                if let Some(value) = self.static_composite_literal(expr)? {
1670                    let idx = self.get_const(value);
1671                    return Ok(Expr::new(ExprKind::Const(idx), expr.span));
1672                }
1673                let mut dyn_kv = Vec::new();
1674                let mut m = BTreeMap::new();
1675                for (k, v) in dict {
1676                    if v.is_value() {
1677                        m.insert(k.clone(), v.clone().value()?);
1678                    } else {
1679                        let key = Expr::new(ExprKind::Const(self.get_const(Dynamic::String(k.clone()))), v.span);
1680                        dyn_kv.push((key, self.eval(v, stmts, cap)?));
1681                        m.insert(k.clone(), Dynamic::Null);
1682                    }
1683                }
1684                let dict = Expr::new(ExprKind::Const(self.get_const(Dynamic::map(m))), expr.span);
1685                Ok(self.dyn_init(dict, stmts, dyn_kv, Type::Any))
1686            }
1687            ExprKind::Id(_, _) | ExprKind::AssocId { .. } => Ok(expr.clone()),
1688            _ => Ok(expr.clone()),
1689        }
1690    }
1691
1692    fn get_stmt(&mut self, stmt: Stmt, cap: &mut Capture) -> Result<Stmt> {
1693        let span = stmt.span;
1694        let mut stmts = Vec::new();
1695        self.compile_stmt(stmt, &mut stmts, cap)?;
1696        Ok(Stmt::new(StmtKind::Block(stmts), span))
1697    }
1698
1699    fn compile_stmt(&mut self, stmt: Stmt, compiled: &mut Vec<Stmt>, cap: &mut Capture) -> Result<()> {
1700        let stmt_span = stmt.span;
1701        match stmt.kind {
1702            StmtKind::Let { mut pat, value } => {
1703                let value = *value;
1704                let string_literal_constraint = matches!(
1705                    (&pat.kind, &value.kind),
1706                    (
1707                        PatternKind::Ident { ty: Type::Str, .. },
1708                        StmtKind::Expr(
1709                            Expr {
1710                                kind: ExprKind::Value(value),
1711                                ..
1712                            },
1713                            _
1714                        )
1715                    ) if value.is_str()
1716                );
1717                if string_literal_constraint {
1718                    log::warn!("常量 String 只能作为动态值使用，已忽略 string 类型约束");
1719                    if let PatternKind::Ident { ty, .. } = &mut pat.kind {
1720                        *ty = Type::Any;
1721                    }
1722                }
1723                let annotated_ty = if let PatternKind::Ident { ty, .. } = &pat.kind {
1724                    let ty = self.symbols.get_type(ty)?;
1725                    if ty.is_any() { None } else { Some(ty) }
1726                } else {
1727                    None
1728                };
1729                let pattern_expr_ty = if matches!(pat.kind, PatternKind::List { .. } | PatternKind::Tuple(_)) { if let StmtKind::Expr(expr, _) = &value.kind { Some(self.infer_expr(expr)?) } else { None } } else { None };
1730                if let Some(ty) = annotated_ty {
1731                    if let StmtKind::Expr(expr, close) = value.kind {
1732                        let span = expr.span;
1733                        let typed = Expr::new(ExprKind::Typed { value: Box::new(expr), ty }, span);
1734                        self.compile_stmt(Stmt::new(StmtKind::Expr(typed, close), value.span), compiled, cap)?;
1735                    } else {
1736                        self.compile_stmt(value, compiled, cap)?;
1737                    }
1738                } else {
1739                    self.compile_stmt(value, compiled, cap)?;
1740                }
1741                let expr_ty = if let Some(ty) = pattern_expr_ty {
1742                    ty
1743                } else if let Some(stmt) = compiled.last() {
1744                    if let StmtKind::Expr(expr, _) = &stmt.kind { self.infer_expr(expr)? } else { self.infer_stmt(stmt)? }
1745                } else {
1746                    Type::Any
1747                };
1748                let pat = self.pat_to_var(pat, expr_ty)?;
1749                compiled.last_mut().ok_or_else(|| Self::semantic_error(stmt_span, "没有生成可绑定模式的编译语句")).and_then(|stmt| stmt.bind_pattern(pat))?;
1750            }
1751            StmtKind::Expr(expr, close) => {
1752                if let ExprKind::Binary { left, op: BinaryOp::Assign, right } = &expr.kind
1753                    && Self::is_multi_assign_target(left)
1754                {
1755                    self.lower_multi_assign(left, right, compiled, cap, stmt_span)?;
1756                    return Ok(());
1757                }
1758                let e = self.eval(&expr, compiled, cap)?;
1759                compiled.push(Stmt::new(StmtKind::Expr(e, close), stmt_span));
1760            }
1761            StmtKind::Block(stmts) => {
1762                let mut block = Vec::new();
1763                for stmt in stmts {
1764                    self.compile_stmt(stmt, &mut block, cap)?;
1765                }
1766                compiled.push(Stmt::new(StmtKind::Block(block), stmt_span));
1767            }
1768            StmtKind::Fn { name, generic_params, args, body, is_pub } => {
1769                let (ty, args) = Type::from_args(args);
1770                if let Type::Fn { mut tys, ret } = ty {
1771                    let mut fn_cap = Capture::default();
1772                    let compiled_body = self.compile_fn(&args, &mut tys, *body, &mut fn_cap)?;
1773                    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 });
1774                } else {
1775                    panic!("nested functions are not supported here")
1776                }
1777            }
1778            StmtKind::Return(expr) => {
1779                let expr = expr.and_then(|e| self.eval(&e, compiled, cap).ok());
1780                compiled.push(Stmt::new(StmtKind::Return(expr), stmt_span));
1781            }
1782            StmtKind::If { cond, then_body, else_body } => {
1783                let cond = self.eval(&cond, compiled, cap)?;
1784                if let Some(cond_value) = cond.compact()
1785                    && let Some(cond_bool) = cond_value.as_bool()
1786                {
1787                    if cond_bool {
1788                        self.compile_stmt(*then_body, compiled, cap)?;
1789                    } else if let Some(body) = else_body {
1790                        self.compile_stmt(*body, compiled, cap)?;
1791                    }
1792                } else {
1793                    let then_body = Box::new(self.get_stmt(*then_body, cap)?);
1794                    let else_body = if let Some(body) = else_body { Some(Box::new(self.get_stmt(*body, cap)?)) } else { None };
1795                    compiled.push(Stmt::new(StmtKind::If { cond, then_body, else_body }, stmt_span));
1796                }
1797            }
1798            StmtKind::Loop(body) => {
1799                compiled.push(Stmt::new(StmtKind::Loop(Box::new(self.get_stmt(*body, cap)?)), stmt_span));
1800            }
1801            StmtKind::While { cond, body } => {
1802                let cond = self.eval(&cond, compiled, cap)?;
1803                compiled.push(Stmt::new(StmtKind::While { cond, body: Box::new(self.get_stmt(*body, cap)?) }, stmt_span));
1804            }
1805            StmtKind::For { pat, range, body } => {
1806                let range = self.eval(&range, compiled, cap)?;
1807                let range_ty = self.infer_range_type(&range);
1808                let pat = self.pat_to_var(pat, range_ty)?;
1809                compiled.push(Stmt::new(StmtKind::For { pat, range, body: Box::new(self.get_stmt(*body, cap)?) }, stmt_span));
1810            }
1811            stmt_kind => {
1812                compiled.push(Stmt::new(stmt_kind, stmt_span));
1813            }
1814        }
1815        Ok(())
1816    }
1817}