Grammar v1

Cargo.toml

@@ -1,13 +1,64 @@
 [workspace]
 resolver = "2"
 members = [
-    "opslang-ast",
+    "structure/type-registry",
+    "structure/opslang-ast",
+    "structure/opslang-ast/macro",
+    "opslang-diag",
+    "structure/opslang-ir",
+    "structure/opslang-ir/macro",
     "opslang-parser",
+    "opslang-printer",
+    "ty/opslang-ty",
+    "ty/opslang-typeck",
+    "ty/opslang-module",
+    "opslang-visitor",
+    "opslang-visitor/macro",
+    "opslang-visitor-macro-helper",
+    "tools/opslang-migration",
+    "tools/opslang-formatter",
 ]
 
 [workspace.package]
 version = "0.4.0"
+edition = "2024"
+license = "MPL-2.0"
 
 [workspace.dependencies]
-opslang-ast = { path = "opslang-ast" }
-opslang-parser = { path = "opslang-parser" }
+anyhow = "1.0.100"
+chrono = "0.4.42"
+typed-arena = "2.0.2"
+thiserror = "2.0.17"
+
+clap = { version = "4.5.48", features = ["derive"] }
+walkdir = "2.5.0"
+toml = "0.9.7"
+
+serde = { version = "1.0.228", features = ["derive"] }
+
+syn = { version = "2.0.106", features = ["visit-mut", "full", "derive"] }
+proc-macro2 = "1.0.101"
+quote = "1.0.41"
+synstructure = "0.13.2"
+convert_case = "0.8.0"
+
+peg = "0.8.1"
+parol = "3.0.1"
+parol_runtime = "3.0.0"
+
+opslang-type-registry = { path = "./structure/type-registry", version = "=0.4.0" }
+opslang-ast = { path = "./structure/opslang-ast", version = "=0.4.0" }
+opslang-ast-macro = { path = "./structure/opslang-ast/macro", version = "=0.4.0" }
+opslang-ir = { path = "./structure/opslang-ir", version = "=0.4.0" }
+opslang-ir-macro = { path = "./structure/opslang-ir/macro", version = "=0.4.0" }
+opslang-diag = { path = "./opslang-diag", version = "=0.4.0" }
+opslang-parser = { path = "./opslang-parser", version = "=0.4.0" }
+opslang-printer = { path = "./opslang-printer", version = "=0.4.0" }
+opslang-ty = { path = "./ty/opslang-ty", version = "=0.4.0" }
+opslang-typeck = { path = "./ty/opslang-typeck", version = "=0.4.0" }
+opslang-module = { path = "./ty/opslang-module", version = "=0.4.0" }
+opslang-visitor = { path = "./opslang-visitor", version = "=0.4.0" }
+opslang-visitor-macro = { path = "./opslang-visitor/macro", version = "=0.4.0" }
+opslang-visitor-macro-helper = { path = "./opslang-visitor-macro-helper", version = "=0.4.0" }
+opslang-migration = { path = "./tools/opslang-migration", version = "=0.4.0" }
+opslang-formatter = { path = "./tools/opslang-formatter", version = "=0.4.0" }

opslang-diag/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "opslang-diag"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]

opslang-diag/src/lib.rs

@@ -0,0 +1,105 @@
+use std::cell::RefCell;
+
+pub struct DiagContext {
+    emitter: RefCell<Box<dyn DiagEmitter>>,
+}
+
+impl DiagContext {
+    pub fn new(emitter: Box<dyn DiagEmitter>) -> Self {
+        Self {
+            emitter: RefCell::new(emitter),
+        }
+    }
+
+    fn emit_diagnostic(&self, diag: DiagInner) {
+        self.emitter.borrow_mut().emit_diagnostic(diag);
+    }
+
+    #[track_caller]
+    pub fn create_err(&self, err: impl Diagnostic) -> Diag<'_> {
+        err.into_diag(self, Level::Error)
+    }
+
+    #[track_caller]
+    pub fn emit_err(&self, err: impl Diagnostic) {
+        self.create_err(err).emit()
+    }
+}
+
+pub trait DiagEmitter {
+    fn emit_diagnostic(&mut self, diag: DiagInner);
+}
+
+pub trait Diagnostic {
+    fn into_diag(self, dcx: &DiagContext, level: Level) -> Diag<'_>;
+}
+
+pub struct DiagInner {
+    pub(crate) level: Level,
+    pub message: String,
+}
+
+impl DiagInner {
+    pub fn level(&self) -> &Level {
+        &self.level
+    }
+}
+
+pub enum Level {
+    Bug,
+    Error,
+    Warning,
+    Info,
+    Lint,
+}
+
+pub struct Diag<'dcx> {
+    pub dcx: &'dcx DiagContext,
+    inner: Option<Box<DiagInner>>,
+}
+
+impl Drop for Diag<'_> {
+    fn drop(&mut self) {
+        if let Some(diag) = self.inner.take() {
+            self.dcx.emit_diagnostic(DiagInner::new(
+                Level::Bug,
+                String::from("the following error was constructed but not emitted"),
+            ));
+            self.dcx.emit_diagnostic(*diag);
+            panic!("error was constructed but not emitted");
+        }
+    }
+}
+
+impl Diag<'_> {
+    pub fn emit(mut self) {
+        self.dcx.emit_diagnostic(*self.inner.take().unwrap());
+    }
+
+    pub fn cancel(mut self) {
+        self.inner.take();
+    }
+}
+
+// constructors
+
+impl DiagInner {
+    fn new(level: Level, message: String) -> Self {
+        Self { level, message }
+    }
+}
+
+impl<'dcx> Diag<'dcx> {
+    #[track_caller]
+    pub fn new(dcx: &'dcx DiagContext, level: Level, message: String) -> Self {
+        Self::new_diagnostic(dcx, DiagInner::new(level, message))
+    }
+
+    #[track_caller]
+    pub(crate) fn new_diagnostic(dcx: &'dcx DiagContext, diag: DiagInner) -> Self {
+        Self {
+            dcx,
+            inner: Some(Box::new(diag)),
+        }
+    }
+}

opslang-parser/Cargo.toml

@@ -1,13 +1,35 @@
 [package]
 name = "opslang-parser"
 version.workspace = true
-edition = "2021"
-license = "MPL-2.0"
+edition.workspace = true
+license.workspace = true
 description = "ops file language parser"
 
+[features]
+v0 = ["dep:peg"]
+v1 = ["build-parol", "dep:typed-arena"]
+build-parol = ["dep:parol", "dep:parol_runtime"]
+default = ["v0", "v1"]
+
 [dependencies]
-peg = "0.8.1"
-thiserror = "1.0.48"
-anyhow = "1.0.75"
-opslang-ast = "0.4.0"
-chrono = "0.4.33"
+opslang-ast.workspace = true
+opslang-diag.workspace = true
+
+peg.workspace = true
+peg.optional = true
+parol.workspace = true
+parol.optional = true
+parol_runtime.workspace = true
+parol_runtime.optional = true
+typed-arena.workspace = true
+typed-arena.optional = true
+
+thiserror.workspace = true
+anyhow.workspace = true
+chrono.workspace = true
+
+[build-dependencies]
+parol.workspace = true
+parol.optional = true
+parol_runtime.workspace = true
+parol_runtime.optional = true

opslang-parser/build.rs

@@ -0,0 +1,141 @@
+#[cfg(feature = "build-parol")]
+fn build_parol() {
+    use std::path::PathBuf;
+    use std::process;
+
+    use parol::{ParolErrorReporter, build::Builder};
+    use parol_runtime::Report;
+
+    #[allow(unused_mut, unused_variables)]
+    let mut versions = Vec::new();
+
+    {
+        #[cfg(feature = "v1")]
+        versions.push("v1");
+    }
+
+    let mut has_error = false;
+
+    mod name {
+        pub struct Path {
+            pub path: &'static str,
+        }
+        impl AsRef<std::path::Path> for Path {
+            fn as_ref(&self) -> &std::path::Path {
+                self.path.as_ref()
+            }
+        }
+        #[derive(PartialEq)]
+        pub struct RustFile {
+            pub path: &'static str,
+            pub module: &'static str,
+        }
+        impl AsRef<std::path::Path> for RustFile {
+            fn as_ref(&self) -> &std::path::Path {
+                self.path.as_ref()
+            }
+        }
+
+        pub const ACTION_MOD: &str = "parse";
+        pub const USER_TYPE: &str = "Action";
+        pub const GENERATED: &str = "generated";
+        pub const GRAMMAR: Path = Path {
+            path: "grammar.par",
+        };
+        pub const EXPANDED_GRAMMAR: Path = Path {
+            path: "grammar-exp.par",
+        };
+        pub const PARSER: RustFile = RustFile {
+            path: "parser.rs",
+            module: "parser",
+        };
+        pub const TRAIT: RustFile = RustFile {
+            path: "grammar_trait.rs",
+            module: "grammar_trait",
+        };
+    }
+
+    for v in versions {
+        let input = {
+            let mut path = PathBuf::from("src");
+            path.push("version");
+            path.push(v);
+            path
+        };
+        let generated = {
+            let mut path = PathBuf::from("src");
+            path.push("version");
+            path.push(v);
+            path.push(name::GENERATED);
+            path
+        };
+        std::fs::create_dir_all(&generated).unwrap();
+
+        let grammar_file = input.join(name::GRAMMAR.path);
+        if let Err(err) = Builder::with_explicit_output_dir(".")
+            .grammar_file(&grammar_file)
+            .expanded_grammar_output_file(generated.join(name::EXPANDED_GRAMMAR))
+            .parser_output_file(generated.join(name::PARSER))
+            .actions_output_file(generated.join(name::TRAIT))
+            .user_trait_module_name(&format!("version::{v}::{path}", path = name::ACTION_MOD))
+            .user_type_name(name::USER_TYPE)
+            .trim_parse_tree()
+            .generate_parser()
+        {
+            ParolErrorReporter::report_error(&err, &grammar_file).unwrap_or_default();
+            has_error = true;
+        }
+
+        // Generate `generated.rs`
+        let mut f = std::fs::File::create(generated.join("../generated.rs")).unwrap();
+        {
+            use name::*;
+            use std::io::Write;
+            writeln!(f, "// This file is generated by `build.rs`.").unwrap();
+            writeln!(f, "// Do not edit it manually.").unwrap();
+            writeln!(f).unwrap();
+            for file in [TRAIT, PARSER] {
+                if file == TRAIT {
+                    writeln!(f, "#[allow(clippy::all)]").unwrap();
+                }
+                let module_name = file.module;
+                writeln!(f, "pub mod {module_name};").unwrap();
+            }
+        }
+    }
+
+    if has_error {
+        process::exit(1);
+    }
+
+    // Generate `src/parol_macro.rs`
+    let mut f = std::fs::File::create("src/parol_macro.rs").unwrap();
+    {
+        use name::*;
+        use std::io::Write;
+        writeln!(f, "// This file is generated by `build.rs`.").unwrap();
+        writeln!(f, "// Do not edit it manually.").unwrap();
+        writeln!(f).unwrap();
+        let action = TRAIT.module;
+        writeln!(
+            f,
+            r#"#[macro_export]
+/// Redirect due to `actions_output_file` depending on `user_trait_module_name` in fact.
+///
+/// This macro is generated by `build.rs`.
+macro_rules! redirect_parol {{
+    () => {{
+        mod {ACTION_MOD}_trait {{
+            pub use super::{GENERATED}::{action}::{USER_TYPE}Auto;
+        }}
+    }};
+}}"#
+        )
+        .unwrap();
+    }
+}
+
+fn main() {
+    #[cfg(feature = "build-parol")]
+    build_parol();
+}