more work on lsp

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)
@@ -182,6 +183,10 @@ lsp.methods["initialize"] = function(params)
 				resolveProvider = true,
 			},]]
 			documentSymbolProvider = true,
+			documentHighlightProvider = true,
+			signatureHelpProvider = {
+				triggerCharacters = {"(", ","},
+			},
 		-- for symbols like all functions within a file
 		-- highlighting equal upvalues
 		-- documentHighlightProvider = true, 
@@ -255,21 +260,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 +499,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)
 

language_server/lsp.lua

@@ -63,25 +63,30 @@ 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 upvalue = self:CreateLocalValue(node.tokens["identifier"]:GetValueString(), val)
+			self:MapTypeToNode(upvalue, node.tokens["identifier"])
+			self:MapTypeToNode(val, node.tokens["identifier"])
 			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,6 +315,8 @@ do
 end
 
 function META:MapTypeToNode(typ, node)
+	if not typ or not node then return end
+
 	self.type_to_node[typ] = node
 end
 

nattlua/analyzer/analyzer.lua

@@ -257,6 +257,7 @@ return {
 					end
 
 					local val = self:SetLocalOrGlobalValue(key, val)
+					self:MapTypeToNode(val, exp_key)
 
 					if false and val then
 						-- this is used for tracking function dependencies

nattlua/analyzer/statements/assignment.lua

@@ -64,12 +64,13 @@ local DISABLE = _G.DISABLE_BASE_ENV
 local REUSE = _G.REUSE_BASE_ENV
 local cached_runtime
 local cached_typesystem
+local cached_node_map
 return {
 	BuildBaseEnvironment = function(root_node, parent_analyzer)
-		if DISABLE then return Table(), Table() end
+		if DISABLE then return Table(), Table(), {} end
 
 		if REUSE and cached_runtime and cached_typesystem then
-			return cached_runtime, cached_typesystem
+			return cached_runtime, cached_typesystem, cached_node_map
 		end
 
 		local compiler = load_definitions(root_node, parent_analyzer and parent_analyzer.config)
@@ -87,6 +88,7 @@ return {
 
 		if parent_analyzer then
 			analyzer = require("nattlua.analyzer.analyzer").New(parent_analyzer.config)
+			analyzer.type_to_node = parent_analyzer.type_to_node
 		-- Ensure we're using a common statement count if we want to track it
 		-- but for base environment it might be noisy. Let's at least record parsed paths.
 		end
@@ -109,8 +111,9 @@ return {
 		if REUSE then
 			cached_runtime = runtime_env
 			cached_typesystem = typesystem_env
+			cached_node_map = compiler.analyzer:GetTypeToNodeMap()
 		end
 
-		return runtime_env, typesystem_env
+		return runtime_env, typesystem_env, compiler.analyzer:GetTypeToNodeMap()
 	end,
 }

nattlua/base_environment.lua

@@ -99,7 +99,7 @@ function META:FindType()
 	do
 		local node = self.parent
 
-		while node and node.parent do
+		while node do
 			table_insert(found_parents, node)
 			node = node.parent
 		end
@@ -120,19 +120,21 @@ function META:FindType()
 	for _, node in ipairs(found_parents) do
 		local found = false
 
-		for _, obj in ipairs(node:GetAssociatedTypes()) do
-			if
-				(
-					obj.Type == "string" or
-					obj.Type == "number"
-				)
-				and
-				tostring(obj:GetData()) == self:GetValueString()
-			then
-
-			else
-				table_insert(types, obj)
-				found = true
+		if node.GetAssociatedTypes then
+			for _, obj in ipairs(node:GetAssociatedTypes()) do
+				if
+					(
+						obj.Type == "string" or
+						obj.Type == "number"
+					)
+					and
+					tostring(obj:GetData()) == self:GetValueString()
+				then
+
+				else
+					table_insert(types, obj)
+					found = true
+				end
 			end
 		end
 
@@ -150,7 +152,7 @@ function META:FindUpvalue()
 
 		if #types > 0 then
 			for i, v in ipairs(types) do
-				local upvalue = v:GetUpvalue()
+				local upvalue = (v.Type == "upvalue" and v) or (v.GetUpvalue and v:GetUpvalue())
 
 				if upvalue then return upvalue end
 			end

nattlua/lexer/token.lua

@@ -0,0 +1,102 @@
+local json = require("language_server.json")
+local rpc_util = require("language_server.jsonrpc")
+local class = require("nattlua.other.class")
+local path_util = require("nattlua.other.path")
+local META = class.CreateTemplate("lsp_client")
+
+function META.New()
+	return META.NewObject(
+		{
+			last_id = 0,
+			pending_requests = {},
+			notifications = {},
+			responses = {},
+			working_directory = "/",
+		}
+	)
+end
+
+function META:SetWorkingDirectory(dir)
+	self.working_directory = path_util.Normalize(dir)
+end
+
+function META:ToLSPPath(path)
+	return path_util.PathToUrlScheme(path_util.Normalize(path))
+end
+
+function META:ToFSPath(url)
+	return path_util.UrlSchemeToPath(url, self.working_directory)
+end
+
+function META:Call(lsp, method, params)
+	self.last_id = self.last_id + 1
+	local id = self.last_id
+	local request = {
+		jsonrpc = "2.0",
+		id = id,
+		method = method,
+		params = params,
+	}
+	self.pending_requests[id] = request
+	-- Mock lsp.Call to capture output
+	local old_call = lsp.Call
+	lsp.Call = function(response)
+		if response.id then
+			self.responses[response.id] = response
+		else
+			table.insert(self.notifications, response)
+		end
+	end
+	-- Simple direct call to the method handler
+	local res = lsp.methods[method](params)
+	-- Restore old call
+	lsp.Call = old_call
+
+	if res then return res end
+
+	return self.responses[id] and self.responses[id].result
+end
+
+function META:Notify(lsp, method, params)
+	local notification = {
+		jsonrpc = "2.0",
+		method = method,
+		params = params,
+	}
+	-- Mock lsp.Call to capture side-effects (like publishDiagnostics)
+	local old_call = lsp.Call
+	lsp.Call = function(response)
+		if not response.id then table.insert(self.notifications, response) end
+	end
+
+	if lsp.methods[method] then lsp.methods[method](params) end
+
+	lsp.Call = old_call
+end
+
+function META:GetNotifications(method)
+	local found = {}
+
+	for _, n in ipairs(self.notifications) do
+		if n.method == method then table.insert(found, n) end
+	end
+
+	return found
+end
+
+function META:ClearNotifications()
+	self.notifications = {}
+end
+
+function META:Initialize(lsp, root_uri)
+	return self:Call(
+		lsp,
+		"initialize",
+		{
+			workspaceFolders = {{uri = root_uri, name = "test-workspace"}},
+			capabilities = {},
+		}
+	)
+end
+
+return META