path: root/cfg/nvim/syntax/close.vim

" Vim syntax file
" Language:     Close
" Maintainer:   George Abbott <george@gabbott.dev>
" Last Change:  2024-08-03
" For bugs, patches and license go to https://github.com/close-lang/close.vim

if version < 600
    syntax clear
elseif exists("b:current_syntax")
    finish
endif

" Syntax definitions {{{1
" Basic keywords {{{2
syn keyword   closeConditional switch if else elif unless 
syn keyword   closeRepeat loop while for until
" `:syn match` must be used to prioritize highlighting `for` keyword.
syn keyword   closeStructure struct enum error record 
syn keyword   closeUnion union nextgroup=closeIdentifier skipwhite skipempty contained
syn match closeUnionContextual /\<union\_s\+\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*/ transparent contains=closeUnion
syn keyword   closeOperator    as
syn keyword   closeExistential existential nextgroup=closeTypedef skipwhite skipempty contained
syn match closeExistentialContextual /\<existential\_s\+type/ transparent contains=closeExistential,closeTypedef

syn match     closeAssert      "\<assert\(\w\)*!" contained
syn match     closeAsync       "\<async\%(\s\|\n\)\@="
syn keyword   closeKeyword     then do end in out has with c asm goto label is where
syn keyword   closeKeyword     construct destruct deconstruct
syn keyword   closeKeyword     default default_initialized zero_initialized uninitialized
syn keyword   closeKeyword     panic recklessly recover rescue ensure retry
syn keyword   closeKeyword     type typeof sizeof sized unsized assert
syn keyword   closeKeyword     abstract virtual final override
syn keyword   closeKeyword     generic generator immediate packed repr
syn keyword   closeKeyword     permitted 

syn keyword   closeKeyword     break redo next skip
syn keyword   closeKeyword     box
syn keyword   closeKeyword     next 
syn keyword   closeKeyword     crate
syn keyword   closeKeyword     priv typeof unsized abstract virtual final override nopanic
syn keyword   closeKeyword     extern nextgroup=closeExternCrate,closeObsoleteExternMod skipwhite skipempty
syn keyword   closeKeyword     fn nextgroup=closeFuncName skipwhite skipempty
syn keyword   closeKeyword     pub priv nextgroup=closePubScope skipwhite skipempty
syn keyword   closeKeyword     return
syn keyword   closeKeyword     yield
syn keyword   closeKeyword     import nextgroup=closeModPath skipwhite skipempty
" FIXME: Scoped impl's name is also fallen in this category
syn keyword   closeKeyword     module trait nextgroup=closeIdentifier skipwhite skipempty
syn keyword   closeStorage     move mut ref static const
syn match     closeDefault     /\<default\ze\_s\+\(impl\|fn\|type\|const\)\>/
syn keyword   closeAwait       await
syn keyword   closeKeyword     try catch propagate or_else

syn keyword closePubScopeCrate crate contained
syn match closePubScopeDelim /[()]/ contained
syn match closePubScope /([^()]*)/ contained contains=closePubScopeDelim,closePubScopeCrate,closeSuper,closeModPath,closeModPathSep,closeSelf transparent

syn keyword   closeExternCrate crate contained nextgroup=closeIdentifier,closeExternCrateString skipwhite skipempty
" This is to get the `bar` part of `extern crate "foo" as bar;` highlighting.
syn match   closeExternCrateString /".*"\_s*as/ contained nextgroup=closeIdentifier skipwhite transparent skipempty contains=closeString,closeOperator
syn keyword   closeObsoleteExternMod mod contained nextgroup=closeIdentifier skipwhite skipempty

syn match     closeIdentifier  contains=closeIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
syn match     closeFuncName    "\%(r#\)\=\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained

syn region closeMacroRepeat matchgroup=closeMacroRepeatDelimiters start="$(" end="),\=[*+]" contains=TOP
syn match closeMacroVariable "$\w\+"
syn match closeRawIdent "\<r#\h\w*" contains=NONE


" Built-in types {{{2
syn keyword   closeType        isize usize char bool u8 u16 u32 u64 u128 f32
syn keyword   closeType        f64 i8 i16 i32 i64 i128 str void size noreturn

" Things from the libstd v1 prelude (src/libstd/prelude/v1.rs) {{{2
" This section is just straight transformation of the contents of the prelude,
" to make it easy to update.

" Reexported core operators {{{3
syn keyword   closeTrait       Copy Send Sized Sync
syn keyword   closeTrait       Drop Fn FnMut FnOnce

" Reexported functions {{{3
" There’s no point in highlighting these; when one writes drop( or drop::< it
" gets the same highlighting anyway, and if someone writes `let drop = …;` we
" don’t really want *that* drop to be highlighted.
"syn keyword closeFunction drop

" Reexported types and traits {{{3
syn keyword closeTrait Box
syn keyword closeTrait ToOwned
syn keyword closeTrait Clone
syn keyword closeTrait PartialEq PartialOrd Eq Ord
syn keyword closeTrait Default
syn keyword closeTrait Iterator Extend IntoIterator
syn keyword closeTrait DoubleEndedIterator ExactSizeIterator
syn keyword closeEnum Option
syn keyword closeEnumVariant Some None
syn keyword closeEnum Result
syn keyword closeEnumVariant Ok Err
syn keyword closeTrait SliceConcatExt
syn keyword closeTrait String ToString
syn keyword closeTrait Vec

" Other syntax {{{2
syn keyword   closeSelf        self
syn keyword   closeBoolean     true false

" If foo::bar changes to foo.bar, change this ("::" to "\.").
" If foo::bar changes to Foo::bar, change this (first "\w" to "\u").
syn match     closeModPath     "\w\(\w\)*::[^<]"he=e-3,me=e-3
syn match     closeModPathSep  "::"

syn match     closeFuncCall    "\w\(\w\)*("he=e-1,me=e-1
syn match     closeFuncCall    "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>();

" This is merely a convention; note also the use of [A-Z], restricting it to
" latin identifiers rather than the full Unicode uppercase. I have not used
" [:upper:] as it depends upon 'noignorecase'
"syn match     closeCapsIdent    display "[A-Z]\w\(\w\)*"

syn match     closeOperator     display "\%(+\|-\|/\|*\|=\|\^\|&\||\|!\|>\|<\|%\)=\?"
" This one isn't *quite* right, as we could have binary-& with a reference
syn match     closeSigil        display /&\s\+[&~@*][^)= \t\r\n]/he=e-1,me=e-1
syn match     closeSigil        display /[&~@*][^)= \t\r\n]/he=e-1,me=e-1
" This isn't actually correct; a closure with no arguments can be `|| { }`.
" Last, because the & in && isn't a sigil
syn match     closeOperator     display "&&\|||"
" This is closeArrowCharacter rather than closeArrow for the sake of matchparen,
" so it skips the ->; see http://stackoverflow.com/a/30309949 for details.
syn match     closeArrowCharacter display "->"
syn match     closeQuestionMark display "?\([a-zA-Z]\+\)\@!"

syn match     closeMacro       '\w\(\w\)*!' contains=closeAssert,closePanic
syn match     closeMacro       '#\w\(\w\)*' contains=closeAssert,closePanic

syn match     closeEscapeError   display contained /\\./
syn match     closeEscape        display contained /\\\([nrt0\\'"]\|x\x\{2}\)/
syn match     closeEscapeUnicode display contained /\\u{\%(\x_*\)\{1,6}}/
syn match     closeStringContinuation display contained /\\\n\s*/
syn region    closeString      matchgroup=closeStringDelimiter start=+b"+ skip=+\\\\\|\\"+ end=+"+ contains=closeEscape,closeEscapeError,closeStringContinuation
syn region    closeString      matchgroup=closeStringDelimiter start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=closeEscape,closeEscapeUnicode,closeEscapeError,closeStringContinuation,@Spell
syn region    closeString      matchgroup=closeStringDelimiter start='b\?r\z(#*\)"' end='"\z1' contains=@Spell

" Match attributes with either arbitrary syntax or special highlighting for
" derives. We still highlight strings and comments inside of the attribute.
syn region    closeAttribute   start="#!\?\[" end="\]" contains=@closeAttributeContents,closeAttributeParenthesizedParens,closeAttributeParenthesizedCurly,closeAttributeParenthesizedBrackets,closeDerive
syn region    closeAttributeParenthesizedParens matchgroup=closeAttribute start="\w\%(\w\)*("rs=e end=")"re=s transparent contained contains=closeAttributeBalancedParens,@closeAttributeContents
syn region    closeAttributeParenthesizedCurly matchgroup=closeAttribute start="\w\%(\w\)*{"rs=e end="}"re=s transparent contained contains=closeAttributeBalancedCurly,@closeAttributeContents
syn region    closeAttributeParenthesizedBrackets matchgroup=closeAttribute start="\w\%(\w\)*\["rs=e end="\]"re=s transparent contained contains=closeAttributeBalancedBrackets,@closeAttributeContents
syn region    closeAttributeBalancedParens matchgroup=closeAttribute start="("rs=e end=")"re=s transparent contained contains=closeAttributeBalancedParens,@closeAttributeContents
syn region    closeAttributeBalancedCurly matchgroup=closeAttribute start="{"rs=e end="}"re=s transparent contained contains=closeAttributeBalancedCurly,@closeAttributeContents
syn region    closeAttributeBalancedBrackets matchgroup=closeAttribute start="\["rs=e end="\]"re=s transparent contained contains=closeAttributeBalancedBrackets,@closeAttributeContents
syn cluster   closeAttributeContents contains=closeString,closeCommentLine,closeCommentBlock,closeCommentLineDocError,closeCommentBlockDocError
syn region    closeDerive      start="derive(" end=")" contained contains=closeDeriveTrait
" This list comes from src/libsyntax/ext/deriving/mod.rs
" Some are deprecated (Encodable, Decodable) or to be removed after a new snapshot (Show).
syn keyword   closeDeriveTrait contained Clone Hash RustcEncodable RustcDecodable Encodable Decodable PartialEq Eq PartialOrd Ord Rand Show Debug Default FromPrimitive Send Sync Copy

" dyn keyword: It's only a keyword when used inside a type expression, so
" we make effort here to highlight it only when Rust identifiers follow it
" (not minding the case of pre-2018 Rust where a path starting with :: can
" follow).
"
" This is so that uses of dyn variable names such as in 'let &dyn = &2'
" and 'let dyn = 2' will not get highlighted as a keyword.
syn match     closeKeyword "\<dyn\ze\_s\+\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)" contains=closeDynKeyword
syn keyword   closeDynKeyword  dyn contained

" Number literals
syn match     closeDecNumber   display "\<[0-9][0-9_]*\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
syn match     closeHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
syn match     closeOctNumber   display "\<0o[0-7_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
syn match     closeBinNumber   display "\<0b[01_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="

" Special case for numbers of the form "1." which are float literals, unless followed by
" an identifier, which makes them integer literals with a method call or field access,
" or by another ".", which makes them integer literals followed by the ".." token.
" (This must go first so the others take precedence.)
syn match     closeFloat       display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\|\.\)\@!"
" To mark a number as a normal float, it must have at least one of the three things integral values don't have:
" a decimal point and more numbers; an exponent; and a type suffix.
syn match     closeFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)\="
syn match     closeFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\(f32\|f64\)\="
syn match     closeFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)"

" For the benefit of delimitMate
syn region closeLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt0\\\"]\|x\x\{2}\|u{\%(\x_*\)\{1,6}}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=closeSigil,closeLifetime
syn region closeGenericRegion display start=/<\%('\|[^[:cntrl:][:space:][:punct:]]\)\@=')\S\@=/ end=/>/ contains=closeGenericLifetimeCandidate
syn region closeGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=closeSigil,closeLifetime

"closeLifetime must appear before closeCharacter, or chars will get the lifetime highlighting
syn match     closeLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
syn match     closeLabel       display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*:"
syn match   closeCharacterInvalid   display contained /b\?'\zs[\n\r\t']\ze'/
" The groups negated here add up to 0-255 but nothing else (they do not seem to go beyond ASCII).
syn match   closeCharacterInvalidUnicode   display contained /b'\zs[^[:cntrl:][:graph:][:alnum:][:space:]]\ze'/
syn match   closeCharacter   /b'\([^\\]\|\\\(.\|x\x\{2}\)\)'/ contains=closeEscape,closeEscapeError,closeCharacterInvalid,closeCharacterInvalidUnicode
syn match   closeCharacter   /'\([^\\]\|\\\(.\|x\x\{2}\|u{\%(\x_*\)\{1,6}}\)\)'/ contains=closeEscape,closeEscapeUnicode,closeEscapeError,closeCharacterInvalid

syn match closeShebang /\%^#![^[].*/
syn region closeCommentLine                                                  start="//"                      end="$"   contains=closeTodo,@Spell
syn region closeCommentLineDoc                                               start="//\%(//\@!\|!\)"         end="$"   contains=closeTodo,@Spell
syn region closeCommentLineDocError                                          start="//\%(//\@!\|!\)"         end="$"   contains=closeTodo,@Spell contained
syn region closeCommentBlock             matchgroup=closeCommentBlock         start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=closeTodo,closeCommentBlockNest,@Spell
syn region closeCommentBlockDoc          matchgroup=closeCommentBlockDoc      start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=closeTodo,closeCommentBlockDocNest,closeCommentBlockDocRustCode,@Spell
syn region closeCommentBlockDocError     matchgroup=closeCommentBlockDocError start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=closeTodo,closeCommentBlockDocNestError,@Spell contained
syn region closeCommentBlockNest         matchgroup=closeCommentBlock         start="/\*"                     end="\*/" contains=closeTodo,closeCommentBlockNest,@Spell contained transparent
syn region closeCommentBlockDocNest      matchgroup=closeCommentBlockDoc      start="/\*"                     end="\*/" contains=closeTodo,closeCommentBlockDocNest,@Spell contained transparent
syn region closeCommentBlockDocNestError matchgroup=closeCommentBlockDocError start="/\*"                     end="\*/" contains=closeTodo,closeCommentBlockDocNestError,@Spell contained transparent

" FIXME: this is a really ugly and not fully correct implementation. Most
" importantly, a case like ``/* */*`` should have the final ``*`` not being in
" a comment, but in practice at present it leaves comments open two levels
" deep. But as long as you stay away from that particular case, I *believe*
" the highlighting is correct. Due to the way Vim's syntax engine works
" (greedy for start matches, unlike Rust's tokeniser which is searching for
" the earliest-starting match, start or end), I believe this cannot be solved.
" Oh you who would fix it, don't bother with things like duplicating the Block
" rules and putting ``\*\@<!`` at the start of them; it makes it worse, as
" then you must deal with cases like ``/*/**/*/``. And don't try making it
" worse with ``\%(/\@<!\*\)\@<!``, either...

syn keyword closeTodo contained TODO FIXME XXX NB NOTE SAFETY

" Clobbered registers
syn keyword closeAsmDirSpec in out lateout inout inlateout contained nextgroup=closeAsmReg skipwhite skipempty
syn region  closeAsmReg start="(" end=")" contained contains=closeString

" Symbol operands
syn keyword closeAsmSym sym contained nextgroup=closeAsmSymPath skipwhite skipempty
syn region  closeAsmSymPath start="\S" end=",\|)"me=s-1 contained contains=closeComment.*,closeIdentifier

" Const
syn region  closeAsmConstBalancedParens start="("ms=s+1 end=")" contained contains=@closeAsmConstExpr
syn cluster closeAsmConstExpr contains=closeComment.*,close.*Number,closeString,closeAsmConstBalancedParens
syn region  closeAsmConst start="const" end=",\|)"me=s-1 contained contains=closeStorage,@closeAsmConstExpr

" Options
syn region  closeAsmOptionsGroup start="options\s*(" end=")" contained contains=closeAsmOptions,closeAsmOptionsKey
syn keyword closeAsmOptionsKey options contained
syn keyword closeAsmOptions pure nomem readonly preserves_flags noreturn nostack att_syntax contained

" Folding rules {{{2
" Trivial folding rules to begin with.
" FIXME: use the AST to make really good folding
syn region closeFoldBraces start="{" end="}" transparent fold

if !exists("b:current_syntax_embed")
    let b:current_syntax_embed = 1
    syntax include @RustCodeInComment <sfile>:p:h/close.vim
    unlet b:current_syntax_embed

    " Currently regions marked as ```<some-other-syntax> will not get
    " highlighted at all. In the future, we can do as vim-markdown does and
    " highlight with the other syntax. But for now, let's make sure we find
    " the closing block marker, because the rules below won't catch it.
    syn region closeCommentLinesDocNonRustCode matchgroup=closeCommentDocCodeFence start='^\z(\s*//[!/]\s*```\).\+$' end='^\z1$' keepend contains=closeCommentLineDoc

    " We borrow the rules from close’s src/libclosedoc/html/markdown.rs, so that
    " we only highlight as Rust what it would perceive as Rust (almost; it’s
    " possible to trick it if you try hard, and indented code blocks aren’t
    " supported because Markdown is a menace to parse and only mad dogs and
    " Englishmen would try to handle that case correctly in this syntax file).
    syn region closeCommentLinesDocRustCode matchgroup=closeCommentDocCodeFence start='^\z(\s*//[!/]\s*```\)[^A-Za-z0-9_-]*\%(\%(should_panic\|no_run\|ignore\|allow_fail\|close\|test_harness\|compile_fail\|E\d\{4}\|edition201[58]\)\%([^A-Za-z0-9_-]\+\|$\)\)*$' end='^\z1$' keepend contains=@RustCodeInComment,closeCommentLineDocLeader
    syn region closeCommentBlockDocRustCode matchgroup=closeCommentDocCodeFence start='^\z(\%(\s*\*\)\?\s*```\)[^A-Za-z0-9_-]*\%(\%(should_panic\|no_run\|ignore\|allow_fail\|close\|test_harness\|compile_fail\|E\d\{4}\|edition201[58]\)\%([^A-Za-z0-9_-]\+\|$\)\)*$' end='^\z1$' keepend contains=@RustCodeInComment,closeCommentBlockDocStar
    " Strictly, this may or may not be correct; this code, for example, would
    " mishighlight:
    "
    "     /**
    "     ```close
    "     println!("{}", 1
    "     * 1);
    "     ```
    "     */
    "
    " … but I don’t care. Balance of probability, and all that.
    syn match closeCommentBlockDocStar /^\s*\*\s\?/ contained
    syn match closeCommentLineDocLeader "^\s*//\%(//\@!\|!\)" contained
endif

" Default highlighting {{{1
hi def link closeDecNumber       closeNumber
hi def link closeHexNumber       closeNumber
hi def link closeOctNumber       closeNumber
hi def link closeBinNumber       closeNumber
hi def link closeIdentifierPrime closeIdentifier
hi def link closeTrait           closeType
hi def link closeDeriveTrait     closeTrait

hi def link closeMacroRepeatDelimiters   Macro
hi def link closeMacroVariable Define
hi def link closeSigil         StorageClass
hi def link closeEscape        Special
hi def link closeEscapeUnicode closeEscape
hi def link closeEscapeError   Error
hi def link closeStringContinuation Special
hi def link closeString        String
hi def link closeStringDelimiter String
hi def link closeCharacterInvalid Error
hi def link closeCharacterInvalidUnicode closeCharacterInvalid
hi def link closeCharacter     Character
hi def link closeNumber        Number
hi def link closeBoolean       Boolean
hi def link closeEnum          closeType
hi def link closeEnumVariant   closeConstant
hi def link closeConstant      Constant
hi def link closeSelf          Constant
hi def link closeFloat         Float
hi def link closeArrowCharacter closeOperator
hi def link closeOperator      Operator
hi def link closeKeyword       Keyword
hi def link closeDynKeyword    closeKeyword
hi def link closeTypedef       Keyword " More precise is Typedef, but it doesn't feel right for Rust
hi def link closeStructure     Keyword " More precise is Structure
hi def link closeUnion         closeStructure
hi def link closeExistential   closeKeyword
hi def link closePubScopeDelim Delimiter
hi def link closePubScopeCrate closeKeyword
hi def link closeSuper         closeKeyword
hi def link closeUnsafeKeyword Exception
hi def link closeReservedKeyword Error
hi def link closeRepeat        Conditional
hi def link closeConditional   Conditional
hi def link closeIdentifier    Identifier
hi def link closeCapsIdent     closeIdentifier
hi def link closeModPath       Include
hi def link closeModPathSep    Delimiter
hi def link closeFunction      Function
hi def link closeFuncName      Function
hi def link closeFuncCall      Function
hi def link closeShebang       Comment
hi def link closeCommentLine   Comment
hi def link closeCommentLineDoc SpecialComment
hi def link closeCommentLineDocLeader closeCommentLineDoc
hi def link closeCommentLineDocError Error
hi def link closeCommentBlock  closeCommentLine
hi def link closeCommentBlockDoc closeCommentLineDoc
hi def link closeCommentBlockDocStar closeCommentBlockDoc
hi def link closeCommentBlockDocError Error
hi def link closeCommentDocCodeFence closeCommentLineDoc
hi def link closeAssert        PreCondit
hi def link closePanic         PreCondit
hi def link closeMacro         Macro
hi def link closeType          Type
hi def link closeTodo          Todo
hi def link closeAttribute     PreProc
hi def link closeDerive        PreProc
hi def link closeDefault       StorageClass
hi def link closeStorage       StorageClass
hi def link closeObsoleteStorage Error
hi def link closeLifetime      Special
hi def link closeLabel         Label
hi def link closeExternCrate   closeKeyword
hi def link closeObsoleteExternMod Error
hi def link closeQuestionMark  Special
hi def link closeAsync         closeKeyword
hi def link closeAwait         closeKeyword
hi def link closeAsmDirSpec    closeKeyword
hi def link closeAsmSym        closeKeyword
hi def link closeAsmOptions    closeKeyword
hi def link closeAsmOptionsKey closeAttribute

" Other Suggestions:
" hi closeAttribute ctermfg=cyan
" hi closeDerive ctermfg=cyan
" hi closeAssert ctermfg=yellow
" hi closePanic ctermfg=red
" hi closeMacro ctermfg=magenta

syn sync minlines=200
syn sync maxlines=500

let b:current_syntax = "close"

" vim: set et sw=4 sts=4 ts=8: