Fix `cargo watch` code action filtering

There are two issues with the implementation of `provideCodeActions`
introduced in #1439:

1. We're returning the code action based on the file its diagnostic is
   in; not the file the suggested fix is in. I'm not sure how often
   fixes are suggested cross-file but it's something we should handle.

2. We're not filtering code actions based on the passed range. The means
   if there is any suggestion in a file we'll show an action for every
   line of the file. I naively thought that VS Code would filter for us
   but that was wrong.

Unfortunately the VS Code `CodeAction` object is very complex - it can
handle edits across multiple files, run commands, etc. This makes it
complex to check them for equality or see if any of their edits
intersects with a specified range.

To make it easier to work with suggestions this introduces a
`SuggestedFix` model object and a `SuggestFixCollection` code action
provider. This is a layer between the raw Rust JSON and VS Code's
`CodeAction`s. I was reluctant to introduce another layer of abstraction
here but my attempt to work directly with VS Code's model objects was
worse.

1 files changed, 133 insertions, 0 deletions

diff --git a/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts b/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts
new file mode 100644
index 000000000..6c7f436f3
--- /dev/null
+++ b/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts
@@ -0,0 +1,133 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+
+import { SuggestionApplicability } from '../../../utils/diagnostics/rust';
+import SuggestedFix from '../../../utils/diagnostics/SuggestedFix';
+
+const location1 = new vscode.Location(
+    vscode.Uri.file('/file/1'),
+    new vscode.Range(new vscode.Position(1, 2), new vscode.Position(3, 4))
+);
+
+const location2 = new vscode.Location(
+    vscode.Uri.file('/file/2'),
+    new vscode.Range(new vscode.Position(5, 6), new vscode.Position(7, 8))
+);
+
+describe('SuggestedFix', () => {
+    describe('isEqual', () => {
+        it('should treat identical instances as equal', () => {
+            const suggestion1 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!'
+            );
+
+            const suggestion2 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!'
+            );
+
+            assert(suggestion1.isEqual(suggestion2));
+        });
+
+        it('should treat instances with different titles as inequal', () => {
+            const suggestion1 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!'
+            );
+
+            const suggestion2 = new SuggestedFix(
+                'Not the same title!',
+                location1,
+                'With this!'
+            );
+
+            assert(!suggestion1.isEqual(suggestion2));
+        });
+
+        it('should treat instances with different replacements as inequal', () => {
+            const suggestion1 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!'
+            );
+
+            const suggestion2 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With something else!'
+            );
+
+            assert(!suggestion1.isEqual(suggestion2));
+        });
+
+        it('should treat instances with different locations as inequal', () => {
+            const suggestion1 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!'
+            );
+
+            const suggestion2 = new SuggestedFix(
+                'Replace me!',
+                location2,
+                'With this!'
+            );
+
+            assert(!suggestion1.isEqual(suggestion2));
+        });
+
+        it('should treat instances with different applicability as inequal', () => {
+            const suggestion1 = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!',
+                SuggestionApplicability.MachineApplicable
+            );
+
+            const suggestion2 = new SuggestedFix(
+                'Replace me!',
+                location2,
+                'With this!',
+                SuggestionApplicability.HasPlaceholders
+            );
+
+            assert(!suggestion1.isEqual(suggestion2));
+        });
+    });
+
+    describe('toCodeAction', () => {
+        it('should map a simple suggestion', () => {
+            const suggestion = new SuggestedFix(
+                'Replace me!',
+                location1,
+                'With this!'
+            );
+
+            const codeAction = suggestion.toCodeAction();
+            assert.strictEqual(codeAction.kind, vscode.CodeActionKind.QuickFix);
+            assert.strictEqual(codeAction.title, 'Replace me!');
+            assert.strictEqual(codeAction.isPreferred, false);
+
+            const edit = codeAction.edit;
+            if (!edit) {
+                return assert.fail('Code Action edit unexpectedly missing');
+            }
+
+            const editEntries = edit.entries();
+            assert.strictEqual(editEntries.length, 1);
+
+            const [[editUri, textEdits]] = editEntries;
+            assert.strictEqual(editUri.toString(), location1.uri.toString());
+
+            assert.strictEqual(textEdits.length, 1);
+            const [textEdit] = textEdits;
+
+            assert(textEdit.range.isEqual(location1.range));
+            assert.strictEqual(textEdit.newText, 'With this!');
+        });
+    });
+});