Remove global WorkspaceIndex (also add command for triggering reindex)

Author: mauve

package.json

@@ -34,6 +34,10 @@
       {
         "command": "terraform.lint",
         "title": "Terraform: Lint"
+      },
+      {
+        "command": "terraform.reindex",
+        "title": "Terraform: Reindex terraform files"
       }
     ],
     "languages": [
@@ -187,4 +191,4 @@
   "dependencies": {
     "lodash": "^4.17.10"
   }
-}
+}

src/autocompletion/completion-provider.ts

@@ -1,8 +1,8 @@
 import * as vscode from 'vscode';
 import * as _ from "lodash"
 
-import { WorkspaceIndex } from '../index/index';
 import { terraformConfigAutoComplete, allProviders, IFieldDef } from './model';
+import { Index } from '../index';
 
 const resourceExp = new RegExp("(resource|data)\\s+(\")?(\\w+)(\")?\\s+(\")?([\\w\\-]+)(\")?\\s+({)");
 const terraformExp = new RegExp("(variable|output|module)\\s+(\")?([\\w\\-]+)(\")?\\s+({)");
@@ -15,8 +15,10 @@ const modules = ["module", "provider"];
 const interfaces = ["resource", "data"];
 
 export class CompletionProvider implements vscode.CompletionItemProvider {
+  constructor(private index: Index) { }
+
   private getVariables(position: vscode.Position, includePrefix: boolean, match?: string): vscode.CompletionItem[] {
-    return WorkspaceIndex.query("ALL_FILES", { type: "variable", name: match }).map((variable) => {
+    return this.index.query("ALL_FILES", { type: "variable", name: match }).map((variable) => {
       let item = new vscode.CompletionItem(variable.name);
       item.kind = vscode.CompletionItemKind.Variable;
       if (includePrefix) {
@@ -28,7 +30,7 @@ export class CompletionProvider implements vscode.CompletionItemProvider {
   }
 
   private getOutputs(match?: string): vscode.CompletionItem[] {
-    return WorkspaceIndex.query("ALL_FILES", { type: "output", name: match }).map((output) => {
+    return this.index.query("ALL_FILES", { type: "output", name: match }).map((output) => {
       let item = new vscode.CompletionItem(output.name);
       item.kind = vscode.CompletionItemKind.Property;
       return item;

src/codelense.ts

@@ -1,17 +1,18 @@
 import * as vscode from 'vscode';
 
-import { WorkspaceIndex, Section, Reference } from './index/index';
+import { Section, Reference, Index } from './index/index';
 
 export class SectionReferenceCodeLens extends vscode.CodeLens {
   constructor(
+    private index: Index,
     range: vscode.Range,
     readonly section: Section,
     command?: vscode.Command) {
     super(range, command);
   }
 
   createCommand(): vscode.Command {
-    let references = WorkspaceIndex.queryReferences("ALL_FILES", { target: this.section });
+    let references = this.index.queryReferences("ALL_FILES", { target: this.section });
 
     return {
       title: `${references.length} references`,
@@ -26,16 +27,16 @@ export class CodeLensProvider implements vscode.CodeLensProvider {
   private eventEmitter = new vscode.EventEmitter<void>();
   onDidChangeCodeLenses = this.eventEmitter.event;
 
-  constructor() {
-    WorkspaceIndex.onDidChange(() => {
+  constructor(private index: Index) {
+    this.index.onDidChange(() => {
       this.eventEmitter.fire();
     });
   }
 
   provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.CodeLens[]> {
-    return WorkspaceIndex.getOrIndexDocument(document).sections.map((s) => {
+    return this.index.getOrIndexDocument(document).sections.map((s) => {
       let firstLineOfSection = new vscode.Range(s.location.range.start, new vscode.Position(s.location.range.start.line, 100000));
-      return new SectionReferenceCodeLens(firstLineOfSection, s);
+      return new SectionReferenceCodeLens(this.index, firstLineOfSection, s);
     });
   }
 
@@ -67,8 +68,8 @@ export class ReferenceQuickPick implements vscode.QuickPickItem {
   }
 }
 
-export function showReferencesCommand(section: Section) {
-  let picks = WorkspaceIndex.queryReferences("ALL_FILES", { target: section }).map((r) => new ReferenceQuickPick(r));
+export function showReferencesCommand(index: Index, section: Section) {
+  let picks = index.queryReferences("ALL_FILES", { target: section }).map((r) => new ReferenceQuickPick(r));
 
   vscode.window.showQuickPick(picks, {
     onDidSelectItem: (r: ReferenceQuickPick) => r.goto()

src/extension.ts

@@ -6,7 +6,7 @@ import { liveIndex } from './live';
 import { CompletionProvider } from './autocompletion/completion-provider';
 import { DefinitionProvider, DocumentSymbolProvider, WorkspaceSymbolProvider, ReferenceProvider, RenameProvider } from './index/providers';
 import { initialCrawl, createWorkspaceWatcher } from './index/watcher';
-import { WorkspaceIndex, Section } from './index';
+import { Section, Index } from './index';
 import { CodeLensProvider, showReferencesCommand } from './codelense';
 import { getConfiguration } from './configuration';
 import { HoverProvider } from './hover';
@@ -20,6 +20,8 @@ const documentSelector: vscode.DocumentSelector = [
 ];
 
 export function activate(ctx: vscode.ExtensionContext) {
+    let index = new Index();
+
     ctx.subscriptions.push(ErrorDiagnosticCollection);
 
     let formattingProvider = new FormattingEditProvider;
@@ -30,30 +32,35 @@ export function activate(ctx: vscode.ExtensionContext) {
         vscode.commands.registerCommand('terraform.validate', () => { validateCommand(); }),
         vscode.commands.registerCommand('terraform.lint', () => { lintCommand(); }),
         vscode.commands.registerCommand('terraform.showReferences', (section: Section) => {
-            showReferencesCommand(section);
+            showReferencesCommand(index, section);
+        }),
+        vscode.commands.registerCommand('terraform.reindex', () => {
+            if (getConfiguration().indexing.enabled) {
+                initialCrawl(index);
+            }
         }),
 
         // providers
-        vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionProvider, '.', '"'),
-        vscode.languages.registerDefinitionProvider(documentSelector, new DefinitionProvider),
-        vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider),
-        vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider),
-        vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider),
-        vscode.languages.registerRenameProvider(documentSelector, new RenameProvider),
-        vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider),
-        vscode.languages.registerHoverProvider(documentSelector, new HoverProvider)
+        vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionProvider(index), '.', '"'),
+        vscode.languages.registerDefinitionProvider(documentSelector, new DefinitionProvider(index)),
+        vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider(index)),
+        vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(index)),
+        vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider(index)),
+        vscode.languages.registerRenameProvider(documentSelector, new RenameProvider(index)),
+        vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(index)),
+        vscode.languages.registerHoverProvider(documentSelector, new HoverProvider(index))
     );
 
     // operations which should only work in a local context (as opposed to live-share)
     if (vscode.workspace.rootPath) {
         // we need to manually handle save events otherwise format on autosave does not work
         ctx.subscriptions.push(vscode.workspace.onDidSaveTextDocument((doc) => formattingProvider.onSave(doc)));
-        ctx.subscriptions.push(vscode.workspace.onDidChangeTextDocument(liveIndex));
+        ctx.subscriptions.push(vscode.workspace.onDidChangeTextDocument((e) => liveIndex(index, e)));
 
         // start to build the index
         if (getConfiguration().indexing.enabled) {
-            ctx.subscriptions.push(createWorkspaceWatcher(WorkspaceIndex));
-            initialCrawl(WorkspaceIndex);
+            ctx.subscriptions.push(createWorkspaceWatcher(index));
+            initialCrawl(index);
         }
     }
 }

src/hover.ts

@@ -1,14 +1,16 @@
 import * as vscode from 'vscode';
-import { WorkspaceIndex, Section } from './index';
+import { Section, Index } from './index';
 import { findValue, getStringValue, getValue } from './index/ast';
 
 export class HoverProvider implements vscode.HoverProvider {
+  constructor(private index: Index) { }
+
   provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): vscode.ProviderResult<vscode.Hover> {
-    let reference = WorkspaceIndex.queryReferences(document.uri, { position: position })[0];
+    let reference = this.index.queryReferences(document.uri, { position: position })[0];
     if (!reference)
       return null;
 
-    let section = WorkspaceIndex.query("ALL_FILES", reference.getQuery())[0];
+    let section = this.index.query("ALL_FILES", reference.getQuery())[0];
     if (section.sectionType !== "variable")
       return null;
 

src/index/index.ts

@@ -282,5 +282,3 @@ export class Index {
         return index;
     }
 }
-
-export let WorkspaceIndex = new Index;

src/index/providers.ts

@@ -1,52 +1,60 @@
 import * as vscode from 'vscode';
-
-import { WorkspaceIndex } from '../index/index';
-
+import { Index } from '.';
 
 export class DefinitionProvider implements vscode.DefinitionProvider {
+  constructor(private index: Index) { }
+
   provideDefinition(document: vscode.TextDocument, position: vscode.Position): vscode.Location {
-    let reference = WorkspaceIndex.queryReferences(document.uri, { position: position })[0];
+    let reference = this.index.queryReferences(document.uri, { position: position })[0];
     if (!reference)
       return null;
 
-    let section = WorkspaceIndex.query("ALL_FILES", reference.getQuery())[0];
+    let section = this.index.query("ALL_FILES", reference.getQuery())[0];
     if (!section)
       return null;
     return section.location;
   }
 }
 
 export class ReferenceProvider implements vscode.ReferenceProvider {
+  constructor(private index: Index) { }
+
   provideReferences(document: vscode.TextDocument, position: vscode.Position, context: vscode.ReferenceContext): vscode.Location[] {
-    let section = WorkspaceIndex.query(document.uri, { position: position })[0];
+    let section = this.index.query(document.uri, { position: position })[0];
     if (!section)
       return [];
 
-    let references = WorkspaceIndex.queryReferences("ALL_FILES", { target: section });
+    let references = this.index.queryReferences("ALL_FILES", { target: section });
     return references.map((r) => r.location);
   }
 }
 
 export class DocumentSymbolProvider implements vscode.DocumentSymbolProvider {
+  constructor(private index: Index) { }
+
   provideDocumentSymbols(document: vscode.TextDocument): vscode.SymbolInformation[] {
-    return WorkspaceIndex.query(document.uri);
+    return this.index.query(document.uri);
   }
 }
 
 export class WorkspaceSymbolProvider implements vscode.WorkspaceSymbolProvider {
+  constructor(private index: Index) { }
+
   provideWorkspaceSymbols(query: string): vscode.SymbolInformation[] {
-    return WorkspaceIndex.query("ALL_FILES", { name: query });
+    return this.index.query("ALL_FILES", { name: query });
   }
 }
 
 export class RenameProvider implements vscode.RenameProvider {
+  constructor(private index: Index) { }
+
   provideRenameEdits(document: vscode.TextDocument, position: vscode.Position, newName: string): vscode.WorkspaceEdit {
-    let section = WorkspaceIndex.query(document.uri, { name_position: position })[0];
+    let section = this.index.query(document.uri, { name_position: position })[0];
     if (!section) {
       return null;
     }
 
-    let references = WorkspaceIndex.queryReferences("ALL_FILES", { target: section });
+    let references = this.index.queryReferences("ALL_FILES", { target: section });
     if (references.length === 0) {
       return null;
     }

src/index/watcher.ts

@@ -5,8 +5,8 @@ import { parseHcl, ParseError } from './hcl-hil';
 import { build } from './build';
 import { ErrorDiagnosticCollection } from '../extension';
 
-function updateDocument(index: Index, uri: vscode.Uri) {
-  vscode.workspace.openTextDocument(uri).then((doc) => {
+function updateDocument(index: Index, uri: vscode.Uri): Thenable<void> {
+  return vscode.workspace.openTextDocument(uri).then((doc) => {
     if (doc.isDirty || doc.languageId !== "terraform") {
       // ignore
       return;
@@ -34,8 +34,16 @@ export function createWorkspaceWatcher(index: Index): vscode.FileSystemWatcher {
 export function initialCrawl(index: Index): Thenable<vscode.Uri[]> {
   return vscode.workspace.findFiles("**/*.{tf,tfvars}", "")
     .then((uris) => {
-      uris.forEach((uri) => updateDocument(index, uri));
+      return vscode.window.withProgress({
+        location: vscode.ProgressLocation.Window,
+        title: "Indexing terraform templates"
+      }, async (progress) => {
+        for (let uri of uris) {
+          progress.report({ message: `Indexing ${uri.toString()}` });
+          await updateDocument(index, uri);
+        }
 
-      return uris;
+        return uris;
+      });
     });
 }

src/live.ts

@@ -4,7 +4,7 @@ import { execFile } from 'child_process';
 import { getConfiguration } from './configuration';
 import { ErrorDiagnosticCollection } from './extension';
 import { isTerraformDocument } from './helpers';
-import { WorkspaceIndex } from './index';
+import { Index } from './index';
 
 let runner;
 
@@ -17,7 +17,7 @@ function liveIndexEnabledForDocument(doc: vscode.TextDocument): boolean {
   return cfg.enabled && cfg.liveIndexing;
 }
 
-export function liveIndex(e: vscode.TextDocumentChangeEvent) {
+export function liveIndex(index: Index, e: vscode.TextDocumentChangeEvent) {
   if (!liveIndexEnabledForDocument(e.document)) {
     return;
   }
@@ -26,6 +26,6 @@ export function liveIndex(e: vscode.TextDocumentChangeEvent) {
     clearTimeout(runner);
   }
   runner = setTimeout(function () {
-    WorkspaceIndex.indexDocument(e.document);
+    index.indexDocument(e.document);
   }, getConfiguration().indexing.liveIndexingDelay);
 }