Issue title: Style/GuardClause false positive
 Issue body: The following example:

```ruby
def foo(args)
  if args.nil?
    raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing'
  end
end
```

Will result in the following offense being detected:

```
foo.rb:2:3: C: Use a guard clause instead of wrapping the code inside a conditional expression.
```

The problem is that the line will be too long if change the code to use a guard clause. If I add some additional code to the method I don't get the above offense:

```ruby
def foo(args)
  if args.nil?
    raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing'
  end

  3
end
```

I would expect that no offense is reported for the first code example.

```
$ rubocop -V
0.46.0 (using Parser 116.69.203.115, running on ruby 2.1.5 x86_64-darwin15.0)
```
 Comments: 
 Comment 0: Hi @jacob-carlborg, one thing I've done in the past for situations like this is breaking out the arguments into their own fewer-chars variables. In you example:

```rb
def foo(args)
  msg = 'Lorem ipsum dolor sit amet, consectetur adipisicing'
  raise(ArgumentError, msg) if args.nil?
end
```

I tend to like that a bit more, although that's just a matter of choice. I hope this helps 😃 
 Comment 1: I thought about doing that as well, but the real issue, in my opinion is the different behavior depending on if the method only contains the if statement or some else as well.
 Comment 2: RuboCop is looking for:

```
def foo(args)
  return unless args.nil?
  raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing'
end
```

> [...] the real issue, in my opinion is the different behavior depending on if the method only contains the if statement or something else as well.

This is intended, as:

```
def foo(args)
  if args.nil?
    raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing'
  end
  3
end
```

is different from:

```
def foo(args)
  return unless args.nil?
  raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing'
  3
end
```

where `3` would be unreachable.
 Comment 3: Hmm, I see. Would it be possible, somehow, to clarify that in the message?
 Comment 4: I'm not sure how much clearer "Use a guard clause" can be. Perhaps the message could include a link to https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals
 Comment 5: @mikegee: I think the issue here was caused by there being two possible guard clauses, the other being:

```
raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing' if args.nil?
```

which would violate the line length cop, but I also don't see a way of making it clearer. 😕 
 Comment 6: @mikegee I could only think of the guard clause that Drenmi refers to.
@Drenmi what about: `Use a guard clause with early return instead ...`

Hmm, actually, I think I'm mixing up "if modifier" and "guard clause". According to [the guidelines](https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals) a "guard clause" returns from the method.

I think, that according to the guidelines, the above:

```ruby
raise ArgumentError, 'Lorem ipsum dolor sit amet, consectetur adipisicing' if args.nil?
```

Is not a "guard clause" but instead a "if modifier". I guess it's just me that confuses the terms.
 Comment 7: > Is not a "guard clause" but instead a "if modifier". I guess it's just me that confuses the terms.

Exactly.
{'source': 'GithubIssues', 'repo_name_with_owner': 'rubocop/rubocop', 'issue_id': 197204195, 'repo_stars': 12026.0}