Bunch of changes/fixes after finally upgrading (#40)

* * Updated teal type definition file based on current state of teal master
* Fixed to report all diagnostics correctly.  For whatever reason this was fixed by passing in filename to tl.parse_program
* Refactors logging to be simpler.  No longer supports named fields.  The string placeholders should always be {} or {formatting} where formatting is a string.format compatible formatting string or a few special cases like @ for serialize
* Added a bunch more logging as necessary while I was debugging.  Should all be disabled unless --verbose is provided
* Fixed tree sitter issue.  I was finding that 'hover' was incorrectly providing data for the previous column, so I changed "Document:_tree_sitter_token" to interpret the 'end_point' value tree sitter provides as exclusive.  I was unable to confirm that this is expected from tree sitter docs but this fixes my issue
* Fixed bug with completion request, where it would fail if called from the end of the line in neovim.  I assume this was because neovim sends the cursor position, which is technically outside the range of the current line, so I subtraced character by one to account for this in MiscHandlers:_on_completion.
* Fixed bug where some methods wouldn't be returned by completion when arg type == tl.typcodes.RECORD

* Fixed to include lsp_formatter

* Fix to rockspec to include tracing_util

* Fixed tests to pass again

* More test fixes

* Fix signature help event which was broken due to new changes

Author: svermeulen

gen/teal_language_server.sh

@@ -1,7 +1,7 @@
 
 local asserts = require("teal_language_server.asserts")
 
-local args_parser = {CommandLineArgs = {}, }
+local args_parser = { CommandLineArgs = {} }
 
 
 

gen/teal_language_server/args_parser.lua

@@ -23,21 +23,7 @@ local tl = require("tl")
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-local Document = {NodeInfo = {}, }
+local Document = { NodeInfo = {} }
 
 
 
@@ -126,29 +112,30 @@ function Document:_get_tokens()
    return cache.tokens, cache.err_tokens
 end
 
-local parse_prog = tl.parse_program
 function Document:_get_ast(tokens)
    local cache = self._cache
    if not cache.ast then
       local _
       cache.parse_errors = {}
-      cache.ast, _ = parse_prog(tokens, cache.parse_errors)
-      tracing.debug(_module_name, "parse_prog errors: " .. #cache.parse_errors)
+      cache.ast, _ = tl.parse_program(tokens, cache.parse_errors, self._uri.path)
+      tracing.debug(_module_name, "parse_prog errors: {}", { #cache.parse_errors })
    end
    return cache.ast, cache.parse_errors
 end
 
-local type_check = tl.type_check
-
 function Document:_get_result(ast)
    local cache = self._cache
    if not cache.result then
-      tracing.info(_module_name, "Type checking document {}", { self._uri.path })
-      cache.result = type_check(ast, {
-         lax = is_lua(self._uri.path),
-         filename = self._uri.path,
-         env = self._server_state:get_env(),
-      })
+      local lax = is_lua(self._uri.path)
+      tracing.info(_module_name, "Type checking document{} {}", { lax and " (lax)" or "", self._uri.path })
+
+      local opts = {
+         feat_lax = lax and "on" or "off",
+         feat_arity = "on",
+      }
+
+      cache.result = tl.check(
+      ast, self._uri.path, opts, self._server_state:get_env())
    end
    return cache.result
 end
@@ -188,7 +175,7 @@ end
 
 function Document:clear_cache()
    self._cache = {}
-   tracing.debug(_module_name, "Cleared cache for document {}", { self._uri })
+   tracing.debug(_module_name, "Cleared cache for document {@}", { self._uri })
 end
 
 function Document:update_text(text, version)
@@ -209,10 +196,9 @@ function Document:update_text(text, version)
    self._tree_cursor = self._tree:root():create_cursor()
 end
 
-local get_raw_token_at = tl.get_token_at
 local function make_diagnostic_from_error(tks, err, severity)
    local x, y = err.x, err.y
-   local err_tk = get_raw_token_at(tks, y, x)
+   local err_tk = tl.get_token_at(tks, y, x)
    return {
       range = {
          start = {
@@ -256,6 +242,7 @@ end
 
 function Document:process_and_publish_results()
    local tks, err_tks = self:_get_tokens()
+   tracing.debug(_module_name, "Detected {} lex errors", { #err_tks })
    if #err_tks > 0 then
       self:_publish_diagnostics(imap(err_tks, function(t)
          return {
@@ -271,6 +258,7 @@ function Document:process_and_publish_results()
    end
 
    local ast, parse_errs = self:_get_ast(tks)
+   tracing.debug(_module_name, "Detected {} parse errors", { #parse_errs })
    if #parse_errs > 0 then
       self:_publish_diagnostics(imap(parse_errs, function(e)
          return make_diagnostic_from_error(tks, e, "Error")
@@ -282,6 +270,8 @@ function Document:process_and_publish_results()
    local fname = self._uri.path
    local result = self:_get_result(ast)
 
+   tracing.debug(_module_name, "Detected {} type errors", { #result.type_errors })
+
    local config = self._server_state.config
    local disabled_warnings = set(config.disable_warnings or {})
    local warning_errors = set(config.warning_error or {})
@@ -313,36 +303,37 @@ function Document:resolve_type_ref(type_number)
    end
 end
 
-function Document:_quick_get(tr, last_token)
+function Document:type_information_for_tokens(tokens, y, x)
+   local tr = self:get_type_report()
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-   local file = tr.by_pos[self._uri.path]
-   if file == nil then
-      tracing.warning(_module_name, "selfchecker: the file dissappeared?")
-      return nil
-   end
 
-   local line = file[last_token.y] or file[last_token.y - 1] or file[last_token.y + 1]
-   if line == nil then
-      tracing.warning(_module_name, "selfchecker: the file dissappeared?")
-      return nil
-   end
 
-   local type_ref = line[last_token.x] or line[last_token.x - 1] or line[last_token.x + 1]
-   if type_ref == nil then
-      tracing.warning(_module_name, "selfchecker: couldn't find the typeref")
-      return nil
-   end
-   return self:resolve_type_ref(type_ref)
-end
 
-function Document:type_information_for_tokens(tokens, y, x)
-   local tr = self:get_type_report()
 
 
-   local type_info
 
+
+
+
+
+
+   local type_info
 
    local scope_symbols = tl.symbols_in_scope(tr, y + 1, x + 1, self._uri.path)
+   tracing.trace(_module_name, "Looked up symbols at {}, {} for file {} with result: {@}", { y + 1, x + 1, self._uri.path, scope_symbols })
    if #tokens == 0 then
       local out = {}
       for key, value in pairs(scope_symbols) do out[key] = value end
@@ -352,26 +343,35 @@ function Document:type_information_for_tokens(tokens, y, x)
       }
       return type_info
    end
-   local type_id = scope_symbols[tokens[1]]
-   tracing.warning(_module_name, "tokens[1]: " .. tokens[1])
+   local raw_token = tokens[1]
+   tracing.trace(_module_name, "Processing token {} (all: {@})", { raw_token, tokens })
+   local type_id = scope_symbols[raw_token]
+   if type_id == nil then
+      tracing.warning(_module_name, "Failed to find type id for token {}", { raw_token })
+   end
    if type_id ~= nil then
+      tracing.trace(_module_name, "Matched token {} to type id {}", { raw_token, type_id })
       type_info = self:resolve_type_ref(type_id)
+
+      if type_info == nil then
+         tracing.warning(_module_name, "Failed to resolve type ref for id {}", {})
+      end
    end
 
 
    if type_info == nil then
-      type_info = tr.types[tr.globals[tokens[1]]]
-   end
+      type_info = tr.types[tr.globals[raw_token]]
 
-   if type_info == nil then
-      tracing.warning(_module_name, "Unable to find type info in global table as well..")
+      if type_info == nil then
+         tracing.warning(_module_name, "Unable to find type info in global table as well..")
+      end
    end
 
-   tracing.warning(_module_name, "What is this type_info:" .. tostring(type_info))
+   tracing.debug(_module_name, "Got type info: {@}", { type_info })
 
    if type_info and #tokens > 1 then
       for i = 2, #tokens do
-         tracing.trace(_module_name, "tokens[i]: " .. tokens[i])
+         tracing.trace(_module_name, "tokens[i]: {}", { tokens[i] })
 
          if type_info.fields then
             type_info = self:resolve_type_ref(type_info.fields[tokens[i]])
@@ -403,6 +403,7 @@ function Document:_tree_sitter_token(y, x)
 
    if moved == false then
       self._tree_cursor:goto_parent()
+
       local parent_node = self._tree_cursor:current_node()
 
       local out = {
@@ -486,7 +487,7 @@ function Document:_tree_sitter_token(y, x)
       end_point = node:end_point()
 
       if y == start_point.row and y == end_point.row then
-         if x >= start_point.column and x <= end_point.column then
+         if x >= start_point.column and x < end_point.column then
             return self:_tree_sitter_token(y, x)
          end
 

gen/teal_language_server/document.lua

@@ -5,7 +5,7 @@
 
 local tl = require("tl")
 
-local lsp = {Message = {ResponseError = {}, }, Position = {}, Range = {}, Location = {}, Diagnostic = {}, Method = {}, TextDocument = {}, TextDocumentContentChangeEvent = {}, CompletionContext = {}, }
+local lsp = { Message = { ResponseError = {} }, Position = {}, Range = {}, Location = {}, Diagnostic = {}, Method = {}, TextDocument = {}, TextDocumentContentChangeEvent = {}, CompletionContext = {} }
 
 
 

gen/teal_language_server/lsp.lua

@@ -44,7 +44,7 @@ function LspEventsManager:_trigger(method, params, id)
       if ok then
          tracing.debug(_module_name, "Successfully handled request with method {}", { method })
       else
-         tracing.error(_module_name, "Error in handler for request with method {method}: {error}", { method, err })
+         tracing.error(_module_name, "Error in handler for request with method {}: {}", { method, err })
       end
    else
       tracing.warning(_module_name, "No handler found for event with method {}", { method })

gen/teal_language_server/lsp_events_manager.lua

@@ -2,7 +2,7 @@ local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 th
 
 local Document = require("teal_language_server.document")
 
-local lsp_formatter = {Documentation = {}, SignatureHelp = {SignatureParameter = {}, Signature = {}, }, }
+local lsp_formatter = { Documentation = {}, SignatureHelp = { SignatureParameter = {}, Signature = {} } }
 
 
 

gen/teal_language_server/lsp_formatter.lua

@@ -48,7 +48,7 @@ function LspReaderWriter:_parse_header(lines)
 
       asserts.that(key ~= nil and val ~= nil, "invalid header: " .. line)
 
-      tracing.trace(_module_name, "Request Header: {key}: {val}", { key, val })
+      tracing.trace(_module_name, "Request Header: {}: {}", { key, val })
 
       if key == "Content-Length" then
          asserts.is_nil(len)
@@ -106,9 +106,9 @@ end
 function LspReaderWriter:receive_rpc()
    local header_info = self:_decode_header()
 
-   tracing.trace(_module_name, "Successfully read LSP rpc header: {header_info}\nWaiting to receive body...", { header_info })
+   tracing.trace(_module_name, "Successfully read LSP rpc header: {}\nWaiting to receive body...", { header_info })
    local body_line = self._stdin_reader:read(header_info.length)
-   tracing.trace(_module_name, "Received request Body: {body_line}", { body_line })
+   tracing.trace(_module_name, "Received request Body: {}", { body_line })
 
    local data = json.decode(body_line)
 
@@ -126,7 +126,7 @@ function LspReaderWriter:_encode(t)
    local content = "Content-Length: " .. tostring(#msg) .. "\r\n\r\n" .. msg
    assert(self._stdout:write(content))
 
-   tracing.trace(_module_name, "Sending data: {content}", { content })
+   tracing.trace(_module_name, "Sending data: {}", { content })
 end
 
 function LspReaderWriter:send_rpc(id, t)

gen/teal_language_server/lsp_reader_writer.lua

@@ -65,9 +65,9 @@ local function main()
 
    cached_entries = nil
 
-   tracing.info(_module_name, "Started new instance teal-language-server. Lua Version: {version}. Platform: {platform}", { _VERSION, util.get_platform() })
+   tracing.info(_module_name, "Started new instance teal-language-server. Lua Version: {}. Platform: {}", { _VERSION, util.get_platform() })
    tracing.info(_module_name, "Received command line args: {}", { args })
-   tracing.info(_module_name, "CWD = {cwd}", { uv.cwd() })
+   tracing.info(_module_name, "CWD = {}", { uv.cwd() })
 
    local disposables
 
@@ -118,7 +118,7 @@ local function main()
          generate_debug_names = true,
          on_completed = function(err)
             if err ~= nil then
-               tracing.error(_module_name, "Received on_completed request with error:\n{error}", { err })
+               tracing.error(_module_name, "Received on_completed request with error:\n{}", { err })
             else
                tracing.info(_module_name, "Received on_completed request")
             end
@@ -145,7 +145,7 @@ local function main()
       uv.walk(function(handle)
          if not handle:is_closing() then
             local handle_type = handle:get_type()
-            tracing.warning(_module_name, "Found unclosed handle of type '{handle_type}', closing it.", { handle_type })
+            tracing.warning(_module_name, "Found unclosed handle of type '{}', closing it.", { handle_type })
             handle:close()
          end
       end)
@@ -162,7 +162,7 @@ local function main()
    util.try({
       action = run_luv,
       catch = function(err)
-         tracing.error(_module_name, "Error: {error}", { err })
+         tracing.error(_module_name, "Error: {}", { err })
          error(err)
       end,
    })