{ / } and line breaks in function calls

[lorenzwalthert]

The tidyverse style guide states in section 2.4 that

A } should always go on its own line, unless it’s followed by else or ).

So that's why we implemented remove_line_break_before_round_closing() which is responsible for
the line breaks removed in tikzDevice.

I personally think that's fine, but we may only include this rule if strict = TRUE.

Also it says that a { should never go on its own line and should always be followed by a new line, so

tryCatch(
{
  ...
} 

from the above-referenced commit is in my eyes not compliant with the tidyverse style guide.

[krlmlr]

The rules might need a refinement. In this example, the closing brace } belongs to an argument that is indented already, which is why indenting the closing parenthesis looks wrong:

# good
fun(arg, {
  block
})

fun(
  arg,
  {
    block
  }
)

fun(
  {
    block
  },
  arg
)

# bad

fun({
  block
},
{
  another block
})

fun(
  arg,
  {
    another block
  })

[lorenzwalthert]

I am not sure whether I understand you correctly. Why is

fun(
  arg,
  {
    block
  }
)

a good example with regard to the second rule cited? Shouldn't it be

fun(
  arg, {
    block
  }
)

or even

fun(
  arg, {
    block
})

Also

fun(
  arg,
  {
    another block
  })

is bad, I agree, but I thought

fun(
  arg, {
    another block
})

would be correct, so } is unindented since a ) follows.

[krlmlr]

I haven't found a specification for long function calls in the tidyverse guide. Maybe we could contribute one, that also covers complex function arguments that consists of whole blocks?

No need to hurry though, I'm fine with this limitation for now.

[krlmlr]

Attempt to formulate a line-break rule:

A multi-line argument to a function must start on a new line, unless it's the last argument (like test_that(..., {}) and all other arguments fit on one line.

A function call must either fit on one line, or have a line break after the opening ( with the arguments indented. Exceptions are switch() and ifelse()/if_else(), and calls where the only multi-line argument is the last argument.

Example: #125 (comment)

# good
switch(var,
  case1 = ,
  case2 = "val",
  "default_val"
)

switch(var,
  case1 = {
  },
  case2 = {
  },
  {
  }
)

if_else(cond,
  true_val,
  false_val,
  na_val
)

regular_call(
  usually,
  all,
  arguments,
  go,
  on,
  a,
  separate,
  line,
  maybe,
  only,
  `if`,
  strict = TRUE
)

regular_call(all, args, fit)

# bad
regular_call(usually, all,
  arguments, ...)

regular_call(
  usually, all,
  arguments, ...)

[krlmlr]

Another potential exception, perhaps if all arguments are multi-line?

tryCatch({
  block
},
error = function(e) {
  handler
},
finally = {
  cleanup
})

Maybe not for the tidyverse style, but it looks like a valid option for other styles.

[lorenzwalthert]

I suggested a function to add a line break after the opening parenthesis if the expression is a function call, see #118 (comment). Should we implement that for the CRAN milestone or not? Otherwise,

long_call(1, 
          k * 3)

Will become just

long_call(1, 
  k * 3)

[krlmlr]

Did you mean

long_call(
  1,
  k * 3
)

?

[lorenzwalthert]

In the meanwhile, I implemented #149, which does what you wrote, yes. Otherwise, just removing the rule we had (update_indention_ref_fun_dec()) would result in what I wrote.

[lorenzwalthert]

Reference: #254.