Merge pull request #541 from Jafaral/ulsp-refactor

ulsp: code refactoring with error handling improvements

Author: Jafaral

uni/lib/jsonrpc.icn

@@ -43,7 +43,9 @@ class JRPC_Message(msg, kind, json_table)
    # Parse the JSON-RPC message and set the kind of the message
    method parse_json(s)
       msg := s
-      if json_table := jtou(s) then {
+      json_table := &null
+
+      if json_table := jtous(s) then {
          guess_kind()
          return self
       } else
@@ -52,11 +54,10 @@ class JRPC_Message(msg, kind, json_table)
 
    # Guess the kind of the message based on the JSON-RPC message
    method guess_kind()
-      #if we have a method, the msg is a request
-      if \json_table["method"] then
-         kind := if \json_table["id"] then "request" else "notification"
-      else if \json_table["error"] then
+      if \json_table["error"] then
          kind := "error"
+      else if \json_table["method"] then
+         kind := if \json_table["id"] then "request" else "notification"
       else if \json_table["result"] then
          kind := "response"
       else
@@ -100,38 +101,54 @@ class JRPC_Message(msg, kind, json_table)
       return msg
    end
 
+   method to_json()
+      if msg := tojson(json_table) then
+         return msg
+   end
+
    # Initialize the JSON RPC message
    method init_msg()
       /json_table := ["jsonrpc" : "2.0"]
    end
 
    # Set the result of the JSON RPC message
    method set_result(result)
+      init_msg()
       json_table["result"] := result
    end
    # Set the id of the JSON RPC message
    method set_id(id)
+      init_msg()
       return json_table["id"] := id
    end
    # Set the method of the JSON RPC message
    method set_method(meth)
-      return json_table["method"] := meth
+      init_msg()
+      json_table["method"] := meth
+      guess_kind()
+      return meth
    end
    # Set the params of the JSON RPC message
    method set_params(params)
-      return json_table["params"] := params
+      init_msg()
+      json_table["params"] := params
+      return params
    end
 
    # Make a result response JSON RPC message
    method make_result_response(result)
+      init_msg()
       delete(json_table, "method", "params", "error")
-      json_table["result"] := \result | ""
+      # JSON-RPC 2.0: result can be null, so preserve null
+      json_table["result"] := result
+      guess_kind()
       if msg := tojson(json_table) then
          return self
    end
 
    # Make a request JSON RPC message
    method make_request(id, meth, params)
+      init_msg()
       if /json_table then
          json_table := [
             "id" : id;
@@ -144,6 +161,24 @@ class JRPC_Message(msg, kind, json_table)
          json_table["method"] := meth
          json_table["params"] := params
       }
+      guess_kind()
+      if msg := tojson(json_table) then
+         return self
+   end
+
+   method make_notification(meth, params)
+      init_msg()
+      if /json_table then
+         json_table := [
+            "method" : meth;
+            "params" : params
+            ]
+      else {
+         delete(json_table, "id", "result", "error")
+         json_table["method"] := meth
+         json_table["params"] := params
+      }
+      guess_kind()
       if msg := tojson(json_table) then
          return self
    end
@@ -198,12 +233,24 @@ class JRPC_Message(msg, kind, json_table)
 
    # Make an error response JSON RPC message
    method make_error_response(err_code, err_msg, err_data)
-      delete(json_table, "method", "params", "result")
-      json_table["error"] := [
-         "code" : err_code;
-         "message" : err_msg;
-         "data" : \err_data | ""
-      ]
+      init_msg()
+      if /json_table then
+         json_table := [
+            "error" : [
+               "code" : err_code;
+               "message" : err_msg;
+               "data" : \err_data | ""
+            ]
+         ]
+      else {
+         delete(json_table, "method", "params", "result")
+         json_table["error"] := [
+            "code" : err_code;
+            "message" : err_msg;
+            "data" : \err_data | ""
+         ]
+      }
+      guess_kind()
       if msg := tojson(json_table) then
          return self
    end
@@ -229,7 +276,7 @@ class JRPC_HTTPSocket(sock)
          # Wait for a message to arrive, read the header
          # assume the min header size is 22, because the shortest jrpc
          # msgs will be at least 2 digits, I.e header size >=22
-         *select(sock, timeout) > 0  | fail
+         *select(\sock, timeout) > 0  | fail
          data ||:= ready(sock, size-*data)
          data ~== "" | fail
          if *data < size then next

uni/ulsp/completion.icn

@@ -13,10 +13,18 @@ class CompletionHandler(
    end
 
    method getResult()
-      local _context, line, character, results_table, results, desired_line, objectName, context
-
-      line := params["position"]["line"] + 1
-      character := params["position"]["character"] + 1
+      local _context, line, character, results_table, results, desired_line, objectName, context, position
+
+      # Check that params and position exist and are valid
+      if /params then fail
+      if not member(params, "position") then fail
+      # Get position and verify it's not null before accessing its members
+      if /(position := params["position"]) then fail
+      if not member(position, "line") then fail
+      if not member(position, "character") then fail
+
+      line := position["line"] + 1
+      character := position["character"] + 1
 
       context := filehandler.getContext(line, character) | fail
       desired_line := context.line

uni/ulsp/launch-lsp.icn

@@ -88,5 +88,6 @@ procedure main(args)
    member(opts, mode := "c") | (mode := "s")
 
    ulsp_server := Server(sock, mode)
+   ulsp_server.connect()
    ulsp_server.run()
 end

uni/ulsp/server.icn

@@ -221,6 +221,12 @@ class Server(
       uri := request_params["textDocument"]["uri"]
       file_contents := request_params["contentChanges"][1]["text"]
       filehandler_object := openFiles[\uri]
+      # If file handler doesn't exist, create it (file might have been changed before didOpen)
+      if /filehandler_object then {
+         openFiles[\uri] := FileHandler(fname, lsp_database)
+         filehandler_object := openFiles[\uri]
+         filehandler_object.setFile()
+      }
       filehandler_object.updateUniDoc(fname, file_contents)
       filehandler_object.updateFileHandler()
    end
@@ -232,10 +238,19 @@ class Server(
    method completion(msg)
       local filehandler_object, result
       filehandler_object := openFiles[\msg.get_param_uri()]
+      if /filehandler_object then {
+         msg.make_error_response(-32602, "Invalid params", "File not open")
+         jrpc_handler.send_msg(msg)
+         return
+      }
       completionHandler.setVariables(filehandler_object, msg.get_params())
-      result := completionHandler.getResult()
-      msg.make_result_response(result)
-      jrpc_handler.send_msg(msg)
+      if result := completionHandler.getResult() then {
+         msg.make_result_response(result)
+         jrpc_handler.send_msg(msg)
+      } else {
+         msg.make_error_response(-32602, "Invalid params", "Missing required parameter: position")
+         jrpc_handler.send_msg(msg)
+      }
    end
 
 ########################################################
@@ -358,22 +373,20 @@ class Server(
       formattingHandler := FormattingHandler()
    end
 
+   method connect()
+      local openopt := "n", mstring
 
-   initially
-      local openopt := "n", mstring := "server"
-
-      renewSymbols := 1
-      cacheSymbols := table()
       case mode of {
-         "s" : { openopt ||:= "a" }
-         "c" : { mstring := "client" }
-         default: { write("Unknown mode: " || mode) }
+         "s" : {
+            openopt ||:= "a"
+            mstring := "server"
+         }
+         "c" : {
+            mstring := "client"
+         }
+         default: { Logger.error("Unknown mode: " || mode) }
       }
 
-      \Logger | Logger(7) # default to informational
-
-      Logger.info("Loading Database...")
-      loadDB()
       Logger.info("Starting Unicon LSP in ", mstring, " mode at ", port)
       every 1 to 5 do {
          if sock := open(port, openopt) then
@@ -388,4 +401,12 @@ class Server(
          Logger.crit("Failed to establish connection on: ", port)
          exit(1)
       }
+   end
+
+   initially
+      renewSymbols := 1
+      cacheSymbols := table()
+      \Logger | Logger(7) # default to informational
+      Logger.info("Loading Database...")
+      loadDB()
 end