Files
rexlang/src/check.rs
T
Your NameandClaude Opus 5.5 a68c720755 Let a Rex file wrap a C header with the same name
Structs from C headers get their own table names, so raylib.rex can
wrap "raylib.h" and still have its own Color. Ignore Opcode's
.opcode file.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 14:08:46 +01:00

4204 lines
178 KiB
Rust

//! 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<HProgram> {
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<HProgram> {
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<cheader::Lib>) -> PResult<HProgram> {
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<Ty> {
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<String, Ty>,
/// `Some(type)` for a method of a generic type.
owner: Option<String>,
}
/// 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<Ty>,
ret: Ty,
}
/// Which cases of a `match` have been handled so far.
#[derive(Default)]
struct Cover {
variants: HashSet<usize>,
catch_all: bool,
t: bool,
f: bool,
ints: HashSet<i64>,
strs: HashSet<String>,
}
struct VariantInfo {
name: String,
fields: Vec<(String, Ty)>,
}
struct EnumInfo {
name: &'static str,
variants: Vec<VariantInfo>,
methods: HashMap<String, FuncSig>,
span: Span,
}
struct StructInfo {
name: &'static str,
fields: Vec<(String, Ty)>,
methods: HashMap<String, FuncSig>,
span: Span,
}
struct Local {
id: u32,
ty: Ty,
is_const: bool,
}
struct Checker {
funcs: HashMap<String, FuncSig>,
/// Top-level constants: uses are replaced by their (call-free) value.
consts: HashMap<String, HExpr>,
structs: HashMap<String, StructInfo>,
enums: HashMap<String, EnumInfo>,
/// 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<u32>,
scopes: Vec<HashMap<String, Local>>,
next_id: u32,
ret: Ty,
loops: u32,
/// Optional variables known not to be `nil` at this point (after `if x != nil`).
narrowed: HashSet<u32>,
/// `import os`: the built-in modules this file may use.
imports: HashMap<String, Target>,
/// 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<String, HashMap<String, Target>>,
/// Modules that exist as files.
known_modules: HashSet<String>,
/// Items (`mod.name`) and methods (`mod.Type.name`) declared without `pub`.
private: HashSet<String>,
generics: HashMap<String, GenericFn>,
gtypes: HashMap<String, GenericType>,
ifaces: HashMap<String, IfaceInfo>,
iface_decls: HashMap<String, (InterfaceDecl, String)>,
/// The rules of the type parameters of each generic function/type (by table name).
bounds_of: HashMap<String, Vec<Option<Bound>>>,
/// While checking a generic function: what its type names (`T`) stand for.
tsubst: HashMap<String, Ty>,
inst_queue: Vec<Instance>,
/// The C headers the program imports.
clibs: Vec<cheader::Lib>,
/// Structs that come from C headers: table name -> how C spells the type.
c_structs: HashMap<String, String>,
}
// ---------- names used inside a function body (to find what a closure captures) ----------
fn idents_expr(e: &Expr, out: &mut HashSet<String>) {
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<String>) {
b.stmts.iter().for_each(|s| idents_stmt(s, out));
}
fn idents_stmt(s: &Stmt, out: &mut HashSet<String>) {
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>, 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<String, Ty>) -> 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<T>(span: Span, what: &str) -> PResult<T> {
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<HExpr> {
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<HProgram> {
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>, 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<String>, items: Vec<String>| {
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<VariantInfo> = 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>, 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<Bound> {
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<Vec<Option<Bound>>> {
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::<Vec<_>>().join(", "),
if *ret == Ty::Unit { String::new() } else { format!(": {ret}") }
);
let has = format!(
"{name}({}){}",
sig.params.iter().map(|t| t.to_string()).collect::<Vec<_>>().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<HFunc>) -> 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<Vec<&'static str>> {
#[derive(Clone, Copy, PartialEq)]
enum Mark {
Visiting,
Done,
}
fn deps(c: &Checker, name: &str) -> Vec<&'static str> {
let tys: Vec<Ty> = 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<String> {
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<usize> {
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<usize> {
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<String> {
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<Ty> {
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<Ty> {
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<HExpr> {
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<HExpr> {
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<String> = 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<HExpr> {
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<HExpr> {
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<HExpr>,
args: &[Expr],
span: Span,
) -> PResult<HExpr> {
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<HExpr> = 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<FuncSig> {
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<String, FuncSig>> {
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<Ty> {
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<HExpr> {
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<HFunc> {
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<HLocal> {
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<Vec<HStmt>> {
stmts.iter().map(|s| self.stmt(s)).collect()
}
fn block(&mut self, b: &Block) -> PResult<Vec<HStmt>> {
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<HStmt> {
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<HExpr> {
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<HStmt> {
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<HExpr> = 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<HStmt> {
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<u32>, Vec<u32>) {
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<HStmt> {
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<HExpr> {
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<HStmt> {
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<HStmt> = 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<HStmt>) -> 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<HExpr> {
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<HStmt> {
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<HStmt> {
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>, 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>, 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>, 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<Ty>) -> PResult<HExpr> {
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<HExpr> {
// 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<HExpr> {
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<HExpr> {
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<HExpr> {
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<Ty>) -> PResult<HExpr> {
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<u32> = 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<Ty>, span: Span) -> PResult<HExpr> {
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<Ty> {
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<Ty>, span: Span) -> PResult<HExpr> {
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<HExpr> {
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<HExpr> {
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<usize> {
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<Ty>, span: Span, as_stmt: bool) -> PResult<HExpr> {
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<Ty> = 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<String> = 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<HLocal> {
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<Ty>,
expect: Option<Ty>,
as_stmt: bool,
) -> PResult<HArm> {
let span = arm.span;
let case_pat = |this: &mut Checker, en: &'static str, name: &str, subs: &[Pattern], cover: &mut Cover| -> PResult<HPat> {
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<String> = 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<HExpr> {
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<HExpr> {
// `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<Vec<HExpr>> {
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<HExpr> {
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<HExpr> {
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<HExpr>, 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<HExpr> {
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, &params, 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<HExpr> {
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<String> = 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<HExpr> {
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<HExpr> {
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<Ty>) -> (Option<Vec<Ty>>, Option<Ty>) {
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<Vec<Ty>>,
exp_ret: Option<Ty>,
span: Span,
) -> PResult<HExpr> {
// 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<Ty> = 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<String> = 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<Ty>,
body: ClosureBody,
span: Span,
) -> PResult<(Vec<HLocal>, Vec<HLocal>, Vec<HStmt>)> {
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<HExpr> {
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<HExpr> {
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<Ty>, span: Span) -> PResult<Ty> {
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::<Vec<_>>().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::<Vec<_>>().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<String, Ty> = 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<String, Ty>) -> PResult<Ty> {
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<VariantInfo> = 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<Ty> {
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<HExpr> {
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<String, Ty> = 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<String> = 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<HExpr> {
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, &params, 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<u32> = 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<Diag> = 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<char>, Vec<char>) = (a.chars().collect(), b.chars().collect());
let mut prev: Vec<usize> = (0..=b.len()).collect();
let mut prev2: Vec<usize> = 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)
}