Create and publish binaries in CI (#44)

Author: purefunctor

.github/workflows/checks.yml

@@ -10,9 +10,13 @@ env:
 jobs:
   build_and_test:
     name: Compilation
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
         toolchain:
           - stable
 
@@ -27,7 +31,7 @@ jobs:
         uses: Swatinem/[email protected]
         with:
           cache-bin: "false"
-          prefix-key: "v5-maho"
+          prefix-key: "v5-maho-${{ matrix.os }}-${{ matrix.toolchain }}"
 
       - name: Install cargo-binstall
         uses: cargo-bins/[email protected]
@@ -60,7 +64,7 @@ jobs:
         uses: Swatinem/[email protected]
         with:
           cache-bin: "false"
-          prefix-key: "v4-maho"
+          prefix-key: "v5-maho-${{ matrix.toolchain }}"
 
       - name: Install cargo-binstall
         uses: cargo-bins/[email protected]

.github/workflows/release.yml

@@ -0,0 +1,58 @@
+name: Cargo Build & Release
+
+permissions:
+  contents: write
+
+on:
+  push:
+    tags:
+      - v[0-9]+.*
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: taiki-e/create-gh-release-action@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  build-and-release:
+    needs: create-release
+    name: Build & Release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+
+          - os: macos-latest
+            target: x86_64-apple-darwin
+
+          - os: macos-latest
+            target: aarch64-apple-darwin
+
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install cross-compilation tools
+        uses: taiki-e/setup-cross-toolchain-action@v1
+        if: startsWith(matrix.os, 'ubuntu')
+        with:
+          target: ${{ matrix.target }}
+      
+      - name: Build and Release
+        uses: taiki-e/upload-rust-binary-action@v1
+        with:
+          bin: purescript-analyzer
+          package: purescript-analyzer
+          target: ${{ matrix.target }}
+          token: ${{ secrets.GITHUB_TOKEN }}

Cargo.lock

@@ -22,3 +22,7 @@ tokio = { version = "1.46.1", features = ["full"] }
 tower = "0.5.2"
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
+url = "2.5.7"
+
+[target.'cfg(not(unix))'.dependencies]
+tokio-util = { version = "0.7.16", features = ["compat"] }

compiler-bin/Cargo.toml

@@ -109,7 +109,8 @@ fn initialized(state: &mut State, _: InitializedParams) -> ControlFlow<async_lsp
     if let Some(files) = files {
         tracing::info!("Loading {} files.", files.len());
         for file in &files {
-            let uri = format!("file://{}", file.to_str().unwrap());
+            let url = url::Url::from_file_path(file).unwrap();
+            let uri = url.to_string();
             let text = fs::read_to_string(file).unwrap();
             on_change(state, &uri, &text);
         }
@@ -258,10 +259,17 @@ pub async fn analyzer_loop() {
     let subscriber = Registry::default().with(fmt).with(SpanTimingLayer);
     tracing::subscriber::set_global_default(subscriber).unwrap();
 
+    #[cfg(unix)]
     let (stdin, stdout) = (
         async_lsp::stdio::PipeStdin::lock_tokio().unwrap(),
         async_lsp::stdio::PipeStdout::lock_tokio().unwrap(),
     );
 
-    server.run_buffered(stdin, stdout).await.unwrap()
+    #[cfg(not(unix))]
+    let (stdin, stdout) = (
+        tokio_util::compat::TokioAsyncReadCompatExt::compat(tokio::io::stdin()),
+        tokio_util::compat::TokioAsyncWriteCompatExt::compat_write(tokio::io::stdout()),
+    );
+
+    server.run_buffered(stdin, stdout).await.unwrap();
 }

compiler-bin/src/lib.rs

@@ -6,7 +6,7 @@ use url::Url;
 
 use crate::QueryEngine;
 
-pub const HOST: &str = "generated";
+pub const SCHEME: &str = "prim";
 pub const PRIM: &str = include_str!("prim/Prim.purs");
 pub const PRIM_BOOLEAN: &str = include_str!("prim/Prim.Boolean.purs");
 pub const PRIM_COERCE: &str = include_str!("prim/Prim.Coerce.purs");
@@ -29,7 +29,7 @@ pub fn configure(engine: &mut QueryEngine, files: &mut Files) {
         ("Prim.Symbol", PRIM_SYMBOL),
         ("Prim.TypeError", PRIM_TYPE_ERROR),
     ] {
-        let path = format!("file://{HOST}/{name}.purs");
+        let path = format!("{SCHEME}://localhost/{name}.purs");
         let id = files.insert(path, content);
 
         engine.set_content(id, content);
@@ -44,15 +44,12 @@ pub static TEMPORARY_DIRECTORY: LazyLock<TempDir> = LazyLock::new(|| {
         .expect("invariant violated: failed to create TEMPORARY_DIRECTORY")
 });
 
-pub fn handle_generated(mut uri: Url, content: &str) -> Option<Url> {
-    if uri.host_str() != Some(HOST) {
+pub fn handle_generated(uri: Url, content: &str) -> Option<Url> {
+    if uri.scheme() != SCHEME {
         return Some(uri);
     }
 
-    uri.set_host(Some("localhost")).ok()?;
-    let original = uri.to_file_path().ok()?;
-
-    let file = original.components().next_back()?;
+    let file = uri.path_segments()?.next_back()?;
     let path = TEMPORARY_DIRECTORY.path().join(file);
 
     let mut file = File::create(&path).ok()?;

compiler-core/building/src/prim.rs

@@ -7,7 +7,8 @@ use std::fmt::Write;
 use syntax::cst;
 
 fn index_source(source: &str) -> (cst::Module, FullIndexedModule) {
-    let lexed = lexing::lex(source);
+    let source = source.replace("\r\n", "\n").replace("\r", "\n");
+    let lexed = lexing::lex(&source);
     let tokens = lexing::layout(&lexed);
 
     let (parsed, _) = parsing::parse(&lexed, &tokens);

compiler-core/indexing/tests/indexing.rs

@@ -3,7 +3,8 @@ use test_each_file::test_each_file;
 test_each_file! { in "./compiler-core/lexing/tests/lexer" => |content: &str| {
     use std::fmt::Write;
 
-    let lexed = lexing::lex(content);
+    let content = content.replace("\r\n", "\n").replace("\r", "\n");
+    let lexed = lexing::lex(&content);
 
     let mut snapshot = String::new();
     for index in 0..lexed.len() {

compiler-core/lexing/tests/lexer.rs

@@ -1,23 +1,26 @@
 use test_each_file::test_each_file;
 
 test_each_file! { in "./compiler-core/parsing/tests/parser" => |content: &str| {
-    let lexed = lexing::lex(content);
+    let content = content.replace("\r\n", "\n").replace("\r", "\n");
+    let lexed = lexing::lex(&content);
     let tokens = lexing::layout(&lexed);
     let (parsed, errors) = parsing::parse(&lexed, &tokens);
     let node = parsed.syntax_node();
     insta::assert_debug_snapshot!((node, errors));
 }}
 
 test_each_file! { in "./compiler-core/parsing/tests/parser" as lossless => |content: &str| {
-    let lexed = lexing::lex(content);
+    let content = content.replace("\r\n", "\n").replace("\r", "\n");
+    let lexed = lexing::lex(&content);
     let tokens = lexing::layout(&lexed);
     let (parsed, _) = parsing::parse(&lexed, &tokens);
     let node = parsed.syntax_node();
     assert_eq!(node.to_string(), content);
 }}
 
 test_each_file! { in "./compiler-core/parsing/tests/parser" as stability => |content: &str| {
-    let lexed = lexing::lex(content);
+    let content = content.replace("\r\n", "\n").replace("\r", "\n");
+    let lexed = lexing::lex(&content);
     for index in 0..lexed.len() - 1 {
         let partial = lexed.text_in_range(0..index + 1);
         let lexed = lexing::lex(partial);

compiler-core/parsing/tests/parser.rs

@@ -237,21 +237,21 @@ pub fn bracketed(
     let mut binders = FxHashMap::default();
     for (id, kind) in lowered.intermediate.iter_binder() {
         if let BinderKind::OperatorChain { head, tail } = kind {
-            binders.insert(id, bracket(external, &lowered, *head, tail));
+            binders.insert(id, bracket(external, lowered, *head, tail));
         }
     }
 
     let mut expressions = FxHashMap::default();
     for (id, kind) in lowered.intermediate.iter_expression() {
         if let ExpressionKind::OperatorChain { head, tail } = kind {
-            expressions.insert(id, bracket(external, &lowered, *head, tail));
+            expressions.insert(id, bracket(external, lowered, *head, tail));
         }
     }
 
     let mut types = FxHashMap::default();
     for (id, kind) in lowered.intermediate.iter_type() {
         if let TypeKind::OperatorChain { head, tail } = kind {
-            types.insert(id, bracket(external, &lowered, *head, tail));
+            types.insert(id, bracket(external, lowered, *head, tail));
         }
     }