Made string/byte types and saturated bool optional

Author: Sam Crow

CHANGELOG.md

@@ -6,12 +6,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-- `canadensis_dsdl_parser`: Breaking change: Removed `saturated bool` type
+- `canadensis_dsdl_parser`: Breaking change: Added Config, with options for `byte`, `utf8`, and `saturated bool`
 - `canadensis_dsdl_parser`: Added support for `byte` and `utf8` types (this is a breaking change for code that uses
   this library, but it does not break compatibility with any existing DSDL file)
-- `canadensis_dsdl_frontend`: Added support for `byte` and `utf8` types (this is a breaking change for code that uses
-  this library, but it does not break compatibility with any existing DSDL file)
-- `canadensis_codegen_rust`: Added support for `byte` and `utf8` (code generation is the same as for uint8)
+- `canadensis_dsdl_frontend`: Breaking change: Added Config, with options for `byte`, `utf8`, and `saturated bool`
+- `canadensis_macro`: Added options for `byte`, `utf8`, and `saturated bool` (not a breaking change)
+- `canadensis_codegen_rust`: Added unstable optional support for `byte` and `utf8` (code generation is the same as for uint8)
+- `canadensis_codegen_rust`: Added unstable option to forbid `saturated bool`
 
 ## [canadensis-v0.3.3](https://github.com/samcrow/canadensis/releases/tag/canadensis-v0.3.3) - 2025-03-23
 

canadensis_codegen_rust/src/main.rs

@@ -2,7 +2,7 @@ extern crate canadensis_codegen_rust;
 extern crate canadensis_dsdl_frontend;
 extern crate clap;
 
-use canadensis_dsdl_frontend::Package;
+use canadensis_dsdl_frontend::{Config, Package};
 use clap::{value_parser, Arg, Command};
 use std::collections::BTreeMap;
 use std::fs::File;
@@ -28,12 +28,13 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             output_file: output_path,
             external_packages,
             rustfmt,
+            config,
         } => {
             let mut package = Package::new();
             for path in input_folders {
                 package.add_files(path)?;
             }
-            let package = match package.compile_with_warnings() {
+            let package = match package.compile_with_warnings(&config) {
                 Ok(package) => package,
                 Err((e, warnings)) => {
                     for warning in warnings {
@@ -103,6 +104,8 @@ enum Args {
         external_packages: BTreeMap<Vec<String>, Vec<String>>,
         /// Run rustfmt on the generated code
         rustfmt: bool,
+        /// Parser configuration
+        config: Config,
     },
     PrintDependencies,
 }
@@ -142,6 +145,15 @@ fn get_args() -> Args {
                 .long("rustfmt")
                 .num_args(0)
                 .help("Run rustfmt to format the generated code")
+        )
+            .arg(Arg::new("allow_utf8_and_byte")
+                .long("unstable-allow-utf8-and-byte")
+                .num_args(0)
+                .help("Allow utf8 and byte DSDL types (this option is unstable)")
+            ).arg(Arg::new("forbid_saturated_bool")
+            .long("unstable-forbid-saturated-bool")
+            .num_args(0)
+            .help("Forbid the saturated bool DSDL type (this option is unstable and may become the default)")
         ))
         .subcommand(Command::new("print-dependencies")
             .about("Prints the packages that the generated code depends on (for use in Cargo.toml)"));
@@ -165,6 +177,10 @@ fn get_args() -> Args {
                 })
                 .unwrap_or_else(BTreeMap::new),
             rustfmt: matches.contains_id("rustfmt"),
+            config: Config {
+                allow_utf8_and_byte: matches.contains_id("allow_utf8_and_byte"),
+                allow_saturated_bool: !matches.contains_id("forbid_saturated_bool"),
+            },
         },
         Some(("print-dependencies", _)) => Args::PrintDependencies,
         _ => panic!("Unrecognized Subcommand"),

canadensis_codegen_rust/tests/compile_fail.rs

@@ -7,7 +7,7 @@ extern crate canadensis_codegen_rust;
 extern crate canadensis_dsdl_frontend;
 
 use canadensis_dsdl_frontend::compiled::package::CompiledPackage;
-use canadensis_dsdl_frontend::Package;
+use canadensis_dsdl_frontend::{Config, Package};
 use std::ffi::OsString;
 use std::fs;
 use std::io;
@@ -49,7 +49,8 @@ fn compile_fail() -> io::Result<()> {
 fn try_compile_package(path: &Path) -> Result<CompiledPackage, canadensis_dsdl_frontend::Error> {
     let mut package = Package::new();
     package.add_files(path)?;
-    package.compile()
+    let config = Config::default();
+    package.compile(&config)
 }
 
 fn try_compile_and_generate_code(path: &Path) -> Result<(), Box<dyn std::error::Error>> {

canadensis_codegen_rust/tests/compile_pass.rs

@@ -4,7 +4,7 @@ extern crate canadensis_dsdl_frontend;
 use std::path::PathBuf;
 
 use canadensis_dsdl_frontend::compiled::package::CompiledPackage;
-use canadensis_dsdl_frontend::Package;
+use canadensis_dsdl_frontend::{Config, Package};
 
 /// Checks that this library can compile the Cyphal public regulated data types, Nunavut test
 /// types, and a few additional Canadensis test types
@@ -43,7 +43,11 @@ fn try_compile_package(
     for path in paths {
         package.add_files(path)?;
     }
-    package.compile()
+    let config = Config {
+        allow_utf8_and_byte: true,
+        allow_saturated_bool: false,
+    };
+    package.compile(&config)
 }
 
 fn try_compile_and_generate_code(paths: &[PathBuf]) -> Result<(), Box<dyn std::error::Error>> {

canadensis_dsdl_frontend/Cargo.toml

@@ -26,3 +26,8 @@ path = "../canadensis_dsdl_parser"
 [dependencies.canadensis_bit_length_set]
 version = "0.3.0"
 path = "../canadensis_bit_length_set"
+
+[dev-dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+regex = "1.10.5"

canadensis_dsdl_frontend/examples/load_package.rs

@@ -1,6 +1,6 @@
 extern crate canadensis_dsdl_frontend;
 use canadensis_dsdl_frontend::compiled::DsdlKind;
-use canadensis_dsdl_frontend::{Error, Package};
+use canadensis_dsdl_frontend::{Config, Error, Package};
 use std::env;
 use std::process;
 
@@ -29,7 +29,7 @@ fn run() -> Result<(), Error> {
         package.add_files(path)?;
     }
 
-    let compiled = package.compile()?;
+    let compiled = package.compile(&Config::default())?;
 
     for (key, compiled_dsdl) in compiled {
         println!("{}:", key);

canadensis_dsdl_frontend/src/compile.rs

@@ -11,7 +11,7 @@ use crate::types::expression::convert_type;
 use crate::types::{array_length_bits, PrimitiveType, ResolvedScalarType, ResolvedType};
 use crate::warning::Warnings;
 use canadensis_bit_length_set::BitLengthSet;
-use canadensis_dsdl_parser::{Identifier, Span, Statement};
+use canadensis_dsdl_parser::{Config, Identifier, Span, Statement};
 use once_cell::sync::Lazy;
 use std::collections::btree_map::Entry;
 use std::collections::BTreeMap;
@@ -32,8 +32,9 @@ static BIT_LENGTH_ZERO: Lazy<BitLengthSet> = Lazy::new(|| BitLengthSet::single(0
 ///
 /// This function returns the compiled DSDL or an error. In either case, it also returns
 /// a set of warnings.
-pub(crate) fn compile(files: BTreeMap<TypeKey, DsdlFile>) -> CompileOutput {
+pub(crate) fn compile(files: BTreeMap<TypeKey, DsdlFile>, config: &Config) -> CompileOutput {
     let context = PersistentContext {
+        config,
         pending: files,
         done: BTreeMap::new(),
         warnings: Warnings::new(),
@@ -53,14 +54,14 @@ pub(crate) struct CompileOutput {
 ///
 /// They use its functions to collect information about the type currently being compiled, and
 /// about other types.
-pub(crate) struct CompileContext<'p> {
+pub(crate) struct CompileContext<'p, 'c: 'p> {
     /// Persistent context and information about other types
-    persistent: &'p mut PersistentContext,
+    persistent: &'p mut PersistentContext<'c>,
     /// Information about the type currently being compiled
     current_file: &'p mut FileState,
 }
 
-impl<'p> CompileContext<'p> {
+impl<'p, 'c: 'p> CompileContext<'p, 'c> {
     /// Returns the constants that have been declared in the current file
     ///
     /// If the current file defines a service type, constants declared in the request section
@@ -220,15 +221,19 @@ impl<'p> CompileContext<'p> {
 }
 
 /// A convenience function to make a `CompileContext`
-fn ctx<'p>(p: &'p mut PersistentContext, c: &'p mut FileState) -> CompileContext<'p> {
+fn ctx<'p, 'c: 'p>(
+    p: &'p mut PersistentContext<'c>,
+    c: &'p mut FileState,
+) -> CompileContext<'p, 'c> {
     CompileContext {
         persistent: p,
         current_file: c,
     }
 }
 
 /// A context used during the compilation process
-struct PersistentContext {
+struct PersistentContext<'c> {
+    config: &'c Config,
     /// Files that have not been compiled
     pending: BTreeMap<TypeKey, DsdlFile>,
     /// Files that have been compiled
@@ -237,7 +242,7 @@ struct PersistentContext {
     warnings: Warnings,
 }
 
-impl PersistentContext {
+impl<'c> PersistentContext<'c> {
     fn compile(mut self) -> CompileOutput {
         while let Some(key) = self.pending.keys().next().cloned() {
             let input = self.pending.remove(&key).unwrap();
@@ -277,7 +282,7 @@ impl PersistentContext {
         let mut state = FileState::new(key.name().path());
 
         let text = input.read()?;
-        let ast = canadensis_dsdl_parser::parse(&text)?;
+        let ast = canadensis_dsdl_parser::parse(&text, &self.config)?;
 
         for statement in ast.statements {
             match statement {

canadensis_dsdl_frontend/src/lib.rs

@@ -29,6 +29,8 @@ mod type_key;
 pub mod types;
 pub mod warning;
 
+pub use canadensis_dsdl_parser::Config;
+
 pub use crate::error::Error;
 pub use crate::package::Package;
 pub use crate::type_key::{TypeFullName, TypeKey};

canadensis_dsdl_frontend/src/operators/attribute.rs

@@ -8,7 +8,7 @@ use canadensis_dsdl_parser::Span;
 
 /// Evaluates the attribute operator `expr.attribute`
 pub(crate) fn evaluate(
-    cx: &mut CompileContext<'_>,
+    cx: &mut CompileContext<'_, '_>,
     lhs: Value,
     rhs: &str,
     span: Span<'_>,
@@ -87,7 +87,7 @@ fn make_set_min_max_gt_undefined_error(
 }
 
 fn evaluate_type_attr(
-    cx: &mut CompileContext<'_>,
+    cx: &mut CompileContext<'_, '_>,
     ty: Type,
     rhs: &str,
     span: Span<'_>,

canadensis_dsdl_frontend/src/package.rs

@@ -4,7 +4,7 @@ use crate::error::Error;
 use crate::type_key::{TypeFullName, TypeKey};
 use crate::types::keywords::{is_reserved_keyword, is_valid_identifier};
 use crate::warning::Warnings;
-use canadensis_dsdl_parser::TypeVersion;
+use canadensis_dsdl_parser::{Config, TypeVersion};
 use once_cell::sync::Lazy;
 use regex::Regex;
 use std::collections::btree_map::Entry;
@@ -162,8 +162,9 @@ impl Package {
     /// invalid content, or an `@assert` directive fails.
     ///
     /// If this function returns an error, it cannot return any warnings.
-    pub fn compile(self) -> Result<CompiledPackage, Error> {
-        self.compile_with_warnings().map_err(|(e, _warnings)| e)
+    pub fn compile(self, config: &Config) -> Result<CompiledPackage, Error> {
+        self.compile_with_warnings(config)
+            .map_err(|(e, _warnings)| e)
     }
     /// Compiles all input files that were previously added
     ///
@@ -174,8 +175,11 @@ impl Package {
     ///
     /// If an error occurs, this function returns the error and any warnings reported before
     /// encountering the error.
-    pub fn compile_with_warnings(self) -> Result<CompiledPackage, (Error, Warnings)> {
-        match crate::compile::compile(self.files) {
+    pub fn compile_with_warnings(
+        self,
+        config: &Config,
+    ) -> Result<CompiledPackage, (Error, Warnings)> {
+        match crate::compile::compile(self.files, config) {
             CompileOutput {
                 dsdl: Ok(types),
                 warnings,