version assumption

Author: s-ylide

opslang-ast/src/lib.rs

@@ -1,6 +1,5 @@
 pub mod compat;
 pub mod syntax;
-pub mod version;
 
 pub use compat::*;
 pub use syntax::*;

opslang-ast/src/syntax.rs

@@ -5,7 +5,6 @@ macro_rules! declare_versions {
     ($([$current:vis])? $path:ident, $ty:ident; $($tt:tt)*) => {
         pub mod $path;
         pub struct $ty;
-        impl $crate::version::sealed::VersionMarker for $ty {}
 
         $(
             /// Type alias for the default version of the ast.

opslang-ast/src/version.rs

@@ -1,4 +1,6 @@
 pub mod version;
+use std::{marker::PhantomData, path::PathBuf};
+
 pub use version::*;
 
 pub(crate) mod parol_macro;
@@ -9,9 +11,56 @@ pub(crate) mod parol_macro;
 ///
 /// - `Parser`: The type that distinguishes the parser. This is used to
 ///   differentiate between different parsing strategies or contexts.
-pub trait ParseOps<Format, Parser>: Sized {
+pub trait ParseOps<Format: InputFormat, Parser>: Sized {
     type Context;
     type Error;
 
     fn parse(from: Format, context: Self::Context) -> Result<Self, Self::Error>;
 }
+
+/// A marker trait for input formats.
+#[diagnostic::on_unimplemented(
+    message = "the type `{Self}` is not a valid input format",
+    label = "this type does not implement the `InputFormat` trait"
+)]
+pub trait InputFormat {}
+
+/// An input structure for the parser.
+pub struct ParserInput<'a> {
+    /// The string content to be parsed.
+    pub content: &'a str,
+
+    /// The name of the file from which the content was read.
+    ///
+    /// FIXME: This is specific to V1 and not used for accessing the content.
+    pub file_name: PathBuf,
+}
+
+impl<'a> ParserInput<'a> {
+    /// Assumes that the input is in the format of the inferred grammar version.
+    pub fn assume_inferred<Version: GrammarVersion>(self) -> Versioned<Version, Self> {
+        Versioned::assume_inferred(self)
+    }
+}
+
+/// A wrapper type for a value that is assumed to be in the specific format.
+pub struct Versioned<Version: GrammarVersion, T>(pub T, PhantomData<Version>);
+impl<Version: GrammarVersion, T> InputFormat for Versioned<Version, T> {}
+
+impl<Version: GrammarVersion, T> Versioned<Version, T> {
+    /// Creates a [`Versioned`] instance with the given value.
+    ///
+    /// This is useful when the type system already knows the version of the value.
+    pub fn assume_inferred(value: T) -> Self {
+        Self(value, PhantomData)
+    }
+
+    /// Creates a [`Versioned`] instance with an assumed version and the given value.
+    ///
+    /// This is useful when you want to explicitly specify the version at the point of parsing, not just at the type level.
+    /// If the type system already knows the version, you can use [`Versioned::assume_inferred`].
+    pub fn assume_version(version: Version, value: T) -> Self {
+        let _ = version;
+        Self(value, PhantomData)
+    }
+}

opslang-parser/src/lib.rs

@@ -1,27 +1,41 @@
-macro_rules! declare_versions {
-    () => {};
-    ($([$current:vis])? $path:ident, $ty:ident; $($tt:tt)*) => {
-        pub mod $path;
-        pub struct $ty;
+/// A marker trait for grammar versions.
+pub trait GrammarVersion {}
 
+/// A macro to declare grammar versions and their associated modules.
+///
+/// Note that this macro **re-exports** the types from the module.
+macro_rules! declare_versions {
+    (
         $(
-            /// Type alias for the default version of the parser.
-            $current type Default = $ty;
-            $current use $path::*;
-        )?
+            $([$current:vis])? $path:ident, $ty:ident;
+        )*
+    ) => {
+        $(
+            pub mod $path;
+            pub struct $ty;
+            impl GrammarVersion for $ty {}
+
+            $(
+                /// Type alias for the default version of the parser.
+                $current type Default = $ty;
 
-        declare_versions! { $($tt)* }
+                // Re-export the types from the module
+                $current use $path::*;
+            )?
+        )*
+
+        // assert that `[pub]` is used only once
+
+        /// Assertion that [`Default`] type alias exists at this scope.
+        ///
+        /// This is a compile-time check that will fail if [`Default`] is not defined.
+        #[allow(dead_code)]
+        const _: () = {
+            let _: Default;
+        };
     }
 }
 
-/// Assertion that [`Default`] type alias exists at this scope.
-///
-/// This is a compile-time check that will fail if [`Default`] is not defined.
-#[allow(dead_code)]
-const _: () = {
-    let _: Default;
-};
-
 declare_versions! {
     [pub] v0, V0;
     v1, V1;

opslang-parser/src/version.rs

@@ -1,26 +1,28 @@
 use opslang_ast::v0::Row;
 
-use crate::ParseOps;
+use crate::{ParseOps, Versioned};
 
 type This = super::V0;
 
-impl<'a> ParseOps<&'a str, This> for opslang_ast::v0::SRow {
+pub type AssumeV0Format<T> = Versioned<This, T>;
+
+impl<'a> ParseOps<AssumeV0Format<&'a str>, This> for opslang_ast::v0::SRow {
     type Context = ();
 
     type Error = peg::error::ParseError<<str as peg::Parse>::PositionRepr>;
 
-    fn parse(from: &'a str, _context: Self::Context) -> Result<Self, Self::Error> {
-        ops_parser::row(from)
+    fn parse(from: AssumeV0Format<&'a str>, _context: Self::Context) -> Result<Self, Self::Error> {
+        ops_parser::row(from.0)
     }
 }
 
-impl<'a> ParseOps<&'a str, This> for Vec<opslang_ast::v0::Statement> {
+impl<'a> ParseOps<AssumeV0Format<&'a str>, This> for Vec<opslang_ast::v0::Statement> {
     type Context = ();
 
     type Error = peg::error::ParseError<<str as peg::Parse>::PositionRepr>;
 
-    fn parse(from: &'a str, _context: Self::Context) -> Result<Self, Self::Error> {
-        ops_parser::statements(from)
+    fn parse(from: AssumeV0Format<&'a str>, _context: Self::Context) -> Result<Self, Self::Error> {
+        ops_parser::statements(from.0)
     }
 }
 

opslang-parser/src/version/v0.rs

@@ -6,27 +6,23 @@ pub use context::*;
 
 crate::redirect_parol!();
 
-use crate::ParseOps;
+use crate::{ParseOps, ParserInput, Versioned};
 
 type This = super::V1;
 
-pub struct ParserInput<'a> {
-    pub string: &'a str,
-    pub file_name: String,
-}
+pub type AssumeV1Format<T> = Versioned<This, T>;
 
-impl<'a, 'cx> ParseOps<ParserInput<'a>, This> for opslang_ast::v1::Program<'cx> {
+impl<'cx> ParseOps<AssumeV1Format<ParserInput<'cx>>, This> for opslang_ast::v1::Program<'cx> {
     type Context = &'cx ParseContext<'cx>;
 
     type Error = parol_runtime::ParolError;
 
     fn parse(
-        ParserInput { string, file_name }: ParserInput<'a>,
+        Versioned(ParserInput { content, file_name }, _): AssumeV1Format<ParserInput<'cx>>,
         context: Self::Context,
     ) -> Result<Self, Self::Error> {
         let mut action = parse::Action::new(context);
-        let string = context.alloc_str(string);
-        let _ = generated::parser::parse(string, file_name, &mut action)?;
+        let _ = generated::parser::parse(content, file_name, &mut action)?;
         Ok(action.finish())
     }
 }
@@ -38,14 +34,13 @@ mod tests {
     #[test]
     fn test_parse_file() {
         let input_str = include_str!("../../tests/test_v1.ops");
+        let input = ParserInput {
+            content: input_str,
+            file_name: "test_v1.ops".into(),
+        }
+        .assume_inferred();
         let context = ParseContext::new();
-        let result = opslang_ast::v1::Program::parse(
-            ParserInput {
-                string: input_str,
-                file_name: "test_v1.ops".to_string(),
-            },
-            &context,
-        );
+        let result = opslang_ast::v1::Program::parse(input, &context);
         assert!(
             result.is_ok(),
             "Failed to parse test_v1.ops: {:?}",