rangectlop visitor fixes and rangectlop parent implementation

src/ast.rs

@@ -48,6 +48,8 @@ pub enum CDDLType<'a, 'b: 'a> {
   Type1(&'b Type1<'a>),
   Type2(&'b Type2<'a>),
   Operator(&'b Operator<'a>),
+  RangeCtlOp(&'b RangeCtlOp),
+  ControlOperator(&'b ControlOperator),
   Occurrence(&'b Occurrence<'a>),
   Occur(Occur),
   Value(Value<'a>),
@@ -87,6 +89,8 @@ cddl_types_from_ast! {
   &'b Type1<'a> => CDDLType::Type1,
   &'b Type2<'a> => CDDLType::Type2,
   &'b Operator<'a> => CDDLType::Operator,
+  &'b RangeCtlOp => CDDLType::RangeCtlOp,
+  &'b ControlOperator => CDDLType::ControlOperator,
   &'b Occurrence<'a> => CDDLType::Occurrence,
   &'b ValueMemberKeyEntry<'a> => CDDLType::ValueMemberKeyEntry,
   &'b TypeGroupnameEntry<'a> => CDDLType::TypeGroupnameEntry,

src/token.rs

@@ -200,7 +200,7 @@ pub enum ControlOperator {
   /// .bits control operator
   BITS,
   /// .regexp control operator
-  CREGEXP,
+  REGEXP,
   /// .cbor control operator
   CBOR,
   /// .cborseq control operator
@@ -488,7 +488,7 @@ impl fmt::Display for ControlOperator {
     match self {
       ControlOperator::SIZE => write!(f, ".size"),
       ControlOperator::BITS => write!(f, ".bits"),
-      ControlOperator::CREGEXP => write!(f, ".regexp"),
+      ControlOperator::REGEXP => write!(f, ".regexp"),
       ControlOperator::PCRE => write!(f, ".pcre"),
       ControlOperator::CBOR => write!(f, ".cbor"),
       ControlOperator::CBORSEQ => write!(f, ".cborseq"),
@@ -611,7 +611,7 @@ pub fn lookup_control_from_str(ident: &str) -> Option<ControlOperator> {
   match ident {
     ".size" => Some(ControlOperator::SIZE),
     ".bits" => Some(ControlOperator::BITS),
-    ".regexp" => Some(ControlOperator::CREGEXP),
+    ".regexp" => Some(ControlOperator::REGEXP),
     ".cbor" => Some(ControlOperator::CBOR),
     ".cborseq" => Some(ControlOperator::CBORSEQ),
     ".within" => Some(ControlOperator::WITHIN),

src/validator/cbor.rs

@@ -1198,7 +1198,7 @@ where
         self.ctrl = None;
         Ok(())
       }
-      ControlOperator::CREGEXP | ControlOperator::PCRE => {
+      ControlOperator::REGEXP | ControlOperator::PCRE => {
         self.ctrl = Some(ctrl);
         match target {
           Type2::Typename { ident, .. } if is_ident_string_data_type(self.cddl, ident) => {
@@ -3255,7 +3255,7 @@ where
               Some(format!("expected {} .ne to \"{}\"", value, s))
             }
           }
-          Some(ControlOperator::CREGEXP) | Some(ControlOperator::PCRE) => {
+          Some(ControlOperator::REGEXP) | Some(ControlOperator::PCRE) => {
             let re = regex::Regex::new(
               &format_regex(
                 // Text strings must be JSON escaped per

src/validator/json.rs

@@ -1287,7 +1287,7 @@ impl<'a, 'b> Visitor<'a, 'b, Error> for JSONValidator<'a> {
         }
         self.ctrl = None;
       }
-      ControlOperator::CREGEXP | ControlOperator::PCRE => {
+      ControlOperator::REGEXP | ControlOperator::PCRE => {
         self.ctrl = Some(ctrl);
         match target {
           Type2::Typename { ident, .. } if is_ident_string_data_type(self.cddl, ident) => {
@@ -2431,7 +2431,7 @@ impl<'a, 'b> Visitor<'a, 'b, Error> for JSONValidator<'a> {
               Some(format!("expected {} .ne to \"{}\"", value, s))
             }
           }
-          Some(ControlOperator::CREGEXP) | Some(ControlOperator::PCRE) => {
+          Some(ControlOperator::REGEXP) | Some(ControlOperator::PCRE) => {
             let re = regex::Regex::new(
               &format_regex(
                 // Text strings must be JSON escaped per

src/validator/parent_visitor.rs

@@ -2,7 +2,7 @@
 
 use crate::{
   ast::*,
-  token::{ByteValue, Value},
+  token::{ByteValue, ControlOperator, Value},
   visitor::{self, *},
 };
 
@@ -64,6 +64,7 @@ impl_parent! {
   TypeChoice<'a> => ([Type1<'a>], CDDLType::TypeChoice),
   Type1<'a> => ([Operator<'a>, Type2<'a>], CDDLType::Type1),
   Operator<'a> => ([Type2<'a>], CDDLType::Operator),
+  RangeCtlOp => ([ControlOperator], CDDLType::RangeCtlOp),
   Type2<'a> => ([Identifier<'a>, GenericArgs<'a>, Type<'a>, Group<'a>], CDDLType::Type2),
   Group<'a> => ([GroupChoice<'a>, Occurrence<'a>], CDDLType::Group),
   GroupChoice<'a> => ([GroupEntry<'a>], CDDLType::GroupChoice),
@@ -325,7 +326,30 @@ impl<'a, 'b: 'a> Visitor<'a, 'b, Error> for ParentVisitor<'a, 'b> {
     let child = self.arena_tree.node(CDDLType::Type2(&o.type2));
     self.insert(parent, child)?;
 
-    walk_operator(self, target, o)
+    let child = self.arena_tree.node(CDDLType::RangeCtlOp(&o.operator));
+    self.insert(parent, child)?;
+
+    self.visit_rangectlop(&o.operator, target, &o.type2)
+  }
+
+  fn visit_rangectlop(
+    &mut self,
+    op: &'b RangeCtlOp,
+    target: &'b Type1<'a>,
+    controller: &'b Type2<'a>,
+  ) -> visitor::Result<Error> {
+    match op {
+      RangeCtlOp::RangeOp { is_inclusive, .. } => {
+        self.visit_range(&target.type2, controller, *is_inclusive)
+      }
+      RangeCtlOp::CtlOp { ctrl, .. } => {
+        let parent = self.arena_tree.node(CDDLType::RangeCtlOp(op));
+        let child = self.arena_tree.node(CDDLType::ControlOperator(ctrl));
+        self.insert(parent, child)?;
+
+        self.visit_control_operator(&target.type2, *ctrl, controller)
+      }
+    }
   }
 
   fn visit_type2(&mut self, t2: &'b Type2<'a>) -> visitor::Result<Error> {
@@ -981,4 +1005,28 @@ mod tests {
 
     Ok(())
   }
+
+  #[test]
+  fn ctrl_parent_is_rangectlop() -> Result<()> {
+    let cddl = cddl_from_str(r#"ip4 = bstr .size 4"#, true).unwrap();
+    let pv = ParentVisitor::new(&cddl).unwrap();
+
+    if let Rule::Type { rule, .. } = cddl.rules.first().unwrap() {
+      if let op @ RangeCtlOp::CtlOp { ctrl, .. } = &rule
+        .value
+        .type_choices
+        .first()
+        .unwrap()
+        .type1
+        .operator
+        .as_ref()
+        .unwrap()
+        .operator
+      {
+        assert_eq!(ctrl.parent(&pv).unwrap(), op)
+      }
+    }
+
+    Ok(())
+  }
 }

src/visitor.rs

@@ -62,6 +62,16 @@ pub trait Visitor<'a, 'b, E: Error> {
     walk_operator(self, target, o)
   }
 
+  /// Visit rangectlop
+  fn visit_rangectlop(
+    &mut self,
+    op: &'b RangeCtlOp,
+    target: &'b Type1<'a>,
+    controller: &'b Type2<'a>,
+  ) -> Result<E> {
+    walk_rangectlop(self, op, target, controller)
+  }
+
   /// Visit range
   fn visit_range(
     &mut self,
@@ -244,12 +254,26 @@ where
   E: Error,
   V: Visitor<'a, 'b, E> + ?Sized,
 {
-  match &o.operator {
+  visitor.visit_rangectlop(&o.operator, target, &o.type2)
+}
+
+/// Walk rangectlop
+pub fn walk_rangectlop<'a, 'b, E, V>(
+  visitor: &mut V,
+  op: &'b RangeCtlOp,
+  target: &'b Type1<'a>,
+  controller: &'b Type2<'a>,
+) -> Result<E>
+where
+  E: Error,
+  V: Visitor<'a, 'b, E> + ?Sized,
+{
+  match op {
     RangeCtlOp::RangeOp { is_inclusive, .. } => {
-      visitor.visit_range(&target.type2, &o.type2, *is_inclusive)
+      visitor.visit_range(&target.type2, controller, *is_inclusive)
     }
     RangeCtlOp::CtlOp { ctrl, .. } => {
-      visitor.visit_control_operator(&target.type2, *ctrl, &o.type2)
+      visitor.visit_control_operator(&target.type2, *ctrl, controller)
     }
   }
 }