add strict mode to the parser

this mode rejects unknown display hints
use strict mode when parsing strings used in the write! and logging macros
do not use the strict mode when decoding defmt data in e.g. probe-run

Author: japaric

decoder/src/lib.rs

@@ -682,7 +682,7 @@ impl<'t, 'b> Decoder<'t, 'b> {
     /// Decodes arguments from the stream, according to `format`.
     fn decode_format(&mut self, format: &str) -> Result<Vec<Arg<'t>>, DecodeError> {
         let mut args = vec![]; // will contain the deserialized arguments on return
-        let mut params = defmt_parser::parse(format)
+        let mut params = defmt_parser::parse(format, false)
             .map_err(|_| DecodeError::Malformed)?
             .iter()
             .filter_map(|frag| match frag {
@@ -993,7 +993,7 @@ fn format_args_real(
         Ok(())
     }
 
-    let params = defmt_parser::parse(format).unwrap();
+    let params = defmt_parser::parse(format, false).unwrap();
     let mut buf = String::new();
     for param in params {
         match param {

macros/src/lib.rs

@@ -494,7 +494,7 @@ fn log_ts(level: Level, ts: TokenStream) -> TokenStream {
 
 fn log(level: Level, log: FormatArgs) -> TokenStream2 {
     let ls = log.litstr.value();
-    let fragments = match defmt_parser::parse(&ls) {
+    let fragments = match defmt_parser::parse(&ls, true) {
         Ok(args) => args,
         Err(e) => return parse::Error::new(log.litstr.span(), e).to_compile_error(),
     };
@@ -989,7 +989,7 @@ pub fn internp(ts: TokenStream) -> TokenStream {
 pub fn write(ts: TokenStream) -> TokenStream {
     let write = parse_macro_input!(ts as Write);
     let ls = write.litstr.value();
-    let fragments = match defmt_parser::parse(&ls) {
+    let fragments = match defmt_parser::parse(&ls, true) {
         Ok(args) => args,
         Err(e) => {
             return parse::Error::new(write.litstr.span(), e)

parser/src/lib.rs

@@ -153,7 +153,7 @@ fn parse_array(mut s: &str) -> Result<usize, Cow<'static, str>> {
 }
 
 // example input: "0=Type:hint" (note: no braces)
-fn parse_param(mut s: &str) -> Result<Param, Cow<'static, str>> {
+fn parse_param(mut s: &str, strict: bool) -> Result<Param, Cow<'static, str>> {
     const TYPE_PREFIX: &str = "=";
     const HINT_PREFIX: &str = ":";
 
@@ -249,7 +249,13 @@ fn parse_param(mut s: &str) -> Result<Param, Cow<'static, str>> {
             },
             "X" => DisplayHint::Hexadecimal { is_uppercase: true },
             "?" => DisplayHint::Debug,
-            _ => DisplayHint::Unknown(s.to_owned()),
+            _ => {
+                if strict {
+                    return Err(format!("unknown display hint: {:?}", s).into());
+                } else {
+                    DisplayHint::Unknown(s.to_owned())
+                }
+            }
         });
     } else if !s.is_empty() {
         return Err(format!("unexpected content {:?} in format string", s).into());
@@ -325,7 +331,10 @@ where
     }
 }
 
-pub fn parse<'f>(format_string: &'f str) -> Result<Vec<Fragment<'f>>, Cow<'static, str>> {
+pub fn parse<'f>(
+    format_string: &'f str,
+    strict: bool,
+) -> Result<Vec<Fragment<'f>>, Cow<'static, str>> {
     let mut fragments = Vec::new();
 
     // Index after the `}` of the last format specifier.
@@ -363,7 +372,7 @@ pub fn parse<'f>(format_string: &'f str) -> Result<Vec<Fragment<'f>>, Cow<'stati
 
         // Parse the contents inside the braces.
         let param_str = &format_string[brace_pos + 1..][..len];
-        let param = parse_param(param_str)?;
+        let param = parse_param(param_str, strict)?;
         fragments.push(Fragment::Parameter(Parameter {
             index: param.index.unwrap_or_else(|| {
                 // If there is no explicit index, assign the next one.

tests/ui/log-invalid-hint.rs

@@ -0,0 +1,3 @@
+fn main() {
+    defmt::info!("{=u8:dunno}", 42)
+}

tests/ui/log-invalid-hint.stderr

@@ -0,0 +1,5 @@
+error: unknown display hint: "dunno"
+ --> $DIR/log-invalid-hint.rs:2:18
+  |
+2 |     defmt::info!("{=u8:dunno}", 42)
+  |                  ^^^^^^^^^^^^^

tests/ui/write-invalid-hint.rs

@@ -0,0 +1,9 @@
+struct S;
+
+impl defmt::Format for S {
+    fn format(&self, f: defmt::Formatter) {
+        defmt::write!(f, "{=u8:dunno}", 42)
+    }
+}
+
+fn main() {}

tests/ui/write-invalid-hint.stderr

@@ -0,0 +1,5 @@
+error: unknown display hint: "dunno"
+ --> $DIR/write-invalid-hint.rs:5:26
+  |
+5 |         defmt::write!(f, "{=u8:dunno}", 42)
+  |                          ^^^^^^^^^^^^^