forgot label for edges

assert/src/dsl.rs

@@ -114,6 +114,7 @@ pub enum QualifierSystem {
 pub enum QualifierEdge {
     Source,
     Target,
+    Label,
 }
 
 #[derive(Clone, Copy, Serialize, Deserialize, Hash)]
@@ -304,8 +305,12 @@ impl Unary {
             ) => Ok(AssertionTypes::Set),
             | (Self::ToEl, AssertionTypes::String) =>
                 Ok(AssertionTypes::Element),
-            | (Self::Qualifier(Qualifier::Edge(_)), AssertionTypes::Edge) =>
+            | (Self::Qualifier(Qualifier::Edge(QualifierEdge::Source)), AssertionTypes::Edge) =>
                 Ok(AssertionTypes::Node),
+            | (Self::Qualifier(Qualifier::Edge(QualifierEdge::Target)), AssertionTypes::Edge) =>
+                Ok(AssertionTypes::Node),
+            | (Self::Qualifier(Qualifier::Edge(QualifierEdge::Label)), AssertionTypes::Edge) =>
+                Ok(AssertionTypes::Label),
             | (
                 Self::Qualifier(Qualifier::Node(QualifierNode::Neighbours)),
                 AssertionTypes::Node,
@@ -839,6 +844,12 @@ impl AssertReturnValue {
             ) => Ok(AssertReturnValue::Node(
                 graph.edge_endpoints(edge).unwrap().1,
             )),
+            | (
+                AssertReturnValue::Edge(edge),
+                Unary::Qualifier(Qualifier::Edge(QualifierEdge::Label)),
+            ) => Ok(AssertReturnValue::Label(
+                graph[edge].clone()
+            )),
             | (
                 AssertReturnValue::Node(node),
                 Unary::Qualifier(Qualifier::Node(QualifierNode::Neighbours)),

assert/src/fmt.rs

@@ -181,6 +181,7 @@ impl fmt::Debug for QualifierEdge {
         match self {
             | Self::Source => write!(f, "source"),
             | Self::Target => write!(f, "target"),
+            | Self::Label => write!(f, "label"),
         }
     }
 }

assert/src/positivedsl.rs

@@ -130,6 +130,7 @@ pub enum QualifierSystem {
 pub enum QualifierEdge {
     Source,
     Target,
+    Label,
 }
 
 #[derive(Clone, Copy, Serialize, Deserialize, Hash)]
@@ -334,9 +335,17 @@ impl PositiveUnary {
             | (Self::ToEl, PositiveAssertionTypes::String) =>
                 Ok(PositiveAssertionTypes::PositiveElement),
             | (
-                Self::Qualifier(PositiveQualifier::Edge(_)),
+                Self::Qualifier(PositiveQualifier::Edge(QualifierEdge::Source)),
                 PositiveAssertionTypes::Edge,
             ) => Ok(PositiveAssertionTypes::Node),
+            | (
+                Self::Qualifier(PositiveQualifier::Edge(QualifierEdge::Target)),
+                PositiveAssertionTypes::Edge,
+            ) => Ok(PositiveAssertionTypes::Node),
+            | (
+                Self::Qualifier(PositiveQualifier::Edge(QualifierEdge::Label)),
+                PositiveAssertionTypes::Edge,
+            ) => Ok(PositiveAssertionTypes::Label),
             | (
                 Self::Qualifier(PositiveQualifier::Node(
                     QualifierNode::Neighbours,
@@ -999,6 +1008,14 @@ impl PositiveAssertReturnValue {
             ) => Ok(PositiveAssertReturnValue::Node(
                 graph.edge_endpoints(edge).unwrap().1,
             )),
+            | (
+                PositiveAssertReturnValue::Edge(edge),
+                PositiveUnary::Qualifier(PositiveQualifier::Edge(
+                    QualifierEdge::Label,
+                )),
+            ) => Ok(PositiveAssertReturnValue::Label(
+                graph[edge].clone(),
+            )),
             | (
                 PositiveAssertReturnValue::Node(node),
                 PositiveUnary::Qualifier(PositiveQualifier::Node(

assert/src/positivefmt.rs

@@ -181,6 +181,7 @@ impl fmt::Debug for QualifierEdge {
         match self {
             | Self::Source => write!(f, "source"),
             | Self::Target => write!(f, "target"),
+            | Self::Label => write!(f, "label"),
         }
     }
 }

grammar_separated/src/assert.lalrpop

@@ -251,6 +251,7 @@ AssertQualifierSystem: relabel::QualifierSystem = {
 AssertQualifierEdge: relabel::QualifierEdge = {
     "source" => relabel::QualifierEdge::Source,
     "target" => relabel::QualifierEdge::Target,
+    "label"  => relabel::QualifierEdge::Label,
 }
 
 AssertQualifierNode: relabel::QualifierNode = {

grammar_separated/src/grouping.lalrpop

@@ -252,6 +252,7 @@ GroupQualifierSystem: grouping::QualifierSystem = {
 GroupQualifierEdge: grouping::QualifierEdge = {
     "source" => grouping::QualifierEdge::Source,
     "target" => grouping::QualifierEdge::Target,
+    "label"  => grouping::QualifierEdge::Label,
 }
 
 GroupQualifierNode: grouping::QualifierNode = {

grammar_separated/src/positive_assert.lalrpop

@@ -255,6 +255,7 @@ AssertQualifierSystem: positive_relabel::QualifierSystem = {
 AssertQualifierEdge: positive_relabel::QualifierEdge = {
     "source" => positive_relabel::QualifierEdge::Source,
     "target" => positive_relabel::QualifierEdge::Target,
+    "label"  => positive_relabel::QualifierEdge::Label,
 }
 
 AssertQualifierNode: positive_relabel::QualifierNode = {

grammar_separated/src/positive_grouping.lalrpop

@@ -256,6 +256,7 @@ GroupQualifierSystem: positive_grouping::QualifierSystem = {
 GroupQualifierEdge: positive_grouping::QualifierEdge = {
     "source" => positive_grouping::QualifierEdge::Source,
     "target" => positive_grouping::QualifierEdge::Target,
+    "label"  => positive_grouping::QualifierEdge::Label,
 }
 
 GroupQualifierNode: positive_grouping::QualifierNode = {