JS plugin

code/common.ts

@@ -0,0 +1,278 @@
+import * as vscode from 'vscode'
+import { log } from 'util'
+
+export function createPlugin(
+    backend,
+    fileExtension: string,
+    disposables: vscode.Disposable[],
+    doHighlighting: boolean = false,
+    diganosticCollection: vscode.DiagnosticCollection | null = null
+) {
+    let uris = {
+        syntaxTree: vscode.Uri.parse(`fall-${fileExtension}://syntaxtree`),
+        metrics: vscode.Uri.parse(`fall-${fileExtension}://metrics`)
+    }
+
+    function updateActiveEditor() {
+        let editor = vscode.window.activeTextEditor
+        if (editor == null) return
+        let file = currentFile()
+        if (file == null) return
+        if (doHighlighting) {
+            setHighlights(editor, file.highlight())
+        }
+        if (diganosticCollection != null) {
+            diganosticCollection.clear()
+            diganosticCollection.set(
+                editor.document.uri,
+                file.diagnostics()
+            )
+        }
+    }
+
+
+    function currentFile(): EditorFile | null {
+        let editor = vscode.window.activeTextEditor
+        if (editor == null) return
+        let doc = editor.document
+        return getFile(doc)
+    }
+
+    vscode.window.onDidChangeActiveTextEditor(updateActiveEditor)
+    let cmd = vscode.commands.registerCommand(`fall-${fileExtension}.applyContextAction`, (range, id) => {
+        let file = currentFile()
+        if (file == null) return
+        return file.applyContextAction(range, id)
+    })
+    disposables.push(cmd)
+
+    return {
+        getFile: getFile,
+        showSyntaxTree: () => {
+            let file = currentFile()
+            if (file == null) return
+            return openDoc(uris.syntaxTree)
+        },
+        metrics: () => {
+            let file = currentFile()
+            if (file == null) return
+            return openDoc(uris.metrics)
+        },
+        extendSelection: () => {
+            let editor = vscode.window.activeTextEditor
+            let file = currentFile()
+            if (editor == null || file == null) return
+            editor.selections = editor.selections.map((s) => {
+                let range = file.extendSelection(s)
+                return new vscode.Selection(range.start, range.end)
+            })
+        },
+        documentSymbolsProvider: new DocumentSymbolProvider(getFile),
+        documentFormattingEditProvider: new DocumentFormattingEditProvider(getFile),
+        codeActionProvider: new CodeActionProvider(getFile, fileExtension)
+    }
+}
+
+
+export interface FileStructureNode {
+    name: string
+    range: [number, number]
+    children: [FileStructureNode]
+}
+
+export interface FallDiagnostic {
+    range: [number, number]
+    severity: string
+    message: string
+}
+
+export class EditorFile {
+    backend;
+    imp;
+    doc: vscode.TextDocument;
+
+    constructor(backend, imp, doc: vscode.TextDocument) {
+        this.backend = backend
+        this.imp = imp
+        this.doc = doc
+    }
+
+    metrics(): string { return this.call("metrics") }
+    syntaxTree(): string { return this.call("syntaxTree") }
+    extendSelection(range_: vscode.Range): vscode.Range | null {
+        let range = fromVsRange(this.doc, range_)
+        let exp = this.call("extendSelection", range)
+        if (exp == null) return null
+        return toVsRange(this.doc, exp)
+    }
+
+    structure(): Array<FileStructureNode> { return this.call("structure") }
+    reformat(): Array<vscode.TextEdit> {
+        let edits = this.call("reformat")
+        return toVsEdits(this.doc, edits)
+    }
+
+    highlight(): Array<[[number, number], string]> { return this.call("highlight") }
+    diagnostics(): Array<vscode.Diagnostic> {
+        return this.call("diagnostics").map((d) => {
+            let range = toVsRange(this.doc, d.range)
+            let severity = d.severity == "Error"
+                ? vscode.DiagnosticSeverity.Error
+                : vscode.DiagnosticSeverity.Warning
+
+            return new vscode.Diagnostic(range, d.message, severity)
+        })
+    }
+
+    contextActions(range_: vscode.Range): Array<string> {
+        let range = fromVsRange(this.doc, range_)
+        let result = this.call("contextActions", range)
+        return result
+    }
+
+    applyContextAction(range_: vscode.Range, id: string) {
+        let range = fromVsRange(this.doc, range_)
+        let edits = this.call("applyContextAction", range, id)
+        let editor = vscode.window.activeTextEditor
+        return editor.edit((builder) => {
+            for (let op of edits) {
+                builder.replace(toVsRange(this.doc, op.delete), op.insert)
+            }
+        })
+    }
+
+    call(method: string, ...args) {
+        let result = this.backend[method](this.imp, ...args)
+        return result
+    }
+}
+
+function documentToFile(backend, fileExtension: string, disposables: vscode.Disposable[], onChange) {
+    let docs = {}
+    function update(doc: vscode.TextDocument, file) {
+        let key = doc.uri.toString()
+        if (file == null) {
+            delete docs[key]
+        } else {
+            docs[key] = file
+        }
+        onChange(doc)
+    }
+    function get(doc: vscode.TextDocument) {
+        return docs[doc.uri.toString()]
+    }
+
+    function isKnownDoc(doc: vscode.TextDocument) {
+        return doc.fileName.endsWith(`.${fileExtension}`)
+    }
+
+    vscode.workspace.onDidChangeTextDocument((event: vscode.TextDocumentChangeEvent) => {
+        let doc = event.document
+        if (!isKnownDoc(event.document)) return
+        let tree = get(doc)
+        if (event.contentChanges.length == 1 && tree) {
+            let edits = event.contentChanges.map((change) => {
+                let start = doc.offsetAt(change.range.start)
+                return {
+                    "delete": [start, start + change.rangeLength],
+                    "insert": change.text
+                }
+            })
+            update(doc, backend.edit(tree, edits))
+            return
+        }
+        update(doc, null)
+    }, null, disposables)
+
+    vscode.workspace.onDidOpenTextDocument((doc: vscode.TextDocument) => {
+        if (!isKnownDoc(doc)) return
+        update(doc, backend.parse(doc.getText()))
+    }, null, disposables)
+
+    vscode.workspace.onDidCloseTextDocument((doc: vscode.TextDocument) => {
+        update(doc, null)
+    }, null, disposables)
+
+    return (doc: vscode.TextDocument) => {
+        if (!isKnownDoc(doc)) return null
+
+        if (!get(doc)) {
+            update(doc, backend.parse(doc.getText()))
+        }
+        let imp = get(doc)
+        return new EditorFile(backend, imp, doc)
+    }
+}
+
+export class DocumentSymbolProvider implements vscode.DocumentSymbolProvider {
+    getFile: (doc: vscode.TextDocument) => EditorFile | null;
+    constructor(getFile) {
+        this.getFile = getFile
+    }
+
+    provideDocumentSymbols(document: vscode.TextDocument, token: vscode.CancellationToken) {
+        let file = this.getFile(document)
+        if (file == null) return null
+        return file.structure().map((node) => {
+            return new vscode.SymbolInformation(
+                node.name,
+                vscode.SymbolKind.Function,
+                toVsRange(document, node.range),
+                null,
+                null
+            )
+        })
+    }
+}
+
+export class DocumentFormattingEditProvider implements vscode.DocumentFormattingEditProvider {
+    getFile: (doc: vscode.TextDocument) => EditorFile | null;
+    constructor(getFile) { this.getFile = getFile }
+
+    provideDocumentFormattingEdits(
+        document: vscode.TextDocument,
+        options: vscode.FormattingOptions,
+        token: vscode.CancellationToken
+    ): vscode.TextEdit[] {
+        let file = this.getFile(document)
+        if (file == null) return []
+        return file.reformat()
+    }
+}
+
+export class CodeActionProvider implements vscode.CodeActionProvider {
+    fileExtension: string
+    getFile: (doc: vscode.TextDocument) => EditorFile | null;
+    constructor(getFile, fileExtension) {
+        this.getFile = getFile
+        this.fileExtension = fileExtension
+    }
+
+    provideCodeActions(
+        document: vscode.TextDocument,
+        range: vscode.Range,
+        context: vscode.CodeActionContext,
+        token: vscode.CancellationToken
+    ): vscode.Command[] {
+        let file = this.getFile(document)
+        if (file == null) return
+        let actions = file.contextActions(range)
+        return actions.map((id) => {
+            return {
+                title: id,
+                command: `fall-${this.fileExtension}.applyContextAction`,
+                arguments: [range, id]
+            }
+        })
+    }
+}
+
+
+export function toVsEdits(doc: vscode.TextDocument, edits): Array<vscode.TextEdit> {
+    return edits.map((op) => vscode.TextEdit.replace(toVsRange(doc, op.delete), op.insert))
+}
+
+async function openDoc(uri: vscode.Uri) {
+    let document = await vscode.workspace.openTextDocument(uri)
+    vscode.window.showTextDocument(document, vscode.ViewColumn.Two, true)
+}