neovim

language.lua (5899B)

---

local api = vim.api

local M = {}

---@type table<string,string>
local ft_to_lang = {
 help = 'vimdoc',
 checkhealth = 'vimdoc',
}

--- Returns the filetypes for which a parser named {lang} is used.
---
--- The list includes {lang} itself plus all filetypes registered via
--- |vim.treesitter.language.register()|.
---
--- @param lang string Name of parser
--- @return string[] filetypes
function M.get_filetypes(lang)
 local r = { lang } ---@type string[]
 for ft, p in pairs(ft_to_lang) do
   if p == lang then
     r[#r + 1] = ft
   end
 end
 return r
end

--- Returns the language name to be used when loading a parser for {filetype}.
---
--- If no language has been explicitly registered via |vim.treesitter.language.register()|,
--- default to {filetype}. For composite filetypes like `html.glimmer`, only the main filetype is
--- returned.
---
--- @param filetype string
--- @return string|nil
function M.get_lang(filetype)
 if filetype == '' then
   return
 end
 if ft_to_lang[filetype] then
   return ft_to_lang[filetype]
 end
 -- for subfiletypes like html.glimmer use only "main" filetype
 filetype = assert(vim.split(filetype, '.', { plain = true })[1])
 return ft_to_lang[filetype] or filetype
end

---@deprecated
function M.require_language(lang, path, silent, symbol_name)
 vim.deprecate(
   'vim.treesitter.language.require_language()',
   'vim.treesitter.language.add()',
   '0.12'
 )
 local opts = {
   silent = silent,
   path = path,
   symbol_name = symbol_name,
 }

 if silent then
   local installed = pcall(M.add, lang, opts)
   return installed
 end

 return M.add(lang, opts)
end

--- Load wasm or native parser (wrapper)
--- todo(clason): move to C
---
---@param path string Path of parser library
---@param lang string Language name
---@param symbol_name? string Internal symbol name for the language to load (default lang)
---@return boolean? True if parser is loaded
local function loadparser(path, lang, symbol_name)
 if vim.endswith(path, '.wasm') then
   return vim._ts_add_language_from_wasm and vim._ts_add_language_from_wasm(path, lang)
 else
   return vim._ts_add_language_from_object(path, lang, symbol_name)
 end
end

---@class vim.treesitter.language.add.Opts
---@inlinedoc
---
---Optional path the parser is located at
---@field path? string
---
---Internal symbol name for the language to load
---@field symbol_name? string

--- Load parser with name {lang}
---
--- Parsers are searched in the `parser` runtime directory, or the provided {path}.
--- Can be used to check for available parsers before enabling treesitter features, e.g.,
--- ```lua
---   if vim.treesitter.language.add('markdown') then
---     vim.treesitter.start(bufnr, 'markdown')
---   end
--- ```
---
---@param lang string Name of the parser (alphanumerical and `_` only)
---@param opts? vim.treesitter.language.add.Opts Options:
---@return boolean? True if parser is loaded
---@return string? Error if parser cannot be loaded
function M.add(lang, opts)
 opts = opts or {}
 local path = opts.path
 local symbol_name = opts.symbol_name

 vim.validate('lang', lang, 'string')
 vim.validate('path', path, 'string', true)
 vim.validate('symbol_name', symbol_name, 'string', true)

 -- parser names are assumed to be lowercase (consistent behavior on case-insensitive file systems)
 lang = lang:lower()

 if vim._ts_has_language(lang) then
   return true
 end

 if path == nil then
   -- allow only safe language names when looking for libraries to load
   if not (lang and lang:match('[%w_]+') == lang) then
     return nil, string.format('Invalid language name "%s"', lang)
   end

   local fname = 'parser/' .. lang .. '.*'
   local paths = api.nvim_get_runtime_file(fname, false)
   if #paths == 0 then
     return nil, string.format('No parser for language "%s"', lang)
   end
   path = paths[1]
 end

 local res = loadparser(path, lang, symbol_name)
 return res,
   res == nil and string.format('Cannot load parser %s for language "%s"', path, lang) or nil
end

--- @param x string|string[]
--- @return string[]
local function ensure_list(x)
 if type(x) == 'table' then
   return x
 end
 return { x }
end

--- Register a parser named {lang} to be used for {filetype}(s).
---
--- Note: this adds or overrides the mapping for {filetype}, any existing mappings from other
--- filetypes to {lang} will be preserved.
---
--- @param lang string Name of parser
--- @param filetype string|string[] Filetype(s) to associate with lang
function M.register(lang, filetype)
 vim.validate('lang', lang, 'string')
 vim.validate('filetype', filetype, { 'string', 'table' })

 for _, f in ipairs(ensure_list(filetype)) do
   if f ~= '' then
     ft_to_lang[f] = lang
   end
 end
end

--- Inspects the provided language.
---
--- Inspecting provides some useful information on the language like ABI version, parser state count
--- (a measure of parser complexity), node and field names, and whether the language came from a
--- WASM module.
---
--- Node names are returned in a table mapping each node name to a `boolean` indicating whether or
--- not the node is named (i.e., not anonymous). Anonymous nodes are surrounded with double quotes
--- (`"`).
---
--- For ABI 15 parsers, also show parser metadata (major, minor, patch version) and a table of
--- supertypes with their respective subtypes.
---
---@param lang string Language
---@return TSLangInfo
function M.inspect(lang)
 M.add(lang)
 return vim._ts_inspect_language(lang)
end

--- Returns available treesitter languages.
function M._complete()
 local parsers = api.nvim_get_runtime_file('parser/*', true)
 local parser_names_set = {} ---@type table<string, boolean>
 for _, parser in ipairs(parsers) do
   local parser_name = vim.fn.fnamemodify(parser, ':t:r')
   parser_names_set[parser_name] = true
 end
 return vim.tbl_keys(parser_names_set)
end

return M