Merge pull request #105 from The3gs/playground-feature

Author: faiface

Cargo.toml

@@ -4,14 +4,18 @@ version = "0.1.0"
 edition = "2021"
 repository = "https://github.com/faiface/par-lang"
 
+[features]
+default = ["playground"]
+playground = ["eframe", "egui_code_editor", "rfd"]
+
 [dependencies]
 futures = { version = "0.3.31", features = ["executor", "thread-pool"] }
-eframe = { version = "0.32.0", features = ["default", "__screenshot"] }
-egui_code_editor = "0.2.17"
+eframe = { version = "0.32.0", features = ["default", "__screenshot"], optional = true }
+egui_code_editor = { version = "0.2.17", optional = true }
 indexmap = "2.7.0"
 tokio = { version = "1.43.0", features = ["rt-multi-thread", "macros", "fs", "io-util", "io-std", "signal"] }
 stacker = "0.1.19"
-rfd = "0.15.2"
+rfd = { version = "0.15.2", optional = true }
 winnow = { version = "0.7.4", features = [
     #"unstable-doc", # build docs locally
     #"debug" # debug output/state of parser

src/icombs/net.rs

@@ -182,6 +182,7 @@ impl core::ops::Add<Rewrites> for Rewrites {
     }
 }
 
+#[allow(unused)]
 impl Rewrites {
     pub fn total(&self) -> u128 {
         self.commute + self.annihilate + self.signal + self.expand + self.era + self.resp

src/icombs/readback.rs

@@ -50,6 +50,7 @@ pub(crate) mod private {
             self.net.lock()
         }
 
+        #[cfg(feature = "playground")]
         pub(crate) fn net(&self) -> Arc<Mutex<Net>> {
             Arc::clone(&self.net)
         }
@@ -110,6 +111,7 @@ impl TypedHandle {
     }
 }
 
+#[allow(dead_code)]
 pub enum TypedReadback {
     Nat(BigInt),
     Int(BigInt),
@@ -407,6 +409,7 @@ impl TypedHandle {
         }
     }
 
+    #[cfg(feature = "playground")]
     pub fn net(&self) -> Arc<Mutex<Net>> {
         self.net.net()
     }

src/language_server/feedback.rs

@@ -55,7 +55,7 @@ impl FeedbackBookKeeper {
 }
 
 pub fn diagnostic_for_error(err: &CompileError, code: Arc<str>) -> lsp::Diagnostic {
-    use crate::playground::Error;
+    use crate::par::build_result::Error;
 
     let (span, message, help, _related_spans) = match err {
         CompileError::Compile(Error::Syntax(err)) => (

src/language_server/instance.rs

@@ -1,13 +1,13 @@
 use super::io::IO;
 use crate::location::FileName;
-use crate::playground::BuildResult;
+use crate::par::build_result::BuildResult;
 use lsp_types::{self as lsp, Uri};
 use std::collections::HashMap;
 use std::fmt::Write;
 
 #[derive(Debug, Clone)]
 pub enum CompileError {
-    Compile(crate::playground::Error),
+    Compile(crate::par::build_result::Error),
     //Types(TypeError<Internal<Name>>),
 }
 

src/main.rs

@@ -1,12 +1,16 @@
 use crate::icombs::readback::{TypedHandle, TypedReadback};
+use crate::par::build_result::BuildResult;
 use crate::par::types::Type;
-use crate::playground::{BuildResult, Playground};
+#[cfg(feature = "playground")]
+use crate::playground::Playground;
 use crate::spawn::TokioSpawn;
 use clap::{arg, command, value_parser, Command};
 use colored::Colorize;
+#[cfg(feature = "playground")]
 use eframe::egui;
 use futures::task::SpawnExt;
 use std::fs::File;
+#[cfg(feature = "playground")]
 use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -15,7 +19,9 @@ mod icombs;
 mod language_server;
 mod location;
 mod par;
+#[cfg(feature = "playground")]
 mod playground;
+#[cfg(feature = "playground")]
 mod readback;
 mod spawn;
 mod test_assertion;
@@ -26,7 +32,11 @@ fn main() {
         .subcommand_required(true)
         .subcommand(
             Command::new("playground")
-                .about("Start the Par playground")
+                .about(if cfg!(feature = "playground") {
+                    "Start the Par playground"
+                } else {
+                    "Disabled in build"
+                })
                 .arg(
                     arg!([file] "Open a Par file in the playground")
                         .value_parser(value_parser!(PathBuf)),
@@ -90,9 +100,16 @@ fn main() {
     }
 }
 
+#[cfg(feature = "playground")]
 /// String to save on crash. Used by the playground to avoid losing everything on panic.
 static CRASH_STR: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
 
+#[cfg(not(feature = "playground"))]
+fn run_playground(_: Option<PathBuf>) {
+    eprintln!("Playground was disabled when building Par")
+}
+
+#[cfg(feature = "playground")]
 fn run_playground(file: Option<PathBuf>) {
     let options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default().with_inner_size([1000.0, 700.0]),

src/par.rs

@@ -1,3 +1,4 @@
+pub mod build_result;
 pub mod builtin;
 pub mod language;
 pub mod lexer;

src/par/build_result.rs

@@ -0,0 +1,189 @@
+use crate::{
+    icombs::{self, IcCompiled},
+    par::{language::CompileError, parse::SyntaxError, process::Expression, types::TypeError},
+};
+use crate::{
+    location::FileName,
+    par::{
+        builtin::import_builtins,
+        program::{CheckedModule, Definition, Module, ParseAndCompileError, TypeOnHover},
+    },
+};
+
+use std::fmt::Write;
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub(crate) enum Error {
+    Syntax(SyntaxError),
+    Compile(CompileError),
+    InetCompile(crate::icombs::compiler::Error),
+    Type(TypeError),
+}
+
+impl Error {
+    pub fn display(&self, code: Arc<str>) -> String {
+        match self {
+            Self::Syntax(error) => {
+                // Show syntax error with miette's formatting
+                format!(
+                    "{:?}",
+                    miette::Report::from(error.to_owned()).with_source_code(code)
+                )
+            }
+
+            Self::Compile(error) => format!("{:?}", error.to_report(code)),
+
+            Self::Type(error) => format!("{:?}", error.to_report(code)),
+
+            Self::InetCompile(err) => {
+                format!("inet compilation error: {:?}", err)
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum BuildResult {
+    None,
+    SyntaxError {
+        error: SyntaxError,
+    },
+    CompileError {
+        error: CompileError,
+    },
+    TypeError {
+        #[allow(dead_code)]
+        pretty: String,
+        error: TypeError,
+    },
+    InetError {
+        #[allow(dead_code)]
+        pretty: String,
+        checked: Arc<CheckedModule>,
+        type_on_hover: TypeOnHover,
+        error: icombs::compiler::Error,
+    },
+    Ok {
+        #[allow(dead_code)]
+        pretty: String,
+        checked: Arc<CheckedModule>,
+        type_on_hover: TypeOnHover,
+        ic_compiled: IcCompiled,
+    },
+}
+
+impl BuildResult {
+    pub fn error(&self) -> Option<Error> {
+        match self {
+            Self::None => None,
+            Self::SyntaxError { error } => Some(Error::Syntax(error.clone())),
+            Self::CompileError { error } => Some(Error::Compile(error.clone())),
+            Self::TypeError { error, .. } => Some(Error::Type(error.clone())),
+            Self::InetError { error, .. } => Some(Error::InetCompile(error.clone())),
+            Self::Ok { .. } => None,
+        }
+    }
+
+    #[cfg(feature = "playground")]
+    pub fn pretty(&self) -> Option<&str> {
+        match self {
+            Self::None => None,
+            Self::SyntaxError { .. } => None,
+            Self::CompileError { .. } => None,
+            Self::TypeError { pretty, .. } => Some(&pretty),
+            Self::InetError { pretty, .. } => Some(&pretty),
+            Self::Ok { pretty, .. } => Some(&pretty),
+        }
+    }
+
+    pub fn checked(&self) -> Option<Arc<CheckedModule>> {
+        match self {
+            Self::None => None,
+            Self::SyntaxError { .. } => None,
+            Self::CompileError { .. } => None,
+            Self::TypeError { .. } => None,
+            Self::InetError { checked, .. } => Some(Arc::clone(checked)),
+            Self::Ok { checked, .. } => Some(Arc::clone(checked)),
+        }
+    }
+
+    pub fn type_on_hover(&self) -> Option<&TypeOnHover> {
+        match self {
+            Self::None => None,
+            Self::SyntaxError { .. } => None,
+            Self::CompileError { .. } => None,
+            Self::TypeError { .. } => None,
+            Self::InetError { type_on_hover, .. } => Some(&type_on_hover),
+            Self::Ok { type_on_hover, .. } => Some(&type_on_hover),
+        }
+    }
+
+    pub fn ic_compiled(&self) -> Option<&IcCompiled> {
+        match self {
+            Self::None => None,
+            Self::SyntaxError { .. } => None,
+            Self::CompileError { .. } => None,
+            Self::TypeError { .. } => None,
+            Self::InetError { .. } => None,
+            Self::Ok { ic_compiled, .. } => Some(&ic_compiled),
+        }
+    }
+
+    pub fn from_source(source: &str, file: FileName) -> Self {
+        let mut module = match Module::parse_and_compile(source, file) {
+            Ok(module) => module,
+            Err(ParseAndCompileError::Parse(error)) => return Self::SyntaxError { error },
+            Err(ParseAndCompileError::Compile(error)) => return Self::CompileError { error },
+        };
+        import_builtins(&mut module);
+        Self::from_compiled(module)
+    }
+
+    pub fn from_compiled(compiled: Module<Arc<Expression<()>>>) -> Self {
+        let pretty = compiled
+            .definitions
+            .iter()
+            .map(
+                |Definition {
+                     span: _,
+                     name,
+                     expression,
+                 }| {
+                    let mut buf = String::new();
+                    write!(&mut buf, "def {} = ", name).expect("write failed");
+                    expression.pretty(&mut buf, 0).expect("write failed");
+                    write!(&mut buf, "\n\n").expect("write failed");
+                    buf
+                },
+            )
+            .collect();
+
+        let checked = match compiled.type_check() {
+            Ok(checked) => Arc::new(checked),
+            Err(error) => return Self::TypeError { pretty, error },
+        };
+        Self::from_checked(pretty, checked)
+    }
+
+    pub fn from_checked(pretty: String, checked: Arc<CheckedModule>) -> Self {
+        let type_on_hover = TypeOnHover::new(&checked);
+        let ic_compiled = match icombs::compiler::compile_file(&checked) {
+            Ok(ic_compiled) => ic_compiled,
+            Err(error) => {
+                return Self::InetError {
+                    pretty,
+                    checked,
+                    type_on_hover,
+                    error,
+                }
+            }
+        };
+        Self::Ok {
+            pretty,
+            checked,
+            type_on_hover,
+            ic_compiled,
+        }
+    }
+}

src/par/parse.rs

@@ -359,6 +359,7 @@ pub fn parse_module(
     })
 }
 
+#[cfg(feature = "playground")]
 pub fn parse_bytes(input: &str, file: &FileName) -> Option<Vec<u8>> {
     (literal_bytes_inner, winnow::combinator::eof)
         .parse_next(&mut Input::new(&lex(input, file)))

src/par/primitive.rs

@@ -33,6 +33,7 @@ impl Primitive {
         }
     }
 
+    #[cfg(feature = "playground")]
     pub fn pretty_string(&self) -> String {
         let mut buf = String::new();
         self.pretty(&mut buf, 0).unwrap();