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>
4204 lines
178 KiB
Rust
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, ¶ms, args, span)?;
|
|
return Ok(mk(HExprKind::IfaceCall { recv: Box::new(recv), method: name.to_string(), args: hs }, ret));
|
|
}
|
|
if recv.ty == Ty::Char {
|
|
return match stdlib::char_method(name) {
|
|
Some(sig) => self.builtin_call(name, sig, Some(recv), args, span),
|
|
None => Err(Diag::new(
|
|
format!("characters have no method `{name}` (they have: {})", stdlib::CHAR_METHODS),
|
|
name_span,
|
|
)),
|
|
};
|
|
}
|
|
if matches!(recv.ty, Ty::List(_) | Ty::Str | Ty::Map(..)) {
|
|
return self.builtin_method(recv, name, args, span, name_span);
|
|
}
|
|
let (Ty::Struct(owner) | Ty::Enum(owner)) = recv.ty else {
|
|
return Err(Diag::new(format!("a `{}` has no methods (looking for `.{name}()`)", recv.ty), name_span));
|
|
};
|
|
let Some(sig) = self.methods_of(owner).and_then(|m| m.get(name)).cloned() else {
|
|
if let Ty::Enum(_) = recv.ty {
|
|
return Err(Diag::new(format!("enum `{owner}` has no method `{name}`"), name_span));
|
|
}
|
|
// reuse the field error for a good "did you mean" list
|
|
return match self.field_of(recv, name, name_span) {
|
|
Ok(h) if matches!(h.ty, Ty::Func(_)) => self.call_value(h, name, args, span),
|
|
Ok(_) => Err(Diag::new(format!("`{name}` is a field, not a method"), name_span)),
|
|
Err(d) => Err(d),
|
|
};
|
|
};
|
|
let owner_mod = module_of(owner);
|
|
// generic code may call the methods an `interface` asks for on the types it was given
|
|
let via_rule = self.tsubst.values().any(|t| matches!(t, Ty::Struct(n) | Ty::Enum(n) if *n == owner))
|
|
&& self.ifaces.values().any(|i| i.methods.iter().any(|(n, _, _)| n == name));
|
|
if owner_mod != self.cur_mod && !via_rule && self.private.contains(&format!("{owner}.{name}")) {
|
|
return Err(Diag::new(
|
|
format!("method `{name}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.rex to share it"),
|
|
name_span,
|
|
));
|
|
}
|
|
let hs = self.check_args(name, &sig.params, args, span)?;
|
|
Ok(mk(
|
|
HExprKind::MethodCall {
|
|
owner: owner.to_string(),
|
|
method: name.to_string(),
|
|
recv: Box::new(recv),
|
|
args: hs,
|
|
span,
|
|
},
|
|
sig.ret,
|
|
))
|
|
}
|
|
|
|
/// If `e` is just the name of an enum (not shadowed by a variable), that enum.
|
|
fn enum_named(&self, e: &Expr) -> Option<&'static str> {
|
|
if let ExprKind::Ident(n) = &e.kind {
|
|
if self.lookup(n).is_some() || self.implicit_field(n).is_some() || self.consts.contains_key(&self.q(n)) {
|
|
return None;
|
|
}
|
|
}
|
|
let key = self.global_key(e)?;
|
|
self.enums.get(&key).map(|i| i.name)
|
|
}
|
|
|
|
/// `Shape.Circle(2.0)` or `Shape.Point`.
|
|
fn enum_value(&mut self, enum_name: &'static str, case: &str, args: Option<&[Expr]>, span: Span) -> PResult<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, ¶ms, args, span)?;
|
|
Ok(mk(HExprKind::Call { func: key.to_string(), args: hs }, ret))
|
|
}
|
|
}
|
|
|
|
// ---------- mutation inference ----------
|
|
|
|
/// A method "mutates" if its body assigns to something inside `self`, or calls
|
|
/// a mutating method on something inside `self`. Found by iterating to a fixpoint.
|
|
fn infer_mutation(funcs: &mut [HFunc]) {
|
|
let mut mutating: HashSet<(String, String)> = HashSet::new();
|
|
loop {
|
|
let mut changed = false;
|
|
for f in funcs.iter_mut() {
|
|
let (Some(owner), Some(me)) = (&f.owner, &f.self_param) else { continue };
|
|
if f.mutates {
|
|
continue;
|
|
}
|
|
let self_id = me.id;
|
|
let mut found = false;
|
|
walk_stmts(
|
|
&f.body,
|
|
&mut |s| {
|
|
if let HStmt::Assign { target, .. } = s {
|
|
if place_root(target).map(|(id, _)| id) == Some(self_id) {
|
|
found = true;
|
|
}
|
|
}
|
|
},
|
|
&mut |_| {},
|
|
);
|
|
walk_stmts(
|
|
&f.body,
|
|
&mut |_| {},
|
|
&mut |e| {
|
|
if expr_mutates_root(e, self_id, &|o, m| mutating.contains(&(o.to_string(), m.to_string()))) {
|
|
found = true;
|
|
}
|
|
},
|
|
);
|
|
if found {
|
|
f.mutates = true;
|
|
mutating.insert((owner.clone(), f.name.clone()));
|
|
changed = true;
|
|
}
|
|
}
|
|
if !changed {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Mutating methods need a variable to change: not a constant, not a temporary value.
|
|
fn check_mutating_calls(funcs: &[HFunc]) -> PResult<()> {
|
|
let mutating: HashSet<(&str, &str)> = funcs
|
|
.iter()
|
|
.filter(|f| f.mutates)
|
|
.map(|f| (f.owner.as_deref().unwrap(), f.name.as_str()))
|
|
.collect();
|
|
for f in funcs {
|
|
let mut consts: HashSet<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)
|
|
}
|