nixos/make-options-doc: add inline roles for varname/envar

both of these render distinctly from plain literals in the manpage, and
manpages even semantically distinguish between the two.

doc/build-aux/pandoc-filters/docbook-writer/rst-roles.lua

···
       tag = 'command'
     elseif elem.attributes['role'] == 'option' then
       tag = 'option'
+    elseif elem.attributes['role'] == 'var' then
+      tag = 'varname'
+    elseif elem.attributes['role'] == 'env' then
+      tag = 'envar'
     end
 
     if tag ~= nil then

doc/contributing/contributing-to-documentation.chapter.md

···
   A few markups for other kinds of literals are also available:
 
   - `` {command}`rm -rfi` `` turns into {command}`rm -rfi`
-  - `` {option}`networking.useDHCP` `` turns into {option}`networking.useDHCP`
+  - `` {env}`XDG_DATA_DIRS` `` turns into {env}`XDG_DATA_DIRS`
   - `` {file}`/etc/passwd` `` turns into {file}`/etc/passwd`
+  - `` {option}`networking.useDHCP` `` turns into {option}`networking.useDHCP`
+  - `` {var}`/etc/passwd` `` turns into {var}`/etc/passwd`
 
   These literal kinds are used mostly in NixOS option documentation.
 

nixos/lib/make-options-doc/mergeJSON.py

···
         return f"<option>{escape(text)}</option>"
     def file(self, text):
         return f"<filename>{escape(text)}</filename>"
+    def var(self, text):
+        return f"<varname>{escape(text)}</varname>"
+    def env(self, text):
+        return f"<envar>{escape(text)}</envar>"
     def manpage(self, page, section):
         title = f"<refentrytitle>{escape(page)}</refentrytitle>"
         vol = f"<manvolnum>{escape(section)}</manvolnum>"
···
     md.inline.register_rule('file', FILE_PATTERN, parse)
     md.inline.rules.append('file')
 
+def p_var(md):
+    VAR_PATTERN = r'\{var\}`(.*?)`'
+    def parse(self, m, state):
+        return ('var', m.group(1))
+    md.inline.register_rule('var', VAR_PATTERN, parse)
+    md.inline.rules.append('var')
+
+def p_env(md):
+    ENV_PATTERN = r'\{env\}`(.*?)`'
+    def parse(self, m, state):
+        return ('env', m.group(1))
+    md.inline.register_rule('env', ENV_PATTERN, parse)
+    md.inline.rules.append('env')
+
 def p_option(md):
     OPTION_PATTERN = r'\{option\}`(.*?)`'
     def parse(self, m, state):
···
     md.block.rules.append('admonition')
 
 md = mistune.create_markdown(renderer=Renderer(), plugins=[
-    p_command, p_file, p_option, p_manpage, p_admonition
+    p_command, p_file, p_var, p_env, p_option, p_manpage, p_admonition
 ])
 
 # converts in-place!