Writing An Interpreter In Rust して、Wasm で動かしてみた

impl<'a> Lexer<'a> {
    pub fn next_token(&mut self) -> Token {
        // 現在の読み取り文字を `.ch` が持っている
        let tok = match self.ch {
            b'=' => {
                if self.nextch_is(b'=') {
                    self.read_char();
                    Token::Equal
                } else {
                    Token::Assign
                }
            }
            b'+' => Token::Plus,
            b'-' => Token::Minus,
            b'0'...b'9' => {
                // 数値の読み取りを行う
                return self.consume_number();
            }
            b'"' => {
                // 文字列の読み取りを行う
                return self.consume_string();
            }
            0 => Token::Eof,
            _ => Token::Illegal,
        };

        // 次の読み取り位置へ進める
        self.read_char();

        return tok;
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum Token {
    Illegal,
    Blank,
    Eof,

    // Identifiers + literals
    Ident(String),
    Int(i64),
    String(String),
    Bool(bool),

    // Statements
    Assign,
    If,
    Else,

    // Operators
    Plus,
    Minus,
    Bang,
    Asterisk,
    Slash,
}

package ast

type Node interface {
  TokenLiteral() string
}

type Statement interface {
  Node
  statementNode()
}

type Expression interface {
  Node
  expressionNode()
}

pub enum Expr {
    Ident(Ident),
    Literal(Literal),
    Prefix(Prefix, Box<Expr>),
    Infix(Infix, Box<Expr>, Box<Expr>),
    If {
        cond: Box<Expr>,
        consequence: BlockStmt,
        alternative: Option<BlockStmt>,
    },
}

pub enum Stmt {
    Let(Ident, Expr),
    Return(Expr),
    Expr(Expr),
}

10 + 5 * 7 + 10 / 2 - 30 + (-10 + 10 * 4);

pub enum Object {
    Int(i64),
    String(String),
    Bool(bool),
    Array(Vec<Object>),
    Hash(HashMap<Object, Object>),
    Func(Vec<Ident>, BlockStmt, Rc<RefCell<Env>>),
    Builtin(i32, BuiltinFunc),
    Null,
    ReturnValue(Box<Object>),
    Error(String),
}

impl Evaluator {
    // ...
    // リテラルの評価
    fn eval_literal(&mut self, literal: Literal) -> Object {
        match literal {
            Literal::Int(value) => Object::Int(value),
            Literal::Bool(value) => Object::Bool(value),
            Literal::String(value) => Object::String(value),
            Literal::Array(objects) => self.eval_array_literal(objects),
            Literal::Hash(pairs) => self.eval_hash_literal(pairs),
        }
    }

    // Array の評価
    fn eval_array_literal(&mut self, objects: Vec<Expr>) -> Object {
        Object::Array(
            objects
                .iter()
                .map(|e| self.eval_expr(e.clone()).unwrap_or(Object::Null))
                .collect::<Vec<_>>(),
        )
    }

    // Hash の評価
    fn eval_hash_literal(&mut self, pairs: Vec<(Expr, Expr)>) -> Object {
        let mut hash = HashMap::new();

        for (key_expr, value_expr) in pairs {
            let key = self.eval_expr(key_expr).unwrap_or(Object::Null);
            if Self::is_error(&key) {
                return key;
            }

            let value = self.eval_expr(value_expr).unwrap_or(Object::Null);
            if Self::is_error(&value) {
                return value;
            }

            hash.insert(key, value);
        }

        Object::Hash(hash)
    }
    // ...
}

impl Formatter {
    // ...
    fn format_func_expr(&mut self, params: Vec<Ident>, body: BlockStmt) -> String {
        let mut params_str = String::new();

        for (i, param) in params.into_iter().enumerate() {
            if i > 0 {
                params_str.push_str(", ");
            }

            params_str.push_str(&self.format_ident_expr(param));
        }

        self.indent += 1;

        let body_str = self.format_block_stmt(body);

        self.indent -= 1;

        format!(
            "fn({}) {{\n{}\n{}}}",
            params_str,
            body_str,
            self.indent_str(0)
        )
    }
    // ...
}

if         (          true ) {  puts("Hello")     }      else 
{
  puts("unreachable")    }

if (true) {
  puts('Hello');
} else {
  puts('unreachable');
}

#[no_mangle]
pub fn alloc(size: usize) -> *mut c_void {
    let mut buf = Vec::with_capacity(size);
    let ptr = buf.as_mut_ptr();
    mem::forget(buf);
    ptr as *mut c_void
}

#[no_mangle]
pub fn dealloc(ptr: *mut c_void, size: usize) {
    unsafe {
        let _buf = Vec::from_raw_parts(ptr, 0, size);
    }
}

#[no_mangle]
pub fn eval(input_ptr: *mut c_char) -> *mut c_char {
    let input = unsafe { CStr::from_ptr(input_ptr).to_string_lossy().into_owned() };

    // ... JavaScript から渡ってくる文字列 `input` を Parsing -> Evaluation する

    let output = /* 実行結果の文字列を生成する */;

    CString::new(output).unwrap().into_raw()
}

const input = '...'; // 入力されたソースコード

const {
  instance: { exports },
} = await WebAssembly.instantiateStreaming(fetch('...'));
const encoder = new TextEncoder('UTF-8');
const decoder = new TextDecoder('UTF-8');

// WebAssembly へ文字列を渡すためにメモリに書き込む
const buf = encoder.encode(input);
const ptr = exports.alloc(buf.length + 1);
const heap = new Uint8Array(exports.memory.buffer);

for (let i = 0; i < buf.length; i++) {
  heap[ptr + i] = buf[i];
}

heap[ptr + buf.length] = 0;

// ポインタを渡し、評価後のポインタを受け取る
const resultPtr = exports.eval(ptr);
exports.dealloc(resultPtr, buf.length);

// 評価後の値 (文字列) をメモリから読み込む
const resultBuf = new Uint8Array(exports.memory.buffer, resultPtr);
let i = 0;

while (resultBuf[i] !== 0) {
  i++;
}

const result = decoder.decode(resultBuf.slice(0, i));

// result -> 評価結果

$ cargo install wasm-gc

$ cargo build --release --target wasm32-unknown-unknown
$ wasm-gc target/wasm32-unknown-unknown/release/main.wasm main.wasm