8 files changed, 364 insertions, 40 deletions

diff --git a/docs/user/README.md b/docs/user/README.md
index eb1d5ed14..909e574d0 100644
--- a/docs/user/README.md
+++ b/docs/user/README.md
@@ -82,7 +82,16 @@ host.
 
 ### Settings
 
-* `rust-analyzer.highlightingOn`: enables experimental syntax highlighting
+* `rust-analyzer.highlightingOn`: enables experimental syntax highlighting.
+* `rust-analyzer.scopeMappings` -- a scheme backed JSON object to tweak Rust Analyzer scopes to TextMate scopes.
+   ```jsonc
+    {
+        //Will autocomplete keys to available RA scopes. 
+        "keyword.unsafe": ["keyword", "keyword.control"],
+        //Values are string | TextMateScope | [string | TextMateScope]
+        "variable.mut": "variable"
+    }
+   ```
 * `rust-analyzer.enableEnhancedTyping`: by default, rust-analyzer intercepts
   `Enter` key to make it easier to continue comments. Note that it may conflict with VIM emulation plugin.
 * `rust-analyzer.raLspServerPath`: path to `ra_lsp_server` executable
@@ -101,7 +110,7 @@ host.
 * `rust-analyzer.trace.cargo-watch`: enables cargo-watch logging
 * `RUST_SRC_PATH`: environment variable that overwrites the sysroot
 * `rust-analyzer.featureFlags` -- a JSON object to tweak fine-grained behavior:
-   ```js
+   ```jsonc
    {
        // Show diagnostics produced by rust-analyzer itself.
        "lsp.diagnostics": true,
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index e6bcbfa60..9c55c257f 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -598,9 +598,9 @@
             }
         },
         "https-proxy-agent": {
-            "version": "2.2.2",
-            "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.2.tgz",
-            "integrity": "sha512-c8Ndjc9Bkpfx/vCJueCPy0jlP4ccCCSNDp8xwCZzPjKJUm+B+u9WX2x98Qx4n1PiMNTWo3D7KK5ifNV/yJyRzg==",
+            "version": "2.2.3",
+            "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.3.tgz",
+            "integrity": "sha512-Ytgnz23gm2DVftnzqRRz2dOXZbGd2uiajSw/95bPp6v53zPRspQjLm/AfBgqbJ2qfeRXWIOMVLpp86+/5yX39Q==",
             "dev": true,
             "requires": {
                 "agent-base": "^4.3.0",
diff --git a/editors/code/package.json b/editors/code/package.json
index ee997e58f..35f2f1e62 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -167,6 +167,68 @@
                     "default": false,
                     "description": "Highlight Rust code (overrides built-in syntax highlighting)"
                 },
+                "rust-analyzer.scopeMappings": {
+                    "type": "object",
+                    "definitions": {},
+                    "properties": {
+                        "comment": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "string": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "keyword": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "keyword.control": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "keyword.unsafe": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "function": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "parameter": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "constant": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "type": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "builtin": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "text": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "attribute": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "literal": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "macro": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "variable": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "variable.mut": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "field": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        },
+                        "module": {
+                            "$ref": "vscode://schemas/textmate-colors#/items/properties/scope"
+                        }
+                    },
+                    "additionalProperties": false,
+                    "description": "Mapping Rust Analyzer scopes to TextMateRule scopes list."
+                },
                 "rust-analyzer.rainbowHighlightingOn": {
                     "type": "boolean",
                     "default": false,
@@ -488,4 +550,4 @@
             }
         ]
     }
-}
+}
\ No newline at end of file
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 95c3f42e5..234a390ac 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
-
+import * as scopes from './scopes';
+import * as scopesMapper from './scopes_mapper';
 import { Server } from './server';
 
 const RA_LSP_DEBUG = process.env.__RA_LSP_SERVER_DEBUG;
@@ -45,8 +46,15 @@ export class Config {
 
     public userConfigChanged() {
         const config = vscode.workspace.getConfiguration('rust-analyzer');
+        
+        Server.highlighter.removeHighlights();
+
         if (config.has('highlightingOn')) {
             this.highlightingOn = config.get('highlightingOn') as boolean;
+            if (this.highlightingOn) {
+                scopes.load();
+                scopesMapper.load();    
+            }
         }
 
         if (config.has('rainbowHighlightingOn')) {
@@ -55,9 +63,6 @@ export class Config {
             ) as boolean;
         }
 
-        if (!this.highlightingOn && Server) {
-            Server.highlighter.removeHighlights();
-        }
 
         if (config.has('enableEnhancedTyping')) {
             this.enableEnhancedTyping = config.get(
diff --git a/editors/code/src/extension.ts b/editors/code/src/extension.ts
index c06928d12..07a5c59e8 100644
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@@ -91,11 +91,11 @@ export function activate(context: vscode.ExtensionContext) {
     const allNotifications: Iterable<
         [string, lc.GenericNotificationHandler]
     > = [
-        [
-            'rust-analyzer/publishDecorations',
-            notifications.publishDecorations.handle
-        ]
-    ];
+            [
+                'rust-analyzer/publishDecorations',
+                notifications.publishDecorations.handle
+            ]
+        ];
     const syntaxTreeContentProvider = new SyntaxTreeContentProvider();
 
     // The events below are plain old javascript events, triggered and handled by vscode
diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
index d21d8a06a..ee39ca64c 100644
--- a/editors/code/src/highlighting.ts
+++ b/editors/code/src/highlighting.ts
@@ -1,6 +1,8 @@
 import seedrandom = require('seedrandom');
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
+import * as scopes from './scopes';
+import * as scopesMapper from './scopes_mapper';
 
 import { Server } from './server';
 
@@ -23,6 +25,37 @@ function fancify(seed: string, shade: 'light' | 'dark') {
     return `hsl(${h},${s}%,${l}%)`;
 }
 
+
+function createDecorationFromTextmate(themeStyle: scopes.TextMateRuleSettings): vscode.TextEditorDecorationType {
+    const options: vscode.DecorationRenderOptions = {};
+    options.rangeBehavior = vscode.DecorationRangeBehavior.OpenOpen;
+    if (themeStyle.foreground) {
+        options.color = themeStyle.foreground;
+    }
+    if (themeStyle.background) {
+        options.backgroundColor = themeStyle.background;
+    }
+    if (themeStyle.fontStyle) {
+        const parts: string[] = themeStyle.fontStyle.split(' ');
+        parts.forEach((part) => {
+            switch (part) {
+                case 'italic':
+                    options.fontStyle = 'italic';
+                    break;
+                case 'bold':
+                    options.fontWeight = 'bold';
+                    break;
+                case 'underline':
+                    options.textDecoration = 'underline';
+                    break;
+                default:
+                    break;
+            }
+        })
+    }
+    return vscode.window.createTextEditorDecorationType(options);
+}
+
 export class Highlighter {
     private static initDecorations(): Map<
         string,
@@ -32,36 +65,51 @@ export class Highlighter {
             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 rule = scopesMapper.toRule(tag, scopes.find);
+
+            if (rule) {
+                const decor = createDecorationFromTextmate(rule);
+                return [tag, decor];
+            }
+            else {
+                const fallBackTag = 'ralsp.' + tag;
+                // console.log(' ');
+                // console.log('Missing theme for: <"' + tag + '"> for following mapped scopes:');
+                // console.log(scopesMapper.find(tag));
+                // console.log('Falling back to values defined in: ' + fallBackTag);
+                // console.log(' ');
+                const color = new vscode.ThemeColor(fallBackTag);
+                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'),
-            decoration('builtin'),
-            decoration('text'),
-            decoration('attribute'),
-            decoration('literal'),
-            decoration('macro'),
-            decoration('variable'),
-            decoration('variable.mut', 'underline'),
-            decoration('field'),
-            decoration('module')
-        ];
+                decoration('comment'),
+                decoration('string'),
+                decoration('keyword'),
+                decoration('keyword.control'),
+                decoration('keyword.unsafe'),
+                decoration('function'),
+                decoration('parameter'),
+                decoration('constant'),
+                decoration('type'),
+                decoration('builtin'),
+                decoration('text'),
+                decoration('attribute'),
+                decoration('literal'),
+                decoration('macro'),
+                decoration('variable'),
+                decoration('variable.mut', 'underline'),
+                decoration('field'),
+                decoration('module')
+            ];
 
         return new Map<string, vscode.TextEditorDecorationType>(decorations);
     }
@@ -89,6 +137,8 @@ export class Highlighter {
         //
         // 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();
         }
@@ -133,6 +183,7 @@ export class Highlighter {
                 tag
             ) as vscode.TextEditorDecorationType;
             const ranges = byTag.get(tag)!;
+
             editor.setDecorations(dec, ranges);
         }
 
diff --git a/editors/code/src/scopes.ts b/editors/code/src/scopes.ts
new file mode 100644
index 000000000..a6138fad0
--- /dev/null
+++ b/editors/code/src/scopes.ts
@@ -0,0 +1,134 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as vscode from 'vscode';
+
+
+
+export interface TextMateRule {
+    scope: string | string[];
+    settings: TextMateRuleSettings;
+}
+
+export interface TextMateRuleSettings {
+    foreground: string | undefined;
+    background: string | undefined;
+    fontStyle: string | undefined;
+}
+
+// Current theme colors
+const rules = new Map<string, TextMateRuleSettings>();
+
+export function find(scope: string): TextMateRuleSettings | undefined {
+    return rules.get(scope);
+}
+
+// Load all textmate scopes in the currently active theme
+export function load() {
+    // Remove any previous theme
+    rules.clear();
+    // Find out current color theme
+    const themeName = vscode.workspace.getConfiguration('workbench').get('colorTheme');
+
+    if (typeof themeName !== 'string') {
+        // console.warn('workbench.colorTheme is', themeName)
+        return;
+    }
+    // Try to load colors from that theme
+    try {
+        loadThemeNamed(themeName);
+    } catch (e) {
+        // console.warn('failed to load theme', themeName, e)
+    }
+}
+
+function filterThemeExtensions(extension: vscode.Extension<any>): boolean {
+    return extension.extensionKind === vscode.ExtensionKind.UI &&
+        extension.packageJSON.contributes &&
+        extension.packageJSON.contributes.themes;
+}
+
+
+
+// Find current theme on disk
+function loadThemeNamed(themeName: string) {
+
+    const themePaths = vscode.extensions.all
+        .filter(filterThemeExtensions)
+        .reduce((list, extension) => {
+            return extension.packageJSON.contributes.themes
+                .filter((element: any) => (element.id || element.label) === themeName)
+                .map((element: any) => path.join(extension.extensionPath, element.path))
+                .concat(list)
+        }, Array<string>());
+
+
+    themePaths.forEach(loadThemeFile);
+
+    const tokenColorCustomizations: [any] = [vscode.workspace.getConfiguration('editor').get('tokenColorCustomizations')]
+
+    tokenColorCustomizations
+        .filter(custom => custom && custom.textMateRules)
+        .map(custom => custom.textMateRules)
+        .forEach(loadColors);
+
+}
+
+
+function loadThemeFile(themePath: string) {
+    const themeContent = [themePath]
+        .filter(isFile)
+        .map(readFileText)
+        .map(parseJSON)
+        .filter(theme => theme);
+
+    themeContent
+        .filter(theme => theme.tokenColors)
+        .map(theme => theme.tokenColors)
+        .forEach(loadColors);
+
+    themeContent
+        .filter(theme => theme.include)
+        .map(theme => path.join(path.dirname(themePath), theme.include))
+        .forEach(loadThemeFile);
+}
+
+function mergeRuleSettings(defaultSetting: TextMateRuleSettings | undefined, override: TextMateRuleSettings): TextMateRuleSettings {
+    if (defaultSetting === undefined) { return override; }
+    const mergedRule = defaultSetting;
+
+    mergedRule.background = override.background || defaultSetting.background;
+    mergedRule.foreground = override.foreground || defaultSetting.foreground;
+    mergedRule.fontStyle = override.fontStyle || defaultSetting.foreground;
+
+    return mergedRule
+}
+
+function updateRules(scope: string, updatedSettings: TextMateRuleSettings): void {
+    [rules.get(scope)]
+        .map(settings => mergeRuleSettings(settings, updatedSettings))
+        .forEach(settings => rules.set(scope, settings));
+}
+
+function loadColors(textMateRules: TextMateRule[]): void {
+    textMateRules.forEach(rule => {
+        if (typeof rule.scope === 'string') {
+            updateRules(rule.scope, rule.settings);
+        }
+        else if (rule.scope instanceof Array) {
+            rule.scope.forEach(scope => updateRules(scope, rule.settings));
+        }
+    })
+}
+
+function isFile(filePath: string): boolean {
+    return [filePath].map(fs.statSync).every(stat => stat.isFile());
+}
+
+function readFileText(filePath: string): string {
+    return fs.readFileSync(filePath, 'utf8');
+}
+
+// Might need to replace with JSONC if a theme contains comments. 
+function parseJSON(content: string): any {
+    return JSON.parse(content);
+}
\ No newline at end of file
diff --git a/editors/code/src/scopes_mapper.ts b/editors/code/src/scopes_mapper.ts
new file mode 100644
index 000000000..dfb8bf217
--- /dev/null
+++ b/editors/code/src/scopes_mapper.ts
@@ -0,0 +1,63 @@
+import * as vscode from 'vscode';
+import { TextMateRuleSettings } from './scopes';
+
+
+
+let mappings = new Map<string, string[]>();
+
+
+const defaultMapping = new Map<string, string[]>([
+    ['comment', ['comment', 'comment.block', 'comment.line', 'comment.block.documentation']],
+    ['string', ['string']],
+    ['keyword', ['keyword']],
+    ['keyword.control', ['keyword.control', 'keyword', 'keyword.other']],
+    ['keyword.unsafe', ['storage.modifier', 'keyword.other', 'keyword.control', 'keyword']],
+    ['function', ['entity.name.function']],
+    ['parameter', ['variable.parameter']],
+    ['constant', ['constant', 'variable']],
+    ['type', ['entity.name.type']],
+    ['builtin', ['variable.language', 'support.type', 'support.type']],
+    ['text', ['string', 'string.quoted', 'string.regexp']],
+    ['attribute', ['keyword']],
+    ['literal', ['string', 'string.quoted', 'string.regexp']],
+    ['macro', ['support.other']],
+    ['variable', ['variable']],
+    ['variable.mut', ['variable', 'storage.modifier']],
+    ['field', ['variable.object.property', 'meta.field.declaration', 'meta.definition.property', 'variable.other',]],
+    ['module', ['entity.name.section', 'entity.other']]
+]
+);
+
+// Temporary exported for debugging for now. 
+export function find(scope: string): string[] {
+    return mappings.get(scope) || [];
+}
+
+export function toRule(scope: string, intoRule: (scope: string) => TextMateRuleSettings | undefined): TextMateRuleSettings | undefined {
+    return find(scope).map(intoRule).filter(rule => rule !== undefined)[0];
+}
+
+
+function isString(value: any): value is string {
+    return typeof value === 'string';
+}
+
+function isArrayOfString(value: any): value is string[] {
+    return Array.isArray(value) && value.every(item => isString(item));
+}
+
+
+export function load() {
+    const rawConfig: { [key: string]: any } = vscode.workspace
+        .getConfiguration('rust-analyzer')
+        .get('scopeMappings')
+        || {};
+
+    mappings = Object
+        .entries(rawConfig)
+        .filter(([_, value]) => isString(value) || isArrayOfString(value))
+        .reduce((list, [key, value]: [string, string | string[]]) => {
+            return list.set(key, isString(value) ? [value] : value);
+        }, defaultMapping);
+
+}
\ No newline at end of file