Experimenting with a version written in Rust

.github/workflows/rust.yml

@@ -0,0 +1,26 @@
+name: Rust
+
+on:
+  push:
+    branches: [ master, ci-execution ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+defaults:
+  run:
+    working-directory: ./compiler-rs
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: cargo build --verbose
+    - name: Ensure formatted
+      run: cargo fmt --all -- --check
+    - name: Run Cargo tests
+      run: cargo test

compiler-rs/.gitignore

@@ -0,0 +1,11 @@
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk

compiler-rs/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "eel_wasm"
+version = "0.1.0"
+authors = ["Jordan Eldredge <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["console_error_panic_hook"]
+
+[dependencies]
+wasm-bindgen = "0.2.63"
+parity-wasm = "0.42.2"
+structopt = "0.3.21"
+indexmap = "1.6.2"
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.6", optional = true }
+
+# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
+# compared to the default allocator's ~10K. It is slower than the default
+# allocator, however.
+#
+# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
+wee_alloc = { version = "0.4.5", optional = true }
+
+
+[dev-dependencies]
+# https://github.com/paritytech/wasmi/issues/252
+# wasmi = { path = "../../wasmi"}
+wasmi = { git = "https://github.com/paritytech/wasmi", branch = "master" }
+wabt = "0.9.0"
+wasm-bindgen-test = "0.3.13"
+wasmprinter = "0.2.0"
+
+[profile.release]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"
+

compiler-rs/README.md

@@ -0,0 +1,19 @@
+## Build
+
+To build the Wasm module:
+```bash
+wasm-pack build
+```
+
+You can find the output in `pkg/`.
+
+To check the resulting wasm size
+```bash
+gzip -9 < pkg/optimized.wasm | wc -c
+```
+
+## TODO
+
+- [ ] Add AST node for arguments list so that we can show it as the error node when arg count is wrong.
+- [ ] Run `wasm-pack build` in CI.
+- [ ] Should the magicness of reg10 values be case insensitive? (It is in the JS version)

compiler-rs/src/ast.rs

@@ -0,0 +1,102 @@
+use crate::span::Span;
+
+#[derive(Debug, PartialEq)]
+pub struct EelFunction {
+    pub expressions: ExpressionBlock,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct ExpressionBlock {
+    pub expressions: Vec<Expression>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Expression {
+    BinaryExpression(BinaryExpression),
+    UnaryExpression(UnaryExpression),
+    NumberLiteral(NumberLiteral),
+    Assignment(Assignment),
+    FunctionCall(FunctionCall),
+    ExpressionBlock(ExpressionBlock),
+    Identifier(Identifier),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct UnaryExpression {
+    pub right: Box<Expression>,
+    pub op: UnaryOperator,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct BinaryExpression {
+    pub left: Box<Expression>,
+    pub right: Box<Expression>,
+    pub op: BinaryOperator,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct NumberLiteral {
+    pub value: f64,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum BinaryOperator {
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Mod,
+    Eq,
+    BitwiseAnd,
+    BitwiseOr,
+    LogicalAnd,
+    LogicalOr,
+    Pow,
+    LessThan,
+    GreaterThan,
+    LessThanEqual,
+    GreaterThanEqual,
+    NotEqual,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum UnaryOperator {
+    Plus,
+    Minus,
+    Not,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Identifier {
+    pub name: String,
+    pub span: Span,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum AssignmentOperator {
+    Equal,
+    PlusEqual,
+    MinusEqual,
+    TimesEqual,
+    DivEqual,
+    ModEqual,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Assignment {
+    pub left: AssignmentTarget,
+    pub operator: AssignmentOperator,
+    pub right: Box<Expression>,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum AssignmentTarget {
+    Identifier(Identifier),
+    FunctionCall(FunctionCall),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct FunctionCall {
+    pub name: Identifier,
+    pub arguments: Vec<Expression>,
+}

compiler-rs/src/bin/compiler.rs

@@ -0,0 +1,52 @@
+use eel_wasm::compile;
+use std::io::{self, Write};
+use std::process;
+use std::{collections::HashMap, fs};
+
+use std::path::PathBuf;
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+#[structopt(name = "eel-wasm", about = "Compile Eel code to WebAssembly.")]
+struct Opt {
+    /// Input file
+    #[structopt(parse(from_os_str))]
+    input: PathBuf,
+
+    /// Output file, stdout if not present
+    #[structopt(parse(from_os_str))]
+    output: Option<PathBuf>,
+}
+
+fn main() {
+    let opt = Opt::from_args();
+    let filename = opt.input;
+    let source = fs::read_to_string(filename).unwrap_or_else(|err| {
+        eprintln!("Error reading file: {}", err);
+        process::exit(1);
+    });
+
+    let result = compile(
+        vec![("test".to_string(), &source, "pool".to_string())],
+        HashMap::default(),
+    )
+    .unwrap_or_else(|err| {
+        eprintln!("{:?}", err);
+        process::exit(1);
+    });
+
+    match opt.output {
+        Some(output) => {
+            fs::write(output, result).unwrap_or_else(|err| {
+                eprintln!("Error writing output: {}", err);
+                process::exit(1);
+            });
+        }
+        None => {
+            io::stdout().write_all(&result).unwrap_or_else(|err| {
+                eprintln!("Error writing to stdout: {}", err);
+                process::exit(1);
+            });
+        }
+    }
+}