In particular, the issue occurs because the testdata Go file in question has no suggested fixes. So RunWithSuggestedFixes skips the file during its assertions.

Ideally files that don't have suggested fixes are still compared against a golden file: some test authors may write tests to ensure that no fixes are suggested for a given file, and that the file remains unchanged after applying (the zero) suggested fixes.

cc @matloob @timothy-king @guodongli-google @zpavlinovic

Documentation:

// RunWithSuggestedFixes behaves like Run, but additionally verifies suggested fixes.
// It uses golden files placed alongside the source code under analysis:
// suggested fixes for code in example.go will be compared against example.go.golden.

I think there is a reasonable interpretation here that the .golden file is only needed for verifying fixes, and if there are no fixes, [there] is no need to look at a .golden file. This lets folks use this as the "super" operator if they want utilities that can test analyzers both with and without fixes.

I think an alternative reading of this as suggesting that it will always compare against a golden file is also kinda reasonable. This would mean tightening the contact of this function.

If we tighten the contract of RunWithSuggestedFixes(), we may want another function to act as the generalization of these two modes. If we don't, we might want to clarify the documentation of this function for what happens if there are no suggested edits/no golden file.

This change would break existing users that use RunWithSuggestedFixes() without specifying a golden file. For example, https://github.com/dominikh/go-tools/blob/master/simple/testdata/src/CheckSortHelpers/LintSortHelpers.go

some test authors may write tests to ensure that no fixes are suggested for a given file, and that the file remains unchanged after applying (the zero) suggested fixes.

I believe you can already write such tests by not specifying a golden file or giving a no-op golden file. But I believe the only way to distinguish between 0 edits and all edits combined are a no-op is by not giving a golden file. This is more implicit, but if there are any edits I believe an error is raised here. It is not clear we need to be able to distinguish the 0 edits and the net no-op cases.

Thank you for looking into this, @timothy-king. I tend to agree with all the points you made in your comment.

I think there is a reasonable interpretation here that the .golden file is only needed for verifying fixes, and if there are no fixes is no need to look at a .golden file. This lets folks use this as the "super" operator if they want utilities that can test analyzers both with and without fixes.

I hadn't read the doc comment on RunWithSuggestedFixes closely earlier. I have now, and I also think the interpretation that you mention is a reasonable one. I also hadn't thought of the use of RunWithSuggestedFixes as the "super" operator, which makes a lot of sense too.

But I believe the only way to distinguish between 0 edits and all edits combined are a no-op is by not giving a golden file. This is more implicit, but if there are any edits I believe an error is raised here. It is not clear we need to be able to distinguish the 0 edits and the net no-op cases.

This is very well put. And I don't think we need to able to distinguish between these two cases as well.

So overall, I tend to agree that no changes necessarily need to be made to address this issue. Feel free to close the issue (or move it to a similar appropriate state).

So overall, I tend to agree that no changes necessarily need to be made to address this issue. Feel free to close the issue (or move it to a similar appropriate state).

Closing for now.

If someone wants to improve the documentation of RunWithSuggestedFixes to clarify what happens when there is no .golden file, you can send a CL, assign me as the reviewer, and I will happily take a look.