1627 lines
50 KiB
Lua
1627 lines
50 KiB
Lua
local util = require 'utility'
|
|
local cap = require 'provider.capability'
|
|
local await = require 'await'
|
|
local files = require 'files'
|
|
local proto = require 'proto.proto'
|
|
local define = require 'proto.define'
|
|
local workspace = require 'workspace'
|
|
local config = require 'config'
|
|
local client = require 'client'
|
|
local pub = require 'pub'
|
|
local lang = require 'language'
|
|
local progress = require 'progress'
|
|
local tm = require 'text-merger'
|
|
local cfgLoader = require 'config.loader'
|
|
local converter = require 'proto.converter'
|
|
local filewatch = require 'filewatch'
|
|
local json = require 'json'
|
|
local scope = require 'workspace.scope'
|
|
local furi = require 'file-uri'
|
|
local inspect = require 'inspect'
|
|
local guide = require 'parser.guide'
|
|
local fs = require 'bee.filesystem'
|
|
|
|
require 'library'
|
|
|
|
---@class provider
|
|
local m = {}
|
|
|
|
m.attributes = {}
|
|
|
|
---@async
|
|
function m.updateConfig(uri)
|
|
config.addNullSymbol(json.null)
|
|
local specified = cfgLoader.loadLocalConfig(uri, CONFIGPATH)
|
|
if specified then
|
|
log.info('Load config from specified', CONFIGPATH)
|
|
log.info(inspect(specified))
|
|
-- watch directory
|
|
filewatch.watch(workspace.getAbsolutePath(uri, CONFIGPATH):gsub('[^/\\]+$', ''), false)
|
|
config.update(scope.override, specified)
|
|
end
|
|
|
|
for _, folder in ipairs(scope.folders) do
|
|
local clientConfig = cfgLoader.loadClientConfig(folder.uri)
|
|
if clientConfig then
|
|
log.info('Load config from client', folder.uri)
|
|
log.info(inspect(clientConfig))
|
|
end
|
|
|
|
local rc = cfgLoader.loadRCConfig(folder.uri, '.luarc.json')
|
|
or cfgLoader.loadRCConfig(folder.uri, '.luarc.jsonc')
|
|
if rc then
|
|
log.info('Load config from .luarc.json/.luarc.jsonc', folder.uri)
|
|
log.info(inspect(rc))
|
|
end
|
|
|
|
config.update(folder, clientConfig, rc)
|
|
end
|
|
|
|
local global = cfgLoader.loadClientConfig()
|
|
log.info('Load config from client', 'fallback')
|
|
log.info(inspect(global))
|
|
config.update(scope.fallback, global)
|
|
end
|
|
|
|
function m.register(method)
|
|
return function (attrs)
|
|
m.attributes[method] = attrs
|
|
if attrs.preview and not PREVIEW then
|
|
return
|
|
end
|
|
if attrs.capability then
|
|
cap.filling(attrs.capability)
|
|
end
|
|
proto.on(method, attrs[1])
|
|
end
|
|
end
|
|
|
|
filewatch.event(function (ev, path) ---@async
|
|
if (CONFIGPATH and util.stringEndWith(path, CONFIGPATH)) then
|
|
for _, scp in ipairs(workspace.folders) do
|
|
local configPath = workspace.getAbsolutePath(scp.uri, CONFIGPATH)
|
|
if path == configPath then
|
|
m.updateConfig(scp.uri)
|
|
end
|
|
end
|
|
end
|
|
if util.stringEndWith(path, '.luarc.json') then
|
|
for _, scp in ipairs(workspace.folders) do
|
|
local rcPath = workspace.getAbsolutePath(scp.uri, '.luarc.json')
|
|
if path == rcPath then
|
|
m.updateConfig(scp.uri)
|
|
end
|
|
end
|
|
end
|
|
if util.stringEndWith(path, '.luarc.jsonc') then
|
|
for _, scp in ipairs(workspace.folders) do
|
|
local rcPath = workspace.getAbsolutePath(scp.uri, '.luarc.jsonc')
|
|
if path == rcPath then
|
|
m.updateConfig(scp.uri)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
m.register 'initialize' {
|
|
function(params)
|
|
client.init(params)
|
|
|
|
if params.rootUri then
|
|
workspace.initRoot(params.rootUri)
|
|
cap.resolve('ROOT_PATH', furi.decode(params.rootUri):gsub('\\', '/') .. '/')
|
|
end
|
|
|
|
if params.workspaceFolders then
|
|
for _, folder in ipairs(params.workspaceFolders) do
|
|
workspace.create(files.getRealUri(folder.uri))
|
|
end
|
|
elseif params.rootUri then
|
|
workspace.create(files.getRealUri(params.rootUri))
|
|
end
|
|
|
|
local response = {
|
|
capabilities = cap.getProvider(),
|
|
serverInfo = {
|
|
name = 'sumneko.lua',
|
|
},
|
|
}
|
|
log.debug('Server init', inspect(response))
|
|
return response
|
|
end
|
|
}
|
|
|
|
m.register 'initialized'{
|
|
---@async
|
|
function (params)
|
|
local _ <close> = progress.create(workspace.getFirstScope().uri, lang.script.WINDOW_INITIALIZING, 0.5)
|
|
m.updateConfig()
|
|
local registrations = {}
|
|
|
|
if client.getAbility 'workspace.didChangeConfiguration.dynamicRegistration' then
|
|
-- 监视配置变化
|
|
registrations[#registrations+1] = {
|
|
id = 'workspace/didChangeConfiguration',
|
|
method = 'workspace/didChangeConfiguration',
|
|
}
|
|
end
|
|
|
|
if #registrations ~= 0 then
|
|
proto.awaitRequest('client/registerCapability', {
|
|
registrations = registrations
|
|
})
|
|
end
|
|
client.setReady()
|
|
workspace.init()
|
|
return true
|
|
end
|
|
}
|
|
|
|
m.register 'exit' {
|
|
function ()
|
|
log.info('Server exited.')
|
|
os.exit(0, true)
|
|
end
|
|
}
|
|
|
|
m.register 'shutdown' {
|
|
function ()
|
|
log.info('Server shutdown.')
|
|
return true
|
|
end
|
|
}
|
|
|
|
m.register 'workspace/didChangeConfiguration' {
|
|
function () ---@async
|
|
if CONFIGPATH then
|
|
return
|
|
end
|
|
m.updateConfig()
|
|
end
|
|
}
|
|
|
|
m.register 'workspace/didRenameFiles' {
|
|
capability = {
|
|
workspace = {
|
|
fileOperations = {
|
|
didRename = {
|
|
filters = function ()
|
|
local filters = {}
|
|
for i, scp in ipairs(workspace.folders) do
|
|
local path = furi.decode(scp.uri):gsub('\\', '/')
|
|
filters[i] = {
|
|
pattern = {
|
|
glob = path .. '/**',
|
|
options = {
|
|
ignoreCase = true,
|
|
}
|
|
},
|
|
}
|
|
end
|
|
return filters
|
|
end
|
|
},
|
|
},
|
|
},
|
|
},
|
|
---@async
|
|
function (params)
|
|
log.debug('workspace/didRenameFiles', inspect(params))
|
|
local renames = {}
|
|
for _, file in ipairs(params.files) do
|
|
local oldUri = furi.normalize(file.oldUri)
|
|
local newUri = furi.normalize(file.newUri)
|
|
if workspace.isValidLuaUri(oldUri)
|
|
and workspace.isValidLuaUri(newUri) then
|
|
renames[#renames+1] = {
|
|
oldUri = oldUri,
|
|
newUri = newUri,
|
|
}
|
|
end
|
|
local childs = files.getChildFiles(oldUri)
|
|
for _, uri in ipairs(childs) do
|
|
if files.exists(uri) then
|
|
local ouri = uri
|
|
local tail = ouri:sub(#oldUri)
|
|
local nuri = file.newUri .. tail
|
|
renames[#renames+1] = {
|
|
oldUri = ouri,
|
|
newUri = nuri,
|
|
}
|
|
end
|
|
end
|
|
end
|
|
local core = require 'core.modifyRequirePath'
|
|
core(renames)
|
|
end
|
|
}
|
|
|
|
m.register 'workspace/didChangeWorkspaceFolders' {
|
|
capability = {
|
|
workspace = {
|
|
workspaceFolders = {
|
|
supported = true,
|
|
changeNotifications = true,
|
|
},
|
|
},
|
|
},
|
|
---@async
|
|
function (params)
|
|
log.debug('workspace/didChangeWorkspaceFolders', inspect(params))
|
|
for _, folder in ipairs(params.event.added) do
|
|
local uri = files.getRealUri(folder.uri)
|
|
workspace.create(uri)
|
|
m.updateConfig()
|
|
workspace.reload(scope.getScope(uri))
|
|
end
|
|
for _, folder in ipairs(params.event.removed) do
|
|
local uri = files.getRealUri(folder.uri)
|
|
workspace.remove(uri)
|
|
end
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/didOpen' {
|
|
---@async
|
|
function (params)
|
|
local doc = params.textDocument
|
|
local uri = files.getRealUri(doc.uri)
|
|
log.debug('didOpen', uri)
|
|
local text = doc.text
|
|
files.setText(uri, text, true, function (file)
|
|
file.version = doc.version
|
|
end)
|
|
files.open(uri)
|
|
workspace.awaitReady(uri)
|
|
files.compileState(uri)
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/didClose' {
|
|
function (params)
|
|
local doc = params.textDocument
|
|
local uri = files.getRealUri(doc.uri)
|
|
log.debug('didClose', uri)
|
|
files.close(uri)
|
|
if not files.isLua(uri) then
|
|
files.remove(uri)
|
|
end
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/didChange' {
|
|
---@async
|
|
function (params)
|
|
local doc = params.textDocument
|
|
local changes = params.contentChanges
|
|
local uri = files.getRealUri(doc.uri)
|
|
local text = files.getOriginText(uri)
|
|
if not text then
|
|
text = util.loadFile(furi.decode(uri))
|
|
files.setText(uri, text, false)
|
|
return
|
|
end
|
|
local rows = files.getCachedRows(uri)
|
|
text, rows = tm(text, rows, changes)
|
|
files.setText(uri, text, true, function (file)
|
|
file.version = doc.version
|
|
end)
|
|
files.setCachedRows(uri, rows)
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/didSave' {
|
|
capability = {
|
|
textDocumentSync = {
|
|
save = {
|
|
includeText = false,
|
|
},
|
|
}
|
|
},
|
|
---@async
|
|
function (params)
|
|
local doc = params.textDocument
|
|
local uri = files.getRealUri(doc.uri)
|
|
files.onWatch('save', uri)
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/hover' {
|
|
capability = {
|
|
hoverProvider = true,
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local doc = params.textDocument
|
|
local uri = files.getRealUri(doc.uri)
|
|
if not config.get(uri, 'Lua.hover.enable') then
|
|
return
|
|
end
|
|
if not workspace.isReady(uri) then
|
|
local count, max = workspace.getLoadingProcess(uri)
|
|
return {
|
|
contents = {
|
|
value = lang.script('HOVER_WS_LOADING', count, max),
|
|
kind = 'markdown',
|
|
}
|
|
}
|
|
end
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_HOVER, 0.5)
|
|
local core = require 'core.hover'
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local hover, source = core.byUri(uri, pos)
|
|
if not hover or not source then
|
|
return nil
|
|
end
|
|
return {
|
|
contents = {
|
|
value = tostring(hover),
|
|
kind = 'markdown',
|
|
},
|
|
range = converter.packRange(state, source.start, source.finish),
|
|
}
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/definition' {
|
|
capability = {
|
|
definitionProvider = true,
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_DEFINITION, 0.5)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.definition'
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core(uri, pos)
|
|
if not result then
|
|
return nil
|
|
end
|
|
local response = {}
|
|
for i, info in ipairs(result) do
|
|
---@type uri
|
|
local targetUri = info.uri
|
|
if targetUri then
|
|
local targetState = files.getState(targetUri)
|
|
if targetState then
|
|
if client.getAbility 'textDocument.definition.linkSupport' then
|
|
response[i] = converter.locationLink(targetUri
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
, converter.packRange(state, info.source.start, info.source.finish)
|
|
)
|
|
else
|
|
response[i] = converter.location(targetUri
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
)
|
|
end
|
|
else
|
|
response[i] = converter.location(
|
|
targetUri,
|
|
converter.range(
|
|
converter.position(guide.rowColOf(info.target.start)),
|
|
converter.position(guide.rowColOf(info.target.finish))
|
|
)
|
|
)
|
|
end
|
|
end
|
|
end
|
|
return response
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/typeDefinition' {
|
|
capability = {
|
|
typeDefinitionProvider = true,
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_TYPE_DEFINITION, 0.5)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return
|
|
end
|
|
local core = require 'core.type-definition'
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core(uri, pos)
|
|
if not result then
|
|
return nil
|
|
end
|
|
local response = {}
|
|
for i, info in ipairs(result) do
|
|
---@type uri
|
|
local targetUri = info.uri
|
|
if targetUri then
|
|
local targetState = files.getState(targetUri)
|
|
if targetState then
|
|
if client.getAbility 'textDocument.typeDefinition.linkSupport' then
|
|
response[i] = converter.locationLink(targetUri
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
, converter.packRange(state, info.source.start, info.source.finish)
|
|
)
|
|
else
|
|
response[i] = converter.location(targetUri
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return response
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/references' {
|
|
capability = {
|
|
referencesProvider = true,
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_REFERENCE, 0.5)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.reference'
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core(uri, pos, params.context.includeDeclaration)
|
|
if not result then
|
|
return nil
|
|
end
|
|
local response = {}
|
|
for i, info in ipairs(result) do
|
|
---@type uri
|
|
local targetUri = info.uri
|
|
local targetState = files.getState(targetUri)
|
|
if targetState then
|
|
response[#response+1] = converter.location(targetUri
|
|
, converter.packRange(targetState, info.target.start, info.target.finish)
|
|
)
|
|
end
|
|
end
|
|
return response
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/documentHighlight' {
|
|
capability = {
|
|
documentHighlightProvider = true,
|
|
},
|
|
---@async
|
|
function (params)
|
|
local core = require 'core.highlight'
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core(uri, pos)
|
|
if not result then
|
|
return nil
|
|
end
|
|
local response = {}
|
|
for _, info in ipairs(result) do
|
|
response[#response+1] = {
|
|
range = converter.packRange(state, info.start, info.finish),
|
|
kind = info.kind,
|
|
}
|
|
end
|
|
return response
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/rename' {
|
|
capability = {
|
|
renameProvider = {
|
|
prepareProvider = true,
|
|
},
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_RENAME, 0.5)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.rename'
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core.rename(uri, pos, params.newName)
|
|
if not result then
|
|
return nil
|
|
end
|
|
local workspaceEdit = {
|
|
changes = {},
|
|
}
|
|
for _, info in ipairs(result) do
|
|
---@type uri
|
|
local ruri = info.uri
|
|
local rstate = files.getState(ruri)
|
|
if rstate then
|
|
if not workspaceEdit.changes[ruri] then
|
|
workspaceEdit.changes[ruri] = {}
|
|
end
|
|
local textEdit = converter.textEdit(converter.packRange(rstate, info.start, info.finish), info.text)
|
|
workspaceEdit.changes[ruri][#workspaceEdit.changes[ruri]+1] = textEdit
|
|
end
|
|
end
|
|
return workspaceEdit
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/prepareRename' {
|
|
abortByFileUpdate = true,
|
|
function (params)
|
|
local core = require 'core.rename'
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core.prepareRename(uri, pos)
|
|
if not result then
|
|
return nil
|
|
end
|
|
return {
|
|
range = converter.packRange(state, result.start, result.finish),
|
|
placeholder = result.text,
|
|
}
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/completion' {
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
if not workspace.isReady(uri) then
|
|
return nil
|
|
end
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_COMPLETION, 0.5)
|
|
--log.info(util.dump(params))
|
|
local core = require 'core.completion'
|
|
--log.debug('textDocument/completion')
|
|
--log.debug('completion:', params.context and params.context.triggerKind, params.context and params.context.triggerCharacter)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return
|
|
end
|
|
local triggerCharacter = params.context and params.context.triggerCharacter
|
|
if config.get(uri, 'editor.acceptSuggestionOnEnter') ~= 'off' then
|
|
if triggerCharacter == '\n'
|
|
or triggerCharacter == '{'
|
|
or triggerCharacter == ',' then
|
|
return
|
|
end
|
|
end
|
|
--await.setPriority(1000)
|
|
local clock = os.clock()
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local result = core.completion(uri, pos, triggerCharacter)
|
|
local passed = os.clock() - clock
|
|
if passed > 0.1 then
|
|
log.warn(('Completion takes %.3f sec.'):format(passed))
|
|
end
|
|
if not result then
|
|
return nil
|
|
end
|
|
tracy.ZoneBeginN 'completion make'
|
|
local _ <close> = tracy.ZoneEnd
|
|
local easy = false
|
|
local items = {}
|
|
for i, res in ipairs(result) do
|
|
local item = {
|
|
label = res.label,
|
|
kind = res.kind,
|
|
detail = res.detail,
|
|
deprecated = res.deprecated,
|
|
sortText = res.sortText or ('%04d'):format(i),
|
|
filterText = res.filterText,
|
|
insertText = res.insertText,
|
|
insertTextFormat = 2,
|
|
commitCharacters = res.commitCharacters,
|
|
command = res.command,
|
|
textEdit = res.textEdit and {
|
|
range = converter.packRange(
|
|
state,
|
|
res.textEdit.start,
|
|
res.textEdit.finish
|
|
),
|
|
newText = res.textEdit.newText,
|
|
},
|
|
additionalTextEdits = res.additionalTextEdits and (function ()
|
|
local t = {}
|
|
for j, edit in ipairs(res.additionalTextEdits) do
|
|
t[j] = {
|
|
range = converter.packRange(
|
|
state,
|
|
edit.start,
|
|
edit.finish
|
|
),
|
|
newText = edit.newText,
|
|
}
|
|
end
|
|
return t
|
|
end)(),
|
|
documentation = res.description and {
|
|
value = tostring(res.description),
|
|
kind = 'markdown',
|
|
},
|
|
}
|
|
if res.id then
|
|
if easy and os.clock() - clock < 0.05 then
|
|
local resolved = core.resolve(res.id)
|
|
if resolved then
|
|
item.detail = resolved.detail
|
|
item.documentation = resolved.description and {
|
|
value = tostring(resolved.description),
|
|
kind = 'markdown',
|
|
}
|
|
end
|
|
else
|
|
easy = false
|
|
item.data = {
|
|
uri = uri,
|
|
id = res.id,
|
|
}
|
|
end
|
|
end
|
|
items[i] = item
|
|
end
|
|
if result.incomplete == nil then
|
|
result.incomplete = false
|
|
end
|
|
return {
|
|
isIncomplete = result.incomplete,
|
|
items = items,
|
|
}
|
|
end
|
|
}
|
|
|
|
m.register 'completionItem/resolve' {
|
|
---@async
|
|
function (item)
|
|
local core = require 'core.completion'
|
|
if not item.data then
|
|
return item
|
|
end
|
|
local id = item.data.id
|
|
local uri = item.data.uri
|
|
--await.setPriority(1000)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local resolved = core.resolve(id)
|
|
if not resolved then
|
|
return nil
|
|
end
|
|
item.detail = resolved.detail or item.detail
|
|
item.documentation = resolved.description and {
|
|
value = tostring(resolved.description),
|
|
kind = 'markdown',
|
|
} or item.documentation
|
|
item.additionalTextEdits = resolved.additionalTextEdits and (function ()
|
|
local t = {}
|
|
for j, edit in ipairs(resolved.additionalTextEdits) do
|
|
t[j] = {
|
|
range = converter.packRange(
|
|
state,
|
|
edit.start,
|
|
edit.finish
|
|
),
|
|
newText = edit.newText,
|
|
}
|
|
end
|
|
return t
|
|
end)() or item.additionalTextEdits
|
|
return item
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/signatureHelp' {
|
|
capability = {
|
|
signatureHelpProvider = {
|
|
triggerCharacters = { '(', ',' },
|
|
},
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
if not config.get(uri, 'Lua.signatureHelp.enable') then
|
|
return nil
|
|
end
|
|
workspace.awaitReady(uri)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_SIGNATURE, 0.5)
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local core = require 'core.signature'
|
|
local results = core(uri, pos)
|
|
if not results then
|
|
return nil
|
|
end
|
|
local infos = {}
|
|
for i, result in ipairs(results) do
|
|
local parameters = {}
|
|
for j, param in ipairs(result.params) do
|
|
parameters[j] = {
|
|
label = {
|
|
param.label[1],
|
|
param.label[2],
|
|
}
|
|
}
|
|
end
|
|
infos[i] = {
|
|
label = result.label,
|
|
parameters = parameters,
|
|
activeParameter = math.max(0, result.index - 1),
|
|
documentation = result.description and {
|
|
value = tostring(result.description),
|
|
kind = 'markdown',
|
|
},
|
|
}
|
|
end
|
|
return {
|
|
signatures = infos,
|
|
}
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/documentSymbol' {
|
|
capability = {
|
|
documentSymbolProvider = true,
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_SYMBOL, 0.5)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.document-symbol'
|
|
local symbols = core(uri)
|
|
if not symbols then
|
|
return nil
|
|
end
|
|
|
|
---@async
|
|
local function convert(symbol)
|
|
await.delay()
|
|
symbol.range = converter.packRange(
|
|
state,
|
|
symbol.range[1],
|
|
symbol.range[2]
|
|
)
|
|
symbol.selectionRange = converter.packRange(
|
|
state,
|
|
symbol.selectionRange[1],
|
|
symbol.selectionRange[2]
|
|
)
|
|
if symbol.name == '' then
|
|
symbol.name = ' '
|
|
end
|
|
symbol.valueRange = nil
|
|
if symbol.children then
|
|
for _, child in ipairs(symbol.children) do
|
|
convert(child)
|
|
end
|
|
end
|
|
end
|
|
|
|
for _, symbol in ipairs(symbols) do
|
|
convert(symbol)
|
|
end
|
|
|
|
return symbols
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/codeAction' {
|
|
capability = {
|
|
codeActionProvider = {
|
|
codeActionKinds = {
|
|
'',
|
|
'quickfix',
|
|
'refactor.rewrite',
|
|
'refactor.extract',
|
|
},
|
|
resolveProvider = false,
|
|
},
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local core = require 'core.code-action'
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
local range = params.range
|
|
local diagnostics = params.context.diagnostics
|
|
workspace.awaitReady(uri)
|
|
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
|
|
local start, finish = converter.unpackRange(state, range)
|
|
local results = core(uri, start, finish, diagnostics)
|
|
|
|
if not results or #results == 0 then
|
|
return nil
|
|
end
|
|
|
|
for _, res in ipairs(results) do
|
|
if res.edit then
|
|
---@param turi uri
|
|
for turi, changes in pairs(res.edit.changes) do
|
|
local tstate = files.getState(turi)
|
|
if tstate then
|
|
for _, change in ipairs(changes) do
|
|
change.range = converter.packRange(tstate, change.start, change.finish)
|
|
change.start = nil
|
|
change.finish = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return results
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/codeLens' {
|
|
capability = {
|
|
codeLensProvider = {
|
|
resolveProvider = true,
|
|
}
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
if not config.get(uri, 'Lua.codeLens.enable') then
|
|
return
|
|
end
|
|
workspace.awaitReady(uri)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.code-lens'
|
|
local results = core.codeLens(uri)
|
|
if not results then
|
|
return nil
|
|
end
|
|
local codeLens = {}
|
|
for _, result in ipairs(results) do
|
|
codeLens[#codeLens+1] = {
|
|
range = converter.packRange(state, result.position, result.position),
|
|
data = {
|
|
uri = uri,
|
|
id = result.id,
|
|
},
|
|
}
|
|
end
|
|
return codeLens
|
|
end
|
|
}
|
|
|
|
m.register 'codeLens/resolve' {
|
|
---@async
|
|
function (codeLen)
|
|
local core = require 'core.code-lens'
|
|
local command = core.resolve(codeLen.data.uri, codeLen.data.id)
|
|
codeLen.command = command or converter.command('...', '', {})
|
|
return codeLen
|
|
end
|
|
}
|
|
|
|
m.register 'workspace/executeCommand' {
|
|
capability = {
|
|
executeCommandProvider = {
|
|
commands = {
|
|
'lua.removeSpace',
|
|
'lua.solve',
|
|
'lua.jsonToLua',
|
|
'lua.setConfig',
|
|
'lua.getConfig',
|
|
'lua.autoRequire',
|
|
},
|
|
},
|
|
},
|
|
---@async
|
|
function (params)
|
|
local command = params.command:gsub(':.+', '')
|
|
if command == 'lua.removeSpace' then
|
|
local core = require 'core.command.removeSpace'
|
|
return core(params.arguments[1])
|
|
elseif command == 'lua.solve' then
|
|
local core = require 'core.command.solve'
|
|
return core(params.arguments[1])
|
|
elseif command == 'lua.jsonToLua' then
|
|
local core = require 'core.command.jsonToLua'
|
|
return core(params.arguments[1])
|
|
elseif command == 'lua.setConfig' then
|
|
local core = require 'core.command.setConfig'
|
|
return core(params.arguments)
|
|
elseif command == 'lua.getConfig' then
|
|
local core = require 'core.command.getConfig'
|
|
return core(params.arguments)
|
|
elseif command == 'lua.autoRequire' then
|
|
local core = require 'core.command.autoRequire'
|
|
return core(params.arguments[1])
|
|
elseif command == 'lua.exportDocument' then
|
|
local core = require 'core.command.exportDocument'
|
|
core(params.arguments)
|
|
elseif command == 'lua.reloadFFIMeta' then
|
|
local core = require 'core.command.reloadFFIMeta'
|
|
for _, scp in ipairs(workspace.folders) do
|
|
core(scp.uri)
|
|
end
|
|
end
|
|
end
|
|
}
|
|
|
|
m.register 'workspace/symbol' {
|
|
capability = {
|
|
workspaceSymbolProvider = true,
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local _ <close> = progress.create(workspace.getFirstScope().uri, lang.script.WINDOW_PROCESSING_WS_SYMBOL, 0.5)
|
|
local core = require 'core.workspace-symbol'
|
|
|
|
local symbols = core(params.query, nil, true)
|
|
if not symbols or #symbols == 0 then
|
|
return nil
|
|
end
|
|
|
|
local function convert(symbol)
|
|
local uri = guide.getUri(symbol.source)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
return {
|
|
name = symbol.name,
|
|
kind = symbol.skind,
|
|
location = converter.location(
|
|
uri,
|
|
converter.packRange(
|
|
state,
|
|
symbol.source.start,
|
|
symbol.source.finish
|
|
)
|
|
)
|
|
}
|
|
end
|
|
|
|
local results = {}
|
|
|
|
for _, symbol in ipairs(symbols) do
|
|
results[#results+1] = convert(symbol)
|
|
end
|
|
|
|
return results
|
|
end
|
|
}
|
|
|
|
local function toArray(map)
|
|
local array = {}
|
|
for k in pairs(map) do
|
|
array[#array+1] = k
|
|
end
|
|
table.sort(array, function (a, b)
|
|
return map[a] < map[b]
|
|
end)
|
|
return array
|
|
end
|
|
|
|
client.event(function (ev)
|
|
if ev == 'init' then
|
|
if not client.isVSCode() then
|
|
m.register 'textDocument/semanticTokens/full' {
|
|
capability = {
|
|
semanticTokensProvider = {
|
|
legend = {
|
|
tokenTypes = toArray(define.TokenTypes),
|
|
tokenModifiers = toArray(define.TokenModifiers),
|
|
},
|
|
full = true,
|
|
},
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
log.debug('textDocument/semanticTokens/full')
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
await.sleep(0.0)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_SEMANTIC_FULL, 0.5)
|
|
local core = require 'core.semantic-tokens'
|
|
local results = core(uri, 0, math.huge)
|
|
return {
|
|
data = results
|
|
}
|
|
end
|
|
}
|
|
end
|
|
end
|
|
end)
|
|
|
|
m.register 'textDocument/semanticTokens/range' {
|
|
capability = {
|
|
semanticTokensProvider = {
|
|
legend = {
|
|
tokenTypes = toArray(define.TokenTypes),
|
|
tokenModifiers = toArray(define.TokenModifiers),
|
|
},
|
|
range = true,
|
|
},
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
log.debug('textDocument/semanticTokens/range')
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_SEMANTIC_RANGE, 0.5)
|
|
await.sleep(0.0)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.semantic-tokens'
|
|
local start, finish = converter.unpackRange(state, params.range)
|
|
local results = core(uri, start, finish)
|
|
return {
|
|
data = results
|
|
}
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/foldingRange' {
|
|
capability = {
|
|
foldingRangeProvider = true,
|
|
},
|
|
---@async
|
|
function (params)
|
|
local core = require 'core.folding'
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
if not files.exists(uri) then
|
|
return nil
|
|
end
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local regions = core(uri)
|
|
if not regions then
|
|
return nil
|
|
end
|
|
|
|
local results = {}
|
|
for _, region in ipairs(regions) do
|
|
local startLine = converter.packPosition(state, region.start).line
|
|
local endLine = converter.packPosition(state, region.finish).line
|
|
if not region.hideLastLine then
|
|
endLine = endLine - 1
|
|
end
|
|
if startLine < endLine then
|
|
results[#results+1] = {
|
|
startLine = startLine,
|
|
endLine = endLine,
|
|
kind = region.kind,
|
|
}
|
|
end
|
|
end
|
|
|
|
return results
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/documentColor' {
|
|
capability = {
|
|
colorProvider = true
|
|
},
|
|
---@async
|
|
function (params)
|
|
local color = require 'core.color'
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local colors = color.colors(uri)
|
|
if not colors then
|
|
return nil
|
|
end
|
|
local results = {}
|
|
for _, colorValue in ipairs(colors) do
|
|
results[#results+1] = {
|
|
range = converter.packRange(state, colorValue.start, colorValue.finish),
|
|
color = colorValue.color
|
|
}
|
|
end
|
|
return results
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/colorPresentation' {
|
|
function (params)
|
|
local color = (require 'core.color').colorToText(params.color)
|
|
return {{label = color}}
|
|
end
|
|
}
|
|
|
|
m.register 'window/workDoneProgress/cancel' {
|
|
function (params)
|
|
log.debug('close proto(cancel):', params.token)
|
|
progress.cancel(params.token)
|
|
end
|
|
}
|
|
|
|
m.register '$/status/click' {
|
|
---@async
|
|
function ()
|
|
local titleDiagnostic = lang.script.WINDOW_LUA_STATUS_DIAGNOSIS_TITLE
|
|
local result = client.awaitRequestMessage('Info', lang.script.WINDOW_LUA_STATUS_DIAGNOSIS_MSG, {
|
|
titleDiagnostic,
|
|
DEVELOP and 'Restart Server' or nil,
|
|
DEVELOP and 'Clear Node Cache' or nil,
|
|
DEVELOP and 'GC' or nil,
|
|
})
|
|
if not result then
|
|
return
|
|
end
|
|
if result == titleDiagnostic then
|
|
local diagnostic = require 'provider.diagnostic'
|
|
for _, scp in ipairs(workspace.folders) do
|
|
diagnostic.diagnosticsScope(scp.uri, true)
|
|
end
|
|
elseif result == 'Restart Server' then
|
|
local diag = require 'provider.diagnostic'
|
|
diag.clearAll(nil, true)
|
|
os.exit(0, true)
|
|
elseif result == 'Clear Node Cache' then
|
|
local vm = require 'vm'
|
|
vm.clearNodeCache()
|
|
collectgarbage()
|
|
collectgarbage()
|
|
elseif result == 'GC' then
|
|
collectgarbage()
|
|
collectgarbage()
|
|
end
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/formatting' {
|
|
capability = {
|
|
documentFormattingProvider = true,
|
|
},
|
|
---@async
|
|
function(params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
|
|
if not config.get(uri, 'Lua.format.enable') then
|
|
return nil
|
|
end
|
|
|
|
local pformatting = require 'provider.formatting'
|
|
pformatting.updateConfig(uri)
|
|
|
|
local core = require 'core.formatting'
|
|
local edits = core(uri, params.options)
|
|
if not edits or #edits == 0 then
|
|
return nil
|
|
end
|
|
|
|
local results = {}
|
|
for i, edit in ipairs(edits) do
|
|
results[i] = {
|
|
range = converter.packRange(state, edit.start, edit.finish),
|
|
newText = edit.text,
|
|
}
|
|
end
|
|
|
|
return results
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/rangeFormatting' {
|
|
capability = {
|
|
documentRangeFormattingProvider = true,
|
|
},
|
|
---@async
|
|
function(params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
|
|
if not config.get(uri, 'Lua.format.enable') then
|
|
return nil
|
|
end
|
|
|
|
local pformatting = require 'provider.formatting'
|
|
pformatting.updateConfig(uri)
|
|
|
|
local core = require 'core.rangeformatting'
|
|
local edits = core(uri, params.range, params.options)
|
|
if not edits or #edits == 0 then
|
|
return nil
|
|
end
|
|
|
|
local results = {}
|
|
for i, edit in ipairs(edits) do
|
|
results[i] = {
|
|
range = converter.packRange(state, edit.start, edit.finish),
|
|
newText = edit.text,
|
|
}
|
|
end
|
|
|
|
return results
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/onTypeFormatting' {
|
|
capability = {
|
|
documentOnTypeFormattingProvider = {
|
|
firstTriggerCharacter = '\n',
|
|
moreTriggerCharacter = nil, -- string[]
|
|
},
|
|
},
|
|
abortByFileUpdate = true,
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_TYPE_FORMATTING, 0.5)
|
|
local ch = params.ch
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local core = require 'core.type-formatting'
|
|
local pos = converter.unpackPosition(state, params.position)
|
|
local edits = core(uri, pos, ch, params.options)
|
|
if not edits or #edits == 0 then
|
|
return nil
|
|
end
|
|
local tab = '\t'
|
|
if params.options.insertSpaces then
|
|
tab = (' '):rep(params.options.tabSize)
|
|
end
|
|
local results = {}
|
|
for i, edit in ipairs(edits) do
|
|
results[i] = {
|
|
range = converter.packRange(state, edit.start, edit.finish),
|
|
newText = edit.text:gsub('\t', tab),
|
|
}
|
|
end
|
|
return results
|
|
end
|
|
}
|
|
|
|
m.register '$/cancelRequest' {
|
|
function (params)
|
|
proto.close(params.id, define.ErrorCodes.RequestCancelled, 'Request cancelled.')
|
|
end
|
|
}
|
|
|
|
m.register '$/requestHint' {
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
if not config.get(uri, 'Lua.hint.enable') then
|
|
return
|
|
end
|
|
workspace.awaitReady(uri)
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return
|
|
end
|
|
local core = require 'core.hint'
|
|
local start, finish = converter.unpackRange(state, params.range)
|
|
local results = core(uri, start, finish)
|
|
local hintResults = {}
|
|
for i, res in ipairs(results) do
|
|
hintResults[i] = {
|
|
text = res.text,
|
|
pos = converter.packPosition(state, res.offset),
|
|
kind = res.kind,
|
|
}
|
|
end
|
|
return hintResults
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/inlayHint' {
|
|
capability = {
|
|
inlayHintProvider = {
|
|
resolveProvider = true,
|
|
},
|
|
},
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
if not config.get(uri, 'Lua.hint.enable') then
|
|
return nil
|
|
end
|
|
workspace.awaitReady(uri)
|
|
local core = require 'core.hint'
|
|
local state = files.getState(uri)
|
|
if not state then
|
|
return nil
|
|
end
|
|
local start, finish = converter.unpackRange(state, params.range)
|
|
local results = core(uri, start, finish)
|
|
local hintResults = {}
|
|
for i, res in ipairs(results) do
|
|
local luri = res.source and guide.getUri(res.source)
|
|
local lstate = files.getState(luri)
|
|
hintResults[i] = {
|
|
label = {
|
|
{
|
|
value = res.text,
|
|
tooltip = res.tooltip,
|
|
location = lstate and converter.location(
|
|
luri,
|
|
converter.packRange(
|
|
lstate,
|
|
res.source.start,
|
|
res.source.finish
|
|
)
|
|
),
|
|
},
|
|
},
|
|
position = converter.packPosition(state, res.offset),
|
|
kind = res.kind,
|
|
paddingLeft = res.kind == 1,
|
|
paddingRight = res.kind == 2,
|
|
}
|
|
end
|
|
return hintResults
|
|
end
|
|
}
|
|
|
|
m.register 'inlayHint/resolve' {
|
|
capability = {
|
|
inlayHintProvider = {
|
|
resolveProvider = true,
|
|
},
|
|
},
|
|
---@async
|
|
function (hint)
|
|
return hint
|
|
end
|
|
}
|
|
|
|
m.register 'textDocument/diagnostic' {
|
|
preview = true,
|
|
capability = {
|
|
diagnosticProvider = {
|
|
identifier = 'identifier',
|
|
interFileDependencies = true,
|
|
workspaceDiagnostics = false,
|
|
}
|
|
},
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.textDocument.uri)
|
|
workspace.awaitReady(uri)
|
|
local core = require 'provider.diagnostic'
|
|
-- TODO: do some trick
|
|
core.doDiagnostic(uri)
|
|
|
|
return {
|
|
kind = 'unchanged',
|
|
resultId = uri,
|
|
}
|
|
|
|
--if not params.previousResultId then
|
|
-- core.clearCache(uri)
|
|
--end
|
|
--local results, unchanged = core.pullDiagnostic(uri, false)
|
|
--if unchanged then
|
|
-- return {
|
|
-- kind = 'unchanged',
|
|
-- resultId = uri,
|
|
-- }
|
|
--else
|
|
-- return {
|
|
-- kind = 'full',
|
|
-- resultId = uri,
|
|
-- items = results or {},
|
|
-- }
|
|
--end
|
|
end
|
|
}
|
|
|
|
m.register 'workspace/diagnostic' {
|
|
--preview = true,
|
|
--capability = {
|
|
-- diagnosticProvider = {
|
|
-- workspaceDiagnostics = false,
|
|
-- }
|
|
--},
|
|
---@async
|
|
function (params)
|
|
local core = require 'provider.diagnostic'
|
|
local excepts = {}
|
|
for _, id in ipairs(params.previousResultIds) do
|
|
excepts[#excepts+1] = id.value
|
|
end
|
|
core.clearCacheExcept(excepts)
|
|
local function convertItem(result)
|
|
if result.unchanged then
|
|
return {
|
|
kind = 'unchanged',
|
|
resultId = result.uri,
|
|
uri = result.uri,
|
|
version = result.version,
|
|
}
|
|
else
|
|
return {
|
|
kind = 'full',
|
|
resultId = result.uri,
|
|
items = result.result or {},
|
|
uri = result.uri,
|
|
version = result.version,
|
|
}
|
|
end
|
|
end
|
|
core.pullDiagnosticScope(function (result)
|
|
proto.notify('$/progress', {
|
|
token = params.partialResultToken,
|
|
value = {
|
|
items = {
|
|
convertItem(result)
|
|
}
|
|
}
|
|
})
|
|
end)
|
|
return { items = {} }
|
|
end
|
|
}
|
|
|
|
m.register '$/api/report' {
|
|
---@async
|
|
function (params)
|
|
local buildMeta = require 'provider.build-meta'
|
|
local SDBMHash = require 'SDBMHash'
|
|
await.close 'api/report'
|
|
await.setID 'api/report'
|
|
local name = params.name or 'default'
|
|
local uri = workspace.getFirstScope().uri
|
|
local hash = uri and ('%08x'):format(SDBMHash():hash(uri))
|
|
local encoding = config.get(nil, 'Lua.runtime.fileEncoding')
|
|
local nameBuf = {}
|
|
nameBuf[#nameBuf+1] = name
|
|
nameBuf[#nameBuf+1] = hash
|
|
nameBuf[#nameBuf+1] = encoding
|
|
local fileDir = METAPATH .. '/' .. table.concat(nameBuf, ' ')
|
|
fs.create_directories(fs.path(fileDir))
|
|
buildMeta.build(fileDir, params)
|
|
client.setConfig {
|
|
{
|
|
key = 'Lua.workspace.library',
|
|
action = 'add',
|
|
value = fileDir,
|
|
uri = uri,
|
|
}
|
|
}
|
|
end
|
|
}
|
|
|
|
m.register '$/psi/view' {
|
|
---@async
|
|
function (params)
|
|
local uri = files.getRealUri(params.uri)
|
|
workspace.awaitReady(uri)
|
|
local _ <close> = progress.create(uri, lang.script.WINDOW_PROCESSING_TYPE_FORMATTING, 0.5)
|
|
if not files.exists(uri) then
|
|
return nil
|
|
end
|
|
local core = require 'core.view.psi-view'
|
|
local result = core(uri)
|
|
return result
|
|
end
|
|
}
|
|
|
|
m.register '$/psi/select' {
|
|
---@async
|
|
function(params)
|
|
local uri = files.getRealUri(params.uri)
|
|
workspace.awaitReady(uri)
|
|
local _<close> = progress.create(uri, lang.script.WINDOW_PROCESSING_TYPE_FORMATTING, 0.5)
|
|
if not files.exists(uri) then
|
|
return nil
|
|
end
|
|
local core = require 'core.view.psi-select'
|
|
local result = core(uri, params.position)
|
|
return result
|
|
end
|
|
}
|
|
|
|
|
|
local function refreshStatusBar()
|
|
local valid = config.get(nil, 'Lua.window.statusBar')
|
|
for _, scp in ipairs(workspace.folders) do
|
|
if not config.get(scp.uri, 'Lua.window.statusBar') then
|
|
valid = false
|
|
break
|
|
end
|
|
end
|
|
if valid then
|
|
proto.notify('$/status/show')
|
|
else
|
|
proto.notify('$/status/hide')
|
|
end
|
|
end
|
|
|
|
config.watch(function (uri, key, value)
|
|
if key == 'Lua.window.statusBar'
|
|
or key == '' then
|
|
refreshStatusBar()
|
|
end
|
|
end)
|
|
|
|
m.register '$/status/refresh' { refreshStatusBar }
|
|
|
|
files.watch(function (ev, uri)
|
|
if not workspace.isReady(uri) then
|
|
return
|
|
end
|
|
if ev == 'update'
|
|
or ev == 'remove' then
|
|
for id, p in pairs(proto.holdon) do
|
|
if m.attributes[p.method].abortByFileUpdate then
|
|
log.debug('close proto(ContentModified):', id, p.method)
|
|
proto.close(id, define.ErrorCodes.ContentModified, 'Content modified.')
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
return m
|