chore(deps): Upgrade to Rust 1.50.0

lib/prometheus-parser/src/lib.rs

@@ -319,7 +319,8 @@ mod test {
         assert!(matches!(
             error,
             ParserError::WithLine {
-                kind: ErrorKind::ExpectedChar { expected: ',', .. }, ..
+                kind: ErrorKind::ExpectedChar { expected: ',', .. },
+                ..
             }
         ));
 
@@ -329,7 +330,8 @@ mod test {
         assert!(matches!(
             error,
             ParserError::WithLine {
-                kind: ErrorKind::InvalidMetricKind { .. }, ..
+                kind: ErrorKind::InvalidMetricKind { .. },
+                ..
             }
         ));
 
@@ -339,7 +341,8 @@ mod test {
         assert!(matches!(
             error,
             ParserError::WithLine {
-                kind: ErrorKind::ExpectedSpace { .. }, ..
+                kind: ErrorKind::ExpectedSpace { .. },
+                ..
             }
         ));
 
@@ -349,7 +352,8 @@ mod test {
         assert!(matches!(
             error,
             ParserError::WithLine {
-                kind: ErrorKind::ExpectedChar { expected: '"', .. }, ..
+                kind: ErrorKind::ExpectedChar { expected: '"', .. },
+                ..
             }
         ));
 
@@ -359,7 +363,8 @@ mod test {
         assert!(matches!(
             error,
             ParserError::WithLine {
-                kind: ErrorKind::ExpectedChar { expected: '"', .. }, ..
+                kind: ErrorKind::ExpectedChar { expected: '"', .. },
+                ..
             }
         ));
 
@@ -369,7 +374,8 @@ mod test {
         assert!(matches!(
             error,
             ParserError::WithLine {
-                kind: ErrorKind::ParseFloatError { .. }, ..
+                kind: ErrorKind::ParseFloatError { .. },
+                ..
             }
         ));
     }

lib/prometheus-parser/src/line.rs

@@ -611,10 +611,7 @@ mod test {
         let input = wrap(r#"{ a="b" ,, c="d" }"#);
         let error = Metric::parse_labels(&input).unwrap_err().into();
         println!("{}", error);
-        assert!(matches!(
-            error,
-            ErrorKind::ParseNameError { .. }
-        ));
+        assert!(matches!(error, ErrorKind::ParseNameError { .. }));
     }
 
     #[test]

lib/remap-cli/src/cmd.rs

@@ -73,14 +73,13 @@ fn run(opts: &Opts) -> Result<(), Error> {
     }
 }
 
-#[cfg(feature = "repl")]
 fn repl(objects: Vec<Value>) -> Result<(), Error> {
-    repl::run(objects)
-}
-
-#[cfg(not(feature = "repl"))]
-fn repl(_: Vec<Value>) -> Result<(), Error> {
-    Err(Error::ReplFeature)
+    if cfg!(feature = "repl") {
+        repl::run(objects);
+        Ok(())
+    } else {
+        Err(Error::ReplFeature)
+    }
 }
 
 fn execute(object: &mut impl Object, source: String) -> Result<Value, Error> {

lib/remap-cli/src/lib.rs

@@ -18,7 +18,6 @@ pub enum Error {
     #[error("json error")]
     Json(#[from] serde_json::Error),
 
-    #[cfg(not(feature = "repl"))]
     #[error("repl feature disabled, program input required")]
     ReplFeature,
 }

lib/remap-cli/src/repl.rs

@@ -1,4 +1,3 @@
-use crate::Error;
 use prettytable::{format, Cell, Row, Table};
 use regex::Regex;
 use remap::{state, Formatter, Object, Program, Runtime, Value};
@@ -24,7 +23,7 @@ VRL REPL commands:
 const DOCS_URL: &str = "https://vector.dev/docs/reference/vrl";
 const FUNCTIONS_ROOT_URL: &str = "https://vector.dev/docs/reference/vrl/functions";
 
-pub(crate) fn run(mut objects: Vec<Value>) -> Result<(), Error> {
+pub(crate) fn run(mut objects: Vec<Value>) {
     let mut index = 0;
     let func_docs_regex = Regex::new(r"^help\sdocs\s(\w{1,})$").unwrap();
 
@@ -131,8 +130,6 @@ pub(crate) fn run(mut objects: Vec<Value>) -> Result<(), Error> {
             }
         }
     }
-
-    Ok(())
 }
 
 fn resolve(

lib/remap-functions/src/parse_aws_alb_log.rs

@@ -55,14 +55,14 @@ impl Expression for ParseAwsAlbLogFn {
         self.value
             .type_def(state)
             .into_fallible(true) // Log parsing error
-            .with_inner_type(inner_type_def())
+            .with_inner_type(Some(inner_type_def()))
             .with_constraint(value::Kind::Map)
     }
 }
 
 /// The type defs of the fields contained by the returned map.
-fn inner_type_def() -> Option<InnerTypeDef> {
-    Some(inner_type_def! ({
+fn inner_type_def() -> InnerTypeDef {
+    inner_type_def! ({
         "type": Kind::Bytes,
         "timestamp": Kind::Bytes,
         "elb": Kind::Bytes,
@@ -94,7 +94,7 @@ fn inner_type_def() -> Option<InnerTypeDef> {
         "target_status_code_list": Kind::Bytes,
         "classification": Kind::Bytes,
         "classification_reason": Kind::Bytes
-    }))
+    })
 }
 
 fn parse_log(mut input: &str) -> Result<Value> {
@@ -240,12 +240,12 @@ mod tests {
     remap::test_type_def![
         value_string {
             expr: |_| ParseAwsAlbLogFn { value: Literal::from("foo").boxed() },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         value_optional {
             expr: |_| ParseAwsAlbLogFn { value: Box::new(Noop) },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
     ];
 

lib/remap-functions/src/parse_aws_cloudwatch_log_subscription_message.rs

@@ -58,14 +58,14 @@ impl Expression for ParseAwsCloudWatchLogSubscriptionMessageFn {
         self.value
             .type_def(state)
             .into_fallible(true) // Message parsing error
-            .with_inner_type(inner_type_def())
+            .with_inner_type(Some(inner_type_def()))
             .with_constraint(value::Kind::Map)
     }
 }
 
 /// The type defs of the fields contained by the returned map.
-fn inner_type_def() -> Option<InnerTypeDef> {
-    Some(inner_type_def! ({
+fn inner_type_def() -> InnerTypeDef {
+    inner_type_def! ({
         "owner": Kind::Bytes,
         "message_type": Kind::Bytes,
         "log_group": Kind::Bytes,
@@ -78,7 +78,7 @@ fn inner_type_def() -> Option<InnerTypeDef> {
                 "timestamp": Kind::Timestamp,
                 "message": Kind::Bytes,
             })))
-    }))
+    })
 }
 
 #[cfg(test)]
@@ -150,7 +150,7 @@ mod tests {
         def: TypeDef {
             fallible: true,
             kind: Kind::Map,
-            inner_type_def: inner_type_def(),
+            inner_type_def: Some(inner_type_def()),
         },
     }];
 }

lib/remap-functions/src/parse_aws_vpc_flow_log.rs

@@ -64,14 +64,14 @@ impl Expression for ParseAwsVpcFlowLogFn {
         self.value
             .type_def(state)
             .into_fallible(true) // Log parsin_ error
-            .with_inner_type(inner_type_def())
+            .with_inner_type(Some(inner_type_def()))
             .with_constraint(value::Kind::Map)
     }
 }
 
 /// The type defs of the fields contained by the returned map.
-fn inner_type_def() -> Option<InnerTypeDef> {
-    Some(inner_type_def! ({
+fn inner_type_def() -> InnerTypeDef {
+    inner_type_def! ({
         "version": Kind::Integer | Kind::Null,
         "account_id": Kind::Integer | Kind::Null,
         "interface_id": Kind::Bytes | Kind::Null,
@@ -96,11 +96,12 @@ fn inner_type_def() -> Option<InnerTypeDef> {
         "region": Kind::Bytes | Kind::Null,
         "az_id": Kind::Bytes | Kind::Null,
         "sublocation_type": Kind::Bytes | Kind::Null,
-    }))
+    })
 }
 
 type ParseResult<T> = std::result::Result<T, String>;
 
+#[allow(clippy::unnecessary_wraps)] // match other parse methods
 fn identity<'a>(_key: &'a str, value: &'a str) -> ParseResult<&'a str> {
     Ok(value)
 }
@@ -185,22 +186,22 @@ mod tests {
     remap::test_type_def![
         value_noop {
             expr: |_| ParseAwsVpcFlowLogFn::new(Box::new(Noop), None),
-            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         value_non_string {
             expr: |_| ParseAwsVpcFlowLogFn::new(Literal::from(1).boxed(), None),
-            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         value_string {
             expr: |_| ParseAwsVpcFlowLogFn::new(Literal::from("foo").boxed(), None),
-            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         format_non_string {
             expr: |_| ParseAwsVpcFlowLogFn::new(Literal::from("foo").boxed(), Some(Literal::from(1).boxed())),
-            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
     ];
 

lib/remap-functions/src/parse_common_log.rs

@@ -153,14 +153,14 @@ impl Expression for ParseCommonLogFn {
             .type_def(state)
             .into_fallible(true)
             .with_constraint(value::Kind::Map)
-            .with_inner_type(inner_type_def())
+            .with_inner_type(Some(inner_type_def()))
     }
 }
 
-fn inner_type_def() -> Option<InnerTypeDef> {
+fn inner_type_def() -> InnerTypeDef {
     use value::Kind;
 
-    Some(inner_type_def!({
+    inner_type_def!({
         "host": Kind::Bytes | Kind::Null,
         "identity": Kind::Bytes | Kind::Null,
         "user": Kind::Bytes | Kind::Null,
@@ -171,7 +171,7 @@ fn inner_type_def() -> Option<InnerTypeDef> {
         "protocol": Kind::Bytes | Kind::Null,
         "status": Kind::Integer | Kind::Null,
         "size": Kind::Integer | Kind::Null,
-    }))
+    })
 }
 
 #[cfg(test)]
@@ -242,22 +242,22 @@ mod tests {
     test_type_def![
         value_string {
             expr: |_| ParseCommonLogFn { value: Literal::from("foo").boxed(), timestamp_format: None },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         value_non_string {
             expr: |_| ParseCommonLogFn { value: Literal::from(1).boxed(), timestamp_format: None },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         timestamp_format_string {
             expr: |_| ParseCommonLogFn { value: Literal::from("foo").boxed(), timestamp_format: Some(Literal::from("foo").boxed()) },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         timestamp_format_non_string {
             expr: |_| ParseCommonLogFn { value: Literal::from("foo").boxed(), timestamp_format: Some(Literal::from(1).boxed()) },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
     ];
 }

lib/remap-functions/src/parse_glog.rs

@@ -114,21 +114,21 @@ impl Expression for ParseGlogFn {
             .type_def(state)
             .into_fallible(true)
             .with_constraint(value::Kind::Map)
-            .with_inner_type(inner_type_def())
+            .with_inner_type(Some(inner_type_def()))
     }
 }
 
-fn inner_type_def() -> Option<InnerTypeDef> {
+fn inner_type_def() -> InnerTypeDef {
     use value::Kind;
 
-    Some(inner_type_def!({
+    inner_type_def!({
         "level": Kind::Bytes,
         "timestamp": Kind::Timestamp,
         "id": Kind::Integer,
         "file": Kind::Bytes,
         "line": Kind::Integer,
         "message": Kind::Bytes,
-    }))
+    })
 }
 
 #[cfg(test)]
@@ -188,17 +188,17 @@ mod tests {
     test_type_def![
         value_string {
             expr: |_| ParseGlogFn { value: Literal::from("foo").boxed() },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         value_non_string {
             expr: |_| ParseGlogFn { value: Literal::from(1).boxed() },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
 
         value_optional {
             expr: |_| ParseGlogFn { value: Box::new(Noop) },
-            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: inner_type_def() },
+            def: TypeDef { fallible: true, kind: value::Kind::Map, inner_type_def: Some(inner_type_def()) },
         }
     ];
 }