Bump version to 1.7.1

Update NEWS
Use esbuild option preserveSymlinks
2026-01-10 23:48:01 -05:00 · 2021-09-30 14:48:12 -05:00 · 2021-09-30 14:48:06 -05:00 · 2021-09-30 14:44:17 -05:00 · 2021-09-30 14:43:09 -05:00 · 2021-09-28 18:00:36 -04:00
84 changed files with 1428 additions and 854 deletions
--- a/.github/workflows/R-CMD-check.yaml
+++ b/.github/workflows/R-CMD-check.yaml
@@ -1,37 +1,73 @@
-name: R-CMD-check
+# NOTE: This workflow is overkill for most R packages
+# check-standard.yaml is likely a better choice
+# usethis::use_github_action("check-standard") will install it.
+#
+# For help debugging build failures open an issue on the RStudio community with the 'github-actions' tag.
+# https://community.rstudio.com/new-topic?category=Package%20development&tags=github-actions
 on:
  push:
    branches:
+      - main
      - master
  pull_request:
    branches:
+      - main
      - master
+      - rc-v**

+name: R-CMD-check

 jobs:

+  rversions:
+    name: R Versions
+    runs-on: ubuntu-latest
+    outputs:
+      devel:   ${{ steps.devel.outputs.installed-r-version }}
+      release: ${{ steps.release.outputs.installed-r-version }}
+      oldrel1: ${{ steps.oldrel1.outputs.installed-r-version }}
+      oldrel2: ${{ steps.oldrel2.outputs.installed-r-version }}
+      oldrel3: ${{ steps.oldrel3.outputs.installed-r-version }}
+      oldrel4: ${{ steps.oldrel4.outputs.installed-r-version }}
+    steps:
+    - { name: devel,    uses: r-lib/actions/setup-r@master, id: devel,   with: { r-version: devel,    install-r: false }}
+    - { name: release,  uses: r-lib/actions/setup-r@master, id: release, with: { r-version: release,  install-r: false }}
+    - { name: oldrel/1, uses: r-lib/actions/setup-r@master, id: oldrel1, with: { r-version: oldrel/1, install-r: false }}
+    - { name: oldrel/2, uses: r-lib/actions/setup-r@master, id: oldrel2, with: { r-version: oldrel/2, install-r: false }}
+    - { name: oldrel/3, uses: r-lib/actions/setup-r@master, id: oldrel3, with: { r-version: oldrel/3, install-r: false }}
+    - { name: oldrel/4, uses: r-lib/actions/setup-r@master, id: oldrel4, with: { r-version: oldrel/4, install-r: false }}
+
+
  R-CMD-check:
    runs-on: ${{ matrix.config.os }}

    name: ${{ matrix.config.os }} (${{ matrix.config.r }})

+    needs:
+      - rversions
    strategy:
      fail-fast: false
      matrix:
        config:
-          - {os: macOS-latest,   r: 'devel'}
-          - {os: macOS-latest,   r: '4.0'}
-          - {os: windows-latest, r: '4.0'}
-          - {os: ubuntu-16.04,   r: '4.0', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
-          - {os: ubuntu-16.04,   r: '3.6', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
-          - {os: ubuntu-16.04,   r: '3.5', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
-          - {os: ubuntu-16.04,   r: '3.4', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
-          - {os: ubuntu-16.04,   r: '3.3', rspm: "https://packagemanager.rstudio.com/cran/__linux__/xenial/latest"}
+          - {os: macOS-latest,   r: '${{ needs.rversions.outputs.release }}'}
+          - {os: windows-latest, r: '${{ needs.rversions.outputs.release }}'}
+          - {os: windows-latest, r: '3.6'}
+
+          - {os: ubuntu-20.04,   r: '${{ needs.rversions.outputs.devel }}', http-user-agent: "release" }
+          - {os: ubuntu-20.04,   r: '${{ needs.rversions.outputs.release }}'}
+          - {os: ubuntu-20.04,   r: '${{ needs.rversions.outputs.oldrel1 }}'}
+          - {os: ubuntu-20.04,   r: '${{ needs.rversions.outputs.oldrel2 }}'}
+          - {os: ubuntu-20.04,   r: '${{ needs.rversions.outputs.oldrel3 }}'}
+          - {os: ubuntu-20.04,   r: '${{ needs.rversions.outputs.oldrel4 }}'}
+
+          - {os: ubuntu-18.04,   r: '${{ needs.rversions.outputs.devel }}', http-user-agent: "release" }
+          - {os: ubuntu-18.04,   r: '${{ needs.rversions.outputs.release }}'}
+          - {os: ubuntu-18.04,   r: '${{ needs.rversions.outputs.oldrel1 }}'}
+          - {os: ubuntu-18.04,   r: '${{ needs.rversions.outputs.oldrel2 }}'}
+          - {os: ubuntu-18.04,   r: '${{ needs.rversions.outputs.oldrel3 }}'}
+          - {os: ubuntu-18.04,   r: '${{ needs.rversions.outputs.oldrel4 }}'}

    env:
-      _R_CHECK_FORCE_SUGGESTS_: false
-      R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
-      RSPM: ${{ matrix.config.rspm }}
      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}

    steps:
@@ -44,38 +80,18 @@ jobs:

      - uses: actions/checkout@v2

-      - uses: r-lib/actions/setup-r@master
+      - uses: r-lib/actions/setup-r@v1
        id: install-r
        with:
          r-version: ${{ matrix.config.r }}
+          http-user-agent: ${{ matrix.config.http-user-agent }}
+          use-public-rspm: true

-      - uses: r-lib/actions/setup-pandoc@master
+      - uses: r-lib/actions/setup-pandoc@v1

-      - name: Install pak and query dependencies
-        shell: Rscript {0}
-        run: |
-          install.packages("pak", repos = "https://r-lib.github.io/p/pak/dev/")
-          saveRDS(pak::pkg_deps_tree("local::.", dependencies = TRUE), ".github/r-depends.rds")
-
-      - name: Cache R packages
-        uses: actions/cache@v2
+      - uses: r-lib/actions/setup-r-dependencies@v1
        with:
-          path: ${{ env.R_LIBS_USER }}
-          key: ${{ matrix.config.os }}-${{ steps.install-r.outputs.installed-r-version }}-1-${{ hashFiles('.github/r-depends.rds') }}
-          restore-keys: ${{ matrix.config.os }}-${{ steps.install-r.outputs.installed-r-version }}-1-
-
-      - name: Install system dependencies
-        if: runner.os == 'Linux'
-        shell: Rscript {0}
-        run: |
-          pak::local_system_requirements(execute = TRUE)
-      
-      # https://stackoverflow.com/a/66568545/591574
-      #> fatal error: 'X11/Intrinsic.h' file not found
-      - name: Install Cairo macOS R devel dependency
-        if: runner.os == 'macOS' && matrix.config.r == 'devel'
-        run: |
-          brew install libxt
+          extra-packages: rcmdcheck

      # xquartz and cairo are needed for Cairo package.
      # harfbuzz and fribidi are needed for textshaping package.
@@ -86,20 +102,6 @@ jobs:
          brew install cairo
          brew install harfbuzz fribidi

-      # Use a shorter temp directory for pak installations, due to filename
-      # length issues on Windows. https://github.com/r-lib/pak/issues/252
-      - name: Windows temp dir
-        if: runner.os == 'Windows'
-        run: |
-          New-Item -Path "C:\" -Name "tmp" -ItemType Directory
-          echo "TMPDIR=c:\tmp" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-
-      - name: Install dependencies
-        run: |
-          pak::local_install_dev_deps(upgrade = TRUE)
-          pak::pkg_install("rcmdcheck")
-        shell: Rscript {0}
-
      - name: Find PhantomJS path
        id: phantomjs
        run: |
@@ -115,18 +117,13 @@ jobs:
          Rscript
          -e "if (!shinytest::dependenciesInstalled()) shinytest::installDependencies()"

-      - name: Session info
-        run: |
-          options(width = 100)
-          pkgs <- installed.packages()[, "Package"]
-          sessioninfo::session_info(pkgs, include_base = TRUE)
-        shell: Rscript {0}
-
      - name: Check
        env:
          _R_CHECK_CRAN_INCOMING_: false
          _R_CHECK_FORCE_SUGGESTS_: ${{ matrix.config.r != 'devel' }}
-        run: rcmdcheck::rcmdcheck(args = c("--no-manual", "--as-cran"), error_on = "warning", check_dir = "check")
+        run: |
+          options(crayon.enabled = TRUE)
+          rcmdcheck::rcmdcheck(args = c("--no-manual", "--as-cran"), error_on = "warning", check_dir = "check")
        shell: Rscript {0}

      - name: Show testthat output
@@ -136,15 +133,7 @@ jobs:

      - name: Upload check results
        if: failure()
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@main
        with:
          name: ${{ matrix.config.os }}-r${{ matrix.config.r }}-results
          path: check
-
-      - name: Fix path for Windows caching
-        if: runner.os == 'Windows'
-        # This is needed because if you use the default tar at this stage,
-        # C:/Rtools/bin/tar.exe, it will say that it can't find gzip.exe. So
-        # we'll just set the path so that the original tar that would be
-        # found, will be found.
-        run: echo "C:/Program Files/Git/usr/bin" >> $GITHUB_PATH
--- a/.github/workflows/rituals.yaml
+++ b/.github/workflows/rituals.yaml
@@ -12,15 +12,14 @@ name: Rituals
 jobs:
  rituals:
    name: Rituals
-    # if: false
-    runs-on: ${{ matrix.config.os }}

+    runs-on: ${{ matrix.config.os }}

    strategy:
      fail-fast: false
      matrix:
        config:
-        - { os: ubuntu-16.04, r: '4.0', node: "14.x", rspm: "https://packagemanager.rstudio.com/all/__linux__/xenial/latest"}
+        - { os: ubuntu-20.04, r: 'release', node: "14.x", rspm: "https://packagemanager.rstudio.com/all/__linux__/focal/latest"}

    env:
      R_REMOTES_NO_ERRORS_FROM_WARNINGS: true
@@ -159,9 +158,9 @@ jobs:
        if: github.event_name == 'push'
        run: |
          # Can't push to a protected branch
-          if [ -z "`git cherry`"]; then
+          if [ -n "`git cherry origin/master`" ]; then
            echo "Un-pushed commits:"
-            git cherry -v
+            git cherry -v origin/master
            echo "\nCan not push to a protected branch. Exiting"
            exit 1
          fi
@@ -169,5 +168,4 @@ jobs:
      # Execute after pushing, as no updated files will be produced
      - name: Test TypeScript code
        run: |
-          cd srcts
          yarn test
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,7 @@ README.html
 tools/yarn-error.log

 # TypeScript / yarn
-node_modules/
+/node_modules/
 .cache
 .yarn/*
 !.yarn/releases
--- a/12
+++ b/12
@@ -1,7 +1,7 @@
 Package: shiny
 Type: Package
 Title: Web Application Framework for R
-Version: 1.6.0.9021
+Version: 1.7.1
 Authors@R: c(
    person("Winston", "Chang", role = c("aut", "cre"), email = "winston@rstudio.com", comment = c(ORCID = "0000-0002-1576-2126")),
    person("Joe", "Cheng", role = "aut", email = "joe@rstudio.com"),
@@ -79,7 +79,7 @@ Imports:
    jsonlite (>= 0.9.16),
    xtable,
    fontawesome (>= 0.2.1),
-    htmltools (>= 0.5.1.9003),
+    htmltools (>= 0.5.2),
    R6 (>= 2.0),
    sourcetools,
    later (>= 1.0.0),
@@ -91,7 +91,7 @@ Imports:
    withr,
    commonmark (>= 1.7),
    glue (>= 1.3.2),
-    bslib (>= 0.2.5.9002),
+    bslib (>= 0.3.0),
    cachem,
    ellipsis,
    lifecycle (>= 0.2.0)
@@ -112,10 +112,6 @@ Suggests:
    ragg,
    showtext,
    sass
-Remotes:
-    r-lib/rlang,
-    rstudio/bslib,
-    rstudio/htmltools
 URL: https://shiny.rstudio.com/
 BugReports: https://github.com/rstudio/shiny/issues
 Collate:
@@ -205,7 +201,7 @@ Collate:
    'version_selectize.R'
    'version_strftime.R'
    'viewer.R'
-RoxygenNote: 7.1.1
+RoxygenNote: 7.1.2
 Encoding: UTF-8
 Roxygen: list(markdown = TRUE)
 RdMacros: lifecycle
--- a/9
+++ b/9
@@ -378,6 +378,7 @@ importFrom(htmltools,tags)
 importFrom(htmltools,validateCssUnit)
 importFrom(htmltools,withTags)
 importFrom(lifecycle,deprecated)
+importFrom(lifecycle,is_present)
 importFrom(promises,"%...!%")
 importFrom(promises,"%...>%")
 importFrom(promises,as.promise)
@@ -386,14 +387,18 @@ importFrom(promises,promise)
 importFrom(promises,promise_reject)
 importFrom(promises,promise_resolve)
 importFrom(rlang,"%||%")
+importFrom(rlang,"fn_body<-")
+importFrom(rlang,"fn_fmls<-")
 importFrom(rlang,as_function)
 importFrom(rlang,as_quosure)
 importFrom(rlang,enexpr)
 importFrom(rlang,enquo)
+importFrom(rlang,enquo0)
 importFrom(rlang,enquos)
 importFrom(rlang,enquos0)
 importFrom(rlang,eval_tidy)
 importFrom(rlang,expr)
+importFrom(rlang,fn_body)
 importFrom(rlang,get_env)
 importFrom(rlang,get_expr)
 importFrom(rlang,inject)
@@ -408,4 +413,8 @@ importFrom(rlang,new_function)
 importFrom(rlang,new_quosure)
 importFrom(rlang,pairlist2)
 importFrom(rlang,quo)
+importFrom(rlang,quo_get_expr)
+importFrom(rlang,quo_is_missing)
+importFrom(rlang,quo_set_env)
+importFrom(rlang,quo_set_expr)
 importFrom(rlang,zap_srcref)
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,9 +1,15 @@
-Addresses #2521: Updated the list of TCP ports that will [be rejected](https://chromium.googlesource.com/chromium/src.git/+/refs/heads/main/net/base/port_util.cc)
-by default in runapp.R, adding 5060, 5061 and 6566. Added documentation describing the port range (3000:8000)
-and which ports are rejected. 
+shiny 1.7.1
+===========

-shiny 1.6.0.9000
-================
+## Bug Fixes
+
+* Closed #3516: Fix regression in repeated calls to `appendTab()` when `navbarMenu()` is already present within a `tabsetPanel()`/`navbarPage()`. (#3518)
+
+* Re-arranged conditions for testthat 1.0.0 compatibility. (#3512)
+
+
+shiny 1.7.0
+===========

 ## Full changelog

@@ -21,13 +27,17 @@ shiny 1.6.0.9000
 * Closed #3322, #3313, #1823, #3321, #3320, #1928, and #2310: Various improvements to `navbarPage()`, `tabsetPanel()`, `tabPanel()`, `navbarMenu()`, etc. Also, these functions are now powered by the `{bslib}` package's new `nav()` API (consider using `{bslib}`'s API to create better looking and more fully featured navs). (#3388)

 * All uses of `list(...)` have been replaced with `rlang::list2(...)`. This means that you can use trailing `,` without error and use rlang's `!!!` operator to "splice" a list of argument values into `...`. We think this'll be particularly useful for passing a list of `tabPanel()` to their consumers (i.e., `tabsetPanel()`, `navbarPage()`, etc). For example, `tabs <- list(tabPanel("A", "a"), tabPanel("B", "b")); navbarPage(!!!tabs)`. (#3315 and #3328)
-  
+
+* `installExprFunction()` and `exprToFunction()` are now able to handle quosures when `quoted = TRUE`. So `render`-functions which call these functions (such as with `htmlwidgets`) can now understand quosures. Users can also use `rlang::inject()` to unquote a quosure for evaluation.  This also means that `render` function no longer need `env` and `quoted` parameters; that information can be embedded into a quosure which is then passed to the `render` function. Better documentation was added for how to create `render` functions. (#3472)
+
 * `icon(lib="fontawesome")` is now powered by the `{fontawesome}` package, which will make it easier to use the latest FA icons in the future (by updating the `{fontawesome}` package). (#3302)

 * Closed #3397: `renderPlot()` new uses `ggplot2::get_alt_text()` to inform an `alt` text default (for `{ggplot2}` plots). (#3398)

 * `modalDialog()` gains support for `size = "xl"`. (#3410)

+* Addressed #2521: Updated the list of TCP ports that will be rejected by default in runapp.R, adding 5060, 5061 and 6566. Added documentation describing the port range (3000:8000) and which ports are rejected. (#3456)
+
 ### Other improvements

 * Shiny's core JavaScript code was converted to TypeScript. For the latest development information, please see the [README.md in `./srcts`](https://github.com/rstudio/shiny/tree/master/srcts). (#3296)
@@ -42,10 +52,14 @@ shiny 1.6.0.9000

 * Closed #3345: Shiny now correctly renders `htmltools::htmlDependency()`(s) with a `list()` of `script` attributes when used in a dynamic UI context. This fairly new `htmlDependency()` feature was added in `{htmltools}` v0.5.1. (#3395)

-* Closed #3374: `quoToFunction()` now works correctly with nested quosures; and as a result, quasi-quotation with rendering function (e.g., `renderPrint()`, `renderPlot()`, etc) now works as expected with nested quosures. (#3373) 
+* Fixed [#2666](https://github.com/rstudio/shiny/issues/2666) and [#2670](https://github.com/rstudio/shiny/issues/2670): `nearPoints()` and `brushedPoints()` weren't properly account for missing values (#2666 was introduced in v1.4.0). ([#2668](https://github.com/rstudio/shiny/pull/2668))
+
+* Closed #3374: `quoToFunction()` now works correctly with nested quosures; and as a result, quasi-quotation with rendering function (e.g., `renderPrint()`, `renderPlot()`, etc) now works as expected with nested quosures. (#3373)

 * Exported `register_devmode_option()`. This method was described in the documentation for `devmode()` but was never exported. See `?devmode()` for more details on how to register Shiny Developer options using `register_devmode_option()`. (#3364)

+* Closed #3484: In the RStudio IDE on Mac 11.5, selected checkboxes and radio buttons were not visible. (#3485)
+
 ### Library updates

 * Closed #3286: Updated to Font-Awesome 5.15.2. (#3288)
@@ -59,7 +73,7 @@ This release focuses on improvements in three main areas:

 1. Better theming (and Bootstrap 4) support:
  * The `theme` argument of `fluidPage()`, `navbarPage()`, and `bootstrapPage()` all now understand `bslib::bs_theme()` objects, which can be used to opt-into Bootstrap 4, use any Bootswatch theme, and/or implement custom themes without writing any CSS.
-  * The `session` object now includes `$setCurrentTheme()` and `$getCurrentTheme()` methods to dynamically update (or obtain) the page's `theme` after initial load, which is useful for things such as [adding a dark mode switch to an app](https://rstudio.github.io/bslib/articles/theming.html#dynamic-shiny) or some other "real-time" theming tool like `bslib::bs_themer()`.
+  * The `session` object now includes `$setCurrentTheme()` and `$getCurrentTheme()` methods to dynamically update (or obtain) the page's `theme` after initial load, which is useful for things such as [adding a dark mode switch to an app](https://rstudio.github.io/bslib/articles/bslib.html#dynamic) or some other "real-time" theming tool like `bslib::bs_themer()`.
  * For more details, see [`{bslib}`'s website](https://rstudio.github.io/bslib/)

 2. Caching of `reactive()` and `render*()` (e.g. `renderText()`, `renderTable()`, etc) expressions.
@@ -181,7 +195,7 @@ shiny 1.5.0

 * The new `moduleServer` function provides a simpler interface for creating and using modules. (#2773)

-* Resolved #2732: `markdown()` is a new function for writing Markdown with Github extensions directly in Shiny UIs. Markdown rendering is performed by the [commonmark](https://github.com/jeroen/commonmark) package. (#2737)
+* Resolved #2732: `markdown()` is a new function for writing Markdown with Github extensions directly in Shiny UIs. Markdown rendering is performed by the [commonmark](https://github.com/r-lib/commonmark) package. (#2737)

 * The `getCurrentOutputInfo()` function can now return the background color (`bg`), foreground color (`fg`), `accent` (i.e., hyperlink) color, and `font` information of the output's HTML container. This information is reported by `plotOutput()`, `imageOutput()`, and any other output bindings containing a class of `.shiny-report-theme`. This feature allows developers to style an output's contents based on the container's CSS styling.  (#2740)

--- a/R/bind-cache.R
+++ b/R/bind-cache.R
@@ -255,7 +255,7 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   the cache.
 #'
 #'   You may need to provide a `cacheHint` to [createRenderFunction()] (or
-#'   [htmlwidgets::shinyRenderWidget()], if you've authored an htmlwidget) in
+#'   `htmlwidgets::shinyRenderWidget()`, if you've authored an htmlwidget) in
 #'   order for `bindCache()` to correctly compute a cache key.
 #'
 #'   The potential problem is a cache collision. Consider the following:
@@ -292,11 +292,11 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   In some cases, however, the automatic cache hint inference is not
 #'   sufficient, and it is necessary to provide a cache hint. This is true
 #'   for `renderPrint()`. Unlike `renderText()`, it wraps the user-provided
-#'   expression in another function, before passing it to [markRenderFunction()]
+#'   expression in another function, before passing it to [createRenderFunction()]
 #'   (instead of [createRenderFunction()]). Because the user code is wrapped in
-#'   another function, `markRenderFunction()` is not able to automatically
+#'   another function, `createRenderFunction()` is not able to automatically
 #'   extract the user-provided code and use it in the cache key. Instead,
-#'   `renderPrint` calls `markRenderFunction()`, it explicitly passes along a
+#'   `renderPrint` calls `createRenderFunction()`, it explicitly passes along a
 #'   `cacheHint`, which includes a label and the original user expression.
 #'
 #'   In general, if you need to provide a `cacheHint`, it is best practice to
@@ -310,19 +310,19 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'
 #'   ```
 #'   renderMyWidget <- function(expr) {
-#'     expr <- substitute(expr)
+#'     q <- rlang::enquo0(expr)
 #'
-#'     htmlwidgets::shinyRenderWidget(expr,
+#'     htmlwidgets::shinyRenderWidget(
+#'       q,
 #'       myWidgetOutput,
 #'       quoted = TRUE,
-#'       env = parent.frame(),
-#'       cacheHint = list(label = "myWidget", userExpr = expr)
+#'       cacheHint = list(label = "myWidget", userQuo = q)
 #'     )
 #'   }
 #'   ```
 #'
 #'   If your `render` function sets any internal state, you may find it useful
-#'   in your call to [createRenderFunction()] or [markRenderFunction()] to use
+#'   in your call to [createRenderFunction()] to use
 #'   the `cacheWriteHook` and/or `cacheReadHook` parameters. These hooks are
 #'   functions that run just before the object is stored in the cache, and just
 #'   after the object is retrieved from the cache. They can modify the data
@@ -339,8 +339,8 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   effects or modify some external state, and they must re-execute each time
 #'   in order to work properly.
 #'
-#'   For developers of such code, they should call [createRenderFunction()] or
-#'   [markRenderFunction()] with `cacheHint = FALSE`.
+#'   For developers of such code, they should call [createRenderFunction()] (or
+#'   [markRenderFunction()]) with `cacheHint = FALSE`.
 #'
 #'
 #' @section Caching with `renderPlot()`:
--- a/R/deprecated.R
+++ b/R/deprecated.R
@@ -9,13 +9,19 @@
 #' @param details Additional information to be added after a new line to the displayed message
 #' @keywords internal
 shinyDeprecated <- function(
-  version, what, with = NULL, details = NULL
+  version,
+  what,
+  with = NULL,
+  details = NULL,
+  type = c("deprecated", "superseded")
 ) {
  if (is_false(getOption("shiny.deprecation.messages"))) {
    return(invisible())
  }

-  msg <- paste0("`", what, "` is deprecated as of shiny ", version, ".")
+  type <- match.arg(type)
+
+  msg <- paste0("`", what, "` is ", type, " as of shiny ", version, ".")
  if (!is.null(with)) {
    msg <- paste0(msg, "\n", "Please use `", with, "` instead.")
  }
@@ -32,13 +38,20 @@ deprecatedEnvQuotedMessage <- function() {
  if (!in_devmode()) return(invisible())
  if (is_false(getOption("shiny.deprecation.messages"))) return(invisible())

-  # manually
+  # Capture calling function
+  grandparent_call <- sys.call(-2)
+  # Turn language into user friendly string
+  grandparent_txt <- paste0(utils::capture.output({grandparent_call}), collapse = "\n")
+
  msg <- paste0(
-    "The `env` and `quoted` arguments are deprecated as of shiny 1.6.0.",
+    "The `env` and `quoted` arguments are deprecated as of shiny 1.7.0.",
    " Please use quosures from `rlang` instead.\n",
-    "See <https://github.com/rstudio/shiny/issues/3108> for more information."
+    "See <https://github.com/rstudio/shiny/issues/3108> for more information.\n",
+    "Function call:\n",
+    grandparent_txt
  )
-  rlang::inform(message = msg, .frequency = "always", .frequency_id = msg, .file = stderr())
+  # Call less often as users do not have much control over this warning
+  rlang::inform(message = msg, .frequency = "regularly", .frequency_id = msg, .file = stderr())
 }


@@ -60,7 +73,7 @@ diskCache <- function(
  logfile = NULL
 ) {
  shinyDeprecated("1.6.0", "diskCache()", "cachem::cache_disk()")
-  if (lifecycle::is_present(exec_missing)) {
+  if (is_present(exec_missing)) {
    shinyDeprecated("1.6.0", "diskCache(exec_missing =)")
  }

@@ -93,7 +106,7 @@ memoryCache <- function(
  logfile = NULL)
 {
  shinyDeprecated("1.6.0", "diskCache()", "cachem::cache_mem()")
-  if (lifecycle::is_present(exec_missing)) {
+  if (is_present(exec_missing)) {
    shinyDeprecated("1.6.0", "diskCache(exec_missing =)")
  }

--- a/R/graph.R
+++ b/R/graph.R
@@ -512,7 +512,7 @@ MessageLogger = R6Class(
      return(txt)
    },
    singleLine = function(txt) {
-      gsub("[^\\]\\n", "\\\\n", txt)
+      gsub("([^\\])\\n", "\\1\\\\n", txt)
    },
    valueStr = function(valueStr) {
      paste0(
--- a/R/image-interact-opts.R
+++ b/R/image-interact-opts.R
@@ -20,7 +20,6 @@
 #'   `delay` milliseconds before sending an event.
 #' @seealso [brushOpts()] for brushing events.
 #' @export
-#' @keywords internal
 clickOpts <- function(id, clip = TRUE) {
  if (is.null(id))
    stop("id must not be NULL")
--- a/R/image-interact.R
+++ b/R/image-interact.R
@@ -267,6 +267,7 @@ nearPoints <- function(df, coordinfo, xvar = NULL, yvar = NULL,
    stop("nearPoints: `yvar` ('", yvar ,"')  not in names of input")

  # Extract data values from the data frame
+  coordinfo <- fortifyDiscreteLimits(coordinfo)
  x <- asNumber(df[[xvar]], coordinfo$domain$discrete_limits$x)
  y <- asNumber(df[[yvar]], coordinfo$domain$discrete_limits$y)

@@ -392,6 +393,7 @@ nearPoints <- function(df, coordinfo, xvar = NULL, yvar = NULL,
 # an input brush
 within_brush <- function(vals, brush, var = "x") {
  var <- match.arg(var, c("x", "y"))
+  brush <- fortifyDiscreteLimits(brush)
  vals <- asNumber(vals, brush$domain$discrete_limits[[var]])
  # It's possible for a non-missing data values to not
  # map to the axis limits, for example:
@@ -414,11 +416,43 @@ asNumber <- function(x, levels = NULL) {
  as.numeric(x)
 }

+# Ensure the discrete limits/levels of a coordmap received
+# from the client matches the data structure sent the client.
+#
+# When we construct the coordmap (in getGgplotCoordmap()),
+# we save a character vector which may contain missing values
+# (e.g., c("a", "b", NA)). When that same character is received
+# from the client, it runs through decodeMessage() which sets
+# simplifyVector=FALSE, which means NA are replaced by NULL
+# (because jsonlite::fromJSON('["a", "b", null]') -> list("a", "b", NULL))
+#
+# Thankfully, it doesn't seem like it's meaningful for limits to
+# contains a NULL in the 1st place, so we simply treat NULL like NA.
+# For more context, https://github.com/rstudio/shiny/issues/2666
+fortifyDiscreteLimits <- function(coord) {
+  # Note that discrete_limits$x/y are populated iff
+  # x/y are discrete mappings
+  coord$domain$discrete_limits <- lapply(
+    coord$domain$discrete_limits,
+    function(var) {
+      # if there is an 'explicit' NULL, then the limits are NA
+      if (is.null(var)) return(NA)
+      vapply(var, function(x) {
+        if (is.null(x) || isTRUE(is.na(x))) NA_character_ else x
+      }, character(1))
+    }
+  )
+  coord
+}
+
+
+
 # Given a panelvar value and a vector x, return logical vector indicating which
 # items match the panelvar value. Because the panelvar value is always a
 # string but the vector could be numeric, it might be necessary to coerce the
 # panelvar to a number before comparing to the vector.
 panelMatch <- function(search_value, x) {
+  if (is.null(search_value)) return(is.na(x))
  if (is.numeric(x)) search_value <- as.numeric(search_value)
  x == search_value
 }
--- a/R/knitr.R
+++ b/R/knitr.R
@@ -4,6 +4,7 @@
 #' themselves in knitr/rmarkdown documents.
 #'
 #' @name knitr_methods
+#' @keywords internal
 #' @param x Object to knit_print
 #' @param ... Additional knit_print arguments
 NULL
--- a/R/map.R
+++ b/R/map.R
@@ -1,4 +1,3 @@
-#' @importFrom fastmap fastmap
 Map <- R6Class(
  'Map',
  portable = FALSE,
--- a/R/reactives.R
+++ b/R/reactives.R
@@ -875,8 +875,7 @@ Observable <- R6Class(
        invisible(.value)
    },
    format = function() {
-      label <- sprintf('reactive(%s)', paste(deparse(body(.origFunc)), collapse='\n'))
-      strsplit(label, "\n")[[1]]
+      simpleExprToFunction(fn_body(.origFunc), "reactive")
    },
    .updateValue = function() {
      ctx <- Context$new(.domain, .label, type = 'observable',
@@ -945,14 +944,15 @@ Observable <- R6Class(
 #' See the [Shiny tutorial](https://shiny.rstudio.com/tutorial/) for
 #' more information about reactive expressions.
 #'
-#' @param x For `reactive`, an expression (quoted or unquoted). For
-#'   `is.reactive`, an object to test.
-#' @param env The parent environment for the reactive expression. By default,
-#'   this is the calling environment, the same as when defining an ordinary
-#'   non-reactive expression.
-#' @param quoted Is the expression quoted? By default, this is `FALSE`.
-#'   This is useful when you want to use an expression that is stored in a
-#'   variable; to do so, it must be quoted with `quote()`.
+#' @param x For `is.reactive()`, an object to test. For `reactive()`, an expression. When passing in a [`quo()`]sure with `reactive()`, remember to use [`rlang::inject()`] to distinguish that you are passing in the content of your quosure, not the expression of the quosure.
+#' @template param-env
+#' @templateVar x x
+#' @templateVar env env
+#' @templateVar quoted quoted
+#' @template param-quoted
+#' @templateVar x x
+#' @templateVar quoted quoted
+
 #' @param label A label for the reactive expression, useful for debugging.
 #' @param domain See [domains].
 #' @param ..stacktraceon Advanced use only. For stack manipulation purposes; see
@@ -961,46 +961,56 @@ Observable <- R6Class(
 #' @return a function, wrapped in a S3 class "reactive"
 #'
 #' @examples
+#' library(rlang)
 #' values <- reactiveValues(A=1)
 #'
 #' reactiveB <- reactive({
 #'   values$A + 1
 #' })
-#'
-#' # Can use quoted expressions
-#' reactiveC <- reactive(quote({ values$A + 2 }), quoted = TRUE)
-#'
-#' # To store expressions for later conversion to reactive, use quote()
-#' expr_q <- quote({ values$A + 3 })
-#' reactiveD <- reactive(expr_q, quoted = TRUE)
-#'
 #' # View the values from the R console with isolate()
 #' isolate(reactiveB())
+#' # 2
+#'
+#' # To store expressions for later conversion to reactive, use quote()
+#' myquo <- rlang::quo(values$A + 2)
+#' # Unexpected value! Sending a quosure directly will not work as expected.
+#' reactiveC <- reactive(myquo)
+#' # We'd hope for `3`, but instead we get the quosure that was supplied.
 #' isolate(reactiveC())
+#'
+#' # Instead, the quosure should be `rlang::inject()`ed
+#' reactiveD <- rlang::inject(reactive(!!myquo))
 #' isolate(reactiveD())
+#' # 3
+#'
+#' # (Legacy) Can use quoted expressions
+#' expr <- quote({ values$A + 3 })
+#' reactiveE <- reactive(expr, quoted = TRUE)
+#' isolate(reactiveE())
+#' # 4
+#'
 #' @export
-reactive <- function(x, env = parent.frame(), quoted = FALSE,
+reactive <- function(
+  x,
+  env = parent.frame(),
+  quoted = FALSE,
  ...,
  label = NULL,
  domain = getDefaultReactiveDomain(),
-  ..stacktraceon = TRUE)
-{
+  ..stacktraceon = TRUE
+) {
  check_dots_empty()

-  x <- get_quosure(x, env, quoted)
-  fun <- as_function(x)
-  # as_function returns a function that takes `...`. We need one that takes no
-  # args.
-  formals(fun) <- list()
-
+  func <- installExprFunction(x, "func", env, quoted, wrappedWithLabel = FALSE)
  # Attach a label and a reference to the original user source for debugging
-  label <- exprToLabel(get_expr(x), "reactive", label)
+  userExpr <- fn_body(func)
+  label <- exprToLabel(userExpr, "reactive", label)

-  o <- Observable$new(fun, label, domain, ..stacktraceon = ..stacktraceon)
+  o <- Observable$new(func, label, domain, ..stacktraceon = ..stacktraceon)
  structure(
    o$getValue,
    observable = o,
-    cacheHint = list(userExpr = zap_srcref(get_expr(x))),
+    cacheHint = list(userExpr = zap_srcref(userExpr)),
    class = c("reactiveExpr", "reactive", "function")
  )
 }
@@ -1325,12 +1335,7 @@ Observer <- R6Class(
 #'
 #' @param x An expression (quoted or unquoted). Any return value will be
 #'   ignored.
-#' @param env The parent environment for the reactive expression. By default,
-#'   this is the calling environment, the same as when defining an ordinary
-#'   non-reactive expression.
-#' @param quoted Is the expression quoted? By default, this is `FALSE`.
-#'   This is useful when you want to use an expression that is stored in a
-#'   variable; to do so, it must be quoted with `quote()`.
+#' @inheritParams reactive
 #' @param label A label for the observer, useful for debugging.
 #' @param suspended If `TRUE`, start the observer in a suspended state. If
 #'   `FALSE` (the default), start in a non-suspended state.
@@ -1389,18 +1394,21 @@ Observer <- R6Class(
 #'   print(values$A + 1)
 #' })
 #'
-#' # Can use quoted expressions
-#' obsC <- observe(quote({ print(values$A + 2) }), quoted = TRUE)
+#' # To store expressions for later conversion to observe, use rlang::quo()
+#' myquo <- rlang::quo({ print(values$A + 3) })
+#' obsC <- rlang::inject(observe(!!myquo))
 #'
-#' # To store expressions for later conversion to observe, use quote()
-#' expr_q <- quote({ print(values$A + 3) })
-#' obsD <- observe(expr_q, quoted = TRUE)
+#' # (Legacy) Can use quoted expressions
+#' obsD <- observe(quote({ print(values$A + 2) }), quoted = TRUE)
 #'
 #' # In a normal Shiny app, the web client will trigger flush events. If you
 #' # are at the console, you can force a flush with flushReact()
 #' shiny:::flushReact()
 #' @export
-observe <- function(x, env = parent.frame(), quoted = FALSE,
+observe <- function(
+  x,
+  env = parent.frame(),
+  quoted = FALSE,
  ...,
  label = NULL,
  suspended = FALSE,
@@ -1411,18 +1419,11 @@ observe <- function(x, env = parent.frame(), quoted = FALSE,
 {
  check_dots_empty()

-  x <- get_quosure(x, env, quoted)
-  fun <- as_function(x)
-  # as_function returns a function that takes `...`. We need one that takes no
-  # args.
-  formals(fun) <- list()
-
-  if (is.null(label)) {
-    label <- sprintf('observe(%s)', paste(deparse(get_expr(x)), collapse='\n'))
-  }
+  func <- installExprFunction(x, "func", env, quoted)
+  label <- funcToLabel(func, "observe", label)

  o <- Observer$new(
-    fun,
+    func,
    label = label,
    suspended = suspended,
    priority = priority,
@@ -2144,23 +2145,30 @@ maskReactiveContext <- function(expr) {
 #' @param valueExpr The expression that produces the return value of the
 #'   `eventReactive`. It will be executed within an [isolate()]
 #'   scope.
-#' @param event.env The parent environment for `eventExpr`. By default,
-#'   this is the calling environment.
-#' @param event.quoted Is the `eventExpr` expression quoted? By default,
-#'   this is `FALSE`. This is useful when you want to use an expression
-#'   that is stored in a variable; to do so, it must be quoted with
-#'   `quote()`.
-#' @param handler.env The parent environment for `handlerExpr`. By default,
-#'   this is the calling environment.
-#' @param handler.quoted Is the `handlerExpr` expression quoted? By
-#'   default, this is `FALSE`. This is useful when you want to use an
-#'   expression that is stored in a variable; to do so, it must be quoted with
-#'   `quote()`.
-#' @param value.env The parent environment for `valueExpr`. By default,
-#'   this is the calling environment.
-#' @param value.quoted Is the `valueExpr` expression quoted? By default,
-#'   this is `FALSE`. This is useful when you want to use an expression
-#'   that is stored in a variable; to do so, it must be quoted with `quote()`.
+#' @param event.env The parent environment for the reactive expression. By default,
+#'   this is the calling environment, the same as when defining an ordinary
+#'   non-reactive expression. If `eventExpr` is a quosure and `event.quoted` is `TRUE`,
+#'   then `event.env` is ignored.
+#' @param event.quoted If it is `TRUE`, then the [`quote()`]ed value of `eventExpr`
+#'   will be used when `eventExpr` is evaluated. If `eventExpr` is a quosure and you
+#'   would like to use its expression as a value for `eventExpr`, then you must set
+#'  `event.quoted` to `TRUE`.
+#' @param handler.env The parent environment for the reactive expression. By default,
+#'   this is the calling environment, the same as when defining an ordinary
+#'   non-reactive expression. If `handlerExpr` is a quosure and `handler.quoted` is `TRUE`,
+#'   then `handler.env` is ignored.
+#' @param handler.quoted If it is `TRUE`, then the [`quote()`]ed value of `handlerExpr`
+#'   will be used when `handlerExpr` is evaluated. If `handlerExpr` is a quosure and you
+#'   would like to use its expression as a value for `handlerExpr`, then you must set
+#'  `handler.quoted` to `TRUE`.
+#' @param value.env The parent environment for the reactive expression. By default,
+#'   this is the calling environment, the same as when defining an ordinary
+#'   non-reactive expression. If `valueExpr` is a quosure and `value.quoted` is `TRUE`,
+#'   then `value.env` is ignored.
+#' @param value.quoted If it is `TRUE`, then the [`quote()`]ed value of `valueExpr`
+#'   will be used when `valueExpr` is evaluated. If `valueExpr` is a quosure and you
+#'   would like to use its expression as a value for `valueExpr`, then you must set
+#'  `value.quoted` to `TRUE`.
 #' @param label A label for the observer or reactive, useful for debugging.
 #' @param suspended If `TRUE`, start the observer in a suspended state. If
 #'   `FALSE` (the default), start in a non-suspended state.
@@ -2274,15 +2282,13 @@ observeEvent <- function(eventExpr, handlerExpr,
 {
  check_dots_empty()

-  eventExpr   <- get_quosure(eventExpr,   event.env,   event.quoted)
-  handlerExpr <- get_quosure(handlerExpr, handler.env, handler.quoted)
+  eventQ <- exprToQuo(eventExpr, event.env, event.quoted)
+  handlerQ <- exprToQuo(handlerExpr, handler.env, handler.quoted)

-  if (is.null(label)) {
-    label <- sprintf('observeEvent(%s)', paste(deparse(get_expr(eventExpr)), collapse='\n'))
-  }
+  label <- quoToLabel(eventQ, "observeEvent", label)

  handler <- inject(observe(
-    !!handlerExpr,
+    !!handlerQ,
    label = label,
    suspended = suspended,
    priority = priority,
@@ -2296,7 +2302,7 @@ observeEvent <- function(eventExpr, handlerExpr,
    ignoreInit = ignoreInit,
    once = once,
    label = label,
-    !!eventExpr,
+    !!eventQ,
    x = handler
  ))

@@ -2314,19 +2320,17 @@ eventReactive <- function(eventExpr, valueExpr,
 {
  check_dots_empty()

-  eventExpr <- get_quosure(eventExpr, event.env, event.quoted)
-  valueExpr <- get_quosure(valueExpr, value.env, value.quoted)
+  eventQ <- exprToQuo(eventExpr, event.env, event.quoted)
+  valueQ <- exprToQuo(valueExpr, value.env, value.quoted)

-  if (is.null(label)) {
-    label <- sprintf('eventReactive(%s)', paste(deparse(get_expr(eventExpr)), collapse='\n'))
-  }
+  label <- quoToLabel(eventQ, "eventReactive", label)

  invisible(inject(bindEvent(
    ignoreNULL = ignoreNULL,
    ignoreInit = ignoreInit,
    label = label,
-    !!eventExpr,
-    x = reactive(!!valueExpr, domain = domain, label = label)
+    !!eventQ,
+    x = reactive(!!valueQ, domain = domain, label = label)
  )))
 }

--- a/R/reexports.R
+++ b/R/reexports.R
@@ -1,6 +1,6 @@
 ####
-# Generated by `./tools/updateReexports.R`: do not edit by hand
-# Please call `source('tools/updateReexports.R') from the root folder to update`
+# Generated by `./tools/documentation/updateReexports.R`: do not edit by hand
+# Please call `source('tools/documentation/updateReexports.R')` from the root folder to update`
 ####


@@ -90,17 +90,20 @@ htmltools::em
 #' @export
 htmltools::hr

-
-# htmltools tag.Rd -------------------------------------------------------------
-
 #' @importFrom htmltools tag
 #' @export
 htmltools::tag

+
+# htmltools tagList.Rd ---------------------------------------------------------
+
 #' @importFrom htmltools tagList
 #' @export
 htmltools::tagList

+
+# htmltools tagAppendAttributes.Rd ---------------------------------------------
+
 #' @importFrom htmltools tagAppendAttributes
 #' @export
 htmltools::tagAppendAttributes
@@ -113,6 +116,9 @@ htmltools::tagHasAttribute
 #' @export
 htmltools::tagGetAttribute

+
+# htmltools tagAppendChild.Rd --------------------------------------------------
+
 #' @importFrom htmltools tagAppendChild
 #' @export
 htmltools::tagAppendChild
--- a/R/render-cached-plot.R
+++ b/R/render-cached-plot.R
@@ -181,7 +181,7 @@
 #' # At the top of app.R, this set the application-scoped cache to be a disk
 #' # cache that can be shared among multiple concurrent R processes, and is
 #' # deleted when the system reboots.
-#' shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache"))
+#' shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache")))
 #'
 #' # At the top of app.R, this set the application-scoped cache to be a disk
 #' # cache that can be shared among multiple concurrent R processes, and
--- a/R/render-plot.R
+++ b/R/render-plot.R
@@ -46,9 +46,7 @@
 #'   decorative images.
 #' @param ... Arguments to be passed through to [grDevices::png()].
 #'   These can be used to set the width, height, background color, etc.
-#' @param env The environment in which to evaluate `expr`.
-#' @param quoted Is `expr` a quoted expression (with `quote()`)? This
-#'   is useful if you want to save an expression in a variable.
+#' @inheritParams renderUI
 #' @param execOnResize If `FALSE` (the default), then when a plot is
 #'   resized, Shiny will *replay* the plot drawing commands with
 #'   [grDevices::replayPlot()] instead of re-executing `expr`.
@@ -65,10 +63,13 @@ renderPlot <- function(expr, width = 'auto', height = 'auto', res = 72, ...,
                       execOnResize = FALSE, outputArgs = list()
 ) {

-  expr <- get_quosure(expr, env, quoted)
-  # This ..stacktraceon is matched by a ..stacktraceoff.. when plotFunc
-  # is called
-  func <- quoToFunction(expr, "renderPlot", ..stacktraceon = TRUE)
+  func <- installExprFunction(
+    expr, "func", env, quoted,
+    label = "renderPlot",
+    # This ..stacktraceon is matched by a ..stacktraceoff.. when plotFunc
+    # is called
+    ..stacktraceon = TRUE
+  )

  args <- list(...)

@@ -186,7 +187,7 @@ renderPlot <- function(expr, width = 'auto', height = 'auto', res = 72, ...,
    outputFunc,
    renderFunc,
    outputArgs,
-    cacheHint = list(userExpr = get_expr(expr), res = res)
+    cacheHint = list(userExpr = installedFuncExpr(func), res = res)
  )
  class(markedFunc) <- c("shiny.renderPlot", class(markedFunc))
  markedFunc
--- a/R/render-table.R
+++ b/R/render-table.R
@@ -42,9 +42,7 @@
 #'   (i.e. they either evaluate to `NA` or `NaN`).
 #' @param ... Arguments to be passed through to [xtable::xtable()]
 #'   and [xtable::print.xtable()].
-#' @param env The environment in which to evaluate `expr`.
-#' @param quoted Is `expr` a quoted expression (with `quote()`)?
-#'   This is useful if you want to save an expression in a variable.
+#' @inheritParams renderUI
 #' @param outputArgs A list of arguments to be passed through to the
 #'   implicit call to [tableOutput()] when `renderTable` is
 #'   used in an interactive R Markdown document.
@@ -74,8 +72,7 @@ renderTable <- function(expr, striped = FALSE, hover = FALSE,
                        env = parent.frame(), quoted = FALSE,
                        outputArgs=list())
 {
-  expr <- get_quosure(expr, env, quoted)
-  func <- quoToFunction(expr, "renderTable")
+  func <- installExprFunction(expr, "func", env, quoted, label = "renderTable")

  if (!is.function(spacing)) spacing <- match.arg(spacing)

--- a/R/serializers.R
+++ b/R/serializers.R
@@ -5,7 +5,6 @@
 #'   value. The returned value will be used for the test snapshot.
 #' @param session A Shiny session object.
 #'
-#' @keywords internal
 #' @export
 setSerializer <- function(inputId, fun, session = getDefaultReactiveDomain()) {
  if (is.null(session)) {
--- a/R/server-input-handlers.R
+++ b/R/server-input-handlers.R
@@ -41,12 +41,12 @@ inputHandlers <- Map$new()
 #' })
 #'
 #' ## On the Javascript side, the associated input binding must have a corresponding getType method:
-#' getType: function(el) {
-#'   return "mypackage.validint";
-#' }
+#' # getType: function(el) {
+#' #   return "mypackage.validint";
+#' # }
 #'
 #' }
-#' @seealso [removeInputHandler()]
+#' @seealso [removeInputHandler()] [applyInputHandlers()]
 #' @export
 registerInputHandler <- function(type, fun, force=FALSE){
  if (inputHandlers$containsKey(type) && !force){
--- a/R/shiny-package.R
+++ b/R/shiny-package.R
@@ -2,7 +2,7 @@

 ## usethis namespace: start
 ## usethis namespace: end
-#' @importFrom lifecycle deprecated
+#' @importFrom lifecycle deprecated is_present
 #' @importFrom grDevices dev.set dev.cur
 #' @importFrom fastmap fastmap
 #' @importFrom promises %...!%
@@ -11,11 +11,13 @@
 #'    promise promise_resolve promise_reject is.promising
 #'    as.promise
 #' @importFrom rlang
-#'    quo enquo as_function get_expr get_env new_function enquos
+#'    quo enquo enquo0 as_function get_expr get_env new_function enquos
 #'    eval_tidy expr pairlist2 new_quosure enexpr as_quosure is_quosure inject
+#'    quo_set_env quo_set_expr quo_get_expr
 #'    enquos0 zap_srcref %||% is_na
 #'    is_false list2
 #'    missing_arg is_missing maybe_missing
+#'    quo_is_missing fn_fmls<- fn_body fn_body<-
 #' @importFrom ellipsis
 #'    check_dots_empty check_dots_unnamed
 #' @import htmltools
--- a/R/shinywrappers.R
+++ b/R/shinywrappers.R
@@ -2,12 +2,23 @@ utils::globalVariables('func', add = TRUE)

 #' Mark a function as a render function
 #'
+#' `r lifecycle::badge("superseded")` Please use [`createRenderFunction()`] to
+#' support async execution. (Shiny 1.1.0)
+#'
 #' Should be called by implementers of `renderXXX` functions in order to mark
 #' their return values as Shiny render functions, and to provide a hint to Shiny
 #' regarding what UI function is most commonly used with this type of render
 #' function. This can be used in R Markdown documents to create complete output
 #' widgets out of just the render function.
 #'
+#' Note that it is generally preferable to use [createRenderFunction()] instead
+#' of `markRenderFunction()`. It essentially wraps up the user-provided
+#' expression in the `transform` function passed to it, then passes the resulting
+#' function to `markRenderFunction()`. It also provides a simpler calling
+#' interface. There may be cases where `markRenderFunction()` must be used instead of
+#' [createRenderFunction()] -- for example, when the `transform` parameter of
+#' [createRenderFunction()] is not flexible enough for your needs.
+#'
 #' @param uiFunc A function that renders Shiny UI. Must take a single argument:
 #'   an output ID.
 #' @param renderFunc A function that is suitable for assigning to a Shiny output
@@ -37,7 +48,7 @@ utils::globalVariables('func', add = TRUE)
 #'   is able to serve JS and CSS resources.
 #' @return The `renderFunc` function, with annotations.
 #'
-#' @seealso [createRenderFunction()], [quoToFunction()]
+#' @seealso [createRenderFunction()]
 #' @export
 markRenderFunction <- function(
  uiFunc,
@@ -47,6 +58,12 @@ markRenderFunction <- function(
  cacheWriteHook = NULL,
  cacheReadHook = NULL
 ) {
+  # (Do not emit warning for superseded code, "since there’s no risk if you keep using it")
+  # # This method is called by the superseding function, createRenderFunction().
+  # if (in_devmode()) {
+  #   shinyDeprecated("1.1.0", "markRenderFunction()", "createRenderFunction()")
+  # }
+
  force(renderFunc)

  # a mutable object that keeps track of whether `useRenderFunction` has been
@@ -94,6 +111,7 @@ markRenderFunction <- function(
    # For everything else, do nothing.
    cacheHint <- lapply(cacheHint, function(x) {
      if      (is.function(x)) formalsAndBody(x)
+      else if (is_quosure(x)) zap_srcref(quo_get_expr(x))
      else if (is.language(x)) zap_srcref(x)
      else                     x
    })
@@ -133,10 +151,27 @@ print.shiny.render.function <- function(x, ...) {
  cat_line("<shiny.render.function>")
 }

-#' Implement render functions
+#' Implement custom render functions
 #'
-#' This function is a wrapper for [markRenderFunction()] which provides support
-#' for async computation via promises.
+#' Developer-facing utilities for implementing a custom `renderXXX()` function.
+#' Before using these utilities directly, consider using the [`htmlwidgets`
+#' package](http://www.htmlwidgets.org/develop_intro.html) to implement custom
+#' outputs (i.e., custom `renderXXX()`/`xxxOutput()` functions). That said,
+#' these utilities can be used more directly if a full-blown htmlwidget isn't
+#' needed and/or the user-supplied reactive expression needs to be wrapped in
+#' additional call(s).
+#'
+#' To implement a custom `renderXXX()` function, essentially 2 things are needed:
+#'   1. Capture the user's reactive expression as a function.
+#'      * New `renderXXX()` functions can use `quoToFunction()` for this, but
+#'      already existing `renderXXX()` functions that contain `env` and `quoted`
+#'      parameters may want to continue using `installExprFunction()` for better
+#'      legacy support (see examples).
+#'   2. Flag the resulting function (from 1) as a Shiny rendering function and
+#'   also provide a UI container for displaying the result of the rendering
+#'   function.
+#'      * `createRenderFunction()` is currently recommended (instead of
+#'      [markRenderFunction()]) for this step (see examples).
 #'
 #' @param func A function without parameters, that returns user data. If the
 #'   returned value is a promise, then the render function will proceed in async
@@ -153,16 +188,24 @@ print.shiny.render.function <- function(x, ...) {
 #' @return An annotated render function, ready to be assigned to an
 #'   `output` slot.
 #'
-#' @seealso [quoToFunction()], [markRenderFunction()].
-#'
 #' @examples
-#' # A very simple render function
-#' renderTriple <- function(x) {
-#'   x <- substitute(x)
-#'   if (!rlang::is_quosure(x)) {
-#'     x <- rlang::new_quosure(x, env = parent.frame())
-#'   }
-#'   func <- quoToFunction(x, "renderTriple")
+#' # A custom render function that repeats the supplied value 3 times
+#' renderTriple <- function(expr) {
+#'   # Wrap user-supplied reactive expression into a function
+#'   func <- quoToFunction(rlang::enquo0(expr))
+#'
+#'   createRenderFunction(
+#'     func,
+#'     transform = function(value, session, name, ...) {
+#'       paste(rep(value, 3), collapse=", ")
+#'     },
+#'     outputFunc = textOutput
+#'   )
+#' }
+#'
+#' # For better legacy support, consider using installExprFunction() over quoToFunction()
+#' renderTripleLegacy <- function(expr, env = parent.frame(), quoted = FALSE) {
+#'   func <- installExprFunction(expr, "func", env, quoted)
 #'
 #'   createRenderFunction(
 #'     func,
@@ -174,10 +217,38 @@ print.shiny.render.function <- function(x, ...) {
 #' }
 #'
 #' # Test render function from the console
-#' a <- 1
-#' r <- renderTriple({ a + 1 })
-#' a <- 2
+#' reactiveConsole(TRUE)
+#'
+#' v <- reactiveVal("basic")
+#' r <- renderTriple({ v() })
 #' r()
+#' #> [1] "basic, basic, basic"
+#'
+#' # User can supply quoted code via rlang::quo(). Note that evaluation of the
+#' # expression happens when r2() is invoked, not when r2 is created.
+#' q <- rlang::quo({ v() })
+#' r2 <- rlang::inject(renderTriple(!!q))
+#' v("rlang")
+#' r2()
+#' #> [1] "rlang, rlang, rlang"
+#'
+#' # Supplying quoted code without rlang::quo() requires installExprFunction()
+#' expr <- quote({ v() })
+#' r3 <- renderTripleLegacy(expr, quoted = TRUE)
+#' v("legacy")
+#' r3()
+#' #> [1] "legacy, legacy, legacy"
+#'
+#' # The legacy approach also supports with quosures (env is ignored in this case)
+#' q <- rlang::quo({ v() })
+#' r4 <- renderTripleLegacy(q, quoted = TRUE)
+#' v("legacy-rlang")
+#' r4()
+#' #> [1] "legacy-rlang, legacy-rlang, legacy-rlang"
+#'
+#' # Turn off reactivity in the console
+#' reactiveConsole(FALSE)
+#'
 #' @export
 createRenderFunction <- function(
  func,
@@ -316,9 +387,7 @@ markOutputAttrs <- function(renderFunc, snapshotExclude = NULL,
 #'   the output, see [plotPNG()].
 #'
 #' @param expr An expression that returns a list.
-#' @param env The environment in which to evaluate `expr`.
-#' @param quoted Is `expr` a quoted expression (with `quote()`)? This
-#'   is useful if you want to save an expression in a variable.
+#' @inheritParams renderUI
 #' @param deleteFile Should the file in `func()$src` be deleted after
 #'   it is sent to the client browser? Generally speaking, if the image is a
 #'   temp file generated within `func`, then this should be `TRUE`;
@@ -397,11 +466,10 @@ markOutputAttrs <- function(renderFunc, snapshotExclude = NULL,
 #'
 #' shinyApp(ui, server)
 #' }
-renderImage <- function(expr, env=parent.frame(), quoted=FALSE,
+renderImage <- function(expr, env = parent.frame(), quoted = FALSE,
                        deleteFile, outputArgs=list())
 {
-  expr <- get_quosure(expr, env, quoted)
-  func <- quoToFunction(expr, "renderImage")
+  func <- installExprFunction(expr, "func", env, quoted, label = "renderImage")

  # missing() must be used directly within the function with the given arg
  if (missing(deleteFile)) {
@@ -523,9 +591,7 @@ isTemp <- function(path, tempDir = tempdir(), mustExist) {
 #' function return [invisible()].
 #'
 #' @param expr An expression to evaluate.
-#' @param env The environment in which to evaluate `expr`. For expert use only.
-#' @param quoted Is `expr` a quoted expression (with `quote()`)? This
-#'   is useful if you want to save an expression in a variable.
+#' @inheritParams renderUI
 #' @param width Width of printed output.
 #' @param outputArgs A list of arguments to be passed through to the implicit
 #'   call to [verbatimTextOutput()] or [textOutput()] when the functions are
@@ -536,8 +602,7 @@ isTemp <- function(path, tempDir = tempdir(), mustExist) {
 renderPrint <- function(expr, env = parent.frame(), quoted = FALSE,
                        width = getOption('width'), outputArgs=list())
 {
-  expr <- get_quosure(expr, env, quoted)
-  func <- quoToFunction(expr, "renderPrint")
+  func <- installExprFunction(expr, "func", env, quoted, label = "renderPrint")

  # Set a promise domain that sets the console width
  #   and captures output
@@ -569,7 +634,7 @@ renderPrint <- function(expr, env = parent.frame(), quoted = FALSE,
    outputArgs,
    cacheHint = list(
      label = "renderPrint",
-      origUserExpr = get_expr(expr)
+      origUserExpr = installedFuncExpr(func)
    )
  )
 }
@@ -619,11 +684,10 @@ createRenderPrintPromiseDomain <- function(width) {
 #'   element.
 #' @export
 #' @rdname renderPrint
-renderText <- function(expr, env=parent.frame(), quoted=FALSE,
+renderText <- function(expr, env = parent.frame(), quoted = FALSE,
                       outputArgs=list(), sep=" ") {

-  expr <- get_quosure(expr, env, quoted)
-  func <- quoToFunction(expr, "renderText")
+  func <- installExprFunction(expr, "func", env, quoted, label = "renderText")

  createRenderFunction(
    func,
@@ -644,9 +708,13 @@ renderText <- function(expr, env=parent.frame(), quoted=FALSE,
 #'
 #' @param expr An expression that returns a Shiny tag object, [HTML()],
 #'   or a list of such objects.
-#' @param env The environment in which to evaluate `expr`.
-#' @param quoted Is `expr` a quoted expression (with `quote()`)? This
-#'   is useful if you want to save an expression in a variable.
+#' @template param-env
+#' @templateVar x expr
+#' @templateVar env env
+#' @templateVar quoted quoted
+#' @template param-quoted
+#' @templateVar x expr
+#' @templateVar quoted quoted
 #' @param outputArgs A list of arguments to be passed through to the implicit
 #'   call to [uiOutput()] when `renderUI` is used in an
 #'   interactive R Markdown document.
@@ -675,8 +743,7 @@ renderText <- function(expr, env=parent.frame(), quoted=FALSE,
 renderUI <- function(expr, env = parent.frame(), quoted = FALSE,
                     outputArgs = list())
 {
-  expr <- get_quosure(expr, env, quoted)
-  func <- quoToFunction(expr, "renderUI")
+  func <- installExprFunction(expr, "func", env, quoted, label = "renderUI")

  createRenderFunction(
    func,
@@ -755,6 +822,10 @@ downloadHandler <- function(filename, content, contentType=NA, outputArgs=list()
 #' Table output with the JavaScript DataTables library
 #'
 #' @description
+#' `r lifecycle::badge("superseded")` Please use
+#' \href{https://rstudio.github.io/DT/shiny.html}{\code{DT::renderDataTable()}}.
+#' (Shiny 0.11.1)
+#'
 #' Makes a reactive version of the given function that returns a data frame (or
 #' matrix), which will be rendered with the [DataTables](https://datatables.net)
 #' library. Paging, searching, filtering, and sorting can be done on the R side
@@ -829,8 +900,7 @@ renderDataTable <- function(expr, options = NULL, searchDelay = 500,
    )
  }

-  expr <- get_quosure(expr, env, quoted)
-  func <- quoToFunction(expr, "renderDataTable")
+  func <- installExprFunction(expr, "func", env, quoted, label = "renderDataTable")

  renderFunc <- function(shinysession, name, ...) {
    if (is.function(options)) options <- options()
--- a/R/utils-lang.R
+++ b/R/utils-lang.R
@@ -51,60 +51,199 @@ formalsAndBody <- function(x) {
 }


-# This function is to be called from functions like `reactive()`, `observe()`,
-# and the various render functions. It handles the following cases:
-# - The typical case where x is an unquoted expression, and `env` and `quoted`
-#   are not used.
-# - New-style metaprogramming cases, where rlang::inject() is used to inline a
-#   quosure into the AST, as in `inject(reactive(!!x))`.
-# - Old-style metaprogramming cases, where `env` and/or `quoted` are used.
-#
-# Much of the complexity is handling old-style metaprogramming cases. The code
-# in this function is more complicated because it needs to look at unevaluated
-# expressions in the _calling_ function. If this code were put directly in the
-# calling function, it would look like this:
-#
-# if (!missing(env) || !missing(quoted)) {
-#   deprecatedEnvQuotedMessage()
-#   if (!quoted) x <- substitute(x)
-#   x <- new_quosure(x, env)
-#
-# } else {
-#   x <- substitute(x)
-#   if (!is_quosure(x)) {
-#     x <- new_quosure(x, env = parent.frame())
-#   }
-# }
-#
-# In the future, the calling functions will not need to have the `env` and
-# `quoted` arguments -- `rlang::inject()` and quosures can be used instead.
-# Instead of using this function, `get_quosure()`, the caller can instead use
-# just the following code:
-#
-# x <- substitute(x)
-# if (!is_quosure(x)) {
-#   x <- new_quosure(x, env = parent.frame())
-# }
-#
-get_quosure <- function(x, env, quoted) {
-  if (!eval(substitute(missing(env)), parent.frame()) ||
-      !eval(substitute(missing(quoted)), parent.frame()))
-  {
-    deprecatedEnvQuotedMessage()
-    if (!quoted) {
-      x <- eval(substitute(substitute(x)), parent.frame())
-    }
-    x <- new_quosure(x, env)
+#' @describeIn createRenderFunction convert a quosure to a function.
+#' @param q Quosure of the expression `x`. When capturing expressions to create
+#'   your quosure, it is recommended to use [`enquo0()`] to not unquote the
+#'   object too early. See [`enquo0()`] for more details.
+#' @inheritParams installExprFunction
+#' @export
+quoToFunction <- function(
+  q,
+  label = sys.call(-1)[[1]],
+  ..stacktraceon = FALSE
+) {
+  func <- quoToSimpleFunction(as_quosure(q))
+  wrapFunctionLabel(func, updateFunctionLabel(label), ..stacktraceon = ..stacktraceon, dots = FALSE)
+}

-  } else {
-    x <- eval(substitute(substitute(x)), parent.frame())
-
-    # At this point, x can be a quosure if rlang::inject() is used, but the
-    # typical case is that x is not a quosure.
-    if (!is_quosure(x)) {
-      x <- new_quosure(x, env = parent.frame(2L))
+updateFunctionLabel <- function(label) {
+  badFnName <- "anonymous"
+  if (all(is.language(label))) {
+    # Prevent immediately invoked functions like as.language(a()())
+    if (is.language(label) && length(label) > 1) {
+      return(badFnName)
    }
+    label <- deparse(label, width.cutoff = 500L)
+  }
+  label <- as.character(label)
+  # Prevent function calls that are over one line; (Assignments are hard to perform)
+    # Prevent immediately invoked functions like "a()()"
+  if (length(label) > 1 || grepl("(", label, fixed = TRUE)) {
+    return(badFnName)
+  }
+  if (label == "NULL") {
+    return(badFnName)
+  }
+  label
+}
+
+quoToSimpleFunction <- function(q) {
+  # Should not use `new_function(list(), get_expr(q), get_env(q))` as extra logic
+  # is done by rlang to convert the quosure to a function within `as_function(q)`
+  fun <- as_function(q)
+
+  # If the quosure is empty, then the returned function can not be called.
+  # https://github.com/r-lib/rlang/issues/1244
+  if (quo_is_missing(q)) {
+    fn_body(fun) <- quote({})
  }

-  x
+  # `as_function()` returns a function that takes `...`. We need one that takes no
+  # args.
+  fn_fmls(fun) <- list()
+
+  fun
+}
+
+
+#' Convert an expression to a function
+#'
+#' `r lifecycle::badge("superseded")` Please use [`installExprFunction()`] for a better
+#' debugging experience (Shiny 0.8.0). If the `expr` and `quoted` parameters are not needed, please see
+#' [`quoToFunction()`] (Shiny 1.6.0).
+#'
+#' Similar to [installExprFunction()] but doesn't register debug hooks.
+#'
+#' @param expr A quoted or unquoted expression, or a quosure.
+#' @param env The desired environment for the function. Defaults to the
+#'   calling environment two steps back.
+#' @param quoted Is the expression quoted?
+#' @seealso [`installExprFunction()`] for the modern approach to converting an expression to a function
+#' @export
+#' @keywords internal
+exprToFunction <- function(expr, env = parent.frame(), quoted = FALSE) {
+  # If `expr` is a raw quosure, must say `quoted = TRUE`; (env is ignored)
+  # If `inject()` a quosure, env is ignored, and quoted should be FALSE (aka ignored).
+  # Make article of usage
+  # * (by joe)
+
+  if (!quoted) {
+    expr <- eval(substitute(substitute(expr)), parent.frame())
+  }
+  # MUST call with `quoted = TRUE` as exprToQuo() will not reach high enough
+  q <- exprToQuo(expr, env, quoted = TRUE)
+
+  # MUST call `as_function()`. Can NOT call `new_function()`
+  # rlang has custom logic for handling converting a quosure to a function
+  quoToSimpleFunction(q)
+}
+# For internal use only; External users should be using `exprToFunction()` or `installExprFunction()`
+# MUST be the exact same logic as `exprToFunction()`, but without the `quoToSimpleFunction()` call
+exprToQuo <- function(expr, env = parent.frame(), quoted = FALSE) {
+  if (!quoted) {
+    expr <- eval(substitute(substitute(expr)), parent.frame())
+  }
+  q <-
+    if (is_quosure(expr)) {
+      # inject()ed quosure
+      # do nothing
+      expr
+    } else if (is.language(expr) || rlang::is_atomic(expr) || is.null(expr)) {
+      # Most common case...
+      new_quosure(expr, env = env)
+    } else {
+      stop("Don't know how to convert '", class(expr)[1], "' to a function; a quosure or quoted expression was expected")
+    }
+  q
+}
+
+#' @describeIn createRenderFunction converts a user's reactive `expr` into a
+#'   function that's assigned to a `name` in the `assign.env`.
+#'
+#' @param name The name the function should be given
+#' @param eval.env The desired environment for the function. Defaults to the
+#'   calling environment two steps back.
+#' @param assign.env The environment in which the function should be assigned.
+#' @param label A label for the object to be shown in the debugger. Defaults to
+#'   the name of the calling function.
+#' @param wrappedWithLabel,..stacktraceon Advanced use only. For stack manipulation purposes; see
+#'   [stacktrace()].
+#' @inheritParams exprToFunction
+#' @export
+installExprFunction <- function(expr, name, eval.env = parent.frame(2),
+                                quoted = FALSE,
+                                assign.env = parent.frame(1),
+                                label = sys.call(-1)[[1]],
+                                wrappedWithLabel = TRUE,
+                                ..stacktraceon = FALSE) {
+  if (!quoted) {
+    quoted <- TRUE
+    expr <- eval(substitute(substitute(expr)), parent.frame())
+  }
+
+  func <- exprToFunction(expr, eval.env, quoted)
+  if (length(label) > 1) {
+    # Just in case the deparsed code is more complicated than we imagine. If we
+    # have a label with length > 1 it causes warnings in wrapFunctionLabel.
+    label <- paste0(label, collapse = "\n")
+  }
+  wrappedWithLabel <- isTRUE(wrappedWithLabel)
+  if (wrappedWithLabel) {
+    func <- wrapFunctionLabel(func, updateFunctionLabel(label), ..stacktraceon = ..stacktraceon, dots = FALSE)
+  }
+  assign(name, func, envir = assign.env)
+  if (!wrappedWithLabel) {
+    registerDebugHook(name, assign.env, label)
+  }
+
+  invisible(func)
+}
+
+# Utility function for creating a debugging label, given an expression.
+# `expr` is a quoted expression.
+# `function_name` is the name of the calling function.
+# `label` is an optional user-provided label. If NULL, it will be inferred.
+exprToLabel <- function(expr, function_name, label = NULL) {
+  srcref <- attr(expr, "srcref", exact = TRUE)
+  if (is.null(label)) {
+    label <- rexprSrcrefToLabel(
+      srcref[[1]],
+      simpleExprToFunction(expr, function_name)
+    )
+  }
+  if (length(srcref) >= 2) attr(label, "srcref") <- srcref[[2]]
+  attr(label, "srcfile") <- srcFileOfRef(srcref[[1]])
+  label
+}
+simpleExprToFunction <- function(expr, function_name) {
+  sprintf('%s(%s)', function_name, paste(deparse(expr), collapse='\n'))
+}
+
+installedFuncExpr <- function(func) {
+  fn_body(attr(func, "wrappedFunc", exact = TRUE))
+}
+
+funcToLabelBody <- function(func) {
+  paste(deparse(installedFuncExpr(func)), collapse='\n')
+}
+funcToLabel <- function(func, functionLabel, label = NULL) {
+  if (!is.null(label)) return(label)
+
+  sprintf(
+    '%s(%s)',
+    functionLabel,
+    funcToLabelBody(func)
+  )
+}
+quoToLabelBody <- function(q) {
+  paste(deparse(quo_get_expr(q)), collapse='\n')
+}
+quoToLabel <- function(q, functionLabel, label = NULL) {
+  if (!is.null(label)) return(label)
+
+  sprintf(
+    '%s(%s)',
+    functionLabel,
+    quoToLabelBody(q)
+  )
 }
--- a/R/utils.R
+++ b/R/utils.R
@@ -404,165 +404,6 @@ getContentType <- function(file, defaultType = 'application/octet-stream') {
  mime::guess_type(file, unknown = defaultType, subtype = subtype)
 }

-# Create a zero-arg function from a quoted expression and environment
-# @examples
-# makeFunction(body=quote(print(3)))
-makeFunction <- function(args = pairlist(), body, env = parent.frame()) {
-  eval(call("function", args, body), env)
-}
-
-#' Convert an expression to a function
-#'
-#' This is to be called from another function, because it will attempt to get
-#' an unquoted expression from two calls back. Note: as of Shiny 1.6.0, it is
-#' recommended to use [quoToFunction()] instead.
-#'
-#' If expr is a quoted expression, then this just converts it to a function.
-#' If expr is a function, then this simply returns expr (and prints a
-#'   deprecation message).
-#' If expr was a non-quoted expression from two calls back, then this will
-#'   quote the original expression and convert it to a function.
-#
-#' @param expr A quoted or unquoted expression, or a function.
-#' @param env The desired environment for the function. Defaults to the
-#'   calling environment two steps back.
-#' @param quoted Is the expression quoted?
-#'
-#' @examples
-#' # Example of a new renderer, similar to renderText
-#' # This is something that toolkit authors will do
-#' renderTriple <- function(expr, env=parent.frame(), quoted=FALSE) {
-#'   # Convert expr to a function
-#'   func <- shiny::exprToFunction(expr, env, quoted)
-#'
-#'   function() {
-#'     value <- func()
-#'     paste(rep(value, 3), collapse=", ")
-#'   }
-#' }
-#'
-#'
-#' # Example of using the renderer.
-#' # This is something that app authors will do.
-#' values <- reactiveValues(A="text")
-#'
-#' \dontrun{
-#' # Create an output object
-#' output$tripleA <- renderTriple({
-#'   values$A
-#' })
-#' }
-#'
-#' # At the R console, you can experiment with the renderer using isolate()
-#' tripleA <- renderTriple({
-#'   values$A
-#' })
-#'
-#' isolate(tripleA())
-#' # "text, text, text"
-#' @export
-exprToFunction <- function(expr, env=parent.frame(), quoted=FALSE) {
-  if (!quoted) {
-    expr <- eval(substitute(substitute(expr)), parent.frame())
-  }
-
-  # expr is a quoted expression
-  makeFunction(body=expr, env=env)
-}
-
-#' Install an expression as a function
-#'
-#' Installs an expression in the given environment as a function, and registers
-#' debug hooks so that breakpoints may be set in the function. Note: as of
-#' Shiny 1.6.0, it is recommended to use [quoToFunction()] instead.
-#'
-#' This function can replace `exprToFunction` as follows: we may use
-#' `func <- exprToFunction(expr)` if we do not want the debug hooks, or
-#' `installExprFunction(expr, "func")` if we do. Both approaches create a
-#' function named `func` in the current environment.
-#'
-#' @seealso Wraps [exprToFunction()]; see that method's documentation
-#'   for more documentation and examples.
-#'
-#' @param expr A quoted or unquoted expression
-#' @param name The name the function should be given
-#' @param eval.env The desired environment for the function. Defaults to the
-#'   calling environment two steps back.
-#' @param quoted Is the expression quoted?
-#' @param assign.env The environment in which the function should be assigned.
-#' @param label A label for the object to be shown in the debugger. Defaults to
-#'   the name of the calling function.
-#' @param wrappedWithLabel,..stacktraceon Advanced use only. For stack manipulation purposes; see
-#'   [stacktrace()].
-#' @export
-installExprFunction <- function(expr, name, eval.env = parent.frame(2),
-                                quoted = FALSE,
-                                assign.env = parent.frame(1),
-                                label = deparse(sys.call(-1)[[1]]),
-                                wrappedWithLabel = TRUE,
-                                ..stacktraceon = FALSE) {
-  if (!quoted) {
-    quoted <- TRUE
-    expr <- eval(substitute(substitute(expr)), parent.frame())
-  }
-
-  func <- exprToFunction(expr, eval.env, quoted)
-  if (length(label) > 1) {
-    # Just in case the deparsed code is more complicated than we imagine. If we
-    # have a label with length > 1 it causes warnings in wrapFunctionLabel.
-    label <- paste0(label, collapse = "\n")
-  }
-  if (wrappedWithLabel) {
-    func <- wrapFunctionLabel(func, label, ..stacktraceon = ..stacktraceon)
-  } else {
-    registerDebugHook(name, assign.env, label)
-  }
-  assign(name, func, envir = assign.env)
-}
-
-#' Convert a quosure to a function for a Shiny render function
-#'
-#' This takes a quosure and label, and wraps them into a function that should be
-#' passed to [createRenderFunction()] or [markRenderFunction()].
-#'
-#' This function was added in Shiny 1.6.0. Previously, it was recommended to use
-#' [installExprFunction()] or [exprToFunction()] in render functions, but now we
-#' recommend using [quoToFunction()], because it does not require `env` and
-#' `quoted` arguments -- that information is captured by quosures provided by
-#' \pkg{rlang}.
-#'
-#' @param q A quosure.
-#' @inheritParams installExprFunction
-#' @seealso [createRenderFunction()] for example usage.
-#'
-#' @export
-quoToFunction <- function(q, label, ..stacktraceon = FALSE) {
-  q <- as_quosure(q)
-  func <- as_function(q)
-  # as_function returns a function that takes `...`. We want one that takes no
-  # args.
-  formals(func) <- list()
-  wrapFunctionLabel(func, label, ..stacktraceon = ..stacktraceon)
-}
-
-
-# Utility function for creating a debugging label, given an expression.
-# `expr` is a quoted expression.
-# `function_name` is the name of the calling function.
-# `label` is an optional user-provided label. If NULL, it will be inferred.
-exprToLabel <- function(expr, function_name, label = NULL) {
-  srcref <- attr(expr, "srcref", exact = TRUE)
-  if (is.null(label)) {
-    label <- rexprSrcrefToLabel(
-      srcref[[1]],
-      sprintf('%s(%s)', function_name, paste(deparse(expr), collapse = '\n'))
-    )
-  }
-  if (length(srcref) >= 2) attr(label, "srcref") <- srcref[[2]]
-  attr(label, "srcfile") <- srcFileOfRef(srcref[[1]])
-  label
-}
-
 #' Parse a GET query string from a URL
 #'
 #' Returns a named list of key-value pairs.
@@ -1597,21 +1438,31 @@ dateYMD <- function(date = NULL, argName = "value") {
 # function which calls the original function using the specified name. This can
 # be helpful for profiling, because the specified name will show up on the stack
 # trace.
-wrapFunctionLabel <- function(func, name, ..stacktraceon = FALSE) {
+wrapFunctionLabel <- function(func, name, ..stacktraceon = FALSE, dots = TRUE) {
  if (name == "name" || name == "func" || name == "relabelWrapper") {
    stop("Invalid name for wrapFunctionLabel: ", name)
  }
  assign(name, func, environment())
  registerDebugHook(name, environment(), name)

-  if (..stacktraceon) {
-    # We need to wrap the `...` in `!!quote(...)` so that R CMD check won't
-    # complain about "... may be used in an incorrect context"
-    body <- expr({ ..stacktraceon..((!!name)(!!quote(...))) })
+  if (isTRUE(dots)) {
+    if (..stacktraceon) {
+      # We need to wrap the `...` in `!!quote(...)` so that R CMD check won't
+      # complain about "... may be used in an incorrect context"
+      body <- expr({ ..stacktraceon..((!!name)(!!quote(...))) })
+    } else {
+      body <- expr({ (!!name)(!!quote(...)) })
+    }
+    relabelWrapper <- new_function(pairlist2(... =), body, environment())
  } else {
-    body <- expr({ (!!name)(!!quote(...)) })
+    # Same logic as when `dots = TRUE`, but without the `...`
+    if (..stacktraceon) {
+      body <- expr({ ..stacktraceon..((!!name)()) })
+    } else {
+      body <- expr({ (!!name)() })
+    }
+    relabelWrapper <- new_function(list(), body, environment())
  }
-  relabelWrapper <- new_function(pairlist2(... =), body, environment())

  # Preserve the original function that was passed in; is used for caching.
  attr(relabelWrapper, "wrappedFunc") <- func
--- a/inst/www/shared/shiny-autoreload.js
+++ b/inst/www/shared/shiny-autoreload.js
@@ -1,3 +1,3 @@
-/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
+/*! shiny 1.7.0 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
 (function(){var t="ws:";window.location.protocol==="https:"&&(t="wss:");var o=window.location.pathname;/\/$/.test(o)||(o+="/");o+="autoreload/";var n=new WebSocket(t+"//"+window.location.host+o);n.onmessage=function(a){a.data==="autoreload"&&window.location.reload()};})();
 //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjdHMvZXh0cmFzL3NoaW55LWF1dG9yZWxvYWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIGVzbGludC1kaXNhYmxlIHVuaWNvcm4vZmlsZW5hbWUtY2FzZSAqL1xudmFyIHByb3RvY29sID0gXCJ3czpcIjtcbmlmICh3aW5kb3cubG9jYXRpb24ucHJvdG9jb2wgPT09IFwiaHR0cHM6XCIpIHByb3RvY29sID0gXCJ3c3M6XCI7XG52YXIgZGVmYXVsdFBhdGggPSB3aW5kb3cubG9jYXRpb24ucGF0aG5hbWU7XG5pZiAoIS9cXC8kLy50ZXN0KGRlZmF1bHRQYXRoKSkgZGVmYXVsdFBhdGggKz0gXCIvXCI7XG5kZWZhdWx0UGF0aCArPSBcImF1dG9yZWxvYWQvXCI7XG52YXIgd3MgPSBuZXcgV2ViU29ja2V0KHByb3RvY29sICsgXCIvL1wiICsgd2luZG93LmxvY2F0aW9uLmhvc3QgKyBkZWZhdWx0UGF0aCk7XG5cbndzLm9ubWVzc2FnZSA9IGZ1bmN0aW9uIChldmVudCkge1xuICBpZiAoZXZlbnQuZGF0YSA9PT0gXCJhdXRvcmVsb2FkXCIpIHtcbiAgICB3aW5kb3cubG9jYXRpb24ucmVsb2FkKCk7XG4gIH1cbn07XG5cbmV4cG9ydCB7fTsiXSwKICAibWFwcGluZ3MiOiAiO1lBQ0EsR0FBSSxHQUFXLE1BQ2YsQUFBSSxPQUFPLFNBQVMsV0FBYSxVQUFVLEdBQVcsUUFDdEQsR0FBSSxHQUFjLE9BQU8sU0FBUyxTQUNsQyxBQUFLLE1BQU0sS0FBSyxJQUFjLElBQWUsS0FDN0MsR0FBZSxjQUNmLEdBQUksR0FBSyxHQUFJLFdBQVUsRUFBVyxLQUFPLE9BQU8sU0FBUyxLQUFPLEdBRWhFLEVBQUcsVUFBWSxTQUFVLEVBQU8sQ0FDOUIsQUFBSSxFQUFNLE9BQVMsY0FDakIsT0FBTyxTQUFTIiwKICAibmFtZXMiOiBbXQp9Cg==
--- a/inst/www/shared/shiny-showcase.css
+++ b/inst/www/shared/shiny-showcase.css
@@ -1,2 +1,2 @@
-/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
+/*! shiny 1.7.0 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
 #showcase-well{border-radius:0}.shiny-code{background-color:#fff;margin-bottom:0}.shiny-code code{font-family:Menlo,Consolas,"Courier New",monospace}.shiny-code-container{margin-top:20px;clear:both}.shiny-code-container h3{display:inline;margin-right:15px}.showcase-header{font-size:16px;font-weight:normal}.showcase-code-link{text-align:right;padding:15px}#showcase-app-container{vertical-align:top}#showcase-code-tabs{margin-right:15px}#showcase-code-tabs pre{border:none;line-height:1em}#showcase-code-tabs .nav{margin-bottom:0}#showcase-code-tabs ul{margin-bottom:0}#showcase-code-tabs .tab-content{border-style:solid;border-color:#e5e5e5;border-width:0px 1px 1px 1px;overflow:auto;border-bottom-right-radius:4px;border-bottom-left-radius:4px}#showcase-app-code{width:100%}#showcase-code-position-toggle{float:right}#showcase-sxs-code{padding-top:20px;vertical-align:top}.showcase-code-license{display:block;text-align:right}#showcase-code-content pre{background-color:#fff}
--- a/inst/www/shared/shiny-showcase.js
+++ b/inst/www/shared/shiny-showcase.js
--- a/inst/www/shared/shiny-testmode.js
+++ b/inst/www/shared/shiny-testmode.js
@@ -1,3 +1,3 @@
-/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
+/*! shiny 1.7.0 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
 (function(){var a=eval;window.addEventListener("message",function(i){var e=i.data;e.code&&a(e.code)});})();
 //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjdHMvc3JjL3V0aWxzL2V2YWwudHMiLCAiLi4vLi4vLi4vc3JjdHMvZXh0cmFzL3NoaW55LXRlc3Rtb2RlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvL2VzYnVpbGQuZ2l0aHViLmlvL2NvbnRlbnQtdHlwZXMvI2RpcmVjdC1ldmFsXG4vL3RsL2RyO1xuLy8gKiBEaXJlY3QgdXNhZ2Ugb2YgYGV2YWwoXCJ4XCIpYCBpcyBiYWQgd2l0aCBidW5kbGVkIGNvZGUuXG4vLyAqIEluc3RlYWQsIHVzZSBpbmRpcmVjdCBjYWxscyB0byBgZXZhbGAgc3VjaCBhcyBgaW5kaXJlY3RFdmFsKFwieFwiKWBcbi8vICAgKiBFdmVuIGp1c3QgcmVuYW1pbmcgdGhlIGZ1bmN0aW9uIHdvcmtzIHdlbGwgZW5vdWdoLlxuLy8gPiBUaGlzIGlzIGtub3duIGFzIFwiaW5kaXJlY3QgZXZhbFwiIGJlY2F1c2UgZXZhbCBpcyBub3QgYmVpbmcgY2FsbGVkIGRpcmVjdGx5LCBhbmQgc28gZG9lcyBub3QgdHJpZ2dlciB0aGUgZ3JhbW1hdGljYWwgc3BlY2lhbCBjYXNlIGZvciBkaXJlY3QgZXZhbCBpbiB0aGUgSmF2YVNjcmlwdCBWTS4gWW91IGNhbiBjYWxsIGluZGlyZWN0IGV2YWwgdXNpbmcgYW55IHN5bnRheCBhdCBhbGwgZXhjZXB0IGZvciBhbiBleHByZXNzaW9uIG9mIHRoZSBleGFjdCBmb3JtIGV2YWwoJ3gnKS4gRm9yIGV4YW1wbGUsIHZhciBldmFsMiA9IGV2YWw7IGV2YWwyKCd4JykgYW5kIFtldmFsXVswXSgneCcpIGFuZCB3aW5kb3cuZXZhbCgneCcpIGFyZSBhbGwgaW5kaXJlY3QgZXZhbCBjYWxscy5cbi8vID4gV2hlbiB5b3UgdXNlIGluZGlyZWN0IGV2YWwsIHRoZSBjb2RlIGlzIGV2YWx1YXRlZCBpbiB0aGUgZ2xvYmFsIHNjb3BlIGluc3RlYWQgb2YgaW4gdGhlIGlubGluZSBzY29wZSBvZiB0aGUgY2FsbGVyLlxudmFyIGluZGlyZWN0RXZhbCA9IGV2YWw7XG5leHBvcnQgeyBpbmRpcmVjdEV2YWwgfTsiLCAiLyogZXNsaW50LWRpc2FibGUgdW5pY29ybi9maWxlbmFtZS1jYXNlICovXG5pbXBvcnQgeyBpbmRpcmVjdEV2YWwgfSBmcm9tIFwiLi4vc3JjL3V0aWxzL2V2YWxcIjsgLy8gTGlzdGVuIGZvciBtZXNzYWdlcyBmcm9tIHBhcmVudCBmcmFtZS4gVGhpcyBmaWxlIGlzIG9ubHkgYWRkZWQgd2hlbiB0aGVcbi8vIHNoaW55LnRlc3Rtb2RlIG9wdGlvbiBpcyBUUlVFLlxuXG53aW5kb3cuYWRkRXZlbnRMaXN0ZW5lcihcIm1lc3NhZ2VcIiwgZnVuY3Rpb24gKGUpIHtcbiAgdmFyIG1lc3NhZ2UgPSBlLmRhdGE7XG4gIGlmIChtZXNzYWdlLmNvZGUpIGluZGlyZWN0RXZhbChtZXNzYWdlLmNvZGUpO1xufSk7Il0sCiAgIm1hcHBpbmdzIjogIjtZQU9BLEdBQUksR0FBZSxLQ0huQixPQUFPLGlCQUFpQixVQUFXLFNBQVUsRUFBRyxDQUM5QyxHQUFJLEdBQVUsRUFBRSxLQUNoQixBQUFJLEVBQVEsTUFBTSxFQUFhLEVBQVEiLAogICJuYW1lcyI6IFtdCn0K
--- a/inst/www/shared/shiny.js
+++ b/inst/www/shared/shiny.js
@@ -1,4 +1,4 @@
-/*! shiny 1.6.0.9021 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
+/*! shiny 1.7.0 | (c) 2012-2021 RStudio, PBC. | License: GPL-3 | file LICENSE */
 (function() {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
@@ -2877,6 +2877,9 @@
    } else {
      setIsQt(false);
    }
+    if (/\bQt/.test(userAgent) && /\bMacintosh/.test(userAgent)) {
+      (0, import_jquery3.default)(document.documentElement).addClass("qtmac");
+    }
    if (/\bQt\/5/.test(userAgent) && /Linux/.test(userAgent)) {
      (0, import_jquery3.default)(document.documentElement).addClass("qt5");
    }
@@ -12815,8 +12818,8 @@
          }
          function getTabIndex($tabset2, tabsetId2) {
            var existingTabIds = [0];
-            $tabset2.find("a[data-toggle='tab']").each(function() {
-              var $tab = (0, import_jquery41.default)(this);
+            $tabset2.find("> li").each(function() {
+              var $tab = (0, import_jquery41.default)(this).find("> a[data-toggle='tab']");
              if ($tab.length > 0) {
                var href = $tab.attr("href").replace(/.*(?=#[^\s]+$)/, "");
                var _index = href.replace("#tab-" + tabsetId2 + "-", "");
@@ -13245,7 +13248,6 @@
    (0, import_jquery42.default)(document).one("shiny:connected", function() {
      initDeferredIframes();
    });
-    window.console.log("Shiny version: ", windowShiny3.version);
  }
  function initDeferredIframes() {
    if (!window.Shiny || !window.Shiny.shinyapp || !window.Shiny.shinyapp.isConnected()) {
@@ -13263,7 +13265,7 @@
  var windowShiny2;
  function setShiny(windowShiny_) {
    windowShiny2 = windowShiny_;
-    windowShiny2.version = "1.6.0.9021";
+    windowShiny2.version = "1.7.0";
    var _initInputBindings = initInputBindings(), inputBindings = _initInputBindings.inputBindings, fileInputBinding2 = _initInputBindings.fileInputBinding;
    var _initOutputBindings = initOutputBindings(), outputBindings = _initOutputBindings.outputBindings;
    setFileInputBinding(fileInputBinding2);
--- a/inst/www/shared/shiny.js.map
+++ b/inst/www/shared/shiny.js.map
--- a/inst/www/shared/shiny.min.css
+++ b/inst/www/shared/shiny.min.css
--- a/inst/www/shared/shiny.min.js
+++ b/inst/www/shared/shiny.min.js
--- a/inst/www/shared/shiny.min.js.map
+++ b/inst/www/shared/shiny.min.js.map
--- a/inst/www/shared/shiny_scss/shiny.scss
+++ b/inst/www/shared/shiny_scss/shiny.scss
@@ -295,6 +295,15 @@ pre.shiny-text-output {
  margin-top: 0px;
 }

+/* Workaround for radio buttons and checkboxes not showing on Qt on Mac.
+   This occurs in the RStudio IDE on macOS 11.5.
+   https://github.com/rstudio/shiny/issues/3484
+*/
+.qtmac input[type="radio"],
+.qtmac input[type="checkbox"] {
+  zoom: 1.0000001;
+}
+
 /* consistency with bootstrap.css for selectize.js */
 .selectize-control {
  margin-bottom: 10px;
--- a/man-roxygen/param-env.R
+++ b/man-roxygen/param-env.R
@@ -0,0 +1,6 @@
+# Also update observeEvent param descriptions!
+# https://github.com/r-lib/roxygen2/issues/1241
+#' @param <%= env %> The parent environment for the reactive expression. By default,
+#'   this is the calling environment, the same as when defining an ordinary
+#'   non-reactive expression. If `<%= x %>` is a quosure and `<%= quoted %>` is `TRUE`,
+#'   then `<%= env %>` is ignored.
--- a/man-roxygen/param-quoted.R
+++ b/man-roxygen/param-quoted.R
@@ -0,0 +1,6 @@
+# Also update observeEvent param descriptions!
+# https://github.com/r-lib/roxygen2/issues/1241
+#' @param <%= quoted %> If it is `TRUE`, then the [`quote()`]ed value of `<%= x %>`
+#'   will be used when `<%= x %>` is evaluated. If `<%= x %>` is a quosure and you
+#'   would like to use its expression as a value for `<%= x %>`, then you must set
+#'  `<%= quoted %>` to `TRUE`.
--- a/man/bindCache.Rd
+++ b/man/bindCache.Rd
@@ -40,7 +40,7 @@ sense, namely:

 In the example here, the \code{bindCache()} key consists of \code{input$x} and
 \code{input$y} combined, and the value is \code{input$x * input$y}. In this simple
-example, for any given key, there is only one possible returned value.\if{html}{\out{<div class="NA">}}\preformatted{r <- reactive(\{ input$x * input$y \}) \%>\%
+example, for any given key, there is only one possible returned value.\if{html}{\out{<div class="sourceCode NA">}}\preformatted{r <- reactive(\{ input$x * input$y \}) \%>\%
  bindCache(input$x, input$y)
 }\if{html}{\out{</div>}}

@@ -63,7 +63,7 @@ to do some sort of reduction on the data that still captures information
 about whether a value can be retrieved from the cache. For example, if you
 have a large data set with timestamps, it might make sense to extract the
 most recent timestamp and return that. Then, instead of hashing the entire
-data object, the cached reactive only needs to hash the timestamp.\if{html}{\out{<div class="NA">}}\preformatted{r <- reactive(\{ compute(bigdata()) \} \%>\%
+data object, the cached reactive only needs to hash the timestamp.\if{html}{\out{<div class="sourceCode NA">}}\preformatted{r <- reactive(\{ compute(bigdata()) \} \%>\%
  bindCache(\{ extract_most_recent_time(bigdata()) \})
 }\if{html}{\out{</div>}}

@@ -105,7 +105,7 @@ cache key is not too expensive.
 Remember that the key is \emph{reactive}, so it is not re-executed every single
 time that someone accesses the cached reactive. It is only re-executed if
 it has been invalidated by one of the reactives it depends on. For
-example, suppose we have this cached reactive:\if{html}{\out{<div class="NA">}}\preformatted{r <- reactive(\{ input$x * input$y \}) \%>\%
+example, suppose we have this cached reactive:\if{html}{\out{<div class="sourceCode NA">}}\preformatted{r <- reactive(\{ input$x * input$y \}) \%>\%
 bindCache(input$x, input$y)
 }\if{html}{\out{</div>}}

@@ -244,7 +244,7 @@ cache collisions, dealing with internal state that may be set by the,
 the cache.

 You may need to provide a \code{cacheHint} to \code{\link[=createRenderFunction]{createRenderFunction()}} (or
-\code{\link[htmlwidgets:htmlwidgets-shiny]{htmlwidgets::shinyRenderWidget()}}, if you've authored an htmlwidget) in
+\code{htmlwidgets::shinyRenderWidget()}, if you've authored an htmlwidget) in
 order for \code{bindCache()} to correctly compute a cache key.

 The potential problem is a cache collision. Consider the following:\preformatted{output$x1 <- renderText(\{ input$x \}) \%>\% bindCache(input$x)
@@ -258,7 +258,7 @@ this, a \emph{cache hint} is automatically added when \code{\link[=renderText]{r
 \code{\link[=createRenderFunction]{createRenderFunction()}}. The cache hint is used as part of the actual
 cache key, in addition to the one passed to \code{bindCache()} by the user. The
 cache hint can be viewed by calling the internal Shiny function
-\code{extractCacheHint()}:\if{html}{\out{<div class="NA">}}\preformatted{r <- renderText(\{ input$x \})
+\code{extractCacheHint()}:\if{html}{\out{<div class="sourceCode NA">}}\preformatted{r <- renderText(\{ input$x \})
 shiny:::extractCacheHint(r)
 }\if{html}{\out{</div>}}

@@ -275,11 +275,11 @@ render function for cache collisions in a real application.
 In some cases, however, the automatic cache hint inference is not
 sufficient, and it is necessary to provide a cache hint. This is true
 for \code{renderPrint()}. Unlike \code{renderText()}, it wraps the user-provided
-expression in another function, before passing it to \code{\link[=markRenderFunction]{markRenderFunction()}}
+expression in another function, before passing it to \code{\link[=createRenderFunction]{createRenderFunction()}}
 (instead of \code{\link[=createRenderFunction]{createRenderFunction()}}). Because the user code is wrapped in
-another function, \code{markRenderFunction()} is not able to automatically
+another function, \code{createRenderFunction()} is not able to automatically
 extract the user-provided code and use it in the cache key. Instead,
-\code{renderPrint} calls \code{markRenderFunction()}, it explicitly passes along a
+\code{renderPrint} calls \code{createRenderFunction()}, it explicitly passes along a
 \code{cacheHint}, which includes a label and the original user expression.

 In general, if you need to provide a \code{cacheHint}, it is best practice to
@@ -290,19 +290,19 @@ For \pkg{htmlwidgets}, it will try to automatically infer a cache hint;
 again, you can inspect the cache hint with \code{shiny:::extractCacheHint()} and
 also test it in an application. If you do need to explicitly provide a
 cache hint, pass it to \code{shinyRenderWidget}. For example:\preformatted{renderMyWidget <- function(expr) \{
-  expr <- substitute(expr)
+  q <- rlang::enquo0(expr)

-  htmlwidgets::shinyRenderWidget(expr,
+  htmlwidgets::shinyRenderWidget(
+    q,
    myWidgetOutput,
    quoted = TRUE,
-    env = parent.frame(),
-    cacheHint = list(label = "myWidget", userExpr = expr)
+    cacheHint = list(label = "myWidget", userQuo = q)
  )
 \}
 }

 If your \code{render} function sets any internal state, you may find it useful
-in your call to \code{\link[=createRenderFunction]{createRenderFunction()}} or \code{\link[=markRenderFunction]{markRenderFunction()}} to use
+in your call to \code{\link[=createRenderFunction]{createRenderFunction()}} to use
 the \code{cacheWriteHook} and/or \code{cacheReadHook} parameters. These hooks are
 functions that run just before the object is stored in the cache, and just
 after the object is retrieved from the cache. They can modify the data
@@ -321,8 +321,8 @@ Some render functions cannot be cached, typically because they have side
 effects or modify some external state, and they must re-execute each time
 in order to work properly.

-For developers of such code, they should call \code{\link[=createRenderFunction]{createRenderFunction()}} or
-\code{\link[=markRenderFunction]{markRenderFunction()}} with \code{cacheHint = FALSE}.
+For developers of such code, they should call \code{\link[=createRenderFunction]{createRenderFunction()}} (or
+\code{\link[=markRenderFunction]{markRenderFunction()}}) with \code{cacheHint = FALSE}.
 }

 \section{Caching with \code{renderPlot()}}{
--- a/man/bindEvent.Rd
+++ b/man/bindEvent.Rd
@@ -171,7 +171,7 @@ user sets both \code{x} and \code{y}, and then clicks on an \link{actionButton}
 \code{go}.

 To use both caching and events, the object should first be passed to
-\code{bindCache()}, then \code{bindEvent()}. For example:\if{html}{\out{<div class="NA">}}\preformatted{r <- reactive(\{
+\code{bindCache()}, then \code{bindEvent()}. For example:\if{html}{\out{<div class="sourceCode NA">}}\preformatted{r <- reactive(\{
   Sys.sleep(2)  # Pretend this is an expensive computation
   input$x * input$y
 \}) \%>\%
--- a/man/clickOpts.Rd
+++ b/man/clickOpts.Rd
@@ -49,4 +49,3 @@ These functions give control over the \code{click}, \code{dblClick} and
 \seealso{
 \code{\link[=brushOpts]{brushOpts()}} for brushing events.
 }
-\keyword{internal}
--- a/man/createRenderFunction.Rd
+++ b/man/createRenderFunction.Rd
@@ -1,8 +1,10 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/shinywrappers.R
+% Please edit documentation in R/shinywrappers.R, R/utils-lang.R
 \name{createRenderFunction}
 \alias{createRenderFunction}
-\title{Implement render functions}
+\alias{quoToFunction}
+\alias{installExprFunction}
+\title{Implement custom render functions}
 \usage{
 createRenderFunction(
  func,
@@ -13,6 +15,19 @@ createRenderFunction(
  cacheWriteHook = NULL,
  cacheReadHook = NULL
 )
+
+quoToFunction(q, label = sys.call(-1)[[1]], ..stacktraceon = FALSE)
+
+installExprFunction(
+  expr,
+  name,
+  eval.env = parent.frame(2),
+  quoted = FALSE,
+  assign.env = parent.frame(1),
+  label = sys.call(-1)[[1]],
+  wrappedWithLabel = TRUE,
+  ..stacktraceon = FALSE
+)
 }
 \arguments{
 \item{func}{A function without parameters, that returns user data. If the
@@ -55,23 +70,85 @@ argument, the value retrieved from the cache. This can be useful when some
 side effect needs to occur for a render function to behave correctly. For
 example, some render functions call \code{\link[=createWebDependency]{createWebDependency()}} so that Shiny
 is able to serve JS and CSS resources.}
+
+\item{q}{Quosure of the expression \code{x}. When capturing expressions to create
+your quosure, it is recommended to use \code{\link[=enquo0]{enquo0()}} to not unquote the
+object too early. See \code{\link[=enquo0]{enquo0()}} for more details.}
+
+\item{label}{A label for the object to be shown in the debugger. Defaults to
+the name of the calling function.}
+
+\item{expr}{A quoted or unquoted expression, or a quosure.}
+
+\item{name}{The name the function should be given}
+
+\item{eval.env}{The desired environment for the function. Defaults to the
+calling environment two steps back.}
+
+\item{quoted}{Is the expression quoted?}
+
+\item{assign.env}{The environment in which the function should be assigned.}
+
+\item{wrappedWithLabel, ..stacktraceon}{Advanced use only. For stack manipulation purposes; see
+\code{\link[=stacktrace]{stacktrace()}}.}
 }
 \value{
 An annotated render function, ready to be assigned to an
 \code{output} slot.
 }
 \description{
-This function is a wrapper for \code{\link[=markRenderFunction]{markRenderFunction()}} which provides support
-for async computation via promises.
+Developer-facing utilities for implementing a custom \code{renderXXX()} function.
+Before using these utilities directly, consider using the \href{http://www.htmlwidgets.org/develop_intro.html}{\code{htmlwidgets} package} to implement custom
+outputs (i.e., custom \code{renderXXX()}/\code{xxxOutput()} functions). That said,
+these utilities can be used more directly if a full-blown htmlwidget isn't
+needed and/or the user-supplied reactive expression needs to be wrapped in
+additional call(s).
 }
+\details{
+To implement a custom \code{renderXXX()} function, essentially 2 things are needed:
+\enumerate{
+\item Capture the user's reactive expression as a function.
+\itemize{
+\item New \code{renderXXX()} functions can use \code{quoToFunction()} for this, but
+already existing \code{renderXXX()} functions that contain \code{env} and \code{quoted}
+parameters may want to continue using \code{installExprFunction()} for better
+legacy support (see examples).
+}
+\item Flag the resulting function (from 1) as a Shiny rendering function and
+also provide a UI container for displaying the result of the rendering
+function.
+\itemize{
+\item \code{createRenderFunction()} is currently recommended (instead of
+\code{\link[=markRenderFunction]{markRenderFunction()}}) for this step (see examples).
+}
+}
+}
+\section{Functions}{
+\itemize{
+\item \code{quoToFunction}: convert a quosure to a function.
+
+\item \code{installExprFunction}: converts a user's reactive \code{expr} into a
+function that's assigned to a \code{name} in the \code{assign.env}.
+}}
+
 \examples{
-# A very simple render function
-renderTriple <- function(x) {
-  x <- substitute(x)
-  if (!rlang::is_quosure(x)) {
-    x <- rlang::new_quosure(x, env = parent.frame())
-  }
-  func <- quoToFunction(x, "renderTriple")
+# A custom render function that repeats the supplied value 3 times
+renderTriple <- function(expr) {
+  # Wrap user-supplied reactive expression into a function
+  func <- quoToFunction(rlang::enquo0(expr))
+
+  createRenderFunction(
+    func,
+    transform = function(value, session, name, ...) {
+      paste(rep(value, 3), collapse=", ")
+    },
+    outputFunc = textOutput
+  )
+}
+
+# For better legacy support, consider using installExprFunction() over quoToFunction()
+renderTripleLegacy <- function(expr, env = parent.frame(), quoted = FALSE) {
+  func <- installExprFunction(expr, "func", env, quoted)

  createRenderFunction(
    func,
@@ -83,11 +160,36 @@ renderTriple <- function(x) {
 }

 # Test render function from the console
-a <- 1
-r <- renderTriple({ a + 1 })
-a <- 2
+reactiveConsole(TRUE)
+
+v <- reactiveVal("basic")
+r <- renderTriple({ v() })
 r()
-}
-\seealso{
-\code{\link[=quoToFunction]{quoToFunction()}}, \code{\link[=markRenderFunction]{markRenderFunction()}}.
+#> [1] "basic, basic, basic"
+
+# User can supply quoted code via rlang::quo(). Note that evaluation of the
+# expression happens when r2() is invoked, not when r2 is created.
+q <- rlang::quo({ v() })
+r2 <- rlang::inject(renderTriple(!!q))
+v("rlang")
+r2()
+#> [1] "rlang, rlang, rlang"
+
+# Supplying quoted code without rlang::quo() requires installExprFunction()
+expr <- quote({ v() })
+r3 <- renderTripleLegacy(expr, quoted = TRUE)
+v("legacy")
+r3()
+#> [1] "legacy, legacy, legacy"
+
+# The legacy approach also supports with quosures (env is ignored in this case)
+q <- rlang::quo({ v() })
+r4 <- renderTripleLegacy(q, quoted = TRUE)
+v("legacy-rlang")
+r4()
+#> [1] "legacy-rlang, legacy-rlang, legacy-rlang"
+
+# Turn off reactivity in the console
+reactiveConsole(FALSE)
+
 }
--- a/man/devmode.Rd
+++ b/man/devmode.Rd
@@ -101,7 +101,7 @@ displays a message once every 8 hrs (by default)
 value and Developer message. This registration method allows package
 authors to write one message in a single location.

-For example, the following Shiny Developer Mode options are registered:\if{html}{\out{<div class="r">}}\preformatted{# Reload the Shiny app when a sourced R file changes
+For example, the following Shiny Developer Mode options are registered:\if{html}{\out{<div class="sourceCode r">}}\preformatted{# Reload the Shiny app when a sourced R file changes
 register_devmode_option(
  "shiny.autoreload",
  "Turning on shiny autoreload. To disable, call `options(shiny.autoreload = FALSE)`",
@@ -126,7 +126,7 @@ register_devmode_option(
 Other known, non-Shiny Developer Mode options:
 \itemize{
 \item Sass:
-}\if{html}{\out{<div class="r">}}\preformatted{# Display the full stack trace when errors occur during Shiny app execution
+}\if{html}{\out{<div class="sourceCode r">}}\preformatted{# Display the full stack trace when errors occur during Shiny app execution
 register_devmode_option(
  "sass.cache",
  "Turning off sass cache. To use default caching, call `options(sass.cache = TRUE)`",
@@ -165,7 +165,7 @@ re-implementing these two functions:

 This function should return \code{TRUE} if \code{getOption("shiny.devmode")} is set.
 In addition, we strongly recommend that it also checks to make sure
-\code{testthat} is not testing.\if{html}{\out{<div class="r">}}\preformatted{in_devmode <- function() \{
+\code{testthat} is not testing.\if{html}{\out{<div class="sourceCode r">}}\preformatted{in_devmode <- function() \{
  isTRUE(getOption("shiny.devmode", FALSE)) &&
    !identical(Sys.getenv("TESTTHAT"), "true")
 \}
@@ -201,7 +201,7 @@ recommend displaying a message (\code{devmode_message}) to \code{stderr()} once
 hours using \code{\link[rlang:abort]{rlang::inform()}}. This will keep the author up to date as to
 which Dev Mode options are being altered. To allow developers a chance to
 disable Dev Mode messages, the message should be skipped if
-\code{getOption("shiny.devmode.verbose", TRUE)} is not \code{TRUE}.\if{html}{\out{<div class="r">}}\preformatted{get_devmode_option <- function(name, default = NULL, devmode_default, devmode_message) \{
+\code{getOption("shiny.devmode.verbose", TRUE)} is not \code{TRUE}.\if{html}{\out{<div class="sourceCode r">}}\preformatted{get_devmode_option <- function(name, default = NULL, devmode_default, devmode_message) \{
  if (!in_devmode()) \{
    # Dev Mode disabled, act like `getOption()`
    return(getOption(name, default = default))
--- a/man/exprToFunction.Rd
+++ b/man/exprToFunction.Rd
@@ -1,5 +1,5 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utils.R
+% Please edit documentation in R/utils-lang.R
 \name{exprToFunction}
 \alias{exprToFunction}
 \title{Convert an expression to a function}
@@ -7,7 +7,7 @@
 exprToFunction(expr, env = parent.frame(), quoted = FALSE)
 }
 \arguments{
-\item{expr}{A quoted or unquoted expression, or a function.}
+\item{expr}{A quoted or unquoted expression, or a quosure.}

 \item{env}{The desired environment for the function. Defaults to the
 calling environment two steps back.}
@@ -15,47 +15,14 @@ calling environment two steps back.}
 \item{quoted}{Is the expression quoted?}
 }
 \description{
-This is to be called from another function, because it will attempt to get
-an unquoted expression from two calls back. Note: as of Shiny 1.6.0, it is
-recommended to use \code{\link[=quoToFunction]{quoToFunction()}} instead.
+\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}} Please use \code{\link[=installExprFunction]{installExprFunction()}} for a better
+debugging experience (Shiny 0.8.0). If the \code{expr} and \code{quoted} parameters are not needed, please see
+\code{\link[=quoToFunction]{quoToFunction()}} (Shiny 1.6.0).
 }
 \details{
-If expr is a quoted expression, then this just converts it to a function.
-If expr is a function, then this simply returns expr (and prints a
-deprecation message).
-If expr was a non-quoted expression from two calls back, then this will
-quote the original expression and convert it to a function.
+Similar to \code{\link[=installExprFunction]{installExprFunction()}} but doesn't register debug hooks.
 }
-\examples{
-# Example of a new renderer, similar to renderText
-# This is something that toolkit authors will do
-renderTriple <- function(expr, env=parent.frame(), quoted=FALSE) {
-  # Convert expr to a function
-  func <- shiny::exprToFunction(expr, env, quoted)
-
-  function() {
-    value <- func()
-    paste(rep(value, 3), collapse=", ")
-  }
-}
-
-
-# Example of using the renderer.
-# This is something that app authors will do.
-values <- reactiveValues(A="text")
-
-\dontrun{
-# Create an output object
-output$tripleA <- renderTriple({
-  values$A
-})
-}
-
-# At the R console, you can experiment with the renderer using isolate()
-tripleA <- renderTriple({
-  values$A
-})
-
-isolate(tripleA())
-# "text, text, text"
+\seealso{
+\code{\link[=installExprFunction]{installExprFunction()}} for the modern approach to converting an expression to a function
 }
+\keyword{internal}
--- a/man/installExprFunction.Rd
+++ b/man/installExprFunction.Rd
@@ -1,50 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utils.R
-\name{installExprFunction}
-\alias{installExprFunction}
-\title{Install an expression as a function}
-\usage{
-installExprFunction(
-  expr,
-  name,
-  eval.env = parent.frame(2),
-  quoted = FALSE,
-  assign.env = parent.frame(1),
-  label = deparse(sys.call(-1)[[1]]),
-  wrappedWithLabel = TRUE,
-  ..stacktraceon = FALSE
-)
-}
-\arguments{
-\item{expr}{A quoted or unquoted expression}
-
-\item{name}{The name the function should be given}
-
-\item{eval.env}{The desired environment for the function. Defaults to the
-calling environment two steps back.}
-
-\item{quoted}{Is the expression quoted?}
-
-\item{assign.env}{The environment in which the function should be assigned.}
-
-\item{label}{A label for the object to be shown in the debugger. Defaults to
-the name of the calling function.}
-
-\item{wrappedWithLabel, ..stacktraceon}{Advanced use only. For stack manipulation purposes; see
-\code{\link[=stacktrace]{stacktrace()}}.}
-}
-\description{
-Installs an expression in the given environment as a function, and registers
-debug hooks so that breakpoints may be set in the function. Note: as of
-Shiny 1.6.0, it is recommended to use \code{\link[=quoToFunction]{quoToFunction()}} instead.
-}
-\details{
-This function can replace \code{exprToFunction} as follows: we may use
-\code{func <- exprToFunction(expr)} if we do not want the debug hooks, or
-\code{installExprFunction(expr, "func")} if we do. Both approaches create a
-function named \code{func} in the current environment.
-}
-\seealso{
-Wraps \code{\link[=exprToFunction]{exprToFunction()}}; see that method's documentation
-for more documentation and examples.
-}
--- a/man/knitr_methods.Rd
+++ b/man/knitr_methods.Rd
@@ -24,3 +24,4 @@ knit_print.reactive(x, ..., inline = FALSE)
 These S3 methods are necessary to help Shiny applications and UI chunks embed
 themselves in knitr/rmarkdown documents.
 }
+\keyword{internal}
--- a/man/markRenderFunction.Rd
+++ b/man/markRenderFunction.Rd
@@ -51,12 +51,24 @@ is able to serve JS and CSS resources.}
 The \code{renderFunc} function, with annotations.
 }
 \description{
+\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}} Please use \code{\link[=createRenderFunction]{createRenderFunction()}} to
+support async execution. (Shiny 1.1.0)
+}
+\details{
 Should be called by implementers of \code{renderXXX} functions in order to mark
 their return values as Shiny render functions, and to provide a hint to Shiny
 regarding what UI function is most commonly used with this type of render
 function. This can be used in R Markdown documents to create complete output
 widgets out of just the render function.
+
+Note that it is generally preferable to use \code{\link[=createRenderFunction]{createRenderFunction()}} instead
+of \code{markRenderFunction()}. It essentially wraps up the user-provided
+expression in the \code{transform} function passed to it, then passes the resulting
+function to \code{markRenderFunction()}. It also provides a simpler calling
+interface. There may be cases where \code{markRenderFunction()} must be used instead of
+\code{\link[=createRenderFunction]{createRenderFunction()}} -- for example, when the \code{transform} parameter of
+\code{\link[=createRenderFunction]{createRenderFunction()}} is not flexible enough for your needs.
 }
 \seealso{
-\code{\link[=createRenderFunction]{createRenderFunction()}}, \code{\link[=quoToFunction]{quoToFunction()}}
+\code{\link[=createRenderFunction]{createRenderFunction()}}
 }
--- a/man/observe.Rd
+++ b/man/observe.Rd
@@ -23,11 +23,13 @@ ignored.}

 \item{env}{The parent environment for the reactive expression. By default,
 this is the calling environment, the same as when defining an ordinary
-non-reactive expression.}
+non-reactive expression. If \code{x} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is the expression quoted? By default, this is \code{FALSE}.
-This is useful when you want to use an expression that is stored in a
-variable; to do so, it must be quoted with \code{quote()}.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{x}
+will be used when \code{x} is evaluated. If \code{x} is a quosure and you
+would like to use its expression as a value for \code{x}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{...}{Not used.}

@@ -116,12 +118,12 @@ obsB <- observe({
  print(values$A + 1)
 })

-# Can use quoted expressions
-obsC <- observe(quote({ print(values$A + 2) }), quoted = TRUE)
+# To store expressions for later conversion to observe, use rlang::quo()
+myquo <- rlang::quo({ print(values$A + 3) })
+obsC <- rlang::inject(observe(!!myquo))

-# To store expressions for later conversion to observe, use quote()
-expr_q <- quote({ print(values$A + 3) })
-obsD <- observe(expr_q, quoted = TRUE)
+# (Legacy) Can use quoted expressions
+obsD <- observe(quote({ print(values$A + 2) }), quoted = TRUE)

 # In a normal Shiny app, the web client will trigger flush events. If you
 # are at the console, you can force a flush with flushReact()
--- a/man/observeEvent.Rd
+++ b/man/observeEvent.Rd
@@ -48,21 +48,25 @@ invalidated. This should be a side-effect-producing action (the return
 value will be ignored). It will be executed within an \code{\link[=isolate]{isolate()}}
 scope.}

-\item{event.env}{The parent environment for \code{eventExpr}. By default,
-this is the calling environment.}
+\item{event.env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{eventExpr} is a quosure and \code{event.quoted} is \code{TRUE},
+then \code{event.env} is ignored.}

-\item{event.quoted}{Is the \code{eventExpr} expression quoted? By default,
-this is \code{FALSE}. This is useful when you want to use an expression
-that is stored in a variable; to do so, it must be quoted with
-\code{quote()}.}
+\item{event.quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{eventExpr}
+will be used when \code{eventExpr} is evaluated. If \code{eventExpr} is a quosure and you
+would like to use its expression as a value for \code{eventExpr}, then you must set
+\code{event.quoted} to \code{TRUE}.}

-\item{handler.env}{The parent environment for \code{handlerExpr}. By default,
-this is the calling environment.}
+\item{handler.env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{handlerExpr} is a quosure and \code{handler.quoted} is \code{TRUE},
+then \code{handler.env} is ignored.}

-\item{handler.quoted}{Is the \code{handlerExpr} expression quoted? By
-default, this is \code{FALSE}. This is useful when you want to use an
-expression that is stored in a variable; to do so, it must be quoted with
-\code{quote()}.}
+\item{handler.quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{handlerExpr}
+will be used when \code{handlerExpr} is evaluated. If \code{handlerExpr} is a quosure and you
+would like to use its expression as a value for \code{handlerExpr}, then you must set
+\code{handler.quoted} to \code{TRUE}.}

 \item{...}{Currently not used.}

@@ -99,12 +103,15 @@ happen once.}
 \code{eventReactive}. It will be executed within an \code{\link[=isolate]{isolate()}}
 scope.}

-\item{value.env}{The parent environment for \code{valueExpr}. By default,
-this is the calling environment.}
+\item{value.env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{valueExpr} is a quosure and \code{value.quoted} is \code{TRUE},
+then \code{value.env} is ignored.}

-\item{value.quoted}{Is the \code{valueExpr} expression quoted? By default,
-this is \code{FALSE}. This is useful when you want to use an expression
-that is stored in a variable; to do so, it must be quoted with \code{quote()}.}
+\item{value.quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{valueExpr}
+will be used when \code{valueExpr} is evaluated. If \code{valueExpr} is a quosure and you
+would like to use its expression as a value for \code{valueExpr}, then you must set
+\code{value.quoted} to \code{TRUE}.}
 }
 \value{
 \code{observeEvent} returns an observer reference class object (see
--- a/man/quoToFunction.Rd
+++ b/man/quoToFunction.Rd
@@ -1,31 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/utils.R
-\name{quoToFunction}
-\alias{quoToFunction}
-\title{Convert a quosure to a function for a Shiny render function}
-\usage{
-quoToFunction(q, label, ..stacktraceon = FALSE)
-}
-\arguments{
-\item{q}{A quosure.}
-
-\item{label}{A label for the object to be shown in the debugger. Defaults to
-the name of the calling function.}
-
-\item{..stacktraceon}{Advanced use only. For stack manipulation purposes; see
-\code{\link[=stacktrace]{stacktrace()}}.}
-}
-\description{
-This takes a quosure and label, and wraps them into a function that should be
-passed to \code{\link[=createRenderFunction]{createRenderFunction()}} or \code{\link[=markRenderFunction]{markRenderFunction()}}.
-}
-\details{
-This function was added in Shiny 1.6.0. Previously, it was recommended to use
-\code{\link[=installExprFunction]{installExprFunction()}} or \code{\link[=exprToFunction]{exprToFunction()}} in render functions, but now we
-recommend using \code{\link[=quoToFunction]{quoToFunction()}}, because it does not require \code{env} and
-\code{quoted} arguments -- that information is captured by quosures provided by
-\pkg{rlang}.
-}
-\seealso{
-\code{\link[=createRenderFunction]{createRenderFunction()}} for example usage.
-}
--- a/man/reactive.Rd
+++ b/man/reactive.Rd
@@ -18,16 +18,17 @@ reactive(
 is.reactive(x)
 }
 \arguments{
-\item{x}{For \code{reactive}, an expression (quoted or unquoted). For
-\code{is.reactive}, an object to test.}
+\item{x}{For \code{is.reactive()}, an object to test. For \code{reactive()}, an expression. When passing in a \code{\link[=quo]{quo()}}sure with \code{reactive()}, remember to use \code{\link[rlang:inject]{rlang::inject()}} to distinguish that you are passing in the content of your quosure, not the expression of the quosure.}

 \item{env}{The parent environment for the reactive expression. By default,
 this is the calling environment, the same as when defining an ordinary
-non-reactive expression.}
+non-reactive expression. If \code{x} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is the expression quoted? By default, this is \code{FALSE}.
-This is useful when you want to use an expression that is stored in a
-variable; to do so, it must be quoted with \code{quote()}.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{x}
+will be used when \code{x} is evaluated. If \code{x} is a quosure and you
+would like to use its expression as a value for \code{x}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{...}{Not used.}

@@ -58,21 +59,32 @@ See the \href{https://shiny.rstudio.com/tutorial/}{Shiny tutorial} for
 more information about reactive expressions.
 }
 \examples{
+library(rlang)
 values <- reactiveValues(A=1)

 reactiveB <- reactive({
  values$A + 1
 })
-
-# Can use quoted expressions
-reactiveC <- reactive(quote({ values$A + 2 }), quoted = TRUE)
-
-# To store expressions for later conversion to reactive, use quote()
-expr_q <- quote({ values$A + 3 })
-reactiveD <- reactive(expr_q, quoted = TRUE)
-
 # View the values from the R console with isolate()
 isolate(reactiveB())
+# 2
+
+# To store expressions for later conversion to reactive, use quote()
+myquo <- rlang::quo(values$A + 2)
+# Unexpected value! Sending a quosure directly will not work as expected.
+reactiveC <- reactive(myquo)
+# We'd hope for `3`, but instead we get the quosure that was supplied.
 isolate(reactiveC())
+
+# Instead, the quosure should be `rlang::inject()`ed
+reactiveD <- rlang::inject(reactive(!!myquo))
 isolate(reactiveD())
+# 3
+
+# (Legacy) Can use quoted expressions
+expr <- quote({ values$A + 3 })
+reactiveE <- reactive(expr, quoted = TRUE)
+isolate(reactiveE())
+# 4
+
 }
--- a/man/registerInputHandler.Rd
+++ b/man/registerInputHandler.Rd
@@ -51,12 +51,12 @@ registerInputHandler("mypackage.validint", function(x, shinysession, name) {
 })

 ## On the Javascript side, the associated input binding must have a corresponding getType method:
-getType: function(el) {
-  return "mypackage.validint";
-}
+# getType: function(el) {
+#   return "mypackage.validint";
+# }

 }
 }
 \seealso{
-\code{\link[=removeInputHandler]{removeInputHandler()}}
+\code{\link[=removeInputHandler]{removeInputHandler()}} \code{\link[=applyInputHandlers]{applyInputHandlers()}}
 }
--- a/man/renderCachedPlot.Rd
+++ b/man/renderCachedPlot.Rd
@@ -219,7 +219,7 @@ shinyOptions(cache = cachem::cache_mem(max_size = 20e6, max_age = 3600))
 # At the top of app.R, this set the application-scoped cache to be a disk
 # cache that can be shared among multiple concurrent R processes, and is
 # deleted when the system reboots.
-shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache"))
+shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache")))

 # At the top of app.R, this set the application-scoped cache to be a disk
 # cache that can be shared among multiple concurrent R processes, and
--- a/man/renderDataTable.Rd
+++ b/man/renderDataTable.Rd
@@ -48,16 +48,25 @@ indicate which columns to escape, e.g. \code{1:5} (the first 5 columns),
 \code{c(1, 3, 4)}, or \code{c(-1, -3)} (all columns except the first and
 third), or \code{c('Species', 'Sepal.Length')}.}

-\item{env}{The environment in which to evaluate \code{expr}.}
+\item{env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{expr} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})?
-This is useful if you want to save an expression in a variable.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{expr}
+will be used when \code{expr} is evaluated. If \code{expr} is a quosure and you
+would like to use its expression as a value for \code{expr}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{outputArgs}{A list of arguments to be passed through to the implicit
 call to \code{dataTableOutput()} when \code{renderDataTable()} is used
 in an interactive R Markdown document.}
 }
 \description{
+\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}} Please use
+\href{https://rstudio.github.io/DT/shiny.html}{\code{DT::renderDataTable()}}.
+(Shiny 0.11.1)
+
 Makes a reactive version of the given function that returns a data frame (or
 matrix), which will be rendered with the \href{https://datatables.net}{DataTables}
 library. Paging, searching, filtering, and sorting can be done on the R side
--- a/man/renderImage.Rd
+++ b/man/renderImage.Rd
@@ -15,10 +15,15 @@ renderImage(
 \arguments{
 \item{expr}{An expression that returns a list.}

-\item{env}{The environment in which to evaluate \code{expr}.}
+\item{env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{expr} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})? This
-is useful if you want to save an expression in a variable.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{expr}
+will be used when \code{expr} is evaluated. If \code{expr} is a quosure and you
+would like to use its expression as a value for \code{expr}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{deleteFile}{Should the file in \code{func()$src} be deleted after
 it is sent to the client browser? Generally speaking, if the image is a
--- a/man/renderPlot.Rd
+++ b/man/renderPlot.Rd
@@ -50,10 +50,15 @@ ggplot objects; for other plots, \code{NA} results in alt text of "Plot object".
 \code{NULL} or \code{""} is not recommended because those should be limited to
 decorative images.}

-\item{env}{The environment in which to evaluate \code{expr}.}
+\item{env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{expr} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})? This
-is useful if you want to save an expression in a variable.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{expr}
+will be used when \code{expr} is evaluated. If \code{expr} is a quosure and you
+would like to use its expression as a value for \code{expr}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{execOnResize}{If \code{FALSE} (the default), then when a plot is
 resized, Shiny will \emph{replay} the plot drawing commands with
--- a/man/renderPrint.Rd
+++ b/man/renderPrint.Rd
@@ -24,10 +24,15 @@ renderText(
 \arguments{
 \item{expr}{An expression to evaluate.}

-\item{env}{The environment in which to evaluate \code{expr}. For expert use only.}
+\item{env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{expr} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})? This
-is useful if you want to save an expression in a variable.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{expr}
+will be used when \code{expr} is evaluated. If \code{expr} is a quosure and you
+would like to use its expression as a value for \code{expr}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{width}{Width of printed output.}

--- a/man/renderTable.Rd
+++ b/man/renderTable.Rd
@@ -71,10 +71,15 @@ columns will be displayed in scientific format with a precision of
 \item{...}{Arguments to be passed through to \code{\link[xtable:xtable]{xtable::xtable()}}
 and \code{\link[xtable:print.xtable]{xtable::print.xtable()}}.}

-\item{env}{The environment in which to evaluate \code{expr}.}
+\item{env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{expr} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})?
-This is useful if you want to save an expression in a variable.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{expr}
+will be used when \code{expr} is evaluated. If \code{expr} is a quosure and you
+would like to use its expression as a value for \code{expr}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{outputArgs}{A list of arguments to be passed through to the
 implicit call to \code{\link[=tableOutput]{tableOutput()}} when \code{renderTable} is
--- a/man/renderUI.Rd
+++ b/man/renderUI.Rd
@@ -10,10 +10,15 @@ renderUI(expr, env = parent.frame(), quoted = FALSE, outputArgs = list())
 \item{expr}{An expression that returns a Shiny tag object, \code{\link[=HTML]{HTML()}},
 or a list of such objects.}

-\item{env}{The environment in which to evaluate \code{expr}.}
+\item{env}{The parent environment for the reactive expression. By default,
+this is the calling environment, the same as when defining an ordinary
+non-reactive expression. If \code{expr} is a quosure and \code{quoted} is \code{TRUE},
+then \code{env} is ignored.}

-\item{quoted}{Is \code{expr} a quoted expression (with \code{quote()})? This
-is useful if you want to save an expression in a variable.}
+\item{quoted}{If it is \code{TRUE}, then the \code{\link[=quote]{quote()}}ed value of \code{expr}
+will be used when \code{expr} is evaluated. If \code{expr} is a quosure and you
+would like to use its expression as a value for \code{expr}, then you must set
+\code{quoted} to \code{TRUE}.}

 \item{outputArgs}{A list of arguments to be passed through to the implicit
 call to \code{\link[=uiOutput]{uiOutput()}} when \code{renderUI} is used in an
--- a/man/runApp.Rd
+++ b/man/runApp.Rd
@@ -30,7 +30,10 @@ expression that produces a Shiny app object.
 \item{port}{The TCP port that the application should listen on. If the
 \code{port} is not specified, and the \code{shiny.port} option is set (with
 \code{options(shiny.port = XX)}), then that port will be used. Otherwise,
-use a random port.}
+use a random port between 3000:8000, excluding ports that are blocked
+by Google Chrome for being considered unsafe: 3659, 4045, 5060,
+5061, 6000, 6566, 6665:6669 and 6697. Up to twenty random
+ports will be tried.}

 \item{launch.browser}{If true, the system's default web browser will be
 launched automatically after the app is started. Defaults to true in
--- a/man/runExample.Rd
+++ b/man/runExample.Rd
@@ -19,7 +19,10 @@ list the available examples.}
 \item{port}{The TCP port that the application should listen on. If the
 \code{port} is not specified, and the \code{shiny.port} option is set (with
 \code{options(shiny.port = XX)}), then that port will be used. Otherwise,
-use a random port.}
+use a random port between 3000:8000, excluding ports that are blocked
+by Google Chrome for being considered unsafe: 3659, 4045, 5060,
+5061, 6000, 6566, 6665:6669 and 6697. Up to twenty random
+ports will be tried.}

 \item{launch.browser}{If true, the system's default web browser will be
 launched automatically after the app is started. Defaults to true in
--- a/man/setSerializer.Rd
+++ b/man/setSerializer.Rd
@@ -17,4 +17,3 @@ value. The returned value will be used for the test snapshot.}
 \description{
 Add a function for serializing an input before bookmarking application state
 }
-\keyword{internal}
--- a/man/shinyDeprecated.Rd
+++ b/man/shinyDeprecated.Rd
@@ -4,7 +4,13 @@
 \alias{shinyDeprecated}
 \title{Print message for deprecated functions in Shiny}
 \usage{
-shinyDeprecated(version, what, with = NULL, details = NULL)
+shinyDeprecated(
+  version,
+  what,
+  with = NULL,
+  details = NULL,
+  type = c("deprecated", "superseded")
+)
 }
 \arguments{
 \item{version}{Shiny version when the function was deprecated}
--- a/man/varSelectInput.Rd
+++ b/man/varSelectInput.Rd
@@ -76,10 +76,10 @@ value when it is a single choice input and the empty string is not in the
 The resulting server \code{input} value will be returned as:
 \itemize{
 \item A symbol if \code{multiple = FALSE}. The \code{input} value should be
-used with rlang's \code{\link[rlang:bang-bang]{rlang::!!()}}. For example,
+used with rlang's \code{\link[rlang:nse-force]{rlang::!!()}}. For example,
 \code{ggplot2::aes(!!input$variable)}.
 \item A list of symbols if \code{multiple = TRUE}. The \code{input} value
-should be used with rlang's \code{\link[rlang:bang-bang]{rlang::!!!()}} to expand
+should be used with rlang's \code{\link[rlang:nse-force]{rlang::!!!()}} to expand
 the symbol list as individual arguments. For example,
 \code{dplyr::select(mtcars, !!!input$variabls)} which is
 equivalent to \code{dplyr::select(mtcars, !!input$variabls[[1]], !!input$variabls[[2]], ..., !!input$variabls[[length(input$variabls)]])}.
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
  "homepage": "https://shiny.rstudio.com",
  "repository": "github:rstudio/shiny",
  "name": "@types/rstudio-shiny",
-  "version": "1.6.0-alpha.9021",
+  "version": "1.7.0",
  "license": "GPL-3.0-only",
  "main": "",
  "browser": "",
@@ -51,7 +51,7 @@
    "esbuild": "^0.12.4",
    "esbuild-plugin-babel": "https://github.com/schloerke/esbuild-plugin-babel#patch-2",
    "esbuild-plugin-globals": "^0.1.1",
-    "esbuild-plugin-sass": "https://github.com/schloerke/esbuild-plugin-sass#js-files-typo",
+    "esbuild-plugin-sass": "^0.5.2",
    "eslint": "^7.27.0",
    "eslint-config-prettier": "^7.2.0",
    "eslint-plugin-jest": "^24.3.6",
--- a/srcts/README.md
+++ b/srcts/README.md
@@ -1,4 +1,21 @@
-# TypeScript build tools
+# Using Shiny TypeScript Definitions
+
+When developing TypeScript projects that use `window.Shiny`, we recommend installing the Shiny TypeScript definitions to your package. To install the latest stable definitions, call
+
+```bash
+yarn add https://github.com/rstudio/shiny\#v1.7.0
+```
+
+, matching the GitHub tag to your current the Shiny CRAN release (ex: `v1.7.0`).  If you are asked to select a version of `@types/jquery`, please select the closest matching version.
+
+This will provide a global type defintion of `Shiny`, let your IDE know that `window.Shiny` is of type `Shiny`, and declare a globally available variable `Shiny` within your project. You **should not** need to import anything. Similar to `jQuery`, it should _Just Work_<sup>TM</sup>.
+
+When loading your compiled file, it should be loaded after `shiny.js` is loaded. If you are using an `htmlDependency()` to add your code to the page, your script will automatically be loaded after has been loaded.
+
+
+----------------------------------------------------
+
+# TypeScript build tools (Shiny Developers)

 All files will be described as if the working directory is the root folder of `rstudio/shiny`, not relative to this `README.md` file.

@@ -177,21 +194,6 @@ Both JavaScript files will produce a sourcemap (`**.js.map`) that the browser wi

 `./extras/globalShiny.ts` contains global declarations to define `window.Shiny`, a globally available `Shiny` variable, and a globally available `Shiny` type. This file is in a parallel folder to `./src` to avoid `Shiny` from being globally accessable within the source code. However, this file is the default type defintion when the Type definitions are installed by external developers.

-#### External development
-
-When developing TypeScript projects that leverage Shiny, we recommend installing the Shiny TypeScript definitions to your package. To install the definitions, call
-
-```bash
-yarn add https://github.com/rstudio/shiny\#v1.7.0
-```
-
-, matching the GitHub tag to your current the Shiny CRAN release (ex: `v1.7.0`).  If you are asked to select a version of `@types/jquery`, please select the closest version.
-
-This will provide a global type defintion of `Shiny`, let your IDE know that `window.Shiny` is of type `Shiny`, and declare a globally available variable `Shiny` within your project. You **should not** need to import anything. Similar to `jQuery`, it should _Just Work_<sup>TM</sup>.
-
-When loading your compiled file, it should be loaded after Shiny is loaded. If you are using an `htmlDependency()` to add your code to the page, your script will automatically be loaded after has been loaded.
-
-
 ### GitHub Actions

 On push to the `master` branch or push to a Pull Request to the `master` branch, a GitHub Action will be run to make sure the bundled JavaScript code is up to date. If the source code does not compile to the exact same file, it will be committed an pushed back to the outdated branch. (This makes it so the full build tools are not necessary for small tweaks and comments. 🎉)
--- a/srcts/build/_build.ts
+++ b/srcts/build/_build.ts
@@ -70,6 +70,7 @@ async function build(
    incremental: incremental,
    watch: watch,
    target: "es5",
+    preserveSymlinks: true,
    ...opts,
  }).then((x) => {
    onRebuild();
--- a/srcts/src/initialize/browser.ts
+++ b/srcts/src/initialize/browser.ts
@@ -37,6 +37,12 @@ function determineBrowserInfo(): void {
    setIsQt(false);
  }

+  // For Qt on Mac. Note that the target string as of RStudio 1.4.173
+  // is "QtWebEngine" and does not have a trailing slash.
+  if (/\bQt/.test(userAgent) && /\bMacintosh/.test(userAgent)) {
+    $(document.documentElement).addClass("qtmac");
+  }
+
  // Enable special treatment for Qt 5 quirks on Linux
  if (/\bQt\/5/.test(userAgent) && /Linux/.test(userAgent)) {
    $(document.documentElement).addClass("qt5");
--- a/srcts/src/shiny/init.ts
+++ b/srcts/src/shiny/init.ts
@@ -517,7 +517,7 @@ function initShiny(windowShiny: Shiny): void {
    initDeferredIframes();
  });

-  window.console.log("Shiny version: ", windowShiny.version);
+  // window.console.log("Shiny version: ", windowShiny.version);
 } // function initShiny()

 // Give any deferred iframes a chance to load.
--- a/srcts/src/shiny/shinyapp.ts
+++ b/srcts/src/shiny/shinyapp.ts
@@ -1112,8 +1112,8 @@ class ShinyApp {
          // loop through all existing tabs, find the one with highest id
          // (since this is based on a numeric counter), and increment

-          $tabset.find("a[data-toggle='tab']").each(function () {
-            const $tab = $(this);
+          $tabset.find("> li").each(function () {
+            const $tab = $(this).find("> a[data-toggle='tab']");

            if ($tab.length > 0) {
              // remove leading url if it exists. (copy of bootstrap url stripper)
--- a/tests/test-helpers/app7-port/app.R
+++ b/tests/test-helpers/app7-port/app.R
@@ -7,7 +7,7 @@ server <- function(input, output, session) {
 }

 opts <- list(
-  port = 3030,
+  port = as.numeric(Sys.getenv("SHINY_TESTTHAT_PORT_APP", "8080")),
  launch.browser = FALSE
 )

--- a/tests/test-helpers/app7-port/option-broken.R
+++ b/tests/test-helpers/app7-port/option-broken.R
@@ -1,6 +1,6 @@
 library(shiny)

-op <- options(shiny.port = 7777)
+op <- options(shiny.port = httpuv::randomPort())
 onStop(function() { options(op) })

 stop("boom")
--- a/tests/test-helpers/app7-port/option.R
+++ b/tests/test-helpers/app7-port/option.R
@@ -1,6 +1,6 @@
 library(shiny)

-op <- options(shiny.port = 7777)
+op <- options(shiny.port = as.numeric(Sys.getenv("SHINY_TESTTHAT_PORT_OPTION", "8080")))
 onStop(function() { options(op) })

 ui <- fluidPage(
--- a/tests/test-helpers/app7-port/wrapped2.R
+++ b/tests/test-helpers/app7-port/wrapped2.R
@@ -1 +1,6 @@
-shinyAppFile("wrapped.R", options = list(port = 3032))
+shinyAppFile(
+  "wrapped.R",
+  options = list(
+    port = as.numeric(Sys.getenv("SHINY_TESTTHAT_PORT_WRAPPED2", "8080"))
+  )
+)
--- a/tests/testthat/test-app.R
+++ b/tests/testthat/test-app.R
@@ -51,8 +51,7 @@ test_that("With ui/server.R, global.R is loaded before R/ helpers and into the r
  }

  # Temporarily opt-in to R/ file autoloading
-  op <- options(shiny.autoload.r=TRUE)
-  on.exit(options(op), add=TRUE)
+  withr::local_options(list(shiny.autoload.r=TRUE))

  # + shinyAppDir_serverR
  # +--- sourceUTF8
@@ -108,9 +107,7 @@ test_that("Loading supporting R files is opt-out", {
  }

  # Temporarily unset autoloading option
-  orig <- getOption("shiny.autoload.r", NULL)
-  options(shiny.autoload.r=NULL)
-  on.exit({options(shiny.autoload.r=orig)}, add=TRUE)
+  withr::local_options(list(shiny.autoload.r = NULL))

  # + shinyAppDir_serverR
  # +--- sourceUTF8
@@ -137,9 +134,7 @@ test_that("Disabling supporting R files works", {
  }

  # Temporarily unset autoloading option
-  orig <- getOption("shiny.autoload.r", NULL)
-  options(shiny.autoload.r=FALSE)
-  on.exit({options(shiny.autoload.r=orig)}, add=TRUE)
+  withr::local_options(list(shiny.autoload.r = FALSE))

  # + shinyAppDir_serverR
  # +--- sourceUTF8
@@ -165,9 +160,7 @@ test_that("app.R is loaded after R/ helpers and into the right envs", {
  }

  # Temporarily opt-in to R/ file autoloading
-  orig <- getOption("shiny.autoload.r", NULL)
-  options(shiny.autoload.r=TRUE)
-  on.exit({options(shiny.autoload.r=orig)}, add=TRUE)
+  withr::local_options(list(shiny.autoload.r = TRUE))

  # + shinyAppDir_serverR
  # +--- sourceUTF8
@@ -208,54 +201,80 @@ test_that("global.R and sources in R/ are sourced in the app directory", {
 })

 test_that("Setting options in various places works", {
-  op <- options(shiny.launch.browser = FALSE)
-  on.exit(options(op), add = TRUE)
+  withr::local_options(list(shiny.launch.browser = FALSE))
+
+  # Use random ports to avoid errors while running revdepcheck in parallel
+  # https://github.com/rstudio/shiny/pull/3488
+  # Try up to 100 times to find a unique port
+  for (i in 1:100) {
+    test_app_port      <- httpuv::randomPort()
+    test_wrapped2_port <- httpuv::randomPort()
+    test_option_port   <- httpuv::randomPort()
+    # If all ports are unique, move on
+    if (length(unique(
+      c(test_app_port, test_wrapped2_port, test_option_port)
+    )) == 3) {
+      break
+    }
+  }
+  # Use system envvars to pass values into the tests
+  withr::local_envvar(
+    list(
+      SHINY_TESTTHAT_PORT_APP      = as.character(test_app_port),
+      SHINY_TESTTHAT_PORT_WRAPPED2 = as.character(test_wrapped2_port),
+      SHINY_TESTTHAT_PORT_OPTION   = as.character(test_option_port)
+    )
+  )

  appDir <- test_path("../test-helpers/app7-port")
  withPort <- function(port, expr) {
-    op <- options(app7.port = port)
-    on.exit(options(op), add = TRUE)
+    withr::local_options(list(app7.port = port))

    force(expr)
  }

  expect_port <- function(expr, port) {
    later::later(~stopApp(), 0)
-    expect_message(expr, paste0("Listening on http://127.0.0.1:", port), fixed = TRUE)
+    testthat::expect_message(expr, paste0("Listening on http://127.0.0.1:", port), fixed = TRUE)
  }

-  expect_port(runApp(appDir), 3030)
+  expect_port(runApp(appDir), test_app_port)

  appObj <- source(file.path(appDir, "app.R"))$value
-  expect_port(print(appObj), 3030)
+  expect_port(print(appObj), test_app_port)

  appObj <- shinyAppDir(appDir)
-  expect_port(print(appObj), 3030)
+  expect_port(print(appObj), test_app_port)

  # The outermost call (shinyAppDir) has its options take precedence over the
  # options in the inner call (shinyApp in app7-port/app.R).
-  appObj <- shinyAppDir(appDir, options = list(port = 4040))
-  expect_port(print(appObj), 4040)
-  expect_port(runApp(appObj), 4040)
+  options_port <- httpuv::randomPort()
+  appObj <- shinyAppDir(appDir, options = list(port = options_port))
+  expect_port(print(appObj), options_port)
+  expect_port(runApp(appObj), options_port)

  # Options set directly on the runApp call take precedence over everything.
-  expect_port(runApp(appObj, port = 5050), 5050)
+  provided_port <- httpuv::randomPort()
+  expect_port(runApp(appObj, port = provided_port), provided_port)

  # wrapped.R calls shinyAppDir("app.R")
-  expect_port(runApp(file.path(appDir, "wrapped.R")), 3030)
+  expect_port(runApp(file.path(appDir, "wrapped.R")), test_app_port)
  # wrapped2.R calls shinyAppFile("wrapped.R", options = list(port = 3032))
-  expect_port(runApp(file.path(appDir, "wrapped2.R")), 3032)
+  expect_port(runApp(file.path(appDir, "wrapped2.R")), test_wrapped2_port)

  shiny_port_orig <- getOption("shiny.port")
  # Calls to options(shiny.port = xxx) within app.R should also work reliably
-  expect_port(runApp(file.path(appDir, "option.R")), 7777)
+  expect_port(runApp(file.path(appDir, "option.R")), test_option_port)
  # Ensure that option was unset/restored
  expect_identical(getOption("shiny.port"), shiny_port_orig)
  # options(shiny.port = xxx) is overrideable
-  appObj <- shinyAppFile(file.path(appDir, "option.R"), options = list(port = 8888))
-  expect_port(print(appObj), 8888)
+  override_port <- httpuv::randomPort()
+  appObj <- shinyAppFile(file.path(appDir, "option.R"), options = list(port = override_port))
+  expect_port(print(appObj), override_port)

  # onStop still works even if app.R has an error (ensure option was unset)
  expect_error(runApp(file.path(appDir, "option-broken.R")), "^boom$")
  expect_null(getOption("shiny.port"))
+
+
 })
--- a/tests/testthat/test-bind-cache.R
+++ b/tests/testthat/test-bind-cache.R
@@ -997,7 +997,7 @@ test_that("bindCache renderFunction basic functionality", {
 # ==============================================================================
 test_that("Custom render functions that call installExprFunction", {
  # Combinations with `installExprFunction` or `quoToFunction` plus
-  # `markRenderFunction` or `createRenderFunction` should worjk.
+  # `markRenderFunction` or `createRenderFunction` should work.

  # The expressions passed into renderDouble below should be converted into this
  # function. We'll use this for comparison.
@@ -1099,7 +1099,6 @@ test_that("Custom render functions that call installExprFunction", {
  # quoToFunction + markRenderFunction (with cacheHint): OK
  # Also, non-list cacheHint will get wrapped into a list
  renderDouble <- function(expr) {
-    # browser()
    func <- quoToFunction(enquo(expr), "renderDouble")
    markRenderFunction(textOutput,
      function() {
@@ -1263,3 +1262,55 @@ test_that("cacheHint to avoid collisions", {
    extractCacheHint(renderUI({ a + 1 }))
  ))
 })
+
+
+test_that("cacheHint works with quosures", {
+  # Cache hint ignores environment
+  my_quo <- local({
+    a <- 5
+    rlang::quo({a + 1})
+  })
+  ap1 <- rlang::expr({a+1})
+  plotCacheList <- list(userExpr = ap1, res = 72)
+  reactiveCacheList <- list(userExpr = ap1)
+  quoCacheList <- list(q = ap1)
+
+
+  # render**
+  # Regular expression, quoted quosure object, injected quosure object
+  expect_equal(
+    extractCacheHint(renderPlot({ a + 1 })),
+    plotCacheList
+  )
+  expect_equal(
+    extractCacheHint(renderPlot(my_quo, quoted = TRUE)),
+    plotCacheList
+  )
+  expect_equal(
+    extractCacheHint(inject(renderPlot(!!my_quo))),
+    plotCacheList
+  )
+
+  # reactive
+  # Regular expression, quoted quosure object, injected quosure object
+  expect_equal(
+    extractCacheHint(reactive(a + 1)),
+    reactiveCacheList
+  )
+  expect_equal(
+    extractCacheHint(reactive(my_quo, quoted = TRUE)),
+    reactiveCacheList
+  )
+  expect_equal(
+    extractCacheHint(inject(reactive(!!my_quo))),
+    reactiveCacheList
+  )
+
+  # markRenderFunction handles raw quosure objects as cacheHint
+  expect_equal(
+    extractCacheHint(
+      markRenderFunction(force, force, cacheHint = list(q = my_quo))
+    ),
+    quoCacheList
+  )
+})
--- a/tests/testthat/test-devmode.R
+++ b/tests/testthat/test-devmode.R
@@ -11,6 +11,10 @@ test_that("devmode can not be turned on while testing", {

 test_that("devmode can be turned on while _testing_ is disabled and check messages", {

+  # TODO - Once a stable version of rlang lands with `options(rlib_message_verbosity)` functionality,
+  #        bump the rlang version in DESCRIPTION and remove these skip calls
+  # Skip if *not* on CI; Inspired from `testthat::skip_on_ci()`
+  skip_if(!isTRUE(as.logical(Sys.getenv("CI"))), "Not testing in CI")
  skip_if_not_installed("rlang", "0.4.11.9000")

  # disable all existing options
--- a/tests/testthat/test-reactivity.r
+++ b/tests/testthat/test-reactivity.r
@@ -700,9 +700,9 @@ test_that("reactive() accepts injected quosures", {
  y <- quo(a)
  exp <- quo(!!y + 10)
  a <- 2
-  f <- inject(reactive(!! exp ))
+  ff <- inject(reactive(!! exp ))
  a <- 3
-  expect_identical(isolate(f()), 13)
+  expect_identical(isolate(ff()), 13)
 })

 test_that("observe() accepts injected quosures", {
--- a/tests/testthat/test-reactlog.R
+++ b/tests/testthat/test-reactlog.R
@@ -83,7 +83,7 @@ test_that("message logger appears", {
      {
        react <- reactive(val() + values$a)
      },
-      "- define: r3:'reactive(val() + values$a)' - observable ' NULL'"
+      "- define: r3:'reactive({\\n    val() + values$a\\n})' - observable ' NULL'"
    )

    expect_logs(
@@ -91,13 +91,13 @@ test_that("message logger appears", {
        react()
      },
      "- createContext: ctxDummy - isolate",
-      "- dependsOn: rDummyReactId:'DummyReactId' on r3:'reactive(val() + values$a)' in ctxDummy",
+      "- dependsOn: rDummyReactId:'DummyReactId' on r3:'reactive({\\n    val() + values$a\\n})' in ctxDummy",
      "- createContext: ctx1 - observable",
-      "- enter: r3:'reactive(val() + values$a)' in ctx1 - observable",
-      "= - dependsOn: r3:'reactive(val() + values$a)' on r1:'val' in ctx1",
+      "- enter: r3:'reactive({\\n    val() + values$a\\n})' in ctx1 - observable",
+      "= - dependsOn: r3:'reactive({\\n    val() + values$a\\n})' on r1:'val' in ctx1",
      "= - define: r2$a:'values$a' - reactiveValuesKey ' num 2'",
-      "= - dependsOn: r3:'reactive(val() + values$a)' on r2$a:'values$a' in ctx1",
-      "- exit: r3:'reactive(val() + values$a)' in ctx1 - observable"
+      "= - dependsOn: r3:'reactive({\\n    val() + values$a\\n})' on r2$a:'values$a' in ctx1",
+      "- exit: r3:'reactive({\\n    val() + values$a\\n})' in ctx1 - observable"
    )

    expect_logs(
@@ -106,13 +106,13 @@ test_that("message logger appears", {
      },
      "- valueChange: r1:'val' ' num 4'",
      "- invalidateStart: r1:'val'",
-      "= - invalidateStart: r3:'reactive(val() + values$a)' in ctx1 - observable",
+      "= - invalidateStart: r3:'reactive({\\n    val() + values$a\\n})' in ctx1 - observable",
      "= = - isolateInvalidateStart: rDummyReactId:'DummyReactId' in ctxDummy",
-      "= = = - dependsOnRemove: rDummyReactId:'DummyReactId' on r3:'reactive(val() + values$a)' in ctxDummy",
+      "= = = - dependsOnRemove: rDummyReactId:'DummyReactId' on r3:'reactive({\\n    val() + values$a\\n})' in ctxDummy",
      "= = - isolateInvalidateEnd: rDummyReactId:'DummyReactId' in ctxDummy",
-      "= = - dependsOnRemove: r3:'reactive(val() + values$a)' on r1:'val' in ctx1",
-      "= = - dependsOnRemove: r3:'reactive(val() + values$a)' on r2$a:'values$a' in ctx1",
-      "= - invalidateEnd: r3:'reactive(val() + values$a)' in ctx1 - observable",
+      "= = - dependsOnRemove: r3:'reactive({\\n    val() + values$a\\n})' on r1:'val' in ctx1",
+      "= = - dependsOnRemove: r3:'reactive({\\n    val() + values$a\\n})' on r2$a:'values$a' in ctx1",
+      "= - invalidateEnd: r3:'reactive({\\n    val() + values$a\\n})' in ctx1 - observable",
      "- invalidateEnd: r1:'val'"
    )

--- a/tests/testthat/test-render-functions.R
+++ b/tests/testthat/test-render-functions.R
@@ -32,3 +32,266 @@ test_that("Render functions correctly handle quosures", {
  expect_true(grepl("0\\.0", r1()))
  expect_true(grepl("20\\.0", r2()))
 })
+
+test_that("functionLabel returns static value when the label can not be assigned to", {
+  getFunc <- function(exprF, envF = parent.frame(), quotedF = FALSE) {
+    quoToFunction(enquo0(exprF))
+  }
+
+  expect_label <- function(func, labely) {
+    expect_equal(
+      as.character(body(func)[[2]][[1]]),
+      labely
+    )
+  }
+
+  a <- 1
+
+  expect_label(
+    getFunc({a + 1}),
+    "getFunc"
+  )
+
+  # multiline labels are not supported
+  expect_label(
+    (function(exprF) {
+      quoToFunction(enquo0(exprF))
+    })(),
+    "anonymous"
+  )
+  # parents are not supported
+  expect_label(
+    (function(exprF) {quoToFunction(enquo0(exprF))})(),
+    "anonymous"
+  )
+})
+
+local({
+
+# (must also copy logic into `lower - quoToFunction(enquo0(expr))` code)
+return_func <- function(func) {
+  function() {
+    value <- func()
+    list(value, value)
+  }
+}
+
+for (info in list(
+  list(
+    name = "exprToFunction(expr, env, quoted)",
+    fn = function(exprF, envF = parent.frame(), quotedF = FALSE) {
+      func <- exprToFunction(exprF, envF, quotedF)
+      return_func(func)
+    }
+  ),
+  list(
+    name = "exprToFunction(expr, env, quoted = TRUE)",
+    fn = function(exprF, envF = parent.frame(), quotedF = FALSE) {
+      # `exprF` coudl be a raw quosure if `inject()`ed
+      if (!quotedF) exprF <- substitute(exprF)
+      func <- exprToFunction(exprF, envF, quoted = TRUE)
+      return_func(func)
+    }
+  ),
+  list(
+    name = "exprToFunction(expr, env, quoted = TRUE) + force()",
+    fn = function(exprF, envF = parent.frame(), quotedF = FALSE) {
+      # Make `exprF` always language, even if `inject()`ed
+      if (!quotedF) exprF <- substitute(force(exprF))
+      func <- exprToFunction(exprF, envF, quoted = TRUE)
+      return_func(func)
+    }
+  ),
+  list(
+    name = "installExprFunction(expr, \"func\", env, quoted)",
+    fn = function(exprF, envF = parent.frame(), quotedF = FALSE) {
+      a <- 1000
+      installExprFunction(exprF, "func", envF, quotedF)
+      return_func(func)
+    }
+  ),
+  list(
+    name = "installExprFunction(expr, \"func\", env, quoted = TRUE)",
+    fn = function(exprF, envF = parent.frame(), quotedF = FALSE) {
+      a <- 1000
+      # `exprF` coudl be a raw quosure if `inject()`ed
+      if (!quotedF) exprF <- substitute(exprF)
+      installExprFunction(exprF, "func", envF, quoted = TRUE)
+      return_func(func)
+    }
+  ),
+  list(
+    name = "installExprFunction(expr, \"func\", env, quoted = TRUE)",
+    fn = function(exprF, envF = parent.frame(), quotedF = FALSE) {
+      a <- 1000
+      # Make `exprF` always language, even if `inject()`ed
+      if (!quotedF) exprF <- substitute(force(exprF))
+      installExprFunction(exprF, "func", envF, quoted = TRUE)
+      return_func(func)
+    }
+  ),
+  list(
+    name = "quoToFunction(enquo0(expr))",
+    fn = function(expr) {
+      func <- quoToFunction(enquo0(expr))
+      return_func(func)
+    }
+  ),
+  list(
+    name = "lower - quoToFunction(enquo0(expr))",
+    fn = function(expr) {
+      function() {
+        func <- quoToFunction(enquo0(expr))
+        value <- func()
+        list(value, value)
+      }
+    }
+  )
+)) {
+
+  # Scope the local variables
+  local({
+    renderH <- info$fn %||% stop("`info$fn` not found")
+
+    # Different usages of env and quoted param
+    a <- 1
+    e <- new.env()
+    e$a <- 10
+
+    test_that(paste0("vanilla: ", info$name), {
+      val <- renderH({a + 1})()
+      expect_identical(val, list(2, 2))
+    })
+
+    # Test that no error is thrown when the function is created
+    # This proves that the expression is not immediately evaluated
+    test_that(paste0("stop('boom'): ", info$name), {
+      expect_error(
+        renderH(stop("boom")),
+        NA
+      )
+    })
+
+    if (length(formals(renderH)) > 1) {
+      test_that(paste0("quoted = FALSE: ", info$name), {
+        r <- renderH(a + 1, quotedF = FALSE)
+        expect_identical(r(), list(2, 2))
+      })
+
+      test_that(paste0("quoted = TRUE: ", info$name), {
+        r <- renderH(quote(a + 1), quotedF = TRUE)
+        expect_identical(r(), list(2, 2))
+      })
+
+      test_that(paste0("env = e: ", info$name), {
+        r <- renderH(a + 1, envF = e)
+        expect_identical(r(), list(11, 11))
+      })
+
+      test_that(paste0("env = e, quoted = FALSE: ", info$name), {
+        r <- renderH(a + 1, envF = e, quotedF = FALSE)
+        expect_identical(r(), list(11, 11))
+      })
+
+      test_that(paste0("env = e, quoted = TRUE: ", info$name), {
+        r <- renderH(quote(a + 1), envF = e, quotedF = TRUE)
+        expect_identical(r(), list(11, 11))
+      })
+
+      test_that(paste0("Works with raw quosures, quoted = FALSE: ", info$name), {
+        e <- list2env(list(a=10))
+        x <- new_quosure(quote({ a + 1 }) , env = e)
+        r <- renderH(x, quotedF = FALSE)
+        expect_identical(r(), list(x, x))
+      })
+      test_that(paste0(
+        "Passing in a raw quosures, quoted = FALSE, env = otherenv",
+        " is treated like an expression: ", info$name),
+      {
+        e <- list2env(list(a=10))
+        x <- new_quosure(quote({ a + 1 }) , env = e)
+        other_env <- list2env(list(x=20))
+        r <- renderH(x, quotedF = FALSE, envF = e)
+        expect_identical(r(), list(x, x))
+      })
+      test_that(
+        paste0("Works with injected quosures, quoted = FALSE, env = otherenv: ", info$name), {
+        e <- list2env(list(a=10))
+        x <- new_quosure(quote({ a + 1 }) , env = e)
+        other_env <- new.env(parent = emptyenv())
+        r <- inject(renderH(!!x, quotedF = FALSE, envF = e))
+        expect_identical(r(), list(11, 11))
+      })
+      test_that(paste0("Works with raw quosures, quoted = TRUE: ", info$name), {
+        e <- list2env(list(a=10))
+        x <- new_quosure(quote({ a + 1 }) , env = e)
+        ans <- renderH(x, quotedF = TRUE)()
+        expect_identical(ans, list(11, 11))
+      })
+      test_that(paste0("Works with injecting raw quosures: ", info$name), {
+        e <- list2env(list(a=10))
+        x <- new_quosure(quote({ a + 1 }) , env = e)
+        ans <- inject(renderH(!!x))()
+        expect_identical(ans, list(11, 11))
+      })
+
+      test_that(paste0("Missing env with quosure, quoted = TRUE: ", info$name), {
+        e <- list2env(list(a=10))
+        x <- new_quosure(quote({ a + 1 }) , env = e)
+
+        ans <- renderH(x, envF = rlang::missing_arg(), quotedF = TRUE)()
+        expect_identical(ans, list(11, 11))
+      })
+
+    }
+
+    test_that(paste0("Works with inject / !!: ", info$name), {
+      # Quosures
+      a <- 1
+      r1 <- inject(renderH({ !!a }))
+      r2 <- renderH({ eval_tidy(quo(!!a)) })
+      a <- 100
+      expect_identical(r1(), list(1,1))
+      expect_identical(r2(), list(100, 100))
+    })
+  })
+}
+})
+
+
+
+test_that("nested observe events work with exprToFunction", {
+
+  val <- 0
+
+  local({
+    t1 <- reactiveVal(0)
+    t2 <- reactiveVal(10)
+    observeEvent(
+      {
+        # message("outer observeEvent trigger")
+        val <<- val + 1
+        t1()
+      },
+      {
+        # message("outer observeEvent handler")
+        val <<- val + 2
+        observeEvent(
+          {
+            # message("inner observeEvent trigger")
+            val <<- val + 3
+            t2()
+          },
+          {
+            val <<- val + 4
+            # message("inner observeEvent handler")
+          }
+        )
+      }
+    )
+  })
+
+  expect_equal(val, 0)
+  flushReact()
+  expect_equal(val, 1 + 2 + 3 + 4)
+})
--- a/tests/testthat/test-utils.R
+++ b/tests/testthat/test-utils.R
@@ -216,28 +216,21 @@ test_that("dateYMD works", {
    c("2020-01-14", "2019-11-05")
  )

-  expect_identical(
-    expect_warning(dateYMD("")),
-    ""
-  )
-  expect_identical(
-    expect_warning(dateYMD(c(NA))),
-    NA
-  )
-  expect_identical(
-    expect_warning(dateYMD(c("", NA))),
-    c("", NA)
-  )
+  expect_warning(val <- dateYMD(""))
+  expect_identical(val, "")
+
+  expect_warning(val <- dateYMD(c(NA)))
+  expect_identical(val, NA)
+
+  expect_warning(val <- dateYMD(c("", NA)))
+  expect_identical(val, c("", NA))

  # If there are any bad values, the entire thing goes through unchanged
-  expect_identical(
-    expect_warning(dateYMD(c("2019/11/05", NA))),
-    c("2019/11/05", NA)
-  )
-  expect_identical(
-    expect_warning(dateYMD(c("2019/11/05", ""))),
-    c("2019/11/05", "")
-  )
+  expect_warning(val <- dateYMD(c("2019/11/05", NA)))
+  expect_identical(val, c("2019/11/05", NA))
+
+  expect_warning(val <- dateYMD(c("2019/11/05", "")))
+  expect_identical(val, c("2019/11/05", ""))
 })

 test_that("quoToFunction handles nested quosures", {
--- a/tools/documentation/checkPkgdown.R
+++ b/tools/documentation/checkPkgdown.R
@@ -15,7 +15,6 @@ local({
    unlist(lapply(yaml::yaml.load_file(pkgdown_file)$reference, function(x) x$contents))
  }

-
  indexed_topics <- get_indexed(pkgdown_file)
  all_topics     <- get_exported()

@@ -29,30 +28,48 @@ local({
      })
    })
  )
-  # TODO check for internal help pages and not warn about them
-  # TODO .. or check that pkgdown::build_reference_index() does not produce warnings
-  known_unindexed <- c("shiny-package", "stacktrace", "knitr_methods",
-                       "pageWithSidebar", "headerPanel", "shiny.appobj",
-                       "reexports", "makeReactiveBinding",
-                       "reactiveConsole", "registerThemeDependency",
-                       "memoryCache", "diskCache", "shinyDeprecated")

  ## This test ensures that every documented topic is included in
  ## staticdocs/index.r, unless explicitly waived by specifying it
-  ## in the known_unindexed variable above.
-  missing <- setdiff(all_topics, c(known_unindexed, indexed_topics))
-  ## Explicitly add reexports man files as they will be added at shiny-dev-center documentation build time
-  unknown <- setdiff(c(known_unindexed, indexed_topics), c(all_topics, reexports_man_file_names))
+  ## as `@keywords internal`
+  no_entry_topics <- setdiff(all_topics, indexed_topics)
+  internal_topics <- unlist(lapply(
+    all_topics,
+    function(topic) {
+      topic_txt <- readLines(rprojroot::find_package_root_file(paste0("man/", topic, ".Rd")))
+      if (
+        any(grepl("\\keyword{internal}", topic_txt, fixed = TRUE)) ||
+        any(grepl("\\docType{package}", topic_txt, fixed = TRUE))
+      ) {
+        # Return internal topic name
+        topic
+      } else {
+        NULL
+      }
+    }
+  ))

-  testthat::expect_equal(length(missing), 0,
+  # # Make sure internal functions to NOT have an entry
+  # displayed_internal_topics <- internal_topics[internal_topics %in% indexed_topics]
+  # testthat::expect_equal(length(displayed_internal_topics), 0,
+  #   info = paste("Functions listed in ./tools/documentation/pkgdown.yml but has the keyword internal:\n",
+  #     paste(" - ", displayed_internal_topics, sep = "", collapse = "\n"),
+  #     "\nPlease update ./tools/documentation/pkgdown.yml or make it `#' @keywords internal`",
+  #     sep = ""))
+
+  # Make sure there are no non-internal topics have an entry
+  missing_entry_topics <- setdiff(no_entry_topics, internal_topics)
+  testthat::expect_equal(length(missing_entry_topics), 0,
    info = paste("Functions missing from ./tools/documentation/pkgdown.yml:\n",
-      paste(" - ", missing, sep = "", collapse = "\n"),
-      "\nPlease update ./tools/documentation/pkgdown.yml or ",
-      "`known_unindexed` in ./tools/documentation/checkPkgdown.R",
+      paste(" - ", missing_entry_topics, sep = "", collapse = "\n"),
+      "\nPlease update ./tools/documentation/pkgdown.yml or remove `#' @keywords internal`",
      sep = ""))
-  testthat::expect_equal(length(unknown), 0,
+
+  ## Explicitly add reexports man files as they will be added at shiny-dev-center documentation build time
+  unknown_topics <- setdiff(indexed_topics, c(all_topics, reexports_man_file_names))
+  testthat::expect_equal(length(unknown_topics), 0,
    info = paste("Unrecognized functions in ./tools/documentation/pkgdown.yml:\n",
-      paste(" - ", unknown, sep = "", collapse = "\n"),
+      paste(" - ", unknown_topics, sep = "", collapse = "\n"),
      "\nPlease update ./tools/documentation/pkgdown.yml",
      sep = ""))
  invisible(TRUE)
--- a/tools/documentation/pkgdown.yml
+++ b/tools/documentation/pkgdown.yml
@@ -89,7 +89,9 @@ reference:
      - HTML
      - include
      - singleton
-      - tag
+      - tagList
+      - tagAppendAttributes
+      - tagAppendChild
      - validateCssUnit
      - withTags
      - htmlTemplate
@@ -130,11 +132,6 @@ reference:
      - reactiveTimer
      - domains
      - freezeReactiveValue
-  - title: Boilerplate
-    desc: Functions that are required boilerplate in ui.R and server.R.
-    contents:
-      - shinyUI
-      - shinyServer
  - title: Running
    desc: Functions that are used to run or stop Shiny applications.
    contents:
@@ -177,12 +174,8 @@ reference:
      - onFlush
      - restoreInput
      - applyInputHandlers
-      - exprToFunction
-      - installExprFunction
-      - quoToFunction
      - parseQueryString
      - getCurrentOutputInfo
-      - getCurrentTheme
      - plotPNG
      - sizeGrowthRatio
      - exportTestValues
@@ -190,7 +183,6 @@ reference:
      - snapshotExclude
      - snapshotPreprocessInput
      - snapshotPreprocessOutput
-      - markOutputAttrs
      - repeatable
      - serverInfo
      - onStop
@@ -219,3 +211,10 @@ reference:
      - runTests
      - testServer
      - MockShinySession
+  - title: Superseded
+    desc: Functions that have been `r lifecycle::badge("superseded")`
+    contents:
+      - markRenderFunction
+      - shinyUI
+      - shinyServer
+      - exprToFunction
--- a/tools/documentation/reexports.json
+++ b/tools/documentation/reexports.json
@@ -11,7 +11,9 @@
    "repo": "rstudio/htmltools",
    "exports": [
      { "file": "builder.Rd", "ignore": "builder" },
-      { "file": "tag.Rd" },
+      { "file": "tagList.Rd" },
+      { "file": "tagAppendAttributes.Rd" },
+      { "file": "tagAppendChild.Rd", "ignore": "tagInsertChildren" },
      { "file": "HTML.Rd" },
      { "file": "include.Rd", "ignore": "include" },
      { "file": "singleton.Rd" },
--- a/tools/documentation/updateReexports.R
+++ b/tools/documentation/updateReexports.R
@@ -16,6 +16,9 @@ local({

  `%>%` <- magrittr::`%>%`

+  local_reexports_r_file <- rprojroot::find_package_root_file("R/reexports.R")
+  unlink(local_reexports_r_file)
+
  # pre document
  devtools::document()

@@ -23,7 +26,6 @@ local({

  alias_info <- jsonlite::fromJSON(rprojroot::find_package_root_file("tools/documentation/reexports.json"), simplifyDataFrame = FALSE)
  local_man_folder <- rprojroot::find_package_root_file("man")
-  local_reexports_r_file <- rprojroot::find_package_root_file("R/reexports.R")

  latest_tag <- memoise::memoise(function(repo) {
    # requires a GITHUB_PAT token
@@ -84,8 +86,8 @@ local({
    paste0(collapse = "\n\n\n") %>%
    paste0(
      "####\n",
-      "# Generated by `./tools/updateReexports.R`: do not edit by hand\n",
-      "# Please call `source('tools/updateReexports.R') from the root folder to update`\n",
+      "# Generated by `./tools/documentation/updateReexports.R`: do not edit by hand\n",
+      "# Please call `source('tools/documentation/updateReexports.R')` from the root folder to update`\n",
      "####\n",
      "\n",
      .
--- a/yarn.lock
+++ b/yarn.lock
@@ -1969,7 +1969,7 @@ __metadata:
    esbuild: ^0.12.4
    esbuild-plugin-babel: "https://github.com/schloerke/esbuild-plugin-babel#patch-2"
    esbuild-plugin-globals: ^0.1.1
-    esbuild-plugin-sass: "https://github.com/schloerke/esbuild-plugin-sass#js-files-typo"
+    esbuild-plugin-sass: ^0.5.2
    eslint: ^7.27.0
    eslint-config-prettier: ^7.2.0
    eslint-plugin-jest: ^24.3.6
@@ -3801,9 +3801,9 @@ __metadata:
  languageName: node
  linkType: hard

-"esbuild-plugin-sass@https://github.com/schloerke/esbuild-plugin-sass#js-files-typo":
-  version: 0.5.1
-  resolution: "esbuild-plugin-sass@https://github.com/schloerke/esbuild-plugin-sass.git#commit=1f04d94e5c2894339e428018613a43b742e0bd03"
+"esbuild-plugin-sass@npm:^0.5.2":
+  version: 0.5.2
+  resolution: "esbuild-plugin-sass@npm:0.5.2"
  dependencies:
    css-tree: ^1.1.2
    fs-extra: ^9.0.1
@@ -3811,7 +3811,7 @@ __metadata:
    tmp: ^0.2.1
  peerDependencies:
    esbuild: ">=0.11.14"
-  checksum: 2cbb57fb40b315a16b8e1fff9478b716ee1e5984388cebe1558ff52ad327a88e063f407d18a493bcef9309c9a54d84d8b1109bf1cb6b85018f0228328998546e
+  checksum: 405a7c845858cb6fc7e69fd48a55d8fe28421ec756b7d146b0d776b344c2bec7b807ebdba546bf579cd7863d9467f4d69090ca740bd96607ed046e0c6d7644fe
  languageName: node
  linkType: hard
Author	SHA1	Message	Date
Winston Chang	00775b90e8	Bump version to 1.7.1	2021-09-30 14:48:12 -05:00
Winston Chang	c6ae4c0034	Update NEWS	2021-09-30 14:48:06 -05:00
Winston Chang	1efcaa0b5d	Use esbuild option preserveSymlinks This allows the node_modules directory to be a symlink, without causing weird build problems.	2021-09-30 14:44:17 -05:00
Carson Sievert	e6d94f6f66	Fix regression in repeated appendTab()s when navbarMenu() is present (#3518 )	2021-09-30 14:43:09 -05:00
Barret Schloerke	5a8a02626c	add news item for #3512	2021-09-28 18:00:36 -04:00
Hadley Wickham	c23293750d	Re-arrange conditions for testthat 1.0.0 compatibility (#3512 )	2021-09-28 17:51:45 -04:00
Winston Chang	9de74048a2	Bump version to 1.7.0.9000	2021-09-28 16:39:35 -05:00
wch	0fc861afb4	yarn build (GitHub Actions)	2021-09-10 20:05:12 +00:00
wch	2300dae10b	sync package version (GitHub Actions)	2021-09-10 20:02:58 +00:00
wch	dfbb98abfd	Document (GitHub Actions)	2021-09-10 20:02:19 +00:00
Winston Chang	9670839235	Fix example parse errors	2021-09-10 14:55:53 -05:00
Winston Chang	1e2326c2b6	Update reexports	2021-09-10 14:46:30 -05:00
Carson	6f46b847e2	Address check NOTE: Undeclared package ‘htmlwidgets’ in Rd xrefs	2021-09-07 15:10:52 -05:00
Carson	8c44559a1f	Fix DT Rd link	2021-09-07 14:48:34 -05:00
Carson	d245a972ee	simplify gha	2021-09-07 14:23:22 -05:00
Carson	c153d0591f	bump version	2021-09-07 14:14:50 -05:00
Barret Schloerke	2ce18ef324	Update GHA workflows to use latest versions (#3492 )	2021-08-24 14:59:52 -04:00
Barret Schloerke	2792d65e40	Fix link to `DT::renderDataTable()` (#3490 )	2021-08-20 09:14:57 -05:00
Barret Schloerke	7b00f605aa	Remove `rlang` remote (#3487 )	2021-08-19 18:07:23 -04:00
Barret Schloerke	4cb3f05e8e	Adjust app port tests to use random port values (#3488 )	2021-08-19 18:06:43 -04:00
Winston Chang	8e40c815eb	Merge pull request #3485 from rstudio/wch-fix-checkbox-radio	2021-08-13 13:56:35 -05:00
Winston Chang	6dfd8bc0ff	Only ignore node_modules at top level	2021-08-13 13:50:54 -05:00
wch	2ef397f024	yarn build (GitHub Actions)	2021-08-13 18:08:05 +00:00
wch	94749f6114	yarn lint (GitHub Actions)	2021-08-13 18:08:05 +00:00
Winston Chang	4a39588d00	Update NEWS	2021-08-13 13:00:57 -05:00
Winston Chang	f5d5832149	Fix invisible checkboxes and radio buttons in RStudio on Mac	2021-08-13 12:58:12 -05:00
Barret Schloerke	68deab9b0e	Remove `console.log("Shiny version: ", Shiny.version)` statement (#3480 )	2021-08-05 18:16:39 -04:00
Winston Chang	96efac2bd7	Merge pull request #3478 from rstudio/install_expr_news_entry	2021-08-05 10:17:50 -05:00
Barret Schloerke	a67059f9f9	update news	2021-08-04 15:31:56 -04:00
Barret Schloerke	cdc51c09c7	Add test for `inject()`ed quosures when extracting the `cacheHint` (#3476 )	2021-08-04 13:35:50 -04:00
Barret Schloerke	a6f02cf214	Fix bash logic in action step (#3474 )	2021-08-02 22:35:11 -04:00
Barret Schloerke	7600770a6e	Fix Rituals workflow validating commits have not been made (#3473 )	2021-08-02 22:19:31 -04:00
Barret Schloerke	1b3ed88bd1	`exprToFunction()` and `installExprFunction()` support quosures (#3472 ) Co-authored-by: Barret Schloerke <schloerke@gmail.com> Co-authored-by: Winston Chang <winston@stdout.org> Co-authored-by: Carson Sievert <cpsievert1@gmail.com> Co-authored-by: Joe Cheng <joe@rstudio.com>	2021-08-02 22:09:19 -04:00
Barret Schloerke	f01dc9f0fb	Move user documentation up to the top of Readme (#3464 )	2021-08-02 22:06:09 -04:00
Barret Schloerke	9a65890e92	Update `esbuild-plugin-sass` to latest version (#3463 )	2021-08-02 21:41:02 -04:00
Carson Sievert	ffef0c2eb1	Interpret NULL discrete limits as NA, fixes #2666 (#2668 ) Co-authored-by: Winston Chang <winston@stdout.org> Co-authored-by: cpsievert <cpsievert@users.noreply.github.com>	2021-07-27 14:02:58 -05:00
Barret Schloerke	8b74338b0f	Add `sustainEnvAndQuoted()`. Remove `getQuosure()` (#3468 ) Documentation to come in a later PR Co-authored-by: Barret Schloerke <schloerke@gmail.com> Co-authored-by: Winston Chang <winston@stdout.org>	2021-07-26 17:54:37 -04:00
Winston Chang	ed3c676548	Merge pull request #3466 from rstudio/wch-exprfunction-fix	2021-07-16 16:14:38 -05:00
Winston Chang	30c0a2bd29	Update NEWS	2021-07-16 15:17:37 -05:00
Winston Chang	997e5e5ce5	Fix handling of getQuosure3(expr, env, quoted=TRUE)	2021-07-16 15:14:28 -05:00
Winston Chang	aba6b2e4db	Fix NEWS entry	2021-07-15 17:52:59 -05:00
Winston Chang	3f48e3b0af	Merge pull request #3462 from rstudio/wch-exprfunction-quosures	2021-07-15 17:51:22 -05:00
Winston Chang	b4879a342c	Update NEWS	2021-07-15 17:50:40 -05:00
Winston Chang	5070146061	Fix example	2021-07-15 17:21:15 -05:00
Winston Chang	d28c3e15ad	Update pkgdown.yml	2021-07-15 17:14:47 -05:00
Winston Chang	4b496be520	Update documentation	2021-07-15 17:11:36 -05:00
Winston Chang	979288a590	Add quosure tests for custom render functions	2021-07-14 16:31:23 -05:00
Winston Chang	9365d4f3c4	Update comment	2021-07-14 16:30:53 -05:00
Winston Chang	e1daf8aae7	Export getQuosure() and add internal getQuosure3()	2021-07-09 17:36:46 -05:00
Winston Chang	8a57dbf608	Rename get_quosure to getQuosure	2021-07-06 12:36:45 -05:00
Winston Chang	ac9b76c651	Modify exprToFunction to accept quosures	2021-07-02 15:45:10 -05:00
Winston Chang	139526ef2d	Move expression/quosure functions to utils-lang.R	2021-07-02 14:25:46 -05:00