Revive – Fast, configurable, extensible linter for Go
github.com
github.com
One reason golangci-linter is faster is that it shares the same in-memory representation of the linted packages between all the linters. From what I can tell, Revive requires that each rule parse the file itself, which is the same design gometalinter use, and it will absolutely kill performance for anything that needs to operate on the full AST.
Also, the Go community does not need a bunch of competing linter tools. For one, at means that tools like Visual Studio Code's Go plugin [2] will have to build special support for each linter tool. Gometalinter was nice because it built lots of rules (including golint) into a single tool, so you just needed that one tool.
I agree with the others about configuration. I think a lint tool should have a configuration work out of the box that reflects Go standards that everyone, without doubt, uses. More controversial conventions such as requiring all exported functions to have comments don't need to be included.
Revive is a project, which I started about 9 months ago but recently found time to put some finishing touches and open source it. It's not a linter aggregator; it's a framework which provides tools for reducing the friction for development of custom rules for static analysis of your applications.
And no, the individual rules in revive do not parse the files. There's an abstraction on a higher level which parses the files ones. Each rule may request type information for the package which is then cached and reused across the invocations as well. That's how revive manages to improve the performance of golint to this extent.
I wonder where you draw the line between a "linter aggregator" and a "linter". golangci-lint incorporates all the rules themselves, though it imports the linter logic as libraries, so I'm not sure that it's fair to call it an aggregator. Gometalinter runs linters as child processes and I don't think it contains any linter code, so it's a pure aggregator.
My point is that while your project is admirable, the Go world isn't large enough for so many linter projects. Personally, I just want one good linter that is maintained and that incorporates all the rules I want.
Gofmt is the canonical example (there is no configuration. It formats things like how Go code is formatted), but almost all of the go tooling sticks to similar principles and its fantastic IMO. No more pointless arguments about style because your config file doesn't match your coworkers, but you both have great reasons for why your configuration is the right one.
I guess it's less a problem with linting, so long as your local configuration is more strict than any run during CI, or other validation steps, but still, in this case I'd prefer to have less control to match the rest of the ecosystem.
The configurability is mostly due to allow developers to extend the tool with custom rules.
Allowing this gives the option to enforce even more opinionated style guide within an organization.
In fact, this is the main purpose of the tool - to provide a framework for static analysis and reduce the friction for creating custom rules.
On the other hand, there are domain-specific problems which can be solved with static analysis as well. They don't have to be style-related, they don't have to be as generic as the ones in golint, they can be on an organization or a project level.
It is often convenient to invest in tooling and automate some manual, error-prone parts of the code review process, whenever possible.
Of course, I'm not implying that everyone should proceed this way. Not all organizations can afford to invest that much time in infrastructure, nor it's necessary. That's mostly a matter of personal choice and priorities.
Disagree. Some things the Go team just could not justify putting in their checker, such as line lengths. So long as you only add restrictions and don't take any away, you are still honoring the spirit, you just acknowledge that your org may be even more stringent.
It should also disable an added rule if that rule conflicts with some new rule added by the community.
I've always been fond of the Golden Rule for code style: "All code in your project should look as if it was written by one and only one person". The Go toolchain starts you a long way down that road out of the box, with no option to even try to reignite the indent wars, or to slaughter more goats at the altar of the One True Brace. Instead, you get to focus entirely on how that rule applies to language idioms straight away, which is far more meaningful than the colour of the bikeshed or the number of spaces around an operator.
Adding linters is cool, but taking them away directly compromises that property, which I now consider far too valuable to lose.
Other than on the internet, I've never experienced pointless bikeshed arguments. So long as within an organization you keep the same standards, what difference does it make? Everywhere I've worked does this and it's fine - and allows us to be break from patterns handed down to us from people doing a different job.
This is, in sharp contrast I would add, to all my experience with code-reviews where colleagues are making style criticisms at the same time, which is an utterly useless experience that devalues the entire code review activity.
There's a network effect too. Sooner or later you'll start to notice that not only does all your organisation's code look consistent, dependencies you pull in look extremely consistent too, as if other organisations were following the same interpretation of the Golden Rule yours is following.
This has enormous benefits when you're assessing the quality of a dependency because once again, you get to walk straight past the same thousand pointless and distracting arguments you got to walk past internally (well, not you of course, but those of us who have been stuck having them!) and get right to the meat of the quality of the code you're assessing for inclusion. "Are the idioms sensible? Are the errors being propagated correctly? Is the public API neat and tidy?" That stuff, the real stuff, is all visible much more quickly when you're not rage-twitching because some other developer from some other team on the other side of the world likes to put the curly brace on a new line at the same indent level as the function body.
I had never experienced this unique benefit with any language ecosystem I worked with before Go and I'm loath to leave it behind. I'm incredibly heartened to see tools like Prettier and Black making strides in the Javascript and Python communities respectively.
Golint literally suggests scope pollution. It deserves to be replaced.
Ideally, one could configure the compiler to treat specified warnings as errors and fail the build if they are fired.
Somewhere between code formatting and type checking, there's another area which unfortunately doesn't fit in any of these two categories. For example, enforcement of style-related practices fits here but it doesn't necessarily take the entire space. That's a broad spectrum.
Revive let you develop rules which can use the Go's type system to provide style suggestions with a confidence level (just like golint), or even domain-specific rules which aim to automate other parts of the code-review process.
Such rules will often produce warnings (suggestions to developers), rather than compile-time errors.