1 files changed, 151 insertions, 58 deletions

diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
index e1b0d13e7..014e96f75 100644
--- a/editors/code/src/highlighting.ts
+++ b/editors/code/src/highlighting.ts
@@ -1,10 +1,69 @@
-import seedrandom = require('seedrandom');
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as seedrandom_ from 'seedrandom';
+const seedrandom = seedrandom_; // https://github.com/jvandemo/generator-angular2-library/issues/221#issuecomment-355945207
+
+import { ColorTheme, TextMateRuleSettings } from './color_theme';
+
+import { Ctx, sendRequestWithRetry } from './ctx';
+
+export function activateHighlighting(ctx: Ctx) {
+    const highlighter = new Highlighter(ctx);
+    ctx.onDidRestart(client => {
+        client.onNotification(
+            'rust-analyzer/publishDecorations',
+            (params: PublishDecorationsParams) => {
+                if (!ctx.config.highlightingOn) return;
+
+                const targetEditor = vscode.window.visibleTextEditors.find(
+                    editor => {
+                        const unescapedUri = unescape(
+                            editor.document.uri.toString(),
+                        );
+                        // Unescaped URI looks like:
+                        // file:///c:/Workspace/ra-test/src/main.rs
+                        return unescapedUri === params.uri;
+                    },
+                );
+                if (!targetEditor) return;
+
+                highlighter.setHighlights(targetEditor, params.decorations);
+            },
+        );
+    });
+
+    vscode.workspace.onDidChangeConfiguration(
+        _ => highlighter.removeHighlights(),
+        ctx.subscriptions,
+    );
+
+    vscode.window.onDidChangeActiveTextEditor(
+        async (editor: vscode.TextEditor | undefined) => {
+            if (!editor || editor.document.languageId !== 'rust') return;
+            if (!ctx.config.highlightingOn) return;
+            let client = ctx.client;
+            if (!client) return;
+
+            const params: lc.TextDocumentIdentifier = {
+                uri: editor.document.uri.toString(),
+            };
+            const decorations = await sendRequestWithRetry<Decoration[]>(
+                client,
+                'rust-analyzer/decorationsRequest',
+                params,
+            );
+            highlighter.setHighlights(editor, decorations);
+        },
+        ctx.subscriptions,
+    );
+}
 
-import { Server } from './server';
+interface PublishDecorationsParams {
+    uri: string;
+    decorations: Decoration[];
+}
 
-export interface Decoration {
+interface Decoration {
     range: lc.Range;
     tag: string;
     bindingHash?: string;
@@ -23,62 +82,17 @@ function fancify(seed: string, shade: 'light' | 'dark') {
     return `hsl(${h},${s}%,${l}%)`;
 }
 
-export class Highlighter {
-    private static initDecorations(): Map<
-        string,
-        vscode.TextEditorDecorationType
-    > {
-        const decoration = (
-            tag: string,
-            textDecoration?: string,
-        ): [string, vscode.TextEditorDecorationType] => {
-            const color = new vscode.ThemeColor('ralsp.' + tag);
-            const decor = vscode.window.createTextEditorDecorationType({
-                color,
-                textDecoration,
-            });
-            return [tag, decor];
-        };
-
-        const decorations: Iterable<[
-            string,
-            vscode.TextEditorDecorationType,
-        ]> = [
-            decoration('comment'),
-            decoration('string'),
-            decoration('keyword'),
-            decoration('keyword.control'),
-            decoration('keyword.unsafe'),
-            decoration('function'),
-            decoration('parameter'),
-            decoration('constant'),
-            decoration('type.builtin'),
-            decoration('type.generic'),
-            decoration('type.lifetime'),
-            decoration('type.param'),
-            decoration('type.self'),
-            decoration('type'),
-            decoration('text'),
-            decoration('attribute'),
-            decoration('literal'),
-            decoration('literal.numeric'),
-            decoration('literal.char'),
-            decoration('literal.byte'),
-            decoration('macro'),
-            decoration('variable'),
-            decoration('variable.mut', 'underline'),
-            decoration('field'),
-            decoration('module'),
-        ];
-
-        return new Map<string, vscode.TextEditorDecorationType>(decorations);
-    }
-
+class Highlighter {
+    private ctx: Ctx;
     private decorations: Map<
         string,
         vscode.TextEditorDecorationType
     > | null = null;
 
+    constructor(ctx: Ctx) {
+        this.ctx = ctx;
+    }
+
     public removeHighlights() {
         if (this.decorations == null) {
             return;
@@ -93,12 +107,14 @@ export class Highlighter {
     }
 
     public setHighlights(editor: vscode.TextEditor, highlights: Decoration[]) {
+        let client = this.ctx.client;
+        if (!client) return;
         // Initialize decorations if necessary
         //
         // Note: decoration objects need to be kept around so we can dispose them
         // if the user disables syntax highlighting
         if (this.decorations == null) {
-            this.decorations = Highlighter.initDecorations();
+            this.decorations = initDecorations();
         }
 
         const byTag: Map<string, vscode.Range[]> = new Map();
@@ -106,7 +122,7 @@ export class Highlighter {
             string,
             [vscode.Range[], boolean]
         > = new Map();
-        const rainbowTime = Server.config.rainbowHighlightingOn;
+        const rainbowTime = this.ctx.config.rainbowHighlightingOn;
 
         for (const tag of this.decorations.keys()) {
             byTag.set(tag, []);
@@ -125,13 +141,13 @@ export class Highlighter {
                 colorfulIdents
                     .get(d.bindingHash)![0]
                     .push(
-                        Server.client.protocol2CodeConverter.asRange(d.range),
+                        client.protocol2CodeConverter.asRange(d.range),
                     );
             } else {
                 byTag
                     .get(d.tag)!
                     .push(
-                        Server.client.protocol2CodeConverter.asRange(d.range),
+                        client.protocol2CodeConverter.asRange(d.range),
                     );
             }
         }
@@ -154,3 +170,80 @@ export class Highlighter {
         }
     }
 }
+
+function initDecorations(): Map<string, vscode.TextEditorDecorationType> {
+    const theme = ColorTheme.load();
+    const res = new Map();
+    TAG_TO_SCOPES.forEach((scopes, tag) => {
+        if (!scopes) throw `unmapped tag: ${tag}`;
+        let rule = theme.lookup(scopes);
+        const decor = createDecorationFromTextmate(rule);
+        res.set(tag, decor);
+    });
+    return res;
+}
+
+function createDecorationFromTextmate(
+    themeStyle: TextMateRuleSettings,
+): vscode.TextEditorDecorationType {
+    const decorationOptions: vscode.DecorationRenderOptions = {};
+    decorationOptions.rangeBehavior = vscode.DecorationRangeBehavior.OpenOpen;
+
+    if (themeStyle.foreground) {
+        decorationOptions.color = themeStyle.foreground;
+    }
+
+    if (themeStyle.background) {
+        decorationOptions.backgroundColor = themeStyle.background;
+    }
+
+    if (themeStyle.fontStyle) {
+        const parts: string[] = themeStyle.fontStyle.split(' ');
+        parts.forEach(part => {
+            switch (part) {
+                case 'italic':
+                    decorationOptions.fontStyle = 'italic';
+                    break;
+                case 'bold':
+                    decorationOptions.fontWeight = 'bold';
+                    break;
+                case 'underline':
+                    decorationOptions.textDecoration = 'underline';
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    return vscode.window.createTextEditorDecorationType(decorationOptions);
+}
+
+// sync with tags from `syntax_highlighting.rs`.
+const TAG_TO_SCOPES = new Map<string, string[]>([
+    ["field", ["entity.name.field"]],
+    ["function", ["entity.name.function"]],
+    ["module", ["entity.name.module"]],
+    ["constant", ["entity.name.constant"]],
+    ["macro", ["entity.name.macro"]],
+
+    ["variable", ["variable"]],
+    ["variable.mut", ["variable", "meta.mutable"]],
+
+    ["type", ["entity.name.type"]],
+    ["type.builtin", ["entity.name.type", "support.type.primitive"]],
+    ["type.self", ["entity.name.type.parameter.self"]],
+    ["type.param", ["entity.name.type.parameter"]],
+    ["type.lifetime", ["entity.name.type.lifetime"]],
+
+    ["literal.byte", ["constant.character.byte"]],
+    ["literal.char", ["constant.character"]],
+    ["literal.numeric", ["constant.numeric"]],
+
+    ["comment", ["comment"]],
+    ["string", ["string.quoted"]],
+    ["attribute", ["meta.attribute"]],
+
+    ["keyword", ["keyword"]],
+    ["keyword.unsafe", ["keyword.other.unsafe"]],
+    ["keyword.control", ["keyword.control"]],
+]);