Add unsafe fn for modifying GrammarAST

Author: ratmice

cfgrammar/src/lib/mod.rs

@@ -3,7 +3,7 @@
 #![allow(clippy::new_without_default)]
 #![allow(clippy::unnecessary_wraps)]
 #![allow(clippy::upper_case_acronyms)]
-#![forbid(unsafe_code)]
+#![deny(unsafe_code)]
 #![deny(unreachable_pub)]
 
 //! A library for manipulating Context Free Grammars (CFG). It is impractical to fully homogenise

cfgrammar/src/lib/yacc/ast.rs

@@ -17,6 +17,8 @@ use crate::{
 };
 /// Contains a `GrammarAST` structure produced from a grammar source file.
 /// As well as any errors which occurred during the construction of the AST.
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct ASTWithValidityInfo {
     yacc_kind: YaccKind,
     ast: GrammarAST,
@@ -70,6 +72,16 @@ impl ASTWithValidityInfo {
     pub fn errors(&self) -> &[YaccGrammarError] {
         self.errs.as_slice()
     }
+
+    #[allow(unsafe_code)]
+    pub unsafe fn set_ast(&mut self, ast: GrammarAST) {
+        self.ast = ast;
+    }
+
+    #[allow(unsafe_code)]
+    pub unsafe fn ast_mut(&mut self) -> &mut GrammarAST {
+        &mut self.ast
+    }
 }
 
 impl FromStr for ASTWithValidityInfo {
@@ -110,7 +122,8 @@ impl FromStr for ASTWithValidityInfo {
 /// An AST representing a grammar. This is built up gradually: when it is finished, the
 /// `complete_and_validate` must be called exactly once in order to finish the set-up. At that
 /// point, any further mutations made to the struct lead to undefined behaviour.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
 #[non_exhaustive]
 pub struct GrammarAST {
     pub start: Option<(String, Span)>,
@@ -140,14 +153,15 @@ pub struct GrammarAST {
     pub expect_unused: Vec<Symbol>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(Eq, PartialEq))]
 pub struct Rule {
     pub name: (String, Span),
     pub pidxs: Vec<usize>, // index into GrammarAST.prod
     pub actiont: Option<String>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[cfg_attr(test, derive(Eq, PartialEq))]
 pub struct Production {
     pub symbols: Vec<Symbol>,
@@ -195,7 +209,7 @@ impl fmt::Display for Symbol {
 }
 
 impl GrammarAST {
-    pub fn new() -> GrammarAST {
+    pub(crate) fn new() -> GrammarAST {
         GrammarAST {
             start: None,
             rules: IndexMap::new(), // Using an IndexMap means that we retain the order
@@ -772,4 +786,44 @@ mod test {
                 .contains(&ast_validity.ast().tokens.get_index_of("b").unwrap())
         );
     }
+
+    #[test]
+    #[allow(unsafe_code)]
+    fn clone_ast_changing_start_rule() {
+        use super::*;
+        use crate::yacc::*;
+        let y_src_contents = r#"
+        %token A B C
+        %%
+        AStart: A ':' BStart ';';
+        BStart: B ',' C | C ',' B;
+        "#;
+
+        let astart = format!("%start AStart\n{y_src_contents}");
+        let bcstart = format!("%start BStart\n{y_src_contents}");
+
+        let mut astart_ast_validity = ASTWithValidityInfo::new(
+            YaccKind::Original(YaccOriginalActionKind::NoAction),
+            &astart,
+        );
+        let bstart_ast_validity = ASTWithValidityInfo::new(
+            YaccKind::Original(YaccOriginalActionKind::NoAction),
+            &bcstart,
+        );
+
+        assert!(astart_ast_validity.is_valid());
+        assert!(bstart_ast_validity.is_valid());
+
+        // We'll take the `astart` grammar and programatically modify it into the `bcstart` one.
+        let modified_astart = unsafe { astart_ast_validity.ast_mut() };
+
+        let start_len = "%start ".len();
+        modified_astart.start = Some((
+            "BStart".to_string(),
+            Span::new(start_len, start_len + "BStart".len()),
+        ));
+        // This equality test is really a hack since it relies on all the start rules having the same str length
+        // So as not to change the spans of any rules after the initial `%start` decl.
+        assert_eq!(astart_ast_validity, bstart_ast_validity);
+    }
 }

cfgrammar/src/lib/yacc/mod.rs

@@ -17,7 +17,7 @@ use quote::quote;
 use serde::{Deserialize, Serialize};
 
 /// The particular Yacc variant this grammar makes use of.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[non_exhaustive]
 pub enum YaccKind {
@@ -43,7 +43,7 @@ impl quote::ToTokens for YaccKind {
     }
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum YaccOriginalActionKind {
     /// Execute user-specified actions attached to each production; also requires a %actiontype