Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

* fix(deps): update module golang.org/x/tools to v0.39.0

* Bump `golangci-lint` and fix issues

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Simon Sawert <simon@sawert.se>

* Allow cuddling mutex locking/unlocking

Restore removed support to more tightly cuddle mutex locking and
unlocking. This is no longer configurable and hard coded to the selected
few defaults from before.

It is not limited to a set number of statements between and it is not
restricted to specific type of statements, basically anything can be
cuddled below `Lock` and the statement calling `Unlock` can be cuddled
with anything.

Fixes #218

* Address linting

* Update docs

* Don't decent into blocks

* Exit as early as possible looking for selector

* Add support for `newline-after-block`

This adds a new check type to enforce newline after any block (closing
`}`). In addition, it also makes the check for empty line while using
`case-max-lines` a bit more strict by now _not_ counting a trailing
comment as an empty line.

While doing this, there's a new column based logic to figure out where
the newline should go in the end of a case. If it's aligned with the
last statement of the case body the line is inserted after. If it's
aligned with then next case arm, the line is inserted before the
comment.

While working on this we're also moving to a line based check that uses
`LineStart` to make replacements and with that simplifying some comment
parsing since we only need to know the pos where the line starts. This
also allowed to add support to fix removal of whitespaces both before
_and_ after leading comments in blocks.

* Use `ast.Pos` when checking comments

We don't need to check line number to find relevant comments, if we
instead use the `ast.Pos` as long as possible we save a ton of
conversions and gets some speed improvement.

* Make `isErrNotNilCheck` check stmt type

Removes extra check for statement type before calling function.

Also adds a more detailed comment to why we skip complex groups.

* Don't create `CommentMap` for file

* Improve trailing case comments handling

* Add support to remove newline after left-aligned comment

Similar to how we do support trailing comments in a block, but no
newline after the comment, we want to support left-aligned comments in
case bodies but keep them flush against the next case.

* Improve method name

* Use constant instead of magic number

* Improve finding comments after blocks

* Consider comments when checking case total lines

* Remove more `NewCommentMap` calls

* Skip `FuncLit` for newline after block

We don't really need a `CommentMap` to find comments. In fact, creating
a `CommentMap` is still iterating over all comments in a file to build
it. Instead of deferring that and allocating a map, we can just iterate
like this ourselves.

This will improve performance, especially in the cases where we created
a `CommentMap` _before_ we decided if a check was enabled and it wasn't.

We only have `checkExpr` to recursively find `ast.FuncList` to check its
block. We do this both recursively but also for each known node that has
an expression.

Since we only care about the `FuncLit` it's better to just use
`ast.Inspect` and check block for both `FuncDecl` and `FuncLit` already
in `Run`.

This removes a lot of code and might also be faster potentially. We
might get diagnostics out of order but we never guaranteed a specific
order.