26. 評価と環境 — 変数の表を外側へ辿り、関数呼び出しごとに新しい表を作る

// src/js/runtime.rs の環境・ブロックの実行・関数呼び出し
impl Environment {
    pub fn new(outer: Option<EnvRef>) -> EnvRef {
        Rc::new(RefCell::new(Environment {
            values: HashMap::new(),
            outer,
        }))
    }

    /// 名前を探す。無ければ外側へ(スコープチェーン)
    pub fn get(&self, name: &str) -> Option<RuntimeValue> {
        match self.values.get(name) {
            Some(v) => Some(v.clone()),
            None => self.outer.as_ref().and_then(|o| o.borrow().get(name)),
        }
    }

    /// この環境に新しく定義する(var / function / 仮引数)
    pub fn define(&mut self, name: &str, value: RuntimeValue) {
        self.values.insert(name.to_string(), value);
    }

    /// 既存の変数に代入する。見つかった環境で書き換える。どこにも無ければ false
    pub fn assign(&mut self, name: &str, value: RuntimeValue) -> bool {
        if self.values.contains_key(name) {
            self.values.insert(name.to_string(), value);
            return true;
        }
        match &self.outer {
            Some(o) => o.borrow_mut().assign(name, value),
            None => false,
        }
    }
}

fn exec_block(&mut self, statements: &[Node], env: &EnvRef) -> Result<Completion, JsError> {
    // 関数宣言は巻き上げ(hoisting)される: ブロックの先頭で先に定義する
    for s in statements {
        if let Node::FunctionDeclaration { name, params, body } = s {
            env.borrow_mut().define(
                name,
                RuntimeValue::Function {
                    params: params.clone(),
                    body: body.clone(),
                    closure: env.clone(),
                },
            );
        }
    }
    let mut last = RuntimeValue::Undefined;
    for s in statements {
        match self.exec_statement(s, env)? {
            // 関数宣言と変数宣言は「値を持たない文」。最後の値を上書きしない(ECMAScript の empty completion)
            Completion::Normal(_) if matches!(s, Node::FunctionDeclaration { .. } | Node::VariableDeclaration { .. }) => {}
            Completion::Normal(v) => last = v,
            ret @ Completion::Return(_) => return Ok(ret),
        }
    }
    Ok(Completion::Normal(last))
}

fn call(&mut self, f: RuntimeValue, args: Vec<RuntimeValue>) -> Result<RuntimeValue, JsError> {
    match f {
        RuntimeValue::Function { params, body, closure } => {
            // 呼び出しごとに新しい環境。外側は「定義されたときの環境」(字句スコープ)
            let local = Environment::new(Some(closure));
            for (i, p) in params.iter().enumerate() {
                let v = args.get(i).cloned().unwrap_or(RuntimeValue::Undefined);
                local.borrow_mut().define(p, v);
            }
            match self.exec_block(&body, &local)? {
                Completion::Return(v) => Ok(v),
                Completion::Normal(_) => Ok(RuntimeValue::Undefined), // return が無ければ undefined
            }
        }
        RuntimeValue::Builtin(Builtin::ConsoleLog) => {
            let line = args.iter().map(|a| a.to_string()).collect::<Vec<_>>().join(" ");
            self.console_output.push(line);
            Ok(RuntimeValue::Undefined)
        }
        RuntimeValue::Builtin(Builtin::GetElementById) => {
            let id = args.first().map(|a| a.to_string()).unwrap_or_default();
            let doc = self
                .document
                .clone()
                .ok_or_else(|| JsError::ReferenceError("document is not defined".into()))?;
            Ok(match DomNode::get_element_by_id(&doc, &id) {
                Some(n) => RuntimeValue::Object(JsObject::Element(n)),
                None => RuntimeValue::Null, // 見つからなければ null(仕様どおり)
            })
        }
        other => Err(JsError::TypeError(format!("{other} is not a function"))),
    }
}