静的型検査器を実装する——スコープ付き環境と「Unknown型」で不正な演算を検出する

#[derive(Debug, Clone, PartialEq)]
pub enum Type {
    Int,
    Float,
    Bool,
    String,
    Array(Box<Type>),
    Unknown,
}

struct Env {
    scopes: Vec<HashMap<String, Type>>,
}

impl Env {
    fn new() -> Self {
        Env { scopes: vec![HashMap::new()] }
    }

    fn push_scope(&mut self) {
        self.scopes.push(HashMap::new());
    }

    fn pop_scope(&mut self) {
        self.scopes.pop();
    }

    fn define(&mut self, name: String, ty: Type) {
        self.scopes.last_mut().expect("at least one scope is always present").insert(name, ty);
    }

    fn lookup(&self, name: &str) -> Option<&Type> {
        for scope in self.scopes.iter().rev() {
            if let Some(ty) = scope.get(name) {
                return Some(ty);
            }
        }
        None
    }
}

fn in_new_scope<F>(&mut self, f: F) -> Result<(), TypeError>
where
    F: FnOnce(&mut Self) -> Result<(), TypeError>,
{
    self.env.push_scope();
    let result = f(self);
    self.env.pop_scope();
    result
}

fn check_block(&mut self, block: &Block) -> Result<(), TypeError> {
    self.in_new_scope(|checker| checker.check_stmts(block))
}

StmtKind::If { condition, then_branch, else_branch } => {
    let condition_ty = self.check_expr(condition, line, column)?;
    self.expect_bool(&condition_ty, line, column)?;
    self.check_block(then_branch)?;
    if let Some(else_stmt) = else_branch {
        self.check_stmt(else_stmt)?;
    }
    Ok(())
}

StmtKind::For { var, iterable, body } => {
    let iterable_ty = self.check_expr(iterable, line, column)?;
    let element_ty = match iterable_ty {
        Type::Array(element) => *element,
        Type::Unknown => Type::Unknown,
        other => {
            return Err(self.error(line, column, format!("for-loop expects an array, found {other:?}")));
        }
    };
    self.in_new_scope(|checker| {
        checker.env.define(var.clone(), element_ty);
        checker.check_stmts(body)
    })
}

fn check_binary_op(&self, op: &BinaryOp, left: Type, right: Type, line: usize, column: usize) -> Result<Type, TypeError> {
    if left == Type::Unknown || right == Type::Unknown {
        return Ok(self.binary_op_result_for_unknown(op));
    }

    match op {
        BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => match (&left, &right) {
            (Type::Int, Type::Int) => Ok(Type::Int),
            (Type::Float, Type::Float) => Ok(Type::Float),
            _ => Err(self.error(line, column, format!("operator '{op:?}' cannot be applied to {left:?} and {right:?}"))),
        },
        // ...(比較演算子・論理演算子も同様に列挙)
    }
}

fn check_array(&mut self, elements: &[Expr], line: usize, column: usize) -> Result<Type, TypeError> {
    let mut elements = elements.iter();
    let Some(first) = elements.next() else {
        return Err(self.error(line, column, "cannot infer the type of an empty array".to_string()));
    };

    let element_ty = self.check_expr(first, line, column)?;
    for element in elements {
        let ty = self.check_expr(element, line, column)?;
        if ty != element_ty && ty != Type::Unknown && element_ty != Type::Unknown {
            return Err(self.error(
                line, column,
                format!("array elements must have the same type: expected {element_ty:?}, found {ty:?}"),
            ));
        }
    }
    Ok(Type::Array(Box::new(element_ty)))
}

// Functions don't exist as a declared concept yet (no `fn` syntax),
// so a call's argument types can't be checked against anything.
// Its result is treated as Unknown until Phase 7 introduces `fn`.
Expr::Call { .. } => Ok(Type::Unknown),

fn check_binary_op(&self, op: &BinaryOp, left: Type, right: Type, line: usize, column: usize) -> Result<Type, TypeError> {
    if left == Type::Unknown || right == Type::Unknown {
        return Ok(self.binary_op_result_for_unknown(op));
    }
    // ...
}

pub enum StmtKind {
    Let { name: String, value: Expr },
    Expr(Expr),
    // ...(既存のバリアントはそのまま)
}

#[derive(Debug, Clone)]
pub struct Stmt {
    pub kind: StmtKind,
    pub line: usize,
    pub column: usize,
}

impl PartialEq for Stmt {
    fn eq(&self, other: &Self) -> bool {
        self.kind == other.kind
    }
}

$ cargo run -- examples/hello.na
Stmt { kind: Let { name: "x", ... }, line: 1, column: 1 }
Stmt { kind: If { ... }, line: 2, column: 1 }

$ echo 'let x = 1 + true;' > bad.na
$ cargo run -- bad.na
na: type error (1:1): operator 'Add' cannot be applied to Int and Bool