autofix | Auto-fixing error due to version upgrade , good practice etc | Blockchain library

Problem was

You need to supply a vscode.CodeActionProvider.

This CodeActionProvider when called returns a list of vscode.CodeAction objects.

In the CodeAction you set an vscode.WorkspaceEdit and/or a vscode.Command.

In the WorkspaceEdit you define the delete/insert/replace you want to QuickFix.

In the Command you can set an arguments property where you can put the command arguments. This array will be one of the parameters of the command.

According to this article, settings should be as the following:

• File type: Any (or JavaScript)
• Scope: Project files
• Program: $ProjectFileDir$/node_modules/.bin/eslint
• Arguments: --fix $FilePath$
• Output paths to refresh: $FileDir$

There have been a couple of issues that are opened, about adding auto-fix for the max-len rule, but unfortunately, the eslint team doesn't seem willing to pursue it (the reasons are stated on the thread).

You can consider disabling that rule for the particular line:

With 'vue/max-attributes-per-line': 'off' the rule is disabled so VSCode does not try to fix the long line on autosave. Other eslint fixes are applied, as expected.

With 'vue/max-attributes-per-line': 1 VSCode fixes only one error per save. This is a known limitation of vscode-eslint

vscode-eslint only does a single pass in order to keep to a minimum the amount of edits generated by the plugin. The goal is to keep as many markers (like break points) in the file as possible.

VSCode has a time limit of 1 second for all the plugins to compute the change set on save. If one of the plugins causes the other plugins to not run for 3 times in a row, it will be disabled.

eslint --fix runs all the rules in a loop until there are no more linting errors. I think it has a limit of 10 iterations maximum.

See these links for more details:

• https://github.com/Microsoft/vscode-eslint/issues/154

I've created a minimal setup to demonstrate this issue:

• https://github.com/kenjiru/vscode-eslint-onsave-issue

How much work would you like to do to create the code that could figure out what the fix should be? And, will that amount of work be comparable or less to the work required to examine code by hand?

Now, I'm writing all of this having spent quite a bit of time trying to come up with a system to analyze CPAN installer output to figure out what went wrong (a major impetus for CPANPLUS, now relegated to history). It's easy to tell that something is not right, but beyond that is a lot of suffering.

In your example, you have an error about an undeclared variable. How does AutoFix know if that should be a package or a lexical variable? You can guess one or the other, but you actually have two big problems:

• What is the intent of the code?
• Does the code reflect the actual intent?

Determining the intent of the code is often very difficult for even an experienced human programmer to figure out (just read StackOverflow question comments). Compiling code is often not correct code, in the sense that it doesn't achieve the desired outcome. Furthermore, does the programmer even understand the problem? Does the code the programmer wrote (incorrectly here) reflect the actual work the code should do? It's difficult for humans in code review to figure this out. Tools like Coverity can guess at problems it knows about, but they aren't going to be able to correct the code.

But let's say that the programmer understands the problem. Have they correctly expressed that? The longer you've been programming, the more you lean toward "no", in general, in my experience.

This is completely different than the database constraint you mentioned. That's a narrowly targeted fix for an expected and allowed situation. Consider a different parallel: if the record has a New York area code but a Chicago address, should I fix the city? When I was a younger dumbass, I did a similar thing to a database. It was stupid because I thought I knew something I didn't, and everyone who understood the situation recognized it immediately. Even then, those sorts of constraints are how we model what we know about the world, not what the world actually is.

Now, to make AutoFix, you need to make something that can look at code, understand it, and figure out what it should do. You can make guesses, but you have no basis for playing the probabilities there.

Technical matters can't solve this. AutoFix can undo the work of pragmas such that some classes of errors don't show up, but so what? The program with an error just continues? How does that help anyone?

Not only that, compilers tend to complain when they realize they can't parse something. What they complain about is often not the problem. The first thing I teach people while debugging is that they need to look at the statement immediately proceeding the line line number in the error message. Any error message you catch can have a virtually infinite number of causes.

Consider this code, which fails in the same way as your example (same error message) but for a completely different but common reason:

Okay, this is a faceplant moment for me. Turns out in the 'after' hook, I did have access to the file, but the reason my output was empty was that the json_decode method returned false because the content of the file wasn't valid json (which was what I was trying to test from the start). Anyway, once I finished picking up the pieces of my scattered brain, the following turned out to work perfectly:

Try setting it this way:

I found that the problem occurred when I had more than one project within the same repository as I count here: https://github.com/microsoft/vscode-eslint/issues/856#issuecomment-567952628

In the end the problem was an eslint version bug in vscode.