initial commit

Author: tamasfe

.gitignore

@@ -0,0 +1,5 @@
+/target
+Cargo.lock
+*.local*
+yarn-error.log
+.vscode

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "rhai"]
+	path = rhai
+	url = [email protected]:tamasfe/rhai.git

Cargo.toml

@@ -0,0 +1,12 @@
+[workspace]
+members = ["crates/*"]
+
+[profile.release]
+lto = true
+codegen-units = 1
+opt-level = 3
+
+[profile.bench]
+lto = true
+codegen-units = 1
+opt-level = 3

README.md

@@ -0,0 +1,68 @@
+# Rhai LSP
+
+Rhai LSP Server and IDE support.
+
+## Requirements
+
+- Stable Rust toolchain (e.g. via [rustup](https://rustup.rs/))
+- [vsce](https://www.npmjs.com/package/vsce) for VS Code extensions
+
+**Optionally:**
+
+- [Task](https://taskfile.dev) for running predefined tasks.
+
+## Project Structure
+
+### [`crates/rowan`](crates/rowan)
+
+Rhai syntax and a recursive descent parser based on [Rowan](https://github.com/rust-analyzer/rowan).
+
+The high-level syntax ([ungrammar](https://rust-analyzer.github.io/blog/2020/10/24/introducing-ungrammar.html)) definition is found in [crates/rowan/src/ast/rhai.ungram](crates/rowan/src/ast/rhai.ungram). The parser mimics the structure and produces a fitting CST.
+
+### [`crates/lsp`](crates/lsp)
+
+The LSP server implementation backed up by [lsp-async-stub](https://github.com/tamasfe/taplo/tree/master/lsp-async-stub).
+
+It can be compiled to WASM only right now, but native binaries with stdio or TCP communication can be easily implemented.
+
+### [`crates/sourcegen`](crates/sourcegen)
+
+Crate for source generation.
+
+Currently only some node types and helper macros are generated from the ungrammar definition. Later the AST will also be generated from it.
+
+### [`js/lsp`](js/lsp)
+
+A JavaScript wrapper over the LSP so that it can be used in NodeJS (and browser) environments, it greatly improves portability (e.g. the same JS *"binary"* can be used in a VS Code extension or with coc.nvim).
+
+### [`ide/vscode`](ide/vscode)
+
+VS Code extension that uses the LSP.
+
+If all the tools are available from the [Requirements](#requirements), it can be built and installed with `task vscode:dev`.
+
+### [`ide/web`](ide/web)
+
+A web demo page, nice to have in the future, currently has an editor and does nothing.
+
+## Tests
+
+Run all tests with `cargo test`.
+
+[Parser tests](crates/rowan/tests) are based on scripts found in [`testdata`](testdata), and also in the upstream [rhai submodule](rhai/scripts).
+
+## Benchmarks
+
+Run benchmarks with `cargo bench`.
+
+Current parser results:
+
+![bench](images/bench.png)
+
+We can only go up from here.
+
+## Profiling
+
+To profile the parser, run `cargo bench --bench parse -- --profile-time 5`.
+
+The flame graph outputs will can found in `target/criterion/profile` afterwards.

Taskfile.yml

@@ -0,0 +1,34 @@
+version: 3
+
+tasks:
+  lsp:js:build:
+    desc: Build the LSP
+    dir: js/lsp
+    cmds:
+      - yarn build
+
+  vscode:dev:
+    desc: Build everything and install the extension
+    cmds:
+      - task: lsp:js:build
+      - task: vscode:clean
+      - task: vscode:package
+      - task: vscode:install
+
+  vscode:clean:
+    desc: Clean VS Code extension build artifacts and run Yarn
+    dir: ide/vscode
+    cmds:
+      - rm -rf node_modules
+      - rm -rf dist
+      - yarn
+  vscode:package:
+    desc: Package the VS Code extension
+    dir: ide/vscode
+    cmds:
+      - vsce package
+  vscode:install:
+    desc: Install the VS Code extension
+    dir: ide/vscode
+    cmds:
+      - code --install-extension rhai-*.vsix --force

crates/lsp/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "rhai-lsp"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+tracing = "0.1.28"
+lsp-async-stub = "0.2.0"
+rhai-rowan = { path = "../rowan" }
+lsp-types = "0.90.0"
+once_cell = "1.8.0"
+futures = "0.3.17"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tokio = { version = "1", features = ["rt-multi-thread"] }
+clap = { version = "3.0.0-beta.2", optional = true }
+ctrlc = { version = "3", optional = true }
+notify = { version = "4", optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = { version = "0.2", features = [
+    "serde-serialize",
+] }
+wasm-bindgen-futures = { version = "0.4" }
+console_error_panic_hook = { version = "0.1" }
+js-sys = { version = "0.3" }
+tracing-wasm = { version = "0.2.0" }
+serde_json = "1.0.68"
+
+[features]
+default = []
+cli = ["clap", "ctrlc", "notify"]
+wasm-export = []

crates/lsp/src/diagnostics.rs

@@ -0,0 +1,71 @@
+use lsp_async_stub::{Context, RequestWriter};
+use lsp_types::{notification, Diagnostic, DiagnosticSeverity, PublishDiagnosticsParams, Url};
+use rhai_rowan::parser::Parse;
+use tracing::error;
+
+use crate::{
+    external::spawn,
+    mapper::{LspExt, Mapper},
+    World,
+};
+
+pub async fn publish_diagnostics(mut context: Context<World>, uri: Url) {
+    let w = context.world().lock().unwrap();
+
+    let doc = match w.documents.get(&uri) {
+        Some(d) => d.clone(),
+        None => {
+            // Doesn't exist anymore
+            return;
+        }
+    };
+
+    let mut diagnostics = Vec::new();
+
+    syntax_diagnostics(&mut diagnostics, &doc.parse, &doc.mapper);
+    drop(w);
+
+    // FIXME: why is another `spawn` required here?
+    //  the compiler complains about the future not being Sync otherwise,
+    //  but I don't see why.
+    spawn(async move {
+        context
+            .write_notification::<notification::PublishDiagnostics, _>(Some(
+                PublishDiagnosticsParams {
+                    uri: uri.clone(),
+                    diagnostics,
+                    version: None,
+                },
+            ))
+            .await
+            .unwrap_or_else(|error| error!(%error));
+    });
+}
+
+pub async fn clear_diagnostics(mut context: Context<World>, uri: Url) {
+    context
+        .write_notification::<notification::PublishDiagnostics, _>(Some(PublishDiagnosticsParams {
+            uri,
+            diagnostics: Vec::new(),
+            version: None,
+        }))
+        .await
+        .unwrap_or_else(|error| error!(%error));
+}
+
+fn syntax_diagnostics(diagnostics: &mut Vec<Diagnostic>, parse: &Parse, mapper: &Mapper) {
+    diagnostics.extend(parse.errors.iter().map(|e| {
+        let range = mapper.range(e.range).unwrap_or_default().into_lsp();
+        Diagnostic {
+            range,
+            severity: Some(DiagnosticSeverity::Error),
+            code: None,
+            code_description: None,
+            source: Some("Rhai".into()),
+            message: format!("{}", e),
+            related_information: None,
+            tags: None,
+            data: None,
+        }
+    }));
+}

crates/lsp/src/external/native/mod.rs

@@ -0,0 +1,7 @@
+#![allow(dead_code)]
+
+use futures::Future;
+
+pub(crate) fn spawn<F: Future<Output = ()> + Send + 'static>(fut: F) {
+    tokio::spawn(fut);
+}

crates/lsp/src/external/wasm32/mod.rs

@@ -0,0 +1,78 @@
+#![allow(dead_code)]
+
+use crate::{create_server, create_world, World};
+use futures::{Future, Sink};
+use lsp_async_stub::{rpc::Message, Server};
+use once_cell::sync::Lazy;
+use std::{io, task::Poll};
+use tracing::trace;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::spawn_local;
+
+static SERVER: Lazy<Server<World>> = Lazy::new(|| create_server());
+static WORLD: Lazy<World> = Lazy::new(|| create_world());
+
+#[wasm_bindgen]
+extern {
+    #[wasm_bindgen(js_namespace = __rhai__, js_name = onMessage)]
+    fn js_send_message(message: JsValue);
+}
+
+#[cfg(feature = "wasm-export")]
+#[wasm_bindgen]
+pub async fn initialize() {
+    console_error_panic_hook::set_once();
+    tracing_wasm::set_as_global_default();
+}
+
+#[cfg(feature = "wasm-export")]
+#[wasm_bindgen]
+pub fn message(message: JsValue) {
+    trace!(?message, "received message");
+    let msg = message.into_serde().unwrap();
+    spawn(async move {
+        SERVER
+            .handle_message(WORLD.clone(), msg, MessageWriter)
+            .await
+            .unwrap();
+    });
+}
+
+pub(crate) fn spawn<F: Future<Output = ()> + 'static>(fut: F) {
+    spawn_local(fut)
+}
+
+#[derive(Clone)]
+struct MessageWriter;
+
+impl Sink<Message> for MessageWriter {
+    type Error = io::Error;
+
+    fn poll_ready(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn start_send(self: std::pin::Pin<&mut Self>, item: Message) -> Result<(), Self::Error> {
+        let js_msg = JsValue::from_serde(&item).unwrap();
+        trace!(message = ?js_msg, "sending message");
+        js_send_message(js_msg);
+        Ok(())
+    }
+
+    fn poll_flush(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_close(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}