//! Type checker: resolves names, infers types, and lowers the syntax tree to HIR. use std::collections::{HashMap, HashSet}; use crate::ast::*; use crate::error::{Diag, PResult}; use crate::hir::*; use crate::cheader::{self, CTy}; use crate::stdlib::{self, ModuleValue}; use crate::types::{Num, Ty}; pub fn check(p: &Program) -> PResult { Checker::new().program(p, &[]) } /// The main file plus the files it imports (each after the files it imports). pub fn check_project(main: &Program, modules: &[(String, Program)]) -> PResult { Checker::new().program(main, modules) } /// Like `check_project`, with the C headers the program imports already read. pub fn check_project_c(main: &Program, modules: &[(String, Program)], clibs: Vec) -> PResult { let mut c = Checker::new(); c.clibs = clibs; c.program(main, modules) } /// What an `import` name stands for. #[derive(Clone, Debug)] enum Target { Builtin(&'static str), /// A file of the user's; the full import path (`utils`, `a.b`). User(String), /// A C header (index into `clibs`): its names are used as `zlib.name`. C(usize), /// One name picked from a C header with `import "zlib.h" { name }`. CItem(usize), } const BUILTINS: &[&str] = &[ "print", "int", "float", "char", "string", "error", "i8", "i16", "i32", "i64", "u8", "u16", "u32", "u64", "f32", "f64", ]; /// The number type a conversion like `u8(x)` produces. fn conversion_target(name: &str) -> Option { match name { "int" | "i64" => Some(Ty::Int), "float" | "f64" => Some(Ty::Float), "char" => Some(Ty::Char), n => Num::ALL.iter().find(|k| k.name() == n).map(|k| Ty::Num(*k)), } } /// A generic function, checked again for every set of types it is used with. #[derive(Clone)] struct GenericFn { decl: FuncDecl, module: String, } /// One use of a generic function that still needs its body checked. struct Instance { decl: FuncDecl, module: String, types: HashMap, /// `Some(type)` for a method of a generic type. owner: Option, } /// A generic struct or enum, made into a real type for every list of types it is used with. #[derive(Clone)] enum GenericType { Struct(StructDecl, String), Enum(EnumDecl, String), } /// The module part of a table name: `utils.Stack[m.P]` -> `utils`, `Stack[m.P]` -> ``. fn module_of(key: &str) -> &str { let head = key.split('[').next().unwrap(); head.rsplit_once('.').map_or("", |x| x.0) } #[derive(Clone)] struct FuncSig { params: Vec, ret: Ty, } /// Which cases of a `match` have been handled so far. #[derive(Default)] struct Cover { variants: HashSet, catch_all: bool, t: bool, f: bool, ints: HashSet, strs: HashSet, } struct VariantInfo { name: String, fields: Vec<(String, Ty)>, } struct EnumInfo { name: &'static str, variants: Vec, methods: HashMap, span: Span, } struct StructInfo { name: &'static str, fields: Vec<(String, Ty)>, methods: HashMap, span: Span, } struct Local { id: u32, ty: Ty, is_const: bool, } struct Checker { funcs: HashMap, /// Top-level constants: uses are replaced by their (call-free) value. consts: HashMap, structs: HashMap, enums: HashMap, /// The struct or enum whose method is being checked, if any. cur_struct: Option<&'static str>, /// Variables of the current function that can't be moved out by `return` /// because they only borrow someone else's data: `self`, parameters, loop elements. no_move: HashSet, scopes: Vec>, next_id: u32, ret: Ty, loops: u32, /// Optional variables known not to be `nil` at this point (after `if x != nil`). narrowed: HashSet, /// `import os`: the built-in modules this file may use. imports: HashMap, /// The module being checked (`""` for the main file). Names of items in other /// modules are `module.name`, in the tables above and in the HIR. cur_mod: String, all_imports: HashMap>, /// Modules that exist as files. known_modules: HashSet, /// Items (`mod.name`) and methods (`mod.Type.name`) declared without `pub`. private: HashSet, generics: HashMap, gtypes: HashMap, ifaces: HashMap, iface_decls: HashMap, /// The rules of the type parameters of each generic function/type (by table name). bounds_of: HashMap>>, /// While checking a generic function: what its type names (`T`) stand for. tsubst: HashMap, inst_queue: Vec, /// The C headers the program imports. clibs: Vec, /// Structs that come from C headers: table name -> how C spells the type. c_structs: HashMap, } // ---------- names used inside a function body (to find what a closure captures) ---------- fn idents_expr(e: &Expr, out: &mut HashSet) { match &e.kind { ExprKind::Ident(n) => { out.insert(n.clone()); } ExprKind::Int(_) | ExprKind::Float(_) | ExprKind::Bool(_) | ExprKind::Char(_) | ExprKind::Nil => {} ExprKind::Str(parts) => { for p in parts { if let StrPart::Expr(x) = p { idents_expr(x, out); } } } ExprKind::Array(xs) => xs.iter().for_each(|x| idents_expr(x, out)), ExprKind::MapLit { entries, .. } => entries.iter().for_each(|(k, v)| { idents_expr(k, out); idents_expr(v, out); }), ExprKind::StructLit { ty, fields } => { idents_expr(ty, out); fields.iter().for_each(|f| idents_expr(&f.value, out)); } ExprKind::Unary { expr, .. } | ExprKind::Field { expr, .. } | ExprKind::Generic { expr, .. } | ExprKind::Try(expr) | ExprKind::Shared(expr) | ExprKind::Weak(expr) => idents_expr(expr, out), ExprKind::Binary { lhs, rhs, .. } => { idents_expr(lhs, out); idents_expr(rhs, out); } ExprKind::Range { start, end } => { start.iter().chain(end.iter()).for_each(|x| idents_expr(x, out)); } ExprKind::Call { callee, args } => { idents_expr(callee, out); args.iter().for_each(|x| idents_expr(x, out)); } ExprKind::Index { expr, index } => { idents_expr(expr, out); idents_expr(index, out); } ExprKind::Closure { body, .. } => idents_block(body, out), ExprKind::Lambda { body, .. } => idents_expr(body, out), ExprKind::Match { scrutinee, arms } => { idents_expr(scrutinee, out); for a in arms { match &a.body { ArmBody::Expr(x) => idents_expr(x, out), ArmBody::Block(b) => idents_block(b, out), } } } } } fn idents_block(b: &Block, out: &mut HashSet) { b.stmts.iter().for_each(|s| idents_stmt(s, out)); } fn idents_stmt(s: &Stmt, out: &mut HashSet) { match s { Stmt::Var(v) => { if let Some(x) = &v.value { idents_expr(x, out); } } Stmt::Assign { target, value, .. } => { idents_expr(target, out); idents_expr(value, out); } Stmt::Expr(e) => idents_expr(e, out), Stmt::If { cond, then, else_, .. } => { idents_expr(cond, out); idents_block(then, out); if let Some(e) = else_ { idents_stmt(e, out); } } Stmt::For { kind, body, .. } => { match kind { ForKind::Infinite => {} ForKind::While(c) => idents_expr(c, out), ForKind::In { iter, step, .. } => { idents_expr(iter, out); step.iter().for_each(|x| idents_expr(x, out)); } } idents_block(body, out); } Stmt::Return { values, .. } => values.iter().for_each(|x| idents_expr(x, out)), Stmt::Break(_) | Stmt::Continue(_) => {} Stmt::Block(b) => idents_block(b, out), } } enum ClosureBody<'a> { Block(&'a Block), Expr(&'a Expr), } /// Using a `shared`/`weak` value as the thing inside it (`w.name`, `w.close()`, `match w { }`). fn auto_deref(h: HExpr) -> HExpr { match h.ty { Ty::Shared(t) | Ty::Weak(t) => mk(HExprKind::Deref(Box::new(h)), *t), _ => h, } } /// Does this place go through a shared value (so changing it doesn't need a changeable variable)? fn through_shared(e: &HExpr) -> bool { match &e.kind { HExprKind::Deref(_) => true, HExprKind::Field { base, .. } | HExprKind::Index { base, .. } | HExprKind::Unwrap(base) => through_shared(base), _ => false, } } const BOUNDS: &[&str] = &["Ordered", "Number"]; /// A rule a type parameter must follow: `[T: Ordered]`. #[derive(Clone, Debug)] enum Bound { Ordered, Number, /// A user `interface` (its table name). Iface(String), } /// An `interface`: the methods a type needs to have. #[derive(Clone, Default)] struct IfaceInfo { /// (name, parameter types, result type) methods: Vec<(String, Vec, Ty)>, } fn mentions_type_param(t: &Type, tps: &[TypeParam]) -> bool { match t { Type::Named { path, args } => { (path.len() == 1 && tps.iter().any(|p| p.name == path[0])) || args.iter().any(|a| mentions_type_param(a, tps)) } Type::Slice(x) | Type::Optional(x) | Type::Shared(x) | Type::Weak(x) => mentions_type_param(x, tps), Type::Tuple(xs) => xs.iter().any(|x| mentions_type_param(x, tps)), Type::Func { params, ret } => { params.iter().any(|x| mentions_type_param(x, tps)) || ret.as_ref().map_or(false, |r| mentions_type_param(r, tps)) } } } /// Match the written parameter type `pat` against the type of an argument, noting what each type parameter is. fn unify(pat: &Type, ty: Ty, tps: &[TypeParam], found: &mut HashMap) -> Result<(), String> { match (pat, ty) { (Type::Named { path, args }, _) if path.len() == 1 && args.is_empty() && tps.iter().any(|p| p.name == path[0]) => { match found.get(&path[0]) { Some(prev) if *prev != ty => Err(format!( "`{}` is `{prev}` from an earlier argument, but this one is `{ty}`", path[0] )), Some(_) => Ok(()), None => { found.insert(path[0].clone(), ty); Ok(()) } } } (Type::Slice(inner), Ty::List(e)) => unify(inner, *e, tps, found), (Type::Optional(inner), Ty::Opt(e)) => unify(inner, *e, tps, found), (Type::Func { params, ret }, Ty::Func(ft)) => { for (p, t) in params.iter().zip(&ft.params) { unify(p, *t, tps, found)?; } match ret { Some(r) => unify(r, ft.ret, tps, found), None => Ok(()), } } _ => Ok(()), } } fn unsupported(span: Span, what: &str) -> PResult { Err(Diag::new(format!("{what} is not supported yet"), span)) } fn op_str(op: BinOp) -> &'static str { match op { BinOp::Or => "||", BinOp::And => "&&", BinOp::Eq => "==", BinOp::Ne => "!=", BinOp::Lt => "<", BinOp::Gt => ">", BinOp::Le => "<=", BinOp::Ge => ">=", BinOp::Add => "+", BinOp::Sub => "-", BinOp::Mul => "*", BinOp::Div => "/", BinOp::Rem => "%", } } fn mk(kind: HExprKind, ty: Ty) -> HExpr { HExpr { kind, ty } } /// An integer literal (possibly negated) that has not been given a type yet. fn is_int_lit(h: &HExpr) -> bool { h.ty == Ty::Int && match &h.kind { HExprKind::Int(_) => true, HExprKind::Unary { op: UnOp::Neg, expr } => is_int_lit(expr), _ => false, } } /// A float literal (possibly negated) that has not been given a type yet. fn is_float_lit(h: &HExpr) -> bool { h.ty == Ty::Float && match &h.kind { HExprKind::Float(_) => true, HExprKind::Unary { op: UnOp::Neg, expr } => is_float_lit(expr), _ => false, } } /// Give a number literal the type the context asks for (`var x: u8 = 200`, `f * 2`). fn retype_lit(h: HExpr, want: Ty, span: Span, negated: bool) -> PResult { match h.kind { HExprKind::Int(n) => { if want.is_float() { return Ok(mk(HExprKind::Float(n as f64), want)); } let v = if negated { -(n as i128) } else { n as i128 }; let (lo, hi) = want.int_range(); if v < lo || v > hi { return Err(Diag::new(format!("{v} doesn't fit in a `{want}` (it holds {lo} to {hi})"), span)); } Ok(mk(HExprKind::Int(n), want)) } HExprKind::Float(x) => Ok(mk(HExprKind::Float(x), want)), HExprKind::Unary { op, expr } => { let inner = retype_lit(*expr, want, span, true)?; Ok(mk(HExprKind::Unary { op, expr: Box::new(inner) }, want)) } _ => Ok(h), } } /// True if the expression calls user code or prints (not allowed in a `const`). fn has_call(h: &HExpr) -> bool { match &h.kind { HExprKind::Call { .. } | HExprKind::MethodCall { .. } | HExprKind::Print(_) | HExprKind::ListPush { .. } | HExprKind::ListPop(_) | HExprKind::MapCall { .. } | HExprKind::Builtin { .. } | HExprKind::CCall { .. } | HExprKind::CallValue { .. } | HExprKind::IfaceCall { .. } | HExprKind::Closure { .. } | HExprKind::Try(_) => true, HExprKind::Copy(e) | HExprKind::Move(e) | HExprKind::NewShared(e) | HExprKind::Upgrade(e) | HExprKind::Downgrade(e) | HExprKind::Deref(e) | HExprKind::Len(e) | HExprKind::Wrap(e) | HExprKind::MakeError(e) | HExprKind::IsSet(e) | HExprKind::Unwrap(e) => has_call(e), HExprKind::TupleLit(items) => items.iter().any(has_call), HExprKind::EnumLit { fields, .. } => fields.iter().any(has_call), HExprKind::Match { .. } => true, HExprKind::ListLit { elems } => elems.iter().any(has_call), HExprKind::MapLit { entries } => entries.iter().any(|(k, v)| has_call(k) || has_call(v)), HExprKind::Index { base, index } => has_call(base) || has_call(index), HExprKind::Slice { base, lo, hi } => { has_call(base) || lo.as_deref().map_or(false, has_call) || hi.as_deref().map_or(false, has_call) } HExprKind::Unary { expr, .. } | HExprKind::Convert(expr) => has_call(expr), HExprKind::Field { base, .. } => has_call(base), HExprKind::StructLit { fields, .. } => fields.iter().any(|(_, f)| has_call(f)), HExprKind::Binary { lhs, rhs, .. } => has_call(lhs) || has_call(rhs), HExprKind::Interp(parts) => parts.iter().any(|p| match p { HInterp::Value(e) => has_call(e), HInterp::Text(_) => false, }), _ => false, } } /// Does every path through these statements end in a `return` (or loop forever)? fn always_returns(stmts: &[HStmt]) -> bool { match stmts.last() { Some(HStmt::Return(_)) => true, Some(HStmt::If { then, else_, .. }) => always_returns(then) && always_returns(else_), Some(HStmt::Block(b)) => always_returns(b), Some(HStmt::Loop(body)) => !has_break(body), // a `match` is exhaustive, so if every arm returns, so does the match Some(HStmt::Expr(HExpr { kind: HExprKind::Match { arms, .. }, .. })) => arms.iter().all(|a| match &a.body { HArmBody::Block(b) => always_returns(b), HArmBody::Expr(_) => false, }), _ => false, } } /// Does control never reach the statement after these (they end in return/break/continue)? fn diverges(stmts: &[HStmt]) -> bool { match stmts.last() { Some(HStmt::Return(_) | HStmt::Break | HStmt::Continue) => true, Some(HStmt::If { then, else_, .. }) => diverges(then) && diverges(else_), Some(HStmt::Block(b)) => diverges(b), _ => always_returns(stmts), } } /// Is there a `break` that belongs to the loop whose body this is? fn has_break(stmts: &[HStmt]) -> bool { stmts.iter().any(|s| match s { HStmt::Break => true, HStmt::If { then, else_, .. } => has_break(then) || has_break(else_), HStmt::Block(b) => has_break(b), HStmt::Expr(HExpr { kind: HExprKind::Match { arms, .. }, .. }) => arms.iter().any(|a| match &a.body { HArmBody::Block(b) => has_break(b), HArmBody::Expr(_) => false, }), // breaks inside nested loops belong to those loops _ => false, }) } impl Checker { fn new() -> Checker { Checker { funcs: HashMap::new(), consts: HashMap::new(), structs: HashMap::new(), enums: HashMap::new(), cur_struct: None, no_move: HashSet::new(), scopes: Vec::new(), next_id: 0, ret: Ty::Unit, loops: 0, narrowed: HashSet::new(), imports: HashMap::new(), cur_mod: String::new(), all_imports: HashMap::new(), known_modules: HashSet::new(), private: HashSet::new(), generics: HashMap::new(), gtypes: HashMap::new(), ifaces: HashMap::new(), iface_decls: HashMap::new(), bounds_of: HashMap::new(), tsubst: HashMap::new(), inst_queue: Vec::new(), clibs: Vec::new(), c_structs: HashMap::new(), } } // ---------- program ---------- fn program(&mut self, main: &Program, modules: &[(String, Program)]) -> PResult { let mut mods: Vec<(&str, &Program)> = modules.iter().map(|(k, p)| (k.as_str(), p)).collect(); mods.push(("", main)); self.known_modules = modules.iter().map(|(k, _)| k.clone()).collect(); self.register_c_structs(); for (key, p) in &mods { self.enter(key); self.phase_imports(p).map_err(|d| d.in_module(key))?; } for (key, p) in &mods { self.enter(key); self.phase_type_names(p).map_err(|d| d.in_module(key))?; } for (key, p) in &mods { self.enter(key); self.phase_type_fields(p).map_err(|d| d.in_module(key))?; } for (key, p) in &mods { self.enter(key); self.phase_ifaces(p).map_err(|d| d.in_module(key))?; } for (key, p) in &mods { self.enter(key); self.phase_signatures(p).map_err(|d| d.in_module(key))?; } self.enter(""); self.check_main(main)?; for (key, p) in &mods { self.enter(key); self.phase_consts(p).map_err(|d| d.in_module(key))?; } let mut funcs = Vec::new(); for (key, p) in &mods { self.enter(key); self.phase_bodies(p, &mut funcs).map_err(|d| d.in_module(key))?; } // generic functions, once for each set of types they were used with while let Some(inst) = self.inst_queue.pop() { self.enter(&inst.module); self.tsubst = inst.types; let r = self.func(&inst.decl, inst.owner.as_deref()); self.tsubst.clear(); funcs.push(r.map_err(|d| d.in_module(&inst.module))?); } let type_order = self.type_order()?; // which methods change `self`? and are they only called where that is allowed? infer_mutation(&mut funcs); check_mutating_calls(&funcs)?; for f in &mut funcs { crate::moves::apply(&mut f.body); } let types = type_order .into_iter() .map(|name| match self.structs.get(name) { Some(info) => HTypeDef::Struct(HStruct { name: name.to_string(), fields: info.fields.clone(), c: self.c_structs.get(name).cloned(), }), None => HTypeDef::Enum(HEnum { name: name.to_string(), variants: self.enums[name] .variants .iter() .map(|v| HVariant { name: v.name.clone(), fields: v.fields.clone() }) .collect(), }), }) .collect(); let mut ifaces: Vec<(String, Vec<(String, Vec, Ty)>)> = self.ifaces.iter().map(|(k, i)| (k.clone(), i.methods.clone())).collect(); ifaces.sort_by(|a, b| a.0.cmp(&b.0)); let mut c = CInfo::default(); for lib in &self.clibs { let add = |list: &mut Vec, items: Vec| { for i in items { if !list.contains(&i) { list.push(i); } } }; add(&mut c.headers, vec![lib.header.clone()]); add(&mut c.cflags, lib.cflags.clone()); add(&mut c.libs, lib.libs.clone()); add(&mut c.sources, lib.sources.iter().map(|p| p.display().to_string()).collect()); } Ok(HProgram { types, funcs, ifaces, c }) } /// Start checking the module `key`. fn enter(&mut self, key: &str) { self.cur_mod = key.to_string(); self.imports = self.all_imports.get(key).cloned().unwrap_or_default(); } /// The table name of a top-level item written as `name` in the current module. fn q(&self, name: &str) -> String { if self.cur_mod.is_empty() { name.to_string() } else { format!("{}.{}", self.cur_mod, name) } } fn mark_private(&mut self, key: &str, is_pub: bool) { if !is_pub { self.private.insert(key.to_string()); } } /// Using `module.thing` from another module needs `pub`. fn check_visible(&self, key: &str, span: Span) -> PResult<()> { let module = module_of(key); if module != self.cur_mod && self.private.contains(key) { let short = key.rsplit('.').next().unwrap(); return Err(Diag::new( format!("`{short}` is private to `{module}`; write `pub` in front of it in {module}.rex to share it"), span, )); } Ok(()) } fn phase_imports(&mut self, p: &Program) -> PResult<()> { for item in &p.items { match item { Item::Import(i) => self.import(i)?, _ => {} } } self.all_imports.insert(self.cur_mod.clone(), self.imports.clone()); Ok(()) } /// Type names, so structs and enums can mention each other in any order. fn phase_type_names(&mut self, p: &Program) -> PResult<()> { for item in &p.items { if let Item::Interface(i) = item { if !i.type_params.is_empty() { return unsupported(i.span, "generic interfaces"); } self.check_type_name_free(&i.name, i.span)?; let key = self.q(&i.name); self.mark_private(&key, i.is_pub); self.ifaces.insert(key.clone(), IfaceInfo::default()); self.iface_decls.insert(key, (i.clone(), self.cur_mod.clone())); } } for item in &p.items { if let Item::Enum(e) = item { if !e.type_params.is_empty() { self.declare_generic_type(&e.name, e.is_pub, e.span, &e.type_params)?; let key = self.q(&e.name); self.gtypes.insert(key, GenericType::Enum(e.clone(), self.cur_mod.clone())); continue; } if e.variants.is_empty() { return Err(Diag::new(format!("enum `{}` needs at least one case", e.name), e.span)); } self.check_type_name_free(&e.name, e.span)?; let key = self.q(&e.name); self.mark_private(&key, e.is_pub); let name: &'static str = Box::leak(key.clone().into_boxed_str()); self.enums.insert(key, EnumInfo { name, variants: Vec::new(), methods: HashMap::new(), span: e.span }); } if let Item::Struct(s) = item { if !s.type_params.is_empty() { self.declare_generic_type(&s.name, s.is_pub, s.span, &s.type_params)?; let key = self.q(&s.name); self.gtypes.insert(key, GenericType::Struct(s.clone(), self.cur_mod.clone())); continue; } self.check_type_name_free(&s.name, s.span)?; let key = self.q(&s.name); self.mark_private(&key, s.is_pub); let name: &'static str = Box::leak(key.clone().into_boxed_str()); self.structs.insert(key, StructInfo { name, fields: Vec::new(), methods: HashMap::new(), span: s.span }); } } Ok(()) } /// Fields of structs, data of enum cases. fn phase_type_fields(&mut self, p: &Program) -> PResult<()> { for item in &p.items { if let Item::Enum(e) = item { if !e.type_params.is_empty() { continue; } let mut variants: Vec = Vec::new(); for v in &e.variants { if variants.iter().any(|x| x.name == v.name) { return Err(Diag::new( format!("enum `{}` has two cases named `{}`", e.name, v.name), e.span, )); } let mut fields: Vec<(String, Ty)> = Vec::new(); for f in &v.fields { if fields.iter().any(|(n, _)| *n == f.name) { return Err(Diag::new( format!("case `{}.{}` has two values named `{}`", e.name, v.name, f.name), e.span, )); } let fty = self.resolve_type(&f.ty, e.span)?; if matches!(fty, Ty::Opt(_)) { return unsupported(e.span, "an optional (`T?`) as the data of an enum case"); } fields.push((f.name.clone(), fty)); } variants.push(VariantInfo { name: v.name.clone(), fields }); } { let k = self.q(&e.name); self.enums.get_mut(&k).unwrap() }.variants = variants; } if let Item::Struct(s) = item { if !s.type_params.is_empty() { continue; } let mut fields: Vec<(String, Ty)> = Vec::new(); for f in &s.fields { if fields.iter().any(|(n, _)| *n == f.name) { return Err(Diag::new( format!("struct `{}` has two fields named `{}`", s.name, f.name), s.span, )); } let fty = self.resolve_type(&f.ty, s.span)?; if matches!(fty, Ty::Opt(_)) { return unsupported(s.span, "an optional (`T?`) as a struct field"); } let fkey = format!("{}.{}", self.q(&s.name), f.name); self.mark_private(&fkey, f.is_pub); fields.push((f.name.clone(), fty)); } { let k = self.q(&s.name); self.structs.get_mut(&k).unwrap() }.fields = fields; } } Ok(()) } /// Function and method signatures, so everything can call everything. fn phase_signatures(&mut self, p: &Program) -> PResult<()> { for item in &p.items { match item { Item::Struct(s) if s.type_params.is_empty() => { let key = self.q(&s.name); self.declare_methods(&key, &s.methods)? } Item::Enum(e) if e.type_params.is_empty() => { let key = self.q(&e.name); self.declare_methods(&key, &e.methods)? } _ => {} } } for item in &p.items { if let Item::Func(f) = item { self.declare_func(f)?; } } Ok(()) } /// The methods each `interface` asks for. fn phase_ifaces(&mut self, p: &Program) -> PResult<()> { for item in &p.items { let Item::Interface(i) = item else { continue }; let mut methods: Vec<(String, Vec, Ty)> = Vec::new(); for m in &i.methods { if methods.iter().any(|(n, _, _)| *n == m.name) { return Err(Diag::new(format!("interface `{}` lists `{}` twice", i.name, m.name), m.span)); } let sig = self.sig_of(m)?; methods.push((m.name.clone(), sig.params, sig.ret)); } let key = self.q(&i.name); self.ifaces.insert(key, IfaceInfo { methods }); } Ok(()) } /// What a rule written after `T:` means. fn resolve_bound(&self, c: &Type, who: &str, span: Span) -> PResult { if let Type::Named { path, args } = c { if args.is_empty() && path.len() == 1 { match path[0].as_str() { "Ordered" => return Ok(Bound::Ordered), "Number" => return Ok(Bound::Number), n => { let key = self.q(n); if self.ifaces.contains_key(&key) { return Ok(Bound::Iface(key)); } } } } if args.is_empty() && path.len() == 2 { if let Some(Target::User(m)) = self.imports.get(&path[0]) { let key = format!("{m}.{}", path[1]); if self.ifaces.contains_key(&key) { self.check_visible(&key, span)?; return Ok(Bound::Iface(key)); } } } } Err(Diag::new( format!("unknown rule for `{who}`; the rules are: {} or an `interface` you declared", BOUNDS.join(", ")), span, )) } fn resolve_bounds(&self, tps: &[TypeParam], span: Span) -> PResult>> { tps.iter() .map(|tp| tp.constraint.as_ref().map(|c| self.resolve_bound(c, &tp.name, span)).transpose()) .collect() } /// `Some((what is needed, why this type doesn't have it))` if `ty` breaks the rule. fn bound_failure(&self, b: &Bound, ty: Ty) -> Option<(String, String)> { match b { Bound::Ordered if !(ty.is_number() || ty == Ty::Str || ty == Ty::Char) => { Some(("a number or a string (something with an order)".into(), format!("it is `{ty}`"))) } Bound::Number if !ty.is_number() => Some(("a number".into(), format!("it is `{ty}`"))), Bound::Iface(key) => { let short = key.rsplit('.').next().unwrap(); let what = format!("something with the methods of `{short}`"); if let Ty::Iface(k2) = ty { for (name, params, ret) in &self.ifaces[key].methods { let ok = self.ifaces[k2].methods.iter().any(|(n, p, r)| n == name && p == params && r == ret); if !ok { return Some((what, format!("`{ty}` has no method `{name}` like that"))); } } return None; } let methods = match ty { Ty::Struct(n) | Ty::Enum(n) => self.methods_of(n), _ => None, }; for (name, params, ret) in &self.ifaces[key].methods { let sig = methods.and_then(|m| m.get(name)); match sig { None => return Some((what, format!("`{ty}` has no method `{name}`"))), Some(sig) if sig.params != *params || sig.ret != *ret => { let want = format!( "{name}({}){}", params.iter().map(|t| t.to_string()).collect::>().join(", "), if *ret == Ty::Unit { String::new() } else { format!(": {ret}") } ); let has = format!( "{name}({}){}", sig.params.iter().map(|t| t.to_string()).collect::>().join(", "), if sig.ret == Ty::Unit { String::new() } else { format!(": {}", sig.ret) } ); return Some((what, format!("`{ty}` has `{has}`, but `{short}` needs `{want}`"))); } _ => {} } } None } _ => None, } } fn check_main(&self, p: &Program) -> PResult<()> { match self.funcs.get("main") { None => { return Err(Diag::new( "there is no `main` function; a program starts at `func main() { }`", Span { line: 1, col: 1 }, )) } Some(sig) if !sig.params.is_empty() || !matches!(sig.ret, Ty::Unit | Ty::Error) => { let span = p .items .iter() .find_map(|i| match i { Item::Func(f) if f.name == "main" => Some(f.span), _ => None, }) .unwrap(); return Err(Diag::new("`main` must take no parameters and return nothing (or just an `error`)", span)); } _ => {} } Ok(()) } /// Top-level constants, in order. fn phase_consts(&mut self, p: &Program) -> PResult<()> { for item in &p.items { if let Item::Const(v) = item { self.top_const(v)?; } } Ok(()) } fn phase_bodies(&mut self, p: &Program, funcs: &mut Vec) -> PResult<()> { for item in &p.items { match item { Item::Func(f) if !f.type_params.is_empty() => {} Item::Func(f) => funcs.push(self.func(f, None)?), Item::Struct(s) if s.type_params.is_empty() => { let key = self.q(&s.name); for m in &s.methods { funcs.push(self.func(m, Some(&key))?); } } Item::Enum(e) if e.type_params.is_empty() => { let key = self.q(&e.name); for m in &e.methods { funcs.push(self.func(m, Some(&key))?); } } _ => {} } } Ok(()) } /// Structs and enums sorted so that every type comes after the types it contains by value. fn type_order(&self) -> PResult> { #[derive(Clone, Copy, PartialEq)] enum Mark { Visiting, Done, } fn deps(c: &Checker, name: &str) -> Vec<&'static str> { let tys: Vec = match c.structs.get(name) { Some(s) => s.fields.iter().map(|(_, t)| *t).collect(), None => c.enums[name].variants.iter().flat_map(|v| v.fields.iter().map(|(_, t)| *t)).collect(), }; tys.into_iter() .filter_map(|t| match t { Ty::Struct(n) | Ty::Enum(n) => Some(n), _ => None, }) .collect() } fn span_of(c: &Checker, name: &str) -> Span { c.structs.get(name).map(|s| s.span).unwrap_or_else(|| c.enums[name].span) } fn visit( c: &Checker, name: &'static str, marks: &mut HashMap<&'static str, Mark>, out: &mut Vec<&'static str>, ) -> PResult<()> { match marks.get(name) { Some(Mark::Done) => return Ok(()), Some(Mark::Visiting) => { let kind = if c.structs.contains_key(name) { "struct" } else { "enum" }; return Err(Diag::new( format!( "{kind} `{name}` contains itself, so it would be infinitely big \ (a list like `[]{name}` can hold itself; `shared {name}` will too, once it exists)" ), span_of(c, name), )); } None => {} } marks.insert(name, Mark::Visiting); for dep in deps(c, name) { visit(c, dep, marks, out)?; } marks.insert(name, Mark::Done); out.push(name); Ok(()) } let mut all: Vec<(Span, &'static str)> = Vec::new(); all.extend(self.structs.values().map(|i| (i.span, i.name))); all.extend(self.enums.values().map(|i| (i.span, i.name))); all.sort_by_key(|(sp, name)| (sp.line, sp.col, *name)); let mut marks = HashMap::new(); let mut out = Vec::new(); for (_, name) in all { visit(self, name, &mut marks, &mut out) .map_err(|d| d.in_module(module_of(name)))?; } Ok(out) } fn check_type_name_free(&self, name: &str, span: Span) -> PResult<()> { if matches!(name, "bool" | "string") || conversion_target(name).is_some() { return Err(Diag::new(format!("`{name}` is a built-in type and can't be redefined"), span)); } let key = self.q(name); if self.structs.contains_key(&key) || self.ifaces.contains_key(&key) || self.enums.contains_key(&key) || self.funcs.contains_key(&key) || self.generics.contains_key(&key) || self.gtypes.contains_key(&key) || self.consts.contains_key(&key) { return Err(Diag::new(format!("`{name}` is already defined"), span)); } Ok(()) } fn import(&mut self, i: &Import) -> PResult<()> { if i.c { return self.import_c(i); } let alias = i.path.rsplit('.').next().unwrap().to_string(); if self.imports.contains_key(&alias) { return Err(Diag::new(format!("`{alias}` is imported twice"), i.span)); } let target = match stdlib::MODULES.iter().find(|m| **m == i.path) { Some(m) => Target::Builtin(m), None if self.known_modules.contains(&i.path) => Target::User(i.path.clone()), None => { return Err(Diag::new( format!("there is no module `{}` (built-in modules: {})", i.path, stdlib::MODULES.join(", ")), i.span, )) } }; self.imports.insert(alias, target); Ok(()) } /// Is `e` the name of an imported module, not hidden by a variable? fn alias_target(&self, e: &Expr) -> Option<&Target> { let ExprKind::Ident(n) = &e.kind else { return None }; if self.lookup(n).is_some() || self.implicit_field(n).is_some() || self.consts.contains_key(&self.q(n)) { return None; } self.imports.get(n) } /// If `e` is the name of an imported file of the user's, its import path. fn user_alias(&self, e: &Expr) -> Option { match self.alias_target(e)? { Target::User(p) => Some(p.clone()), _ => None, } } /// If `e` is the name of an imported C header, which one. fn c_alias(&self, e: &Expr) -> Option { match self.alias_target(e)? { Target::C(i) => Some(*i), _ => None, } } /// A name picked from a C header (`import "zlib.h" { name }`), not hidden by a variable. fn c_item(&self, name: &str) -> Option { if self.lookup(name).is_some() || self.implicit_field(name).is_some() { return None; } match self.imports.get(name)? { Target::CItem(i) => Some(*i), _ => None, } } /// The table name for a type or function written as `name` or `module.name`. fn global_key(&self, e: &Expr) -> Option { match &e.kind { ExprKind::Ident(n) => match self.c_item(n) { Some(i) => Some(c_key(&self.clibs[i].prefix, n)), None => Some(self.q(n)), }, ExprKind::Field { expr, name } => match self.alias_target(expr)? { Target::User(p) => Some(format!("{p}.{name}")), Target::C(i) => Some(c_key(&self.clibs[*i].prefix, name)), _ => None, }, _ => None, } } /// If `e` is the name of an imported built-in module (and no variable hides it), that module. fn module_alias(&self, e: &Expr) -> Option<&'static str> { match self.alias_target(e)? { Target::Builtin(m) => Some(m), _ => None, } } // ---------- C headers ---------- fn import_c(&mut self, i: &Import) -> PResult<()> { let Some(idx) = self.clibs.iter().position(|l| l.header == i.path) else { return Err(Diag::new(format!("the C header `{}` could not be read", i.path), i.span)); }; let lib = &self.clibs[idx]; match &i.names { None => { let alias = i.alias.clone().unwrap_or_else(|| lib.prefix.clone()); if self.imports.contains_key(&alias) { return Err(Diag::new( format!("`{alias}` is imported twice; give the header another name, like `import c{alias} \"{}\"`", i.path), i.span, )); } self.imports.insert(alias, Target::C(idx)); } Some(names) => { for (n, span) in names { if !lib.names().contains(&n.as_str()) && lib.func(n).is_none() { let hint = similar(n, &lib.names()).map(|s| format!(" (did you mean `{s}`?)")).unwrap_or_default(); return Err(Diag::new(format!("`{}` has no `{n}`{hint}", lib.header), *span)); } if self.imports.contains_key(n) { return Err(Diag::new(format!("`{n}` is imported twice"), *span)); } self.imports.insert(n.clone(), Target::CItem(idx)); } } } Ok(()) } /// The Rex type for a C type, if it has one. fn c_type(&self, lib: usize, t: &CTy) -> Option { Some(match t { CTy::Void => Ty::Unit, CTy::Num(t) => *t, CTy::Str => Ty::Str, CTy::Handle(n) if n == "pointer" => Ty::CPtr("pointer"), CTy::Handle(n) => Ty::CPtr(Box::leak(format!("{}.{n}", self.clibs[lib].prefix).into_boxed_str())), CTy::Struct(n) => Ty::Struct(self.structs.get(&c_key(&self.clibs[lib].prefix, n))?.name), CTy::Ptr { .. } | CTy::Unsupported(_) => return None, }) } /// Structs from C headers become Rex structs (`raylib.Color`), converted at calls. fn register_c_structs(&mut self) { for li in 0..self.clibs.len() { let prefix = self.clibs[li].prefix.clone(); for s in self.clibs[li].structs.clone() { let key = c_key(&prefix, &s.name); let name: &'static str = Box::leak(key.clone().into_boxed_str()); self.structs.insert(key.clone(), StructInfo { name, fields: Vec::new(), methods: HashMap::new(), span: Span::default() }); self.c_structs.insert(key, s.c.clone()); } for s in self.clibs[li].structs.clone() { let key = c_key(&prefix, &s.name); let fields: Vec<(String, Ty)> = s.fields.iter().map(|(n, t)| (n.clone(), self.c_type(li, t).unwrap_or(Ty::CPtr("pointer")))).collect(); self.structs.get_mut(&key).unwrap().fields = fields; } } } /// The type `name` from C header `lib` (`zlib.gzFile`, `raylib.Color`). fn c_named_type(&self, lib: usize, name: &str, span: Span) -> PResult { let l = &self.clibs[lib]; if l.strukt(name).is_some() { return self.c_type(lib, &CTy::Struct(name.to_string())).ok_or_else(|| Diag::new("unknown C struct", span)); } if l.has_handle(name) { return Ok(self.c_type(lib, &CTy::Handle(name.to_string())).unwrap()); } let types: Vec<&str> = l.structs.iter().map(|s| s.name.as_str()).chain(l.handles.iter().map(|h| h.as_str())).collect(); let hint = similar(name, &types).map(|s| format!(" (did you mean `{s}`?)")).unwrap_or_default(); Err(Diag::new(format!("`{}` has no type `{name}`{hint}", l.header), span)) } /// A constant from a C header: `zlib.Z_OK`, `raylib.RED`. fn c_value(&self, lib: usize, name: &str, span: Span) -> PResult { let l = &self.clibs[lib]; if let Some(c) = l.konst(name) { return Ok(match &c.value { cheader::Value::Int(i) => mk(HExprKind::Int(*i), Ty::Int), cheader::Value::Float(f) => mk(HExprKind::Float(*f), Ty::Float), cheader::Value::Str(s) => mk(HExprKind::Str(s.clone()), Ty::Str), cheader::Value::Struct(sn) => { let ty = self.c_named_type(lib, sn, span)?; mk(HExprKind::CRaw(name.to_string()), ty) } }); } if l.func(name).is_some() { return Err(Diag::new(format!("`{name}` is a C function; call it like `{name}(...)`"), span)); } if l.strukt(name).is_some() || l.has_handle(name) { return Err(Diag::new(format!("`{name}` is a C type, not a value"), span)); } let hint = similar(name, &l.names()).map(|s| format!(" (did you mean `{s}`?)")).unwrap_or_default(); Err(Diag::new(format!("`{}` has no `{name}`{hint}", l.header), span)) } fn c_call(&mut self, lib: usize, name: &str, args: &[Expr], span: Span, name_span: Span) -> PResult { let l = &self.clibs[lib]; let Some(f) = l.func(name).cloned() else { if l.konst(name).is_some() { return Err(Diag::new(format!("`{name}` is a constant, not a function"), name_span)); } if l.strukt(name).is_some() { return Err(Diag::new(format!("`{name}` is a C struct; build one with `{name}{{...}}`"), name_span)); } let hint = similar(name, &l.names()).map(|s| format!(" (did you mean `{s}`?)")).unwrap_or_default(); return Err(Diag::new(format!("`{}` has no function `{name}`{hint}", l.header), name_span)); }; if let Some(why) = &f.problem { return Err(Diag::new(format!("`{name}` can't be called from Rex: it {why}"), name_span)); } if args.len() != f.params.len() { let names: Vec = f .params .iter() .map(|(n, t)| if n.is_empty() { self.c_param_text(lib, t) } else { format!("{n}: {}", self.c_param_text(lib, t)) }) .collect(); return Err(Diag::new( format!( "`{name}` takes {} argument{} ({}), but {} {} given", f.params.len(), if f.params.len() == 1 { "" } else { "s" }, names.join(", "), args.len(), if args.len() == 1 { "was" } else { "were" }, ), span, )); } let mut hs = Vec::new(); let mut modes = Vec::new(); for ((pname, pt), a) in f.params.iter().zip(args) { let (h, m) = self.c_arg(lib, name, pname, pt, a)?; hs.push(h); modes.push(m); } let ret = self.c_type(lib, &f.ret).unwrap_or(Ty::CPtr("pointer")); Ok(mk(HExprKind::CCall { name: name.to_string(), args: hs, modes }, ret)) } /// How a C parameter type reads in a message. fn c_param_text(&self, lib: usize, t: &CTy) -> String { match t { CTy::Ptr { to, .. } if matches!(**to, CTy::Struct(_) | CTy::Handle(_)) => { self.c_type(lib, to).map_or("pointer".into(), |t| format!("{t} variable")) } CTy::Ptr { to, konst } => match self.c_type(lib, to) { Some(inner) if *konst => format!("{inner} or []{inner}"), Some(inner) => format!("{inner} variable or []{inner}"), None => "pointer".into(), }, t => self.c_type(lib, t).map_or("?".into(), |t| t.to_string()), } } fn c_arg(&mut self, lib: usize, fname: &str, pname: &str, pt: &CTy, a: &Expr) -> PResult<(HExpr, CArg)> { let null = || Ok((mk(HExprKind::Bool(false), Ty::Bool), CArg::Null)); let is_nil = matches!(a.kind, ExprKind::Nil); let what = if pname.is_empty() { format!("this argument of `{fname}`") } else { format!("`{pname}` of `{fname}`") }; match pt { CTy::Str => { if is_nil { return null(); } let h = self.expr(a, Some(Ty::Str))?; match h.ty { Ty::Str => Ok((h, CArg::Str)), Ty::List(Ty::Num(Num::U8 | Num::I8)) => Ok((h, CArg::Buffer)), t => Err(Diag::new(format!("{what} is a `string` (or a `[]u8` to fill in), found `{t}`"), a.span)), } } CTy::Handle(_) => { let want = self.c_type(lib, pt).unwrap(); if is_nil { return Ok((mk(HExprKind::Nil, want), CArg::Value)); } let h = self.expr(a, Some(want))?; match h.ty { Ty::CPtr(x) if Ty::CPtr(x) == want || x == "pointer" || want == Ty::CPtr("pointer") => Ok((h, CArg::Value)), Ty::List(e) if want == Ty::CPtr("pointer") && (e.is_number() || *e == Ty::Bool) => Ok((h, CArg::Buffer)), Ty::Str if want == Ty::CPtr("pointer") => Ok((h, CArg::Str)), t => Err(Diag::new(format!("{what} is a `{want}`, found `{t}`"), a.span)), } } CTy::Ptr { to, konst } => { let Some(inner) = self.c_type(lib, to) else { return Err(Diag::new(format!("{what} has a type Rex can't pass"), a.span)); }; if is_nil { return null(); } // `sqlite3 **db`: a pointer variable the function fills in if let Ty::CPtr(want) = inner { let h = self.expr(a, Some(inner))?; let fits = |t: Ty| matches!(t, Ty::CPtr(x) if x == want || x == "pointer" || want == "pointer"); if !fits(h.ty) { return Err(Diag::new(format!("{what} is a `{inner}` variable that the function fills in, found `{}`", h.ty), a.span)); } if *konst { return Ok((h, CArg::AddrIn)); } let thing = if pname.is_empty() { "this argument".to_string() } else { format!("`{pname}`") }; let p = self.place(a).map_err(|_| { Diag::new(format!("`{fname}` writes into {thing}, so it must be a variable (or a field of one)"), a.span) })?; return Ok((p, CArg::Addr)); } let h = self.expr(a, Some(inner))?; if h.ty == Ty::list(inner) { if matches!(inner, Ty::Struct(_)) { return Err(Diag::new(format!("{what} wants C structs in a row; a Rex list of structs can't be passed"), a.span)); } return Ok((h, CArg::Buffer)); } if let Ty::CPtr(_) = h.ty { return Ok((h, CArg::Value)); } let h = self.coerce(h, inner, a.span).map_err(|_| { Diag::new( format!( "{what} is {} `{inner}` (or a list `[]{inner}`), found something else", if *konst { "a" } else { "a variable of type" } ), a.span, ) })?; if *konst { return Ok((h, CArg::AddrIn)); } let p = self.place(a).map_err(|_| { let thing = if pname.is_empty() { "this argument".to_string() } else { format!("`{pname}`") }; Diag::new(format!("`{fname}` writes into {thing}, so it must be a variable (or a field of one)"), a.span) })?; Ok((p, CArg::Addr)) } CTy::Num(_) | CTy::Struct(_) => { let want = self.c_type(lib, pt).unwrap(); // a C `char` takes a Rex character: `'a'` if matches!(want, Ty::Num(Num::I8 | Num::U8)) { let h = self.expr(a, Some(want))?; if h.ty == Ty::Char { return Ok((mk(HExprKind::Convert(Box::new(h)), want), CArg::Value)); } return Ok((self.coerce(h, want, a.span)?, CArg::Value)); } Ok((self.expr_as(a, want)?, CArg::Value)) } CTy::Void | CTy::Unsupported(_) => Err(Diag::new(format!("{what} has a type Rex can't pass"), a.span)), } } fn module_value(&mut self, module: &'static str, name: &str, span: Span) -> PResult { match stdlib::module_value(module, name) { Some(ModuleValue::Float(x)) => Ok(mk(HExprKind::Float(x), Ty::Float)), Some(ModuleValue::Call(sig)) => { Ok(mk(HExprKind::Builtin { c: sig.c, shape: sig.shape, args: Vec::new() }, sig.ret)) } None if stdlib::module_fn(module, name).is_some() => { Err(Diag::new(format!("`{module}.{name}` is a function; call it like `{module}.{name}(...)`"), span)) } None => Err(Diag::new( format!("module `{module}` has no `{name}` (it has: {})", stdlib::module_names(module).join(", ")), span, )), } } fn module_call(&mut self, module: &'static str, name: &str, args: &[Expr], span: Span, name_span: Span) -> PResult { let Some(sig) = stdlib::module_fn(module, name) else { return Err(Diag::new( format!("module `{module}` has no function `{name}` (it has: {})", stdlib::module_names(module).join(", ")), name_span, )); }; let label = format!("{module}.{name}"); use crate::hir::BuiltinShape::*; match sig.shape { Min | Max => { if args.len() != 2 { return Err(Diag::new(format!("`{label}` takes 2 arguments, but {} were given", args.len()), span)); } let mut l = self.expr(&args[0], None)?; let mut r = self.expr(&args[1], None)?; if l.ty != r.ty { if is_int_lit(&l) && r.ty.is_number() || is_float_lit(&l) && r.ty.is_float() { l = retype_lit(l, r.ty, span, false)?; } else if is_int_lit(&r) && l.ty.is_number() || is_float_lit(&r) && r.ty.is_float() { r = retype_lit(r, l.ty, span, false)?; } } if l.ty != r.ty || !l.ty.is_number() { return Err(Diag::new( format!("`{label}` needs two numbers of the same type, found `{}` and `{}`", l.ty, r.ty), span, )); } let ty = l.ty; Ok(mk(HExprKind::Builtin { c: "", shape: sig.shape, args: vec![l, r] }, ty)) } Abs => { if args.len() != 1 { return Err(Diag::new(format!("`{label}` takes 1 argument, but {} were given", args.len()), span)); } let x = self.expr(&args[0], None)?; if !x.ty.is_number() || !x.ty.is_signed() { return Err(Diag::new(format!("`{label}` needs a signed number, found `{}`", x.ty), span)); } let ty = x.ty; Ok(mk(HExprKind::Builtin { c: "", shape: Abs, args: vec![x] }, ty)) } _ => self.builtin_call(&label, sig, None, args, span), } } /// A call of a function from the runtime. `recv` is the string or list for a method. fn builtin_call( &mut self, label: &str, sig: stdlib::BuiltinFn, recv: Option, args: &[Expr], span: Span, ) -> PResult { let skip = recv.is_some() as usize; let want = sig.params.len() - skip; if args.len() != want { return Err(Diag::new( format!( "`{label}` takes {want} argument{}, but {} {} given", if want == 1 { "" } else { "s" }, args.len(), if args.len() == 1 { "was" } else { "were" } ), span, )); } let mut hs: Vec = recv.into_iter().collect(); for (a, ty) in args.iter().zip(&sig.params[skip..]) { hs.push(self.expr_as(a, *ty)?); } Ok(mk(HExprKind::Builtin { c: sig.c, shape: sig.shape, args: hs }, sig.ret)) } fn check_name_free(&self, name: &str, span: Span) -> PResult<()> { if self.imports.contains_key(name) { return Err(Diag::new(format!("`{name}` is an imported module and can't be redefined"), span)); } if BUILTINS.contains(&name) { return Err(Diag::new(format!("`{name}` is built in and can't be redefined"), span)); } let key = self.q(name); if self.funcs.contains_key(&key) || self.ifaces.contains_key(&key) || self.generics.contains_key(&key) || self.gtypes.contains_key(&key) || self.consts.contains_key(&key) || self.structs.contains_key(&key) || self.enums.contains_key(&key) { return Err(Diag::new(format!("`{name}` is already defined"), span)); } Ok(()) } fn sig_of(&mut self, f: &FuncDecl) -> PResult { let mut params = Vec::new(); for p in &f.params { params.push(self.resolve_type(&p.ty, f.span)?); } let ret = match &f.ret { None => Ty::Unit, Some(Type::Tuple(items)) => { let mut tys = Vec::new(); for t in items { let ty = self.resolve_type(t, f.span)?; if matches!(ty, Ty::Opt(_)) { return unsupported(f.span, "an optional (`T?`) inside several return values"); } tys.push(ty); } Ty::tuple(tys) } Some(t) => self.resolve_type(t, f.span)?, }; Ok(FuncSig { params, ret }) } fn declare_func(&mut self, f: &FuncDecl) -> PResult<()> { self.check_name_free(&f.name, f.span)?; if !f.type_params.is_empty() { for (i, tp) in f.type_params.iter().enumerate() { if f.type_params[..i].iter().any(|o| o.name == tp.name) { return Err(Diag::new(format!("two type parameters are named `{}`", tp.name), f.span)); } } let bounds = self.resolve_bounds(&f.type_params, f.span)?; self.bounds_of.insert(self.q(&f.name), bounds); if !f.params.iter().any(|p| mentions_type_param(&p.ty, &f.type_params)) { return Err(Diag::new( "a generic function needs at least one parameter that uses its type (the type is worked out from the arguments)", f.span, )); } let key = self.q(&f.name); self.mark_private(&key, f.is_pub); self.generics.insert(key, GenericFn { decl: f.clone(), module: self.cur_mod.clone() }); return Ok(()); } let sig = self.sig_of(f)?; let key = self.q(&f.name); self.mark_private(&key, f.is_pub); self.funcs.insert(key, sig); Ok(()) } fn declare_methods(&mut self, owner: &str, methods: &[FuncDecl]) -> PResult<()> { for m in methods { let field_clash = self.structs.get(owner).map_or(false, |i| i.fields.iter().any(|(n, _)| *n == m.name)); if field_clash { return Err(Diag::new( format!("`{}` is already a field of `{owner}`, so it can't also be a method", m.name), m.span, )); } if self.methods_of(owner).unwrap().contains_key(&m.name) { return Err(Diag::new(format!("`{owner}` has two methods named `{}`", m.name), m.span)); } if m.params.iter().any(|p| p.name == "self") { return Err(Diag::new("`self` is added automatically; don't list it as a parameter", m.span)); } let sig = self.sig_of(m)?; self.mark_private(&format!("{owner}.{}", m.name), m.is_pub); match self.structs.get_mut(owner) { Some(i) => i.methods.insert(m.name.clone(), sig), None => self.enums.get_mut(owner).unwrap().methods.insert(m.name.clone(), sig), }; } Ok(()) } fn methods_of(&self, owner: &str) -> Option<&HashMap> { match self.structs.get(owner) { Some(i) => Some(&i.methods), None => self.enums.get(owner).map(|i| &i.methods), } } /// Interned name of a struct or enum. fn type_name(&self, name: &str) -> Option<&'static str> { self.structs.get(name).map(|i| i.name).or_else(|| self.enums.get(name).map(|i| i.name)) } fn resolve_type(&mut self, t: &Type, span: Span) -> PResult { match t { Type::Named { path, args } if path.len() == 1 && args.is_empty() => match path[0].as_str() { "int" => Ok(Ty::Int), "float" => Ok(Ty::Float), "bool" => Ok(Ty::Bool), "char" => Ok(Ty::Char), "string" => Ok(Ty::Str), "error" => Ok(Ty::Error), "i64" => Ok(Ty::Int), "f64" => Ok(Ty::Float), n if Num::ALL.iter().any(|k| k.name() == n) => Ok(conversion_target(n).unwrap()), n if self.tsubst.contains_key(n) => Ok(self.tsubst[n]), n if matches!(self.imports.get(n), Some(Target::CItem(..))) => { let Some(Target::CItem(lib)) = self.imports.get(n) else { unreachable!() }; self.c_named_type(*lib, n, span) } n => { let key = self.q(n); if self.ifaces.contains_key(&key) { return Ok(Ty::Iface(Box::leak(key.into_boxed_str()))); } if self.gtypes.contains_key(&key) { return Err(Diag::new(format!("`{n}` needs types: write `{n}[int]` (or whichever types you want)"), span)); } match (self.structs.get(&key), self.enums.get(&key)) { (Some(info), _) => Ok(Ty::Struct(info.name)), (_, Some(info)) => Ok(Ty::Enum(info.name)), _ => Err(Diag::new(format!("unknown type `{n}`"), span)), } } }, Type::Named { path, args } if path.len() == 1 && path[0] == "map" && !self.gtypes.contains_key(&self.q("map")) => { if args.len() != 2 { return Err(Diag::new("a map type needs a key type and a value type: `map[string, int]`", span)); } let key = self.resolve_type(&args[0], span)?; let val = self.resolve_type(&args[1], span)?; if !(matches!(key, Ty::Int | Ty::Str | Ty::Bool | Ty::Char) || matches!(key, Ty::Num(n) if !n.is_float())) { return Err(Diag::new( format!("a map key must be an `int`, `string`, `bool`, `char` or other whole-number type, not `{key}`"), span, )); } if matches!(val, Ty::Opt(_)) { return unsupported(span, "a map of optionals (`map[K, V?]`)"); } Ok(Ty::map(key, val)) } Type::Named { path, args } if !args.is_empty() && path.len() <= 2 => { let key = if path.len() == 1 { self.q(&path[0]) } else { let Some(Target::User(module)) = self.imports.get(&path[0]) else { return Err(Diag::new(format!("unknown type `{}.{}` (is `{}` imported?)", path[0], path[1], path[0]), span)); }; format!("{module}.{}", path[1]) }; let shown = path.join("."); if !self.gtypes.contains_key(&key) { return Err(Diag::new(format!("`{shown}` is not a generic type, so it can't take types in `[...]`"), span)); } self.check_visible(&key, span)?; let mut tys = Vec::new(); for a in args { tys.push(self.resolve_type(a, span)?); } self.instantiate_type(&key, &shown, tys, span) } Type::Named { path, args } if path.len() == 2 && args.is_empty() && matches!(self.imports.get(&path[0]), Some(Target::C(_))) => { let Some(Target::C(lib)) = self.imports.get(&path[0]) else { unreachable!() }; self.c_named_type(*lib, &path[1], span) } Type::Named { path, args } if path.len() == 2 && args.is_empty() => { let Some(Target::User(module)) = self.imports.get(&path[0]) else { return Err(Diag::new(format!("unknown type `{}.{}` (is `{}` imported?)", path[0], path[1], path[0]), span)); }; let key = format!("{module}.{}", path[1]); self.check_visible(&key, span)?; if self.ifaces.contains_key(&key) { return Ok(Ty::Iface(Box::leak(key.into_boxed_str()))); } match (self.structs.get(&key), self.enums.get(&key)) { (Some(info), _) => Ok(Ty::Struct(info.name)), (_, Some(info)) => Ok(Ty::Enum(info.name)), _ => Err(Diag::new(format!("module `{module}` has no type `{}`", path[1]), span)), } } Type::Named { .. } => unsupported(span, "this kind of type"), Type::Slice(inner) => { let elem = self.resolve_type(inner, span)?; if matches!(elem, Ty::Opt(_)) { return unsupported(span, "a list of optionals (`[]T?`)"); } Ok(Ty::list(elem)) } Type::Optional(inner) => { let t = self.resolve_type(inner, span)?; match t { // a weak pointer can already be nil: `weak Window?` and `weak Window` are the same Ty::Weak(_) => Ok(t), Ty::Opt(_) => Err(Diag::new("`T??` doesn't make sense; one `?` is enough", span)), Ty::Error => Err(Diag::new("`error` can already be nil, so `error?` isn't needed", span)), _ => Ok(Ty::opt(t)), } } Type::Shared(inner) | Type::Weak(inner) => { let is_shared = matches!(t, Type::Shared(_)); let word = if is_shared { "shared" } else { "weak" }; let inner_ty = self.resolve_type(inner, span)?; if !matches!(inner_ty, Ty::Struct(_) | Ty::Enum(_)) { return unsupported(span, &format!("`{word} {inner_ty}` (only structs and enums can be shared for now)")); } Ok(if is_shared { Ty::shared(inner_ty) } else { Ty::weak(inner_ty) }) } Type::Tuple(_) => unsupported(span, "tuple types"), Type::Func { params, ret } => { let mut ps = Vec::new(); for p in params { ps.push(self.resolve_type(p, span)?); } let r = match ret { None => Ty::Unit, Some(r) => self.resolve_type(r, span)?, }; if matches!(r, Ty::Tuple(_)) { return unsupported(span, "a function value with several results"); } Ok(Ty::func(ps, r)) } } } fn top_const(&mut self, v: &VarDecl) -> PResult<()> { if v.names.len() != 1 { return unsupported(v.span, "declaring several constants at once"); } let name = &v.names[0]; self.check_name_free(name, v.span)?; self.scopes.clear(); self.cur_struct = None; let value = v.value.as_ref().unwrap(); let h = match &v.ty { Some(t) => { let want = self.resolve_type(t, v.span)?; self.expr_as(value, want)? } None => self.expr(value, None)?, }; if has_call(&h) { return Err(Diag::new("a top-level `const` can't call functions", value.span)); } if self.holds_list(h.ty) { return unsupported(value.span, "a top-level `const` holding a list"); } let key = self.q(name); self.mark_private(&key, v.is_pub); self.consts.insert(key, h); Ok(()) } /// Is there a list inside a value of this type? fn holds_list(&self, ty: Ty) -> bool { match ty { Ty::List(_) | Ty::Map(..) => true, Ty::Opt(inner) => self.holds_list(*inner), Ty::Tuple(items) => items.iter().any(|t| self.holds_list(*t)), Ty::Struct(name) => self.structs[name].fields.iter().any(|(_, t)| self.holds_list(*t)), Ty::Enum(name) => self.enums[name] .variants .iter() .any(|v| v.fields.iter().any(|(_, t)| self.holds_list(*t))), _ => false, } } /// Does a value of this type own heap data (lists, strings built at runtime, errors)? /// Copying such a value is a deep copy (or a reference count bump for strings), and /// every owner must free it. fn needs_copy(&self, ty: Ty) -> bool { match ty { Ty::List(_) | Ty::Map(..) | Ty::Str | Ty::Error | Ty::Shared(_) | Ty::Weak(_) | Ty::Func(_) | Ty::Iface(_) => true, Ty::Opt(inner) => self.needs_copy(*inner), Ty::Tuple(items) => items.iter().any(|t| self.needs_copy(*t)), Ty::Struct(name) => self.structs[name].fields.iter().any(|(_, t)| self.needs_copy(*t)), Ty::Enum(name) => self.enums[name] .variants .iter() .any(|v| v.fields.iter().any(|(_, t)| self.needs_copy(*t))), _ => false, } } /// A value that is about to get a new owner. Reading a variable (or part of one) /// whose type owns heap data copies it; fresh values (call results, literals) don't. fn own(&self, h: HExpr) -> HExpr { // reading a variable, a field or an element gives a view of someone else's data let view = matches!( h.kind, HExprKind::Local(..) | HExprKind::Field { .. } | HExprKind::Index { .. } | HExprKind::Unwrap(_) ); if self.needs_copy(h.ty) && view { let ty = h.ty; mk(HExprKind::Copy(Box::new(h)), ty) } else { h } } fn expr_as_owned(&mut self, e: &Expr, want: Ty) -> PResult { let h = self.expr_as(e, want)?; Ok(self.own(h)) } /// The zero value of a type: `0`, `0.0`, `false`, `""`, or a struct of zero values. fn zero_expr(&self, ty: Ty) -> HExpr { let kind = match ty { Ty::Int => HExprKind::Int(0), Ty::Float => HExprKind::Float(0.0), Ty::Num(n) if n.is_float() => HExprKind::Float(0.0), Ty::Num(_) => HExprKind::Int(0), Ty::Bool => HExprKind::Bool(false), Ty::Char => HExprKind::Int(0), Ty::Str => HExprKind::Str(String::new()), Ty::Struct(name) => HExprKind::StructLit { name: name.to_string(), fields: self.structs[name].fields.iter().map(|(n, t)| (n.clone(), self.zero_expr(*t))).collect(), }, // the zero value of an enum is its first case, with zero data Ty::Enum(name) => HExprKind::EnumLit { enum_name: name.to_string(), variant: 0, fields: self.enums[name].variants[0].fields.iter().map(|(_, t)| self.zero_expr(*t)).collect(), }, Ty::List(_) => HExprKind::ListLit { elems: Vec::new() }, Ty::Map(..) => HExprKind::MapLit { entries: Vec::new() }, Ty::Error | Ty::Opt(_) | Ty::Weak(_) | Ty::Shared(_) | Ty::Func(_) | Ty::Iface(_) | Ty::CPtr(_) => HExprKind::Nil, Ty::Tuple(items) => HExprKind::TupleLit(items.iter().map(|t| self.zero_expr(*t)).collect()), Ty::Unit => unreachable!("nothing has no zero value"), }; mk(kind, ty) } // ---------- functions and statements ---------- fn func(&mut self, f: &FuncDecl, owner: Option<&str>) -> PResult { let sig = match owner { None => self.funcs[&self.q(&f.name)].clone(), Some(o) => self.methods_of(o).unwrap()[&f.name].clone(), }; self.scopes = vec![HashMap::new()]; self.next_id = 0; self.ret = sig.ret; self.loops = 0; self.narrowed.clear(); self.cur_struct = owner.and_then(|o| self.type_name(o)); // `self` is declared first, so it always has id 0 let self_param = match self.cur_struct { Some(name) => { let ty = if self.enums.contains_key(name) { Ty::Enum(name) } else { Ty::Struct(name) }; Some(self.declare("self", ty, false, f.span)?) } None => None, }; self.no_move.clear(); if let Some(me) = &self_param { self.no_move.insert(me.id); } let mut params = Vec::new(); for (p, ty) in f.params.iter().zip(&sig.params) { let local = self.declare(&p.name, *ty, false, f.span)?; self.no_move.insert(local.id); params.push(local); } let body_ast = f.body.as_ref().expect("functions have bodies"); let body = self.stmts(&body_ast.stmts)?; if sig.ret != Ty::Unit && !always_returns(&body) { return Err(Diag::new( format!("function `{}` can reach its end without returning a `{}`", f.name, sig.ret), body_ast.span, )); } self.cur_struct = None; Ok(HFunc { name: if owner.is_none() { self.q(&f.name) } else { f.name.clone() }, owner: owner.map(|o| o.to_string()), self_param, mutates: false, params, ret: sig.ret, body, }) } fn declare(&mut self, name: &str, ty: Ty, is_const: bool, span: Span) -> PResult { let scope = self.scopes.last_mut().unwrap(); if scope.contains_key(name) { return Err(Diag::new(format!("`{name}` is already defined in this scope"), span)); } let id = self.next_id; self.next_id += 1; scope.insert(name.to_string(), Local { id, ty, is_const }); Ok(HLocal { id, name: name.to_string(), ty, is_const }) } fn lookup(&self, name: &str) -> Option<&Local> { self.scopes.iter().rev().find_map(|s| s.get(name)) } fn stmts(&mut self, stmts: &[Stmt]) -> PResult> { stmts.iter().map(|s| self.stmt(s)).collect() } fn block(&mut self, b: &Block) -> PResult> { self.scopes.push(HashMap::new()); let saved = self.narrowed.clone(); let r = self.stmts(&b.stmts); self.narrowed = saved; self.scopes.pop(); r } fn stmt(&mut self, s: &Stmt) -> PResult { match s { Stmt::Var(v) => self.var_stmt(v), Stmt::Assign { target, op, value, span } => self.assign(target, *op, value, *span), Stmt::Expr(e) => { if let ExprKind::Match { scrutinee, arms } = &e.kind { return Ok(HStmt::Expr(self.match_expr(scrutinee, arms, None, e.span, true)?)); } if !matches!(e.kind, ExprKind::Call { .. } | ExprKind::Try(_)) { return Err(Diag::new("this expression's value is never used", e.span)); } let h = self.expr_raw(e, None)?; let can_fail = match h.ty { Ty::Error => true, Ty::Tuple(items) => items.contains(&Ty::Error), _ => false, }; if can_fail { return Err(Diag::new( "this call can fail, but its error is ignored; add `?` after it, or keep the result with `var value, err = ...`", e.span, )); } Ok(HStmt::Expr(h)) } Stmt::If { cond, then, else_, .. } => { let cond_h = self.expr_as(cond, Ty::Bool)?; let (when_true, when_false) = self.facts(cond); let saved = self.narrowed.clone(); self.narrowed.extend(when_true.iter().copied()); let then = self.block(then)?; self.narrowed = saved.clone(); self.narrowed.extend(when_false.iter().copied()); let else_ = match else_ { None => Vec::new(), Some(s) => match &**s { Stmt::Block(b) => self.block(b)?, other => vec![self.stmt(other)?], }, }; self.narrowed = saved; // `if x == nil { return }`: after the `if`, x is known to be set if diverges(&then) { self.narrowed.extend(when_false.iter().copied()); } else if !else_.is_empty() && diverges(&else_) { self.narrowed.extend(when_true.iter().copied()); } Ok(HStmt::If { cond: cond_h, then, else_ }) } Stmt::For { kind, body, span } => self.for_stmt(kind, body, *span), Stmt::Return { values, span } => self.return_stmt(values, *span), Stmt::Break(span) | Stmt::Continue(span) => { if self.loops == 0 { let w = if matches!(s, Stmt::Break(_)) { "break" } else { "continue" }; return Err(Diag::new(format!("`{w}` only makes sense inside a `for` loop"), *span)); } Ok(if matches!(s, Stmt::Break(_)) { HStmt::Break } else { HStmt::Continue }) } Stmt::Block(b) => Ok(HStmt::Block(self.block(b)?)), } } /// A value being returned: a local variable moves out; anything else is copied. fn ret_value(&mut self, e: &Expr, ty: Ty) -> PResult { let h = self.expr_as(e, ty)?; let moves = matches!(&h.kind, HExprKind::Local(id, _) if !self.no_move.contains(id)); Ok(if moves { h } else { self.own(h) }) } fn return_stmt(&mut self, values: &[Expr], span: Span) -> PResult { let ret = self.ret; match ret { Ty::Unit => match values.first() { None => Ok(HStmt::Return(None)), Some(e) => Err(Diag::new("this function returns nothing, so `return` can't have a value", e.span)), }, Ty::Tuple(tys) => { if values.len() == tys.len() { let mut items = Vec::new(); for (e, t) in values.iter().zip(tys.iter()) { items.push(self.ret_value(e, *t)?); } return Ok(HStmt::Return(Some(mk(HExprKind::TupleLit(items), ret)))); } if values.len() == 1 { let h = self.expr_raw(&values[0], None)?; if h.ty == ret { return Ok(HStmt::Return(Some(h))); } // `return error("x")` is short for `return 0, error("x")` if tys.last() == Some(&Ty::Error) && h.ty == Ty::Error { let mut items: Vec = tys[..tys.len() - 1].iter().map(|t| self.zero_expr(*t)).collect(); let moves = matches!(&h.kind, HExprKind::Local(id, _) if !self.no_move.contains(id)); items.push(if moves { h } else { self.own(h) }); return Ok(HStmt::Return(Some(mk(HExprKind::TupleLit(items), ret)))); } } Err(Diag::new( format!( "this function returns `{ret}`, so `return` needs {} values (found {})", tys.len(), values.len() ), span, )) } _ => { if values.len() > 1 { return Err(Diag::new( format!("this function returns one `{ret}`, but {} values were given", values.len()), span, )); } match values.first() { None => Err(Diag::new(format!("this function must return a `{ret}`"), span)), Some(e) => Ok(HStmt::Return(Some(self.ret_value(e, ret)?))), } } } } /// `var a, b = f()` fn var_many(&mut self, v: &VarDecl) -> PResult { let (None, Some(value)) = (&v.ty, &v.value) else { return Err(Diag::new("to declare several variables, write `var a, b = f()`", v.span)); }; let h = self.expr_raw(value, None)?; let Ty::Tuple(tys) = h.ty else { return Err(Diag::new( format!("{} names are listed, but this gives one `{}` value", v.names.len(), h.ty), value.span, )); }; if tys.len() != v.names.len() { return Err(Diag::new( format!("this gives {} values `{}`, but {} names are listed", tys.len(), h.ty, v.names.len()), value.span, )); } let mut locals = Vec::new(); for (name, ty) in v.names.iter().zip(tys.iter()) { // `_` throws a value away let name = if name == "_" { format!("_{}", self.next_id) } else { name.clone() }; locals.push(self.declare(&name, *ty, v.is_const, v.span)?); } Ok(HStmt::LetMany { locals, init: h }) } /// What a condition tells us about optional variables: (set when true, set when false). fn facts(&self, e: &Expr) -> (Vec, Vec) { match &e.kind { ExprKind::Binary { op: op @ (BinOp::Eq | BinOp::Ne), lhs, rhs } => { let name = match (&lhs.kind, &rhs.kind) { (ExprKind::Ident(n), ExprKind::Nil) | (ExprKind::Nil, ExprKind::Ident(n)) => n, _ => return (vec![], vec![]), }; match self.lookup(name) { Some(l) if matches!(l.ty, Ty::Opt(_)) => { if *op == BinOp::Ne { (vec![l.id], vec![]) } else { (vec![], vec![l.id]) } } _ => (vec![], vec![]), } } ExprKind::Binary { op: BinOp::And, lhs, rhs } => { let (mut t, _) = self.facts(lhs); t.extend(self.facts(rhs).0); (t, vec![]) } ExprKind::Binary { op: BinOp::Or, lhs, rhs } => { let (_, mut f) = self.facts(lhs); f.extend(self.facts(rhs).1); (vec![], f) } ExprKind::Unary { op: UnOp::Not, expr } => { let (t, f) = self.facts(expr); (f, t) } _ => (vec![], vec![]), } } /// A variable that is known not to be nil reads as its inner value. fn narrowed_use(&self, h: HExpr) -> HExpr { match (&h.kind, h.ty) { (HExprKind::Local(id, _), Ty::Opt(inner)) if self.narrowed.contains(id) => { mk(HExprKind::Unwrap(Box::new(h)), *inner) } _ => h, } } fn var_stmt(&mut self, v: &VarDecl) -> PResult { if v.names.len() != 1 { return self.var_many(v); } let name = &v.names[0]; let (ty, init) = match (&v.ty, &v.value) { (Some(t), Some(e)) => { let ty = self.resolve_type(t, v.span)?; (ty, self.expr_as_owned(e, ty)?) } (Some(t), None) => { let ty = self.resolve_type(t, v.span)?; (ty, self.zero_expr(ty)) } (None, Some(e)) => { let h = self.expr(e, None)?; (h.ty, self.own(h)) } (None, None) => unreachable!("the parser rejects this"), }; // declared after the initializer is checked: `var x = x` means the outer x let local = self.declare(name, ty, v.is_const, v.span)?; Ok(HStmt::Let { local, init }) } /// Check the left side of an assignment: a variable, or fields of one. fn place(&mut self, e: &Expr) -> PResult { match &e.kind { ExprKind::Ident(name) => { if let Some(l) = self.lookup(name) { return Ok(mk(HExprKind::Local(l.id, name.clone()), l.ty)); } if let Some(h) = self.implicit_field(name) { return Ok(h); } if self.consts.contains_key(&self.q(name)) { return Err(Diag::new(format!("`{name}` is a constant and can't be changed"), e.span)); } Err(Diag::new(format!("unknown variable `{name}`"), e.span)) } ExprKind::Field { expr, name } => { let base = self.place(expr)?; let base = self.narrowed_use(base); self.field_of(base, name, e.span) } ExprKind::Index { expr, index } => { let base = self.place(expr)?; let base = self.narrowed_use(base); if matches!(index.kind, ExprKind::Range { .. }) { return Err(Diag::new("a part of a list (`a[1..3]`) is a copy and can't be assigned to", e.span)); } if base.ty == Ty::Str { return Err(Diag::new("a string can't be changed in place; build a new string instead", e.span)); } self.index_of(base, index, e.span) } _ => unsupported(e.span, "assigning to this kind of expression"), } } fn assign(&mut self, target: &Expr, op: AssignOp, value: &Expr, span: Span) -> PResult { let place = self.place(target)?; if let Some((_, root)) = place_root(&place) { if self.lookup(root).map_or(false, |l| l.is_const) { let what = if matches!(place.kind, HExprKind::Local(..)) { format!("`{root}` is a constant and can't be changed") } else { format!("can't change a part of `{root}` because it is a constant") }; return Err(Diag::new(what, target.span)); } } let ty = place.ty; // `a[f()] += 1` must call f once, so complicated indexes are computed first let mut pre: Vec = Vec::new(); let place = if op == AssignOp::Set { place } else { self.hoist_indexes(place, &mut pre) }; let value = match op { AssignOp::Set => self.expr_as_owned(value, ty)?, _ => { let bop = match op { AssignOp::Add => BinOp::Add, AssignOp::Sub => BinOp::Sub, AssignOp::Mul => BinOp::Mul, AssignOp::Div => BinOp::Div, AssignOp::Rem => BinOp::Rem, AssignOp::Set => unreachable!(), }; let rhs = self.expr(value, Some(ty))?; // `counts[w] += 1` on a key that isn't there yet starts from zero let read = match &place.kind { HExprKind::Index { base, index } if matches!(base.ty, Ty::Map(..)) => { mk(HExprKind::MapCall { map: base.clone(), op: MapOp::Zero, args: vec![(**index).clone()] }, ty) } _ => place.clone(), }; let combined = self.binary_typed(bop, read, rhs, span)?; self.coerce(combined, ty, value.span)? } }; if let HExprKind::Local(id, _) = &place.kind { self.narrowed.remove(id); } let assign = HStmt::Assign { target: place, value }; if pre.is_empty() { Ok(assign) } else { pre.push(assign); Ok(HStmt::Block(pre)) } } /// Replace every index that isn't a plain variable or number by a fresh variable /// (declared in `pre`), so the place can be read and written without running it twice. fn hoist_indexes(&mut self, e: HExpr, pre: &mut Vec) -> HExpr { match e.kind { HExprKind::Index { base, index } => { let base = self.hoist_indexes(*base, pre); let index = if matches!(index.kind, HExprKind::Local(..) | HExprKind::Int(_)) { *index } else { let id = self.next_id; self.next_id += 1; let ity = index.ty; let local = HLocal { id, name: "$index".to_string(), ty: ity, is_const: false }; pre.push(HStmt::Let { local, init: *index }); mk(HExprKind::Local(id, "$index".to_string()), ity) }; mk(HExprKind::Index { base: Box::new(base), index: Box::new(index) }, e.ty) } HExprKind::Field { base, name } => { let base = self.hoist_indexes(*base, pre); mk(HExprKind::Field { base: Box::new(base), name }, e.ty) } other => mk(other, e.ty), } } fn index_of(&mut self, base: HExpr, index: &Expr, span: Span) -> PResult { if base.ty == Ty::Str { // `s[i]`: the character that starts at byte `i` let idx = self.expr_as(index, Ty::Int)?; return Ok(mk(HExprKind::Index { base: Box::new(base), index: Box::new(idx) }, Ty::Char)); } if let Ty::Map(key, val) = base.ty { let k = self.expr_as(index, *key)?; return Ok(mk(HExprKind::Index { base: Box::new(base), index: Box::new(k) }, *val)); } let Ty::List(elem) = base.ty else { let hint = ""; return Err(Diag::new(format!("can't index a `{}`{hint}", base.ty), span)); }; let idx = self.expr_as(index, Ty::Int)?; Ok(mk(HExprKind::Index { base: Box::new(base), index: Box::new(idx) }, *elem)) } fn for_stmt(&mut self, kind: &ForKind, body: &Block, span: Span) -> PResult { match kind { ForKind::Infinite => { self.loops += 1; let body = self.block(body); self.loops -= 1; Ok(HStmt::Loop(body?)) } ForKind::While(cond) => { let cond = self.expr_as(cond, Ty::Bool)?; self.loops += 1; let body = self.block(body); self.loops -= 1; Ok(HStmt::While { cond, body: body? }) } ForKind::In { vars, iter, step } => { let ExprKind::Range { start: Some(start), end: Some(end) } = &iter.kind else { return self.for_each(vars, iter, step.as_ref(), body, span); }; if vars.len() != 1 { return unsupported(span, "`for i, x in ...` over a range"); } let start = self.expr_as(start, Ty::Int)?; let end = self.expr_as(end, Ty::Int)?; let step = match step { Some(s) => Some(self.expr_as(s, Ty::Int)?), None => None, }; self.scopes.push(HashMap::new()); let var = self.declare(&vars[0], Ty::Int, false, span); self.loops += 1; let body = var.and_then(|var| self.block(body).map(|b| (var, b))); self.loops -= 1; self.scopes.pop(); let (var, body) = body?; Ok(HStmt::ForRange { var, start, end, step, body }) } } } fn for_each( &mut self, vars: &[String], iter: &Expr, step: Option<&Expr>, body: &Block, span: Span, ) -> PResult { if let Some(s) = step { return Err(Diag::new("`step` only works with ranges like `0..10`", s.span)); } let it = self.expr(iter, None)?; if it.ty == Ty::Str { // `for c in s` walks the characters; `for i, c in s` also gives the byte position self.scopes.push(HashMap::new()); let declared = (|| -> PResult<(Option, HLocal)> { let (index, var) = if vars.len() == 2 { (Some(self.declare(&vars[0], Ty::Int, false, span)?), self.declare(&vars[1], Ty::Char, false, span)?) } else { (None, self.declare(&vars[0], Ty::Char, false, span)?) }; self.no_move.insert(var.id); Ok((index, var)) })(); self.loops += 1; let body = declared.and_then(|(index, var)| self.block(body).map(|b| (index, var, b))); self.loops -= 1; self.scopes.pop(); let (index, var, body) = body?; return Ok(HStmt::ForEach { index, var, iter: it, body }); } if let Ty::Map(key, val) = it.ty { self.scopes.push(HashMap::new()); let declared = (|| -> PResult<(Option, HLocal)> { let (index, var) = if vars.len() == 2 { let k = self.declare(&vars[0], *key, false, span)?; (Some(k), self.declare(&vars[1], *val, false, span)?) } else { (None, self.declare(&vars[0], *key, false, span)?) }; self.no_move.insert(var.id); Ok((index, var)) })(); self.loops += 1; let body = declared.and_then(|(index, var)| self.block(body).map(|b| (index, var, b))); self.loops -= 1; self.scopes.pop(); let (index, var, body) = body?; return Ok(HStmt::ForEach { index, var, iter: it, body }); } let Ty::List(elem) = it.ty else { return Err(Diag::new( format!("can't loop over a `{}`; use a list or a range like `0..10`", it.ty), iter.span, )); }; self.scopes.push(HashMap::new()); let declared = (|| -> PResult<(Option, HLocal)> { let (index, var_name) = if vars.len() == 2 { (Some(self.declare(&vars[0], Ty::Int, false, span)?), &vars[1]) } else { (None, &vars[0]) }; let var = self.declare(var_name, *elem, false, span)?; self.no_move.insert(var.id); Ok((index, var)) })(); self.loops += 1; let body = declared.and_then(|(index, var)| self.block(body).map(|b| (index, var, b))); self.loops -= 1; self.scopes.pop(); let (index, var, body) = body?; Ok(HStmt::ForEach { index, var, iter: it, body }) } // ---------- expressions ---------- /// Check an expression that must produce a value. fn expr(&mut self, e: &Expr, expect: Option) -> PResult { let h = self.expr_raw(e, expect)?; if h.ty == Ty::Unit { return Err(Diag::new("this call returns nothing, so it can't be used as a value", e.span)); } if let Ty::Tuple(_) = h.ty { return Err(Diag::new( format!( "this call returns several values `{}`; take them with `var a, b = ...` (or add `?` to pass the error up)", h.ty ), e.span, )); } Ok(h) } /// Check an expression and require it to have type `want`. fn expr_as(&mut self, e: &Expr, want: Ty) -> PResult { // a `T` is accepted where a `T?` is wanted (`nil` itself is checked against the whole type) let expect = match want { Ty::Opt(inner) if !matches!(e.kind, ExprKind::Nil) => *inner, _ => want, }; let h = self.expr(e, Some(expect))?; if let Ty::Opt(inner) = want { if h.ty == *inner { let owned = self.own(h); return Ok(mk(HExprKind::Wrap(Box::new(owned)), want)); } } self.coerce(h, want, e.span) } fn coerce(&self, h: HExpr, want: Ty, span: Span) -> PResult { if h.ty == want { return Ok(h); } if want.is_number() && (is_int_lit(&h) || (want.is_float() && is_float_lit(&h))) { return retype_lit(h, want, span, false); } // a value whose type has the interface's methods can be used as the interface if let Ty::Iface(key) = want { if matches!(h.ty, Ty::Struct(_) | Ty::Enum(_)) { return match self.bound_failure(&Bound::Iface(key.to_string()), h.ty) { None => { let owned = self.own(h); Ok(mk(HExprKind::ToIface(Box::new(owned)), want)) } Some((_, why)) => Err(Diag::new(format!("expected `{want}`, found `{}`: {why}", h.ty), span)), }; } } let hint = if h.ty.is_number() && want.is_number() { format!(" (convert it with `{want}(...)`)") } else { String::new() }; Err(Diag::new(format!("expected `{want}`, found `{}`{hint}", h.ty), span)) } fn self_local(&self) -> HExpr { let l = self.lookup("self").expect("only called inside methods"); mk(HExprKind::Local(l.id, "self".to_string()), l.ty) } /// Inside a method, a bare name can be a field of `self`. fn implicit_field(&self, name: &str) -> Option { let owner = self.cur_struct?; let (_, ty) = self.structs.get(owner)?.fields.iter().find(|(n, _)| n == name)?; Some(mk( HExprKind::Field { base: Box::new(self.self_local()), name: name.to_string() }, *ty, )) } fn check_field_visible(&self, owner: &str, field: &str, span: Span) -> PResult<()> { let owner_mod = module_of(owner); if owner_mod != self.cur_mod && self.private.contains(&format!("{owner}.{field}")) { return Err(Diag::new( format!("field `{field}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.rex to share it"), span, )); } Ok(()) } fn field_of(&self, base: HExpr, name: &str, span: Span) -> PResult { let base = auto_deref(base); let Ty::Struct(sname) = base.ty else { let hint = if matches!(base.ty, Ty::Enum(_)) { "; use `match` to get at the data of an enum" } else { "" }; return Err(Diag::new( format!("a `{}` has no fields (looking for `.{name}`){hint}", base.ty), span, )); }; let info = &self.structs[sname]; match info.fields.iter().find(|(n, _)| n == name) { Some((_, ty)) => { self.check_field_visible(sname, name, span)?; Ok(mk(HExprKind::Field { base: Box::new(base), name: name.to_string() }, *ty)) } None if info.methods.contains_key(name) => Err(Diag::new( format!("`{name}` is a method of `{sname}`; call it like `.{name}(...)`"), span, )), None => { let mut known: Vec<&str> = info.fields.iter().map(|(n, _)| n.as_str()).collect(); known.extend(info.methods.keys().map(|k| k.as_str())); known.sort(); Err(Diag::new( format!("`{sname}` has no field or method `{name}` (it has: {})", known.join(", ")), span, )) } } } fn expr_raw(&mut self, e: &Expr, expect: Option) -> PResult { match &e.kind { ExprKind::Int(n) => match expect { Some(t) if t.is_number() && t != Ty::Int => retype_lit(mk(HExprKind::Int(*n), Ty::Int), t, e.span, false), _ => Ok(mk(HExprKind::Int(*n), Ty::Int)), }, ExprKind::Float(x) => Ok(mk( HExprKind::Float(*x), if expect == Some(Ty::Num(Num::F32)) { Ty::Num(Num::F32) } else { Ty::Float }, )), ExprKind::Bool(b) => Ok(mk(HExprKind::Bool(*b), Ty::Bool)), ExprKind::Str(parts) => self.string(parts), ExprKind::Ident(name) => self.ident(name, e.span), ExprKind::Unary { op, expr } => { // a negated literal gets its type later, so `-128` can be an `i8` let literal = matches!(expr.kind, ExprKind::Int(_) | ExprKind::Float(_)); let inner = self.expr(expr, if *op == UnOp::Neg && !literal { expect } else { None })?; match (op, inner.ty) { (UnOp::Neg, t) if t.is_number() && !t.is_signed() => { Err(Diag::new(format!("a `{t}` can't be negative, so it can't be negated"), e.span)) } (UnOp::Neg, t) if t.is_number() => { let ty = inner.ty; Ok(mk(HExprKind::Unary { op: *op, expr: Box::new(inner) }, ty)) } (UnOp::Not, Ty::Bool) => { let ty = inner.ty; Ok(mk(HExprKind::Unary { op: *op, expr: Box::new(inner) }, ty)) } (UnOp::Neg, t) => Err(Diag::new(format!("can't negate a `{t}`"), e.span)), (UnOp::Not, t) => Err(Diag::new(format!("`!` needs a `bool`, found `{t}`"), e.span)), } } ExprKind::Binary { op: op @ (BinOp::Eq | BinOp::Ne), lhs, rhs } if matches!(lhs.kind, ExprKind::Nil) || matches!(rhs.kind, ExprKind::Nil) => { let other = if matches!(lhs.kind, ExprKind::Nil) { rhs } else { lhs }; if matches!(other.kind, ExprKind::Nil) { return Err(Diag::new("`nil == nil` is always true; compare a variable with `nil`", e.span)); } // look at the variable itself, not at its narrowed value let plain = match &other.kind { ExprKind::Ident(n) => self.lookup(n).map(|l| mk(HExprKind::Local(l.id, n.clone()), l.ty)), _ => None, }; let h = match plain { Some(h) => h, None => self.expr(other, None)?, }; if !matches!(h.ty, Ty::Opt(_) | Ty::Error | Ty::Weak(_) | Ty::Iface(_) | Ty::CPtr(_)) { return Err(Diag::new( format!("a `{}` can never be nil, so comparing it with `nil` is pointless", h.ty), e.span, )); } let set = mk(HExprKind::IsSet(Box::new(h)), Ty::Bool); Ok(if *op == BinOp::Ne { set } else { mk(HExprKind::Unary { op: UnOp::Not, expr: Box::new(set) }, Ty::Bool) }) } ExprKind::Binary { op, lhs, rhs } => { let arith = matches!(op, BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Rem); let sub = if arith { expect } else { None }; let l = self.expr(lhs, sub)?; // in `x != nil && x.ok`, the right side knows x is set (and `||` with `==`) let mut added: Vec = Vec::new(); if matches!(op, BinOp::And | BinOp::Or) { let (t, f) = self.facts(lhs); let known = if *op == BinOp::And { t } else { f }; added = known.into_iter().filter(|id| self.narrowed.insert(*id)).collect(); } let r = self.expr(rhs, sub)?; for id in added { self.narrowed.remove(&id); } self.binary_typed(*op, l, r, e.span) } ExprKind::Call { callee, args } => self.call(callee, args, e.span), ExprKind::Field { expr, name } if self.module_alias(expr).is_some() => { let m = self.module_alias(expr).unwrap(); self.module_value(m, name, e.span) } ExprKind::Field { expr, name } if self.c_alias(expr).is_some() => { let lib = self.c_alias(expr).unwrap(); self.c_value(lib, name, e.span) } ExprKind::Generic { .. } => Err(Diag::new( "a generic type is not a value; build one with `Name[types]{...}` or pick an enum case with `Name[types].Case`", e.span, )), ExprKind::Field { expr, name } if matches!(expr.kind, ExprKind::Generic { .. }) => { let ExprKind::Generic { expr: base, args } = &expr.kind else { unreachable!() }; let Ty::Enum(en) = self.generic_expr_type(base, args, expr.span)? else { return Err(Diag::new("only enums have cases to pick with `.`", e.span)); }; self.enum_value(en, name, None, e.span) } ExprKind::Field { expr, name } if self.user_alias(expr).is_some() => { let module = self.user_alias(expr).unwrap(); let key = format!("{module}.{name}"); self.check_visible(&key, e.span)?; match self.consts.get(&key) { Some(c) => Ok(c.clone()), None if self.funcs.contains_key(&key) => Err(Diag::new( format!("`{module}.{name}` is a function; call it like `{module}.{name}(...)`"), e.span, )), None => Err(Diag::new(format!("module `{module}` has no value `{name}`"), e.span)), } } ExprKind::Field { expr, name } if self.enum_named(expr).is_some() => { let en = self.enum_named(expr).unwrap(); self.check_visible(en, expr.span)?; self.enum_value(en, name, None, e.span) } ExprKind::Field { expr, name } => { let base = self.expr(expr, None)?; self.field_of(base, name, e.span) } ExprKind::Match { scrutinee, arms } => self.match_expr(scrutinee, arms, expect, e.span, false), ExprKind::Char(c) => Ok(mk(HExprKind::Int(*c as i64), Ty::Char)), ExprKind::Array(items) => self.array_lit(items, expect, e.span), ExprKind::MapLit { types, entries } => self.map_lit(types.as_ref(), entries, expect, e.span), ExprKind::Index { expr, index } => { let base = self.expr(expr, None)?; if let ExprKind::Range { start, end } = &index.kind { if !matches!(base.ty, Ty::List(_) | Ty::Str) { return Err(Diag::new(format!("can't take a part of a `{}`", base.ty), e.span)); } let lo = match start { Some(s) => Some(Box::new(self.expr_as(s, Ty::Int)?)), None => None, }; let hi = match end { Some(s) => Some(Box::new(self.expr_as(s, Ty::Int)?)), None => None, }; let ty = base.ty; return Ok(mk(HExprKind::Slice { base: Box::new(base), lo, hi }, ty)); } self.index_of(base, index, e.span) } ExprKind::StructLit { ty, fields } => self.struct_lit(ty, fields, e.span), ExprKind::Range { .. } => Err(Diag::new( "a range like `a..b` can only be used in `for i in a..b { }`", e.span, )), ExprKind::Nil => match expect { Some(t @ (Ty::Opt(_) | Ty::Error | Ty::Weak(_) | Ty::Iface(_) | Ty::CPtr(_))) => Ok(mk(HExprKind::Nil, t)), _ => Err(Diag::new( "can't tell what `nil` stands for here; it needs a type like `User?` or `error` (for example `return value, nil`)", e.span, )), }, ExprKind::Try(inner) => { let h = self.expr_raw(inner, None)?; let can_pass_up = match self.ret { Ty::Error => true, Ty::Tuple(items) => items.last() == Some(&Ty::Error), _ => false, }; if !can_pass_up { return Err(Diag::new( "`?` passes an error up to the caller, so this function must return an `error` (for example `func load(): (int, error)`)", e.span, )); } let ty = match h.ty { Ty::Error => Ty::Unit, Ty::Tuple(items) if items.len() == 2 && items[1] == Ty::Error => items[0], Ty::Tuple(_) => return unsupported(e.span, "`?` on a call with more than two results"), Ty::Opt(_) => { return Err(Diag::new("`?` is for calls that return an error; for an optional use `if x != nil`", e.span)) } t => { return Err(Diag::new( format!("`?` needs a call that returns an error, but this gives `{t}`"), e.span, )) } }; Ok(mk(HExprKind::Try(Box::new(h)), ty)) } ExprKind::Shared(inner) => { let want = match expect { Some(Ty::Shared(t)) | Some(Ty::Opt(&Ty::Shared(t))) => Some(*t), _ => None, }; let h = self.expr(inner, want)?; if !matches!(h.ty, Ty::Struct(_) | Ty::Enum(_)) { return if matches!(h.ty, Ty::Shared(_)) { Err(Diag::new("this is already `shared`; copy it with `var b = a` to get another owner", e.span)) } else { unsupported(e.span, &format!("`shared` of a `{}` (only structs and enums can be shared for now)", h.ty)) }; } let ty = Ty::shared(h.ty); let owned = self.own(h); Ok(mk(HExprKind::NewShared(Box::new(owned)), ty)) } ExprKind::Weak(inner) => { let h = self.expr(inner, None)?; let Ty::Shared(t) = h.ty else { return Err(Diag::new( format!("`weak` points at a `shared` value, but this is a `{}`", h.ty), e.span, )); }; Ok(mk(HExprKind::Downgrade(Box::new(h)), Ty::Weak(t))) } ExprKind::Closure { params, ret, body } => { let ps: Vec<(String, Option<&Type>)> = params.iter().map(|p| (p.name.clone(), Some(&p.ty))).collect(); let (ep, er) = Self::expected_fn(expect); self.closure_expr(&ps, ret.as_ref(), ClosureBody::Block(body), ep, er, e.span) } ExprKind::Lambda { params, body } => { let ps: Vec<(String, Option<&Type>)> = params.iter().map(|n| (n.clone(), None)).collect(); let (ep, er) = Self::expected_fn(expect); self.closure_expr(&ps, None, ClosureBody::Expr(body), ep, er, e.span) } } } fn map_lit(&mut self, types: Option<&(Type, Type)>, entries: &[(Expr, Expr)], expect: Option, span: Span) -> PResult { let (key_ty, val_ty) = match (types, expect, entries.first()) { (Some((k, v)), _, _) => { let t = self.resolve_type(&Type::Named { path: vec!["map".into()], args: vec![k.clone(), v.clone()] }, span)?; let Ty::Map(k, v) = t else { unreachable!() }; (*k, *v) } (None, Some(Ty::Map(k, v)), _) => (*k, *v), (None, _, Some((k, v))) => { let kt = self.expr(k, None)?.ty; let vt = self.expr(v, None)?.ty; let t = self.resolve_type_of_map(kt, vt, span)?; let Ty::Map(k, v) = t else { unreachable!() }; (*k, *v) } (None, _, None) => { return Err(Diag::new( "can't tell what kind of map `{}` is here; write the type, e.g. `var m: map[string, int] = {}`", span, )) } }; let mut out = Vec::new(); for (k, v) in entries { out.push((self.expr_as_owned(k, key_ty)?, self.expr_as_owned(v, val_ty)?)); } Ok(mk(HExprKind::MapLit { entries: out }, Ty::map(key_ty, val_ty))) } /// Checks that `key` and `val` can make a map, the way a written `map[K, V]` is checked. fn resolve_type_of_map(&self, key: Ty, val: Ty, span: Span) -> PResult { if !(matches!(key, Ty::Int | Ty::Str | Ty::Bool | Ty::Char) || matches!(key, Ty::Num(n) if !n.is_float())) { return Err(Diag::new( format!("a map key must be an `int`, `string`, `bool`, `char` or other whole-number type, not `{key}`"), span, )); } Ok(Ty::map(key, val)) } fn array_lit(&mut self, items: &[Expr], expect: Option, span: Span) -> PResult { let expected_elem = match expect { Some(Ty::List(e)) => Some(*e), _ => None, }; let mut elems = Vec::new(); let elem_ty = match (expected_elem, items.first()) { (Some(t), _) => t, (None, None) => { return Err(Diag::new( "can't tell what kind of list `[]` is here; write the type, e.g. `var xs: []int`", span, )) } (None, Some(first)) => self.expr(first, None)?.ty, }; for item in items { elems.push(self.expr_as_owned(item, elem_ty)?); } Ok(mk(HExprKind::ListLit { elems }, Ty::list(elem_ty))) } fn ident(&mut self, name: &str, span: Span) -> PResult { if let Some(l) = self.lookup(name) { let h = mk(HExprKind::Local(l.id, name.to_string()), l.ty); return Ok(self.narrowed_use(h)); } if let Some(h) = self.implicit_field(name) { return Ok(h); } if let Some(owner) = self.cur_struct { if self.methods_of(owner).map_or(false, |m| m.contains_key(name)) { return Err(Diag::new(format!("`{name}` is a method; call it like `{name}(...)`"), span)); } } let key = self.q(name); if let Some(c) = self.consts.get(&key) { return Ok(c.clone()); } if let Some(lib) = self.c_item(name) { return self.c_value(lib, name, span); } if self.funcs.contains_key(&key) { return self.func_value(&key, name, span); } if self.generics.contains_key(&key) || BUILTINS.contains(&name) { return Err(Diag::new(format!("`{name}` is a function; call it like `{name}(...)`"), span)); } if self.structs.contains_key(&key) { return Err(Diag::new( format!("`{name}` is a type, not a value; build one with `{name}{{...}}`"), span, )); } if let Some(info) = self.enums.get(&key) { return Err(Diag::new( format!("`{name}` is a type, not a value; pick a case, like `{name}.{}`", info.variants[0].name), span, )); } Err(Diag::new(format!("unknown name `{name}`"), span)) } fn struct_lit(&mut self, ty: &Expr, inits: &[FieldInit], span: Span) -> PResult { let name = match &ty.kind { ExprKind::Ident(n) => n, ExprKind::Field { name, .. } => name, ExprKind::Generic { expr, .. } => match &expr.kind { ExprKind::Ident(n) => n, ExprKind::Field { name, .. } => name, _ => return unsupported(ty.span, "building values of this kind of type"), }, _ => return unsupported(ty.span, "building values of this kind of type"), }; let key = if let ExprKind::Generic { expr, args } = &ty.kind { match self.generic_expr_type(expr, args, ty.span)? { Ty::Struct(n) => n.to_string(), other => return Err(Diag::new(format!("`{other}` is not a struct, so it can't be built with `{{...}}`"), ty.span)), } } else { let Some(key) = self.global_key(ty) else { return Err(Diag::new(format!("unknown type `{name}`"), ty.span)); }; if self.gtypes.contains_key(&key) { return Err(Diag::new(format!("`{name}` needs types: write `{name}[int]{{...}}`"), ty.span)); } key }; let Some(info) = self.structs.get(&key) else { return Err(Diag::new(format!("unknown type `{name}`"), ty.span)); }; self.check_visible(&key, ty.span)?; let (sname, fields) = (info.name, info.fields.clone()); let given: Vec<&str> = if inits.iter().any(|i| i.name.is_some()) { inits.iter().filter_map(|i| i.name.as_deref()).collect() } else { fields.iter().take(inits.len()).map(|(n, _)| n.as_str()).collect() }; for f in given { self.check_field_visible(sname, f, span)?; } let named = inits.iter().filter(|i| i.name.is_some()).count(); if named != 0 && named != inits.len() { return Err(Diag::new("give every field a name (`x: 1`) or none of them, not a mix", span)); } // (field name, value) in the order written let mut values: Vec<(String, HExpr)> = Vec::new(); if named == 0 { if !inits.is_empty() && inits.len() != fields.len() { return Err(Diag::new( format!( "`{name}` has {} field{}, but {} value{} given (or name the fields: `{name}{{x: 1}}`)", fields.len(), if fields.len() == 1 { "" } else { "s" }, inits.len(), if inits.len() == 1 { " was" } else { "s were" }, ), span, )); } for (init, (fname, fty)) in inits.iter().zip(&fields) { values.push((fname.clone(), self.expr_as_owned(&init.value, *fty)?)); } } else { for init in inits { let fname = init.name.as_ref().unwrap(); let Some((_, fty)) = fields.iter().find(|(n, _)| n == fname) else { return Err(Diag::new(format!("`{name}` has no field `{fname}`"), init.value.span)); }; if values.iter().any(|(n, _)| n == fname) { return Err(Diag::new(format!("field `{fname}` is given twice"), init.value.span)); } values.push((fname.clone(), self.expr_as_owned(&init.value, *fty)?)); } } // fields that were left out start at their zero value for (fname, fty) in &fields { if !values.iter().any(|(n, _)| n == fname) { values.push((fname.clone(), self.zero_expr(*fty))); } } Ok(mk(HExprKind::StructLit { name: sname.to_string(), fields: values }, Ty::Struct(sname))) } // ---------- match ---------- fn variant_index(&self, enum_name: &str, written: &str) -> Option { let case = written.rsplit('.').next().unwrap_or(written); self.enums[enum_name].variants.iter().position(|v| v.name == case) } fn match_expr(&mut self, scrutinee: &Expr, arms: &[MatchArm], expect: Option, span: Span, as_stmt: bool) -> PResult { let scrut = self.expr(scrutinee, None)?; let scrut = auto_deref(scrut); let sty = scrut.ty; if !(matches!(sty, Ty::Enum(_) | Ty::Bool | Ty::Str | Ty::Char) || sty.is_int()) { return Err(Diag::new( format!("can't `match` on a `{sty}` (matching works on enums, ints, bools, chars and strings)"), scrutinee.span, )); } let mut cover = Cover::default(); let mut res_ty: Option = None; let mut hir_arms = Vec::new(); for arm in arms { if cover.catch_all { return Err(Diag::new( "this case can never match, because an earlier case already matches everything", arm.span, )); } self.scopes.push(HashMap::new()); let r = self.match_arm(arm, sty, &mut cover, &mut res_ty, expect, as_stmt); self.scopes.pop(); hir_arms.push(r?); } if !cover.catch_all { let missing: Vec = match sty { Ty::Enum(en) => self.enums[en] .variants .iter() .enumerate() .filter(|(i, _)| !cover.variants.contains(i)) .map(|(_, v)| format!("{en}.{}", v.name)) .collect(), Ty::Bool => [(cover.t, "true"), (cover.f, "false")] .iter() .filter(|(seen, _)| !seen) .map(|(_, n)| n.to_string()) .collect(), _ => vec!["every other value".to_string()], }; if !missing.is_empty() { let how = if sty.is_int() || sty == Ty::Str || sty == Ty::Char { "add a `_` case to cover all the other values".to_string() } else { "add the missing cases, or a `_` case for all the rest".to_string() }; return Err(Diag::new( format!("this `match` doesn't handle {} ({how})", missing.join(", ")), span, )); } } let ty = if as_stmt { Ty::Unit } else { res_ty.unwrap_or(Ty::Unit) }; Ok(mk(HExprKind::Match { scrutinee: Box::new(scrut), arms: hir_arms }, ty)) } /// A name in a pattern that binds data (rather than naming an enum case) is lowercase. fn binding_name_ok(name: &str) -> bool { !name.contains('.') && name.chars().next().map_or(false, |c| c.is_lowercase() || c == '_') } fn bind(&mut self, name: &str, ty: Ty, span: Span) -> PResult { let local = self.declare(name, ty, false, span)?; // a binding looks at the matched value; `return x` must copy it self.no_move.insert(local.id); Ok(local) } fn match_arm( &mut self, arm: &MatchArm, sty: Ty, cover: &mut Cover, res_ty: &mut Option, expect: Option, as_stmt: bool, ) -> PResult { let span = arm.span; let case_pat = |this: &mut Checker, en: &'static str, name: &str, subs: &[Pattern], cover: &mut Cover| -> PResult { let Some(idx) = this.variant_index(en, name) else { let cases: Vec<&str> = this.enums[en].variants.iter().map(|v| v.name.as_str()).collect(); return Err(Diag::new( format!("enum `{en}` has no case `{name}` (its cases: {})", cases.join(", ")), span, )); }; let fields = this.enums[en].variants[idx].fields.clone(); let case = this.enums[en].variants[idx].name.clone(); if subs.len() != fields.len() { let msg = if fields.is_empty() { format!("`{en}.{case}` has no data, so write it without parentheses") } else { let names: Vec = fields.iter().map(|(n, t)| format!("{n}: {t}")).collect(); format!("`{en}.{case}` carries {}; write all of them: {case}({})", names.join(", "), vec!["_"; fields.len()].join(", ")) }; return Err(Diag::new(msg, span)); } if !cover.variants.insert(idx) { return Err(Diag::new(format!("`{en}.{case}` is already handled by an earlier case"), span)); } let mut binds = Vec::new(); for (sub, (_, fty)) in subs.iter().zip(&fields) { binds.push(match sub { Pattern::Wildcard => None, Pattern::Binding(n) if Checker::binding_name_ok(n) => Some(this.bind(n, *fty, span)?), Pattern::Binding(n) => { return Err(Diag::new( format!("`{n}` inside a case must be a lowercase name that takes the data (nested cases aren't supported yet)"), span, )) } Pattern::Variant { .. } => return unsupported(span, "a case inside a case"), _ => return unsupported(span, "a literal inside a case"), }); } Ok(HPat::Variant { index: idx, binds }) }; let pat = match &arm.pattern { Pattern::Wildcard => { cover.catch_all = true; HPat::CatchAll(None) } Pattern::Binding(name) => match sty { Ty::Enum(en) if self.variant_index(en, name).is_some() => { let idx = self.variant_index(en, name).unwrap(); let v = &self.enums[en].variants[idx]; if !v.fields.is_empty() { let blanks = vec!["_"; v.fields.len()].join(", "); return Err(Diag::new( format!("`{en}.{}` carries data; write `{}({blanks})` to ignore it or name the pieces", v.name, v.name), span, )); } case_pat(self, en, name, &[], cover)? } _ if Checker::binding_name_ok(name) => { cover.catch_all = true; HPat::CatchAll(Some(self.bind(name, sty, span)?)) } Ty::Enum(en) => { let cases: Vec<&str> = self.enums[en].variants.iter().map(|v| v.name.as_str()).collect(); return Err(Diag::new( format!("enum `{en}` has no case `{name}` (its cases: {})", cases.join(", ")), span, )); } _ => { return Err(Diag::new( format!("`{name}` isn't something a `{sty}` can be matched against; use a value or a lowercase name"), span, )) } }, Pattern::Variant { name, args } => match sty { Ty::Enum(en) => case_pat(self, en, name, args, cover)?, _ => return Err(Diag::new(format!("`{name}(...)` only works when matching an enum, not a `{sty}`"), span)), }, Pattern::Int(n) => { if !sty.is_int() { return Err(Diag::new(format!("this is a number, but the value being matched is a `{sty}`"), span)); } if !cover.ints.insert(*n) { return Err(Diag::new(format!("{n} is already handled by an earlier case"), span)); } HPat::Int(*n) } Pattern::Char(c) => { if sty != Ty::Char { return Err(Diag::new(format!("this is a character, but the value being matched is a `{sty}`"), span)); } if !cover.ints.insert(*c as i64) { return Err(Diag::new(format!("'{c}' is already handled by an earlier case"), span)); } HPat::Int(*c as i64) } Pattern::Bool(b) => { if sty != Ty::Bool { return Err(Diag::new(format!("this is a bool, but the value being matched is a `{sty}`"), span)); } let seen = if *b { &mut cover.t } else { &mut cover.f }; if *seen { return Err(Diag::new(format!("{b} is already handled by an earlier case"), span)); } *seen = true; HPat::Bool(*b) } Pattern::Str(t) => { if sty != Ty::Str { return Err(Diag::new(format!("this is a string, but the value being matched is a `{sty}`"), span)); } if !cover.strs.insert(t.clone()) { return Err(Diag::new(format!("\"{t}\" is already handled by an earlier case"), span)); } HPat::Str(t.clone()) } Pattern::Nil => return unsupported(span, "`nil` in a pattern"), }; let body = match (&arm.body, as_stmt) { (ArmBody::Block(b), true) => HArmBody::Block(self.block(b)?), (ArmBody::Expr(e), true) => HArmBody::Expr(self.expr_raw(e, None)?), (ArmBody::Expr(e), false) => { let h = self.expr(e, res_ty.or(expect))?; let h = match *res_ty { None => { *res_ty = Some(h.ty); h } Some(t) => self.coerce(h, t, e.span)?, }; HArmBody::Expr(self.own(h)) } (ArmBody::Block(b), false) => match b.stmts.as_slice() { [st @ (Stmt::Return { .. } | Stmt::Break(_) | Stmt::Continue(_))] => { HArmBody::Block(vec![self.stmt(st)?]) } _ => { return Err(Diag::new( "an arm of a `match` that produces a value must be a single expression \ (call a function for more, or use the `match` as a statement)", b.span, )) } }, }; Ok(HArm { pat, body }) } fn string(&mut self, parts: &[StrPart]) -> PResult { if parts.iter().all(|p| matches!(p, StrPart::Text(_))) { let s: String = parts .iter() .map(|p| match p { StrPart::Text(t) => t.as_str(), _ => "", }) .collect(); return Ok(mk(HExprKind::Str(s), Ty::Str)); } let mut out = Vec::new(); for p in parts { match p { StrPart::Text(t) => out.push(HInterp::Text(t.clone())), StrPart::Expr(e) => { let h = self.expr(e, None)?; out.push(HInterp::Value(h)); } } } Ok(mk(HExprKind::Interp(out), Ty::Str)) } fn binary_typed(&self, op: BinOp, mut l: HExpr, mut r: HExpr, span: Span) -> PResult { // `x * 2` where x is a float: the literal becomes a float if l.ty != r.ty { if is_int_lit(&l) && r.ty.is_number() || is_float_lit(&l) && r.ty.is_float() { l = retype_lit(l, r.ty, span, false)?; } else if is_int_lit(&r) && l.ty.is_number() || is_float_lit(&r) && l.ty.is_float() { r = retype_lit(r, l.ty, span, false)?; } } if l.ty != r.ty { let hint = if matches!((l.ty, r.ty), (Ty::Int, Ty::Float) | (Ty::Float, Ty::Int)) { "; convert one side with `float(...)` or `int(...)`".to_string() } else if l.ty.is_number() && r.ty.is_number() { format!("; convert one side, for example `{}(...)`", l.ty) } else { String::new() }; return Err(Diag::new( format!("can't use `{}` between `{}` and `{}`{hint}", op_str(op), l.ty, r.ty), span, )); } let t = l.ty; let ok = match op { BinOp::Add => t.is_number() || t == Ty::Str, BinOp::Sub | BinOp::Mul | BinOp::Div => t.is_number(), BinOp::Rem => t.is_int(), BinOp::Eq | BinOp::Ne => { t.is_number() || matches!(t, Ty::Bool | Ty::Str | Ty::Char | Ty::CPtr(_)) || matches!(t, Ty::Enum(n) if self.enums[n].variants.iter().all(|v| v.fields.is_empty())) } BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge => t.is_number() || t == Ty::Str || t == Ty::Char, BinOp::And | BinOp::Or => t == Ty::Bool, }; if !ok { let hint = match t { Ty::Struct(_) if matches!(op, BinOp::Eq | BinOp::Ne) => " (compare the fields one by one)", Ty::Enum(_) if matches!(op, BinOp::Eq | BinOp::Ne) => " (use `match` for enums that carry data)", _ => "", }; return Err(Diag::new(format!("`{}` doesn't work on `{t}` values{hint}", op_str(op)), span)); } let ty = match op { BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge => Ty::Bool, _ => t, }; Ok(mk(HExprKind::Binary { op, lhs: Box::new(l), rhs: Box::new(r) }, ty)) } fn check_args(&mut self, name: &str, params: &[Ty], args: &[Expr], span: Span) -> PResult> { if args.len() != params.len() { return Err(Diag::new( format!( "`{name}` takes {} argument{}, but {} {} given", params.len(), if params.len() == 1 { "" } else { "s" }, args.len(), if args.len() == 1 { "was" } else { "were" }, ), span, )); } let mut hs = Vec::new(); for (a, ty) in args.iter().zip(params) { hs.push(self.expr_as_owned(a, *ty)?); } Ok(hs) } /// Methods that lists and strings have built in. fn builtin_method(&mut self, recv: HExpr, name: &str, args: &[Expr], span: Span, name_span: Span) -> PResult { let want_args = |n: usize| -> PResult<()> { if args.len() != n { return Err(Diag::new( format!("`{name}` takes {n} argument{}, but {} {} given", if n == 1 { "" } else { "s" }, args.len(), if args.len() == 1 { "was" } else { "were" }), span, )); } Ok(()) }; if recv.ty == Ty::Str && name != "len" { if let Some(sig) = stdlib::str_method(name) { return self.builtin_call(name, sig, Some(recv), args, span); } } if matches!(recv.ty, Ty::List(e) if *e == Ty::Str) { if let Some(sig) = stdlib::str_list_method(name) { return self.builtin_call(name, sig, Some(recv), args, span); } } if let Ty::Map(key, val) = recv.ty { return self.map_method(recv, *key, *val, name, args, span, name_span); } match (recv.ty, name) { (Ty::List(_) | Ty::Str, "len") => { want_args(0)?; Ok(mk(HExprKind::Len(Box::new(recv)), Ty::Int)) } (Ty::List(elem), "push") => { want_args(1)?; self.require_variable(&recv, "push", name_span)?; let value = self.expr_as_owned(&args[0], *elem)?; Ok(mk(HExprKind::ListPush { list: Box::new(recv), value: Box::new(value) }, Ty::Unit)) } (Ty::List(elem), "pop") => { want_args(0)?; self.require_variable(&recv, "pop", name_span)?; Ok(mk(HExprKind::ListPop(Box::new(recv)), *elem)) } (Ty::List(_), _) => Err(Diag::new( format!("lists have no method `{name}` (they have: len, push, pop)"), name_span, )), (Ty::Str, _) => Err(Diag::new( format!("strings have no method `{name}` (they have: {})", stdlib::STR_METHODS), name_span, )), _ => unreachable!(), } } fn map_method(&mut self, recv: HExpr, key: Ty, val: Ty, name: &str, args: &[Expr], span: Span, name_span: Span) -> PResult { let want = |n: usize| -> PResult<()> { if args.len() != n { return Err(Diag::new( format!("`{name}` takes {n} argument{}, but {} {} given", if n == 1 { "" } else { "s" }, args.len(), if args.len() == 1 { "was" } else { "were" }), span, )); } Ok(()) }; let call = |recv: HExpr, op: MapOp, args: Vec, ty: Ty| mk(HExprKind::MapCall { map: Box::new(recv), op, args }, ty); match name { "len" => { want(0)?; Ok(mk(HExprKind::Len(Box::new(recv)), Ty::Int)) } "has" => { want(1)?; let k = self.expr_as(&args[0], key)?; Ok(call(recv, MapOp::Has, vec![k], Ty::Bool)) } "get" => { want(1)?; let k = self.expr_as(&args[0], key)?; Ok(call(recv, MapOp::Get, vec![k], Ty::opt(val))) } "get_or" => { want(2)?; let k = self.expr_as(&args[0], key)?; let d = self.expr_as_owned(&args[1], val)?; Ok(call(recv, MapOp::GetOr, vec![k, d], val)) } "remove" => { want(1)?; self.require_variable(&recv, "remove", name_span)?; let k = self.expr_as(&args[0], key)?; Ok(call(recv, MapOp::Remove, vec![k], Ty::Unit)) } "keys" => { want(0)?; Ok(call(recv, MapOp::Keys, vec![], Ty::list(key))) } "values" => { want(0)?; Ok(call(recv, MapOp::Values, vec![], Ty::list(val))) } _ => Err(Diag::new( format!("maps have no method `{name}` (they have: len, has, get, get_or, remove, keys, values)"), name_span, )), } } /// Methods that change a list need a variable to change: not a constant, not a temporary. fn require_variable(&self, recv: &HExpr, method: &str, span: Span) -> PResult<()> { match place_root(recv) { None => Err(Diag::new( format!("`{method}` changes it, so it must be called on a variable, not a temporary value"), span, )), Some((_, root)) if self.lookup(root).map_or(false, |l| l.is_const) => { Err(Diag::new(format!("`{method}` changes `{root}`, but `{root}` is a constant"), span)) } Some(_) => Ok(()), } } fn method_call(&mut self, recv: HExpr, name: &str, args: &[Expr], span: Span, name_span: Span) -> PResult { if let (Ty::Weak(t), "upgrade") = (recv.ty, name) { if !args.is_empty() { return Err(Diag::new("`upgrade` takes no arguments", span)); } return Ok(mk(HExprKind::Upgrade(Box::new(recv)), Ty::opt(Ty::Shared(t)))); } let recv = auto_deref(recv); if let Ty::Iface(key) = recv.ty { let Some((_, params, ret)) = self.ifaces[key].methods.iter().find(|(n, _, _)| n == name).cloned() else { let known: Vec<&str> = self.ifaces[key].methods.iter().map(|(n, _, _)| n.as_str()).collect(); return Err(Diag::new( format!("`{key}` has no method `{name}` (it has: {})", known.join(", ")), name_span, )); }; let hs = self.check_args(name, ¶ms, args, span)?; return Ok(mk(HExprKind::IfaceCall { recv: Box::new(recv), method: name.to_string(), args: hs }, ret)); } if recv.ty == Ty::Char { return match stdlib::char_method(name) { Some(sig) => self.builtin_call(name, sig, Some(recv), args, span), None => Err(Diag::new( format!("characters have no method `{name}` (they have: {})", stdlib::CHAR_METHODS), name_span, )), }; } if matches!(recv.ty, Ty::List(_) | Ty::Str | Ty::Map(..)) { return self.builtin_method(recv, name, args, span, name_span); } let (Ty::Struct(owner) | Ty::Enum(owner)) = recv.ty else { return Err(Diag::new(format!("a `{}` has no methods (looking for `.{name}()`)", recv.ty), name_span)); }; let Some(sig) = self.methods_of(owner).and_then(|m| m.get(name)).cloned() else { if let Ty::Enum(_) = recv.ty { return Err(Diag::new(format!("enum `{owner}` has no method `{name}`"), name_span)); } // reuse the field error for a good "did you mean" list return match self.field_of(recv, name, name_span) { Ok(h) if matches!(h.ty, Ty::Func(_)) => self.call_value(h, name, args, span), Ok(_) => Err(Diag::new(format!("`{name}` is a field, not a method"), name_span)), Err(d) => Err(d), }; }; let owner_mod = module_of(owner); // generic code may call the methods an `interface` asks for on the types it was given let via_rule = self.tsubst.values().any(|t| matches!(t, Ty::Struct(n) | Ty::Enum(n) if *n == owner)) && self.ifaces.values().any(|i| i.methods.iter().any(|(n, _, _)| n == name)); if owner_mod != self.cur_mod && !via_rule && self.private.contains(&format!("{owner}.{name}")) { return Err(Diag::new( format!("method `{name}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.rex to share it"), name_span, )); } let hs = self.check_args(name, &sig.params, args, span)?; Ok(mk( HExprKind::MethodCall { owner: owner.to_string(), method: name.to_string(), recv: Box::new(recv), args: hs, span, }, sig.ret, )) } /// If `e` is just the name of an enum (not shadowed by a variable), that enum. fn enum_named(&self, e: &Expr) -> Option<&'static str> { if let ExprKind::Ident(n) = &e.kind { if self.lookup(n).is_some() || self.implicit_field(n).is_some() || self.consts.contains_key(&self.q(n)) { return None; } } let key = self.global_key(e)?; self.enums.get(&key).map(|i| i.name) } /// `Shape.Circle(2.0)` or `Shape.Point`. fn enum_value(&mut self, enum_name: &'static str, case: &str, args: Option<&[Expr]>, span: Span) -> PResult { let info = &self.enums[enum_name]; let Some(idx) = info.variants.iter().position(|v| v.name == case) else { let cases: Vec<&str> = info.variants.iter().map(|v| v.name.as_str()).collect(); return Err(Diag::new( format!("enum `{enum_name}` has no case `{case}` (its cases: {})", cases.join(", ")), span, )); }; let fields = info.variants[idx].fields.clone(); let args = args.unwrap_or(&[]); if args.len() != fields.len() { let what = if fields.is_empty() { format!("`{enum_name}.{case}` has no data, so write it without parentheses") } else { let names: Vec = fields.iter().map(|(n, t)| format!("{n}: {t}")).collect(); format!("`{enum_name}.{case}` needs {} value{}: ({})", fields.len(), if fields.len() == 1 { "" } else { "s" }, names.join(", ")) }; return Err(Diag::new(what, span)); } let mut values = Vec::new(); for (a, (_, ty)) in args.iter().zip(&fields) { values.push(self.expr_as_owned(a, *ty)?); } Ok(mk( HExprKind::EnumLit { enum_name: enum_name.to_string(), variant: idx, fields: values }, Ty::Enum(enum_name), )) } fn call(&mut self, callee: &Expr, args: &[Expr], span: Span) -> PResult { match &callee.kind { ExprKind::Field { expr, name } if self.c_alias(expr).is_some() => { let lib = self.c_alias(expr).unwrap(); self.c_call(lib, name, args, span, callee.span) } ExprKind::Ident(name) if self.c_item(name).is_some() => { let lib = self.c_item(name).unwrap(); self.c_call(lib, name, args, span, callee.span) } ExprKind::Field { expr, name } if self.module_alias(expr).is_some() => { let m = self.module_alias(expr).unwrap(); self.module_call(m, name, args, span, callee.span) } ExprKind::Field { expr, name } if matches!(expr.kind, ExprKind::Generic { .. }) => { let ExprKind::Generic { expr: base, args: targs } = &expr.kind else { unreachable!() }; let Ty::Enum(en) = self.generic_expr_type(base, targs, expr.span)? else { return Err(Diag::new("only enums have cases to pick with `.`", callee.span)); }; self.enum_value(en, name, Some(args), span) } ExprKind::Field { expr, name } if self.user_alias(expr).is_some() => { let module = self.user_alias(expr).unwrap(); let key = format!("{module}.{name}"); self.check_visible(&key, callee.span)?; self.call_user_func(&key, name, callee.span, args, span) } ExprKind::Field { expr, name } if self.enum_named(expr).is_some() => { let e = self.enum_named(expr).unwrap(); self.check_visible(e, expr.span)?; self.enum_value(e, name, Some(args), span) } ExprKind::Field { expr, name } => { let recv = self.expr(expr, None)?; self.method_call(recv, name, args, span, callee.span) } ExprKind::Ident(name) => self.call_named(name, callee.span, args, span), _ => { let h = self.expr(callee, None)?; if matches!(h.ty, Ty::Func(_)) { self.call_value(h, "this function", args, span) } else { Err(Diag::new(format!("can't call a `{}`", h.ty), callee.span)) } } } } fn call_named(&mut self, name: &str, name_span: Span, args: &[Expr], span: Span) -> PResult { if let Some(l) = self.lookup(name) { if let Ty::Func(_) = l.ty { let callee = mk(HExprKind::Local(l.id, name.to_string()), l.ty); return self.call_value(callee, name, args, span); } return Err(Diag::new(format!("`{name}` is a variable, not a function"), name_span)); } // inside a method, a bare name can be another method of the same struct if let Some(owner) = self.cur_struct { if self.methods_of(owner).map_or(false, |m| m.contains_key(name)) { let recv = self.self_local(); return self.method_call(recv, name, args, span, name_span); } if self.structs.get(owner).map_or(false, |i| i.fields.iter().any(|(n, _)| n == name)) { if let Some(h) = self.implicit_field(name) { if matches!(h.ty, Ty::Func(_)) { return self.call_value(h, name, args, span); } } return Err(Diag::new(format!("`{name}` is a field, not a method"), name_span)); } } match name { "print" => { let mut hs = Vec::new(); for a in args { hs.push(self.expr(a, None)?); } Ok(mk(HExprKind::Print(hs), Ty::Unit)) } "error" => { if args.len() != 1 { return Err(Diag::new("`error` takes exactly 1 argument: the message", span)); } let msg = self.expr_as_owned(&args[0], Ty::Str)?; Ok(mk(HExprKind::MakeError(Box::new(msg)), Ty::Error)) } "string" => { if args.len() != 1 { return Err(Diag::new("`string` takes exactly 1 argument", span)); } let a = self.expr(&args[0], None)?; Ok(mk(HExprKind::Interp(vec![HInterp::Value(a)]), Ty::Str)) } n if conversion_target(n).is_some() => { if args.len() != 1 { return Err(Diag::new(format!("`{name}` takes exactly 1 argument"), span)); } let target = conversion_target(n).unwrap(); let a = self.expr(&args[0], None)?; match a.ty { t if t == target => Ok(a), // a character and its number: `int('a')` is 97, `char(97)` is 'a' Ty::Char if target.is_int() => Ok(mk(HExprKind::Convert(Box::new(a)), target)), t if t.is_int() && target == Ty::Char => Ok(mk(HExprKind::Convert(Box::new(a)), target)), t if t.is_number() && target != Ty::Char => Ok(mk(HExprKind::Convert(Box::new(a)), target)), t => Err(Diag::new(format!("can't convert a `{t}` to `{target}`"), args[0].span)), } } _ => { let key = self.q(name); self.call_user_func(&key, name, name_span, args, span) } } } fn expected_fn(expect: Option) -> (Option>, Option) { match expect { Some(Ty::Func(f)) => (Some(f.params.clone()), Some(f.ret)), Some(Ty::Opt(Ty::Func(f))) => (Some(f.params.clone()), Some(f.ret)), _ => (None, None), } } /// `func(x: int): int { ... }` and `x => x * 2`. Variables of the surrounding function that the body /// uses are copied into the closure when it is made; from then on it has its own copies. fn closure_expr( &mut self, params: &[(String, Option<&Type>)], ret: Option<&Type>, body: ClosureBody, exp_params: Option>, exp_ret: Option, span: Span, ) -> PResult { // parameter types: written, or taken from where the closure is used let mut ptys = Vec::new(); for (i, (name, ty)) in params.iter().enumerate() { let t = match ty { Some(t) => self.resolve_type(t, span)?, None => match &exp_params { Some(ps) if ps.len() == params.len() => ps[i], Some(ps) => { return Err(Diag::new( format!( "this function has {} parameter{}, but {} {} expected here", params.len(), if params.len() == 1 { "" } else { "s" }, ps.len(), if ps.len() == 1 { "is" } else { "are" } ), span, )) } None => { return Err(Diag::new( format!( "can't tell what type `{name}` is here; write it out: `func({name}: int): int {{ ... }}`" ), span, )) } }, }; ptys.push(t); } let mut ret_ty: Option = match ret { Some(t) => Some(self.resolve_type(t, span)?), None => match body { ClosureBody::Block(_) => Some(Ty::Unit), ClosureBody::Expr(_) => exp_ret, }, }; if matches!(ret_ty, Some(Ty::Tuple(_))) { return unsupported(span, "a function value with several results"); } // what the body uses from outside let mut used = HashSet::new(); match &body { ClosureBody::Block(b) => idents_block(b, &mut used), ClosureBody::Expr(x) => idents_expr(x, &mut used), } let mut names: Vec = used .iter() .filter(|n| !params.iter().any(|(p, _)| p == *n) && self.lookup(n).is_some()) .cloned() .collect(); let wants_self = self.cur_struct.is_some() && !params.iter().any(|(p, _)| p == "self") && self.lookup("self").is_some() && used.iter().any(|n| { self.lookup(n).is_none() && (self.implicit_field(n).is_some() || self.methods_of(self.cur_struct.unwrap()).map_or(false, |m| m.contains_key(n))) }); if wants_self && !names.iter().any(|n| n == "self") { names.push("self".to_string()); } names.sort(); let mut outer: Vec<(String, Local, HExpr)> = Vec::new(); for n in names { let l = self.lookup(&n).unwrap(); let l = Local { id: l.id, ty: l.ty, is_const: l.is_const }; let view = mk(HExprKind::Local(l.id, n.clone()), l.ty); let owned = self.own(view); outer.push((n, l, owned)); } // check the body as a function of its own let saved_scopes = std::mem::replace(&mut self.scopes, vec![HashMap::new()]); let saved_ret = self.ret; let saved_loops = std::mem::replace(&mut self.loops, 0); let saved_narrowed = std::mem::take(&mut self.narrowed); let saved_no_move = std::mem::take(&mut self.no_move); let r = self.closure_inner(&outer, params, &ptys, &mut ret_ty, body, span); self.scopes = saved_scopes; self.ret = saved_ret; self.loops = saved_loops; self.narrowed = saved_narrowed; self.no_move = saved_no_move; let (inner_caps, plocals, stmts) = r?; let ret = ret_ty.unwrap_or(Ty::Unit); let captures: Vec<(HLocal, HExpr)> = inner_caps.into_iter().zip(outer.into_iter().map(|(_, _, h)| h)).collect(); Ok(mk( HExprKind::Closure { params: plocals, ret, body: stmts, captures }, Ty::func(ptys, ret), )) } fn closure_inner( &mut self, outer: &[(String, Local, HExpr)], params: &[(String, Option<&Type>)], ptys: &[Ty], ret_ty: &mut Option, body: ClosureBody, span: Span, ) -> PResult<(Vec, Vec, Vec)> { let mut caps = Vec::new(); for (n, l, _) in outer { let inner = self.declare(n, l.ty, l.is_const, span)?; self.no_move.insert(inner.id); caps.push(inner); } let mut plocals = Vec::new(); for ((name, _), ty) in params.iter().zip(ptys) { let l = self.declare(name, *ty, false, span)?; self.no_move.insert(l.id); plocals.push(l); } self.ret = ret_ty.unwrap_or(Ty::Unit); let stmts = match body { ClosureBody::Block(b) => { let stmts = self.stmts(&b.stmts)?; let rt = ret_ty.unwrap_or(Ty::Unit); if rt != Ty::Unit && !always_returns(&stmts) { return Err(Diag::new( format!("this function can reach its end without returning a `{rt}`"), b.span, )); } stmts } ClosureBody::Expr(x) => match *ret_ty { Some(Ty::Unit) => vec![HStmt::Expr(self.expr(x, None)?)], Some(rt) => { let h = self.expr_as_owned(x, rt)?; vec![HStmt::Return(Some(h))] } None => { let h = self.expr(x, None)?; if matches!(h.ty, Ty::Tuple(_)) { return unsupported(x.span, "a function value with several results"); } *ret_ty = Some(h.ty); if h.ty == Ty::Unit { vec![HStmt::Expr(h)] } else { let h = self.own(h); vec![HStmt::Return(Some(h))] } } }, }; Ok((caps, plocals, stmts)) } /// A call of a function value (a variable, a field, or any expression of a function type). fn call_value(&mut self, callee: HExpr, name: &str, args: &[Expr], span: Span) -> PResult { let Ty::Func(ft) = callee.ty else { unreachable!() }; let hs = self.check_args(name, &ft.params, args, span)?; Ok(mk(HExprKind::CallValue { callee: Box::new(callee), args: hs }, ft.ret)) } /// The name of a top-level function used as a value: `apply(double, 3)`. fn func_value(&mut self, key: &str, name: &str, span: Span) -> PResult { let sig = self.funcs[key].clone(); if matches!(sig.ret, Ty::Tuple(_)) { return Err(Diag::new( format!("`{name}` returns several values, so it can't be used as a value yet"), span, )); } let mut params = Vec::new(); let mut args = Vec::new(); for (i, t) in sig.params.iter().enumerate() { let id = self.next_id; self.next_id += 1; let pname = format!("p{i}"); args.push(self.own(mk(HExprKind::Local(id, pname.clone()), *t))); params.push(HLocal { id, name: pname, ty: *t, is_const: false }); } let call = mk(HExprKind::Call { func: key.to_string(), args }, sig.ret); let body = if sig.ret == Ty::Unit { vec![HStmt::Expr(call)] } else { vec![HStmt::Return(Some(call))] }; Ok(mk( HExprKind::Closure { params, ret: sig.ret, body, captures: Vec::new() }, Ty::func(sig.params.clone(), sig.ret), )) } fn declare_generic_type(&mut self, name: &str, is_pub: bool, span: Span, tps: &[TypeParam]) -> PResult<()> { self.check_type_name_free(name, span)?; for (i, tp) in tps.iter().enumerate() { if tps[..i].iter().any(|o| o.name == tp.name) { return Err(Diag::new(format!("two type parameters are named `{}`", tp.name), span)); } } let bounds = self.resolve_bounds(tps, span)?; let key = self.q(name); self.bounds_of.insert(key.clone(), bounds); self.mark_private(&key, is_pub); Ok(()) } /// `Stack[int]`: the real struct or enum for these types, made the first time it is asked for. fn instantiate_type(&mut self, key: &str, shown: &str, tys: Vec, span: Span) -> PResult { let g = self.gtypes[key].clone(); let (tps, module) = match &g { GenericType::Struct(s, m) => (s.type_params.clone(), m.clone()), GenericType::Enum(e, m) => (e.type_params.clone(), m.clone()), }; if tys.len() != tps.len() { return Err(Diag::new( format!( "`{shown}` takes {} type{} (like `{shown}[{}]`), but {} {} given", tps.len(), if tps.len() == 1 { "" } else { "s" }, tps.iter().map(|_| "int").collect::>().join(", "), tys.len(), if tys.len() == 1 { "was" } else { "were" } ), span, )); } for (i, (tp, ty)) in tps.iter().zip(&tys).enumerate() { if let Some(b) = &self.bounds_of[key][i] { if let Some((what, why)) = self.bound_failure(b, *ty) { return Err(Diag::new( format!("`{shown}` needs `{}` to be {what}, but {why}", tp.name), span, )); } } } let inst_key = format!("{key}[{}]", tys.iter().map(|t| t.to_string()).collect::>().join(", ")); if let Some(i) = self.structs.get(&inst_key) { return Ok(Ty::Struct(i.name)); } if let Some(i) = self.enums.get(&inst_key) { return Ok(Ty::Enum(i.name)); } let types: HashMap = tps.iter().map(|t| t.name.clone()).zip(tys).collect(); // check the inside of the type as if we were in the module that wrote it let saved_subst = std::mem::replace(&mut self.tsubst, types.clone()); let saved_mod = std::mem::replace(&mut self.cur_mod, module.clone()); let saved_imports = std::mem::replace(&mut self.imports, self.all_imports.get(&module).cloned().unwrap_or_default()); let r = self.build_instance(&g, &inst_key, &module, types); self.tsubst = saved_subst; self.cur_mod = saved_mod; self.imports = saved_imports; r.map_err(|d| d.in_module(&module)) } fn build_instance(&mut self, g: &GenericType, inst_key: &str, module: &str, types: HashMap) -> PResult { let name: &'static str = Box::leak(inst_key.to_string().into_boxed_str()); match g { GenericType::Struct(s, _) => { self.structs.insert( inst_key.to_string(), StructInfo { name, fields: Vec::new(), methods: HashMap::new(), span: s.span }, ); let mut fields: Vec<(String, Ty)> = Vec::new(); for f in &s.fields { if fields.iter().any(|(n, _)| *n == f.name) { return Err(Diag::new(format!("struct `{}` has two fields named `{}`", s.name, f.name), s.span)); } let fty = self.resolve_type(&f.ty, s.span)?; if matches!(fty, Ty::Opt(_)) { return unsupported(s.span, "an optional (`T?`) as a struct field"); } self.mark_private(&format!("{inst_key}.{}", f.name), f.is_pub); fields.push((f.name.clone(), fty)); } self.structs.get_mut(inst_key).unwrap().fields = fields; self.declare_methods(inst_key, &s.methods)?; for m in &s.methods { self.inst_queue.push(Instance { decl: m.clone(), module: module.to_string(), types: types.clone(), owner: Some(inst_key.to_string()), }); } Ok(Ty::Struct(name)) } GenericType::Enum(e, _) => { self.enums.insert( inst_key.to_string(), EnumInfo { name, variants: Vec::new(), methods: HashMap::new(), span: e.span }, ); let mut variants: Vec = Vec::new(); for v in &e.variants { if variants.iter().any(|x| x.name == v.name) { return Err(Diag::new(format!("enum `{}` has two cases named `{}`", e.name, v.name), e.span)); } let mut fields: Vec<(String, Ty)> = Vec::new(); for f in &v.fields { let fty = self.resolve_type(&f.ty, e.span)?; if matches!(fty, Ty::Opt(_)) { return unsupported(e.span, "an optional (`T?`) as the data of an enum case"); } fields.push((f.name.clone(), fty)); } variants.push(VariantInfo { name: v.name.clone(), fields }); } self.enums.get_mut(inst_key).unwrap().variants = variants; self.declare_methods(inst_key, &e.methods)?; for m in &e.methods { self.inst_queue.push(Instance { decl: m.clone(), module: module.to_string(), types: types.clone(), owner: Some(inst_key.to_string()), }); } Ok(Ty::Enum(name)) } } } /// The type written as `base[args]` in an expression. fn generic_expr_type(&mut self, base: &Expr, args: &[Type], span: Span) -> PResult { let path = match &base.kind { ExprKind::Ident(n) => vec![n.clone()], ExprKind::Field { expr, name } => match &expr.kind { ExprKind::Ident(m) => vec![m.clone(), name.clone()], _ => return unsupported(span, "this kind of type"), }, _ => return unsupported(span, "this kind of type"), }; self.resolve_type(&Type::Named { path, args: args.to_vec() }, span) } /// A call of a generic function: work out the types, make sure that copy exists, call it. fn call_generic(&mut self, key: &str, name: &str, g: &GenericFn, args: &[Expr], span: Span) -> PResult { let f = &g.decl; if args.len() != f.params.len() { return Err(Diag::new( format!( "`{name}` takes {} argument{}, but {} {} given", f.params.len(), if f.params.len() == 1 { "" } else { "s" }, args.len(), if args.len() == 1 { "was" } else { "were" }, ), span, )); } // 1. what is each type parameter? read it off the arguments let mut found: HashMap = HashMap::new(); let mut weak: Vec<(String, bool)> = Vec::new(); // (param, is a float literal) for bare number literals let saved = std::mem::take(&mut self.tsubst); let mut deferred: Vec<(&Param, &Expr)> = Vec::new(); for (p, a) in f.params.iter().zip(args) { if !mentions_type_param(&p.ty, &f.type_params) { continue; } if matches!(a.kind, ExprKind::Lambda { .. }) { deferred.push((p, a)); continue; } let h = match self.expr(a, None) { Ok(h) => h, Err(d) => { self.tsubst = saved; return Err(d); } }; if let Type::Named { path, args: targs } = &p.ty { if path.len() == 1 && targs.is_empty() && f.type_params.iter().any(|t| t.name == path[0]) { if is_int_lit(&h) || is_float_lit(&h) { weak.push((path[0].clone(), is_float_lit(&h))); continue; } } } if let Err(msg) = unify(&p.ty, h.ty, &f.type_params, &mut found) { self.tsubst = saved; return Err(Diag::new(msg, a.span)); } } for (t, is_float) in weak { let e = found.entry(t).or_insert(if is_float { Ty::Float } else { Ty::Int }); if is_float && *e == Ty::Int { *e = Ty::Float; } } // `x => x * 2`: its parameter types come from what is already known; its result may tell us more for (p, a) in deferred { let (Type::Func { params: pp, .. }, ExprKind::Lambda { params: names, body }) = (&p.ty, &a.kind) else { self.tsubst = saved; return Err(Diag::new("this short function (`x => ...`) needs a parameter of a function type", a.span)); }; self.tsubst = found.clone(); let mut ptys = Vec::new(); for t in pp { match self.resolve_type(t, a.span) { Ok(t) => ptys.push(t), Err(_) => { self.tsubst = saved; return Err(Diag::new( format!("can't tell the types of this function's parameters in this call of `{name}`; write them out: `func(x: int): int {{ ... }}`"), a.span, )); } } } self.tsubst = std::mem::take(&mut HashMap::new()); let ps: Vec<(String, Option<&Type>)> = names.iter().map(|n| (n.clone(), None)).collect(); let h = match self.closure_expr(&ps, None, ClosureBody::Expr(body), Some(ptys), None, a.span) { Ok(h) => h, Err(d) => { self.tsubst = saved; return Err(d); } }; if let Err(msg) = unify(&p.ty, h.ty, &f.type_params, &mut found) { self.tsubst = saved; return Err(Diag::new(msg, a.span)); } } self.tsubst = saved; for (i, tp) in f.type_params.iter().enumerate() { let Some(ty) = found.get(&tp.name) else { return Err(Diag::new( format!("can't tell what `{}` is in this call of `{name}`; give an argument that has that type", tp.name), span, )); }; if let Some(b) = &self.bounds_of[key][i] { if let Some((what, why)) = self.bound_failure(b, *ty) { return Err(Diag::new(format!("`{name}` needs `{}` to be {what}, but {why}", tp.name), span)); } } } // 2. the copy for these types let tys: Vec = f.type_params.iter().map(|t| found[&t.name].to_string()).collect(); let inst_name = format!("{}[{}]", f.name, tys.join(", ")); let inst_key = format!("{key}[{}]", tys.join(", ")); if !self.funcs.contains_key(&inst_key) { let mut decl = f.clone(); decl.name = inst_name; decl.type_params = Vec::new(); let saved = std::mem::replace(&mut self.tsubst, found.clone()); let saved_mod = std::mem::replace(&mut self.cur_mod, g.module.clone()); let sig = self.sig_of(&decl); self.cur_mod = saved_mod; self.tsubst = saved; let sig = sig.map_err(|d| d.in_module(&g.module))?; self.funcs.insert(inst_key.clone(), sig); self.inst_queue.push(Instance { decl, module: g.module.clone(), types: found, owner: None }); } let sig = self.funcs[&inst_key].clone(); let hs = self.check_args(name, &sig.params, args, span)?; Ok(mk(HExprKind::Call { func: inst_key, args: hs }, sig.ret)) } /// Call the function stored under `key`; `name` is how it was written. fn call_user_func(&mut self, key: &str, name: &str, name_span: Span, args: &[Expr], span: Span) -> PResult { if let Some(g) = self.generics.get(key).cloned() { return self.call_generic(key, name, &g, args, span); } let Some(sig) = self.funcs.get(key) else { return Err(Diag::new(format!("unknown function `{name}`"), name_span)); }; let (params, ret) = (sig.params.clone(), sig.ret); let hs = self.check_args(name, ¶ms, args, span)?; Ok(mk(HExprKind::Call { func: key.to_string(), args: hs }, ret)) } } // ---------- mutation inference ---------- /// A method "mutates" if its body assigns to something inside `self`, or calls /// a mutating method on something inside `self`. Found by iterating to a fixpoint. fn infer_mutation(funcs: &mut [HFunc]) { let mut mutating: HashSet<(String, String)> = HashSet::new(); loop { let mut changed = false; for f in funcs.iter_mut() { let (Some(owner), Some(me)) = (&f.owner, &f.self_param) else { continue }; if f.mutates { continue; } let self_id = me.id; let mut found = false; walk_stmts( &f.body, &mut |s| { if let HStmt::Assign { target, .. } = s { if place_root(target).map(|(id, _)| id) == Some(self_id) { found = true; } } }, &mut |_| {}, ); walk_stmts( &f.body, &mut |_| {}, &mut |e| { if expr_mutates_root(e, self_id, &|o, m| mutating.contains(&(o.to_string(), m.to_string()))) { found = true; } }, ); if found { f.mutates = true; mutating.insert((owner.clone(), f.name.clone())); changed = true; } } if !changed { break; } } } /// Mutating methods need a variable to change: not a constant, not a temporary value. fn check_mutating_calls(funcs: &[HFunc]) -> PResult<()> { let mutating: HashSet<(&str, &str)> = funcs .iter() .filter(|f| f.mutates) .map(|f| (f.owner.as_deref().unwrap(), f.name.as_str())) .collect(); for f in funcs { let mut consts: HashSet = HashSet::new(); walk_stmts( &f.body, &mut |s| { if let HStmt::Let { local, .. } = s { if local.is_const { consts.insert(local.id); } } }, &mut |_| {}, ); let mut err: Option = None; walk_stmts( &f.body, &mut |_| {}, &mut |e| { let HExprKind::MethodCall { owner, method, recv, span, .. } = &e.kind else { return }; if err.is_some() || !mutating.contains(&(owner.as_str(), method.as_str())) { return; } let msg = match place_root(recv) { _ if through_shared(recv) => None, None => Some(format!( "`{method}` changes the {owner} it is called on, but this value is a temporary or a constant" )), Some((id, name)) if consts.contains(&id) => { Some(format!("`{method}` changes `{name}`, but `{name}` is a constant")) } _ => None, }; if let Some(m) = msg { err = Some(Diag::new(m, *span)); } }, ); if let Some(d) = err { return Err(d); } } Ok(()) } /// The table name of a struct from a C header. It is marked so a file of the user's with the /// same name as the header (a `raylib.rex` wrapping "raylib.h") can have types with the same names. fn c_key(prefix: &str, name: &str) -> String { format!("{}{prefix}.{name}", crate::types::C_MARK) } /// The name in `names` closest to `name`, if one is close enough to be a likely typo. fn similar<'a>(name: &str, names: &[&'a str]) -> Option<&'a str> { fn dist(a: &str, b: &str) -> usize { let (a, b): (Vec, Vec) = (a.chars().collect(), b.chars().collect()); let mut prev: Vec = (0..=b.len()).collect(); let mut prev2: Vec = prev.clone(); for i in 1..=a.len() { let mut cur = vec![i; b.len() + 1]; for j in 1..=b.len() { let cost = if a[i - 1] == b[j - 1] { 0 } else { 1 }; cur[j] = (prev[j] + 1).min(cur[j - 1] + 1).min(prev[j - 1] + cost); // two letters swapped count as one mistake if i > 1 && j > 1 && a[i - 1] == b[j - 2] && a[i - 2] == b[j - 1] { cur[j] = cur[j].min(prev2[j - 2] + 1); } } prev2 = std::mem::replace(&mut prev, cur); } prev[b.len()] } let lower = name.to_lowercase(); if let Some(n) = names.iter().find(|n| n.to_lowercase() == lower) { return Some(n); } let limit = (name.chars().count() / 3).max(1); names.iter().map(|n| (dist(&lower, &n.to_lowercase()), *n)).filter(|(d, _)| *d <= limit).min_by_key(|(d, _)| *d).map(|(_, n)| n) }