more work on lsp

- integration tests for lsp features
- more work on renaming, find references, go to definition, symbol tree, etc
- some error handling improvements in the extension
- overall better editor support

Author: CapsAdmin

language_server/editor_helper.lua

@@ -64,6 +64,7 @@ local function get_range(code, start, stop)
 end
 
 local editor_helper = EditorHelper.New()
+lsp.editor_helper = editor_helper
 editor_helper.debug = false
 
 local function to_fs_path(url)
@@ -128,10 +129,15 @@ function editor_helper:OnDiagnostics(path, data)
 
 	for i, v in ipairs(data) do
 		local range = get_range(v.code, v.start, v.stop)
+		local tags
+
+		if v.message:find("is never used") then tags = {1} end
+
 		diagnostics[i] = {
 			severity = DiagnosticSeverity[v.severity],
 			range = range,
 			message = v.message .. "\n" .. (v.trace or "no trace??"),
+			tags = tags,
 		}
 	end
 
@@ -147,7 +153,12 @@ function editor_helper:OnDiagnostics(path, data)
 end
 
 lsp.methods["initialize"] = function(params)
-	editor_helper:SetWorkingDirectory(to_fs_path(params.workspaceFolders[1].uri))
+	if params.workspaceFolders and params.workspaceFolders[1] then
+		editor_helper:SetWorkingDirectory(to_fs_path(params.workspaceFolders[1].uri))
+	elseif params.rootUri then
+		editor_helper:SetWorkingDirectory(to_fs_path(params.rootUri))
+	end
+
 	return {
 		clientInfo = {name = "NattLua", version = "1.0"},
 		capabilities = {
@@ -182,30 +193,68 @@ lsp.methods["initialize"] = function(params)
 				resolveProvider = true,
 			},]]
 			documentSymbolProvider = true,
-		-- for symbols like all functions within a file
-		-- highlighting equal upvalues
-		-- documentHighlightProvider = true, 
-		--[[
+			documentHighlightProvider = true,
 			signatureHelpProvider = {
-				triggerCharacters = { "(" },
+				triggerCharacters = {"(", ","},
 			},
-			
-			workspaceSymbolProvider = true,
-			codeActionProvider = true,
-			documentFormattingProvider = true,
-			documentRangeFormattingProvider = true,
-			documentOnTypeFormattingProvider = {
-				firstTriggerCharacter = "}",
-				moreTriggerCharacter = { "end" },
+			codeActionProvider = {
+				codeActionKinds = {"quickfix", "source.fixAll.unusedImports"},
 			},
-			renameProvider = true,
-			]]
+			documentFormattingProvider = true,
 		},
 	}
 end
 lsp.methods["initialized"] = function(params)
 	editor_helper:Initialize()
 end
+lsp.methods["textDocument/codeAction"] = function(params)
+	local actions = {}
+	local has_unused = false
+
+	for _, diagnostic in ipairs(params.context.diagnostics) do
+		if diagnostic.tags then
+			for _, tag in ipairs(diagnostic.tags) do
+				if tag == 1 then
+					has_unused = true
+
+					break
+				end
+			end
+		end
+	end
+
+	if has_unused then
+		local path = to_fs_path(params.textDocument.uri)
+		local code = editor_helper:GetFileContent(path)
+		local new_code = editor_helper:Format(code, path, {remove_unused = true})
+
+		if new_code ~= code then
+			table.insert(
+				actions,
+				{
+					title = "Remove all unused code",
+					kind = "source.fixAll.unusedImports",
+					edit = {
+						changes = {
+							[params.textDocument.uri] = {
+								{
+									range = {
+										start = {line = 0, character = 0},
+										["end"] = {line = 100000, character = 0},
+									},
+									newText = new_code,
+								},
+							},
+						},
+					},
+				}
+			)
+		end
+	end
+
+	return actions
+end
+
 lsp.methods["nattlua/format"] = function(params)
 	local path = to_fs_path(params.textDocument.uri)
 	local code = editor_helper:Format(params.code, path)
@@ -216,6 +265,25 @@ lsp.methods["nattlua/format"] = function(params)
 		code = b64.encode(code),
 	}
 end
+lsp.methods["textDocument/formatting"] = function(params)
+	local path = to_fs_path(params.textDocument.uri)
+	local code = editor_helper:GetFileContent(path)
+	local new_code = editor_helper:Format(code, path)
+
+	if new_code ~= code then
+		return {
+			{
+				range = {
+					start = {line = 0, character = 0},
+					["end"] = {line = 100000, character = 0},
+				},
+				newText = new_code,
+			},
+		}
+	end
+
+	return {}
+end
 lsp.methods["shutdown"] = function(params)
 	table.print(params)
 end
@@ -234,8 +302,9 @@ lsp.methods["$/cancelRequest"] = function(params)
 	table.print(params)
 end
 lsp.methods["workspace/didChangeConfiguration"] = function(params)
-	print("configuration changed")
-	table.print(params)
+	if params.settings and params.settings.nattlua then
+		editor_helper.workspace_config = params.settings.nattlua
+	end
 end
 lsp.methods["textDocument/didOpen"] = function(params)
 	local path = to_fs_path(params.textDocument.uri)
@@ -255,21 +324,32 @@ lsp.methods["textDocument/references"] = function(params)
 
 	if not editor_helper:IsLoaded(path) then return {} end
 
-	local data = editor_helper:GetFile(path)
-	local nodes = editor_helper:GetReferences(path, params.position.line, params.position.character - 1)
+	local items = editor_helper:GetReferences(path, params.position.line, params.position.character)
 
-	if not nodes then return {} end
+	if not items then return {} end
 
 	local result = {}
 
-	for k, node in pairs(nodes) do
-		local path = node:GetSourcePath() or to_fs_path(path)
-		editor_helper:OpenFile(path, node.Code:GetString())
+	for k, item in pairs(items) do
+		local start, stop
+		local source_path
+
+		if item.GetStartStop then
+			start, stop = item:GetStartStop()
+			source_path = item:GetSourcePath()
+		else
+			start, stop = item.start, item.stop
+			source_path = item.lexer.Code:GetName()
+		end
+
+		source_path = source_path or path
+		local fs_path = to_fs_path(source_path)
+		local lsp_path = to_lsp_path(source_path)
 		table.insert(
 			result,
 			{
-				uri = to_fs_path(path),
-				range = get_range(editor_helper:GetCode(path), node:GetStartStop()),
+				uri = lsp_path,
+				range = get_range(editor_helper:GetCode(fs_path), start, stop),
 			}
 		)
 	end
@@ -483,6 +563,44 @@ if false then
 	end
 end
 
+lsp.methods["textDocument/documentHighlight"] = function(params)
+	local path = to_fs_path(params.textDocument.uri)
+
+	if not editor_helper:IsLoaded(path) then return {} end
+
+	local highlights = editor_helper:GetUpvalueHighlightRanges(path, params.position.line, params.position.character)
+
+	if not highlights then return {} end
+
+	local result = {}
+
+	for i, range_data in ipairs(highlights) do
+		local range = {
+			start = {
+				line = range_data.line_start - 1,
+				character = range_data.character_start - 1,
+			},
+			["end"] = {
+				line = range_data.line_stop - 1,
+				character = range_data.character_stop,
+			},
+		}
+		table.insert(result, {
+			range = range,
+			kind = 1, -- Text
+		})
+	end
+
+	return result
+end
+lsp.methods["textDocument/signatureHelp"] = function(params)
+	local path = to_fs_path(params.textDocument.uri)
+
+	if not editor_helper:IsLoaded(path) then return {} end
+
+	local result = editor_helper:GetSignatureHelp(path, params.position.line, params.position.character)
+	return result or {signatures = {}, activeSignature = 0, activeParameter = 0}
+end
 lsp.methods["textDocument/rename"] = function(params)
 	local fs_path = to_fs_path(params.textDocument.uri)
 
@@ -517,7 +635,7 @@ lsp.methods["textDocument/definition"] = function(params)
 
 	local node = editor_helper:GetDefinition(path, params.position.line, params.position.character)
 
-	if node then
+	if node and node.GetStartStop then
 		local start, stop = node:GetStartStop()
 		local path = node:GetSourcePath() or path
 		path = to_fs_path(path)

language_server/lsp.lua

@@ -12,29 +12,42 @@ io.stdout:setvbuf("no")
 local function read_message()
 	local line = INPUT:read("*l")
 
+	while line and not line:match("Content%-Length:") do
+		line = INPUT:read("*l")
+	end
+
 	if not line then return nil end
 
 	local content_length = tonumber(line:match("Content%-Length: (%d+)"))
-	INPUT:read("*l") -- Read the empty line
+
+	if not content_length then return nil end
+
+	-- Skip any other headers until we find the empty line
+	while line and line ~= "" and line ~= "\r" do
+		line = INPUT:read("*l")
+	end
+
 	local str = INPUT:read(content_length)
-	session_input:write(str, "\n\n")
-	session_input:flush()
+
+	if session_input then
+		session_input:write(str, "\n\n")
+		session_input:flush()
+	end
+
 	return str
 end
 
 -- Without this, it seems like vscode will error as the body length deviates from content-length with unicode characters
--- I initially thought utf8.length would work, but that doesn't seem to be it.
-local function escape_unicode(c)
-	return string.format("\\u%04x", c:byte())
-end
-
 local function write_message(message)
 	local encoded = json.encode(message)
 	local data = string.format("Content-Length: %d\r\n\r\n%s", #encoded, encoded)
 	OUTPUT:write(data)
 	OUTPUT:flush()
-	session_output:write(data)
-	session_output:flush()
+
+	if session_output then
+		session_output:write(data)
+		session_output:flush()
+	end
 end
 
 OUTPUT:setvbuf("no")

language_server/main.lua

@@ -63,25 +63,31 @@ do
 			node.Type == "statement_local_type_function"
 		then
 			self:PushAnalyzerEnvironment(node.Type == "statement_local_function" and "runtime" or "typesystem")
-			self:CreateLocalValue(node.tokens["identifier"]:GetValueString(), AnalyzeFunction(self, node))
+			local val = AnalyzeFunction(self, node)
+			local ident_token = node.tokens["identifier"]
+			local upvalue = self:CreateLocalValue(ident_token:GetValueString(), val, false, ident_token)
+			self:MapTypeToNode(val, ident_token)
+			self:MapTypeToNode(upvalue, ident_token)
 			self:PopAnalyzerEnvironment()
 		elseif
 			node.Type == "statement_function" or
 			node.Type == "statement_analyzer_function" or
 			node.Type == "statement_type_function"
 		then
-			local key = node.expression
+			local key_node = node.expression
 			self:PushAnalyzerEnvironment(node.Type == "statement_function" and "runtime" or "typesystem")
 
-			if key.Type == "expression_binary_operator" then
-				local obj = self:AnalyzeExpression(key.left)
-				local key = self:AnalyzeExpression(key.right)
+			if key_node.Type == "expression_binary_operator" then
+				local obj = self:AnalyzeExpression(key_node.left)
+				local key = self:AnalyzeExpression(key_node.right)
 				local val = AnalyzeFunction(self, node)
 				self:NewIndexOperator(obj, key, val)
+				self:MapTypeToNode(val, key_node.right)
 			else
-				local key = ConstString(key.value:GetValueString())
+				local key = ConstString(key_node.value:GetValueString())
 				local val = AnalyzeFunction(self, node)
 				self:SetLocalOrGlobalValue(key, val)
+				self:MapTypeToNode(val, key_node)
 			end
 
 			self:PopAnalyzerEnvironment()
@@ -310,7 +316,11 @@ do
 end
 
 function META:MapTypeToNode(typ, node)
+	if not typ or not node then return end
+
 	self.type_to_node[typ] = node
+
+	if node.AssociateType then node:AssociateType(typ) end
 end
 
 function META:GetTypeToNodeMap()

nattlua/analyzer/analyzer.lua

@@ -270,4 +270,25 @@ return function(META--[[#: any]])
 			if info ~= false and info.msg then self:Warning(info.msg, info.node) end
 		end
 	end
+
+	function META:ReportUnusedUpvalues(custom_scope)
+		if not self.config.remove_unused then return end
+
+		local scope = custom_scope or self:GetScope()
+		local unused = scope:FindUnusedUpvalues()
+
+		if unused then
+			for _, upvalue in ipairs(unused) do
+				local name = upvalue:GetKey()
+
+				if name ~= "_" then
+					local identifier = upvalue:GetIdentifier()
+
+					if identifier and type(identifier) == "table" and identifier.GetStartStop then
+						self:Warning(name .. " is never used", identifier)
+					end
+				end
+			end
+		end
+	end
 end