Skip to content

Instantly share code, notes, and snippets.

@yshui

yshui/lsp.log

Created November 5, 2021 12:57
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save yshui/02b430e836889182d01529e3c9ea1b83 to your computer and use it in GitHub Desktop.
Save yshui/02b430e836889182d01529e3c9ea1b83 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
lsp.log
[START][2021-11-05 12:53:06] LSP logging initiated
[INFO][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:258 "Starting RPC client" {
args = {},
cmd = "rust-analyzer",
extra = {}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:851 "LSP[rust_analyzer]" "initialize_params" {
capabilities = {
callHierarchy = {
dynamicRegistration = false
},
textDocument = {
codeAction = {
codeActionLiteralSupport = {
codeActionKind = {
valueSet = { "", "Empty", "QuickFix", "Refactor", "RefactorExtract", "RefactorInline", "RefactorRewrite", "Source", "SourceOrganizeImports", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports" }
}
},
dataSupport = true,
dynamicRegistration = false,
resolveSupport = {
properties = { "edit" }
}
},
completion = {
completionItem = {
commitCharactersSupport = false,
deprecatedSupport = false,
documentationFormat = { "markdown", "plaintext" },
preselectSupport = false,
snippetSupport = false
},
completionItemKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 }
},
contextSupport = false,
dynamicRegistration = false
},
declaration = {
linkSupport = true
},
definition = {
linkSupport = true
},
documentHighlight = {
dynamicRegistration = false
},
documentSymbol = {
dynamicRegistration = false,
hierarchicalDocumentSymbolSupport = true,
symbolKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
}
},
hover = {
contentFormat = { "markdown", "plaintext" },
dynamicRegistration = false
},
implementation = {
linkSupport = true
},
publishDiagnostics = {
relatedInformation = true,
tagSupport = {
valueSet = { 1, 2 }
}
},
references = {
dynamicRegistration = false
},
rename = {
dynamicRegistration = false,
prepareSupport = true
},
signatureHelp = {
dynamicRegistration = false,
signatureInformation = {
activeParameterSupport = true,
documentationFormat = { "markdown", "plaintext" },
parameterInformation = {
labelOffsetSupport = true
}
}
},
synchronization = {
didSave = true,
dynamicRegistration = false,
willSave = false,
willSaveWaitUntil = false
},
typeDefinition = {
linkSupport = true
}
},
window = {
showDocument = {
support = false
},
showMessage = {
messageActionItem = {
additionalPropertiesSupport = false
}
},
workDoneProgress = true
},
workspace = {
applyEdit = true,
configuration = true,
symbol = {
dynamicRegistration = false,
hierarchicalWorkspaceSymbolSupport = true,
symbolKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
}
},
workspaceEdit = {
resourceOperations = { "rename", "create", "delete" }
},
workspaceFolders = true
}
},
clientInfo = {
name = "Neovim",
version = "0.6.0"
},
initializationOptions = vim.empty_dict(),
processId = 702581,
rootPath = "/tmp/xx",
rootUri = "file:///tmp/xx",
trace = "off",
workspaceFolders = { {
name = "/tmp/xx",
uri = "file:///tmp/xx"
} }
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 1,
jsonrpc = "2.0",
method = "initialize",
params = {
capabilities = {
callHierarchy = {
dynamicRegistration = false
},
textDocument = {
codeAction = {
codeActionLiteralSupport = {
codeActionKind = {
valueSet = { "", "Empty", "QuickFix", "Refactor", "RefactorExtract", "RefactorInline", "RefactorRewrite", "Source", "SourceOrganizeImports", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports" }
}
},
dataSupport = true,
dynamicRegistration = false,
resolveSupport = {
properties = { "edit" }
}
},
completion = {
completionItem = {
commitCharactersSupport = false,
deprecatedSupport = false,
documentationFormat = { "markdown", "plaintext" },
preselectSupport = false,
snippetSupport = false
},
completionItemKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 }
},
contextSupport = false,
dynamicRegistration = false
},
declaration = {
linkSupport = true
},
definition = {
linkSupport = true
},
documentHighlight = {
dynamicRegistration = false
},
documentSymbol = {
dynamicRegistration = false,
hierarchicalDocumentSymbolSupport = true,
symbolKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
}
},
hover = {
contentFormat = { "markdown", "plaintext" },
dynamicRegistration = false
},
implementation = {
linkSupport = true
},
publishDiagnostics = {
relatedInformation = true,
tagSupport = {
valueSet = { 1, 2 }
}
},
references = {
dynamicRegistration = false
},
rename = {
dynamicRegistration = false,
prepareSupport = true
},
signatureHelp = {
dynamicRegistration = false,
signatureInformation = {
activeParameterSupport = true,
documentationFormat = { "markdown", "plaintext" },
parameterInformation = {
labelOffsetSupport = true
}
}
},
synchronization = {
didSave = true,
dynamicRegistration = false,
willSave = false,
willSaveWaitUntil = false
},
typeDefinition = {
linkSupport = true
}
},
window = {
showDocument = {
support = false
},
showMessage = {
messageActionItem = {
additionalPropertiesSupport = false
}
},
workDoneProgress = true
},
workspace = {
applyEdit = true,
configuration = true,
symbol = {
dynamicRegistration = false,
hierarchicalWorkspaceSymbolSupport = true,
symbolKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
}
},
workspaceEdit = {
resourceOperations = { "rename", "create", "delete" }
},
workspaceFolders = true
}
},
clientInfo = {
name = "Neovim",
version = "0.6.0"
},
initializationOptions = vim.empty_dict(),
processId = 702581,
rootPath = "/tmp/xx",
rootUri = "file:///tmp/xx",
trace = "off",
workspaceFolders = { {
name = "/tmp/xx",
uri = "file:///tmp/xx"
} }
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 1,
jsonrpc = "2.0",
result = {
capabilities = {
callHierarchyProvider = true,
codeActionProvider = {
codeActionKinds = { "", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite" },
resolveProvider = true
},
codeLensProvider = {
resolveProvider = true
},
completionProvider = {
triggerCharacters = { ":", ".", "'" }
},
declarationProvider = true,
definitionProvider = true,
documentFormattingProvider = true,
documentHighlightProvider = true,
documentOnTypeFormattingProvider = {
firstTriggerCharacter = "=",
moreTriggerCharacter = { ".", ">", "{" }
},
documentRangeFormattingProvider = false,
documentSymbolProvider = true,
experimental = {
hoverRange = true,
joinLines = true,
onEnter = true,
openCargoToml = true,
parentModule = true,
runnables = {
kinds = { "cargo" }
},
ssr = true,
workspaceSymbolScopeKindFiltering = true
},
foldingRangeProvider = true,
hoverProvider = true,
implementationProvider = true,
referencesProvider = true,
renameProvider = {
prepareProvider = true
},
selectionRangeProvider = true,
semanticTokensProvider = {
full = {
delta = true
},
legend = {
tokenModifiers = { "documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "defaultLibrary", "async", "attribute", "callable", "constant", "consuming", "controlFlow", "crateRoot", "injected", "intraDocLink", "library", "mutable", "public", "reference", "trait", "unsafe" },
tokenTypes = { "comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "enumMember", "typeParameter", "function", "method", "property", "macro", "variable", "parameter", "angle", "arithmetic", "attribute", "bitwise", "boolean", "brace", "bracket", "builtinAttribute", "builtinType", "character", "colon", "comma", "comparison", "constParameter", "dot", "escapeSequence", "formatSpecifier", "generic", "label", "lifetime", "logical", "operator", "parenthesis", "punctuation", "selfKeyword", "semicolon", "typeAlias", "union", "unresolvedReference" }
},
range = true
},
signatureHelpProvider = {
triggerCharacters = { "(", "," }
},
textDocumentSync = {
change = 2,
openClose = true,
save = vim.empty_dict()
},
typeDefinitionProvider = true,
workspace = {
fileOperations = {
willRename = {
filters = { {
pattern = {
glob = "**/*.rs",
matches = "file"
},
scheme = "file"
}, {
pattern = {
glob = "**",
matches = "folder"
},
scheme = "file"
} }
}
}
},
workspaceSymbolProvider = true
},
serverInfo = {
name = "rust-analyzer",
version = "210a1d5ec 2021-10-28 dev"
}
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
jsonrpc = "2.0",
method = "initialized",
params = vim.empty_dict()
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
jsonrpc = "2.0",
method = "workspace/didChangeConfiguration",
params = {
settings = {
["rust-analyzer"] = {}
}
}
}
[DEBUG][2021-11-05 12:53:07] .../lua/vim/lsp.lua:878 "LSP[rust_analyzer]" "server_capabilities" {
callHierarchyProvider = true,
codeActionProvider = {
codeActionKinds = { "", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite" },
resolveProvider = true
},
codeLensProvider = {
resolveProvider = true
},
completionProvider = {
triggerCharacters = { ":", ".", "'" }
},
declarationProvider = true,
definitionProvider = true,
documentFormattingProvider = true,
documentHighlightProvider = true,
documentOnTypeFormattingProvider = {
firstTriggerCharacter = "=",
moreTriggerCharacter = { ".", ">", "{" }
},
documentRangeFormattingProvider = false,
documentSymbolProvider = true,
experimental = {
hoverRange = true,
joinLines = true,
onEnter = true,
openCargoToml = true,
parentModule = true,
runnables = {
kinds = { "cargo" }
},
ssr = true,
workspaceSymbolScopeKindFiltering = true
},
foldingRangeProvider = true,
hoverProvider = true,
implementationProvider = true,
referencesProvider = true,
renameProvider = {
prepareProvider = true
},
selectionRangeProvider = true,
semanticTokensProvider = {
full = {
delta = true
},
legend = {
tokenModifiers = { "documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "defaultLibrary", "async", "attribute", "callable", "constant", "consuming", "controlFlow", "crateRoot", "injected", "intraDocLink", "library", "mutable", "public", "reference", "trait", "unsafe" },
tokenTypes = { "comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "enumMember", "typeParameter", "function", "method", "property", "macro", "variable", "parameter", "angle", "arithmetic", "attribute", "bitwise", "boolean", "brace", "bracket", "builtinAttribute", "builtinType", "character", "colon", "comma", "comparison", "constParameter", "dot", "escapeSequence", "formatSpecifier", "generic", "label", "lifetime", "logical", "operator", "parenthesis", "punctuation", "selfKeyword", "semicolon", "typeAlias", "union", "unresolvedReference" }
},
range = true
},
signatureHelpProvider = {
triggerCharacters = { "(", "," }
},
textDocumentSync = {
change = 2,
openClose = true,
save = vim.empty_dict()
},
typeDefinitionProvider = true,
workspace = {
fileOperations = {
willRename = {
filters = { {
pattern = {
glob = "**/*.rs",
matches = "file"
},
scheme = "file"
}, {
pattern = {
glob = "**",
matches = "folder"
},
scheme = "file"
} }
}
}
},
workspaceSymbolProvider = true
}
[INFO][2021-11-05 12:53:07] .../lua/vim/lsp.lua:879 "LSP[rust_analyzer]" "initialized" {
resolved_capabilities = {
call_hierarchy = true,
code_action = {
codeActionKinds = { "", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite" },
resolveProvider = true
},
code_lens = true,
code_lens_resolve = true,
completion = true,
declaration = true,
document_formatting = true,
document_highlight = true,
document_range_formatting = false,
document_symbol = true,
execute_command = false,
find_references = true,
goto_definition = true,
hover = true,
implementation = true,
rename = true,
signature_help = true,
signature_help_trigger_characters = { "(", "," },
text_document_did_change = 2,
text_document_open_close = true,
text_document_save = vim.empty_dict(),
text_document_save_include_text = false,
text_document_will_save = false,
text_document_will_save_wait_until = false,
type_definition = true,
workspace_folder_properties = {
changeNotifications = false,
supported = false
},
workspace_symbol = true
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
jsonrpc = "2.0",
method = "textDocument/didOpen",
params = {
textDocument = {
languageId = "rust",
text = "#[cfg(test)]\nmod tests {\n #[test]\n fn it_works() {\n let result = 2 + 2;\n assert_eq!(result, 4);\n }\n}\nfn main() {\n\n}\n\n",
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 0,
jsonrpc = "2.0",
method = "workspace/configuration",
params = {
items = { {
section = "rust-analyzer"
} }
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 1,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Fetching"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "begin",
title = "Fetching"
}
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:710 "server_request" "workspace/configuration" {
items = { {
section = "rust-analyzer"
} }
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:713 "server_request: found handler for" "workspace/configuration"
[TRACE][2021-11-05 12:53:07] ...lsp/handlers.lua:432 "default_handler" "workspace/configuration" {
ctx = '{\n client_id = 1,\n method = "workspace/configuration"\n}',
result = {
items = { {
section = "rust-analyzer"
} }
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = { {} },
status = true
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 0,
jsonrpc = "2.0",
result = { {} }
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Fetching"
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:07] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Fetching"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 1,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "begin",
title = "Fetching"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "report",
message = "metadata"
}
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "report",
message = "metadata"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "end"
}
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 2,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Roots Scanned"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "begin",
message = "0/2",
percentage = 0,
title = "Roots Scanned"
}
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "report",
message = "1/2",
percentage = 50
}
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 3,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Fetching"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "begin",
title = "Fetching"
}
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 4,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Loading"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Loading",
value = {
kind = "begin",
title = "Loading"
}
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Roots Scanned"
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:07] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Roots Scanned"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 2,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "begin",
message = "0/2",
percentage = 0,
title = "Roots Scanned"
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "report",
message = "1/2",
percentage = 50
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Fetching"
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:07] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Fetching"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 3,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "begin",
title = "Fetching"
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Loading"
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:07] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Loading"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 4,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Loading",
value = {
kind = "begin",
title = "Loading"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "end",
message = "2/2"
}
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "end",
message = "2/2"
}
}
[DEBUG][2021-11-05 12:53:07] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "report",
message = "metadata"
}
}
}
[TRACE][2021-11-05 12:53:07] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "report",
message = "metadata"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "metadata xx"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "metadata xx"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "xx"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "xx"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "metadata xx"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "xx"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "xx"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Loading",
value = {
kind = "report",
message = "metadata xx"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Loading",
value = {
kind = "end"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 5,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Roots Scanned"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Loading",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "begin",
message = "0/2",
percentage = 0,
title = "Roots Scanned"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "report",
message = "1/2",
percentage = 50
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Roots Scanned"
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Roots Scanned"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 5,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "begin",
message = "0/2",
percentage = 0,
title = "Roots Scanned"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "report",
message = "1/2",
percentage = 50
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "end",
message = "2/2"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Roots Scanned",
value = {
kind = "end",
message = "2/2"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "end"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 6,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Fetching"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "begin",
title = "Fetching"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 7,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Indexing"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "begin",
percentage = 0,
title = "Indexing"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "0/11 (core)",
percentage = 0
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Fetching"
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Fetching"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 6,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "begin",
title = "Fetching"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Indexing"
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Indexing"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 7,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "begin",
percentage = 0,
title = "Indexing"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "0/11 (core)",
percentage = 0
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 8,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/cargo check"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/cargo check",
value = {
kind = "begin",
title = "cargo check"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/cargo check"
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/cargo check"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 8,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/cargo check",
value = {
kind = "begin",
title = "cargo check"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "textDocument/publishDiagnostics",
params = {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "textDocument/publishDiagnostics" {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "textDocument/publishDiagnostics" {
ctx = '{\n client_id = 1,\n method = "textDocument/publishDiagnostics"\n}',
result = {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/cargo check",
value = {
kind = "end"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/cargo check",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "report",
message = "metadata"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "report",
message = "metadata"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Fetching",
value = {
kind = "end"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Fetching",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 9,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/cargo check"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/cargo check"
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/cargo check"
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 9,
jsonrpc = "2.0",
result = vim.NIL
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/cargo check",
value = {
kind = "begin",
title = "cargo check"
}
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "textDocument/publishDiagnostics",
params = {
diagnostics = {},
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/cargo check",
value = {
kind = "begin",
title = "cargo check"
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "textDocument/publishDiagnostics" {
diagnostics = {},
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "textDocument/publishDiagnostics" {
ctx = '{\n client_id = 1,\n method = "textDocument/publishDiagnostics"\n}',
result = {
diagnostics = {},
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "textDocument/publishDiagnostics",
params = {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "textDocument/publishDiagnostics" {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
[TRACE][2021-11-05 12:53:08] ...lsp/handlers.lua:432 "default_handler" "textDocument/publishDiagnostics" {
ctx = '{\n client_id = 1,\n method = "textDocument/publishDiagnostics"\n}',
result = {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[DEBUG][2021-11-05 12:53:08] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/cargo check",
value = {
kind = "end"
}
}
}
[TRACE][2021-11-05 12:53:08] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/cargo check",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:09] .../lua/vim/lsp.lua:919 "LSP[rust_analyzer]" "client.request" 1 "textDocument/documentSymbol" {
textDocument = {
uri = "file:///tmp/xx/src/lib.rs"
}
} <function 1> 1
[DEBUG][2021-11-05 12:53:09] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 2,
jsonrpc = "2.0",
method = "textDocument/documentSymbol",
params = {
textDocument = {
uri = "file:///tmp/xx/src/lib.rs"
}
}
}
[DEBUG][2021-11-05 12:53:09] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 2,
jsonrpc = "2.0",
result = { {
children = { {
deprecated = false,
detail = "fn()",
kind = 12,
name = "it_works",
range = {
end = {
character = 5,
line = 6
},
start = {
character = 4,
line = 2
}
},
selectionRange = {
end = {
character = 15,
line = 3
},
start = {
character = 7,
line = 3
}
},
tags = {}
} },
deprecated = false,
kind = 2,
name = "tests",
range = {
end = {
character = 1,
line = 7
},
start = {
character = 0,
line = 0
}
},
selectionRange = {
end = {
character = 9,
line = 1
},
start = {
character = 4,
line = 1
}
},
tags = {}
}, {
deprecated = false,
detail = "fn()",
kind = 12,
name = "main",
range = {
end = {
character = 1,
line = 10
},
start = {
character = 0,
line = 8
}
},
selectionRange = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
tags = {}
} }
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "1/11 (alloc)",
percentage = 9
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "1/11 (alloc)",
percentage = 9
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "2/11 (panic_abort)",
percentage = 18
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "2/11 (panic_abort)",
percentage = 18
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "3/11 (panic_unwind)",
percentage = 27
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "3/11 (panic_unwind)",
percentage = 27
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "4/11 (profiler_builtins)",
percentage = 36
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "4/11 (profiler_builtins)",
percentage = 36
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "5/11 (std_detect)",
percentage = 45
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "5/11 (std_detect)",
percentage = 45
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "6/11 (test)",
percentage = 54
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "6/11 (test)",
percentage = 54
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "7/11 (unwind)",
percentage = 63
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "7/11 (unwind)",
percentage = 63
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "8/11 (std)",
percentage = 72
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "8/11 (std)",
percentage = 72
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "9/11 (proc_macro)",
percentage = 81
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "9/11 (proc_macro)",
percentage = 81
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "10/11 (xx)",
percentage = 90
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "10/11 (xx)",
percentage = 90
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "end"
}
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 10,
jsonrpc = "2.0",
method = "window/workDoneProgress/create",
params = {
token = "rustAnalyzer/Indexing"
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "begin",
percentage = 0,
title = "Indexing"
}
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "1/11 (alloc)",
percentage = 9
}
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "9/11 (proc_macro)",
percentage = 81
}
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "10/11 (xx)",
percentage = 90
}
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "$/progress",
params = {
token = "rustAnalyzer/Indexing",
value = {
kind = "end"
}
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "end"
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:710 "server_request" "window/workDoneProgress/create" {
token = "rustAnalyzer/Indexing"
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:713 "server_request: found handler for" "window/workDoneProgress/create"
[TRACE][2021-11-05 12:53:10] ...lsp/handlers.lua:432 "default_handler" "window/workDoneProgress/create" {
ctx = '{\n client_id = 1,\n method = "window/workDoneProgress/create"\n}',
result = {
token = "rustAnalyzer/Indexing"
}
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:456 "server_request: callback result" {
result = vim.NIL,
status = true
}
[DEBUG][2021-11-05 12:53:10] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 10,
jsonrpc = "2.0",
result = vim.NIL
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "begin",
percentage = 0,
title = "Indexing"
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "1/11 (alloc)",
percentage = 9
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "9/11 (proc_macro)",
percentage = 81
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "report",
message = "10/11 (xx)",
percentage = 90
}
}
[TRACE][2021-11-05 12:53:10] .../lua/vim/lsp.lua:696 "notification" "$/progress" {
token = "rustAnalyzer/Indexing",
value = {
kind = "end"
}
}
[DEBUG][2021-11-05 12:53:11] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "textDocument/publishDiagnostics",
params = {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[TRACE][2021-11-05 12:53:11] .../lua/vim/lsp.lua:696 "notification" "textDocument/publishDiagnostics" {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
[TRACE][2021-11-05 12:53:11] ...lsp/handlers.lua:432 "default_handler" "textDocument/publishDiagnostics" {
ctx = '{\n client_id = 1,\n method = "textDocument/publishDiagnostics"\n}',
result = {
diagnostics = { {
code = "dead_code",
message = "function is never used: `main`\n`#[warn(dead_code)]` on by default",
range = {
end = {
character = 7,
line = 8
},
start = {
character = 3,
line = 8
}
},
severity = 2,
source = "rustc",
tags = { 1 }
} },
uri = "file:///tmp/xx/src/lib.rs",
version = 0
}
}
[DEBUG][2021-11-05 12:53:14] .../lua/vim/lsp.lua:919 "LSP[rust_analyzer]" "client.request" 1 "textDocument/completion" {
context = {
triggerKind = 1
},
position = {
character = 4,
line = 9
},
textDocument = {
uri = "file:///tmp/xx/src/lib.rs"
}
} <function 1> 1
[DEBUG][2021-11-05 12:53:14] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 3,
jsonrpc = "2.0",
method = "textDocument/completion",
params = {
context = {
triggerKind = 1
},
position = {
character = 4,
line = 9
},
textDocument = {
uri = "file:///tmp/xx/src/lib.rs"
}
}
}
[DEBUG][2021-11-05 12:53:14] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 3,
jsonrpc = "2.0",
result = {
isIncomplete = true,
items = { {
additionalTextEdits = {},
deprecated = false,
filterText = "pub(crate)",
kind = 14,
label = "pub(crate)",
sortText = "ffffffff",
textEdit = {
newText = "pub(crate)",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "pub(super)",
kind = 14,
label = "pub(super)",
sortText = "ffffffff",
textEdit = {
newText = "pub(super)",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "pub",
kind = 14,
label = "pub",
sortText = "ffffffff",
textEdit = {
newText = "pub",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "unsafe",
kind = 14,
label = "unsafe",
sortText = "ffffffff",
textEdit = {
newText = "unsafe",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "fn",
kind = 14,
label = "fn",
sortText = "ffffffff",
textEdit = {
newText = "fn",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "const",
kind = 14,
label = "const",
sortText = "ffffffff",
textEdit = {
newText = "const",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "type",
kind = 14,
label = "type",
sortText = "ffffffff",
textEdit = {
newText = "type",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "impl",
kind = 14,
label = "impl",
sortText = "ffffffff",
textEdit = {
newText = "impl",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "extern",
kind = 14,
label = "extern",
sortText = "ffffffff",
textEdit = {
newText = "extern",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "use",
kind = 14,
label = "use",
sortText = "ffffffff",
textEdit = {
newText = "use",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "trait",
kind = 14,
label = "trait",
sortText = "ffffffff",
textEdit = {
newText = "trait",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "static",
kind = 14,
label = "static",
sortText = "ffffffff",
textEdit = {
newText = "static",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "mod",
kind = 14,
label = "mod",
sortText = "ffffffff",
textEdit = {
newText = "mod",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "enum",
kind = 14,
label = "enum",
sortText = "ffffffff",
textEdit = {
newText = "enum",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "struct",
kind = 14,
label = "struct",
sortText = "ffffffff",
textEdit = {
newText = "struct",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "union",
kind = 14,
label = "union",
sortText = "ffffffff",
textEdit = {
newText = "union",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "self",
kind = 14,
label = "self",
sortText = "ffffffff",
textEdit = {
newText = "self",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "super",
kind = 14,
label = "super",
sortText = "ffffffff",
textEdit = {
newText = "super",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "crate",
kind = 14,
label = "crate",
sortText = "ffffffff",
textEdit = {
newText = "crate",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
filterText = "tests",
kind = 9,
label = "tests",
sortText = "ffffffff",
textEdit = {
newText = "tests",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! is_aarch64_feature_detected",
documentation = {
kind = "markdown",
value = "Prevents compilation if `is_aarch64_feature_detected` is used somewhere else\nthan `aarch64` targets."
},
filterText = "is_aarch64_feature_detected!",
kind = 2,
label = "is_aarch64_feature_detected!",
sortText = "ffffffff",
textEdit = {
newText = "is_aarch64_feature_detected!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! panic",
filterText = "panic!",
kind = 2,
label = "panic!",
sortText = "ffffffff",
textEdit = {
newText = "panic!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! debug_assert_eq",
documentation = {
kind = "markdown",
value = "Asserts that two expressions are equal to each other.\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nUnlike [`assert_eq!`], `debug_assert_eq!` statements are only enabled in non\noptimized builds by default. An optimized build will not execute\n`debug_assert_eq!` statements unless `-C debug-assertions` is passed to the\ncompiler. This makes `debug_assert_eq!` useful for checks that are too\nexpensive to be present in a release build but may be helpful during\ndevelopment. The result of expanding `debug_assert_eq!` is always type checked.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 1 + 2;\ndebug_assert_eq!(a, b);\n```"
},
filterText = "debug_assert_eq!",
kind = 2,
label = "debug_assert_eq!",
sortText = "ffffffff",
textEdit = {
newText = "debug_assert_eq!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! stringify",
documentation = {
kind = "markdown",
value = "Stringifies its arguments.\n\nThis macro will yield an expression of type `&'static str` which is the\nstringification of all the tokens passed to the macro. No restrictions\nare placed on the syntax of the macro invocation itself.\n\nNote that the expanded results of the input tokens may change in the\nfuture. You should be careful if you rely on the output.\n\n# Examples\n\n```rust\nlet one_plus_one = stringify!(1 + 1);\nassert_eq!(one_plus_one, \"1 + 1\");\n```"
},
filterText = "stringify!",
kind = 2,
label = "stringify!",
sortText = "ffffffff",
textEdit = {
newText = "stringify!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! concat",
documentation = {
kind = "markdown",
value = "Concatenates literals into a static string slice.\n\nThis macro takes any number of comma-separated literals, yielding an\nexpression of type `&'static str` which represents all of the literals\nconcatenated left-to-right.\n\nInteger and floating point literals are stringified in order to be\nconcatenated.\n\n# Examples\n\n```rust\nlet s = concat!(\"test\", 10, 'b', true);\nassert_eq!(s, \"test10btrue\");\n```"
},
filterText = "concat!",
kind = 2,
label = "concat!",
sortText = "ffffffff",
textEdit = {
newText = "concat!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! format",
documentation = {
kind = "markdown",
value = 'Creates a `String` using interpolation of runtime expressions.\n\nThe first argument `format!` receives is a format string. This must be a string\nliteral. The power of the formatting string is in the `{}`s contained.\n\nAdditional parameters passed to `format!` replace the `{}`s within the\nformatting string in the order given unless named or positional parameters\nare used; see [`std::fmt`] for more information.\n\nA common use for `format!` is concatenation and interpolation of strings.\nThe same convention is used with [`print!`] and [`write!`] macros,\ndepending on the intended destination of the string.\n\nTo convert a single value to a string, use the [`to_string`] method. This\nwill use the [`Display`] formatting trait.\n\n[`std::fmt`]: ../std/fmt/index.html\n[`print!`]: ../std/macro.print.html\n[`write!`]: core::write\n[`to_string`]: crate::string::ToString\n[`Display`]: core::fmt::Display\n\n# Panics\n\n`format!` panics if a formatting trait implementation returns an error.\nThis indicates an incorrect implementation\nsince `fmt::Write for String` never returns an error itself.\n\n# Examples\n\n```rust\nformat!("test");\nformat!("hello {}", "world!");\nformat!("x = {}, y = {y}", 10, y = 30);\n```'
},
filterText = "format!",
kind = 2,
label = "format!",
sortText = "ffffffff",
textEdit = {
newText = "format!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! log_syntax",
documentation = {
kind = "markdown",
value = "Prints passed tokens into the standard output."
},
filterText = "log_syntax!",
kind = 2,
label = "log_syntax!",
sortText = "ffffffff",
textEdit = {
newText = "log_syntax!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! include_str",
documentation = {
kind = "markdown",
value = "Includes a UTF-8 encoded file as a string.\n\nThe file is located relative to the current file (similarly to how\nmodules are found). The provided path is interpreted in a platform-specific\nway at compile time. So, for instance, an invocation with a Windows path\ncontaining backslashes `\\` would not compile correctly on Unix.\n\nThis macro will yield an expression of type `&'static str` which is the\ncontents of the file.\n\n# Examples\n\nAssume there are two files in the same directory with the following\ncontents:\n\nFile 'spanish.in':\n\n```text\nadiós\n```\n\nFile 'main.rs':\n\n```rust\nfn main() {\n let my_str = include_str!(\"spanish.in\");\n assert_eq!(my_str, \"adiós\\n\");\n print!(\"{}\", my_str);\n}\n```\n\nCompiling 'main.rs' and running the resulting binary will print \"adiós\"."
},
filterText = "include_str!",
kind = 2,
label = "include_str!",
sortText = "ffffffff",
textEdit = {
newText = "include_str!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! dbg",
documentation = {
kind = "markdown",
value = "Prints and returns the value of a given expression for quick and dirty\ndebugging.\n\nAn example:\n\n```rust\nlet a = 2;\nlet b = dbg!(a * 2) + 1;\n// ^-- prints: [src/main.rs:2] a * 2 = 4\nassert_eq!(b, 5);\n```\n\nThe macro works by using the `Debug` implementation of the type of\nthe given expression to print the value to [stderr] along with the\nsource location of the macro invocation as well as the source code\nof the expression.\n\nInvoking the macro on an expression moves and takes ownership of it\nbefore returning the evaluated expression unchanged. If the type\nof the expression does not implement `Copy` and you don't want\nto give up ownership, you can instead borrow with `dbg!(&expr)`\nfor some expression `expr`.\n\nThe `dbg!` macro works exactly the same in release builds.\nThis is useful when debugging issues that only occur in release\nbuilds or when debugging in release mode is significantly faster.\n\nNote that the macro is intended as a debugging tool and therefore you\nshould avoid having uses of it in version control for long periods\n(other than in tests and similar).\nDebug output from production code is better done with other facilities\nsuch as the [`debug!`] macro from the [`log`] crate.\n\n# Stability\n\nThe exact output printed by this macro should not be relied upon\nand is subject to future changes.\n\n# Panics\n\nPanics if writing to `io::stderr` fails.\n\n# Further examples\n\nWith a method call:\n\n```rust\nfn foo(n: usize) {\n if let Some(_) = dbg!(n.checked_sub(4)) {\n // ...\n }\n}\n\nfoo(3)\n```\n\nThis prints to [stderr]:\n\n```text,ignore\n[src/main.rs:4] n.checked_sub(4) = None\n```\n\nNaive factorial implementation:\n\n```rust\nfn factorial(n: u32) -> u32 {\n if dbg!(n <= 1) {\n dbg!(1)\n } else {\n dbg!(n * factorial(n - 1))\n }\n}\n\ndbg!(factorial(4));\n```\n\nThis prints to [stderr]:\n\n```text,ignore\n[src/main.rs:3] n <= 1 = false\n[src/main.rs:3] n <= 1 = false\n[src/main.rs:3] n <= 1 = false\n[src/main.rs:3] n <= 1 = true\n[src/main.rs:4] 1 = 1\n[src/main.rs:5] n * factorial(n - 1) = 2\n[src/main.rs:5] n * factorial(n - 1) = 6\n[src/main.rs:5] n * factorial(n - 1) = 24\n[src/main.rs:11] factorial(4) = 24\n```\n\nThe `dbg!(..)` macro moves the input:\n\n```rust\n/// A wrapper around `usize` which importantly is not Copyable.\n#[derive(Debug)]\nstruct NoCopy(usize);\n\nlet a = NoCopy(42);\nlet _ = dbg!(a); // <-- `a` is moved here.\nlet _ = dbg!(a); // <-- `a` is moved again; error!\n```\n\nYou can also use `dbg!()` without a value to just print the\nfile and line whenever it's reached.\n\nFinally, if you want to `dbg!(..)` multiple values, it will treat them as\na tuple (and return it, too):\n\n```rust\nassert_eq!(dbg!(1usize, 2u32), (1, 2));\n```\n\nHowever, a single argument with a trailing comma will still not be treated\nas a tuple, following the convention of ignoring trailing commas in macro\ninvocations. You can use a 1-tuple directly if you need one:\n\n```rust\nassert_eq!(1, dbg!(1u32,)); // trailing comma ignored\nassert_eq!((1,), dbg!((1u32,))); // 1-tuple\n```\n\n[stderr]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)\n[`debug!`]: https://docs.rs/log/*/log/macro.debug.html\n[`log`]: https://crates.io/crates/log"
},
filterText = "dbg!",
kind = 2,
label = "dbg!",
sortText = "ffffffff",
textEdit = {
newText = "dbg!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! assert_ne",
documentation = {
kind = "markdown",
value = 'Asserts that two expressions are not equal to each other (using [`PartialEq`]).\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nLike [`assert!`], this macro has a second form, where a custom\npanic message can be provided.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 2;\nassert_ne!(a, b);\n\nassert_ne!(a, b, "we are testing that the values are not equal");\n```'
},
filterText = "assert_ne!",
kind = 2,
label = "assert_ne!",
sortText = "ffffffff",
textEdit = {
newText = "assert_ne!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! vec",
documentation = {
kind = "markdown",
value = "Creates a [`Vec`] containing the arguments.\n\n`vec!` allows `Vec`s to be defined with the same syntax as array expressions.\nThere are two forms of this macro:\n\n- Create a [`Vec`] containing a given list of elements:\n\n```rust\nlet v = vec![1, 2, 3];\nassert_eq!(v[0], 1);\nassert_eq!(v[1], 2);\nassert_eq!(v[2], 3);\n```\n\n- Create a [`Vec`] from a given element and size:\n\n```rust\nlet v = vec![1; 3];\nassert_eq!(v, [1, 1, 1]);\n```\n\nNote that unlike array expressions this syntax supports all elements\nwhich implement [`Clone`] and the number of elements doesn't have to be\na constant.\n\nThis will use `clone` to duplicate an expression, so one should be careful\nusing this with types having a nonstandard `Clone` implementation. For\nexample, `vec![Rc::new(1); 5]` will create a vector of five references\nto the same boxed integer value, not five references pointing to independently\nboxed integers.\n\nAlso, note that `vec![expr; 0]` is allowed, and produces an empty vector.\nThis will still evaluate `expr`, however, and immediately drop the resulting value, so\nbe mindful of side effects.\n\n[`Vec`]: crate::vec::Vec"
},
filterText = "vec!",
kind = 2,
label = "vec!",
sortText = "ffffffff",
textEdit = {
newText = "vec!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! include",
documentation = {
kind = "markdown",
value = "Parses a file as an expression or an item according to the context.\n\nThe file is located relative to the current file (similarly to how\nmodules are found). The provided path is interpreted in a platform-specific\nway at compile time. So, for instance, an invocation with a Windows path\ncontaining backslashes `\\` would not compile correctly on Unix.\n\nUsing this macro is often a bad idea, because if the file is\nparsed as an expression, it is going to be placed in the\nsurrounding code unhygienically. This could result in variables\nor functions being different from what the file expected if\nthere are variables or functions that have the same name in\nthe current file.\n\n# Examples\n\nAssume there are two files in the same directory with the following\ncontents:\n\nFile 'monkeys.in':\n\n```rust\n['🙈', '🙊', '🙉']\n .iter()\n .cycle()\n .take(6)\n .collect::<String>()\n```\n\nFile 'main.rs':\n\n```rust\nfn main() {\n let my_string = include!(\"monkeys.in\");\n assert_eq!(\"🙈🙊🙉🙈🙊🙉\", my_string);\n println!(\"{}\", my_string);\n}\n```\n\nCompiling 'main.rs' and running the resulting binary will print\n\"🙈🙊🙉🙈🙊🙉\"."
},
filterText = "include!",
kind = 2,
label = "include!",
sortText = "ffffffff",
textEdit = {
newText = "include!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! print",
documentation = {
kind = "markdown",
value = 'Prints to the standard output.\n\nEquivalent to the [`println!`] macro except that a newline is not printed at\nthe end of the message.\n\nNote that stdout is frequently line-buffered by default so it may be\nnecessary to use [`io::stdout().flush()`][flush] to ensure the output is emitted\nimmediately.\n\nUse `print!` only for the primary output of your program. Use\n[`eprint!`] instead to print error and progress messages.\n\n[flush]: crate::io::Write::flush\n\n# Panics\n\nPanics if writing to `io::stdout()` fails.\n\n# Examples\n\n```rust\nuse std::io::{self, Write};\n\nprint!("this ");\nprint!("will ");\nprint!("be ");\nprint!("on ");\nprint!("the ");\nprint!("same ");\nprint!("line ");\n\nio::stdout().flush().unwrap();\n\nprint!("this string has a newline, why not choose println! instead?\\n");\n\nio::stdout().flush().unwrap();\n```'
},
filterText = "print!",
kind = 2,
label = "print!",
sortText = "ffffffff",
textEdit = {
newText = "print!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! concat_idents",
documentation = {
kind = "markdown",
value = 'Concatenates identifiers into one identifier.\n\nThis macro takes any number of comma-separated identifiers, and\nconcatenates them all into one, yielding an expression which is a new\nidentifier. Note that hygiene makes it such that this macro cannot\ncapture local variables. Also, as a general rule, macros are only\nallowed in item, statement or expression position. That means while\nyou may use this macro for referring to existing variables, functions or\nmodules etc, you cannot define a new one with it.\n\n# Examples\n\n```rust\n#![feature(concat_idents)]\n\nfn foobar() -> u32 { 23 }\n\nlet f = concat_idents!(foo, bar);\nprintln!("{}", f());\n\n// fn concat_idents!(new, fun, name) { } // not usable in this way!\n```'
},
filterText = "concat_idents!",
kind = 2,
label = "concat_idents!",
sortText = "ffffffff",
textEdit = {
newText = "concat_idents!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! write",
documentation = {
kind = "markdown",
value = "Writes formatted data into a buffer.\n\nThis macro accepts a 'writer', a format string, and a list of arguments. Arguments will be\nformatted according to the specified format string and the result will be passed to the writer.\nThe writer may be any value with a `write_fmt` method; generally this comes from an\nimplementation of either the [`fmt::Write`] or the [`io::Write`] trait. The macro\nreturns whatever the `write_fmt` method returns; commonly a [`fmt::Result`], or an\n[`io::Result`].\n\nSee [`std::fmt`] for more information on the format string syntax.\n\n[`std::fmt`]: ../std/fmt/index.html\n[`fmt::Write`]: crate::fmt::Write\n[`io::Write`]: ../std/io/trait.Write.html\n[`fmt::Result`]: crate::fmt::Result\n[`io::Result`]: ../std/io/type.Result.html\n\n# Examples\n\n```rust\nuse std::io::Write;\n\nfn main() -> std::io::Result<()> {\n let mut w = Vec::new();\n write!(&mut w, \"test\")?;\n write!(&mut w, \"formatted {}\", \"arguments\")?;\n\n assert_eq!(w, b\"testformatted arguments\");\n Ok(())\n}\n```\n\nA module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects\nimplementing either, as objects do not typically implement both. However, the module must\nimport the traits qualified so their names do not conflict:\n\n```rust\nuse std::fmt::Write as FmtWrite;\nuse std::io::Write as IoWrite;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n let mut s = String::new();\n let mut v = Vec::new();\n\n write!(&mut s, \"{} {}\", \"abc\", 123)?; // uses fmt::Write::write_fmt\n write!(&mut v, \"s = {:?}\", s)?; // uses io::Write::write_fmt\n assert_eq!(v, b\"s = \\\"abc 123\\\"\");\n Ok(())\n}\n```\n\nNote: This macro can be used in `no_std` setups as well.\nIn a `no_std` setup you are responsible for the implementation details of the components.\n\n```rust\nuse core::fmt::Write;\n\nstruct Example;\n\nimpl Write for Example {\n fn write_str(&mut self, _s: &str) -> core::fmt::Result {\n unimplemented!();\n }\n}\n\nlet mut m = Example{};\nwrite!(&mut m, \"Hello World\").expect(\"Not written\");\n```"
},
filterText = "write!",
kind = 2,
label = "write!",
sortText = "ffffffff",
textEdit = {
newText = "write!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! is_powerpc_feature_detected",
documentation = {
kind = "markdown",
value = "Prevents compilation if `is_powerpc_feature_detected` is used somewhere else\nthan `PowerPC` targets."
},
filterText = "is_powerpc_feature_detected!",
kind = 2,
label = "is_powerpc_feature_detected!",
sortText = "ffffffff",
textEdit = {
newText = "is_powerpc_feature_detected!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! is_powerpc64_feature_detected",
documentation = {
kind = "markdown",
value = "Prevents compilation if `is_powerpc64_feature_detected` is used somewhere\nelse than `PowerPC64` targets."
},
filterText = "is_powerpc64_feature_detected!",
kind = 2,
label = "is_powerpc64_feature_detected!",
sortText = "ffffffff",
textEdit = {
newText = "is_powerpc64_feature_detected!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! line",
documentation = {
kind = "markdown",
value = 'Expands to the line number on which it was invoked.\n\nWith [`column!`] and [`file!`], these macros provide debugging information for\ndevelopers about the location within the source.\n\nThe expanded expression has type `u32` and is 1-based, so the first line\nin each file evaluates to 1, the second to 2, etc. This is consistent\nwith error messages by common compilers or popular editors.\nThe returned line is *not necessarily* the line of the `line!` invocation itself,\nbut rather the first macro invocation leading up to the invocation\nof the `line!` macro.\n\n# Examples\n\n```rust\nlet current_line = line!();\nprintln!("defined on line: {}", current_line);\n```'
},
filterText = "line!",
kind = 2,
label = "line!",
sortText = "ffffffff",
textEdit = {
newText = "line!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! env",
documentation = {
kind = "markdown",
value = "Inspects an environment variable at compile time.\n\nThis macro will expand to the value of the named environment variable at\ncompile time, yielding an expression of type `&'static str`.\n\nIf the environment variable is not defined, then a compilation error\nwill be emitted. To not emit a compile error, use the [`option_env!`]\nmacro instead.\n\n# Examples\n\n```rust\nlet path: &'static str = env!(\"PATH\");\nprintln!(\"the $PATH variable at the time of compiling was: {}\", path);\n```\n\nYou can customize the error message by passing a string as the second\nparameter:\n\n```rust\nlet doc: &'static str = env!(\"documentation\", \"what's that?!\");\n```\n\nIf the `documentation` environment variable is not defined, you'll get\nthe following error:\n\n```text\nerror: what's that?!\n```"
},
filterText = "env!",
kind = 2,
label = "env!",
sortText = "ffffffff",
textEdit = {
newText = "env!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! debug_assert",
documentation = {
kind = "markdown",
value = "Asserts that a boolean expression is `true` at runtime.\n\nThis will invoke the [`panic!`] macro if the provided expression cannot be\nevaluated to `true` at runtime.\n\nLike [`assert!`], this macro also has a second version, where a custom panic\nmessage can be provided.\n\n# Uses\n\nUnlike [`assert!`], `debug_assert!` statements are only enabled in non\noptimized builds by default. An optimized build will not execute\n`debug_assert!` statements unless `-C debug-assertions` is passed to the\ncompiler. This makes `debug_assert!` useful for checks that are too\nexpensive to be present in a release build but may be helpful during\ndevelopment. The result of expanding `debug_assert!` is always type checked.\n\nAn unchecked assertion allows a program in an inconsistent state to keep\nrunning, which might have unexpected consequences but does not introduce\nunsafety as long as this only happens in safe code. The performance cost\nof assertions, however, is not measurable in general. Replacing [`assert!`]\nwith `debug_assert!` is thus only encouraged after thorough profiling, and\nmore importantly, only in safe code!\n\n# Examples\n\n```rust\n// the panic message for these assertions is the stringified value of the\n// expression given.\ndebug_assert!(true);\n\nfn some_expensive_computation() -> bool { true } // a very simple function\ndebug_assert!(some_expensive_computation());\n\n// assert with a custom message\nlet x = true;\ndebug_assert!(x, \"x wasn't true!\");\n\nlet a = 3; let b = 27;\ndebug_assert!(a + b == 30, \"a = {}, b = {}\", a, b);\n```"
},
filterText = "debug_assert!",
kind = 2,
label = "debug_assert!",
sortText = "ffffffff",
textEdit = {
newText = "debug_assert!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! const_format_args",
documentation = {
kind = "markdown",
value = "Same as `format_args`, but can be used in some const contexts.\n\nThis macro is used by the panic macros for the `const_panic` feature.\n\nThis macro will be removed once `format_args` is allowed in const contexts."
},
filterText = "const_format_args!",
kind = 2,
label = "const_format_args!",
sortText = "ffffffff",
textEdit = {
newText = "const_format_args!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! include_bytes",
documentation = {
kind = "markdown",
value = "Includes a file as a reference to a byte array.\n\nThe file is located relative to the current file (similarly to how\nmodules are found). The provided path is interpreted in a platform-specific\nway at compile time. So, for instance, an invocation with a Windows path\ncontaining backslashes `\\` would not compile correctly on Unix.\n\nThis macro will yield an expression of type `&'static [u8; N]` which is\nthe contents of the file.\n\n# Examples\n\nAssume there are two files in the same directory with the following\ncontents:\n\nFile 'spanish.in':\n\n```text\nadiós\n```\n\nFile 'main.rs':\n\n```rust\nfn main() {\n let bytes = include_bytes!(\"spanish.in\");\n assert_eq!(bytes, b\"adi\\xc3\\xb3s\\n\");\n print!(\"{}\", String::from_utf8_lossy(bytes));\n}\n```\n\nCompiling 'main.rs' and running the resulting binary will print \"adiós\"."
},
filterText = "include_bytes!",
kind = 2,
label = "include_bytes!",
sortText = "ffffffff",
textEdit = {
newText = "include_bytes!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! thread_local",
documentation = {
kind = "markdown",
value = "Declare a new thread local storage key of type [`std::thread::LocalKey`].\n\n# Syntax\n\nThe macro wraps any number of static declarations and makes them thread local.\nPublicity and attributes for each static are allowed. Example:\n\n```rust\nuse std::cell::RefCell;\nthread_local! {\n pub static FOO: RefCell<u32> = RefCell::new(1);\n\n #[allow(unused)]\n static BAR: RefCell<f32> = RefCell::new(1.0);\n}\n```\n\nSee [`LocalKey` documentation][`std::thread::LocalKey`] for more\ninformation.\n\n[`std::thread::LocalKey`]: crate::thread::LocalKey"
},
filterText = "thread_local!",
kind = 2,
label = "thread_local!",
sortText = "ffffffff",
textEdit = {
newText = "thread_local!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! file",
documentation = {
kind = "markdown",
value = "Expands to the file name in which it was invoked.\n\nWith [`line!`] and [`column!`], these macros provide debugging information for\ndevelopers about the location within the source.\n\nThe expanded expression has type `&'static str`, and the returned file\nis not the invocation of the `file!` macro itself, but rather the\nfirst macro invocation leading up to the invocation of the `file!`\nmacro.\n\n# Examples\n\n```rust\nlet this_file = file!();\nprintln!(\"defined in file: {}\", this_file);\n```"
},
filterText = "file!",
kind = 2,
label = "file!",
sortText = "ffffffff",
textEdit = {
newText = "file!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = true,
detail = "#[macro_export] macro_rules! r#try",
documentation = {
kind = "markdown",
value = 'Unwraps a result or propagates its error.\n\nThe `?` operator was added to replace `try!` and should be used instead.\nFurthermore, `try` is a reserved word in Rust 2018, so if you must use\nit, you will need to use the [raw-identifier syntax][ris]: `r#try`.\n\n[ris]: https://doc.rust-lang.org/nightly/rust-by-example/compatibility/raw_identifiers.html\n\n`try!` matches the given [`Result`]. In case of the `Ok` variant, the\nexpression has the value of the wrapped value.\n\nIn case of the `Err` variant, it retrieves the inner error. `try!` then\nperforms conversion using `From`. This provides automatic conversion\nbetween specialized errors and more general ones. The resulting\nerror is then immediately returned.\n\nBecause of the early return, `try!` can only be used in functions that\nreturn [`Result`].\n\n# Examples\n\n```rust\nuse std::io;\nuse std::fs::File;\nuse std::io::prelude::*;\n\nenum MyError {\n FileWriteError\n}\n\nimpl From<io::Error> for MyError {\n fn from(e: io::Error) -> MyError {\n MyError::FileWriteError\n }\n}\n\n// The preferred method of quick returning Errors\nfn write_to_file_question() -> Result<(), MyError> {\n let mut file = File::create("my_best_friends.txt")?;\n file.write_all(b"This is a list of my best friends.")?;\n Ok(())\n}\n\n// The previous method of quick returning Errors\nfn write_to_file_using_try() -> Result<(), MyError> {\n let mut file = r#try!(File::create("my_best_friends.txt"));\n r#try!(file.write_all(b"This is a list of my best friends."));\n Ok(())\n}\n\n// This is equivalent to:\nfn write_to_file_using_match() -> Result<(), MyError> {\n let mut file = r#try!(File::create("my_best_friends.txt"));\n match file.write_all(b"This is a list of my best friends.") {\n Ok(v) => v,\n Err(e) => return Err(From::from(e)),\n }\n Ok(())\n}\n```'
},
filterText = "try!",
kind = 2,
label = "try!",
sortText = "ffffffff",
tags = { 1 },
textEdit = {
newText = "try!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! assert",
documentation = {
kind = "markdown",
value = "Asserts that a boolean expression is `true` at runtime.\n\nThis will invoke the [`panic!`] macro if the provided expression cannot be\nevaluated to `true` at runtime.\n\n# Uses\n\nAssertions are always checked in both debug and release builds, and cannot\nbe disabled. See [`debug_assert!`] for assertions that are not enabled in\nrelease builds by default.\n\nUnsafe code may rely on `assert!` to enforce run-time invariants that, if\nviolated could lead to unsafety.\n\nOther use-cases of `assert!` include testing and enforcing run-time\ninvariants in safe code (whose violation cannot result in unsafety).\n\n# Custom Messages\n\nThis macro has a second form, where a custom panic message can\nbe provided with or without arguments for formatting. See [`std::fmt`]\nfor syntax for this form. Expressions used as format arguments will only\nbe evaluated if the assertion fails.\n\n[`std::fmt`]: ../std/fmt/index.html\n\n# Examples\n\n```rust\n// the panic message for these assertions is the stringified value of the\n// expression given.\nassert!(true);\n\nfn some_computation() -> bool { true } // a very simple function\n\nassert!(some_computation());\n\n// assert with a custom message\nlet x = true;\nassert!(x, \"x wasn't true!\");\n\nlet a = 3; let b = 27;\nassert!(a + b == 30, \"a = {}, b = {}\", a, b);\n```"
},
filterText = "assert!",
kind = 2,
label = "assert!",
sortText = "ffffffff",
textEdit = {
newText = "assert!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! is_arm_feature_detected",
documentation = {
kind = "markdown",
value = "Prevents compilation if `is_arm_feature_detected` is used somewhere else\nthan `ARM` targets."
},
filterText = "is_arm_feature_detected!",
kind = 2,
label = "is_arm_feature_detected!",
sortText = "ffffffff",
textEdit = {
newText = "is_arm_feature_detected!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = true,
detail = "#[macro_export] macro_rules! llvm_asm",
documentation = {
kind = "markdown",
value = "LLVM-style inline assembly.\n\nRead the [unstable book] for the usage.\n\n[unstable book]: ../unstable-book/library-features/llvm-asm.html"
},
filterText = "llvm_asm!",
kind = 2,
label = "llvm_asm!",
sortText = "ffffffff",
tags = { 1 },
textEdit = {
newText = "llvm_asm!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! column",
documentation = {
kind = "markdown",
value = 'Expands to the column number at which it was invoked.\n\nWith [`line!`] and [`file!`], these macros provide debugging information for\ndevelopers about the location within the source.\n\nThe expanded expression has type `u32` and is 1-based, so the first column\nin each line evaluates to 1, the second to 2, etc. This is consistent\nwith error messages by common compilers or popular editors.\nThe returned column is *not necessarily* the line of the `column!` invocation itself,\nbut rather the first macro invocation leading up to the invocation\nof the `column!` macro.\n\n# Examples\n\n```rust\nlet current_col = column!();\nprintln!("defined on column: {}", current_col);\n```'
},
filterText = "column!",
kind = 2,
label = "column!",
sortText = "ffffffff",
textEdit = {
newText = "column!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! unreachable",
documentation = {
kind = "markdown",
value = "Indicates unreachable code.\n\nThis is useful any time that the compiler can't determine that some code is unreachable. For\nexample:\n\n* Match arms with guard conditions.\n* Loops that dynamically terminate.\n* Iterators that dynamically terminate.\n\nIf the determination that the code is unreachable proves incorrect, the\nprogram immediately terminates with a [`panic!`].\n\nThe unsafe counterpart of this macro is the [`unreachable_unchecked`] function, which\nwill cause undefined behavior if the code is reached.\n\n[`unreachable_unchecked`]: crate::hint::unreachable_unchecked\n\n# Panics\n\nThis will always [`panic!`].\n\n# Examples\n\nMatch arms:\n\n```rust\nfn foo(x: Option<i32>) {\n match x {\n Some(n) if n >= 0 => println!(\"Some(Non-negative)\"),\n Some(n) if n < 0 => println!(\"Some(Negative)\"),\n Some(_) => unreachable!(), // compile error if commented out\n None => println!(\"None\")\n }\n}\n```\n\nIterators:\n\n```rust\nfn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3\n for i in 0.. {\n if 3*i < i { panic!(\"u32 overflow\"); }\n if x < 3*i { return i-1; }\n }\n unreachable!();\n}\n```"
},
filterText = "unreachable!",
kind = 2,
label = "unreachable!",
sortText = "ffffffff",
textEdit = {
newText = "unreachable!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! eprintln",
documentation = {
kind = "markdown",
value = 'Prints to the standard error, with a newline.\n\nEquivalent to the [`println!`] macro, except that output goes to\n[`io::stderr`] instead of [`io::stdout`]. See [`println!`] for\nexample usage.\n\nUse `eprintln!` only for error and progress messages. Use `println!`\ninstead for the primary output of your program.\n\n[`io::stderr`]: crate::io::stderr\n[`io::stdout`]: crate::io::stdout\n\n# Panics\n\nPanics if writing to `io::stderr` fails.\n\n# Examples\n\n```rust\neprintln!("Error: Could not complete task");\n```'
},
filterText = "eprintln!",
kind = 2,
label = "eprintln!",
sortText = "ffffffff",
textEdit = {
newText = "eprintln!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! unimplemented",
documentation = {
kind = "markdown",
value = "Indicates unimplemented code by panicking with a message of \"not implemented\".\n\nThis allows your code to type-check, which is useful if you are prototyping or\nimplementing a trait that requires multiple methods which you don't plan to use all of.\n\nThe difference between `unimplemented!` and [`todo!`] is that while `todo!`\nconveys an intent of implementing the functionality later and the message is \"not yet\nimplemented\", `unimplemented!` makes no such claims. Its message is \"not implemented\".\nAlso some IDEs will mark `todo!`s.\n\n# Panics\n\nThis will always [`panic!`] because `unimplemented!` is just a shorthand for `panic!` with a\nfixed, specific message.\n\nLike `panic!`, this macro has a second form for displaying custom values.\n\n# Examples\n\nSay we have a trait `Foo`:\n\n```rust\ntrait Foo {\n fn bar(&self) -> u8;\n fn baz(&self);\n fn qux(&self) -> Result<u64, ()>;\n}\n```\n\nWe want to implement `Foo` for 'MyStruct', but for some reason it only makes sense\nto implement the `bar()` function. `baz()` and `qux()` will still need to be defined\nin our implementation of `Foo`, but we can use `unimplemented!` in their definitions\nto allow our code to compile.\n\nWe still want to have our program stop running if the unimplemented methods are\nreached.\n\n```rust\nstruct MyStruct;\n\nimpl Foo for MyStruct {\n fn bar(&self) -> u8 {\n 1 + 1\n }\n\n fn baz(&self) {\n // It makes no sense to `baz` a `MyStruct`, so we have no logic here\n // at all.\n // This will display \"thread 'main' panicked at 'not implemented'\".\n unimplemented!();\n }\n\n fn qux(&self) -> Result<u64, ()> {\n // We have some logic here,\n // We can add a message to unimplemented! to display our omission.\n // This will display:\n // \"thread 'main' panicked at 'not implemented: MyStruct isn't quxable'\".\n unimplemented!(\"MyStruct isn't quxable\");\n }\n}\n\nfn main() {\n let s = MyStruct;\n s.bar();\n}\n```"
},
filterText = "unimplemented!",
kind = 2,
label = "unimplemented!",
sortText = "ffffffff",
textEdit = {
newText = "unimplemented!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! cfg",
documentation = {
kind = "markdown",
value = 'Evaluates boolean combinations of configuration flags at compile-time.\n\nIn addition to the `#[cfg]` attribute, this macro is provided to allow\nboolean expression evaluation of configuration flags. This frequently\nleads to less duplicated code.\n\nThe syntax given to this macro is the same syntax as the [`cfg`]\nattribute.\n\n`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true or false. For\nexample, all blocks in an if/else expression need to be valid when `cfg!` is used for\nthe condition, regardless of what `cfg!` is evaluating.\n\n[`cfg`]: ../reference/conditional-compilation.html#the-cfg-attribute\n\n# Examples\n\n```rust\nlet my_directory = if cfg!(windows) {\n "windows-specific-directory"\n} else {\n "unix-directory"\n};\n```'
},
filterText = "cfg!",
kind = 2,
label = "cfg!",
sortText = "ffffffff",
textEdit = {
newText = "cfg!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! todo",
documentation = {
kind = "markdown",
value = "Indicates unfinished code.\n\nThis can be useful if you are prototyping and are just looking to have your\ncode typecheck.\n\nThe difference between [`unimplemented!`] and `todo!` is that while `todo!` conveys\nan intent of implementing the functionality later and the message is \"not yet\nimplemented\", `unimplemented!` makes no such claims. Its message is \"not implemented\".\nAlso some IDEs will mark `todo!`s.\n\n# Panics\n\nThis will always [`panic!`].\n\n# Examples\n\nHere's an example of some in-progress code. We have a trait `Foo`:\n\n```rust\ntrait Foo {\n fn bar(&self);\n fn baz(&self);\n}\n```\n\nWe want to implement `Foo` on one of our types, but we also want to work on\njust `bar()` first. In order for our code to compile, we need to implement\n`baz()`, so we can use `todo!`:\n\n```rust\nstruct MyStruct;\n\nimpl Foo for MyStruct {\n fn bar(&self) {\n // implementation goes here\n }\n\n fn baz(&self) {\n // let's not worry about implementing baz() for now\n todo!();\n }\n}\n\nfn main() {\n let s = MyStruct;\n s.bar();\n\n // we aren't even using baz(), so this is fine.\n}\n```"
},
filterText = "todo!",
kind = 2,
label = "todo!",
sortText = "ffffffff",
textEdit = {
newText = "todo!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! is_mips64_feature_detected",
documentation = {
kind = "markdown",
value = "Prevents compilation if `is_mips64_feature_detected` is used somewhere else\nthan `MIPS64` targets."
},
filterText = "is_mips64_feature_detected!",
kind = 2,
label = "is_mips64_feature_detected!",
sortText = "ffffffff",
textEdit = {
newText = "is_mips64_feature_detected!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! trace_macros",
documentation = {
kind = "markdown",
value = "Enables or disables tracing functionality used for debugging other macros."
},
filterText = "trace_macros!",
kind = 2,
label = "trace_macros!",
sortText = "ffffffff",
textEdit = {
newText = "trace_macros!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! module_path",
documentation = {
kind = "markdown",
value = 'Expands to a string that represents the current module path.\n\nThe current module path can be thought of as the hierarchy of modules\nleading back up to the crate root. The first component of the path\nreturned is the name of the crate currently being compiled.\n\n# Examples\n\n```rust\nmod test {\n pub fn foo() {\n assert!(module_path!().ends_with("test"));\n }\n}\n\ntest::foo();\n```'
},
filterText = "module_path!",
kind = 2,
label = "module_path!",
sortText = "ffffffff",
textEdit = {
newText = "module_path!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! writeln",
documentation = {
kind = "markdown",
value = 'Write formatted data into a buffer, with a newline appended.\n\nOn all platforms, the newline is the LINE FEED character (`\\n`/`U+000A`) alone\n(no additional CARRIAGE RETURN (`\\r`/`U+000D`).\n\nFor more information, see [`write!`]. For information on the format string syntax, see\n[`std::fmt`].\n\n[`std::fmt`]: ../std/fmt/index.html\n\n# Examples\n\n```rust\nuse std::io::{Write, Result};\n\nfn main() -> Result<()> {\n let mut w = Vec::new();\n writeln!(&mut w)?;\n writeln!(&mut w, "test")?;\n writeln!(&mut w, "formatted {}", "arguments")?;\n\n assert_eq!(&w[..], "\\ntest\\nformatted arguments\\n".as_bytes());\n Ok(())\n}\n```\n\nA module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects\nimplementing either, as objects do not typically implement both. However, the module must\nimport the traits qualified so their names do not conflict:\n\n```rust\nuse std::fmt::Write as FmtWrite;\nuse std::io::Write as IoWrite;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n let mut s = String::new();\n let mut v = Vec::new();\n\n writeln!(&mut s, "{} {}", "abc", 123)?; // uses fmt::Write::write_fmt\n writeln!(&mut v, "s = {:?}", s)?; // uses io::Write::write_fmt\n assert_eq!(v, b"s = \\"abc 123\\\\n\\"\\n");\n Ok(())\n}\n```'
},
filterText = "writeln!",
kind = 2,
label = "writeln!",
sortText = "ffffffff",
textEdit = {
newText = "writeln!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! option_env",
documentation = {
kind = "markdown",
value = "Optionally inspects an environment variable at compile time.\n\nIf the named environment variable is present at compile time, this will\nexpand into an expression of type `Option<&'static str>` whose value is\n`Some` of the value of the environment variable. If the environment\nvariable is not present, then this will expand to `None`. See\n[`Option<T>`][Option] for more information on this type.\n\nA compile time error is never emitted when using this macro regardless\nof whether the environment variable is present or not.\n\n# Examples\n\n```rust\nlet key: Option<&'static str> = option_env!(\"SECRET_KEY\");\nprintln!(\"the secret key might be: {:?}\", key);\n```"
},
filterText = "option_env!",
kind = 2,
label = "option_env!",
sortText = "ffffffff",
textEdit = {
newText = "option_env!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! compile_error",
documentation = {
kind = "markdown",
value = "Causes compilation to fail with the given error message when encountered.\n\nThis macro should be used when a crate uses a conditional compilation strategy to provide\nbetter error messages for erroneous conditions. It's the compiler-level form of [`panic!`],\nbut emits an error during *compilation* rather than at *runtime*.\n\n# Examples\n\nTwo such examples are macros and `#[cfg]` environments.\n\nEmit better compiler error if a macro is passed invalid values. Without the final branch,\nthe compiler would still emit an error, but the error's message would not mention the two\nvalid values.\n\n```rust\nmacro_rules! give_me_foo_or_bar {\n (foo) => {};\n (bar) => {};\n ($x:ident) => {\n compile_error!(\"This macro only accepts `foo` or `bar`\");\n }\n}\n\ngive_me_foo_or_bar!(neither);\n// ^ will fail at compile time with message \"This macro only accepts `foo` or `bar`\"\n```\n\nEmit compiler error if one of a number of features isn't available.\n\n```rust\n#[cfg(not(any(feature = \"foo\", feature = \"bar\")))]\ncompile_error!(\"Either feature \\\"foo\\\" or \\\"bar\\\" must be enabled for this crate.\");\n```"
},
filterText = "compile_error!",
kind = 2,
label = "compile_error!",
sortText = "ffffffff",
textEdit = {
newText = "compile_error!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! matches",
documentation = {
kind = "markdown",
value = "Returns whether the given expression matches any of the given patterns.\n\nLike in a `match` expression, the pattern can be optionally followed by `if`\nand a guard expression that has access to names bound by the pattern.\n\n# Examples\n\n```rust\nlet foo = 'f';\nassert!(matches!(foo, 'A'..='Z' | 'a'..='z'));\n\nlet bar = Some(4);\nassert!(matches!(bar, Some(x) if x > 2));\n```"
},
filterText = "matches!",
kind = 2,
label = "matches!",
sortText = "ffffffff",
textEdit = {
newText = "matches!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! println",
documentation = {
kind = "markdown",
value = 'Prints to the standard output, with a newline.\n\nOn all platforms, the newline is the LINE FEED character (`\\n`/`U+000A`) alone\n(no additional CARRIAGE RETURN (`\\r`/`U+000D`)).\n\nUse the [`format!`] syntax to write data to the standard output.\nSee [`std::fmt`] for more information.\n\nUse `println!` only for the primary output of your program. Use\n[`eprintln!`] instead to print error and progress messages.\n\n[`std::fmt`]: crate::fmt\n\n# Panics\n\nPanics if writing to [`io::stdout`] fails.\n\n[`io::stdout`]: crate::io::stdout\n\n# Examples\n\n```rust\nprintln!(); // prints just a newline\nprintln!("hello there!");\nprintln!("format {} arguments", "some");\n```'
},
filterText = "println!",
kind = 2,
label = "println!",
sortText = "ffffffff",
textEdit = {
newText = "println!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! assert_eq",
documentation = {
kind = "markdown",
value = 'Asserts that two expressions are equal to each other (using [`PartialEq`]).\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nLike [`assert!`], this macro has a second form, where a custom\npanic message can be provided.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 1 + 2;\nassert_eq!(a, b);\n\nassert_eq!(a, b, "we are testing addition with {} and {}", a, b);\n```'
},
filterText = "assert_eq!",
kind = 2,
label = "assert_eq!",
sortText = "ffffffff",
textEdit = {
newText = "assert_eq!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! is_mips_feature_detected",
documentation = {
kind = "markdown",
value = "Prevents compilation if `is_mips_feature_detected` is used somewhere else\nthan `MIPS` targets."
},
filterText = "is_mips_feature_detected!",
kind = 2,
label = "is_mips_feature_detected!",
sortText = "ffffffff",
textEdit = {
newText = "is_mips_feature_detected!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! format_args",
documentation = {
kind = "markdown",
value = 'Constructs parameters for the other string-formatting macros.\n\nThis macro functions by taking a formatting string literal containing\n`{}` for each additional argument passed. `format_args!` prepares the\nadditional parameters to ensure the output can be interpreted as a string\nand canonicalizes the arguments into a single type. Any value that implements\nthe [`Display`] trait can be passed to `format_args!`, as can any\n[`Debug`] implementation be passed to a `{:?}` within the formatting string.\n\nThis macro produces a value of type [`fmt::Arguments`]. This value can be\npassed to the macros within [`std::fmt`] for performing useful redirection.\nAll other formatting macros ([`format!`], [`write!`], [`println!`], etc) are\nproxied through this one. `format_args!`, unlike its derived macros, avoids\nheap allocations.\n\nYou can use the [`fmt::Arguments`] value that `format_args!` returns\nin `Debug` and `Display` contexts as seen below. The example also shows\nthat `Debug` and `Display` format to the same thing: the interpolated\nformat string in `format_args!`.\n\n```rust\nlet debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));\nlet display = format!("{}", format_args!("{} foo {:?}", 1, 2));\nassert_eq!("1 foo 2", display);\nassert_eq!(display, debug);\n```\n\nFor more information, see the documentation in [`std::fmt`].\n\n[`Display`]: crate::fmt::Display\n[`Debug`]: crate::fmt::Debug\n[`fmt::Arguments`]: crate::fmt::Arguments\n[`std::fmt`]: ../std/fmt/index.html\n[`format!`]: ../std/macro.format.html\n[`println!`]: ../std/macro.println.html\n\n# Examples\n\n```rust\nuse std::fmt;\n\nlet s = fmt::format(format_args!("hello {}", "world"));\nassert_eq!(s, format!("hello {}", "world"));\n```'
},
filterText = "format_args!",
kind = 2,
label = "format_args!",
sortText = "ffffffff",
textEdit = {
newText = "format_args!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! debug_assert_ne",
documentation = {
kind = "markdown",
value = "Asserts that two expressions are not equal to each other.\n\nOn panic, this macro will print the values of the expressions with their\ndebug representations.\n\nUnlike [`assert_ne!`], `debug_assert_ne!` statements are only enabled in non\noptimized builds by default. An optimized build will not execute\n`debug_assert_ne!` statements unless `-C debug-assertions` is passed to the\ncompiler. This makes `debug_assert_ne!` useful for checks that are too\nexpensive to be present in a release build but may be helpful during\ndevelopment. The result of expanding `debug_assert_ne!` is always type checked.\n\n# Examples\n\n```rust\nlet a = 3;\nlet b = 2;\ndebug_assert_ne!(a, b);\n```"
},
filterText = "debug_assert_ne!",
kind = 2,
label = "debug_assert_ne!",
sortText = "ffffffff",
textEdit = {
newText = "debug_assert_ne!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "#[macro_export] macro_rules! eprint",
documentation = {
kind = "markdown",
value = 'Prints to the standard error.\n\nEquivalent to the [`print!`] macro, except that output goes to\n[`io::stderr`] instead of [`io::stdout`]. See [`print!`] for\nexample usage.\n\nUse `eprint!` only for error and progress messages. Use `print!`\ninstead for the primary output of your program.\n\n[`io::stderr`]: crate::io::stderr\n[`io::stdout`]: crate::io::stdout\n\n# Panics\n\nPanics if writing to `io::stderr` fails.\n\n# Examples\n\n```rust\neprint!("Error: Could not complete task");\n```'
},
filterText = "eprint!",
kind = 2,
label = "eprint!",
sortText = "ffffffff",
textEdit = {
newText = "eprint!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
documentation = {
kind = "markdown",
value = "# The Rust core allocation and collections library\n\nThis library provides smart pointers and collections for managing\nheap-allocated values.\n\nThis library, like libcore, normally doesn’t need to be used directly\nsince its contents are re-exported in the [`std` crate](../std/index.html).\nCrates that use the `#![no_std]` attribute however will typically\nnot depend on `std`, so they’d use this crate instead.\n\n## Boxed values\n\nThe [`Box`] type is a smart pointer type. There can only be one owner of a\n[`Box`], and the owner can decide to mutate the contents, which live on the\nheap.\n\nThis type can be sent among threads efficiently as the size of a `Box` value\nis the same as that of a pointer. Tree-like data structures are often built\nwith boxes because each node often has only one owner, the parent.\n\n## Reference counted pointers\n\nThe [`Rc`] type is a non-threadsafe reference-counted pointer type intended\nfor sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and\nonly allows access to `&T`, a shared reference.\n\nThis type is useful when inherited mutability (such as using [`Box`]) is too\nconstraining for an application, and is often paired with the [`Cell`] or\n[`RefCell`] types in order to allow mutation.\n\n## Atomically reference counted pointers\n\nThe [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It\nprovides all the same functionality of [`Rc`], except it requires that the\ncontained type `T` is shareable. Additionally, [`Arc<T>`][`Arc`] is itself\nsendable while [`Rc<T>`][`Rc`] is not.\n\nThis type allows for shared access to the contained data, and is often\npaired with synchronization primitives such as mutexes to allow mutation of\nshared resources.\n\n## Collections\n\nImplementations of the most common general purpose data structures are\ndefined in this library. They are re-exported through the\n[standard collections library](../std/collections/index.html).\n\n## Heap interfaces\n\nThe [`alloc`](alloc/index.html) module defines the low-level interface to the\ndefault global allocator. It is not compatible with the libc allocator API.\n\n[`Arc`]: sync\n[`Box`]: boxed\n[`Cell`]: core::cell\n[`Rc`]: rc\n[`RefCell`]: core::cell"
},
filterText = "alloc",
kind = 9,
label = "alloc",
sortText = "ffffffff",
textEdit = {
newText = "alloc",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
documentation = {
kind = "markdown",
value = "# The Rust Standard Library\n\nThe Rust Standard Library is the foundation of portable Rust software, a\nset of minimal and battle-tested shared abstractions for the [broader Rust\necosystem][crates.io]. It offers core types, like [`Vec<T>`] and\n[`Option<T>`], library-defined [operations on language\nprimitives](#primitives), [standard macros](#macros), [I/O] and\n[multithreading], among [many other things][other].\n\n`std` is available to all Rust crates by default. Therefore, the\nstandard library can be accessed in [`use`] statements through the path\n`std`, as in [`use std::env`].\n\n# How to read this documentation\n\nIf you already know the name of what you are looking for, the fastest way to\nfind it is to use the <a href=\"#\" onclick=\"focusSearchBar();\">search\nbar</a> at the top of the page.\n\nOtherwise, you may want to jump to one of these useful sections:\n\n* [`std::*` modules](#modules)\n* [Primitive types](#primitives)\n* [Standard macros](#macros)\n* [The Rust Prelude]\n\nIf this is your first time, the documentation for the standard library is\nwritten to be casually perused. Clicking on interesting things should\ngenerally lead you to interesting places. Still, there are important bits\nyou don't want to miss, so read on for a tour of the standard library and\nits documentation!\n\nOnce you are familiar with the contents of the standard library you may\nbegin to find the verbosity of the prose distracting. At this stage in your\ndevelopment you may want to press the `[-]` button near the top of the\npage to collapse it into a more skimmable view.\n\nWhile you are looking at that `[-]` button also notice the `[src]`\nbutton. Rust's API documentation comes with the source code and you are\nencouraged to read it. The standard library source is generally high\nquality and a peek behind the curtains is often enlightening.\n\n# What is in the standard library documentation?\n\nFirst of all, The Rust Standard Library is divided into a number of focused\nmodules, [all listed further down this page](#modules). These modules are\nthe bedrock upon which all of Rust is forged, and they have mighty names\nlike [`std::slice`] and [`std::cmp`]. Modules' documentation typically\nincludes an overview of the module along with examples, and are a smart\nplace to start familiarizing yourself with the library.\n\nSecond, implicit methods on [primitive types] are documented here. This can\nbe a source of confusion for two reasons:\n\n1. While primitives are implemented by the compiler, the standard library\n implements methods directly on the primitive types (and it is the only\n library that does so), which are [documented in the section on\n primitives](#primitives).\n2. The standard library exports many modules *with the same name as\n primitive types*. These define additional items related to the primitive\n type, but not the all-important methods.\n\nSo for example there is a [page for the primitive type\n`i32`](primitive::i32) that lists all the methods that can be called on\n32-bit integers (very useful), and there is a [page for the module\n`std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely\nuseful).\n\nNote the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also\ncalled 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually\ncalls to methods on [`str`] and [`[T]`][prim@slice] respectively, via [deref\ncoercions][deref-coercions].\n\nThird, the standard library defines [The Rust Prelude], a small collection\nof items - mostly traits - that are imported into every module of every\ncrate. The traits in the prelude are pervasive, making the prelude\ndocumentation a good entry point to learning about the library.\n\nAnd finally, the standard library exports a number of standard macros, and\n[lists them on this page](#macros) (technically, not all of the standard\nmacros are defined by the standard library - some are defined by the\ncompiler - but they are documented here the same). Like the prelude, the\nstandard macros are imported by default into all crates.\n\n# Contributing changes to the documentation\n\nCheck out the rust contribution guidelines [here](\nhttps://rustc-dev-guide.rust-lang.org/contributing.html#writing-documentation).\nThe source for this documentation can be found on\n[GitHub](https://github.com/rust-lang/rust).\nTo contribute changes, make sure you read the guidelines first, then submit\npull-requests for your suggested changes.\n\nContributions are appreciated! If you see a part of the docs that can be\nimproved, submit a PR, or chat with us first on [Discord][rust-discord]\n#docs.\n\n# A Tour of The Rust Standard Library\n\nThe rest of this crate documentation is dedicated to pointing out notable\nfeatures of The Rust Standard Library.\n\n## Containers and collections\n\nThe [`option`] and [`result`] modules define optional and error-handling\ntypes, [`Option<T>`] and [`Result<T, E>`]. The [`iter`] module defines\nRust's iterator trait, [`Iterator`], which works with the [`for`] loop to\naccess collections.\n\nThe standard library exposes three common ways to deal with contiguous\nregions of memory:\n\n* [`Vec<T>`] - A heap-allocated *vector* that is resizable at runtime.\n* [`[T; N]`][prim@array] - An inline *array* with a fixed size at compile time.\n* [`[T]`][prim@slice] - A dynamically sized *slice* into any other kind of contiguous\n storage, whether heap-allocated or not.\n\nSlices can only be handled through some kind of *pointer*, and as such come\nin many flavors such as:\n\n* `&[T]` - *shared slice*\n* `&mut [T]` - *mutable slice*\n* [`Box<[T]>`][owned slice] - *owned slice*\n\n[`str`], a UTF-8 string slice, is a primitive type, and the standard library\ndefines many methods for it. Rust [`str`]s are typically accessed as\nimmutable references: `&str`. Use the owned [`String`] for building and\nmutating strings.\n\nFor converting to strings use the [`format!`] macro, and for converting from\nstrings use the [`FromStr`] trait.\n\nData may be shared by placing it in a reference-counted box or the [`Rc`]\ntype, and if further contained in a [`Cell`] or [`RefCell`], may be mutated\nas well as shared. Likewise, in a concurrent setting it is common to pair an\natomically-reference-counted box, [`Arc`], with a [`Mutex`] to get the same\neffect.\n\nThe [`collections`] module defines maps, sets, linked lists and other\ntypical collection types, including the common [`HashMap<K, V>`].\n\n## Platform abstractions and I/O\n\nBesides basic data types, the standard library is largely concerned with\nabstracting over differences in common platforms, most notably Windows and\nUnix derivatives.\n\nCommon types of I/O, including [files], [TCP], [UDP], are defined in the\n[`io`], [`fs`], and [`net`] modules.\n\nThe [`thread`] module contains Rust's threading abstractions. [`sync`]\ncontains further primitive shared memory types, including [`atomic`] and\n[`mpsc`], which contains the channel types for message passing.\n\n[I/O]: io\n[`MIN`]: i32::MIN\n[`MAX`]: i32::MAX\n[page for the module `std::i32`]: crate::i32\n[TCP]: net::TcpStream\n[The Rust Prelude]: prelude\n[UDP]: net::UdpSocket\n[`Arc`]: sync::Arc\n[owned slice]: boxed\n[`Cell`]: cell::Cell\n[`FromStr`]: str::FromStr\n[`HashMap<K, V>`]: collections::HashMap\n[`Mutex`]: sync::Mutex\n[`Option<T>`]: option::Option\n[`Rc`]: rc::Rc\n[`RefCell`]: cell::RefCell\n[`Result<T, E>`]: result::Result\n[`Vec<T>`]: vec::Vec\n[`atomic`]: sync::atomic\n[`for`]: ../book/ch03-05-control-flow.html#looping-through-a-collection-with-for\n[`str`]: prim@str\n[`mpsc`]: sync::mpsc\n[`std::cmp`]: cmp\n[`std::slice`]: mod@slice\n[`use std::env`]: env/index.html\n[`use`]: ../book/ch07-02-defining-modules-to-control-scope-and-privacy.html\n[crates.io]: https://crates.io\n[deref-coercions]: ../book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods\n[files]: fs::File\n[multithreading]: thread\n[other]: #what-is-in-the-standard-library-documentation\n[primitive types]: ../book/ch03-02-data-types.html\n[rust-discord]: https://discord.gg/rust-lang\n[array]: prim@array\n[slice]: prim@slice"
},
filterText = "std",
kind = 9,
label = "std",
sortText = "ffffffff",
textEdit = {
newText = "std",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
documentation = {
kind = "markdown",
value = "# The Rust Core Library\n\nThe Rust Core Library is the dependency-free[^free] foundation of [The\nRust Standard Library](../std/index.html). It is the portable glue\nbetween the language and its libraries, defining the intrinsic and\nprimitive building blocks of all Rust code. It links to no\nupstream libraries, no system libraries, and no libc.\n\n[^free]: Strictly speaking, there are some symbols which are needed but\n they aren't always necessary.\n\nThe core library is *minimal*: it isn't even aware of heap allocation,\nnor does it provide concurrency or I/O. These things require\nplatform integration, and this library is platform-agnostic.\n\n# How to use the core library\n\nPlease note that all of these details are currently not considered stable.\n\nThis library is built on the assumption of a few existing symbols:\n\n* `memcpy`, `memcmp`, `memset` - These are core memory routines which are\n often generated by LLVM. Additionally, this library can make explicit\n calls to these functions. Their signatures are the same as found in C.\n These functions are often provided by the system libc, but can also be\n provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).\n\n* `rust_begin_panic` - This function takes four arguments, a\n `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments\n dictate the panic message, the file at which panic was invoked, and the\n line and column inside the file. It is up to consumers of this core\n library to define this panic function; it is only required to never\n return. This requires a `lang` attribute named `panic_impl`.\n\n* `rust_eh_personality` - is used by the failure mechanisms of the\n compiler. This is often mapped to GCC's personality function, but crates\n which do not trigger a panic can be assured that this function is never\n called. The `lang` attribute is called `eh_personality`."
},
filterText = "core",
kind = 9,
label = "core",
sortText = "ffffffff",
textEdit = {
newText = "core",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = true,
detail = "pub macro RustcDecodable",
documentation = {
kind = "markdown",
value = "Unstable implementation detail of the `rustc` compiler, do not use."
},
filterText = "RustcDecodable!",
kind = 2,
label = "RustcDecodable!",
sortText = "ffffffff",
tags = { 1 },
textEdit = {
newText = "RustcDecodable!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = true,
detail = "pub macro RustcEncodable",
documentation = {
kind = "markdown",
value = "Unstable implementation detail of the `rustc` compiler, do not use."
},
filterText = "RustcEncodable!",
kind = 2,
label = "RustcEncodable!",
sortText = "ffffffff",
tags = { 1 },
textEdit = {
newText = "RustcEncodable!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "pub macro asm",
documentation = {
kind = "markdown",
value = "Inline assembly.\n\nRead the [unstable book] for the usage.\n\n[unstable book]: ../../unstable-book/library-features/asm.html"
},
filterText = "asm!",
kind = 2,
label = "asm!",
sortText = "ffffffff",
textEdit = {
newText = "asm!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
}, {
additionalTextEdits = {},
deprecated = false,
detail = "pub macro global_asm",
documentation = {
kind = "markdown",
value = "Module-level inline assembly."
},
filterText = "global_asm!",
kind = 2,
label = "global_asm!",
sortText = "ffffffff",
textEdit = {
newText = "global_asm!",
range = {
end = {
character = 0,
line = 12
},
start = {
character = 0,
line = 12
}
}
}
} }
}
}
[DEBUG][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:339 "rpc.send" {
jsonrpc = "2.0",
method = "$/cancelRequest",
params = {
id = 3
}
}
[DEBUG][2021-11-05 12:53:17] .../lua/vim/lsp.lua:919 "LSP[rust_analyzer]" "client.request" 1 "textDocument/completion" {
context = {
triggerKind = 3
},
position = {
character = 5,
line = 9
},
textDocument = {
uri = "file:///tmp/xx/src/lib.rs"
}
} <function 1> 1
[DEBUG][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 4,
jsonrpc = "2.0",
method = "textDocument/completion",
params = {
context = {
triggerKind = 3
},
position = {
character = 5,
line = 9
},
textDocument = {
uri = "file:///tmp/xx/src/lib.rs"
}
}
}
[ERROR][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:412 "rpc" "rust-analyzer" "stderr" "Panic context:\n> \nversion: 210a1d5ec 2021-10-28 dev\nrequest: textDocument/completion CompletionParams {\n text_document_position: TextDocumentPositionParams {\n text_document: TextDocumentIdentifier {\n uri: Url {\n scheme: \"file\",\n cannot_be_a_base: false,\n username: \"\",\n password: None,\n host: None,\n port: None,\n path: \"/tmp/xx/src/lib.rs\",\n query: None,\n fragment: None,\n },\n },\n position: Position {\n line: 9,\n character: 5,\n },\n },\n work_done_progress_params: WorkDoneProgressParams {\n work_done_token: None,\n },\n partial_result_params: PartialResultParams {\n partial_result_token: None,\n },\n context: Some(\n CompletionContext {\n trigger_kind: CompletionTriggerKind(\n 3,\n ),\n trigger_character: None,\n },\n ),\n}\n\nthread '<unnamed>' panicked at 'Bad range: node range 0..140, range 141..141', /home/shui/.cargo/registry/src/github.com-1ecc6299db9ec823/rowan-0.14.1/src/cursor.rs:786:13\nstack backtrace:\n"
[ERROR][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:412 "rpc" "rust-analyzer" "stderr" " 0: rust_begin_unwind\n at /rustc/4e0d3973fafdfb1c51011bc74e44257b5e3863f1/library/std/src/panicking.rs:495:5\n"
[ERROR][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:412 "rpc" "rust-analyzer" "stderr" " 1: core::panicking::panic_fmt\n at /rustc/4e0d3973fafdfb1c51011bc74e44257b5e3863f1/library/core/src/panicking.rs:106:14\n 2: rowan::cursor::SyntaxNode::covering_element\n 3: syntax::parsing::reparsing::incremental_reparse\n 4: syntax::Parse<syntax::ast::generated::nodes::SourceFile>::reparse\n 5: ide_completion::context::CompletionContext::new\n 6: ide_completion::completions\n 7: std::panicking::try\n 8: ide::Analysis::completions\n 9: rust_analyzer::handlers::handle_completion\n 10: std::panicking::try\n 11: <F as threadpool::FnBox>::call_box\nnote: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\n"
[DEBUG][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:446 "rpc.receive" {
jsonrpc = "2.0",
method = "window/showMessage",
params = {
message = "server panicked: Bad range: node range 0..140, range 141..141, check the log",
type = 1
}
}
[TRACE][2021-11-05 12:53:17] .../lua/vim/lsp.lua:696 "notification" "window/showMessage" {
message = "server panicked: Bad range: node range 0..140, range 141..141, check the log",
type = 1
}
[TRACE][2021-11-05 12:53:17] ...lsp/handlers.lua:432 "default_handler" "window/showMessage" {
ctx = '{\n client_id = 1,\n method = "window/showMessage"\n}',
result = {
message = "server panicked: Bad range: node range 0..140, range 141..141, check the log",
type = 1
}
}
[DEBUG][2021-11-05 12:53:17] .../vim/lsp/rpc.lua:446 "rpc.receive" {
error = {
code = -32603,
message = "server panicked: Bad range: node range 0..140, range 141..141"
},
id = 4,
jsonrpc = "2.0"
}
[INFO][2021-11-05 12:53:20] .../lua/vim/lsp.lua:1243 "exit_handler" { {
_on_attach = <function 1>,
attached_buffers = { true },
cancel_request = <function 2>,
commands = {},
config = {
_on_attach = <function 3>,
autostart = true,
capabilities = {
callHierarchy = {
dynamicRegistration = false
},
textDocument = {
codeAction = {
codeActionLiteralSupport = {
codeActionKind = {
valueSet = { "", "Empty", "QuickFix", "Refactor", "RefactorExtract", "RefactorInline", "RefactorRewrite", "Source", "SourceOrganizeImports", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite", "source", "source.organizeImports" }
}
},
dataSupport = true,
dynamicRegistration = false,
resolveSupport = {
properties = { "edit" }
}
},
completion = {
completionItem = {
commitCharactersSupport = false,
deprecatedSupport = false,
documentationFormat = { "markdown", "plaintext" },
preselectSupport = false,
snippetSupport = false
},
completionItemKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 }
},
contextSupport = false,
dynamicRegistration = false
},
declaration = {
linkSupport = true
},
definition = {
linkSupport = true
},
documentHighlight = {
dynamicRegistration = false
},
documentSymbol = {
dynamicRegistration = false,
hierarchicalDocumentSymbolSupport = true,
symbolKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
}
},
hover = {
contentFormat = { "markdown", "plaintext" },
dynamicRegistration = false
},
implementation = {
linkSupport = true
},
publishDiagnostics = {
relatedInformation = true,
tagSupport = {
valueSet = { 1, 2 }
}
},
references = {
dynamicRegistration = false
},
rename = {
dynamicRegistration = false,
prepareSupport = true
},
signatureHelp = {
dynamicRegistration = false,
signatureInformation = {
activeParameterSupport = true,
documentationFormat = { "markdown", "plaintext" },
parameterInformation = {
labelOffsetSupport = true
}
}
},
synchronization = {
didSave = true,
dynamicRegistration = false,
willSave = false,
willSaveWaitUntil = false
},
typeDefinition = {
linkSupport = true
}
},
window = {
showDocument = {
support = false
},
showMessage = {
messageActionItem = {
additionalPropertiesSupport = false
}
},
workDoneProgress = true
},
workspace = {
applyEdit = true,
configuration = true,
symbol = {
dynamicRegistration = false,
hierarchicalWorkspaceSymbolSupport = true,
symbolKind = {
valueSet = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 }
}
},
workspaceEdit = {
resourceOperations = { "rename", "create", "delete" }
},
workspaceFolders = true
}
},
cmd = { "rust-analyzer" },
filetypes = { "rust" },
flags = {},
get_language_id = <function 4>,
handlers = <1>{},
init_options = vim.empty_dict(),
log_level = 2,
message_level = 2,
name = "rust_analyzer",
on_attach = <function 5>,
on_exit = <function 6>,
on_init = <function 7>,
root_dir = "/tmp/xx",
settings = {
["rust-analyzer"] = {}
},
workspace_folders = <2>{ {
name = "/tmp/xx",
uri = "file:///tmp/xx"
} },
<metatable> = <3>{
__tostring = <function 8>
}
},
handlers = <table 1>,
id = 1,
initialized = true,
is_stopped = <function 9>,
messages = {
messages = {},
name = "rust_analyzer",
progress = {
["rustAnalyzer/Fetching"] = {},
["rustAnalyzer/Indexing"] = {},
["rustAnalyzer/Loading"] = {},
["rustAnalyzer/Roots Scanned"] = {},
["rustAnalyzer/cargo check"] = {}
},
status = {}
},
name = "rust_analyzer",
notify = <function 10>,
offset_encoding = "utf-16",
request = <function 11>,
request_sync = <function 12>,
requests = {},
resolved_capabilities = {
call_hierarchy = true,
code_action = <4>{
codeActionKinds = { "", "quickfix", "refactor", "refactor.extract", "refactor.inline", "refactor.rewrite" },
resolveProvider = true
},
code_lens = true,
code_lens_resolve = true,
completion = true,
declaration = true,
document_formatting = true,
document_highlight = true,
document_range_formatting = false,
document_symbol = true,
execute_command = false,
find_references = true,
goto_definition = true,
hover = true,
implementation = true,
rename = true,
signature_help = true,
signature_help_trigger_characters = <5>{ "(", "," },
text_document_did_change = 2,
text_document_open_close = true,
text_document_save = <6>vim.empty_dict(),
text_document_save_include_text = false,
text_document_will_save = false,
text_document_will_save_wait_until = false,
type_definition = true,
workspace_folder_properties = {
changeNotifications = false,
supported = false
},
workspace_symbol = true
},
rpc = {
handle = <userdata 1>,
notify = <function 13>,
pid = 702584,
request = <function 14>
},
server_capabilities = {
callHierarchyProvider = true,
codeActionProvider = <table 4>,
codeLensProvider = {
resolveProvider = true
},
completionProvider = {
triggerCharacters = { ":", ".", "'" }
},
declarationProvider = true,
definitionProvider = true,
documentFormattingProvider = true,
documentHighlightProvider = true,
documentOnTypeFormattingProvider = {
firstTriggerCharacter = "=",
moreTriggerCharacter = { ".", ">", "{" }
},
documentRangeFormattingProvider = false,
documentSymbolProvider = true,
experimental = {
hoverRange = true,
joinLines = true,
onEnter = true,
openCargoToml = true,
parentModule = true,
runnables = {
kinds = { "cargo" }
},
ssr = true,
workspaceSymbolScopeKindFiltering = true
},
foldingRangeProvider = true,
hoverProvider = true,
implementationProvider = true,
referencesProvider = true,
renameProvider = {
prepareProvider = true
},
selectionRangeProvider = true,
semanticTokensProvider = {
full = {
delta = true
},
legend = {
tokenModifiers = { "documentation", "declaration", "definition", "static", "abstract", "deprecated", "readonly", "defaultLibrary", "async", "attribute", "callable", "constant", "consuming", "controlFlow", "crateRoot", "injected", "intraDocLink", "library", "mutable", "public", "reference", "trait", "unsafe" },
tokenTypes = { "comment", "keyword", "string", "number", "regexp", "operator", "namespace", "type", "struct", "class", "interface", "enum", "enumMember", "typeParameter", "function", "method", "property", "macro", "variable", "parameter", "angle", "arithmetic", "attribute", "bitwise", "boolean", "brace", "bracket", "builtinAttribute", "builtinType", "character", "colon", "comma", "comparison", "constParameter", "dot", "escapeSequence", "formatSpecifier", "generic", "label", "lifetime", "logical", "operator", "parenthesis", "punctuation", "selfKeyword", "semicolon", "typeAlias", "union", "unresolvedReference" }
},
range = true
},
signatureHelpProvider = {
triggerCharacters = <table 5>
},
textDocumentSync = {
change = 2,
openClose = true,
save = <table 6>
},
typeDefinitionProvider = true,
workspace = {
fileOperations = {
willRename = {
filters = { {
pattern = {
glob = "**/*.rs",
matches = "file"
},
scheme = "file"
}, {
pattern = {
glob = "**",
matches = "folder"
},
scheme = "file"
} }
}
}
},
workspaceSymbolProvider = true
},
stop = <function 15>,
supports_method = <function 16>,
workspaceFolders = <table 2>,
workspace_did_change_configuration = <function 17>
} }
[DEBUG][2021-11-05 12:53:20] .../vim/lsp/rpc.lua:339 "rpc.send" {
id = 5,
jsonrpc = "2.0",
method = "shutdown"
}
[DEBUG][2021-11-05 12:53:20] .../vim/lsp/rpc.lua:446 "rpc.receive" {
id = 5,
jsonrpc = "2.0"
}
[DEBUG][2021-11-05 12:53:20] .../vim/lsp/rpc.lua:339 "rpc.send" {
jsonrpc = "2.0",
method = "exit"
}
[START][2021-11-05 12:53:22] LSP logging initiated
[INFO][2021-11-05 12:54:12] .../lua/vim/lsp.lua:1243 "exit_handler" {}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment