From 725f1f1c08c2d7e338d649062622d313292a41fa Mon Sep 17 00:00:00 2001 From: George Abbott Date: Sun, 26 Jan 2025 11:36:35 +0000 Subject: cfg --- cfg/nvim/syntax/close.vim | 376 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 376 insertions(+) create mode 100644 cfg/nvim/syntax/close.vim (limited to 'cfg/nvim/syntax') 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 +" 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 /\/ +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 "\(); + +" 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 "\/ 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 ``\*\@:p:h/close.vim + unlet b:current_syntax_embed + + " Currently regions marked as ``` 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: -- cgit v1.2.1