Turn off coverage where possible

Ari Breitkreuz · Ari Breitkreuz · commit 219fbd9c2175 · 2024-01-16T17:52:23.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,6 +26,7 @@ spans = ["wasm-bindgen-macro/spans"]
 std = []
 serde-serialize = ["serde", "serde_json", "std"]
 enable-interning = ["std"]
+unstable-coverage = ["wasm-bindgen-macro/unstable-coverage"]
 
 # Whether or not the `#[wasm_bindgen]` macro is strict and generates an error on
 # all unused attributes
diff --git a/crates/backend/src/codegen.rs b/crates/backend/src/codegen.rs
@@ -173,6 +173,7 @@ impl ToTokens for ast::Struct {
         (quote! {
             #[automatically_derived]
             impl #wasm_bindgen::describe::WasmDescribe for #name {
+                #[cfg_attr(feature = "unstable-coverage", allow_internal_unstable(coverage_attribute))]
                 fn describe() {
                     use #wasm_bindgen::__wbindgen_if_not_std;
                     __wbindgen_if_not_std! {
@@ -835,6 +836,7 @@ impl ToTokens for ast::ImportType {
                 use #wasm_bindgen::__rt::core;
 
                 impl WasmDescribe for #rust_name {
+                    #[cfg_attr(feature = "unstable-coverage", allow_internal_unstable(coverage_attribute))]
                     fn describe() {
                         #description
                     }
@@ -1082,6 +1084,7 @@ impl ToTokens for ast::ImportEnum {
             // It should really be using &str for all of these, but that requires some major changes to cli-support
             #[automatically_derived]
             impl #wasm_bindgen::describe::WasmDescribe for #name {
+                #[cfg_attr(feature = "unstable-coverage", allow_internal_unstable(coverage_attribute))]
                 fn describe() {
                     <#wasm_bindgen::JsValue as #wasm_bindgen::describe::WasmDescribe>::describe()
                 }
@@ -1441,6 +1444,7 @@ impl ToTokens for ast::Enum {
 
             #[automatically_derived]
             impl #wasm_bindgen::describe::WasmDescribe for #enum_name {
+                #[cfg_attr(feature = "unstable-coverage", allow_internal_unstable(coverage_attribute))]
                 fn describe() {
                     use #wasm_bindgen::describe::*;
                     inform(ENUM);
@@ -1606,6 +1610,7 @@ impl<'a, T: ToTokens> ToTokens for Descriptor<'a, T> {
                 #(#attrs)*
                 #[no_mangle]
                 #[doc(hidden)]
+                #[cfg_attr(feature = "unstable-coverage", allow_internal_unstable(coverage_attribute))]
                 pub extern "C" fn #name() {
                     use #wasm_bindgen::describe::*;
                     // See definition of `link_mem_intrinsics` for what this is doing
diff --git a/crates/macro/Cargo.toml b/crates/macro/Cargo.toml
@@ -19,6 +19,7 @@ proc-macro = true
 spans = ["wasm-bindgen-macro-support/spans"]
 xxx_debug_only_print_generated_code = []
 strict-macro = ["wasm-bindgen-macro-support/strict-macro"]
+unstable-coverage = []
 
 [dependencies]
 wasm-bindgen-macro-support = { path = "../macro-support", version = "=0.2.90" }
diff --git a/src/closure.rs b/src/closure.rs
@@ -465,6 +465,7 @@ impl<T> WasmDescribe for Closure<T>
 where
     T: WasmClosure + ?Sized,
 {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(EXTERNREF);
     }
@@ -565,6 +566,7 @@ macro_rules! doit {
             where $($var: FromWasmAbi + 'static,)*
                   R: ReturnWasmAbi + 'static,
         {
+            #[cfg_attr(feature = "unstable-coverage", coverage(off))]
             fn describe() {
                 #[allow(non_snake_case)]
                 unsafe extern "C" fn invoke<$($var: FromWasmAbi,)* R: ReturnWasmAbi>(
@@ -622,6 +624,7 @@ macro_rules! doit {
             where $($var: FromWasmAbi + 'static,)*
                   R: ReturnWasmAbi + 'static,
         {
+            #[cfg_attr(feature = "unstable-coverage", coverage(off))]
             fn describe() {
                 #[allow(non_snake_case)]
                 unsafe extern "C" fn invoke<$($var: FromWasmAbi,)* R: ReturnWasmAbi>(
@@ -763,6 +766,7 @@ where
     A: RefFromWasmAbi,
     R: ReturnWasmAbi + 'static,
 {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         #[allow(non_snake_case)]
         unsafe extern "C" fn invoke<A: RefFromWasmAbi, R: ReturnWasmAbi>(
@@ -809,6 +813,7 @@ where
     A: RefFromWasmAbi,
     R: ReturnWasmAbi + 'static,
 {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         #[allow(non_snake_case)]
         unsafe extern "C" fn invoke<A: RefFromWasmAbi, R: ReturnWasmAbi>(
diff --git a/src/convert/closures.rs b/src/convert/closures.rs
@@ -54,6 +54,7 @@ macro_rules! stack_closures {
             where $($var: FromWasmAbi,)*
                   R: ReturnWasmAbi
         {
+            #[cfg_attr(feature = "unstable-coverage", coverage(off))]
             fn describe() {
                 inform(FUNCTION);
                 inform($invoke::<$($var,)* R> as u32);
@@ -108,6 +109,7 @@ macro_rules! stack_closures {
             where $($var: FromWasmAbi,)*
                   R: ReturnWasmAbi
         {
+            #[cfg_attr(feature = "unstable-coverage", coverage(off))]
             fn describe() {
                 inform(FUNCTION);
                 inform($invoke_mut::<$($var,)* R> as u32);
@@ -177,6 +179,7 @@ where
     A: RefFromWasmAbi,
     R: ReturnWasmAbi,
 {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(FUNCTION);
         inform(invoke1_ref::<A, R> as u32);
@@ -232,6 +235,7 @@ where
     A: RefFromWasmAbi,
     R: ReturnWasmAbi,
 {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(FUNCTION);
         inform(invoke1_mut_ref::<A, R> as u32);
diff --git a/src/describe.rs b/src/describe.rs
@@ -66,6 +66,7 @@ pub trait WasmDescribeVector {
 macro_rules! simple {
     ($($t:ident => $d:ident)*) => ($(
         impl WasmDescribe for $t {
+            #[cfg_attr(feature = "unstable-coverage", coverage(off))]
             fn describe() { inform($d) }
         }
     )*)
@@ -103,32 +104,37 @@ cfg_if! {
 }
 
 impl<T> WasmDescribe for *const T {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(U32)
     }
 }
 
 impl<T> WasmDescribe for *mut T {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(U32)
     }
 }
 
 impl<T: WasmDescribe> WasmDescribe for [T] {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(SLICE);
         T::describe();
     }
 }
 
 impl<'a, T: WasmDescribe + ?Sized> WasmDescribe for &'a T {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(REF);
         T::describe();
     }
 }
 
 impl<'a, T: WasmDescribe + ?Sized> WasmDescribe for &'a mut T {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(REFMUT);
         T::describe();
@@ -166,46 +172,53 @@ if_std! {
     }
 
     impl<T: WasmDescribeVector> WasmDescribe for Box<[T]> {
+        #[cfg_attr(feature = "unstable-coverage", coverage(off))]
         fn describe() {
             T::describe_vector();
         }
     }
 
     impl<T> WasmDescribe for Vec<T> where Box<[T]>: WasmDescribe {
+        #[cfg_attr(feature = "unstable-coverage", coverage(off))]
         fn describe() {
             <Box<[T]>>::describe();
         }
     }
 }
 
 impl<T: WasmDescribe> WasmDescribe for Option<T> {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(OPTIONAL);
         T::describe();
     }
 }
 
 impl WasmDescribe for () {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(UNIT)
     }
 }
 
 impl<T: WasmDescribe, E: Into<JsValue>> WasmDescribe for Result<T, E> {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(RESULT);
         T::describe();
     }
 }
 
 impl<T: WasmDescribe> WasmDescribe for Clamped<T> {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         inform(CLAMPED);
         T::describe();
     }
 }
 
 impl WasmDescribe for JsError {
+    #[cfg_attr(feature = "unstable-coverage", coverage(off))]
     fn describe() {
         JsValue::describe();
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -8,6 +8,7 @@
 #![no_std]
 #![allow(coherence_leak_check)]
 #![doc(html_root_url = "https://docs.rs/wasm-bindgen/0.2")]
+#![cfg_attr(feature = "unstable-coverage", feature(coverage_attribute))]
 
 use core::convert::TryFrom;
 use core::fmt;

Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,7 @@ pub trait WasmDescribeVector {`
`66`	`66`	`macro_rules! simple {`
`67`	`67`	`($($t:ident => $d:ident)*) => ($(`
`68`	`68`	`impl WasmDescribe for $t {`
	`69`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`69`	`70`	`fn describe() { inform($d) }`
`70`	`71`	`}`
`71`	`72`	`)*)`
`@@ -103,32 +104,37 @@ cfg_if! {`
`103`	`104`	`}`
`104`	`105`
`105`	`106`	`impl<T> WasmDescribe for *const T {`
	`107`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`106`	`108`	`fn describe() {`
`107`	`109`	`inform(U32)`
`108`	`110`	`}`
`109`	`111`	`}`
`110`	`112`
`111`	`113`	`impl<T> WasmDescribe for *mut T {`
	`114`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`112`	`115`	`fn describe() {`
`113`	`116`	`inform(U32)`
`114`	`117`	`}`
`115`	`118`	`}`
`116`	`119`
`117`	`120`	`impl<T: WasmDescribe> WasmDescribe for [T] {`
	`121`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`118`	`122`	`fn describe() {`
`119`	`123`	`inform(SLICE);`
`120`	`124`	`T::describe();`
`121`	`125`	`}`
`122`	`126`	`}`
`123`	`127`
`124`	`128`	`impl<'a, T: WasmDescribe + ?Sized> WasmDescribe for &'a T {`
	`129`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`125`	`130`	`fn describe() {`
`126`	`131`	`inform(REF);`
`127`	`132`	`T::describe();`
`128`	`133`	`}`
`129`	`134`	`}`
`130`	`135`
`131`	`136`	`impl<'a, T: WasmDescribe + ?Sized> WasmDescribe for &'a mut T {`
	`137`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`132`	`138`	`fn describe() {`
`133`	`139`	`inform(REFMUT);`
`134`	`140`	`T::describe();`
`@@ -166,46 +172,53 @@ if_std! {`
`166`	`172`	`}`
`167`	`173`
`168`	`174`	`impl<T: WasmDescribeVector> WasmDescribe for Box<[T]> {`
	`175`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`169`	`176`	`fn describe() {`
`170`	`177`	`T::describe_vector();`
`171`	`178`	`}`
`172`	`179`	`}`
`173`	`180`
`174`	`181`	`impl<T> WasmDescribe for Vec<T> where Box<[T]>: WasmDescribe {`
	`182`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`175`	`183`	`fn describe() {`
`176`	`184`	`<Box<[T]>>::describe();`
`177`	`185`	`}`
`178`	`186`	`}`
`179`	`187`	`}`
`180`	`188`
`181`	`189`	`impl<T: WasmDescribe> WasmDescribe for Option<T> {`
	`190`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`182`	`191`	`fn describe() {`
`183`	`192`	`inform(OPTIONAL);`
`184`	`193`	`T::describe();`
`185`	`194`	`}`
`186`	`195`	`}`
`187`	`196`
`188`	`197`	`impl WasmDescribe for () {`
	`198`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`189`	`199`	`fn describe() {`
`190`	`200`	`inform(UNIT)`
`191`	`201`	`}`
`192`	`202`	`}`
`193`	`203`
`194`	`204`	`impl<T: WasmDescribe, E: Into<JsValue>> WasmDescribe for Result<T, E> {`
	`205`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`195`	`206`	`fn describe() {`
`196`	`207`	`inform(RESULT);`
`197`	`208`	`T::describe();`
`198`	`209`	`}`
`199`	`210`	`}`
`200`	`211`
`201`	`212`	`impl<T: WasmDescribe> WasmDescribe for Clamped<T> {`
	`213`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`202`	`214`	`fn describe() {`
`203`	`215`	`inform(CLAMPED);`
`204`	`216`	`T::describe();`
`205`	`217`	`}`
`206`	`218`	`}`
`207`	`219`
`208`	`220`	`impl WasmDescribe for JsError {`
	`221`	`+ #[cfg_attr(feature = "unstable-coverage", coverage(off))]`
`209`	`222`	`fn describe() {`
`210`	`223`	`JsValue::describe();`
`211`	`224`	`}`