source_file= argument to ids_with_token() and with_id()."linter"-classed functions.linter= argument of Lint().with_defaults().closed_curly_linter(), open_curly_linter(), paren_brace_linter(), and semicolon_terminator_linter().with_defaults().all_linters() has signature all_linters(..., packages) rather than all_linters(packages, ...) (#2332, @MichaelChirico). This forces packages= to be supplied by name and will break users who rely on supplying packages= positionally, of which we found none searching GitHub.extraction_operator_linter() is deprecated. Although switching from $ to [[ has some robustness benefits for package code, it can lead to non-idiomatic code in many contexts (e.g. R6 classes, Shiny applications, etc.) (#2409, @IndrajeetPatil). To enable the detection of the $ operator for extraction through partial matching, use options(warnPartialMatchDollar = TRUE).unnecessary_nested_if_linter() is deprecated and subsumed into the new/more general unnecessary_nesting_linter().cyclocomp_linter() is no longer part of the default linters (#2555, @IndrajeetPatil) because the tidyverse style guide doesn't contain any guidelines on meeting certain complexity requirements. Note that users with cyclocomp_linter() in their configs may now need to install {cyclocomp} intentionally, in particular in CI/CD pipelines.scalar_in_linter is now configurable to allow other %in% like operators to be linted. The data.table operator %chin% is no longer linted by default; use in_operators = "%chin%" to continue linting it. (@F-Noelle)lint() and friends now normalize paths to forward slashes on Windows (@olivroy, #2613).undesirable_function_linter(), undesirable_operator_linter(), and list_comparison_linter() were removed from the tag efficiency (@IndrajeetPatil, #2655). If you use linters_with_tags("efficiency") to include these linters, you'll need to adjust your config to keep linting your code against them. We did not find any such users on GitHub.expect_identical_linter() also skips expect_equal() comparison to negative non-integers like -1.034 (#2411, @Bisaloo). This is a parity fix since positive reals have always been skipped because "high-precision" comparisons are typically done to get tests within tolerance, so expect_identical() is not a great substitution.object_name_linter() no longer errors when user-supplied regexes= have capture groups (#2188, @MichaelChirico)..lintr config validation correctly accepts regular expressions which only compile under perl = TRUE (#2375, @MichaelChirico). These have always been valid (since rex::re_matches(), which powers the lint exclusion logic, also uses this setting), but the new up-front validation in v3.1.1 incorrectly used perl = FALSE..lintr configs set by option lintr.linter_file or environment variable R_LINTR_LINTER_FILE can point to subdirectories (#2512, @MichaelChirico).indentation_linter() returns ranges[1L]==1L when the offending line has 0 spaces (#2550, @MichaelChirico).literal_coercion_linter() doesn't surface a warning about NAs during coercion for code like as.integer("a") (#2566, @MichaelChirico).commented_code_linter() can detect commented code that ends with a pipe (#2671, @jcken95)return_linter() for the style guide rule that terminal returns should be left implicit (#1100, #2343, #2354, and #2356, @MEO265 and @MichaelChirico).library_call_linter() is extended
library(symbol), not library("symbol", character.only = TRUE) or "vectorized" approaches looping over package names (part of #884, @MichaelChirico).suppressMessages() or suppressPackageStartupMessages() (part of #884, @MichaelChirico).return_linter() also has arguments for fine-tuning which functions get linted:
return_style ("implicit" by default) which checks that all functions confirm to the specified return style of "implicit" or "explicit" (#2271 and part of #884, @MichaelChirico, @AshesITR and @MEO265).allow_implicit_else (default TRUE) which, when FALSE, checks that all terminal if statements are paired with a corresponding else statement (part of #884, @MichaelChirico).return_functions to customize which functions are equivalent to return() as "exit" clauses, e.g. rlang::abort() can be considered in addition to the default functions like stop() and q() from base (#2271 and part of #884, @MichaelChirico and @MEO265).except to customize which functions are ignored entirely (i.e., whether they have a return of the specified style is not checked; #2271 and part of #884, @MichaelChirico and @MEO265). Namespace hooks like .onAttach() and .onLoad() are always ignored.except_regex, the same purpose as except=, but filters functions by pattern. This is motivated by {RUnit}, where test suites are based on unit test functions matched by pattern, e.g. ^Test, and where explicit return may be awkward (#2335, @MichaelChirico).unnecessary_lambda_linter is extended to encourage vectorized comparisons where possible, e.g. sapply(x, sum) > 0 instead of sapply(x, function(x) sum(x) > 0) (part of #884, @MichaelChirico). Toggle this behavior with argument allow_comparison.backport_linter() is slightly faster by moving expensive computations outside the linting function (#2339, #2348, @AshesITR and @MichaelChirico).Linter() has a new argument linter_level (default NA). This is used by lint() to more efficiently check for expression levels than the idiom if (!is_lint_level(...)) { return(list()) } (#2351, @AshesITR).string_boundary_linter() recognizes regular expression calls like grepl("^abc$", x) that can be replaced by using == instead (#1613, @MichaelChirico).unreachable_code_linter() has an argument allow_comment_regex for customizing which "terminal" comments to exclude (#2327, @MichaelChirico). # nolint end comments are always excluded, as are {covr} exclusions (e.g. # nocov end) by default.format() and print() methods for lint and lints classes get a new option width to control the printing width of lint messages (#1884, @MichaelChirico). The default is controlled by a new option lintr.format_width; if unset, no wrapping occurs (matching earlier behavior).implicit_assignment_linter() gets a custom message for the case of using ( to induce printing like (x <- foo()); use an explicit call to print() for clarity (#2257, @MichaelChirico).lint_package() improvement of 14-27% and core linting improvement up to 30%; #2357, @AshesITR). Most linters are written around function usage, and XPath performance searching for many functions is poor. The new xml_find_function_calls() entry in the get_source_expressions() output caches all function call nodes instead. See the vignette on creating linters for more details on how to use it.todo_comment_linter() has a new argument except_regex for setting valid TODO comments, e.g. for forcing TODO comments to be linked to GitHub issues like TODO(#154) (#2047, @MichaelChirico).vector_logic_linter() is extended to recognize incorrect usage of scalar operators && and || inside subsetting expressions like dplyr::filter(x, A && B) (#2166, @MichaelChirico).any_is_na_linter() is extended to catch the unusual usage NA %in% x (#2113, @MichaelChirico).make_linter_from_xpath() errors up front when lint_message is missing (instead of delaying this error until the linter is used, #2541, @MichaelChirico).paste_linter() is extended to recommend using paste() instead of paste0() for simply aggregating a character vector with collapse=, i.e., when sep= is irrelevant (#1108, @MichaelChirico).expect_no_lint() was added as new function to cover the typical use case of expecting no lint message, akin to the recent {testthat} functions like expect_no_warning() (#2580, @F-Noelle).lint() and friends emit a message if no lints are found (#2643, @IndrajeetPatil).{lintr} now has a hex sticker (https://github.com/rstudio/hex-stickers/pull/110). Thank you, @gregswinehart!condition_call_linter() for ensuring consistent use of call. in warning() and stop(). The default call. = FALSE follows the tidyverse guidance of not displaying the call (#2226, @Bisaloo)sample_int_linter() for encouraging sample.int(n, ...) over equivalents like sample(1:n, ...) (part of #884, @MichaelChirico).stopifnot_all_linter() discourages tests with all() like stopifnot(all(x > 0)); stopifnot() runs all() itself, and uses a better error message (part of #884, @MichaelChirico).comparison_negation_linter() for discouraging negated comparisons when a direct negation is preferable, e.g. !(x == y) could be x != y (part of #884, @MichaelChirico).nzchar_linter() for encouraging nzchar() to test for empty strings, e.g. nchar(x) > 0 can be nzchar(x) (part of #884, @MichaelChirico).terminal_close_linter() for discouraging using close() to end functions (part of #884, @MichaelChirico). Such usages are not robust to errors, where close() will not be run as intended. Put close() in an on.exit() hook, or use {withr} to manage connections with proper cleanup.rep_len_linter() for encouraging use of rep_len() directly instead of rep(x, length.out = n) (part of #884, @MichaelChirico).which_grepl_linter() for discouraging which(grepl(ptn, x)) in favor of directly using grep(ptn, x) (part of #884, @MichaelChirico).list_comparison_linter() for discouraging comparisons on the output of lapply(), e.g. lapply(x, sum) > 10 (part of #884, @MichaelChirico).print_linter() for discouraging usage of print() on string literals like print("Reached here") or print(paste("Found", nrow(DF), "rows.")) (#1894, @MichaelChirico).unnecessary_nesting_linter() for discouraging overly-nested code where an early return or eliminated sub-expression (inside '{') is preferable (#2317, #2334 and part of #884, @MichaelChirico).consecutive_mutate_linter() for encouraging consecutive calls to dplyr::mutate() to be combined (part of #884, @MichaelChirico).if_switch_linter() for encouraging switch() over repeated if/else tests (#2322 and part of #884, @MichaelChirico).nested_pipe_linter() for discouraging pipes within pipes, e.g. df1 %>% inner_join(df2 %>% select(a, b)) (part of #884, @MichaelChirico).nrow_subset_linter() for discouraging usage like nrow(subset(x, conditions)) in favor of something like with(x, sum(conditions)) which doesn't require a full subset of x (#2313, #2314 and part of #884, @MichaelChirico).pipe_return_linter() for discouraging usage of return() inside a {magrittr} pipeline (part of #884, @MichaelChirico).one_call_pipe_linter() for discouraging one-step pipelines like x |> as.character() (#2330 and part of #884, @MichaelChirico).object_overwrite_linter() for discouraging re-use of upstream package exports as local variables (#2344, #2346 and part of #884, @MichaelChirico and @AshesITR).object_name_linter() and object_length_linter() ignore {rlang} name injection like x |> mutate("{new_name}" := foo(col)) (#1926, @MichaelChirico). No checking is applied in such cases. {data.table} in-place assignments like DT[, "sPoNGeBob" := "friend"] are still eligible for lints.object_usage_linter() finds global variables assigned with = or ->, which avoids some issues around "undefined global variables" in scripts (#2654, @MichaelChirico).{cli} package (#2418 and #2641, @IndrajeetPatil). All messages have been reviewed and updated to be more informative and consistent.unreachable_code_linter(allow_comment_regex=) and expect_lint(checks=).unreachable_code_linter() ignores reachable code in inline functions like function(x) if (x > 2) stop() else x (#2259, @MEO265).unnecessary_lambda_linter()
lapply(l, function(x) foo(x)$bar) (#2258, @MichaelChirico).lapply(l, function(x) "a" %in% names(x)) (#2310, @MichaelChirico).vector_logic_linter() recognizes some cases where bitwise &/| are used correctly (#1453, @MichaelChirico).expect_comparison_linter() ignores faulty usage like expect_true(x, y > z) (#2083, @MichaelChirico). Note that y > z is being passed to the info= argument, so this is likely a mistake.consecutive_assertion_linter() ignores cases where a second assertion follows an intervening assignment with = (#2444, @MichaelChirico).missing_argument_linter() catches all missing arguments in calls with several, e.g. foo(,,) gives 3 lints instead of 2 (#2399, @MichaelChirico).duplicate_argument_linter() no longer misses cases with duplicate arguments where a comment comes between the argument name and = (#2402, @MichaelChirico).infix_spaces_linter() distinguishes <-, :=, <<- and ->, ->>, i.e. infix_spaces_linter(exclude_operators = "->") will no longer exclude ->> (#2115, @MichaelChirico). This change is breaking for users relying on manually-supplied exclude_operators containing "<-" to also exclude := and <<-. The fix is to manually supply ":=" and "<<-" as well. We don't expect this change to affect many users, the fix is simple, and the new behavior is much more transparent, so we are including this breakage in a minor release.find_line() and find_column() entries from get_source_expressions() expression-level objects. These have been marked deprecated since version 3.0.0. No users were found on GitHub.?default_settings) are copied over. In particular, this removes the need to write R code in a DCF-friendly way, and allows normal R syntax highlighting in the saved file. We may eventually deprecate the DCF approach in favor of this one; user feedback is welcome on strong preferences for either approach, or for a different approach like YAML. Generally you should be able to convert your existing .lintr file to an equivalent R config by replacing the : key-value separators with assignments (<-). By default, such a config is searched for in a file named .lintr.R. This is a mildly breaking change if you happened to be keeping a file .lintr.R around since that file is given precedence over .lintr.
?default_settings. We think this is more likely to affect users declaring settings in R, since any variable defined in the config that's not a setting must be removed to make it clearer which variables are settings vs. ancillary.sprintf_linter() doesn't error in cases where whitespace in ... arguments is significant, e.g. sprintf("%s", if (A) "" else y), which won't parse if whitespace is removed (#2131, @MichaelChirico).assignment_linter() lints the {magrittr} assignment pipe %<>% (#2008, @MichaelChirico). This can be deactivated by setting the new argument allow_pipe_assign to TRUE.object_usage_linter():
glue() is glue::glue() when interpret_glue=TRUE (#2032, @MichaelChirico).glue() calls to avoid false positives for "unused objects" (#2029 and #2069, @MichaelChirico).object_name_linter() no longer attempts to lint strings in function calls on the LHS of assignments (#1466, @MichaelChirico).infix_spaces_linter() allows finer control for linting = in different scenarios using parse tags EQ_ASSIGN, EQ_SUB, and EQ_FORMALS (#1977, @MichaelChirico).equals_na_linter() checks for x %in% NA, which is a more convoluted form of is.na(x) (#2088, @MichaelChirico).# nolint next to signify the next line should skip linting (#1791, @MichaelChirico). The usual rules apply for excluding specific linters, e.g. # nolint next: assignment_linter.. The exact string used to match a subsequent-line exclusion is controlled by the exclude_next config entry or R option "lintr.exclude_next".xp_call_name() helper to facilitate writing custom linters (#2023, @MichaelChirico). This helper converts a matched XPath to the R function to which it corresponds. This is useful for including the "offending" function in the lint's message.make_linter_from_xpath() to facilitate making simple linters directly from a single XPath (#2064, @MichaelChirico). This is especially helpful for making on-the-fly/exploratory linters, but also extends to any case where the linter can be fully defined from a static lint message and single XPath.show_progress to lint_dir() and lint_package() (#972, @MichaelChirico). The default is still to show progress in interactive() sessions. Progress is also now shown with a "proper" progress bar (utils::txtProgressBar()), which in particular solves the issue of progress . spilling well past the width of the screen in large directories.lint(), lint_dir(), and lint_package() fail more gracefully when the user mis-spells an argument name (#2134, @MichaelChirico).lint_dir() by default (#2150, @dave-lovell).library_call_linter() can detect if all library/require calls are not at the top of your script (#2027, #2043, #2163, and #2170, @nicholas-masel and @MichaelChirico).keyword_quote_linter() for finding unnecessary or discouraged quoting of symbols in assignment, function arguments, or extraction (part of #884, @MichaelChirico). Quoting is unnecessary when the target is a valid R name, e.g. c("a" = 1) can be c(a = 1). The same goes to assignment ("a" <- 1) and extraction (x$"a"). Where quoting is necessary, the linter encourages doing so with backticks (e.g. x$`a b` instead of x$"a b").length_levels_linter() for using the specific function nlevels() instead of checking length(levels(x)) (part of #884, @MichaelChirico).scalar_in_linter() for discouraging %in% when the right-hand side is a scalar, e.g. x %in% 1 (part of #884, @MichaelChirico).if_not_else_linter() for encouraging if statements to be structured as if (A) x else y instead of if (!A) y else x (part of #884, @MichaelChirico).repeat_linter() for encouraging repeat for infinite loops instead of while (TRUE) (#2106, @MEO265).length_test_linter() detects the common mistake length(x == 0) which is meant to be length(x) == 0 (#1991, @MichaelChirico).fixed_regex_linter() gains an option allow_unescaped (default FALSE) to toggle linting regexes not requiring any escapes or character classes (#1689, @MichaelChirico). Thus fixed_regex_linter(allow_unescaped = TRUE) would lint on grepl("[$]", x) but not on grepl("a", x) since the latter does not use any regex special characters.line_length_linter() helpfully includes the line length in the lint message (#2057, @MichaelChirico).conjunct_test_linter() also lints usage like dplyr::filter(x, A & B) in favor of using dplyr::filter(x, A, B) (part of #884; #2110 and #2078, @salim-b and @MichaelChirico). Option allow_filter toggles when this applies. allow_filter = "always" drops such lints entirely, while "not_dplyr" only lints calls explicitly qualified as dplyr::filter(). The default, "never", assumes all unqualified calls to filter() are dplyr::filter().sort_linter() checks for code like x == sort(x) which is better served by using the function is.unsorted() (part of #884, @MichaelChirico).paste_linter() gains detection for file paths that are better constructed with file.path(), e.g. paste0(dir, "/", file) would be better as file.path(dir, file) (part of #884, #2082, @MichaelChirico). What exactly gets linted here can be fine-tuned with the allow_file_path option ("double_slash" by default, with alternatives "never" and "always"). When "always", these rules are ignored. When "double_slash", paths appearing to construct a URL that have consecutive forward slashes (/) are skipped. When "never", even URLs should be constructed with file.path().seq_linter() recommends rev() in the lint message for lints like nrow(x):1 (#1542, @MichaelChirico).function_argument_linter() detects usage of missing() for the linted argument (#1546, @MichaelChirico). The simplest fix for function_argument_linter() lints is typically to set that argument to NULL by default, in which case it's usually preferable to update function logic checking missing() to check is.null() instead.commas_linter() gains an option allow_trailing (default FALSE) to allow trailing commas while indexing. (#2104, @MEO265)unreachable_code_linter()
implicit_assignment_linter() gains an argument allow_lazy (default FALSE) that allows optionally skipping lazy assignments like A && (B <- foo(A)) (#2016, @MichaelChirico).unused_import_linter() gains an argument interpret_glue (default TRUE) paralleling that in object_usage_linter() to toggle whether glue::glue() expressions should be inspected for exported object usage (#2042, @MichaelChirico).default_undesirable_functions is updated to also include Sys.unsetenv() and structure() (#2192 and #2228, @IndrajeetPatil and @MichaelChirico).%>% consistently apply it to the other pipes %!>%, %T>%, %<>% (and possibly %$%) where appropriate (#2008, @MichaelChirico).
brace_linter()pipe_call_linter()pipe_continuation_linter()unnecessary_concatenation_linter()unnecessary_placeholder_linter()\() (#2190, @MichaelChirico).
brace_linter()function_left_parentheses_linter()indentation_linter()object_length_linter()object_name_linter()package_hooks_linter()paren_body_linter()unnecessary_lambda_linter()unreachable_code_linter()fixed_regex_linter()
x |> str_replace(fixed("a"), "b") (#1811, @MichaelChirico).pattern= as a keyword argument (#2159, @MichaelChirico).$ extractions get the same exceptions for @ extractions, e.g. S4@T will no longer throw a T_and_F_symbol_linter() hit (#2039, @MichaelChirico).
T_and_F_symbol_linter()for_loop_index_linter()literal_coercion_linter()object_name_linter()undesirable_function_linter()unreachable_code_linter()yoda_test_linter()sprintf_linter() is pipe-aware, so that x %>% sprintf(fmt = "%s") no longer lints (#1943, @MichaelChirico).condition_message_linter() ignores usages of extracted calls like env$stop(paste(a, b)) (#1455, @MichaelChirico).inner_combine_linter() no longer throws on length-1 calls to c() like c(exp(2)) or c(log(3)) (#2017, @MichaelChirico). Such usage is discouraged by unnecessary_concatenation_linter(), but inner_combine_linter() per se does not apply.sort_linter() only lints on order() of a single vector, excluding e.g. x[order(x, y)] and x[order(y, x)] (#2156, @MichaelChirico).redundant_ifelse_linter() is aware of dplyr::if_else()'s missing= argument, so that if_else(A, TRUE, FALSE, missing = FALSE) doesn't lint, but if_else(A, TRUE, FALSE, NA) does (#1941, @MichaelChirico). Note that dplyr::coalesce() or tidyr::replace_na() may still be preferable.unreachable_code_linter() finds unreachable code even in the presence of a comment or semicolon after return() or stop() (#2127, @MEO265).implicit_assignment_linter()
if (A && (B <- foo(A))) { } (#2138, @MichaelChirico).unnecessary_lambda_linter() checks for cases using explicit returns, e.g. lapply(x, \(xi) return(sum(xi))) (#1567, @MichaelChirico).
.lintr files can now be kept in the directory .github/linters for better compatibility with Super-Linter. Note that this may be a breaking change if you already have a config in .github/linters inside a subdirectory as well as in your R project's root, since the former will now be discovered first where it was ignored before. Please see vignette("lintr") for details on how configs are discovered (#1746, @tonyk7440 and @klmr).single_quotes_linter() is deprecated in favor of the more generalizable quotes_linter() (#1729, @MichaelChirico).unneeded_concatentation_linter() is deprecated in favor of unnecessary_concatenation_linter() for naming consistency (#1707, @IndrajeetPatil).consecutive_stopifnot_linter() is deprecated in favor of the more general (see below) consecutive_assertion_linter() (#1604, @MichaelChirico).no_tab_linter() is deprecated in favor of whitespace_linter() for naming consistency and future generalization (#1954, @MichaelChirico).available_linters() prioritizes tags over exclude_tags in the case of overlap, i.e., tags listed in both arguments are included, not excluded. We don't expect many people to be affected by this, and the old behavior was not made explicit in the documentation, but make note of it here since it required changing a test in lintr's own suite where linters_with_tags() implicitly assumed this behavior.lint(), lint_dir(), and lint_package() no longer accept certain arguments (cache= for lint(), relative_path= for the latter two) positionally. The warning() since 3.0.0 has been upgraded to an error.linters_with_tags() now includes the previously missing spaces around "and" when listing missing linters advertised by available_linters().
This error message may appear e.g. when you update lintr to a version with new linters but don't restart your R session (#1946, @Bisaloo)
fixed_regex_linter() is more robust to errors stemming from unrecognized escapes (#1545, #1845, @IndrajeetPatil).
get_source_expressions() can handle Sweave/Rmarkdown documents with reference chunks like <<ref_file>> (#779, @MichaelChirico).
Note that these are simply skipped, rather than attempting to retrieve the reference and also lint it.
assignment_linter() no longer lints assignments in braces that include comments when allow_trailing = FALSE (#1701, @ashbaldry)
object_usage_linter()
glue::glue() (#1919, @MichaelChirico)namespace_linter() correctly recognizes backticked operators to be exported from respective namespaces (like rlang::`%||%`) (#1752, @IndrajeetPatil)
lint_package() correctly finds a package from within a subdir if the path points to anywhere within the package (#1759, @AshesITR)
Improved error behavior in Lint(), lint() and xml_nodes_to_lints() (#1427, #763, @AshesITR)
Lint() validates its inputs more thoroughly, preventing errors during print.Lints like "Error in rep.int(character, length) : invalid 'times' value:".lint() no longer tries to create an expression tree with unexpected end of input errors, because they can be broken.xml_nodes_to_lints() warns if it can't find lint locations and uses dummy locations as a fallback.linters_with_defaults() no longer erroneously marks linter factories as linters (#1725, @AshesITR).
Row names for available_linters() data frame are now contiguous (#1781, @IndrajeetPatil).
object_name_linter() allows all S3 group Generics (see ?base::groupGeneric) and S3 generics defined in a different file in the same package (#1808, #1841, @AshesITR)
object_usage_linter() improves identification of the exact source of a lint
$ (#1914, @MichaelChirico).function_left_parentheses_linter() produces a more specific lint (and no longer fails) when the opening parenthesis is on a different line than function or the call name (#1953, @MichaelChirico). Thanks also to @IndrajeetPatil and @lorenzwalthert for identifying a regression in the initial fix, #1963.
Set the default for the except argument in duplicate_argument_linter() to c("mutate", "transmute").
This allows sequential updates like x |> mutate(a = b + 1, a = log(a)) (#1345, @IndrajeetPatil).
object_usage_linter()
skip_with argument to skip code in with() expressions. To be consistent with
R CMD check, it defaults to TRUE (#941, #1458, @IndrajeetPatil).glue("{`x`}") correctly
determines x was used (#1619, @MichaelChirico)\(...)) (#1933, @MichaelChirico)spaces_inside_linter() allows terminal missing keyword arguments (e.g. alist(arg = ); #540, @MichaelChirico)
brace_linter() allows empty braced expression on the same line (e.g. while (updating_condition()) { })
regardless of allow_single_line to match the corresponding behavior in {styler}. This is an expedient while
the style guide on handling this case awaits clarification: https://github.com/tidyverse/style/issues/191.
(#1346, @MichaelChirico)
undesirable_function_linter() and undesirable_operator_linter() now produce an error
if empty vector of undesirable functions or operators is provided (#1867, @IndrajeetPatil).
New linters which are also included as defaults (see "New linters" for more details):
indentation_linter()quotes_linter()unnecessary_concatenation_linter()whitespace_linter()lint_package() also looks for files in exec/ (#1950, @jmaspons).
New get_r_string() helper to get the R-equivalent value of a string, especially useful for R-4-style raw strings.
Previously an internal lintr helper, now exported to facilitate writing custom linters (#1493, @MichaelChirico).
object_usage_linter() improves lint metadata when detecting undefined infix operators, e.g. %>% or := (#1497, @MichaelChirico)
unused_import_linter() can detect datasets from imported packages and no longer
warns when a package is imported only for its datasets (#1545, @IndrajeetPatil).
When a linter triggers an error, lint() will provide a more actionable summary of where the
error occurred, particularly useful for cases like lint_package() where both the responsible file
and the responsible linter would be unknown (@MichaelChirico).
Typically, linters should not themselves cause R to stop -- syntax errors lead to error lints, for example. Please report such failures as they are likely bugs.
pipe_continuation_linter() recognizes violations involving the native R pipe |> (#1609, @MichaelChirico)
paste_linter() also catches usages like paste(rep("*", 10L), collapse = "") that can be written more
concisely as strrep("*", 10L) (#1108, @MichaelChirico)
spaces_inside_linter() produces lints for spaces inside [[ (#1673, @IndrajeetPatil).
sprintf_linter() also applies to gettextf() (#1677, @MichaelChirico)
Documentation for all linters contains examples of code that does and does not produce lints (#1492, @IndrajeetPatil).
implicit_integer_linter() gains parameter allow_colon to skip lints on expressions like 1:10 (#1155, @MichaelChirico)
infix_spaces_linter() supports the native R pipe |> (#1793, @AshesITR)
unnecessary_concatenation_linter() (f.k.a. unneeded_concatenation_linter()) no longer lints on c(...) (i.e., passing ... in a function call) when allow_single_expression = FALSE (#1696, @MichaelChirico)
object_name_linter() gains parameter regexes to allow custom naming conventions (#822, #1421, @AshesITR)
literal_coercion_linter() reports a replacement in the lint message, e.g. code like as.integer(1) will
suggest using 1L instead, and code like as.numeric(NA) will suggest using NA_real_ instead (#1439, @MichaelChirico)
Added format() functions for lint and lints (#1784, @AshesITR)
all_linters() function provides an easy way to access all available linters (#1843, @IndrajeetPatil)
missing_argument_linter() allows missing arguments in quote() calls (#1889, @IndrajeetPatil).
get_source_expressions() correctly extracts indented code chunks from R Markdown documents, which helps avoid spurious lints related to whitespace (#1945, @MichaelChirico). The convention taken is that, within each chunk, all code is anchored relative to the leftmost non-whitespace column.
available_linters() gives priority to tags over exclude_tags in the case of overlap. In particular, this means that available_linters(tags = "deprecated") will work to return deprecated linters without needing to specify exclude_tags (#1959, @MichaelChirico).
The {lintr} configuration file is now searched in the system's user configuration path; the lintr config filename can
also be configured explicitly by setting the environment variable R_LINTR_LINTER_FILE (#460, @klmr)
Errors in the {lintr} configuration file now produce more informative error messages (#886, @AshesITR)
matrix_apply_linter() recommends use of dedicated rowSums(), colSums(), colMeans(), rowMeans() over apply(., MARGIN, sum) or apply(., MARGIN, mean). The recommended alternative is much more efficient and more readable (#1869, @Bisaloo).
unnecessary_lambda_linter(): detect unnecessary lambdas (anonymous functions), e.g.
lapply(x, function(xi) sum(xi)) can be lapply(x, sum) and purrr::map(x, ~quantile(.x, 0.75, na.rm = TRUE))
can be purrr::map(x, quantile, 0.75, na.rm = TRUE). Naming probs = 0.75 can further improve readability (#1531, #1866, @MichaelChirico, @Bisaloo).
redundant_equals_linter() for redundant comparisons to TRUE or FALSE like is_treatment == TRUE (#1500, @MichaelChirico)
lengths_linter() for encouraging usage of lengths(x) instead of sapply(x, length) (and similar)
function_return_linter() for handling issues in function return() statements. Currently handles assignments within the return()
clause, e.g. return(x <- foo()) (@MichaelChirico)
boolean_arithmetic_linter() for identifying places where logical aggregations are more appropriate, e.g.
length(which(x == y)) == 0 is the same as !any(x == y) or even all(x != y) (@MichaelChirico)
for_loop_index_linter() to prevent overwriting local variables in a for loop declared like for (x in x) { ... } (@MichaelChirico)
is_numeric_linter() for redundant checks equivalent to is.numeric(x) such as is.numeric(x) || is.integer(x) or
class(x) %in% c("numeric", "integer") (@MichaelChirico)
empty_assignment_linter() for identifying empty assignments like x = {} that are more clearly written as x = NULL (@MichaelChirico)
unnecessary_placeholder_linter() for identifying where usage of the {magrittr} placeholder . could be omitted (@MichaelChirico)
routine_registration_linter() for identifying native routines that don't use registration (useDynLib in the NAMESPACE; @MichaelChirico)
indentation_linter() for checking that the indentation conforms to 2-space Tidyverse-style (@AshesITR and @dgkf, #1411, #1792, #1898).
unnecessary_nested_if_linter() for checking unnecessary nested if statements where a single
if statement with appropriate conditional expression would suffice (@IndrajeetPatil and @AshesITR, #1778).
implicit_assignment_linter() for checking implicit assignments in function calls (@IndrajeetPatil and @AshesITR, #1777).
quotes_linter() is a generalized version of (now deprecated) single_quotes_linter(). It accepts an argument delimiter to specify whether " or ' should be the accepted method for delimiting character literals. The default, ", reflects the Tidyverse style guide recommendation and matches the behavior of single_quotes_linter().
unnecessary_concatenation_linter() is simply unneeded_concatenation_linter(), renamed.
consecutive_assertion_linter() (f.k.a. consecutive_stopifnot_linter()) now lints for consecutive calls to assertthat::assert_that() (as long as the msg= argument is not used; #1604, @MichaelChirico).
whitespace_linter() is simply no_tab_linter(), renamed. In the future, we plan to extend it to work for different whitespace preferences.
{lintr} now depends on R version 3.5.0, in line with the tidyverse policy for R version compatibility.
lint() continues to support Rmarkdown documents. For users of custom .Rmd engines, e.g.
marginformat from {tufte} or theorem from {bookdown}, note that those engines must be registered
in {knitr} prior to running lint() in order for {lintr} to behave as expected, i.e., they should be
shown as part of knitr::knit_engines$get().
For {tufte} and {bookdown} in particular, one only needs to load the package namespace to accomplish
this (i.e., minimally loadNamespace("tufte") or loadNamespace("bookdown"), respectively, will
register those packages' custom engines; since library() also runs loadNamespace(), running
library() will also work). Note further that {tufte} only added this code to their .onLoad() recently
after our request to do so (see https://github.com/rstudio/tufte/issues/117). Therefore, ensure you're using a
more recent version to get the behavior described here for {tufte}.
More generally, there is no requirement that loadNamespace() will register a package's custom {knitr}
engines, so you may need to work with other package authors to figure out a solution for other engines.
Thanks to Yihui and other developers for their helpful discussions around this issue (#797, @IndrajeetPatil).
The output of lint() and Lint() gain S3 class "list" to assist with S3 dispatch (#1494, @MichaelChirico)
as_tibble method for class lints, conditional on {tibble} availability, to avoid dispatching to the list method which does not work with lint() output (#1997, @MichaelChirico)object_usage_linter() gives a more helpful warning when a glue() expression fails to evaluate (#1985, @MichaelChirico)
The documentation of object_name_linter() now describes how "symbols"
works when passed to the styles parameter (#1924, @hedsnz).
Skip multi-byte tests in non UTF-8 locales (#1504)
modify_defaults() no longer uses the mistaken "lintr_function" S3 class, instead applying the
"linter" class also common to Linter(). Linter() also includes "function" in the S3
class of its output to facilitate S3 dispatch to function methods where appropriate (#1392, @MichaelChirico).
brace_linter() allows opening curly braces on a new line when there is
a comment ending the preceding line (#1433 and #1434, @IndrajeetPatil).
seq_linter() produces lint for seq(...), since it also cannot properly
handle empty edge cases (#1468, @IndrajeetPatil).
seq_linter() additionally lints on 1:n() (from {dplyr})
and 1:.N (from {data.table}) (#1396, @IndrajeetPatil).
literal_coercion_linter() lints {rlang}'s atomic vector constructors
(i.e., int(), chr(), lgl(), and dbl()) if the argument is a scalar
(#1437, @IndrajeetPatil).
redundant_ifelse_linter()'s lint message correctly suggests negation when
the yes condition is 0 (#1432, @IndrajeetPatil).
seq_linter() provides more specific replacement code in lint message
(#1475, @IndrajeetPatil).
New sort_linter() to detect x[order(x)] and recommend the faster and clearer alternative: sort(x) (#1528, @Bisaloo)
unreachable_code_linter() ignores trailing comments if they match a closing nolint block (#1347, @AshesITR).
New function_argument_linter() to enforce that arguments with defaults appear last in function declarations,
see the Tidyverse design guide (#450, @AshesITR).
New allow_trailing argument added to assignment_linter() to check when assignment operators are at the
end of a line, and the value is on the following line (#1491, @ashbaldry)
New sarif_output() function to output lints to SARIF output (#1424, @shaopeng-gh)
commented_code_linter() now lints commented argument code, containing a trailing comma, as well (#386, @AshesITR).
For example a comment containing # na.rm = TRUE, now triggers a lint.
object_length_linter() does not fail in case there are dependencies with no exports (e.g. data-only packages) (#1424, #1509, @IndrajeetPatil).get_source_expressions() no longer fails on R files that match a knitr pattern (#743, #879, #1406, @AshesITR)."error" instead of NA (#1405, @AshesITR).source_expressions contain invalid string data that would cause error messages
in other linters.
in other linters.lint() from hanging on Rmd files with some syntax errors (#1443, @MichaelChirico).get_source_expressions() no longer omits trailing non-code lines from knitr files (#1400, #1415, @AshesITR).trailing_blank_lines_linter() in RMarkdown documents without terminal
newlines.vignette("lintr") incorrectly cited exclude as the key for setting file exclusions in .lintr when it is
actually exclusions. (#1401, @AshesITR)lint_dir() so it no longer errors if there are multiple exclusions or no global
exclusions configured for a single file (#1413, #1442, @AshesITR).{withr} has been bumped to 2.5.0
(#1404, @IndrajeetPatil).with_defaults() to also mention modify_defaults() (#1438, @AshesITR)..qmd) were supported out of the box. The documentation and the
testing infrastructure are updated to reflect this (#1486, @IndrajeetPatil).All linters are now function factories (i.e., functions that return functions) for consistency. Previously, only linters with customizable parameters were factories (#245, @fangly, @AshesITR, and @MichaelChirico).
This means that usage such as lint("file.R", seq_linter) should be updated to lint("file.R", seq_linter()), and
the following update for custom linters:
my_custom_linter <- function(source_expression) { ... }
# becomes
my_custom_linter <- function() Linter(function(source_expression) { ... })
Exclusions specified in the .lintr file are now relative to the location of that file
and support excluding entire directories (#158, #438, @AshesITR).
Removed long-deprecated linters (they've been marked as deprecated since v1.0.1 in 2017):
absolute_paths_linter()camel_case_linter()multiple_dots_linter()snake_case_linter()trailing_semicolons_linter()Removed return() from all_undesirable_functions because early returns (which often improve
readability and reduce code complexity) require explicit use of return(). Follow #1100 for
an upcoming return_linter() to lint unnecessary return() statements (#1146, @AshesITR).
Note that you can replicate old behavior by supplying return as a custom undesirable function:
undesirable_function_linter(c(all_undesirable_functions, list(return = NA)))
linter that caused them instead of the name of their implementation
function. Deprecated the obsolete linter argument of Lint() (#664, #673, #746, @AshesITR). Downstream custom
linters should follow suit.semicolon_terminator_linter() to semicolon_linter() for better consistency.
semicolon_terminator_linter() survives but is marked for deprecation. The new linter also has a new signature,
taking arguments allow_compound and allow_trailing to replace the old single argument semicolon, again for
signature consistency with other linters.brace_linter() and are now deprecated; see the item on brace_linter()
below:
closed_curly_linter()open_curly_linter()paren_brace_linter()... argument for lint(), lint_dir(), and lint_package() has been promoted to an earlier position to
better match the Tidyverse design principle of
data->descriptor->details. This change enables passing objects to ... without needing to specify non-required
arguments, e.g. lint_dir("/path/to/dir", linter()) now works without the need to specify relative_path.
This affects some code that uses positional arguments (#935, @MichaelChirico).
lint(), ... is now the 3rd argument, where earlier this was cache.lint_dir() and lint_package(), ... is now the 2nd argument, where earlier this was relative_path.source_file to exported functions with_id() and ids_with_token(). It has been renamed to
source_expression to better reflect that this argument is typically the output of get_source_expressions().
For now, the old argument source_file can still be used (with warning). The now-private functional versions of many
linters also underwent the same renaming (source_file -> source_expression). This has no direct effect on
packages importing lintr, but is mentioned in case custom linters imitating lintr style had also adopted the
source_file naming and want to adapt to keep in sync.with_defaults() in favor of linters_with_defaults(), and add modify_defaults() which is intended to
be used more generally to modify (i.e., extend, trim, and/or update) a list of defaults. Note that the argument
corresponding to with_defaults()'s default= is called defaults= (i.e., pluralized) in both of these, and that
usage like with_defaults(default = NULL, ...) should be converted to linters_with_defaults(defaults = list(), ...)
(#1029, #1336, #1361, @AshesITR and @michaelchirico).find_line() and find_column() helpers from the item-level expressions returned with
get_source_expressions(). These helpers were typically associated with regex-based logic for building linters,
which is rarely needed and prone to false positives; now that lintr almost exclusively uses XPath-based
logic for linters, these are no longer necessary (#1373, @MichaelChirico).default_lintersbrace_linter() which combines several curly brace related linters, deprecating the following predecessors
(#1041, @AshesITR):
closed_curly_linter(); both now also allow }] in addition to }) and }, as exceptions, i.e., } doesn't
need to be on its own line if paired with a closing square bracket, a closing parenthesis, or a comma. Also
improved lint metadata so that source markers land at the closing brace instead of the closing parenthesis to
improve the experience of fixing the lint (#583, @AshesITR).open_curly_linter(); both also no longer lint unnecessary trailing whitespace (use trailing_whitespace_linter()
for this) and also allow (, ,, and %>% on preceding lines as exceptions, i.e., { can be alone on a line if
the previous line is terminated with an opening parenthesis, a comma, or a pipe (%>%) (#487, #1028, @AshesITR).paren_brace_linter(); brace_linter() also lints if/else and repeat with missing whitespace.brace_linter() also newly enforces the following rules surrounding curly braces (originally Google linters, see
below):
else to come on the same line as the preceding }, if present (#884, @MichaelChirico).{} in if/else conditions, i.e., if the if branch uses braces,
then so must the else branch, and vice versa (#983, @MichaelChirico).paren_body_linter() checks that there is a space between a right parenthesis and a body expression (#809,
@kpagacz).semicolon_linter() as a default because it enforces a tidyverse style guide rule (#683, @AshesITR).assignment_linter() (#915, @MichaelChirico):
-> and ->>).allow_cascading_assign (TRUE by default) toggles whether to lint <<- and ->>.allow_right_assign (FALSE by default) toggles whether to lint -> and ->>.commented_code_linter(): use the parse tree to find comments, eliminating some false positives (#451, @AshesITR).equals_na_linter() (#545, @MichaelChirico):
x != NA (before, only == was caught) and NA == x (before, only NA on RHS was caught).is.na(x) # use is.na(x), not x == NA.function_left_parentheses_linter(): improved location information (#1266, #1267, @AshesITR).infix_spaces_linter():
allow_multiple_spaces (TRUE by default) which toggles
whether to generate a lint for operators used with multiple spaces, e.g. x + 2.
The default setting allows extra spacing to be used to increase
line-to-line alignment (#940, @f-ritter and @MichaelChirico).a~b and function(a=1) { ... } are linted (#930, #michaelchirico).exclude_operators to disable lints on selected infix operators.
By default, all "low-precedence" operators throw lints; see ?infix_spaces_linter for an enumeration of these.
(#914, @MichaelChirico)./ usage in box::use() declarations (#1087, @klmr).line_length_linter(): place the source marker at the margin of the affected line to improve user experience
during de-linting -- just press Return (#735, @AshesITR).*no_tab_linter(): use more reliable matching (e.g., excluding matches found in comments; #441, @russHyde).object_length_linter(): correctly detect generics and only count the implementation class towards the length.
This prevents false positive lints in the case of long generic names, e.g.
very_very_very_long_generic_name.short_class no longer produces a lint (#871, @AshesITR).object_name_linter():
my_method.upstream.class,
upstream.class no longer throws a lint because the generic (my_method)
properly uses snake_case (#737, @AshesITR)..onLoad() (#500, #614, @AshesITR and @MichaelChirico).names<-.class_name (#843, @jonkeane)."symbols" and "SNAKE_CASE" (#494, #495, #615, #670, @MichaelChirico and @AshesITR).
"symbols" is a new default style which won't lint all-symbol object names. In particular, that means
operator names like %+% are allowed.$ extractions (#582, @AshesITR).object_usage_linter():
glue::glue() constructs (#942, @AshesITR).= instead of <- (#1081, @MichaelChirico).library() or
require() calls (#1127, @AshesITR).assign() and setMethod() (#1322, @AshesITR).spaces_inside_linter(): ignore spaces preceding trailing comments (#636, @MichaelChirico).T_and_F_symbol_linter():
trailing_blank_lines_linter():
trailing_whitespace_linter():
allow_empty_lines (FALSE by default) to toggle this behavior.allow_in_strings (TRUE by default) to toggle this behavior.undesirable_function_linter():
default_undesirable_functions related to debugging (#876, @MichaelChirico):
browser()debug()debugcall()debugonce()trace()untrace()library() and require() calls attaching a package with an undesired name,
e.g. library(foo) (#814, @kpagacz and @MichaelChirico).$ extractions (#1050, @AshesITR).undesirable_operator_linter() (#1133, #1146, #1159, @AshesITR).cyclocomp_linter(): set the default complexity_limit to 15. This brings the default into sync with what
is enforced via default_linters (#693, @AshesITR).lint_package() now lints files in the demo directory by default (#703, @dmurdoch).~/.R/lintr_cache (which was a violation of
CRAN policy) to R_user_dir("lintr", "cache"). Note that 3.0.0 is a major version update and invalidates
the old cache anyway, so it can be safely deleted (#1062, @AshesITR).backport_linter() for detecting mismatched R version dependencies (#506, #1316, #1318, #1319, @MichaelChirico and
@AshesITR).duplicate_argument_linter() similarly checks that there are no duplicate arguments supplied to function calls (#850,
@renkun-ken).missing_argument_linter() to check for empty (missing) arguments in function calls (#563, #1152, @renkun-ken and
@AshesITR).missing_package_linter() to check if packages in calls to library() and friends
are missing (#536, #1037, @renkun-ken and @MichaelChirico).namespace_linter() to check for common mistakes in pkg::symbol usages (#548, @renkun-ken).package_hooks_linter() to run a series of checks also done by R CMD check on the .onLoad(), .onAttach(),
.Last.lib() and .onDetach() hooks (#882, @MichaelChirico).pipe_call_linter() to enforce that all steps of magrittr pipelines use explicit calls instead of symbols,
e.g. x %>% mean() instead of x %>% mean (#801, @MichaelChirico).sprintf_linter() to check for common mistakes in sprintf() usage (#544, #624, @renkun-ken and @AshesITR).unused_import_linter() to detect unnecessary library() calls in R scripts (#239, @jimhester, @AshesITR).Google is a heavy user of lintr internally, and has developed a large set of linters improving code consistency and correcting common R usage mistakes. This release includes many of these linters that are of general interest to the broader R community. More will be included in future releases. See, e.g. #884, #979, #998, #1011, #1016, #1036, #1051, #1066, and #1067; special thanks to @MichaelChirico and @michaelquinn32.
any_duplicated_linter() Require usage of anyDuplicated(x) > 0L over any(duplicated(x)) and similar.any_is_na_linter() Require usage of anyNA(x) over any(is.na(x)).class_equals_linter() Prevent comparing class(x) with ==, !=, or %in%, where inherits() is typically
preferred.condition_message_linter() Prevent condition messages from being constructed like stop(paste(...))
(where just stop(...) is preferable).conjunct_test_linter() Require usage of expect_true(x); expect_true(y) over expect_true(x && y) and similar.consecutive_stopifnot_linter() Require consecutive calls to stopifnot() to be unified into one.expect_comparison_linter() Require usage of expect_gt(x, y) over expect_true(x > y) and similar.expect_identical_linter() Require usage of expect_identical() by default, and expect_equal() only by exception.expect_length_linter() Require usage of expect_length(x, n) over expect_equal(length(x), n) and similar.expect_named_linter() Require usage of expect_named(x, n) over expect_equal(names(x), n) and similar.expect_not_linter() Require usage of expect_false(x) over expect_true(!x), and vice versa.expect_null_linter() Require usage of expect_null(x) over expect_equal(x, NULL) and similar.expect_s3_class_linter() Require usage of expect_s3_class(x, k) over expect_equal(class(x), k) and similar.expect_s4_class_linter() Require usage of expect_s4_class(x, k) over expect_true(methods::is(x, k)).expect_true_false_linter() Require usage of expect_true(x) over expect_equal(x, TRUE) and similar.expect_type_linter() Require usage of expect_type(x, t) over expect_equal(typeof(x), t) and similar.fixed_regex_linter() Require fixed = TRUE or stringr::fixed() for regular expressions that can be
expressed statically, e.g. strsplit(x, "[.]") can be strsplit(x, ".", fixed = TRUE).
allow_grepl (default FALSE) to toggle whether grepl() usages should be linted.
These might be treated separately because grepl("^x", NA) is FALSE; the startsWith() equivalent to
get FALSE for missing input is clunkier, but more explicit: !is.na(x) & startsWith(x, string) (#1376, @MichaelChirico).ifelse_censor_linter() Require usage of pmax() / pmin() where appropriate, e.g. ifelse(x > y, x, y) is
pmax(x, y).inner_combine_linter() Require inputs to known-vectorized functions to be combined first rather than later,
e.g. as.Date(c(x, y)) over c(as.Date(x), as.Date(y)).literal_coercion_linter() Require using correctly-typed literals instead of direct coercion, e.g. 1L instead of
as.numeric(1).nested_ifelse_linter() Prevent nested calls to ifelse() like ifelse(A, x, ifelse(B, y, z)), and similar.numeric_leading_zero_linter() Require a leading 0 in fractional numeric constants, e.g. 0.1 instead of .1.outer_negation_linter() Require usage of !any(x) over all(!x) and !all(x) over any(!x).paste_linter() lint for common mis-use of paste() and paste0():
paste0() encouraged instead of paste(sep = "").toString() or glue::glue_collapse() encouraged instead of paste(x, collapse = ", ").sep= passed to paste0() -- typically a mistake.redundant_ifelse_linter() Prevent usage like ifelse(A & B, TRUE, FALSE) or ifelse(C, 0, 1)
(the latter is as.numeric(!C)).regex_subset_linter() Require usage of grep(ptn, x, value = TRUE) over x[grep(ptn, x)] and similar.string_boundary_linter() Require usage of startsWith(x, ptn) over grepl("^ptn", x) or substr(x, 1, 3) == ptn
and similar.strings_as_factors_linter() Check for code designed to work before and after the stringsAsFactors = FALSE default
change in R 4.0 by examining code for data.frame() usages susceptible to assumptions about the default value
of stringsAsFactors=.system_file_linter() Prevent usage like file.path(system.file("A", package = "pkg"), "B") where simply
system.file("A", "B", package = "pkg") is more concise and readable.unreachable_code_linter() Prevent code after return() and stop() statements that will never be reached
(extended for #1051 thanks to early user testing, thanks @bersbersbers!).vector_logic_linter() Require use of scalar logical operators (&& and ||) inside if() conditions and similar.yoda_test_linter() Require usage of expect_identical(x, 1L) over expect_equal(1L, x) and similar.?linters also links to tag help pages, collecting linters with a similar goal.available_linters(): new function to list available linters and their tags.
This feature is extensible by package authors providing add-on linters for {lintr}.available_tags(): new function to list available tags.linters_with_tags(): new function to help build a list of linters using tags.encoding setting of lintr (#752, #782, @AshesITR).get_source_expressions() resulting in
about 2x speedup in our test suite and even more for complex files (#1169, #1197, #1200, #1201, #1214, @MichaelChirico
and @AshesITR). Average lint_package() execution time is down about 30% and the median package sees about 40%
improvement.R"( a\string )"
(#1034, #1285, @MichaelChirico and @AshesITR).# nolint: linter_name, linter2_name. or # nolint start: linter_name, linter2_name.
in source files or named lists of line numbers in .lintr. Note the terminal . is required.
Also allows for partial matching as long as the supplied prefix is unique, e.g.
# nolint: infix_spaces. works to exclude infix_spaces_linter (#605, #872, @AshesITR).
UseMethod() is called after several
preceding expressions (#846, @jonkeane).extraction_operator_linter(): no longer lint x[NULL] (#1273, @AshesITR).is_lint_level(): new exported helper for readably explaining which type of expression is required for a custom
linter. Some linters are written to require the full file's parse tree (for example, single_quotes_linter()).
Others only need single expressions, which is more cache-friendly (most linters are written this way to leverage
caching) (#921, @MichaelChirico).lint_dir() excludes the renv and packrat directories by default (#697, @AshesITR).lint(): new optional argument text for supplying a line or lines directly, e.g. if the file is already
in memory or linting is being done ad hoc (#503, @renkun-ken).seq_linter(): improve lint message to be clearer about the reason for linting (#522, @MichaelChirico).unneeded_concatenation_linter():
%>% or |>; #573, #1270, @michaelquinn32 and @AshesITR).allow_single_expression, default TRUE, toggling whether c(x) should be linted, i.e.,
a call to c() with only one entry which is not a constant. In some such cases, c() can simply be dropped,
e.g. c(a:b); in others, the parentheses are still needed, e.g. -c(a:b) should be -(a:b);
and in still others, c() is used for the side-effect of stripping attributes, e.g.
c(factor(letters)) or c(matrix(1:10, 5, 2)). In this last case, c() can (and should) in most cases
be replaced by as.vector() or as.integer() for readability. In fact, we suspect it is always
preferable to do so, and may change the default to allow_single_expression = FALSE in the future. Please
report your use case if as.vector() does not suit your needs (#1344, @MichaelChirico).use_lintr(): new exported helper for creating a minimal .lintr configuration (#902, @AshesITR).xml_nodes_to_lints(): new exported helper for converting xml_node objects obtained using linter logic
expressed in XPath into Lint objects (#1124, #1216, #1234, @MichaelChirico and @AshesITR).get_source_expressions():
xmlparsedata::xml_parse_data() (#559, @renkun-ken).getParseData() returns a truncated (invalid) Unicode character as parsed text (#815,
@leogama).text value for STR_CONST nodes involving 1- or 2-width octal escapes
(e.g. "\1") to account for an R parser bug (https://bugs.r-project.org/show_bug.cgi?id=18323; #1056,
@MichaelChirico).line_length_linter(): fix a bug causing duplicate lints for lines containing multiple expressions (#681, @AshesITR).lint_package():
NULL if no package is found (instead of giving a peculiar error message; #776,
@MichaelChirico).DESCRIPTION are ignored (#702,
@MichaelChirico).linters_with_defaults() (formerly with_defaults()):
linters_with_defaults() handles automatic naming of very long arguments correctly (#774, @MichaelChirico).save_cache() will now recursively create the cache directory; this avoids errors that could arise if any parent
directories do not exist (#60, @dankessler).spaces_left_parentheses_linter(): fix a bug causing warnings like "In parent == parent[before_operator_idx]
longer object length is not a multiple of shorter object length" in nested expressions (#654, @AshesITR).test-package - that fails on warnings emitted by tests
(#1263, #1272, @AshesITR).lint-changed-files - for newly written / modified code
(#641, @dragosmg).Imported packages have become Suggested dependencies: httr, testthat, and rstudioapi.
This should allow snappier CI builds for usages not relying on some more "peripheral" features of the package.R CMD check. Code coverage and
linting are implemented using separate GitHub Actions workflows (#572, @dragosmg).lintr now uses the 3rd edition of testthat (@MichaelChirico, @AshesITR, #910, #967).lint_package() will now lint vignettes and data-raw by default (#447, @AshesITR).lint_dir() will now include Rmd and Rnw files by default (@AshesITR).single_quote_linter() no longer causes a print issue when open quote
appears at a column > than close quote (#457, @jamieRowen)absolute_path_linter() and nonportable_path_linter() now handle
file-paths that are wrapped with double-quotes (#433, #437, @russHyde).get_source_expressions() has been changed to handle expr_or_assign_or_help
tokens arising when parsing code containing equals-assignments in R-devel
(#403, #456, @russHyde).object_usage_linter has been changed to ensure lint-position is indicated
relative to the start of the file, rather than the start of a defining
function (#432, @russHyde).commas_linter now allows spaces to come before a comma when used to denote a
fall-through in a switch statement (#499, @MrMallIronmaker)lintr 2.0.0 is a major release, and incorporates development changes since the last major release (1.0.0) in 2016-04-16.
camel_case_linter(), snake_case_linter() and multiple_dots_linter()
in favor of object_name_linter() which enforce the given style: snake_case,
dotted.case, lowerCamelCalse, UpperCamelCase, alllowercase or ALLUPPERCASE
(#59, @fangly).absolute_path_linter(),
with a lax mode for fewer false positive lints (#199, @fangly).cyclocomp_linter() identifies overly complex functions (#361, @fabian-s)equals_na_linter() (#143, #326, @jabranham)extraction_operator_linter() checks that the [[ operator is used when
extracting a single element from an object, not [ (subsetting) nor $
(interactive use) (@fangly).function_left_parentheses_linter() to check that there is no space between
a function name and its left parentheses (#204, @jrnold).implicit_integer_linter() detects round numbers not declared as integers,
i.e. 1 instead of 1L (@fangly).nonportable_path_linter() identifies paths constructed without file.path()
(@fangly).paren_brace_linter() checks that there is a space between right
parenthesis and an opening curly brace (@bfgray3, #242).pipe_continuation_linter() to ensure there is a space before %>% and newline afterwards (#216).semicolon_terminator_linter() reports semicolons at the end of a line (#147,
@gaborcsardi) and between expressions (#181, @fangly).seq_linter(), finds 1:length(...) (and similar) expressions (#155, @gaborcsardi)todo_comment_linter() lints TODOs (@fangly).T_and_F_symbol_linter() warns when using T and F instead of TRUE and FALSE
(@fangly).undesirable_operator_linter() and undesirable_function_linter() lint uses of
user-specified functions and operators (#48, #149, @fangly).unneeded_concatenation_linter() lints uses of c() with a constant or no
arguments (@fangly).expect_lint() (#178, #210)ids_with_token() and with_id() (#297 @stufield)lint_dir() function to lint files under a given directory (@arekbee, #360)summary.lints() function to summarize the linter results (#260, #262, @wlandau).checkstyle_output() function to output lints to checkstyle XML output (#156, @joshkgold)closed_curly_linter() now allows closing parenthesis or comma after closing curly brace (#167, @Enchufa2)commas_linter() now handles missing arguments calls properly (#145)commented_code_linter() now relaxed, it no longer lints comments within roxygen blocks
and does not consider "-" an R operator to avoid too many false positives.function_left_parentheses_linter() now allows spaces if a function starts with a left parenthesis (#311)no_tab_linter() now reports proper line in all cases (#134, @fangly)object_length_linter() argument length now defaults to 30 for consistency (#325 @DragosMG)object_name_linter() now works when passed multiple styles (#341, @infotroph)object_usage_linter() has been changed to better detect lexical scoping of global variables (#27, #336, #91, #382)object_usage_linter() now respects utils::globalVariables(), so it can be used to avoid false positive warnings due to non-standard evaluation (#352)object_usage_linter() now ignores top level calls that contain function definitions (#26).object_linter*()s now only lint objects declared in the current file
(#76, #108, #136, #191, #194, #201, @fangly).open_curly_linter() and closed_curly_linter() now do not lint double curly syntax (#388)open_curly_linter() now allows comments after the curly braces (#188)pipe_continuation_linter() now behaves better in nested expressions, functions etc. (#366 @russHyde)space_inside_linter() now reports proper line and column numbers (#203, @fangly)expect_lint() now no longer shows Rstudio markers and error messages are correctly preserved (#180, #211, @fangly)Lint() / as.data.frame() error now fixed (#179, @fangly).lint() no longer errors with inline \\Sexpr (#127).lint() no longer errors with '<% %>' constructs (#185).lint_package() now works with the cache, as intended (#146, @schloerke)lint_package() now excludes R/RcppExports.R by default (#282)lint_package() now removes fully excluded files as soon as possibleseq_linter is now one of the default linters (#316).read_settings() now has a better error message when the config file does
not end with a newline (#160, #189)expect_lint_free() is now automatically skipped when run on covr (#287)GITHUB_TOKEN environment
variable (#63, @mattyb)# to start a comment. Useful in ESS (#299, @prosoitos)engine format were parsed from R-markdown (#322, @russHyde)lintr runs / installs / tests on R-3.6: pinned to github
xmlparsedata; ensure vectors are length-1 when compared using && and ||
(#363 #377 #384 #391, @russHyde).expect_lint_free() now is always skipped on CRAN. This is necessary because
the non-binary R source may not be available when running tests on CRAN, and
those tests may not be run in the package directory.= in named arguments. (#130, @saurfang).( type (#128, @saurfang)names.lints, split.lints (#49, @ttriche).lintr config files.globalenv() instead of baseenv() for default parent environment so
that methods will be included.trailing_whitespace_linter was reporting the incorrect line number# nolint comments are respected with caching (#68, @krlmlr)