webidl: Make logging a little more consistently formatted

This commit makes these changes:

* Unsupported constructs always log "unsupported" for easy `grep`ing
* There is always a "<generic message> : <details>" format now, so we can easily
  use `cut` to grab the generic message and count which kinds of things are our
  biggest missing features.
* Make sure that we have different `warn!` logs for each kind of unsupported
  thing, instead of grouping them together.

Put all that together and this is the current state of `wasm-bindgen-webidl` and
`web-sys`:

```
$ grep WARN stderr.txt | grep wasm_bindgen_webidl | grep -i unsupported | cut -d ' ' -f5- | cut -d ':' -f 1 | sort | uniq -c | sort -rn
    387 Unsupported WebIDL Dictionary definition
    139 Unsupported argument type
     70 Unsupported return type
     47 Unsupported WebIDL Callback definition
     22 Unsupported WebIDL extended attribute
     18 Unsupported unnamed operation
      9 Unsupported WebIDL CallbackInterface definition
      7 Unsupported WebIDL Stringifier interface member
      7 Unsupported WebIDL Maplike interface member
      2 Unsupported webidl stringifier
      2 Unsupported WebIDL Setlike interface member
      2 Unsupported stringifier on type
```

crates/webidl/src/lib.rs

@@ -188,12 +188,19 @@ impl<'src> WebidlParse<'src, ()> for weedle::Definition<'src> {
             weedle::Definition::Namespace(namespace) => {
                 namespace.webidl_parse(program, first_pass, ())?
             }
+
             // TODO
-            | weedle::Definition::Callback(..)
-            | weedle::Definition::CallbackInterface(..)
-            | weedle::Definition::Dictionary(..)
-            | weedle::Definition::PartialDictionary(..) => {
-                warn!("Unsupported WebIDL definition: {:?}", self)
+            weedle::Definition::Callback(..) => {
+                warn!("Unsupported WebIDL Callback definition: {:?}", self)
+            }
+            weedle::Definition::CallbackInterface(..) => {
+                warn!("Unsupported WebIDL CallbackInterface definition: {:?}", self)
+            }
+            weedle::Definition::Dictionary(..) => {
+                warn!("Unsupported WebIDL Dictionary definition: {:?}", self)
+            }
+            weedle::Definition::PartialDictionary(..) => {
+                warn!("Unsupported WebIDL PartialDictionary definition: {:?}", self)
             }
         }
         Ok(())
@@ -288,7 +295,7 @@ impl<'src> WebidlParse<'src, ()> for weedle::PartialInterfaceDefinition<'src> {
             .get(self.identifier.0)
             .map(|interface_data| !interface_data.partial)
             .unwrap_or(true) {
-            warn!(
+            info!(
                 "Partial interface {} missing non-partial interface",
                 self.identifier.0
             );
@@ -453,10 +460,16 @@ impl<'src> WebidlParse<'src, &'src str> for weedle::interface::InterfaceMember<'
                 iterable.webidl_parse(program, first_pass, self_name)
             }
             // TODO
-            | Maplike(_)
-            | Stringifier(_)
-            | Setlike(_) => {
-                warn!("Unsupported WebIDL interface member: {:?}", self);
+            Maplike(_) => {
+                warn!("Unsupported WebIDL Maplike interface member: {:?}", self);
+                Ok(())
+            }
+            Stringifier(_) => {
+                warn!("Unsupported WebIDL Stringifier interface member: {:?}", self);
+                Ok(())
+            }
+            Setlike(_) => {
+                warn!("Unsupported WebIDL Setlike interface member: {:?}", self);
                 Ok(())
             }
         }
@@ -482,7 +495,7 @@ impl<'a, 'src> WebidlParse<'src, &'a str> for weedle::mixin::MixinMember<'src> {
             }
             // TODO
             weedle::mixin::MixinMember::Stringifier(_) => {
-                warn!("Unsupported WebIDL mixin member: {:?}", self);
+                warn!("Unsupported WebIDL stringifier mixin member: {:?}", self);
                 Ok(())
             }
         }
@@ -551,7 +564,7 @@ fn member_attribute<'src>(
 
     let is_static = match modifier {
         Some(Stringifier(_)) => {
-            warn!("Unsupported stringifier on type {:?}", (self_name, identifier));
+            warn!("Unsupported stringifier on type: {:?}", (self_name, identifier));
             return Ok(())
         }
         Some(Inherit(_)) => false,
@@ -560,7 +573,7 @@ fn member_attribute<'src>(
     };
 
     if type_.attributes.is_some() {
-        warn!("Unsupported attributes on type {:?}", (self_name, identifier));
+        warn!("Unsupported attributes on type: {:?}", (self_name, identifier));
         return Ok(())
     }
 
@@ -656,7 +669,7 @@ fn member_operation<'src>(
 
     let is_static = match modifier {
         Some(Stringifier(_)) => {
-            warn!("Unsupported stringifier on type {:?}", (self_name, identifier));
+            warn!("Unsupported stringifier on type: {:?}", (self_name, identifier));
             return Ok(())
         }
         Some(Static(_)) => true,
@@ -668,7 +681,7 @@ fn member_operation<'src>(
     ];
     if specials.len() > 1 {
         warn!(
-            "Unsupported specials ({:?}) on type {:?}",
+            "Unsupported specials: ({:?}) on type {:?}",
             specials,
             (self_name, identifier),
         );
@@ -893,8 +906,8 @@ impl<'src> WebidlParse<'src, (&'src str, &'src mut backend::ast::Module)> for we
             weedle::namespace::NamespaceMember::Operation(op) => {
                 op.webidl_parse(program, first_pass, (self_name, module))?;
             }
-            weedle::namespace::NamespaceMember::Attribute(_) => {
-                warn!("Attribute namespace members are not supported")
+            weedle::namespace::NamespaceMember::Attribute(attr) => {
+                warn!("Unsupported attribute namespace member: {:?}", attr)
             }
         }
         Ok(())