1use super::{Compiler, FnInferRet, ListElemState, Symbol};
2use anyhow::Result;
3use dynamic::{Dynamic, Type};
4use parser::{BinaryOp, Expr, ExprKind, Pattern, PatternKind, Span, Stmt, StmtKind, UnaryOp};
5
6#[derive(Clone)]
7struct ReturnInfo {
8 ty: Type,
9 shape: Option<Type>,
10}
11
12impl Compiler {
13 fn current_infer_key(&self) -> Option<(u32, Vec<Type>, Vec<Type>)> {
14 self.infer_stack.last().cloned()
15 }
16
17 fn pending_return_seed(&self, id: u32, generic_args: &[Type], fn_tys: &[Type]) -> Option<Type> {
18 self.fns.get(&id).and_then(|fns| {
19 fns.iter().find_map(|item| {
20 if item.0 == generic_args
21 && item.1 == fn_tys
22 && let FnInferRet::Pending(seed) = &item.2
23 {
24 seed.clone()
25 } else {
26 None
27 }
28 })
29 })
30 }
31
32 fn update_pending_return_seed(&mut self, ty: &Type) {
33 if ty.is_any() {
34 return;
35 }
36 let Some((id, generic_args, fn_tys)) = self.current_infer_key() else {
37 return;
38 };
39 let Some(fns) = self.fns.get_mut(&id) else {
40 return;
41 };
42 if let Some(item) = fns.iter_mut().find(|item| item.0 == generic_args && item.1 == fn_tys)
43 && let FnInferRet::Pending(seed) = &mut item.2
44 {
45 let next = seed.take().map(|prev| prev + ty.clone()).unwrap_or_else(|| ty.clone());
46 *seed = Some(next);
47 }
48 }
49
50 fn add_pattern_bindings_for_infer(&mut self, pat: &Pattern, expr_ty: Type) -> Result<()> {
51 match &pat.kind {
52 PatternKind::Ident { name, ty } => {
53 let annotated_ty = self.symbols.get_type(ty)?;
54 self.add_name(name.clone());
55 self.add_ty(if annotated_ty.is_any() { expr_ty } else { annotated_ty });
56 }
57 PatternKind::Var { idx, .. } => self.set_ty(*idx, expr_ty),
58 PatternKind::Tuple(pats) => {
59 if let Type::Tuple(tys) = expr_ty {
60 for (pat, ty) in pats.iter().zip(tys) {
61 self.add_pattern_bindings_for_infer(pat, ty)?;
62 }
63 } else {
64 for pat in pats {
65 self.add_pattern_bindings_for_infer(pat, Type::Any)?;
66 }
67 }
68 }
69 PatternKind::List { elems, .. } => {
70 for pat in elems {
71 self.add_pattern_bindings_for_infer(pat, Type::Any)?;
72 }
73 }
74 PatternKind::Wildcard => {
75 self.add_name("".into());
76 self.add_ty(expr_ty);
77 }
78 PatternKind::Literal(_) | PatternKind::Member(_, _) | PatternKind::Idx(_, _) => {}
79 }
80 Ok(())
81 }
82
83 fn for_pattern_ty(&mut self, range: &Expr) -> Result<Type> {
84 if matches!(range.kind, ExprKind::Range { .. }) {
85 return self.infer_range_expr(range);
86 }
87 Ok(match self.infer_expr(range)? {
88 Type::Array(elem_ty, _) | Type::Vec(elem_ty, _) | Type::List(elem_ty) => elem_ty.as_ref().clone(),
89 _ => Type::Any,
90 })
91 }
92
93 fn infer_range_expr(&mut self, range: &Expr) -> Result<Type> {
94 let ExprKind::Range { start, stop, .. } = &range.kind else {
95 return self.infer_expr(range);
96 };
97 let start_ty = self.infer_expr(start)?;
98 let stop_ty = self.infer_expr(stop)?;
99 Ok(Self::merge_range_bound_types(start_ty, stop_ty))
100 }
101
102 fn merge_range_bound_types(start_ty: Type, stop_ty: Type) -> Type {
103 if start_ty.is_any() {
104 stop_ty
105 } else if stop_ty.is_any() {
106 start_ty
107 } else if start_ty == Type::I32 && stop_ty.is_uint() {
108 stop_ty
109 } else if stop_ty == Type::I32 && start_ty.is_uint() {
110 start_ty
111 } else {
112 start_ty + stop_ty
113 }
114 }
115
116 fn merge_return_type(span: Span, left: Option<Type>, right: Type) -> Result<Type> {
117 match left {
118 Some(left) if left == right => Ok(left),
119 Some(left) if left.is_void() || right.is_void() => Err(Self::semantic_error(span, format!("返回类型不一致: {:?} 和 {:?}", left, right))),
120 Some(left) => Ok(left + right),
121 None => Ok(right),
122 }
123 }
124
125 fn return_shape(&self, expr: &Expr, ty: &Type) -> Option<Type> {
126 if !ty.is_any() {
127 return match ty {
128 Type::Struct { .. } => Some(ty.clone()),
129 Type::Map => Some(Type::Map),
130 Type::List(elem) | Type::Array(elem, _) => Some(Type::List(elem.clone())),
131 _ => None,
132 };
133 }
134 match &expr.kind {
135 ExprKind::List(_) | ExprKind::Tuple(_) => Some(Type::list_any()),
136 ExprKind::Dict(_) => Some(Type::Map),
137 ExprKind::Value(value) => Self::dynamic_return_shape(value.get_type()),
138 ExprKind::Const(idx) => self.consts.get(*idx).and_then(|value| Self::dynamic_return_shape(value.get_type())),
139 ExprKind::Typed { ty, .. } => Some(ty.clone()),
140 _ => None,
141 }
142 }
143
144 fn dynamic_return_shape(ty: Type) -> Option<Type> {
145 match ty {
146 Type::Map => Some(Type::Map),
147 Type::List(elem) => Some(Type::List(elem)),
148 Type::Array(elem, _) => Some(Type::List(elem)),
149 _ => None,
150 }
151 }
152
153 fn local_var_idx_for_expr(&self, expr: &Expr) -> Option<u32> {
154 match &expr.kind {
155 ExprKind::Var(idx) => Some(*idx),
156 ExprKind::Ident(name) => (self.top()..self.names.len()).rev().find(|idx| self.names[*idx].eq(name)).map(|idx| (idx - self.top()) as u32),
157 _ => None,
158 }
159 }
160
161 fn infer_list_method(&mut self, target: &Expr, elem_ty: &Type, method: &str, params: &[Expr]) -> Result<Option<Type>> {
162 match method {
163 "get_idx" | "pop" => Ok(Some(match self.local_var_idx_for_expr(target).and_then(|idx| self.list_elem_state(idx)) {
164 Some(ListElemState::Known(ty)) => ty,
165 Some(ListElemState::Unknown | ListElemState::Mixed) => Type::Any,
166 None => elem_ty.clone(),
167 })),
168 "push" => {
169 let pushed_ty = params
170 .first()
171 .map(|param| {
172 if let Some(value) = self.get_value(param)
173 && (value.is_str() || value.is_native())
174 {
175 Ok(value.get_type())
176 } else {
177 self.infer_expr(param)
178 }
179 })
180 .transpose()?
181 .unwrap_or(Type::Any);
182 if let Some(idx) = self.local_var_idx_for_expr(target) {
183 let state = self.list_elem_state(idx).unwrap_or_else(|| if elem_ty.is_any() { ListElemState::Unknown } else { ListElemState::Known(elem_ty.clone()) });
184 let next_state = match state {
185 ListElemState::Unknown if pushed_ty.is_any() => ListElemState::Mixed,
186 ListElemState::Unknown => ListElemState::Known(pushed_ty),
187 ListElemState::Known(_) if pushed_ty.is_any() => ListElemState::Mixed,
188 ListElemState::Known(prev) => {
189 let merged = if prev == pushed_ty {
190 prev
191 } else if (prev.is_int() || prev.is_uint() || prev.is_float()) && (pushed_ty.is_int() || pushed_ty.is_uint() || pushed_ty.is_float()) {
192 prev + pushed_ty
193 } else {
194 Type::Any
195 };
196 if merged.is_any() { ListElemState::Mixed } else { ListElemState::Known(merged) }
197 }
198 ListElemState::Mixed => ListElemState::Mixed,
199 };
200 let next_elem = if let ListElemState::Known(ty) = &next_state { ty.clone() } else { Type::Any };
201 self.set_ty(idx, Type::List(std::rc::Rc::new(next_elem)));
202 self.set_list_elem_state(idx, Some(next_state));
203 }
204 Ok(Some(Type::Void))
205 }
206 "len" => Ok(Some(Type::I32)),
207 "is_list" | "is_null" => Ok(Some(Type::Bool)),
208 _ => Ok(None),
209 }
210 }
211
212 fn infer_return_expr(&mut self, expr: &Expr) -> Result<ReturnInfo> {
213 let ty = self.infer_expr(expr)?;
214 let shape = self.return_shape(expr, &ty);
215 let ty = if matches!(shape, Some(Type::Map | Type::List(_))) { Type::Any } else { ty };
216 Ok(ReturnInfo { ty, shape })
217 }
218
219 fn merge_return_info(span: Span, left: Option<ReturnInfo>, right: ReturnInfo) -> Result<ReturnInfo> {
220 let Some(left) = left else {
221 return Ok(right);
222 };
223 if let (Some(left_shape), Some(right_shape)) = (&left.shape, &right.shape)
224 && left_shape != right_shape
225 {
226 return Err(Self::semantic_error(span, format!("返回类型不一致: {:?} 和 {:?}", left_shape, right_shape)));
227 }
228 if let Some(left_shape) = &left.shape
229 && left_shape.is_struct()
230 && right.ty.is_any()
231 && right.shape.is_none()
232 {
233 return Err(Self::semantic_error(span, format!("返回类型不一致: {:?} 和 {:?}", left_shape, Type::Any)));
234 }
235 if let Some(right_shape) = &right.shape
236 && right_shape.is_struct()
237 && left.ty.is_any()
238 && left.shape.is_none()
239 {
240 return Err(Self::semantic_error(span, format!("返回类型不一致: {:?} 和 {:?}", Type::Any, right_shape)));
241 }
242 let ty = Self::merge_return_type(span, Some(left.ty), right.ty)?;
243 Ok(ReturnInfo { ty, shape: left.shape.or(right.shape) })
244 }
245
246 fn infer_return_type(&mut self, stmt: &Stmt) -> Result<Option<Type>> {
247 self.infer_returns(stmt, true).map(|(info, _)| info.map(|info| info.ty))
248 }
249
250 pub(crate) fn check_return_type(&mut self, stmt: &Stmt) -> Result<()> {
251 self.infer_returns(stmt, true).map(|_| ())
252 }
253
254 fn infer_returns(&mut self, stmt: &Stmt, tail: bool) -> Result<(Option<ReturnInfo>, bool)> {
255 match &stmt.kind {
256 StmtKind::Return(Some(expr)) => Ok((Some(self.infer_return_expr(expr)?), true)),
257 StmtKind::Return(None) => Ok((Some(ReturnInfo { ty: Type::Void, shape: Some(Type::Void) }), true)),
258 StmtKind::Block(stmts) => {
259 let mut ret = None;
260 for (idx, stmt) in stmts.iter().enumerate() {
261 let (info, always_returns) = self.infer_returns(stmt, tail && idx == stmts.len().saturating_sub(1))?;
262 if let Some(info) = info {
263 self.update_pending_return_seed(&info.ty);
264 ret = Some(Self::merge_return_info(stmt.span, ret, info)?);
265 if let Some(ret) = &ret {
266 self.update_pending_return_seed(&ret.ty);
267 }
268 }
269 if always_returns {
270 return Ok((ret, true));
271 }
272 }
273 Ok((ret, false))
274 }
275 StmtKind::If { cond, then_body, else_body } => {
276 let cond_ty = self.infer_expr(cond)?;
277 if cond_ty != Type::Bool {
278 return Err(Self::semantic_error(cond.span, format!("条件表达式必须是布尔类型，实际是 {:?}", cond_ty)));
279 }
280 let (mut ret, then_returns) = self.infer_returns(then_body, tail)?;
281 if let Some(ret) = &ret {
282 self.update_pending_return_seed(&ret.ty);
283 }
284 let else_returns = if let Some(body) = else_body {
285 let (else_ty, else_returns) = self.infer_returns(body, tail)?;
286 if let Some(info) = else_ty {
287 self.update_pending_return_seed(&info.ty);
288 ret = Some(Self::merge_return_info(body.span, ret, info)?);
289 if let Some(ret) = &ret {
290 self.update_pending_return_seed(&ret.ty);
291 }
292 }
293 else_returns
294 } else {
295 false
296 };
297 Ok((ret, then_returns && else_returns))
298 }
299 StmtKind::While { cond, body } => {
300 let cond_ty = self.infer_expr(cond)?;
301 if cond_ty != Type::Bool {
302 return Err(Self::semantic_error(cond.span, format!("条件表达式必须是布尔类型，实际是 {:?}", cond_ty)));
303 }
304 self.infer_returns(body, false).map(|(ty, _)| (ty, false))
305 }
306 StmtKind::Loop(body) => self.infer_returns(body, false),
307 StmtKind::For { pat, range, body } => {
308 let ty = self.for_pattern_ty(range)?;
309 self.add_pattern_bindings_for_infer(pat, ty)?;
310 self.infer_returns(body, false).map(|(ty, _)| (ty, false))
311 }
312 StmtKind::Let { .. } => {
313 self.infer_stmt(stmt)?;
314 Ok((None, false))
315 }
316 StmtKind::Expr(expr, close) => {
317 let info = self.infer_return_expr(expr)?;
318 Ok(if *close || !tail { (None, false) } else { (Some(info), true) })
319 }
320 _ => {
321 self.infer_stmt(stmt)?;
322 Ok((None, false))
323 }
324 }
325 }
326
327 pub fn infer_expr(&mut self, expr: &Expr) -> Result<Type> {
328 match &expr.kind {
329 ExprKind::Value(Dynamic::Null) => Ok(Type::Any),
330 ExprKind::Value(v) if v.is_list() => Ok(v.get_type()),
331 ExprKind::Value(v) if v.is_map() => Ok(Type::Any),
332 ExprKind::Value(v) => Ok(v.get_type()),
333 ExprKind::Const(idx) => Ok(if self.consts.get(*idx).is_some_and(|value| value.is_list() && value.len() == 0) { Type::list_any() } else { Type::Any }),
334 ExprKind::Var(idx) => {
335 let idx = self.top() + (*idx as usize);
336 if idx < self.tys.len() { self.symbols.get_type(&self.tys[idx]) } else { Ok(Type::Any) }
337 }
338 ExprKind::Ident(ident) => {
339 for idx in (self.top()..self.names.len()).rev() {
340 if self.names[idx].eq(ident) && idx < self.tys.len() {
341 return self.symbols.get_type(&self.tys[idx]);
342 }
343 }
344 let id = self.symbols.get_id(ident).map_err(|_| Self::semantic_error(expr.span, format!("未找到标识符 {}", ident)))?;
345 match self.symbols.get_symbol(id)?.1 {
346 Symbol::Const { ty, .. } => Ok(ty.clone()),
347 Symbol::Static { ty, .. } => Ok(ty.clone()),
348 Symbol::Struct(ty, _) => Ok(ty.clone()),
349 Symbol::Fn { .. } => Ok(Type::Symbol { id, params: Vec::new() }),
350 Symbol::Native(ty) => Ok(ty.clone()),
351 s => Err(Self::semantic_error(expr.span, format!("符号 {:?} 不是变量、常量、静态变量、结构体", s))),
352 }
353 }
354 ExprKind::Id(id, _) => match self.symbols.get_symbol(*id)?.1 {
355 Symbol::Const { ty, .. } => Ok(ty.clone()),
356 Symbol::Static { ty, .. } => Ok(ty.clone()),
357 Symbol::Struct(ty, _) => Ok(ty.clone()),
358 Symbol::Fn { .. } => Ok(Type::Symbol { id: *id, params: Vec::new() }),
359 Symbol::Native(ty) => Ok(ty.clone()),
360 s => Err(Self::semantic_error(expr.span, format!("符号 {:?} 不是变量、常量、静态变量、结构体", s))),
361 },
362 ExprKind::Generic { obj, params } => {
363 let params = params.iter().map(|param| self.symbols.get_type(param).unwrap_or_else(|_| param.clone())).collect();
364 match self.infer_expr(obj)? {
365 Type::Symbol { id, .. } => Ok(Type::Symbol { id, params }),
366 _ => Ok(Type::Any),
367 }
368 }
369 ExprKind::AssocId { id, params } => Ok(Type::Symbol { id: *id, params: params.clone() }),
370 ExprKind::Unary { op, value } => match op {
371 UnaryOp::Not => {
372 let ty = self.infer_expr(value.as_ref())?;
373 if ty.is_int() || ty.is_uint() { Ok(ty) } else { Ok(Type::Bool) }
374 }
375 UnaryOp::Neg => self.infer_expr(value.as_ref()),
376 UnaryOp::Unknow => Ok(Type::Any),
377 },
378 ExprKind::Binary { left, op, right } => {
379 let assign_idx = if op.is_assign() { if let ExprKind::Var(idx) = &left.kind { Some(*idx) } else { None } } else { None };
380 let ty = if op.is_logic() {
381 Type::Bool
382 } else if op == &BinaryOp::Idx {
383 let left_ty = self.infer_expr(left)?;
384 if let Type::Array(elem_ty, _) = left_ty {
385 (*elem_ty).clone()
386 } else if let Type::Vec(elem_ty, _) = left_ty {
387 (*elem_ty).clone()
388 } else if let Type::List(elem_ty) = left_ty {
389 (*elem_ty).clone()
390 } else {
391 let left_ty = self.symbols.get_type(&left_ty)?;
392 let right_ty = if right.is_value() || right.is_const() {
393 let right_value = if let ExprKind::Const(c) = &right.kind { self.consts[*c].clone() } else { right.clone().value()? };
394 if right_value.is_str() {
395 if left_ty.is_any() {
396 return Ok(Type::Any);
397 }
398 if let Ok(field) = self.symbols.get_field(&left_ty, right_value.as_str()) {
399 return if let Type::Fn { ret, .. } = field.1 { Ok(ret.as_ref().clone()) } else { Ok(field.1.clone()) };
400 }
401 } else if let Type::Struct { fields, .. } = &left_ty
402 && let Some(idx) = right_value.as_int()
403 {
404 return fields.get(idx as usize).map(|(_, ty)| ty.clone()).ok_or_else(|| Self::semantic_error(right.span, format!("结构字段索引越界 {}", idx)));
405 }
406 right_value.get_type()
407 } else {
408 self.infer_expr(right)?
409 };
410 if right_ty.is_int() || right_ty.is_uint() {
411 if left_ty.is_any() {
412 return Ok(Type::Any);
413 }
414 let (_, s) = self.symbols.get_field(&left_ty, "get_idx")?;
415 let fn_ty = self.symbols.get_type(&s)?;
416 return if let Type::Fn { ret, .. } = &fn_ty { Ok(ret.as_ref().clone()) } else { Ok(fn_ty) };
417 }
418 if left_ty.is_any() {
419 return Ok(Type::Any);
420 }
421 Type::Any
422 }
423 } else {
424 let left_ty = self.infer_expr(left)?;
425 let right_ty = self.infer_expr(right)?;
426 if op == &BinaryOp::Assign {
427 if !left_ty.is_any() && right_ty.is_any() { left_ty } else { right_ty }
428 } else if op.is_assign() && !left_ty.is_any() && right_ty.is_any() {
429 left_ty
430 } else {
431 left_ty + right_ty
432 }
433 };
434 assign_idx.map(|idx| self.set_ty(idx, ty.clone()));
435 Ok(ty)
436 }
437 ExprKind::Call { obj, params } => {
438 if let ExprKind::Assoc { ty, name } = &obj.kind {
439 let base_name = match ty {
440 Type::Ident { name, .. } => name.clone(),
441 Type::Symbol { id, .. } => self.symbols.get_symbol(*id)?.0.clone(),
442 _ => return Ok(Type::Any),
443 };
444 let id = self.symbols.get_id(&format!("{}::{}", base_name, name))?;
445 let generic_args = match ty {
446 Type::Ident { params, .. } | Type::Symbol { params, .. } => params.iter().map(|param| self.symbols.get_type(param).unwrap_or_else(|_| param.clone())).collect::<Vec<_>>(),
447 _ => Vec::new(),
448 };
449 let mut args = Vec::new();
450 for p in params {
451 args.push(self.infer_expr(p)?);
452 }
453 self.infer_fn_with_params(id, &args, &generic_args)
454 } else if let ExprKind::AssocId { id, params: generic_args } = &obj.kind {
455 let mut args = Vec::new();
456 for p in params {
457 args.push(self.infer_expr(p)?);
458 }
459 self.infer_fn_with_params(*id, &args, generic_args)
460 } else if let ExprKind::Generic { obj, params: generic_args } = &obj.kind {
461 let Type::Symbol { id, .. } = self.infer_expr(obj)? else {
462 return Ok(Type::Any);
463 };
464 let generic_args = generic_args.iter().map(|param| self.symbols.get_type(param).unwrap_or_else(|_| param.clone())).collect::<Vec<_>>();
465 let mut args = Vec::new();
466 for p in params {
467 args.push(self.infer_expr(p)?);
468 }
469 self.infer_fn_with_params(id, &args, &generic_args)
470 } else if let ExprKind::TypedMethod { obj: target, ty, name } = &obj.kind {
471 let base_name = match ty {
472 Type::Ident { name, .. } => name.clone(),
473 Type::Symbol { id, .. } => self.symbols.get_symbol(*id)?.0.clone(),
474 _ => return Ok(Type::Any),
475 };
476 let id = self.symbols.get_id(&format!("{}::{}", base_name, name))?;
477 let mut args = vec![self.infer_expr(target)?];
478 for p in params {
479 args.push(self.infer_expr(p)?);
480 }
481 self.infer_fn(id, &args)
482 } else if let ExprKind::Id(id, obj_expr) = &obj.kind {
483 let method = self.symbols.get_symbol(*id).ok().and_then(|(name, _)| name.rsplit_once("::").map(|(_, method)| method.to_string()));
484 if let Some(target) = obj_expr
485 && let Some(method) = method
486 {
487 let target_ty = self.infer_expr(target)?;
488 if let Type::List(elem_ty) | Type::Array(elem_ty, _) = &target_ty
489 && let Some(ret_ty) = self.infer_list_method(target, elem_ty, method.as_str(), params)?
490 {
491 return Ok(ret_ty);
492 }
493 }
494 let mut args: Vec<Type> = if let Some(obj) = obj_expr { vec![self.infer_expr(obj)?] } else { Vec::new() };
495 for p in params {
496 args.push(self.infer_expr(p)?);
497 }
498 self.infer_fn(*id, &args)
499 } else if let ExprKind::Ident(name) = &obj.kind {
500 for idx in (self.top()..self.names.len()).rev() {
501 if self.names[idx].eq(name) && idx < self.tys.len() {
502 return if let Type::Symbol { id, .. } = &self.tys[idx] {
503 let id = *id;
504 let mut args = Vec::new();
505 for p in params {
506 args.push(self.infer_expr(p)?);
507 }
508 self.infer_fn(id, &args)
509 } else {
510 Ok(Type::Any)
511 };
512 }
513 }
514 let Ok(id) = self.symbols.get_id(name) else {
515 return Ok(Type::Any);
516 };
517 if !self.symbols.get_symbol(id)?.1.is_fn() {
518 return Err(Self::semantic_error(obj.span, format!("符号 {} 不是函数", name)));
519 }
520 let mut args = Vec::new();
521 for p in params {
522 args.push(self.infer_expr(p)?);
523 }
524 self.infer_fn(id, &args)
525 } else if obj.is_idx() {
526 let (target, _, method) = obj.clone().binary().unwrap();
527 let ty = self.infer_expr(&target)?;
528 if let Some(method) = self.get_value(&method) {
529 let method = method.as_str();
530 if let Type::List(elem_ty) | Type::Array(elem_ty, _) = &ty
531 && let Some(ret_ty) = self.infer_list_method(&target, elem_ty, method, params)?
532 {
533 return Ok(ret_ty);
534 }
535 let fn_ty = match self.get_field(&ty, method) {
536 Ok((_, fn_ty)) => fn_ty,
537 Err(_) => {
538 let id = self.symbols.get_id(method)?;
539 if self.symbols.get_symbol(id)?.1.is_fn() {
540 Type::Symbol { id, params: Vec::new() }
541 } else {
542 return Err(Self::semantic_error(obj.span, format!("符号 {method} 不是函数")));
543 }
544 }
545 };
546 if let Type::Symbol { id, .. } = fn_ty {
547 let mut args = vec![ty];
548 for p in params {
549 args.push(self.infer_expr(p)?);
550 }
551 self.infer_fn(id, &args)
552 } else {
553 Ok(fn_ty)
554 }
555 } else {
556 Ok(Type::Any)
557 }
558 } else if let ExprKind::Var(idx) = &obj.kind {
559 let idx = self.top() + (*idx as usize);
560 if idx < self.tys.len()
561 && let Type::Symbol { id, .. } = self.tys[idx]
562 {
563 let mut args = Vec::new();
564 for p in params {
565 args.push(self.infer_expr(p)?);
566 }
567 self.infer_fn(id, &args)
568 } else {
569 Ok(Type::Any)
570 }
571 } else if obj.is_value() {
572 Ok(Type::Void)
573 } else {
574 Ok(Type::Any)
575 }
576 }
577 ExprKind::Typed { ty, .. } => self.symbols.get_type(ty),
578 ExprKind::Stmt(stmt) => self.infer_stmt(stmt),
579 ExprKind::Repeat { value, len } => {
580 let value_ty = self.infer_expr(value)?;
581 let len = self.symbols.get_type(len).unwrap_or_else(|_| len.clone());
582 if let Type::ConstInt(len) = len {
583 let len = u32::try_from(len).map_err(|_| Self::semantic_error(expr.span, "重复数组长度必须是非负 u32"))?;
584 Ok(Type::Array(std::rc::Rc::new(value_ty), len))
585 } else {
586 Ok(Type::ArrayParam(std::rc::Rc::new(value_ty), std::rc::Rc::new(len)))
587 }
588 }
589 ExprKind::List(items) => {
590 if items.is_empty() {
591 return Ok(Type::list_any());
592 }
593 let mut elem_ty = Type::Any;
594 for item in items {
595 let item_ty = self.infer_expr(item)?;
596 elem_ty = if elem_ty.is_any() { item_ty } else { elem_ty + item_ty };
597 }
598 Ok(Type::Array(std::rc::Rc::new(elem_ty), items.len() as u32))
599 }
600 ExprKind::Range { start, stop, .. } => {
601 let start_ty = self.infer_expr(start)?;
602 let stop_ty = self.infer_expr(stop)?;
603 Ok(Self::merge_range_bound_types(start_ty, stop_ty))
604 }
605 _ => Ok(Type::Any),
606 }
607 }
608
609 fn get_fn_tys(&mut self, tys: &[Type], arg_tys: &[Type]) -> Result<Vec<Type>> {
610 let mut fn_tys = Vec::new();
611 for (i, ty) in tys.iter().enumerate() {
612 if !ty.is_any() {
613 fn_tys.push(ty.clone());
614 } else if let Some(arg_ty) = arg_tys.get(i) {
615 fn_tys.push(self.symbols.get_type(arg_ty)?);
616 } else {
617 fn_tys.push(Type::Any);
618 }
619 }
620 Ok(fn_tys)
621 }
622
623 fn is_optimizable_local_ty(ty: &Type) -> bool {
624 ty.is_bool() || ty.is_native()
625 }
626
627 fn is_optimizable_list_elem_ty(ty: &Type) -> bool {
628 matches!(ty, Type::Bool | Type::U8 | Type::I8 | Type::U16 | Type::I16 | Type::U32 | Type::I32 | Type::F32 | Type::U64 | Type::I64 | Type::F64 | Type::Str)
629 }
630
631 fn local_type_hint_at(&self, pos: usize) -> Option<Type> {
632 let ty = self.tys.get(pos)?;
633 match ty {
634 Type::List(_) => self.list_elem_states.get(pos).cloned().flatten().and_then(|state| {
635 if let ListElemState::Known(elem_ty) = state
636 && Self::is_optimizable_list_elem_ty(&elem_ty)
637 {
638 Some(Type::List(std::rc::Rc::new(elem_ty)))
639 } else {
640 None
641 }
642 }),
643 ty if Self::is_optimizable_local_ty(ty) => Some(ty.clone()),
644 _ => None,
645 }
646 }
647
648 fn collect_local_type_hints(&self) -> Vec<Option<Type>> {
649 (self.top()..self.tys.len()).map(|pos| self.local_type_hint_at(pos)).collect()
650 }
651
652 fn set_local_type_hints(&mut self, id: u32, generic_args: &[Type], fn_tys: &[Type], hints: Vec<Option<Type>>) {
653 let items = self.local_type_hints.entry(id).or_default();
654 if let Some(item) = items.iter_mut().find(|item| item.0 == generic_args && item.1 == fn_tys) {
655 item.2 = hints;
656 } else {
657 items.push((generic_args.to_vec(), fn_tys.to_vec(), hints));
658 }
659 }
660
661 pub fn inferred_local_type_hints(&self, id: u32, generic_args: &[Type], fn_tys: &[Type]) -> Vec<Option<Type>> {
662 self.local_type_hints.get(&id).and_then(|items| items.iter().find(|item| item.0 == generic_args && item.1 == fn_tys)).map(|item| item.2.clone()).unwrap_or_default()
663 }
664
665 pub fn infer_fn(&mut self, id: u32, arg_tys: &[Type]) -> Result<Type> {
666 self.infer_fn_with_params(id, arg_tys, &[])
667 }
668
669 pub fn infer_fn_with_params(&mut self, id: u32, arg_tys: &[Type], generic_args: &[Type]) -> Result<Type> {
670 let (name, s) = self.symbols.get_symbol(id).map(|(n, s)| (n.clone(), s.clone()))?;
671 if let Symbol::Fn { ty, args, generic_params, cap, body, .. } = s {
672 if let Type::Fn { tys, ret: _ } = ty {
673 let resolved_generic_args = crate::resolve_generic_args_from_types(&generic_params, &tys, arg_tys, generic_args)?;
674 let generic_args = resolved_generic_args.as_slice();
675 let tys = if generic_params.is_empty() { tys } else { tys.iter().map(|ty| crate::substitute_type(ty, &generic_params, generic_args)).collect() };
676 let body = if generic_params.is_empty() { body.as_ref().clone() } else { crate::substitute_stmt(body.as_ref(), &generic_params, generic_args) };
677 let fn_tys = self.get_fn_tys(&tys, arg_tys)?;
678 let body = if generic_params.is_empty() {
679 body
680 } else {
681 let mut compile_tys = tys.clone();
682 let mut compile_cap = cap.clone();
683 let saved_state = self.take_local_state();
684 if let Some((module, _)) = name.split_once("::") {
685 self.symbols.push_module_scope(module.into());
686 }
687 let compiled = self.compile_fn(&args, &mut compile_tys, body, &mut compile_cap);
688 if name.contains("::") {
689 self.symbols.pop_module_scope();
690 }
691 self.restore_local_state(saved_state);
692 Stmt::new(StmtKind::Block(compiled?), Span::default())
693 };
694 if let Some(fns) = self.fns.get_mut(&id) {
695 for f in fns.iter() {
696 if f.0 == generic_args && f.1 == fn_tys {
697 return match &f.2 {
698 FnInferRet::Done(ret_ty) => self.symbols.get_type(ret_ty),
699 FnInferRet::Pending(seed) => seed.as_ref().map(|ty| self.symbols.get_type(ty)).unwrap_or(Ok(Type::Any)),
700 };
701 }
702 }
703 fns.push((generic_args.to_vec(), fn_tys.clone(), FnInferRet::Pending(None)));
704 } else {
705 self.fns.insert(id, vec![(generic_args.to_vec(), fn_tys.clone(), FnInferRet::Pending(None))]);
706 }
707 let mut ret_ty = None;
708 let mut local_type_hints = Vec::new();
709 for _ in 0..4 {
710 let before_seed = self.pending_return_seed(id, generic_args, &fn_tys);
711 let saved_state = self.take_local_state();
712 self.frames.push(0);
713 for (arg, ty) in args.iter().zip(fn_tys.iter()) {
714 self.add_name(arg.clone());
715 self.add_ty(ty.clone());
716 }
717 for c in cap.vars.iter() {
718 if let Some((name, ty)) = cap.names.get(*c) {
719 self.add_name(name.clone());
720 self.add_ty(ty.clone());
721 } else {
722 self.add_name("".into());
723 self.add_ty(Type::Any);
724 }
725 }
726 self.infer_stack.push((id, generic_args.to_vec(), fn_tys.clone()));
727 let pass_ret_ty = self.infer_return_type(&body).map(|ty| ty.unwrap_or(Type::Void));
728 self.infer_stack.pop();
729 let pass_local_type_hints = self.collect_local_type_hints();
730 self.restore_local_state(saved_state);
731 let pass_ret_ty = match pass_ret_ty {
732 Ok(pass_ret_ty) => self.symbols.get_type(&pass_ret_ty).unwrap_or(pass_ret_ty),
733 Err(err) => {
734 log::error!("infer_fn {} failed: {:?}", name, err);
735 let should_remove = self
736 .fns
737 .get_mut(&id)
738 .map(|fns| {
739 fns.retain(|item| item.0 != generic_args || item.1 != fn_tys || !matches!(item.2, FnInferRet::Pending(_)));
740 fns.is_empty()
741 })
742 .unwrap_or(false);
743 if should_remove {
744 self.fns.remove(&id);
745 }
746 return Err(err);
747 }
748 };
749 if !pass_ret_ty.is_any() {
750 self.update_pending_return_seed(&pass_ret_ty);
751 ret_ty = Some(pass_ret_ty.clone());
752 } else if ret_ty.is_none() {
753 ret_ty = Some(pass_ret_ty);
754 }
755 local_type_hints = pass_local_type_hints;
756 let after_seed = self.pending_return_seed(id, generic_args, &fn_tys);
757 if before_seed == after_seed {
758 break;
759 }
760 }
761 let ret_ty = ret_ty.unwrap_or(Type::Any);
762 self.fns.get_mut(&id).map(|f| {
763 f.iter_mut().find(|item| item.0 == generic_args && item.1 == fn_tys).map(|item| item.2 = FnInferRet::Done(ret_ty.clone()));
764 });
765 self.set_local_type_hints(id, generic_args, &fn_tys, local_type_hints);
766 if generic_args.is_empty()
767 && let Some((_, Symbol::Fn { ty: Type::Fn { ret, .. }, .. })) = self.symbols.get_symbol_mut(id)
768 && ret.is_any()
769 {
770 *ret = std::rc::Rc::new(ret_ty.clone());
771 }
772 Ok(ret_ty)
773 } else {
774 Ok(Type::Any)
775 }
776 } else if let Symbol::Native(f) = s {
777 if let Type::Fn { ret, .. } = f { Ok((*ret).clone()) } else { Ok(Type::Any) }
778 } else if matches!(s, Symbol::Null) {
779 Ok(Type::Any)
780 } else {
781 Err(Self::semantic_error(Span::default(), format!("符号 {:?} 不是函数", name)))
782 }
783 }
784
785 pub fn infer_stmt(&mut self, stmt: &Stmt) -> Result<Type> {
786 match &stmt.kind {
787 StmtKind::Expr(expr, close) => {
788 if !close {
789 self.infer_expr(expr)
790 } else {
791 self.infer_expr(expr)?;
792 Ok(Type::Void)
793 }
794 }
795 StmtKind::Return(expr) => {
796 if let Some(e) = expr {
797 self.infer_expr(e)
798 } else {
799 Ok(Type::Void)
800 }
801 }
802 StmtKind::Block(stmts) => {
803 for (idx, stmt) in stmts.iter().enumerate() {
804 let ty = self.infer_stmt(stmt)?;
805 if stmt.is_return() || idx == stmts.len() - 1 {
806 return Ok(ty);
807 }
808 }
809 Ok(Type::Void)
810 }
811 StmtKind::If { then_body, else_body, .. } => {
812 let then_ty = self.infer_stmt(then_body)?;
813 if let Some(e) = else_body {
814 let else_ty = self.infer_stmt(e)?;
815 if then_ty != else_ty {
816 log::info!("then 和 else 有不同类型 {:?} {:?}", then_ty, else_ty);
817 return Ok(if then_ty.is_any() { else_ty } else { then_ty });
818 }
819 }
820 if else_body.is_none() {
821 return Ok(Type::Void);
822 }
823 Ok(then_ty)
824 }
825 StmtKind::While { cond, body } => {
826 let cond_ty = self.infer_expr(cond)?;
827 if cond_ty != Type::Bool {
828 return Err(Self::semantic_error(cond.span, format!("条件表达式必须是布尔类型，实际是 {:?}", cond_ty)));
829 }
830 self.infer_stmt(body)
831 }
832 StmtKind::For { pat, range, body } => {
833 let ty = self.for_pattern_ty(range)?;
834 self.add_pattern_bindings_for_infer(pat, ty)?;
835 self.infer_stmt(body)
836 }
837 StmtKind::Let { pat, value } => {
838 let expr_ty = if let StmtKind::Expr(expr, _) = &value.kind { self.infer_expr(expr)? } else { self.infer_stmt(value)? };
839 self.add_pattern_bindings_for_infer(pat, expr_ty)?;
840 Ok(Type::Void)
841 }
842 _ => Ok(Type::Void),
843 }
844 }
845}