diff options
Diffstat (limited to 'cfg/nvim/syntax')
| -rw-r--r-- | cfg/nvim/syntax/close.vim | 376 |
1 files changed, 376 insertions, 0 deletions
diff --git a/cfg/nvim/syntax/close.vim b/cfg/nvim/syntax/close.vim new file mode 100644 index 0000000..1bc8994 --- /dev/null +++ b/cfg/nvim/syntax/close.vim @@ -0,0 +1,376 @@ +" 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: |