[Api] Auto fix on save and fix all

[mjbvz]

(edit: see here for a more recent proposal. Original proposal below)

Problem

ES Lint, TS Lint, and other extensions have the concept of auto fix on save. On save, this goes through the errors file and fixes all simple ones, such as removing tailing whitespace or converting { x: string } to Array<{ x: string }>. This functionality is quite useful but is currently implemented per extension. It would be nice if we could:

• Control auto fix on save with a single setting.
• Indicate auto fixes in the code action context menu (since these are usually the preferred fixes)
• Bind auto fix to a keyboard shortcut

Related
Many extensions implement a fix all of this type code action / quick fix. This can be viewed as a special case of auto fix on save where the candidate fixes are only of a single type.

Sketches

(Note that the sketch below record some of the options being considered for this API. They are not yet concrete proposals)

---

Do nothing

Keep things as is. Let extensions handle this all individually

Benefits

• No work! (unless we maybe try to establish some sort of convention for extensions to follow)

Drawbacks

• Many different ways of implementing the same thing
• Cannot bring auto fix or fix all into UI in a consistent way
• Cannot support things that require standardization, such as keybindings or commands

---

CodeAction.autoFixable

Add an autoFixable flag to CodeAction

class CodeAction {
    ...

   autoFixable?: boolean;
}

Use this flag to determine which code actions should be applied on save.

Introduce a editor.autoFixOnSave setting to enable or disable auto fix on save

Implementing auto fix on save

1. For every diagnostic in a file
2. Request all code actions for that diagnostic.
3. If there are is only one code action marked autoFixable in the set, then apply that code action

Implementing auto fix all errors of type X

1. Assuming we have UI that shows a auto fix all errors of type X suggestion .
2. For each diagnostic of type X in the file, request code actions.
3. Filter to only those that CodeAction.diagnostics set to include the diagnostic of type X.
4. Then, if we only have one code action left for that diagnostic, apply it.

Maybe autoFixable here should actually be an array of diagnostics? Would that help with filtering.

Benefits

• Theoretically this lets us address all requirements (perhaps with a few api tweaks)

Drawbacks / Open questions

• Supper chatty api
• Not easy to handle recursive or overlapping fixes

---

CodeActionKind.SourceAutoFix

Add a new code action kind called source.autoFix. Update extensions to return a source code action that fixes all auto fixable errors in the file.

Use "editor.sourceActionsOnSave": ["source.autoFix"] to apply code actions on save

Implementing auto fix on save
Basically no work on VS Code side. Get extensions to adopt this new API.

Implementing auto fix all errors of type X
We could do something like have multiple source code actions for autofix, such as:

• source.autoFix.123
• source.autoFix.456

This may gets confusing though since requesting the code actions for source.autoFix would end up including the source code actions of source.autoFix.123 and source.autoFix.456 unless the extension is smart. Maybe we'd have to have a source.autoFix.all to prevent this for the autofix on save case? Or perhaps it doesn't matter? If editor.sourceActionsOnSave applies all actions of source.autoFix, presumably applying source.autoFix.123 and source.autoFix.456 should work?

Benefits

• Easy to implement
• Allows extensions to compute a batch of edits
• "editor.sourceActionsOnSave": ["source.autoFix"]

Drawbacks / Open questions

• What happens if multiple extensions contribute fix all actions? With current proposal, the source code menu would just show an fix all action for each extension. Would be nice if we just have one entry (autofix on save may still work though, at least as long as the fixes don't overlap)
• Can we actually implement auto fix all errors of type X?
• Is there any standard way to surface autofix in the UI with this proposal?

[mjbvz]

I'm in favor of the CodeActionKind.SourceAutoFix approach as it slots in nicely with existing apis. Still some open questions, specifically around how to present the fix all action in the UI

Also need to see if other languages/extensions have a use case for this.

/cc @dbaeumer and @jrieken

[jrieken]

Not sure that I understood all the implications outlined above but making auto-fix a property and not a kind sound more correct, e.g. I can have all kinds of code actions that can be auto-fixed/applied.

[dbaeumer]

Reading through it I prefer CodeActionKind.SourceAutoFix however I don't fully understand all implications either.

[mjbvz]

Documenting a few other proposals

CodeAction.autoFixable + CodeActionContext. autoFixable

(discussed with @jrieken )

This proposal would add a new CodeAction.autoFixable flag on code actions as originally proposed.

class CodeAction {
    ...

   autoFixable?: boolean;
}

In addition, in order to address the problems around efficiency and overlapping changes with first proposal, we would add a new autoFixable field to the CodeActionContext

class CodeActionContext {
    ...

   autoFixable?: boolean;
}

When requesting the fix all code actions, the context would set autoFixable: true and filter out any code actions that are not marked as autoFixable. This allows providers to compute overlapping changes and to return all code actions in a single batch

CodeAction.autoFixable + CodeActionKind.SourceAutoFix

(discussed with @kieferrm)

This proposal basically combines the first two proposals. The idea here is that there are two issues we are really interested in solving:

• Fix all in file source action. Using SourceAutoFix works nicely for this
• F8 through file and hit a button to fix an error. This is where the CodeAction.autoFixable property comes in

[mjbvz]

I'm in favor of the last proposal — CodeAction.autoFixable + CodeActionKind.SourceAutoFix — as it lets us address most of the original concerns (except the fix all errors of type X one) and the F8 case is pretty interesting too

@dbaeumer From the LSP point of view, CodeActionKind.SourceAutoFix would just be a new CodeActionKind. It would work just like organize imports. Providers that implement it would return a single code action that fixes all auto-fixable errors in the file (the provider and not VS Code would be responsible for identifying auto-fixable errors).

[mjbvz]

A more complete writeup on the last proposal:

Problem

ES Lint, TS Lint, and other extensions have the concept of auto fix on save. On save, this goes through the errors file and fixes all simple ones, such as removing tailing whitespace or converting { x: string } to Array<{ x: string }>. This functionality is quite useful but is currently implemented per extension. It would be nice if we could:

• Standardize auto fix on save: have with a single setting to enable or disable this, clarify expected behavior.
• Indicate auto fixes in the code action context menu (since these are usually the preferred fixes)
• Bind auto fix to a keyboard shortcut

Proposal

There are two related but separate problems with this proposal: an action that auto fixes problems in a file, and auto fixing individual errors.

Auto-fixing all auto-fixable errors in a file

Motivating example
You enable a new linter error in your project that bans semicolons. This introduce 1.21 gazillion errors in every file. Thankfully, your linter extension has implemented the fix all source action so removing those vile semicolons is simple!

You can even fix all linter errors when you save a file by setting editor.codeActionsOnSave in case you accidentally introduce a new semicolon

Proposal

1. Introduce a new CodeActionKind called SourceFixAll with the scope source.fixAll.

   Implementing this would be very similar to the SourceOrganizeImports actions. The implementing extension could compute a single edit that would fix all autofixable errors in the file. It would be up to the extension to determine what can be auto fixed and how to fix

2. Document that you can set "editor.codeActionsOnSave": ["source.fixAll'] to apply this code action on save

Auto fixing individual errors

Motivating example
You open the following TS file:

interface IFoo {
    bar(): void;
}

class Foo implements IFoo { }

new foo()

You hit F8 to start navigating through errors. While navigating, you can hit a single keyboard shortcut to auto implement the interface or to correct foo -> Foo

Proposal

1. Introduce a new isPreferred field on the CodeAction type:

   class CodeAction {
       ...
      /**
        * Indicates that this quick fix can be automatically applied as a correct fix for the error
        *
        * `implement interface` for example would be marked `canAutoApply` while a error suppression
        * would not be.
        */
      isPreferred?: boolean;
   }

2. Introduce editor.action.autoFix command with a keyboard shortcut, something like cmd+option+. which is similar to the regular quick fix shortcut. This action would:

   • Request code actions for the current diagnostic.
   • If only a single code action marked canAutoApply is returned, then apply it .
   • Otherwise show a list of the canAutoApply code actions that were returned

3. (longer term) Use the canAutoApply actions in the UI to indicated preferred code fixes.