implement check for missing filters in pipeline

src/main.rs

@@ -30,6 +30,16 @@ fn main() {
         out_errs.append(&mut errs)
     }
 
+    let invalid_missing_filters = "meow | | test | awa |   | nya";
+    let invalid_missing_filters_id = files.add("invalid_missing_filters", invalid_missing_filters);
+    if let Err(mut errs) = check(
+        parse_syntax(invalid_missing_filters, invalid_missing_filters_id).unwrap(),
+        invalid_missing_filters,
+        invalid_missing_filters_id,
+    ) {
+        out_errs.append(&mut errs)
+    }
+
     // invalid
     let writer = StandardStream::stderr(ColorChoice::Always);
     let config = term::Config::default();

src/syntax/check.rs

@@ -14,6 +14,12 @@ pub fn check(
         errs.push(SyntaxError::MissingStreamer(vec![(file_id, e_span)]));
     }
 
+    if let Err(mut err_locs) = check_missing_filters(&syntax) {
+        errs.push(SyntaxError::MissingFilter(
+            err_locs.into_iter().map(|loc| (file_id, loc)).collect(),
+        ))
+    }
+
     if errs.is_empty() {
         Ok(syntax)
     } else {
@@ -32,3 +38,29 @@ fn check_missing_streamer(syntax: &Vec<PipelineElement>) -> Result<(), logos::Sp
         Ok(())
     }
 }
+
+fn check_missing_filters(syntax: &Vec<PipelineElement>) -> Result<(), Vec<logos::Span>> {
+    let mut missing_filter_locs = Vec::new();
+
+    for i in 0..syntax.len() {
+        if let (
+            Some(PipelineElement {
+                kind: PipelineElementKind::Pipe,
+                ref span,
+            }),
+            Some(PipelineElement {
+                kind: PipelineElementKind::Pipe,
+                span: ref span1,
+            }),
+        ) = (syntax.get(i), syntax.get(i + 1))
+        {
+            missing_filter_locs.push(span.start..span1.end)
+        }
+    }
+
+    if missing_filter_locs.is_empty() {
+        Ok(())
+    } else {
+        Err(missing_filter_locs)
+    }
+}

src/syntax/error.rs

@@ -10,9 +10,9 @@ pub enum SyntaxError {
     /// `MissingStreamer` means, that the pipeline starts with a Pipe (`|`), so it has no streamer as input in front of it.
     MissingStreamer(Vec<(FileId, logos::Span)>),
     /// `MissingSink` means, that the pipeline ends with a Pipe (`|`), meaning that the output can't go anywhere
-    MissingSink,
+    MissingSink(Vec<(FileId, logos::Span)>),
     /// This indicates a missing filter somewhere in the pipeline, meaning that there's 2 pipes after one another
-    MissingFilter,
+    MissingFilter(Vec<(FileId, logos::Span)>),
     /// A literal cannot be a sink
     LiteralAsSink,
     /// A literal can't be a filter either
@@ -42,6 +42,15 @@ impl SyntaxError {
                         })
                         .collect(),
                 ),
+            Self::MissingFilter(locs) => Diagnostic::error()
+                .with_message("missing filters in pipelines")
+                .with_labels(
+                    locs.into_iter()
+                        .map(|(file_id, span)| {
+                            Label::primary(*file_id, span.clone()).with_message("no filter here")
+                        })
+                        .collect(),
+                ),
             _ => todo!(),
         }
     }