支持Hover提供符号信息

Author: liwangqian

package.json

@@ -3,7 +3,7 @@
   "displayName": "LuaCoderAssist",
   "description": "lua coder assistant in javascript for vscode",
   "icon": "images/icon.png",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "publisher": "liwangqian",
   "engines": {
     "vscode": "^1.25.0"

server/coder.js

@@ -155,6 +155,7 @@ class Coder {
     }
 
     provideHover(params) {
+        setTimeout(parseDependences, 0, engine.LoadedPackages[params.textDocument.uri], this);
         return {
             contents: this._hoverProvider.provideHover(params)
         };
@@ -199,6 +200,9 @@ class Coder {
 };
 
 var _coderInstance = undefined;
+/**
+ * @returns {Coder}
+ */
 function instance() {
     if (_coderInstance === undefined) {
         _coderInstance = new Coder();

server/lib/engine/extend.js

@@ -87,7 +87,7 @@ function parseJsonObject(node, name) {
         return undefined;
     }
 
-    if (!node.type && (node instanceof Object)) {
+    if (!name && (node instanceof Object)) {
         const object = {};
         for (const key in node) {
             const value = node[key];
@@ -141,11 +141,12 @@ function parseVariantsArgumentsObject(variants, func) {
         return;
     }
 
-    func.description = [];
-    func.variants = variants.map((variant, index) => {
-        let desc = variant.description;
-        func.description[index] = desc || '';
-        return parseArgumentsObject(variant.args);
+    func.variants = variants.map(variant => {
+        return {
+            description: variant.description || '',
+            args: parseArgumentsObject(variant.args),
+            returns: parseReturnsObject(variant.returnTypes)
+        };
     });
 }
 
@@ -185,5 +186,5 @@ function parseRefJsonObject(node, name) {
 }
 
 
-// loadExtentLib('../../../stdlibs/love.json');
-// console.log(namedTypes);
+loadExtentLib('./stdlibs/5_1.json');
+console.log(namedTypes);

server/lib/engine/symbol.js

@@ -77,7 +77,9 @@ const LuaSymbolKind = {
     table: 'table',
     class: 'class',
     module: 'module',
-    function: 'function'
+    function: 'function',
+    thread: 'thread',
+    userdata: 'userdata'
 }
 
 exports.LuaSymbolKind = LuaSymbolKind;
@@ -143,6 +145,8 @@ const LuaTypes = {
     table: 'table',
     function: 'function',
     module: 'module',
+    thread: 'thread',
+    userdata: 'userdata',
     lazy: 'lazy'
 }
 
@@ -178,6 +182,22 @@ class LuaString extends LuaTypeBase {
 
 exports.LuaString = LuaString;
 
+class LuaThread extends LuaTypeBase {
+    constructor() {
+        super(LuaTypes.thread);
+    }
+}
+
+exports.LuaThread = LuaThread;
+
+class LuaUserData extends LuaTypeBase {
+    constructor() {
+        super(LuaTypes.userdata);
+    }
+}
+
+exports.LuaUserData = LuaUserData;
+
 class LuaAny extends LuaTypeBase {
     constructor() {
         super(LuaTypes.any);
@@ -190,6 +210,8 @@ const LuaBasicTypes = {
     number: new LuaNumber(),
     boolean: new LuaBoolean(),
     string: new LuaString(),
+    thread: new LuaThread(),
+    userdata: new LuaUserData(),
     any: new LuaAny()
 };
 
@@ -214,6 +236,54 @@ class SearchResult {
 SearchResult.null = new SearchResult();
 exports.SearchResult = SearchResult;
 
+class TypeGroup {
+    constructor() {
+        this.symbols = [];
+    }
+
+    has(predictor) {
+        return this.indexOf(predictor) < this.symbols.length;
+    }
+
+    indexOf(predictor) {
+        const length = this.symbol.length;
+        for (let i = 0; i < length; i++) {
+            const symbol = this.symbols[i];
+            if (predictor(symbol)) {
+                return i;
+            }
+        }
+        return length;
+    }
+
+    add(symbol) {
+        const index = this.indexOf(s => s.uri === symbol.uri);
+        delete this.symbols[index];
+        this.symbols[index] = symbol;
+        return index;
+    }
+
+    del(symbol) {
+        const index = this.indexOf(s => s.uri === symbol.uri);
+        delete this.symbols.splice(index, 1)[0];
+    }
+
+    get(name, modulePath) {
+        const symbols = [];
+        this.symbols.forEach(symbol => {
+            if (!symbol.uri || symbol.uri.includes(modulePath)) {
+                if (symbol.type instanceof LuaTable) {
+                    let field = symbol.get(name);
+                    field && symbols.push(field);
+                }
+            }
+        });
+        return symbols;
+    }
+}
+
+exports.TypeGroup = TypeGroup;
+
 class LuaTable extends LuaTypeBase {
     constructor(metatable) {
         super(LuaTypes.table);

server/providers/completion-provider.js

@@ -44,16 +44,14 @@ class CompletionProvider {
         let data = this.cache[item.data.index];
         const override = item.data.override;
         item.detail = utils.symbolSignature(data, override);
-        const description = data.type.description;
+        const description = data.type.description || '';
         const link = data.type.link;
-        if (description) {
-            const desc = (override !== undefined) ? description[override] : description;
-            item.documentation = {
-                kind: langserver.MarkupKind.Markdown,
-                value: desc + (link ? `  \r\n[more...](${link})` : '')
-            };
-        }
-        utils.functionSnippet(item, data);
+        const desc = (override !== undefined) ? data.type.variants[override].description : description;
+        item.documentation = {
+            kind: langserver.MarkupKind.Markdown,
+            value: desc + (link ? `  \r\n[more...](${link})` : '')
+        };
+        utils.functionSnippet(item, data, override);
         return item;
     }
 

server/providers/hover-provider.js

@@ -1,7 +1,8 @@
 'use strict';
 
-const symbol_manager = require('./lib/symbol-manager');
+const { DefinitionContext, definitionProvider } = require('../lib/engine/definition');
 const utils = require('./lib/utils');
+const langserver_1 = require('vscode-languageserver');
 
 class HoverProvider {
     constructor(coder) {
@@ -21,36 +22,33 @@ class HoverProvider {
             return undefined;
         }
 
-        // find in current module
-        let defs = this._findDefInCurrentModule(uri, ref);
-
-        // find in dependence
-        defs = defs.concat(this._findDefInDependence(uri, ref));
-
-        return defs.map(d => {
-            let typeDesc = (d.islocal ? '(local ' : '') + utils.symbolKindDesc(d.kind) + (d.islocal ? ') ' : ' ');
-            var item = {
-                language: document.languageId,
-                value: typeDesc + (utils.symbolSignature(d) || d.name)
+        let defs = definitionProvider(new DefinitionContext(ref.name, ref.range, uri));
+
+        let hovers = [];
+        defs.forEach(d => {
+            const variants = d.type.variants;
+            if (!variants) {
+                let hover = this._makeHover(d);
+                hovers.push(hover);
+            } else {
+                variants.forEach((_, override) => {
+                    let hover = this._makeHover(d, override);
+                    hovers.push(hover);
+                });
             }
-            return item;
         });
-    }
-
-    _findDefInCurrentModule(uri, ref) {
-        let sm = symbol_manager.instance();
-        let docsym = sm.documentSymbol(uri);
-        if (!docsym) {
-            return [];
-        }
 
-        return utils.filterModDefinitions(docsym.definitions(), ref, utils.preciseCompareName);
+        return {
+            kind: langserver_1.MarkupKind.Markdown,
+            value: hovers.join('  \r\n')
+        };
     }
 
-    _findDefInDependence(uri, ref) {
-        return utils.filterDepDefinitions(
-            utils.getDefinitionsInDependences(uri, ref, this.coder.tracer),
-            ref, utils.preciseCompareName);
+    _makeHover(symbol, override) {
+        const desc = (override !== undefined) ? symbol.type.variants[override].description : (symbol.type.description || '');
+        const link = symbol.type.link;
+        const more = (link ? `  \r\n[more...](${link})` : '');
+        return `\`\`\`lua\n${utils.symbolSignature(symbol, override)}\`\`\`` + `\r\n${desc}${more}`;
     }
 };
 

server/providers/lib/file-manager.js

@@ -57,6 +57,9 @@ class FileManager {
 };
 
 var _instance = undefined;
+/**
+ * @returns {FileManager}
+ */
 exports.instance = () => {
     if (_instance === undefined) {
         _instance = new FileManager()

server/providers/lib/utils.js

@@ -177,7 +177,7 @@ function symbolAtPosition(position, doc, options) {
 
 exports.symbolAtPosition = symbolAtPosition;
 
-function functionSignature(symbol, override) {
+function symbolSignature(symbol, override) {
     let details = [];
     details.push(symbol.isLocal ? 'local ' : '');
     let type = engine.typeOf(symbol);
@@ -190,23 +190,24 @@ function functionSignature(symbol, override) {
         return details.join('');
     }
 
-    let ret = type.returns.map(item => {
+    let returns = (override !== undefined) ? type.variants[override].returns : type.returns;
+    let ret = returns.map(item => {
         let typeName = engine.typeOf(item).typeName;
         typeName = typeName.startsWith('@') ? 'any' : typeName;
         return typeName;
     });
 
-    const args = override ? type.variants[override] : type.args;
+    let args = (override !== undefined) ? type.variants[override].args : type.args;
     details.push('function ', symbol.name);
-    details.push('(' + args.map(p => symbol.displayName || p.name).join(', ') + ') : ');
+    details.push('(' + args.map(p => p.displayName || p.name).join(', ') + ') -> ');
     details.push(ret.length == 0 ? 'void' : ret.join(', '));
     return details.join('');
 }
 
-exports.symbolSignature = functionSignature;
+exports.symbolSignature = symbolSignature;
 
-function functionSnippet(item, symbol) {
-    const args = symbol.type.args;
+function functionSnippet(item, symbol, override) {
+    const args = (override === undefined) ? symbol.type.args : symbol.type.variants[override].args;
     if (symbol.type.typeName !== 'function') {
         return;
     }