Update version to 1.0.0 !

Make prism as a custom lib instead of node module to reduce the binary size

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+### 1.0.0
+* Refactor the whole plugin with gdscript language server support
+* Add webview renderer to show documentations of native symbols.
+* Only support godot 3.2 and above
+
 ### 0.3.7
 * Add `lint` configuration to control the behaviors of syntax checking
 * Fix error with run godot editor when the editor contains spaces

README.md

@@ -1,28 +1,32 @@
 A complete set of tools to code games with the [Godot game engine](http://www.godotengine.org/) in Visual Studio Code.
 
+**IMPORTANT NOTE**
+This version of plugin only support godot 3.2 and above.
+
 ## Features
 
 The extension comes with a wealth of features to make your Godot programming experience as comfortable as possible:
 
-- Syntax highlighting for the GDscript (`.gd`) language
+- Syntax highlighting for the GDScript (`.gd`) language
 - Syntax highlighting for the `.tscn` and `.tres` scene formats
+- Full Typed GDScript support
+- Optional `Smart Mode` to speed up dynamic typed script coding
 - Function definitions and documentation display on hover (see image below)
 - Rich auto-completion
-- Static code validation
+- Display script warnings and errors
-- Open projects and scenes in Godot from VS Code
 - Ctrl-click on a variable or method call to jump to its definition
 - Full documentation of the Godot engine's API supported
+- Run godot project from VS Code
 
-![Showing the documentation on hover feature](img/godot-tools.jpg)
+![Showing the documentation on hover feature](img/godot-tools.png)
 
 ## Available Commands
 
 The extension adds a few entries to the VS Code Command Palette under "GodotTools":
 
-- Update workspace symbols
-- Run workspace as Godot project
 - Open workspace with Godot editor
-- Run current scene
+- Run workspace as Godot project
+- List native classes of godot
 
 ## Settings
 
@@ -38,27 +42,22 @@ If you like this extension, you can set VS Code as your default script editor fo
 ### VS Code
 
 You can use the following settings to configure Godot Tools:
-- **GodotTools.godotVersion** - The Godot version of your project.
+- **editor_path** - The absolute path to the Godot editor executable
-- **GodotTools.editorPath** - The absolute path to the Godot executable. Required to run the project and test scenes directly from VS Code.
+- **gdscript_lsp_server_port** - The websocket server port of the GDScript language server
-- **GodotTools.workspaceDocumentWithMarkdown** - Control how the documentation of workspace symbols should be rendered: as plain text or as HTML from Markdown.
+- **check_status** - Check the GDScript language server connection status
-- **GodotTools.ignoreIndentedVars** - Only parse variables defined on lines without an indentation.
-- **GodotTools.parseTextScene** - Parse a file as a Godot scene when the file name ends with `.tscn`.
-- **GodotTools.completeNodePath** - Show node paths within a workspace as part of code completion.
-- **GodotTools.godotProjectRoot** - Your Godot project's directory, which contains `project.godot` or `engine.cfg`.
 
 ## Issues and Contributions
 
-The [Godot Tools](https://github.com/GodotExplorer/godot-tools) extension and  [engine modules](https://github.com/GodotExplorer/editor-server) are both hosted on GitHub. Feel free to open issues there and create pull requests anytime.
+The [Godot Tools](https://github.com/godotengine/godot-vscode-plugin) extension is an open source project of godot orgnization. Feel free to open issues and create pull requests anytime.
 
 See the [full changelog](https://github.com/GodotExplorer/godot-tools/blob/master/CHANGELOG.md) for the latest changes.
 
 ## FAQ
-   
-### Why isn't Intellisense showing up for me?
 
-Make sure you save your `.gd` file, then run "GodotTools: Update Workspace Symbols" from the Command Palette.
+### Why failed to connect to language server?
+- You may not open your project with godot editor.
+- Godot 3.2 and above is required.
 
-## TODO:
+### Why isn't intellisense showing up my script members for me?
-* Convert official BBCode documentation into Markdown and render it into HTML with documentation previewer pages
+- The GDScript is a dynamic typed script language the tool may can infer all the variable types as you want.
-* Add mermaid support with documentation
+- You can turn on the `Smart Mode` in godot editor `Editor Settings > Language Server` check the `Enable Smart Resolve`.
-* Undefined variable checking

configurations/GDScript.tmLanguage.json

@@ -15,22 +15,19 @@
     { "include": "#const_def" },
     { "include": "#type_declear"},
     { "include": "#class_def" },
-    { "include": "#builtinFuncs" },
-    { "include": "#builtinClasses" },
-    { "include": "#builtinProps" },
-    { "include": "#builtinConsts" },
-    { "include": "#const_vars" },
     { "include": "#classname"},
+    { "include": "#builtin_func" },
+    { "include": "#builtin_classes" },
+    { "include": "#const_vars" },
     { "include": "#class_new"},
+    { "include": "#class_is"},
     { "include": "#class_enum"},
     { "include": "#function-declaration" },
     { "include": "#function-return-type" },
     { "include": "#any-method" },
     { "include": "#any-property" },
-    {
+    { "include": "#extends" },
-      "match": "(?<=extends)\\s+[a-zA-Z_][a-zA-Z_0-9]*(\\.([a-zA-Z_][a-zA-Z_0-9]*))?",
+    { "include": "#parscal_class" }
-      "name": "entity.other.inherited-class.gdscript"
-    }
   ],
   "repository": {
     "comment": {
@@ -45,17 +42,32 @@
     "strings": {
       "patterns": [{
           "begin": "\"",
-          "end": "(?<!\\\\)\"",
+          "end": "\"",
+          "patterns": [
+            {  "name": "constant.character.escape.untitled",
+                "match": "\\."
+            }
+          ],
           "name": "string.quoted.double.gdscript"
         },
         {
           "begin": "'",
-          "end": "(?<!\\\\)'",
+          "end": "'",
+          "patterns": [
+            {  "name": "constant.character.escape.untitled",
+                "match": "\\."
+            }
+          ],
           "name": "string.quoted.single.gdscript"
         },
         {
           "begin": "@\"",
-          "end": "(?<!\\\\)\"",
+          "end": "\"",
+          "patterns": [
+            {  "name": "constant.character.escape.untitled",
+                "match": "\\."
+            }
+          ],
           "name": "string.nodepath.gdscript"
         }
       ]
@@ -91,7 +103,7 @@
     },
 
     "keywords": {
-      "match": "\\b(?i:elif|else|for|if|while|break|continue|pass|in|is|return|onready|setget|enum|match|breakpoint|tool|extends|signal|class|static|export|var|const|func|new|void|float|int|bool|as|assert|class_name|preload|yield|remote|sync|master|puppet|slave|remotesync|mastersync|puppetsync)\\b",
+      "match": "\\b(?i:if|elif|else|for|while|break|continue|pass|return|match|func|class|class_name|extends|is|onready|tool|static|export|setget|const|var|as|void|enum|preload|assert|yield|signal|breakpoint|rpc|sync|master|puppet|slave|remotesync|mastersync|puppetsync)\\b",
       "name": "keyword.language.gdscript"
     },
     "letter": {
@@ -154,36 +166,40 @@
       },
       "match": "(?<=^class)\\s+([a-zA-Z_]\\w*)\\s*(?=:)"
     },
-    "classname": {
-      "captures": {
-        "1": {
-          "name": "keyword.language.gdscript"
-        },
-        "2": {
-          "name": "entity.other.inherited-class.gdscript"
-        }
-      },
-      "match": "^(class_name)\\s+([a-zA-Z_]\\w*)"
-    },
     "class_new": {
       "captures": {
         "1": { "name": "entity.name.type.class.gdscript" },
         "2": { "name": "storage.type.new.gdscript" }
       },
       "match": "\\b([a-zA-Z_][a-zA-Z_0-9]*).(new)\\("
+    },
+		"class_is": {
+      "captures": {
+        "1": { "name": "storage.type.is.gdscript" },
+        "2": { "name": "entity.name.type.class.gdscript" }
+      },
+      "match": "\\s+(is)\\s+([a-zA-Z_][a-zA-Z_0-9]*)"
     },
     "class_enum": {
       "captures": {
         "1": { "name": "entity.name.type.class.gdscript" },
         "2": { "name": "constant.language.gdscript" }
       },
-      "match": "\\b([A-Z][a-zA-Z_0-9]*).([A-Z_0-9]+)"
+      "match": "\\b([A-Z][a-zA-Z_0-9]*)\\.([A-Z_0-9]+)"
+    },
+		"classname": {
+      "match": "(?<=class_name)\\s+([a-zA-Z_][a-zA-Z_0-9]*(\\.([a-zA-Z_][a-zA-Z_0-9]*))?)",
+      "name": "entity.name.type.class.gdscript"
+    },
+		"extends": {
+      "match": "(?<=extends)\\s+[a-zA-Z_][a-zA-Z_0-9]*(\\.([a-zA-Z_][a-zA-Z_0-9]*))?",
+      "name": "entity.other.inherited-class.gdscript"
     },
     "builtin_func": {
       "match": "(?<![^.]\\.|:)\\b(sin|cos|tan|sinh|cosh|tanh|asin|acos|atan|atan2|sqrt|fmod|fposmod|floor|ceil|round|abs|sign|pow|log|exp|is_nan|is_inf|ease|decimals|stepify|lerp|dectime|randomize|randi|randf|rand_range|seed|rand_seed|deg2rad|rad2deg|linear2db|db2linear|max|min|clamp|nearest_po2|weakref|funcref|convert|typeof|type_exists|char|str|print|printt|prints|printerr|printraw|var2str|str2var|var2bytes|bytes2var|range|load|inst2dict|dict2inst|hash|Color8|print_stack|instance_from_id|preload|yield|assert)\\b(?=(\\()([^)]*)(\\)))",
       "name": "support.function.builtin.gdscript"
     },
-    "builtinClasses": {
+    "builtin_classes": {
       "match": "(?<![^.]\\.|:)\\b(Vector2|Vector3|Color|Rect2|Array|Basis|Dictionary|Plane|Quat|RID|Rect3|Transform|Transform2D|AABB|String|Color|NodePath|RID|Object|Dictionary|Array|PoolByteArray|PoolIntArray|PoolRealArray|PoolStringArray|PoolVector2Array|PoolVector3Array|PoolColorArray)\\b",
       "name": "support.class.library.gdscript"
     },
@@ -308,6 +324,12 @@
           ]
         }
       ]
+    },
+		"parscal_class": {
+      "captures": {
+        "1": { "name": "entity.name.type.class.gdscript" }
+      },
+      "match": "([A-Z][a-zA-Z_0-9]*)"
     }
   }
 }

package.json

@@ -2,7 +2,7 @@
 	"name": "godot-tools",
 	"displayName": "godot-tools",
 	"icon": "icon.png",
-	"version": "0.9.0",
+	"version": "1.0.0",
 	"description": "Tools for game development with godot game engine",
 	"repository": "https://github.com/godotengine/godot-vscode-plugin",
 	"author": "The Godot Engine community",
@@ -34,6 +34,10 @@
 			{
 				"command": "godot-tool.run_project",
 				"title": "Godot Tools: Run workspace as Godot project"
+			},
+			{
+				"command": "godot-tool.list_native_classes",
+				"title": "Godot Tools: List native classes of godot"
 			}
 		],
 		"configuration": {
@@ -53,7 +57,7 @@
 				"godot-tool.check_status": {
 					"type": "string",
 					"default": "",
-					"description": "The absolute path to the Godot editor executable"
+					"description": "Check the gdscript language server connection status"
 				}
 			}
 		},
@@ -96,16 +100,19 @@
 		]
 	},
 	"devDependencies": {
+		"@types/marked": "^0.6.5",
 		"@types/mocha": "^2.2.42",
 		"@types/node": "^10.12.21",
+		"@types/prismjs": "^1.16.0",
 		"@types/ws": "^6.0.1",
 		"tslint": "^5.16.0",
-		"vscode": "^1.1.33",
+		"typescript": "^3.4.5",
-		"typescript": "^3.4.5"
+		"vscode": "^1.1.33"
 	},
 	"dependencies": {
-		"vscode-languageclient": "^5.2.1",
 		"global": "^4.4.0",
+		"marked": "^0.7.0",
+		"vscode-languageclient": "^5.2.1",
 		"ws": "^7.0.0"
 	}
 }

src/deps/prism/prism.js

@@ -0,0 +1,573 @@
+/* PrismJS 1.17.1
+https://prismjs.com/download.html#themes=prism */
+var _self = (typeof window !== 'undefined')
+	? window   // if in browser
+	: (
+		(typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
+		? self // if in worker
+		: {}   // if in node js
+	);
+
+/**
+ * Prism: Lightweight, robust, elegant syntax highlighting
+ * MIT license http://www.opensource.org/licenses/mit-license.php/
+ * @author Lea Verou http://lea.verou.me
+ */
+
+var Prism = (function (_self){
+
+// Private helper vars
+var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+var uniqueId = 0;
+
+/**
+ * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
+ *
+ * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
+ *
+ * @param {Element} element
+ * @returns {string}
+ */
+function getLanguage(element) {
+	while (element && !lang.test(element.className)) {
+		element = element.parentNode;
+	}
+	if (element) {
+		return (element.className.match(lang) || [, 'none'])[1].toLowerCase();
+	}
+	return 'none';
+}
+
+
+var _ = {
+	manual: _self.Prism && _self.Prism.manual,
+	disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
+	util: {
+		encode: function (tokens) {
+			if (tokens instanceof Token) {
+				return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);
+			} else if (Array.isArray(tokens)) {
+				return tokens.map(_.util.encode);
+			} else {
+				return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
+			}
+		},
+
+		type: function (o) {
+			return Object.prototype.toString.call(o).slice(8, -1);
+		},
+
+		objId: function (obj) {
+			if (!obj['__id']) {
+				Object.defineProperty(obj, '__id', { value: ++uniqueId });
+			}
+			return obj['__id'];
+		},
+
+		// Deep clone a language definition (e.g. to extend it)
+		clone: function deepClone(o, visited) {
+			var clone, id, type = _.util.type(o);
+			visited = visited || {};
+
+			switch (type) {
+				case 'Object':
+					id = _.util.objId(o);
+					if (visited[id]) {
+						return visited[id];
+					}
+					clone = {};
+					visited[id] = clone;
+
+					for (var key in o) {
+						if (o.hasOwnProperty(key)) {
+							clone[key] = deepClone(o[key], visited);
+						}
+					}
+
+					return clone;
+
+				case 'Array':
+					id = _.util.objId(o);
+					if (visited[id]) {
+						return visited[id];
+					}
+					clone = [];
+					visited[id] = clone;
+
+					o.forEach(function (v, i) {
+						clone[i] = deepClone(v, visited);
+					});
+
+					return clone;
+
+				default:
+					return o;
+			}
+		}
+	},
+
+	languages: {
+		extend: function (id, redef) {
+			var lang = _.util.clone(_.languages[id]);
+
+			for (var key in redef) {
+				lang[key] = redef[key];
+			}
+
+			return lang;
+		},
+
+		/**
+		 * Insert a token before another token in a language literal
+		 * As this needs to recreate the object (we cannot actually insert before keys in object literals),
+		 * we cannot just provide an object, we need an object and a key.
+		 * @param inside The key (or language id) of the parent
+		 * @param before The key to insert before.
+		 * @param insert Object with the key/value pairs to insert
+		 * @param root The object that contains `inside`. If equal to Prism.languages, it can be omitted.
+		 */
+		insertBefore: function (inside, before, insert, root) {
+			root = root || _.languages;
+			var grammar = root[inside];
+			var ret = {};
+
+			for (var token in grammar) {
+				if (grammar.hasOwnProperty(token)) {
+
+					if (token == before) {
+						for (var newToken in insert) {
+							if (insert.hasOwnProperty(newToken)) {
+								ret[newToken] = insert[newToken];
+							}
+						}
+					}
+
+					// Do not insert token which also occur in insert. See #1525
+					if (!insert.hasOwnProperty(token)) {
+						ret[token] = grammar[token];
+					}
+				}
+			}
+
+			var old = root[inside];
+			root[inside] = ret;
+
+			// Update references in other language definitions
+			_.languages.DFS(_.languages, function(key, value) {
+				if (value === old && key != inside) {
+					this[key] = ret;
+				}
+			});
+
+			return ret;
+		},
+
+		// Traverse a language definition with Depth First Search
+		DFS: function DFS(o, callback, type, visited) {
+			visited = visited || {};
+
+			var objId = _.util.objId;
+
+			for (var i in o) {
+				if (o.hasOwnProperty(i)) {
+					callback.call(o, i, o[i], type || i);
+
+					var property = o[i],
+					    propertyType = _.util.type(property);
+
+					if (propertyType === 'Object' && !visited[objId(property)]) {
+						visited[objId(property)] = true;
+						DFS(property, callback, null, visited);
+					}
+					else if (propertyType === 'Array' && !visited[objId(property)]) {
+						visited[objId(property)] = true;
+						DFS(property, callback, i, visited);
+					}
+				}
+			}
+		}
+	},
+	plugins: {},
+
+	highlightAll: function(async, callback) {
+		_.highlightAllUnder(document, async, callback);
+	},
+
+	highlightAllUnder: function(container, async, callback) {
+		var env = {
+			callback: callback,
+			selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+		};
+
+		_.hooks.run('before-highlightall', env);
+
+		var elements = container.querySelectorAll(env.selector);
+
+		for (var i=0, element; element = elements[i++];) {
+			_.highlightElement(element, async === true, env.callback);
+		}
+	},
+
+	highlightElement: function(element, async, callback) {
+		// Find language
+		var language = getLanguage(element);
+		var grammar = _.languages[language];
+
+		// Set language on the element, if not present
+		element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
+
+		// Set language on the parent, for styling
+		var parent = element.parentNode;
+		if (parent && parent.nodeName.toLowerCase() === 'pre') {
+			parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
+		}
+
+		var code = element.textContent;
+
+		var env = {
+			element: element,
+			language: language,
+			grammar: grammar,
+			code: code
+		};
+
+		function insertHighlightedCode(highlightedCode) {
+			env.highlightedCode = highlightedCode;
+
+			_.hooks.run('before-insert', env);
+
+			env.element.innerHTML = env.highlightedCode;
+
+			_.hooks.run('after-highlight', env);
+			_.hooks.run('complete', env);
+			callback && callback.call(env.element);
+		}
+
+		_.hooks.run('before-sanity-check', env);
+
+		if (!env.code) {
+			_.hooks.run('complete', env);
+			callback && callback.call(env.element);
+			return;
+		}
+
+		_.hooks.run('before-highlight', env);
+
+		if (!env.grammar) {
+			insertHighlightedCode(_.util.encode(env.code));
+			return;
+		}
+
+		if (async && _self.Worker) {
+			var worker = new Worker(_.filename);
+
+			worker.onmessage = function(evt) {
+				insertHighlightedCode(evt.data);
+			};
+
+			worker.postMessage(JSON.stringify({
+				language: env.language,
+				code: env.code,
+				immediateClose: true
+			}));
+		}
+		else {
+			insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
+		}
+	},
+
+	highlight: function (text, grammar, language) {
+		var env = {
+			code: text,
+			grammar: grammar,
+			language: language
+		};
+		_.hooks.run('before-tokenize', env);
+		env.tokens = _.tokenize(env.code, env.grammar);
+		_.hooks.run('after-tokenize', env);
+		return Token.stringify(_.util.encode(env.tokens), env.language);
+	},
+
+	matchGrammar: function (text, strarr, grammar, index, startPos, oneshot, target) {
+		for (var token in grammar) {
+			if (!grammar.hasOwnProperty(token) || !grammar[token]) {
+				continue;
+			}
+
+			var patterns = grammar[token];
+			patterns = Array.isArray(patterns) ? patterns : [patterns];
+
+			for (var j = 0; j < patterns.length; ++j) {
+				if (target && target == token + ',' + j) {
+					return;
+				}
+
+				var pattern = patterns[j],
+					inside = pattern.inside,
+					lookbehind = !!pattern.lookbehind,
+					greedy = !!pattern.greedy,
+					lookbehindLength = 0,
+					alias = pattern.alias;
+
+				if (greedy && !pattern.pattern.global) {
+					// Without the global flag, lastIndex won't work
+					var flags = pattern.pattern.toString().match(/[imsuy]*$/)[0];
+					pattern.pattern = RegExp(pattern.pattern.source, flags + 'g');
+				}
+
+				pattern = pattern.pattern || pattern;
+
+				// Don’t cache length as it changes during the loop
+				for (var i = index, pos = startPos; i < strarr.length; pos += strarr[i].length, ++i) {
+
+					var str = strarr[i];
+
+					if (strarr.length > text.length) {
+						// Something went terribly wrong, ABORT, ABORT!
+						return;
+					}
+
+					if (str instanceof Token) {
+						continue;
+					}
+
+					if (greedy && i != strarr.length - 1) {
+						pattern.lastIndex = pos;
+						var match = pattern.exec(text);
+						if (!match) {
+							break;
+						}
+
+						var from = match.index + (lookbehind && match[1] ? match[1].length : 0),
+						    to = match.index + match[0].length,
+						    k = i,
+						    p = pos;
+
+						for (var len = strarr.length; k < len && (p < to || (!strarr[k].type && !strarr[k - 1].greedy)); ++k) {
+							p += strarr[k].length;
+							// Move the index i to the element in strarr that is closest to from
+							if (from >= p) {
+								++i;
+								pos = p;
+							}
+						}
+
+						// If strarr[i] is a Token, then the match starts inside another Token, which is invalid
+						if (strarr[i] instanceof Token) {
+							continue;
+						}
+
+						// Number of tokens to delete and replace with the new match
+						delNum = k - i;
+						str = text.slice(pos, p);
+						match.index -= pos;
+					} else {
+						pattern.lastIndex = 0;
+
+						var match = pattern.exec(str),
+							delNum = 1;
+					}
+
+					if (!match) {
+						if (oneshot) {
+							break;
+						}
+
+						continue;
+					}
+
+					if(lookbehind) {
+						lookbehindLength = match[1] ? match[1].length : 0;
+					}
+
+					var from = match.index + lookbehindLength,
+					    match = match[0].slice(lookbehindLength),
+					    to = from + match.length,
+					    before = str.slice(0, from),
+					    after = str.slice(to);
+
+					var args = [i, delNum];
+
+					if (before) {
+						++i;
+						pos += before.length;
+						args.push(before);
+					}
+
+					var wrapped = new Token(token, inside? _.tokenize(match, inside) : match, alias, match, greedy);
+
+					args.push(wrapped);
+
+					if (after) {
+						args.push(after);
+					}
+
+					Array.prototype.splice.apply(strarr, args);
+
+					if (delNum != 1)
+						_.matchGrammar(text, strarr, grammar, i, pos, true, token + ',' + j);
+
+					if (oneshot)
+						break;
+				}
+			}
+		}
+	},
+
+	tokenize: function(text, grammar) {
+		var strarr = [text];
+
+		var rest = grammar.rest;
+
+		if (rest) {
+			for (var token in rest) {
+				grammar[token] = rest[token];
+			}
+
+			delete grammar.rest;
+		}
+
+		_.matchGrammar(text, strarr, grammar, 0, 0, false);
+
+		return strarr;
+	},
+
+	hooks: {
+		all: {},
+
+		add: function (name, callback) {
+			var hooks = _.hooks.all;
+
+			hooks[name] = hooks[name] || [];
+
+			hooks[name].push(callback);
+		},
+
+		run: function (name, env) {
+			var callbacks = _.hooks.all[name];
+
+			if (!callbacks || !callbacks.length) {
+				return;
+			}
+
+			for (var i=0, callback; callback = callbacks[i++];) {
+				callback(env);
+			}
+		}
+	},
+
+	Token: Token
+};
+
+_self.Prism = _;
+
+function Token(type, content, alias, matchedStr, greedy) {
+	this.type = type;
+	this.content = content;
+	this.alias = alias;
+	// Copy of the full string this token was created from
+	this.length = (matchedStr || '').length|0;
+	this.greedy = !!greedy;
+}
+
+Token.stringify = function(o, language) {
+	if (typeof o == 'string') {
+		return o;
+	}
+
+	if (Array.isArray(o)) {
+		return o.map(function(element) {
+			return Token.stringify(element, language);
+		}).join('');
+	}
+
+	var env = {
+		type: o.type,
+		content: Token.stringify(o.content, language),
+		tag: 'span',
+		classes: ['token', o.type],
+		attributes: {},
+		language: language
+	};
+
+	if (o.alias) {
+		var aliases = Array.isArray(o.alias) ? o.alias : [o.alias];
+		Array.prototype.push.apply(env.classes, aliases);
+	}
+
+	_.hooks.run('wrap', env);
+
+	var attributes = Object.keys(env.attributes).map(function(name) {
+		return name + '="' + (env.attributes[name] || '').replace(/"/g, '&quot;') + '"';
+	}).join(' ');
+
+	return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + (attributes ? ' ' + attributes : '') + '>' + env.content + '</' + env.tag + '>';
+};
+
+if (!_self.document) {
+	if (!_self.addEventListener) {
+		// in Node.js
+		return _;
+	}
+
+	if (!_.disableWorkerMessageHandler) {
+		// In worker
+		_self.addEventListener('message', function (evt) {
+			var message = JSON.parse(evt.data),
+				lang = message.language,
+				code = message.code,
+				immediateClose = message.immediateClose;
+
+			_self.postMessage(_.highlight(code, _.languages[lang], lang));
+			if (immediateClose) {
+				_self.close();
+			}
+		}, false);
+	}
+
+	return _;
+}
+
+//Get current script and highlight
+var script = document.currentScript || [].slice.call(document.getElementsByTagName('script')).pop();
+
+if (script) {
+	_.filename = script.src;
+	
+	if (script.hasAttribute('data-manual')) {
+		_.manual = true;
+	}
+}
+
+if (!_.manual) {
+	function highlightAutomaticallyCallback() {
+		if (!_.manual) {
+			_.highlightAll();
+		}
+	}
+
+	if(document.readyState !== 'loading') {
+		if (window.requestAnimationFrame) {
+			window.requestAnimationFrame(highlightAutomaticallyCallback);
+		} else {
+			window.setTimeout(highlightAutomaticallyCallback, 16);
+		}
+	}
+	else {
+		document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
+	}
+}
+
+return _;
+
+})(_self);
+
+if (typeof module !== 'undefined' && module.exports) {
+	module.exports = Prism;
+}
+
+// hack for components to work correctly in node.js
+if (typeof global !== 'undefined') {
+	global.Prism = Prism;
+}
+;

src/godot-tools.ts

@@ -17,7 +17,7 @@ export class GodotTools {
 
 	constructor(p_context: vscode.ExtensionContext) {
 		this.context = p_context;
-		this.client = new GDScriptLanguageClient();
+		this.client = new GDScriptLanguageClient(p_context);
 		this.client.watch_status(this.on_client_status_changed.bind(this));
 		this.connection_status = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right);
 	}

src/lsp/GDScriptLanguageClient.ts

@@ -1,11 +1,10 @@
 import * as vscode from 'vscode';
-import { LanguageClient, LanguageClientOptions, ServerOptions, RequestMessage, NotificationMessage } from "vscode-languageclient";
+import { LanguageClient, LanguageClientOptions, ServerOptions, RequestMessage } from "vscode-languageclient";
 import { is_debug_mode, get_configuration } from "../utils";
-import { MessageIO, MessageIOReader, MessageIOWriter } from "./MessageIO";
+import { MessageIO, MessageIOReader, MessageIOWriter, Message } from "./MessageIO";
-import { ResponseMessage } from "vscode-jsonrpc/lib/messages";
 import logger from "../loggger";
 import { EventEmitter } from "events";
-type Message = RequestMessage | ResponseMessage | NotificationMessage;
+import NativeDocumentManager from './NativeDocumentManager';
 
 function getClientOptions(): LanguageClientOptions {
 	return {
@@ -44,11 +43,13 @@ export default class GDScriptLanguageClient extends LanguageClient {
 	
 	public io: MessageIO = io;
 	
+	private context: vscode.ExtensionContext;
 	private _started : boolean = false;
 	private _status : ClientStatus;
 	private _status_changed_callbacks: ((v : ClientStatus)=>void)[] = [];
 	private _initialize_request: Message = null;
 	private message_handler: MessageHandler = null;
+	private native_doc_manager: NativeDocumentManager = null;	
 	
 	public get started() : boolean { return this._started; }
 	public get status() : ClientStatus { return this._status; }
@@ -67,14 +68,16 @@ export default class GDScriptLanguageClient extends LanguageClient {
 		}
 	}
 	
-	constructor() {
+	constructor(context: vscode.ExtensionContext) {
 		super(`GDScriptLanguageClient`, serverOptions, getClientOptions());
+		this.context = context;
 		this.status = ClientStatus.PENDING;
 		this.message_handler = new MessageHandler();
 		this.io.on('disconnected', this.on_disconnected.bind(this));
 		this.io.on('connected', this.on_connected.bind(this));
 		this.io.on('message', this.on_message.bind(this));
 		this.io.on('send_message', this.on_send_message.bind(this));
+		this.native_doc_manager = new NativeDocumentManager(this.io);
 	}
 	
 	connect_to_server() {

src/lsp/MessageIO.ts

@@ -3,7 +3,8 @@ import { EventEmitter } from "events";
 import * as WebSocket  from 'ws';
 import MessageBuffer from "./MessageBuffer";
 import { AbstractMessageWriter, MessageWriter } from "vscode-jsonrpc/lib/messageWriter";
-import { Message } from "vscode-jsonrpc";
+import { RequestMessage, ResponseMessage, NotificationMessage } from "vscode-jsonrpc/lib/messages";
+export type Message = RequestMessage | ResponseMessage | NotificationMessage;
 
 export class MessageIO extends EventEmitter {
 	

src/lsp/NativeDocumentManager.ts

@@ -0,0 +1,547 @@
+import * as vscode from 'vscode';
+import { EventEmitter } from "events";
+import { MessageIO } from "./MessageIO";
+import { NotificationMessage } from "vscode-jsonrpc";
+import * as Prism from "../deps/prism/prism";
+import * as marked from "marked";
+import { Methods, NativeSymbolInspectParams, GodotNativeSymbol, GodotNativeClassInfo, GodotCapabilities } from './gdscript.capabilities';
+marked.setOptions({
+	highlight: function (code, lang) {
+		return Prism.highlight(code, GDScriptGrammar, lang);
+	}
+});
+
+const enum WebViewMessageType {
+	INSPECT_NATIVE_SYMBOL = 'INSPECT_NATIVE_SYMBOL',
+};
+const LIST_NATIVE_CLASS_COMMAND = 'godot-tool.list_native_classes';
+
+export default class NativeDocumentManager extends EventEmitter {
+	
+	private io: MessageIO = null;
+	private native_classes: {[key: string]: GodotNativeClassInfo } = {};
+	
+	constructor(io: MessageIO) {
+		super();
+		this.io = io;
+		io.on("message", (message: NotificationMessage)=>{
+			if (message.method == Methods.SHOW_NATIVE_SYMBOL) {
+				this.show_native_symbol(message.params);
+			} else if (message.method == Methods.GDSCRIPT_CAPABILITIES) {
+				for (const gdclass of (message.params as GodotCapabilities).native_classes) {
+					this.native_classes[gdclass.name] = gdclass;
+				}
+				for (const gdclass of (message.params as GodotCapabilities).native_classes) {
+					if (gdclass.inherits) {
+						const extended_classes = this.native_classes[gdclass.inherits].extended_classes || [];
+						extended_classes.push(gdclass.name);
+						this.native_classes[gdclass.inherits].extended_classes = extended_classes;
+					}
+				}
+			}
+		});
+		
+		vscode.commands.registerCommand(LIST_NATIVE_CLASS_COMMAND, this.list_native_classes.bind(this));
+	}
+	
+	private async list_native_classes() {
+		let classname = await vscode.window.showQuickPick(
+			Object.keys(this.native_classes).sort(),
+			{
+				placeHolder: 'Type godot class name here',
+				canPickMany: false
+			}
+		);
+		if (classname) {
+			this.inspect_native_symbol({native_class: classname, symbol_name: classname});
+		}
+	}
+	
+	private inspect_native_symbol(params: NativeSymbolInspectParams) {
+		this.io.send_message(JSON.stringify({
+			id: -1,
+			jsonrpc: "2.0",
+			method: Methods.INSPECT_NATIVE_SYMBOL,
+			params
+		}));
+	}
+
+	
+	private show_native_symbol(symbol: GodotNativeSymbol) {
+		// 创建webview
+		const panel = vscode.window.createWebviewPanel(
+			'doc',
+			symbol.name,
+			vscode.ViewColumn.Nine,
+			{
+				enableScripts: true, // 启用JS，默认禁用
+				retainContextWhenHidden: false, // webview被隐藏时保持状态，避免被重置
+			}
+		);
+		panel.title = symbol.name;
+		panel.webview.html = this.make_html_content(symbol);
+		panel.webview.onDidReceiveMessage(this.on_webview_message.bind(this));
+	}
+	
+	private on_webview_message(msg: any) {
+		switch (msg.type) {
+			case WebViewMessageType.INSPECT_NATIVE_SYMBOL:
+				this.inspect_native_symbol(msg.data);
+				break;
+			default:
+				break;
+		}
+	}
+	
+	private make_html_content(symbol: GodotNativeSymbol): string {
+		return `
+		<html>
+			<head>
+				<style type="text/css">
+					${PrismStyleSheet}
+					.codeblock {
+						padding: 0.5em;
+						margin: .5em 0;
+						overflow: auto;
+						border-radius: 0.3em;
+						!background-color: #fdf6e3;
+					}
+					a {
+						text-decoration: none;
+					}
+				</style>
+			</head>
+			<body style="line-height: 16pt;">${this.make_symbol_document(symbol)}</body>
+			<script>
+				var vscode = acquireVsCodeApi();
+				function inspect(native_class, symbol_name) {
+					if (typeof(godot_class) != 'undefined' && godot_class == native_class) {
+						document.getElementById(symbol_name).scrollIntoView();
+					} else {
+						vscode.postMessage({
+							type: '${WebViewMessageType.INSPECT_NATIVE_SYMBOL}',
+							data: {
+								native_class: native_class,
+								symbol_name: symbol_name
+							}
+						});
+					}
+				};
+			</script>
+		</html>`;
+	}
+	
+	
+	private make_symbol_document(symbol: GodotNativeSymbol): string {
+		const classlink = make_link(symbol.native_class, undefined);
+		const classinfo = this.native_classes[symbol.native_class];
+		
+		function make_function_signature(s: GodotNativeSymbol, with_class = false) {
+			let parts = /\((.*)?\)\s*\-\>\s*(([A-z0-9]+)?)$/.exec(s.detail);
+			if (!parts) return "";
+			const ret_type = make_link(parts[2] || "void", undefined);
+			let args = (parts[1] || "").replace(/\:\s([A-z0-9_]+)(\,\s*)?/g, `: <a href="" onclick="inspect('$1', '$1')">$1</a>$2`);
+			args = args.replace(/\s=\s(.*?)[\,\)]/g, "")
+			return `${ret_type} ${with_class?`${classlink}.`:''}${element("a", s.name, {href: `#${s.name}`})}( ${args} )`;
+		};
+		
+		function make_symbol_elements(s: GodotNativeSymbol, with_class = false): {index?: string, body: string} {
+			switch (s.kind) {
+				case vscode.SymbolKind.Property:
+				case vscode.SymbolKind.Variable: {
+					// var Control.anchor_left: float
+					const parts = /\.([A-z_0-9]+)\:\s(.*)$/.exec(s.detail);
+					if (!parts) return;
+					let type = make_link(parts[2], undefined);
+					let name = element("a", s.name, {href: `#${s.name}`});
+					const title = element('h4', `${type} ${with_class?`${classlink}.`:''}${s.name}`);
+					const doc = element("p", format_documentation(s.documentation, symbol.native_class));
+					const div = element("div", title + doc);
+					return {
+						index: type + " " + name,
+						body: div,
+					};
+				} break;
+				case vscode.SymbolKind.Constant: {
+					// const Control.FOCUS_ALL: FocusMode = 2
+					// const Control.NOTIFICATION_RESIZED = 40
+					const parts = /\.([A-Za-z_0-9]+)(\:\s*)?([A-z0-9_\.]+)?\s*=\s*(.*)$/.exec(s.detail);
+					if (!parts) return;
+					let type = make_link(parts[3] || 'int', undefined);
+					let name = parts[1];
+					let value = element('code', parts[4]);
+					
+					const title = element('p', `${type} ${with_class?`${classlink}.`:''}${name} = ${value}`);
+					const doc = element("p", format_documentation(s.documentation, symbol.native_class));
+					const div = element("div", title + doc);
+					return {
+						body: div
+					};
+				} break;
+				case vscode.SymbolKind.Event: {
+					const parts = /\.([A-z0-9]+)\((.*)?\)/.exec(s.detail);
+					if (!parts) return;
+					const args = (parts[2] || "").replace(/\:\s([A-z0-9_]+)(\,\s*)?/g, `: <a href="" onclick="inspect('$1', '$1')">$1</a>$2`);
+					const title = element('p', `${with_class?`signal ${with_class?`${classlink}.`:''}`:''}${s.name}( ${args} )`);
+					const doc = element("p", format_documentation(s.documentation, symbol.native_class));
+					const div = element("div", title + doc);
+					return {
+						body: div
+					};
+				} break;
+				case vscode.SymbolKind.Method:
+				case vscode.SymbolKind.Function: {
+					const signature = make_function_signature(s, with_class);
+					const title = element("h4", signature);
+					const doc = element("p", format_documentation(s.documentation, symbol.native_class));
+					const div = element("div", title + doc);
+					return {
+						index: signature,
+						body: div
+					};
+				} break;
+				default:
+					break;
+			}
+		};
+		
+		if (symbol.kind == vscode.SymbolKind.Class) {
+			
+			let doc = element("h2", `Native class ${symbol.name}`);
+			const parts = /extends\s+([A-z0-9]+)/.exec(symbol.detail);
+			let inherits = parts && parts.length > 1 ? parts[1] : '';
+			if (inherits) {
+				let inherits_chian = '';
+				let base_class = this.native_classes[inherits];
+				while(base_class) {
+					inherits_chian += `${inherits_chian?' >':''} ${make_link(base_class.name, undefined)}`;
+					base_class = this.native_classes[base_class.inherits];
+				}
+				inherits = `Inherits: ${inherits_chian}`;
+				doc += element("p", inherits);
+			}
+			if (classinfo && classinfo.extended_classes) {
+				let inherited = "";
+				for (const c of classinfo.extended_classes) {
+					inherited += (inherited ? ', ' : ' ') + make_link(c, c);
+				}
+				doc += element("p", `Inherited by:${inherited}`);
+			}
+			
+			let constants = "";
+			let signals = "";
+			let methods_index = "";
+			let methods = "";
+			let properties_index = "";
+			let propertyies = "";
+			let others = "";
+			
+			for (let s of symbol.children as GodotNativeSymbol[]) {
+				const elements = make_symbol_elements(s);
+				switch (s.kind) {
+					case vscode.SymbolKind.Property:
+					case vscode.SymbolKind.Variable:
+						properties_index += element("li", elements.index);
+						propertyies += element("li", elements.body, {id: s.name});
+						break;
+					case vscode.SymbolKind.Constant:
+						constants += element("li", elements.body, {id: s.name});
+						break;
+					case vscode.SymbolKind.Event:
+						signals += element("li", elements.body, {id: s.name});
+						break;
+					case vscode.SymbolKind.Method:
+					case vscode.SymbolKind.Function:
+						methods_index += element("li", elements.index);
+						methods += element("li", elements.body, {id: s.name});
+						break;
+					default:
+						others += element("li", elements.body, {id: s.name});
+						break;
+				}
+			}
+			
+			function add_group(title: string, block: string) {
+				if (block) {
+					doc += element('h3', title);
+					doc += element('ul', block);
+				}
+			};
+			
+			doc += element("p", format_documentation(symbol.documentation, symbol.native_class));
+			add_group("Properties", properties_index);
+			add_group("Constants", constants);
+			add_group("Signals", signals);
+			add_group("Methods", methods_index);
+			add_group("Property Descriptions", propertyies);
+			add_group("Method Descriptions", methods);
+			add_group("Other Members", others);
+			doc += element("script", `var godot_class = "${symbol.native_class}";`);
+			
+			return doc;
+		} else {
+			let doc = "";
+			const elements = make_symbol_elements(symbol, true);
+			if (elements.index) {
+				if ([vscode.SymbolKind.Function, vscode.SymbolKind.Method].indexOf(symbol.kind) == -1) {
+					doc += element("h2", elements.index);
+				}
+			}
+			doc += element("div", elements.body);
+			return doc;
+		}
+	}
+}
+
+function element<K extends keyof HTMLElementTagNameMap>(tag: K, content: string, props = {}, new_line?: boolean, indent?:string) {
+	let props_str = "";
+	for (const key in props) {
+		if (props.hasOwnProperty(key)) {
+			props_str += ` ${key}="${props[key]}"`;
+		}
+	}
+	return `${indent || ''}<${tag} ${props_str}>${content}</${tag}>${new_line ? '\n' : ''}`;
+}
+function make_link(classname: string, symbol: string) {
+	if (!symbol || symbol == classname) {
+		return element('a', classname, {onclick: `inspect('${classname}', '${classname}')`, href: ''});
+	} else {
+		return element('a', `${classname}.${symbol}`, {onclick: `inspect('${classname}', '${symbol}')`, href: ''});
+	}
+}
+
+function make_codeblock(code: string) {
+	const md = marked('```gdscript\n' + code + '\n```');
+	return `<div class="codeblock">${md}</div>`;
+}
+
+function format_documentation(p_bbcode: string, classname: string) {
+	let html = p_bbcode.trim();
+	let lines = html.split("\n");
+	let in_code_block = false;
+	let code_block_indent = -1;
+	let cur_code_block = "";
+
+	html = "";
+	for (let i = 0; i < lines.length; i++) {
+		let line = lines[i];
+		let block_start = line.indexOf("[codeblock]");
+		if (block_start != -1) {
+			code_block_indent = block_start;
+			in_code_block = true;
+			line = line.replace("[codeblock]", "");
+		} else if (in_code_block) {
+			line = line.substr(code_block_indent, line.length);
+		}
+
+		if (in_code_block && line.indexOf("[/codeblock]") != -1) {
+			line = line.replace("[/codeblock]", "");
+			in_code_block = false;
+			html += make_codeblock(cur_code_block);
+			cur_code_block = "";
+		}
+
+		if (!in_code_block) {
+			line = line.trim();
+			// [i] [/u] [code] --> <i> </u> <code>
+			line = line.replace(/(\[(\/?)([a-z]+)\])/g, `<$2$3>`);
+			// [Reference] --> <a>Reference</a>
+			line = line.replace(/(\[([A-Z]+[A-Z_a-z0-9]*)\])/g, `<a href="" onclick="inspect('$2', '$2')">$2</a>`);
+			// [method _set] --> <a>_set</a>
+			line = line.replace(/(\[([a-z]+)\s+([A-Z_a-z][A-Z_a-z0-9]*)\])/g, `<a href="" onclick="inspect('${classname}', '$3')">$3</a>`);
+			line += "<br/>";
+			html += line;
+		} else {
+			line += "\n";
+			if (cur_code_block || line.trim()) {
+				cur_code_block += line;
+			}
+		}
+	}
+	return html;
+}
+
+
+const GDScriptGrammar = {
+	'comment': {
+		pattern: /(^|[^\\])#.*/,
+		lookbehind: true
+	},
+	'string-interpolation': {
+		pattern: /(?:f|rf|fr)(?:("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+		greedy: true,
+		inside: {
+			'interpolation': {
+				// "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+				pattern: /((?:^|[^{])(?:{{)*){(?!{)(?:[^{}]|{(?!{)(?:[^{}]|{(?!{)(?:[^{}])+})+})+}/,
+				lookbehind: true,
+				inside: {
+					'format-spec': {
+						pattern: /(:)[^:(){}]+(?=}$)/,
+						lookbehind: true
+					},
+					'conversion-option': {
+						pattern: /![sra](?=[:}]$)/,
+						alias: 'punctuation'
+					},
+					rest: null
+				}
+			},
+			'string': /[\s\S]+/
+		}
+	},
+	'triple-quoted-string': {
+		pattern: /(?:[rub]|rb|br)?("""|''')[\s\S]+?\1/i,
+		greedy: true,
+		alias: 'string'
+	},
+	'string': {
+		pattern: /(?:[rub]|rb|br)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+		greedy: true
+	},
+	'function': {
+		pattern: /((?:^|\s)func[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+		lookbehind: true
+	},
+	'class-name': {
+		pattern: /(\bclass\s+)\w+/i,
+		lookbehind: true
+	},
+	'decorator': {
+		pattern: /(^\s*)@\w+(?:\.\w+)*/im,
+		lookbehind: true,
+		alias: ['annotation', 'punctuation'],
+		inside: {
+			'punctuation': /\./
+		}
+	},
+	'keyword': /\b(?:if|elif|else|for|while|break|continue|pass|return|match|func|class|class_name|extends|is|onready|tool|static|export|setget|const|var|as|void|enum|preload|assert|yield|signal|breakpoint|rpc|sync|master|puppet|slave|remotesync|mastersync|puppetsync)\b/,
+	'builtin': /\b(?:PI|TAU|NAN|INF|_|sin|cos|tan|sinh|cosh|tanh|asin|acos|atan|atan2|sqrt|fmod|fposmod|floor|ceil|round|abs|sign|pow|log|exp|is_nan|is_inf|ease|decimals|stepify|lerp|dectime|randomize|randi|randf|rand_range|seed|rand_seed|deg2rad|rad2deg|linear2db|db2linear|max|min|clamp|nearest_po2|weakref|funcref|convert|typeof|type_exists|char|str|print|printt|prints|printerr|printraw|var2str|str2var|var2bytes|bytes2var|range|load|inst2dict|dict2inst|hash|Color8|print_stack|instance_from_id|preload|yield|assert|Vector2|Vector3|Color|Rect2|Array|Basis|Dictionary|Plane|Quat|RID|Rect3|Transform|Transform2D|AABB|String|Color|NodePath|RID|Object|Dictionary|Array|PoolByteArray|PoolIntArray|PoolRealArray|PoolStringArray|PoolVector2Array|PoolVector3Array|PoolColorArray)\b/,
+	'boolean': /\b(?:true|false)\b/,
+	'number': /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b/i,
+	'operator': /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+	'punctuation': /[{}[\];(),.:]/
+};
+
+const PrismStyleSheet = `
+code[class*="language-"],
+pre[class*="language-"] {
+	color: #657b83; /* base00 */
+	font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
+	font-size: 1em;
+	text-align: left;
+	white-space: pre;
+	word-spacing: normal;
+	word-break: normal;
+	word-wrap: normal;
+
+	line-height: 1.5;
+
+	-moz-tab-size: 4;
+	-o-tab-size: 4;
+	tab-size: 4;
+
+	-webkit-hyphens: none;
+	-moz-hyphens: none;
+	-ms-hyphens: none;
+	hyphens: none;
+}
+
+pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
+code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
+	background: #073642; /* base02 */
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+	background: #073642; /* base02 */
+}
+
+/* Code blocks */
+pre[class*="language-"] {
+	padding: 1em;
+	margin: .5em 0;
+	overflow: auto;
+	border-radius: 0.3em;
+}
+
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+	background-color: #fdf6e3; /* base3 */
+}
+
+/* Inline code */
+:not(pre) > code[class*="language-"] {
+	padding: .1em;
+	border-radius: .3em;
+}
+
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+	color: #93a1a1; /* base1 */
+}
+
+.token.punctuation {
+	color: #586e75; /* base01 */
+}
+
+.namespace {
+	opacity: .7;
+}
+
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol,
+.token.deleted {
+	color: #268bd2; /* blue */
+}
+
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin,
+.token.url,
+.token.inserted {
+	color: #2aa198; /* cyan */
+}
+
+.token.entity {
+	color: #657b83; /* base00 */
+	background: #eee8d5; /* base2 */
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+	color: #859900; /* green */
+}
+
+.token.function,
+.token.class-name {
+	color: #b58900; /* yellow */
+}
+
+.token.regex,
+.token.important,
+.token.variable {
+	color: #cb4b16; /* orange */
+}
+
+.token.important,
+.token.bold {
+	font-weight: bold;
+}
+.token.italic {
+	font-style: italic;
+}
+
+.token.entity {
+	cursor: help;
+}
+`;

src/lsp/gdscript.capabilities.ts

@@ -0,0 +1,27 @@
+import { DocumentSymbol } from "vscode";
+
+export const enum Methods {
+	GDSCRIPT_CAPABILITIES = 'gdscript/capabilities',
+	SHOW_NATIVE_SYMBOL = 'gdscript/show_native_symbol',
+	INSPECT_NATIVE_SYMBOL = 'textDocument/nativeSymbol'
+}
+
+export interface NativeSymbolInspectParams {
+	native_class: string;
+	symbol_name: string;
+}
+
+export class GodotNativeSymbol extends DocumentSymbol {
+	documentation: string;
+	native_class: string;
+};
+
+export interface GodotNativeClassInfo {
+	name: string;
+	inherits: string;
+	extended_classes?: string[];
+}
+
+export interface GodotCapabilities {
+	native_classes: GodotNativeClassInfo[];
+}

tsconfig.json

@@ -4,13 +4,16 @@
 		"target": "es6",
 		"outDir": "out",
 		"lib": [
-			"es6"
+			"es2020",
+			"dom"
 		],
 		"sourceMap": true,
 		"rootDir": "src",
-		"strict": false
+		"strict": false,
+		"allowJs": true
 	},
 	"exclude": [
 		"node_modules",
+		"out"
 	]
 }