Unenhanced warnings are emitted from mutate() when run in a reprex()

[DavisVaughan]

When run with reprex::reprex():

library(dplyr)

foo <- function() {
  warning("foo")
  NA
}

df <- tibble(x = 1)

df <- mutate(df, x = foo())
#> Warning in foo(): foo

vs when run interactively:

df <- mutate(df, x = foo())
#> Warning message:
#> Problem with `mutate()` column `x`.
#> ℹ `x = foo()`.
#> ℹ foo 

I think this is related to the changes from #5686, in particular it is about the maybe_restart() bit here that occurs when the warning is muffled

dplyr/R/mutate.R

Lines 427 to 446 in 87d1cec

	warning = function(w) {
	# Check if there is an upstack calling handler that would muffle
	# the warning. This avoids doing the expensive work below for a
	# silenced warning (#5675).
	if (check_muffled_warning(w)) {
	maybe_restart("muffleWarning")
	}
	local_call_step(dots = dots, .index = i, .fn = "mutate")
	warn(c(
	cnd_bullet_header(),
	i = cnd_bullet_column_info(),
	i = conditionMessage(w),
	i = cnd_bullet_cur_group_label(what = "warning")
	))
	# Cancel `w`
	maybe_restart("muffleWarning")
	})

I guess in the stack of reprex(), someone is muffling the warnings as it captures them to be able to print them out later on?

Since it was slow to throw the enhanced warnings, maybe this is the best we can do, but it wasn't mentioned in #5686 as a potential issue so I figured I'd bring it up in case @lionel- has any thoughts here

[lionel-]

hmmm, it might be possible to create a structured warning where the conditionMessage() method communicates with the calling handler. If the instrumenting handler is alive when the method is called, we'd call it back to return a full warning. I'm happy to work on this if you like (or assist if you want to implement).

[DavisVaughan]

If you have the time I'd appreciate if you could take the lead on this because I only understood about half of that 😬

[hadley]

@lionel- can you take a look at this when you start integrating the new rlang error stuff into dplyr?

[lionel-]

I implemented a working strategy to support capturing+muffling handlers without incurring message generation costs on muffling-only handlers:

modified   R/mutate.R
@@ -443,23 +443,40 @@ mutate_cols <- function(.data, dots, caller_env, error_call = caller_env()) {
       call = error_call
     )
   },
-  warning = function(w) {
+  warning = function(orig) {
+    stale <- FALSE
+    on.exit(stale <- TRUE)
+
+    header <- function(cnd, ...) {
+      if (stale) {
+        return(conditionMessage(orig))
+      }
+      local_error_context(dots = dots, .index = i, mask = mask)
+      cnd_bullet_header("computing")
+    }
+    body <- function(cnd, ...) {
+      if (stale) {
+        return(NULL)
+      }
+      local_error_context(dots = dots, .index = i, mask = mask)
+      c(
+        i = cnd_header(orig),
+        i = cnd_bullet_cur_group_label(what = "warning")
+      )
+    }
+
+    rich <- warning_cnd(header = header, body = body)
+
     # Check if there is an upstack calling handler that would muffle
     # the warning. This avoids doing the expensive work below for a
     # silenced warning (#5675).
-    if (check_muffled_warning(w)) {
+    if (check_muffled_warning(rich)) {
       maybe_restart("muffleWarning")
     }
 
-    local_error_context(dots = dots, .index = i, mask = mask)
-
-    warn(c(
-      cnd_bullet_header("computing"),
-      i = cnd_header(w),
-      i = cnd_bullet_cur_group_label(what = "warning")
-    ))
+    cnd_signal(rich)
 
-    # Cancel `w`
+    # Cancel `orig`
     maybe_restart("muffleWarning")
   })

This uses the newly implemented support for storing header and footer fields in condition objects (r-lib/rlang@5aefc4a7).

However this doesn't help with rmarkdown/knitr because they collect warnings and generate the message at the end of the chunk evaluation. At this point, the state necessary to generate the enriched message is gone.

So it seems like there is a conflict between our optimisation strategy for suppressWarnings() and the way knitr collects messages.