jasonhilder
133f9b1169
Consolidated modules into a single file. Added syntax files over using treesitter.
826 lines
40 KiB
VimL
826 lines
40 KiB
VimL
" Author: Charles Pascoe
|
|
" License: MIT (see LICENSE)
|
|
" Copyright: 2022 Charles Pascoe
|
|
|
|
" Clear any existing syntax first
|
|
syntax clear
|
|
|
|
if !exists('main_syntax')
|
|
if exists("b:current_syntax") && !get(g:, "go_highlight_override_existing_syntax", 1)
|
|
finish
|
|
endif
|
|
|
|
let b:__vim_go_syntax = 1
|
|
endif
|
|
|
|
syntax clear
|
|
syntax case match
|
|
syntax sync fromstart
|
|
|
|
" Define 'iskeyword' to include valid UTF-8 multibyte characters, some of which
|
|
" are technically supported for identifiers.
|
|
" TODO: Check UTF-16
|
|
syntax iskeyword @,48-57,_,192-255
|
|
|
|
" TODO: Check performance of lookbehinds
|
|
" TODO: Check correct use of 'skipempty'
|
|
|
|
" Struct and Interface need 'extend' so that simple matches (e.g. /struct {/)
|
|
" can contain complex nested types by extending the parent match. No other types
|
|
" should use extend
|
|
|
|
" Some things use 'contains=TOP,@Spell' to allow them to behave predictably when
|
|
" they are nested within a region with special syntax elements (e.g.
|
|
" goVarDeclGroup and goConstDeclGroup) or when imported into other syntaxes.
|
|
" The '@Spell' is required to disable spelling in these items. Only a handful
|
|
" of things should use 'transparent'.
|
|
|
|
" Config Utils {{{
|
|
|
|
let s:cleanup = []
|
|
|
|
com! -nargs=* GoDeferCleanup call add(s:cleanup, <q-args>)
|
|
GoDeferCleanup delcom GoDeferCleanup
|
|
|
|
fun s:Cleanup()
|
|
for l:cmd in s:cleanup
|
|
exec l:cmd
|
|
endfor
|
|
endfun
|
|
|
|
fun s:getconfig(keys, default)
|
|
if len(a:keys) == 0
|
|
return a:default
|
|
else
|
|
return get(g:, a:keys[0], s:getconfig(a:keys[1:], a:default))
|
|
endif
|
|
endfun
|
|
|
|
fun s:HiConfig(group, option_names, opts={})
|
|
" Most syntax is highlighted by default, unless turned off by the user
|
|
let l:opt = s:getconfig(a:option_names, get(a:opts, 'default', 1))
|
|
let l:cmd = ''
|
|
|
|
if type(l:opt) == v:t_string
|
|
if l:opt =~ '^[[:alnum:]]\+$'
|
|
exec 'hi link '.a:group.' '.l:opt
|
|
else
|
|
exec 'hi '.a:group.' '.l:opt
|
|
endif
|
|
|
|
return 1
|
|
elseif !l:opt
|
|
exec 'hi link '.a:group.' '.get(a:opts, 'offgroup', 'NONE')
|
|
endif
|
|
|
|
return l:opt
|
|
endfun
|
|
|
|
if get(g:, 'go_highlight_string_spellcheck', 1)
|
|
syntax cluster goStringSpell contains=@Spell
|
|
endif
|
|
|
|
if get(g:, 'go_highlight_comment_spellcheck', 1)
|
|
syntax cluster goCommentSpell contains=@Spell
|
|
endif
|
|
|
|
|
|
" TODO: Rethink this approach (use string/array approach)
|
|
if s:getconfig(['go_fold_function_blocks', 'go_syntax_fold'], 1)
|
|
com! -nargs=* GoFoldFunc <args> fold
|
|
else
|
|
com! -nargs=* GoFoldFunc <args>
|
|
endif
|
|
|
|
GoDeferCleanup delcom GoFoldFunc
|
|
|
|
|
|
if s:getconfig(['go_fold_struct_blocks', 'go_syntax_fold'], 1)
|
|
com! -nargs=* GoFoldStruct <args> fold
|
|
else
|
|
com! -nargs=* GoFoldStruct <args>
|
|
endif
|
|
|
|
GoDeferCleanup delcom GoFoldStruct
|
|
|
|
|
|
if s:getconfig(['go_fold_interface_blocks', 'go_syntax_fold'], 1)
|
|
com! -nargs=* GoFoldInterface <args> fold
|
|
else
|
|
com! -nargs=* GoFoldInterface <args>
|
|
endif
|
|
|
|
GoDeferCleanup delcom GoFoldInterface
|
|
|
|
|
|
if s:getconfig(['go_fold_decl_blocks', 'go_syntax_fold'], 1)
|
|
com! -nargs=* GoFoldDecl <args> fold
|
|
else
|
|
com! -nargs=* GoFoldDecl <args>
|
|
endif
|
|
|
|
GoDeferCleanup delcom GoFoldDecl
|
|
|
|
" }}} Config Utils
|
|
|
|
|
|
" Misc {{{
|
|
|
|
" Two top-level clusters to allow regions to specify what syntax they can
|
|
" contain
|
|
" NOTE: goIota technically shouldn't be here (it should only be a part of a
|
|
" const declaration group), but trying to get it to appear only in
|
|
" goConstDeclGroup would require compromising the performance of the current
|
|
" implementation or duplicating goExpr just for goConstDeclGroup.
|
|
syntax cluster goExpr contains=@goLiteral,goForRange,goDotExpr,goFuncLiteral,goCommaExpr,goOperator,goWordStart,goParenBlock,goBracketBlock,goComment,goIota
|
|
syntax cluster goStatement contains=@goExpr,@goFlowControl,goReturn,goSemicolon,goBraceBlock,goStatementStart,goConstDecl,goVarDecl,goTypeDecl,goKeywords
|
|
|
|
" 'goWordStart' reduces the number of times each of the 'nextgroups' is checked,
|
|
" but also prevents 'goImportedPackages' (a keyword syntax element) from
|
|
" overriding matches (e.g. in 'goStructLiteralField').
|
|
syntax match goWordStart /\<\ze\K/ contained nextgroup=goStructLiteral,goFuncCall,goBuiltins,goMakeBuiltin,goNewBuiltin,goImportedPackages
|
|
|
|
" 'goDotExpr' matches a dot that is found as a part of an expression, whereas
|
|
" 'goDot' is used to highlight a dot in non-expression contexts (e.g. the dot
|
|
" between a package and a type). 'goDotExpr' significantly improves the
|
|
" performance of searching for fields and type assertions.
|
|
syntax match goDot /\./ contained
|
|
syntax match goDotExpr /\./ nextgroup=@goDotExpr skipwhite skipnl
|
|
|
|
" The cluster of items that could follow a dot in an expression
|
|
syntax cluster goDotExpr contains=goFuncCall,goStructLiteral,goTypeAssertion,goField,goDotComment
|
|
|
|
" goDotComment is identical to goComment, except it doesn't break field
|
|
" highlighting across multiple lines, e.g.:
|
|
"
|
|
" foo.bar.
|
|
" baz.
|
|
" // This is goDotComment instead of a goComment
|
|
" blah
|
|
"
|
|
" Both 'baz' and 'blah' are correctly highlighted as fields
|
|
syntax region goDotComment start=+//+ end=+$+ contained contains=@goCommentSpell,goCommentTodo keepend skipwhite skipnl nextgroup=@goDotExpr
|
|
syntax region goDotComment start=+/\*+ end=+\*/+ contained contains=@goCommentSpell,goCommentTodo keepend skipwhite skipnl nextgroup=@goDotExpr
|
|
|
|
syntax match goField /\K\k*/ contained
|
|
|
|
" TODO: Only valid operators?
|
|
syntax match goAssign /=/ skipwhite nextgroup=@goExpr
|
|
syntax match goOperator /[-+*/!:=%&^<>|~]\+/ skipwhite nextgroup=@goExpr
|
|
syntax match goCommaExpr /,/ skipwhite skipnl nextgroup=@goExpr
|
|
syntax match goComma /,/ contained
|
|
syntax match goSemicolon /;/
|
|
syntax keyword goUnderscore _
|
|
|
|
hi link goField Identifier
|
|
hi link goLabel Label
|
|
hi link goOperator Operator
|
|
hi link goAssign goOperator
|
|
hi link goDot goOperator
|
|
hi link goComma Delimiter
|
|
hi link goCommaExpr goComma
|
|
hi link goSemicolon Delimiter
|
|
hi link goUnderscore Special
|
|
hi link goDotExpr goDot
|
|
hi link goDotComment goComment
|
|
|
|
call s:HiConfig('goField', ['go_highlight_fields'], #{default: 1})
|
|
call s:HiConfig('goLabel', ['go_highlight_labels'])
|
|
call s:HiConfig('goOperator', ['go_highlight_operators'])
|
|
call s:HiConfig('goDot', ['go_highlight_dot'])
|
|
call s:HiConfig('goComma', ['go_highlight_comma'], #{default: 1})
|
|
call s:HiConfig('goSemicolon', ['go_highlight_semicolon'], #{default: 1})
|
|
|
|
" }}} Misc
|
|
|
|
|
|
" Comments {{{
|
|
|
|
syntax region goComment start=+//+ end=+$+ contains=@goCommentSpell,goCommentTodo,goDirectiveComment keepend
|
|
syntax region goComment start=+/\*+ end=+\*/+ contains=@goCommentSpell,goCommentTodo keepend
|
|
|
|
syntax keyword goCommentTodo contained TODO FIXME XXX TBD NOTE
|
|
syntax region goDirectiveComment start=+//\(line \|extern \| export\|[a-z0-9]\+:[a-z0-9]\+\)+ end=+$+ contained
|
|
|
|
hi link goComment Comment
|
|
hi link goCommentTodo Todo
|
|
hi link goDirectiveComment PreProc
|
|
|
|
call s:HiConfig('goGenerateComment', ['go_highlight_generate_tags'], #{offgroup: 'goComment'})
|
|
|
|
" }}} Comments
|
|
|
|
|
|
" Literals {{{
|
|
|
|
syntax cluster goLiteral contains=goString,goRawString,goInvalidRuneLiteral,goNumberLeader,goBooleanTrue,goBooleanFalse,goNil,goSliceOrArrayLiteral,goPrimitiveTypes,goStructType,goInterfaceType,goMapLiteral,goSliceOrArrayLiteral
|
|
|
|
" Strings
|
|
|
|
syntax region goString matchgroup=goStringEnds start='"' skip=/\\\\\|\\"/ end='"\|$' oneline contains=@goStringSpell,goStringEscape,goDoubleQuoteEscape,goStringFormat
|
|
syntax match goStringEscape /\v\\%(\o{3}|x\x{2}|u\x{4}|U\x{8}|[abfnrtv\\"])/ contained
|
|
syntax match goStringFormat /\v\%%(\%|[-+# 0]*%([1-9]\d*|%(\[\d+\])?\*)?%(\.%(\d+|%(\[\d+\])?\*)?)?%(\[\d+\])?[EFGOTUXbcdefgopqstwvxf])/ contained contains=goStringFormatInvalidIndex
|
|
|
|
if s:getconfig(['go_highlight_format_string_errors'], 0)
|
|
syntax match goStringFormatInvalidIndex /\[0\]/ contained
|
|
hi link goStringFormatInvalidIndex Error
|
|
endif
|
|
|
|
" 'goInvalidRuneLiteral' is a loose match for all single-quote sequences; they
|
|
" are highlighted as errors. If they contain a valid 'goRuneLiteral' or the
|
|
" cursor is present at the end, then the 'goRuneLiteral' highlighting will
|
|
" override the 'goInvalidRuneLiteral' highlighting and thus look like a string.
|
|
syntax region goInvalidRuneLiteral start=+'+ skip=+\\.+ end=+'+ keepend oneline contains=goRuneLiteral
|
|
syntax match goRuneLiteral /\v'%(.*%#|[^\\]|\\%(\o{3}|x\x{2}|u\x{4}|U\x{8}|[abfnrtv\\']))'/ contained contains=goRuneLiteralEscape
|
|
syntax match goRuneLiteralEscape /\v\\%(\o{3}|x\x{2}|u\x{4}|U\x{8}|[abfnrtv\\'])/ contained
|
|
|
|
syntax region goRawString matchgroup=goRawStringEnds start='`' end='`' keepend
|
|
|
|
" Numbers
|
|
|
|
" 'goNumberZeroLeader' searches for a digit so that the various number patterns
|
|
" don't have to, improving match performance
|
|
syntax match goNumberLeader /\ze\<[0-9]/ nextgroup=goNumber,goNumberTypeBinary,goNumberTypeOctal,goNumberTypeHex
|
|
syntax match goNumberLeader /\ze\.[0-9]/ nextgroup=goNumber
|
|
|
|
" TODO: Highlight all forms of invalid number formatting? E.g. underscores in
|
|
" certain places
|
|
" TODO: Highlight floats differently
|
|
syntax match goNumber /\v<[0-9][0-9_]*%(\.[0-9_]*)?%([eE][-+]?[0-9][0-9_]*)?i?/ contained contains=goNumberDecimalExp
|
|
syntax match goNumber /\v\.[0-9][0-9_]*%([eE][-+]?[0-9][0-9_]*)?i?/ contained contains=goNumberDecimalExp
|
|
|
|
syntax match goNumberTypeBinary /\c0b/ contained nextgroup=goNumberBinary
|
|
syntax match goNumberBinary /[01_]\+i\?/ contained
|
|
|
|
syntax match goNumberTypeOctal /\c0o/ contained nextgroup=goNumberOctal
|
|
syntax match goNumberOctal /[0-7_]\+i\?/ contained
|
|
|
|
syntax match goNumberTypeHex /\c0x/ contained nextgroup=goNumberHex
|
|
syntax match goNumberHex /\v\c[0-9a-f_]*%(\.[0-9a-f_]*)?%([pP][-+]?[0-9a-f][0-9a-f_]*)?i?/ contained contains=goNumberHexExp
|
|
|
|
syntax match goNumberSpecialChar /[_i]/ contained containedin=goNumber,goNumberBinary,goNumberOctal,goNumberHex
|
|
syntax match goNumberError /_\{2,\}/ contained containedin=goNumber,goNumberBinary,goNumberOctal,goNumberHex
|
|
|
|
" Exponent markers
|
|
syntax match goNumberDecimalExp /\ce/ contained
|
|
syntax match goNumberHexExp /\cp/ contained
|
|
|
|
" Other
|
|
|
|
syntax keyword goBooleanTrue true
|
|
syntax keyword goBooleanFalse false
|
|
|
|
syntax keyword goNil nil
|
|
|
|
" Highlighting
|
|
|
|
hi link goString String
|
|
hi link goStringEnds goString
|
|
hi link goStringEscape SpecialChar
|
|
hi link goStringFormat SpecialChar
|
|
|
|
hi link goInvalidRuneLiteral Error
|
|
hi link goRuneLiteral Character
|
|
hi link goRuneLiteralEscape goStringFormat
|
|
|
|
hi link goRawString String
|
|
hi link goRawStringEnds goRawString
|
|
|
|
hi link goNumber Number
|
|
hi link goNumberBinary goNumber
|
|
hi link goNumberOctal goNumber
|
|
hi link goNumberHex goNumber
|
|
hi link goNumberType SpecialChar
|
|
hi link goNumberTypeBinary goNumberType
|
|
hi link goNumberTypeOctal goNumberType
|
|
hi link goNumberTypeHex goNumberType
|
|
hi link goNumberError Error
|
|
hi link goNumberDecimalExp SpecialChar
|
|
hi link goNumberHexExp goNumberDecimalExp
|
|
hi link goNumberSpecialChar SpecialChar
|
|
|
|
hi link goBooleanTrue Boolean
|
|
hi link goBooleanFalse Boolean
|
|
|
|
hi link goNil Constant
|
|
|
|
call s:HiConfig('goStringFormat', ['go_highlight_format_strings'], #{offgroup: 'goString'})
|
|
call s:HiConfig('goInvalidRuneLiteral', ['go_highlight_rune_literal_error'], #{offgroup: 'goRuneLiteral'})
|
|
" TODO: Config for highlighting special chars in numbers
|
|
|
|
" }}} Literals
|
|
|
|
|
|
" Simple Blocks {{{
|
|
|
|
syntax region goBracketBlock matchgroup=goBrackets start='\[' end='\]' transparent extend
|
|
syntax region goParenBlock matchgroup=goParens start='(' end=')' transparent extend
|
|
syntax region goBraceBlock matchgroup=goBraces start='{' end='}' transparent extend
|
|
|
|
hi link goBraces Delimiter
|
|
hi link goBrackets Delimiter
|
|
hi link goParens Delimiter
|
|
|
|
call s:HiConfig('goBraces', ['go_highlight_braces'])
|
|
call s:HiConfig('goBrackets', ['go_highlight_brackets'])
|
|
call s:HiConfig('goParens', ['go_highlight_parens'])
|
|
|
|
" }}} Simple Blocks
|
|
|
|
|
|
" Constants and Variables {{{
|
|
|
|
" TODO Slice/map assignment?
|
|
syntax match goVarAssign /\<\K\k*\%(\.\K\k*\)*\%(\s*,\s*\%(\K\k*\%(\.\K\k*\)*\)\?\)*\ze\s*\%(<<\|>>\|&^\|[-+*/%&|^]\)\?=[^=]/ contained contains=goComma,goUnderscore,goVarStructAssign skipwhite nextgroup=goOperator
|
|
syntax match goShortVarDecl /\<\K\k*\%(\s*,\s*\%(\K\k*\)\?\)*\ze\s*:=/ contained contains=goComma,goUnderscore skipwhite nextgroup=goOperator
|
|
syntax match goVarStructAssign /\<\K\k*\%(\.\K\k*\)\+/ contained contains=goDotExpr
|
|
|
|
" TODO: Should these be skipempty instead of skipnl?
|
|
syntax keyword goConstDecl const skipwhite skipnl nextgroup=goVarIdentifier,goConstDeclGroup
|
|
syntax keyword goVarDecl var skipwhite skipnl nextgroup=goVarIdentifier,goVarDeclGroup
|
|
|
|
" TODO: Remove these once you're certain goVarGroupIdentifier is not needed
|
|
" syntax region goVarDeclGroup matchgroup=goVarDeclParens start='(' end=')' contained contains=@goExpr,goComment,goSemicolon,goVarGroupIdentifier
|
|
" syntax region goConstDeclGroup matchgroup=goConstDeclParens start='(' end=')' contained contains=@goExpr,goComment,goSemicolon,goVarGroupIdentifier,goIota
|
|
|
|
GoFoldDecl syntax region goVarDeclGroup matchgroup=goVarDeclParens start='(' end=')' contained contains=@goExpr,goSemicolon,goVarIdentifier
|
|
GoFoldDecl syntax region goConstDeclGroup matchgroup=goConstDeclParens start='(' end=')' contained contains=@goExpr,goSemicolon,goVarIdentifier
|
|
|
|
" TODO: Is it worth supporting comments in goVarComma??
|
|
syntax match goVarIdentifier /\<\K\k*/ contained skipwhite nextgroup=goVarComma,@goType
|
|
syntax match goVarComma /,/ contained skipwhite skipnl nextgroup=goVarIdentifier
|
|
|
|
" TODO: Remove these once you're certain goVarGroupIdentifier is not needed
|
|
" " goVarGroupIdentifier finds positions inside a var/const declaration group
|
|
" " (e.g. 'const (...)') that may be followed by an identifier. Prevents
|
|
" " goVarIdentifier from matching in the wrong places.
|
|
" syntax match goVarGroupIdentifier /^\ze\s/ contained nextgroup=goVarIdentifier skipwhite
|
|
" syntax match goVarGroupIdentifier /[(;]\@1<=\ze\s/ contained nextgroup=goVarIdentifier skipwhite
|
|
" syntax match goVarGroupIdentifier /[(;]\@1<=\ze\<\K/ contained nextgroup=goVarIdentifier
|
|
|
|
syntax keyword goIota iota contained
|
|
|
|
hi link goConstDecl Statement
|
|
hi link goVarDecl Statement
|
|
|
|
hi link goConstDeclParens goParens
|
|
hi link goVarDeclParens goParens
|
|
|
|
hi link goVarIdentifier Identifier
|
|
hi link goVarComma goComma
|
|
hi link goVarGroupIdentifier goVarIdentifier
|
|
hi link goShortVarDecl Identifier
|
|
|
|
hi link goVarAssign Special
|
|
|
|
hi link goIota Special
|
|
|
|
let s:assignOrShortDecl = 0
|
|
|
|
" goStatementStart ideally shouldn't contain goSwitchKeywords, but the without
|
|
" this, `default:` will be highlighted using `goLabel` instead of `goSwitchKeywords`.
|
|
syntax cluster goStatementStartGroup contains=goLabel,goSwitchKeywords
|
|
|
|
call s:HiConfig('goVarIdentifier', ['go_highlight_variable_declarations'])
|
|
|
|
if s:HiConfig('goVarAssign', ['go_highlight_variable_assignments'], #{default: 1})
|
|
let s:assignOrShortDecl = 1
|
|
syntax cluster goStatementStartGroup add=goVarAssign
|
|
endif
|
|
|
|
if s:HiConfig('goShortVarDecl', ['go_highlight_short_variable_declarations','go_highlight_variable_declarations'])
|
|
let s:assignOrShortDecl = 1
|
|
syntax cluster goStatementStartGroup add=goShortVarDecl
|
|
endif
|
|
|
|
if s:assignOrShortDecl
|
|
" This lookbehind is checked for a lot of characters in the file, which is
|
|
" why goStatementStart is conditional and only added if needed. Splitting
|
|
" this into two makes it slightly faster overall.
|
|
" Note: the pattern /[{;]\@1<=/ seems to be equivalent to /[{;]\@1<=./
|
|
" which is why it had such poor performance and conflict with other
|
|
" patterns; splitting it into two specific patterns works better
|
|
syntax match goStatementStart /[{;]\@1<=\ze\s/ contained skipwhite nextgroup=@goStatementStartGroup
|
|
syntax match goStatementStart /[{;]\@1<=\ze\<\K/ contained skipwhite nextgroup=@goStatementStartGroup
|
|
endif
|
|
|
|
syntax match goStatementStart /^\ze\s/ contained skipwhite nextgroup=@goStatementStartGroup
|
|
syntax match goStatementStart /^\ze\<\K/ contained nextgroup=@goStatementStartGroup
|
|
|
|
" }}} Constants and Variables
|
|
|
|
|
|
" Packages {{{
|
|
|
|
syntax keyword goPackage package
|
|
syntax keyword goImport import skipwhite nextgroup=goImportItem,goImports
|
|
syntax region goImports matchgroup=goImportParens start='(' end=')' contained contains=goImportItem,goComment
|
|
syntax match goImportItem /\(\([\._]\|\K\k*\)\s\+\)\?"[^"]*"/ contained contains=goImportString
|
|
syntax region goImportString start='"' end='"' keepend contained
|
|
|
|
hi link goPackage Keyword
|
|
hi link goImport Keyword
|
|
hi link goImportItem Special
|
|
hi link goImportString goString
|
|
hi link goImportParens goParens
|
|
|
|
" }}} Packages
|
|
|
|
|
|
" Types {{{
|
|
|
|
syntax cluster goType contains=goPrimitiveTypes,goFuncType,goStructType,goInterfaceType,goMapType,goSliceOrArrayType,goChannel,goNonPrimitiveType,goPointer,goTypeParens
|
|
|
|
syntax match goPointer /*/ contained nextgroup=@goType
|
|
|
|
" goTypeParens is used to ensure types within parens are highlighted correctly,
|
|
" e.g. the func type in the slice literal `[](func (a, b int) bool){ ... }`
|
|
syntax region goTypeParens start='(' end=')' contained contains=@goType,goComment
|
|
|
|
syntax keyword goTypeDecl type skipwhite skipnl nextgroup=goTypeDeclName,goTypeDeclGroup
|
|
syntax match goTypeDeclName /\K\k*/ contained skipwhite skipnl nextgroup=goTypeDeclTypeParams,goTypeAssign,@goType
|
|
syntax match goTypeAssign /=/ contained skipwhite nextgroup=@goType
|
|
|
|
syntax region goTypeDeclGroup matchgroup=goTypeDeclGroupParens start='(' end=')' contained contains=goTypeDeclName,goComment
|
|
syntax region goTypeDeclTypeParams matchgroup=goTypeParamBrackets start='\[' end='\]' contained contains=goTypeParam,goComma,goComment skipwhite skipnl nextgroup=@goType
|
|
|
|
" goNonPrimitiveType is used for matching the names and packages of
|
|
" non-primitive types (i.e. types other than int, bool, string, etc.). Note the
|
|
" optional non-capturing group is later in the pattern to avoid backtracking.
|
|
syntax match goNonPrimitiveType /\<\K\k*\%(\.\K\k*\)\?\[\?/ contained contains=goPackageName,goTypeArgs
|
|
syntax match goPackageName /\<\K\k*\ze\./ contained nextgroup=goDot
|
|
|
|
syntax region goTypeArgs matchgroup=goTypeParamBrackets start='\[' end='\]' contained contains=@goType,goUnderscore,goComma,goComment
|
|
|
|
syntax keyword goPrimitiveTypes any bool byte complex128 complex64 error float32 float64 int int8 int16 int32 int64 rune string uint uint8 uint16 uint32 uint64 uintptr contained
|
|
|
|
syntax match goFuncType /func\s*(/ contained contains=goFuncTypeParens skipwhite nextgroup=@goType,goFuncTypeMultiReturnType
|
|
|
|
syntax region goFuncTypeParens matchgroup=goFuncParens start='(' end=')' contained contains=goFuncParam,goComma,goComment
|
|
syntax region goFuncTypeMultiReturnType matchgroup=goFuncMultiReturnParens start='(' end=')' contained contains=goNamedReturnValue,goComma,goComment
|
|
|
|
syntax keyword goMapType map contained skipwhite skipempty nextgroup=goMapTypeKeyType
|
|
syntax region goMapTypeKeyType matchgroup=goMapBrackets start='\[' end='\]' contained contains=@goType skipwhite nextgroup=@goType
|
|
|
|
syntax keyword goMapLiteral map contained skipwhite skipempty nextgroup=goMapLiteralKeyType
|
|
syntax region goMapLiteralKeyType matchgroup=goMapBrackets start='\[' end='\]' contained contains=@goType skipwhite nextgroup=goMapLiteralValueType
|
|
" See comment for goSliceOrArrayLiteralType, which serves the same function as goMapLiteralValueType
|
|
syntax region goMapLiteralValueType start='\S' end='\ze[{(]\|$' contained contains=goSliceMapLiteralTypeMatch skipwhite skipnl nextgroup=goMapLiteralItems
|
|
syntax region goMapLiteralItems matchgroup=goMapBraces start='{' end='}' contained contains=goStructLiteralBlock,@goExpr
|
|
|
|
syntax match goSliceOrArrayType /\[\%(\d\+\|\.\.\.\)\?\]/ contained contains=goNumber,goDot skipwhite nextgroup=@goType
|
|
|
|
" A lookbehind is used to distinguish a slice/array literal with slice indexing
|
|
syntax match goSliceOrArrayLiteral /\k\@1<!\[[0-9.]*\]\ze\%(\*\|\K\|\[\|(\)/ contained contains=goNumber,goDot skipwhite nextgroup=goSliceLiteralType
|
|
|
|
" goSliceOrArrayLiteralType allows matching complex types for slice literals
|
|
" such as a slice of functions without parentheses, e.g. "[]func(a, b Foo) Bar {
|
|
" f1, f2, f3 }", which is technically valid, albeit hard to read. The use of a
|
|
" region allows the contained matches (goSliceMapLiteralTypeMatch) to extend the
|
|
" region as necessary, allowing the type to contain braces, such as "[]struct{X,
|
|
" Y int}{ ... }"
|
|
syntax region goSliceLiteralType start='\S' end='\ze[{()]\|$' contained contains=goSliceMapLiteralTypeMatch skipwhite skipnl nextgroup=goSliceItems
|
|
syntax match goSliceMapLiteralTypeMatch /(\|\%(\%(interface\|struct\)\s*{\|[^{()]\)\+/ contained contains=@goType
|
|
|
|
syntax region goSliceItems matchgroup=goSliceBraces start='{' end='}' contained contains=goStructLiteralBlock,@goExpr
|
|
|
|
syntax match goChannel /<-chan/ contained contains=goChannelDir skipwhite nextgroup=@goType
|
|
syntax match goChannel /chan\%(<-\)\?/ contained contains=goChannelDir skipwhite nextgroup=@goType
|
|
syntax match goChannelDir /<-/ contained
|
|
|
|
hi link goPointer goOperator
|
|
|
|
" goTypeDecl should technically link to Typedef, but it looks a bit odd.
|
|
hi link goTypeDecl Keyword
|
|
hi link goTypeParens goParens
|
|
hi link goTypeDeclGroupParens goParens
|
|
hi link goTypeDeclName Type
|
|
hi link goTypeParamBrackets goBrackets
|
|
hi link goTypeAssign goOperator
|
|
|
|
hi link goPackageName Special
|
|
|
|
hi link goNonPrimitiveType Type
|
|
hi link goPrimitiveTypes Type
|
|
hi link goMapType goPrimitiveTypes
|
|
hi link goMapLiteral goPrimitiveTypes
|
|
hi link goMapBrackets Delimiter
|
|
hi link goSliceOrArrayLiteral Delimiter
|
|
hi link goSliceOrArrayType goSliceOrArrayLiteral
|
|
hi link goSliceBraces goBraces
|
|
hi link goMapBraces goBraces
|
|
hi link goChannel Type
|
|
hi link goChannelDir goOperator
|
|
|
|
hi link goFuncType Keyword
|
|
" See 'Functions' for other function highlight groups
|
|
|
|
call s:HiConfig('goTypeDeclName', ['go_highlight_types'])
|
|
call s:HiConfig('goSliceOrArrayLiteral', ['go_highlight_slice_brackets'])
|
|
call s:HiConfig('goMapBrackets', ['go_highlight_map_brackets'])
|
|
|
|
" }}} Types
|
|
|
|
|
|
" Functions {{{
|
|
|
|
" Unfortunately limited to at most 3 nested type args
|
|
syntax match goFuncCall /\v\K\k*\ze%(\(|\[\s*\n?%(,\n|[^\[\]]|\[\s*\n?%(,\n|[^\[\]]|\[[^\[\]]*\])*\])*\]\()/ contained nextgroup=goFuncCallTypeArgs,goFuncCallArgs
|
|
syntax region goFuncCallTypeArgs matchgroup=goTypeParamBrackets start='\[' end='\]' contained contains=@goType,goUnderscore,goComma,goComment nextgroup=goFuncCallArgs
|
|
syntax region goFuncCallArgs matchgroup=goFuncCallParens start='(' end=')' contained contains=@goExpr,goComment,goArgSpread
|
|
|
|
syntax keyword goFuncDecl func skipwhite skipempty nextgroup=goFuncName,goMethodReceiver
|
|
syntax keyword goFuncLiteral func contained skipwhite skipempty nextgroup=goFuncName,goFuncParams
|
|
|
|
syntax match goVariadic /\.\.\./ contained skipwhite nextgroup=@goType
|
|
syntax match goArgSpread /\.\.\./ contained
|
|
|
|
syntax match goFuncName /\K\k*/ contained skipwhite nextgroup=goFuncTypeParams,goFuncParams
|
|
|
|
syntax region goFuncTypeParams matchgroup=goTypeParamBrackets start='\[' end='\]' contained contains=goTypeParam,goComma,goComment nextgroup=goFuncParams
|
|
|
|
syntax match goTypeParam /\K\k*/ contained skipwhite skipempty nextgroup=goTypeParamComma,goTypeConstraint
|
|
syntax match goTypeParamComma /,/ contained skipwhite skipempty nextgroup=goTypeParam
|
|
|
|
" This is a region to allow use of types that have commas (e.g. function
|
|
" definitions) or nested type parameters, because they will automatically extend
|
|
" the match of the region
|
|
syntax region goTypeConstraint start='\s'ms=e+1 end=/[,\]]/me=s-1 contained contains=@goType,goTypeConstraintSymbols
|
|
syntax match goTypeConstraintSymbols /[~|]/ contained
|
|
|
|
" This is odd, but the \s*\zs at the start seems to ensure that the (\@1<!
|
|
" negative lookbehind works as desired (i.e. to not steal a match from
|
|
" goFuncMultiReturn); look into this further and try to remove this.
|
|
syntax match goFuncReturnType /\s*\zs(\@1<!\%(\%(interface\|struct\)\s*{\|[^{]\)\+/ contained contains=@goType skipwhite skipempty nextgroup=goFuncBlock
|
|
|
|
syntax region goFuncParams matchgroup=goFuncParens start='(' end=')' contained contains=goFuncParam,goComma,goComment skipwhite nextgroup=goFuncReturnType,goFuncMultiReturn,goFuncBlock
|
|
syntax region goFuncMultiReturn matchgroup=goFuncMultiReturnParens start='(' end=')' contained contains=goNamedReturnValue,goComma,goComment skipwhite skipempty nextgroup=goFuncBlock
|
|
syntax region goMethodReceiver matchgroup=goReceiverParens start='(' end=')' contained contains=goFuncParam,goComment skipwhite skipempty nextgroup=goFuncName
|
|
|
|
GoFoldFunc syntax region goFuncBlock matchgroup=goFuncBraces start='{' end='}' contained contains=@goStatement skipwhite nextgroup=goFuncCallArgs
|
|
|
|
" Previous versions (delete later)
|
|
" syntax match goFuncParam /\%(^\|[(,]\)\@1<=\s*\zs\%(\%(\K\k*\s*,\%(\s\|\n\)*\)*\%(chan\>\)\@!\K\k*\s\+\)\?\ze[^,]/ contained contains=goComma skipwhite nextgroup=@goType,goVariadic
|
|
" syntax match goFuncParam /\%(^\|[(,]\)\@1<=\s*\zs\%(\%(\K\k*\s*,\%(\s\|\n\)*\)*\%(chan\>\)\@!\K\k*\)\%(\s*,\?\%(\s\|\n\)*\%#\|\s\+\ze[^,]\)/ contained contains=goComma,goUnderscore skipwhite nextgroup=@goType,goVariadic
|
|
" syntax match goFuncParam /\%(^\|[(,]\)\@1<=\s*\zs\%(\%(\K\k*\s*,\%(\s\|\n\)*\)*\%(chan\>\)\@!\K\k*\)\%(\s*,\?\%(\s\|\n\)*\%#\ze)\|\s\+\ze[^,]\)/ contained contains=goComma,goUnderscore skipwhite nextgroup=@goType,goVariadic
|
|
|
|
" TODO: Peformance: Figure out how to eliminate at least the first \ze in
|
|
" '\ze)', because it more than doubles the time it takes to match this regex.
|
|
" ')\@1<=' didn't work for some reason (i.e. when typing a parameter name, it
|
|
" was highlighted as a type).
|
|
"
|
|
" goFuncParam: Assume the user is typing a parameter name (i.e. avoid
|
|
" highlighting parameter names as types until proven otherwise).
|
|
" conditional group allows skipping directly to type, e.g. func(SomeType) "
|
|
" ┌───────────────────────────────────────────────────────────────────────────────────────────────────┐ "
|
|
syntax match goFuncParam /\%(^\|[(,]\)\@1<=\s*\zs\%(\%(\%(\K\k*\s*,\%(\s\|\n\)*\)*\%(chan\>\)\@!\K\k*\)\%(\s*,\?\%(\s\|\n\)*\%#\ze)\|\s\+\ze[^,]\)\)\?/ contained contains=goComma,goUnderscore skipwhite nextgroup=@goType,goVariadic
|
|
" └──────────────────┘ │ └──────────────┘ │└────────────┘ │└────────────────┘ │ │ │ "
|
|
" Param must be preceded │ comma/ws/nl │ 'chan' a type, │ comma/ws/nl │ │ │ "
|
|
" by start of line, '(', │ │ not param name │ │ │ │ "
|
|
" or ',' followed by └────────────────────────────┘ └────────────────────────┘ └───────────┘ "
|
|
" whitespace zero or more previous params if this matches, then we otherwise if this "
|
|
" (e.g. 'a, b, ' in 'a, b, c') have one or more params, matches, we have "
|
|
" then cursor, then close params then type, "
|
|
" paren, e.g.: e.g.: "
|
|
" (a, b, c, |) (a, b foo) "
|
|
" The above diagrams can be found in the Monodraw file goFuncParam_Diagrams.monopic
|
|
|
|
" goFuncParam: Assume the user is typing a type (i.e. avoid highlighting custom
|
|
" types as return value names until proven otherwise)
|
|
syntax match goNamedReturnValue /\%(^\|[(,]\)\@1<=\s*\zs\%(\%(\K\k*\s*,\%(\s\|\n\)*\)*\%(chan\>\)\@!\K\k*\s\+\)\?\ze[^,]/ contained contains=goComma skipwhite nextgroup=@goType
|
|
|
|
syntax keyword goReturn return contained
|
|
|
|
hi link goFuncName Function
|
|
hi link goFuncCall Function
|
|
hi link goFuncCallParens goParens
|
|
hi link goFuncDecl goFuncType
|
|
hi link goFuncLiteral goFuncDecl
|
|
hi link goFuncParens goParens
|
|
hi link goFuncBraces goBraces
|
|
hi link goFuncMultiReturnParens goParens
|
|
|
|
hi link goReceiverParens goFuncParens
|
|
|
|
hi link goVariadic goOperator
|
|
hi link goArgSpread goVariadic
|
|
|
|
hi link goTypeParam Identifier
|
|
hi link goTypeParamComma goComma
|
|
|
|
hi link goFuncParam Identifier
|
|
hi link goNamedReturnValue NONE
|
|
|
|
hi link goReturn Statement
|
|
|
|
call s:HiConfig('goFuncCall', ['go_highlight_function_calls'])
|
|
call s:HiConfig('goFuncName', ['go_highlight_functions'])
|
|
call s:HiConfig('goFuncParens', ['go_highlight_function_parens'])
|
|
call s:HiConfig('goFuncBraces', ['go_highlight_function_braces'])
|
|
call s:HiConfig('goFuncParam', ['go_highlight_function_parameters'])
|
|
call s:HiConfig('goTypeParam', ['go_highlight_type_parameters'])
|
|
|
|
" }}} Functions
|
|
|
|
|
|
" Structs and Interfaces {{{
|
|
|
|
" Note: 'goStructTypeBlock' has 'nextgroup=goStructLiteralBlock' to handle
|
|
" anonymous struct type literals
|
|
|
|
syntax keyword goStructType struct contained skipempty skipwhite nextgroup=goStructTypeBlock
|
|
syntax region goStructTypeBlock matchgroup=goStructTypeBraces start='{' end='}' extend contained contains=goEmbeddedType,goStructTypeField,goComment,goStructTypeTag,goDot,goSemicolon skipwhite nextgroup=goStructLiteralBlock
|
|
syntax region goStructTypeTag start='`' end='`' contained
|
|
syntax region goStructTypeTag start='"' skip='\\"' end='"' contained oneline
|
|
syntax match goStructTypeField /\%(_\|\K\k*\)\%(,\s*\%(_\|\K\k*\)\)*/ contained contains=goComma,goUnderscore skipwhite nextgroup=@goType
|
|
syntax match goEmbeddedType /\*\?\K\k*\%(\.\K\k*\)\?\%(\[.*\]\)\?\%#\@1<!$/ contained contains=@goType
|
|
|
|
" It is technically possible to have a space between a struct name and the
|
|
" braces, but it's hard to reliably highlight
|
|
syntax match goStructLiteral /\v\K\k*\ze%(\{|\[\s*\n?%(,\n|[^\[\]]|\[\s*\n?%(,\n|[^\[\]]|\[[^\[\]]*\])*\])*\]\{)/ contained nextgroup=goStructLiteralTypeArgs,goStructLiteralBlock
|
|
syntax region goStructLiteralTypeArgs matchgroup=goTypeParamBrackets start='\[' end='\]' contained contains=@goType,goUnderscore,goComma,goComment nextgroup=goStructLiteralBlock
|
|
|
|
" goStructLiteralBlock contains itself to 1) prevent weird highlighting while
|
|
" typing, and 2) allow slice literals of slices of structs to highlight
|
|
" correctly
|
|
GoFoldStruct syntax region goStructLiteralBlock matchgroup=goStructBraces start='{' end='}' contained contains=goStructLiteralField,goComma,@goExpr,goStructLiteralBlock
|
|
|
|
syntax match goStructLiteralField /\<\K\k*\ze:/ contained nextgroup=goStructLiteralColon
|
|
syntax match goStructLiteralColon /:/ contained
|
|
|
|
syntax keyword goInterfaceType interface contained skipwhite skipempty nextgroup=goInterfaceBlock
|
|
GoFoldInterface syntax region goInterfaceBlock matchgroup=goInterfaceBraces start='{' end='}' contained contains=@goType,goTypeConstraintSymbols,goInterfaceMethod,goComment extend
|
|
|
|
syntax match goInterfaceMethod /\K\k*\ze(/ contained skipwhite nextgroup=goInterfaceMethodParams
|
|
syntax region goInterfaceMethodParams matchgroup=goInterfaceMethodParens start='(' end=')' contained contains=goFuncParam,goComma,goComment skipwhite nextgroup=@goType,goInterfaceMethodMultiReturn
|
|
syntax region goInterfaceMethodMultiReturn matchgroup=goFuncMultiReturnParens start='(' end=')' contained contains=goNamedReturnValue,goComma,goComment
|
|
|
|
hi link goStructType Keyword
|
|
hi link goStructTypeBraces goBraces
|
|
hi link goStructTypeField Identifier
|
|
hi link goStructTypeTag PreProc
|
|
hi link goStructLiteral goNonPrimitiveType
|
|
hi link goStructLiteralField Identifier
|
|
hi link goStructLiteralColon goSemicolon
|
|
hi link goStructLiteralComma goComma
|
|
hi link goStructBraces goBraces
|
|
|
|
hi link goInterfaceType goStructType
|
|
hi link goTypeConstraintSymbols goOperator
|
|
hi link goInterfaceBraces goBraces
|
|
hi link goInterfaceMethod goFuncName
|
|
hi link goInterfaceMethodParens goFuncParens
|
|
|
|
call s:HiConfig('goStructTypeTag', ['go_highlight_struct_tags'])
|
|
call s:HiConfig('goStructLiteralField', ['go_highlight_struct_fields'], #{default: 1})
|
|
call s:HiConfig('goStructTypeField', ['go_highlight_struct_type_fields'], #{default: 1})
|
|
|
|
" }}} Structs and Interfaces
|
|
|
|
|
|
" Builtins {{{
|
|
|
|
" `make` and `new` are matched by `goMakeBuiltin` and `goNewBuiltin` so that the
|
|
" paren block that follows can have custom highlighting for types
|
|
syntax keyword goBuiltins append cap close complex copy delete imag len max min panic print println real recover skipwhite nextgroup=goFuncCallArgs
|
|
|
|
syntax keyword goMakeBuiltin make skipwhite nextgroup=goMakeBlock
|
|
syntax region goMakeBlock matchgroup=goFuncCallParens start='(' end=')' contained contains=@goType,goMakeArguments,goComment
|
|
syntax region goMakeArguments start=',' end='\ze)' contained contains=@goExpr,gComment
|
|
|
|
syntax keyword goNewBuiltin new skipwhite nextgroup=goNewBlock
|
|
syntax region goNewBlock matchgroup=goFuncCallParens start='(' end=')' contained contains=@goType,goComment
|
|
|
|
hi link goBuiltins Special
|
|
hi link goMakeBuiltin goBuiltins
|
|
hi link goNewBuiltin goBuiltins
|
|
|
|
call s:HiConfig('goBuiltins', ['go_highlight_builtins'], #{offgroup: 'goFuncCall'})
|
|
call s:HiConfig('goFuncCallParens', ['go_highlight_function_call_parens'])
|
|
|
|
" }}} Builtins
|
|
|
|
|
|
" Flow Control {{{
|
|
|
|
syntax cluster goFlowControl contains=goGoto,goIf,goElse,goFor,goForRange,goForKeywords,goSwitch,goCase,goSelect,goSwitchKeywords
|
|
|
|
" 'goStatementStart' is used to avoid searching for 'goLabel' everywhere
|
|
syntax match goLabel /\K\k*\ze:/ contained
|
|
syntax keyword goGoto goto contained skipwhite nextgroup=goGotoLabel
|
|
syntax match goGotoLabel /\K\k*/ contained
|
|
|
|
syntax keyword goIf if contained skipwhite skipempty nextgroup=goShortVarDecl
|
|
syntax keyword goElse else contained
|
|
|
|
syntax keyword goFor for contained skipwhite skipempty nextgroup=goShortVarDecl
|
|
syntax keyword goForRange range contained
|
|
syntax keyword goForKeywords break continue contained
|
|
|
|
syntax keyword goSwitch switch contained skipwhite nextgroup=goShortVarDecl
|
|
syntax keyword goSelect select contained
|
|
syntax keyword goCase case contained skipwhite nextgroup=goShortVarDecl
|
|
syntax keyword goSwitchKeywords fallthrough default contained
|
|
|
|
syntax match goSwitchTypeCase /^\s\+case\s/ contained skipwhite nextgroup=@goType
|
|
syntax region goSwitchTypeBlock matchgroup=goSwitchTypeBraces start='{' end='}' contained contains=goSwitchTypeCase,goSwitchTypeBlockNestedBraces,@goStatement
|
|
|
|
" goSwitchTypeBlockNestedBraces prevents goSwitchTypeCase from matching "case" in a regular nested switch statement
|
|
syntax region goSwitchTypeBlockNestedBraces matchgroup=goBraces start='{' end='}' contained contains=@goStatement
|
|
|
|
hi link goGoto Statement
|
|
hi link goGotoLabel goLabel
|
|
|
|
hi link goIf Conditional
|
|
hi link goElse goIf
|
|
|
|
hi link goFor Repeat
|
|
hi link goForRange goFor
|
|
hi link goForKeywords goFor
|
|
|
|
hi link goSwitch Conditional
|
|
hi link goSelect goSwitch
|
|
hi link goCase goSwitch
|
|
hi link goSwitchKeywords goSwitch
|
|
|
|
hi link goSwitchTypeBraces goBraces
|
|
hi link goSwitchTypeCase goSwitchKeywords
|
|
|
|
" }}} Flow Control
|
|
|
|
|
|
" Misc {{{
|
|
|
|
syntax keyword goKeywords defer go contained
|
|
|
|
" goTypeAssertion is a part of the nextgroup list of goDotExpr
|
|
syntax region goTypeAssertion matchgroup=goParens start=/(/ end=/)/ contained contains=@goType
|
|
syntax match goTypeAssertion /(type)/ contained contains=goParenBlock skipwhite nextgroup=goSwitchTypeBlock
|
|
|
|
hi link goKeywords Keyword
|
|
hi link goTypeAssertion Special
|
|
|
|
" }}} Misc
|
|
|
|
|
|
" Vim-Go Compatibility {{{
|
|
|
|
" NOTE: The code in this section is a collection of verbatim extracts from
|
|
" https://github.com/fatih/vim-go/blob/master/syntax/go.vim, included here to
|
|
" ensure compatibility with vim-go's code coverage and debugging features. Refer
|
|
" to https://github.com/fatih/vim-go/blob/master/LICENSE for details on vim-go's
|
|
" source license.
|
|
|
|
hi def link goSameId Search
|
|
hi def link goDiagnosticError SpellBad
|
|
hi def link goDiagnosticWarning SpellRare
|
|
|
|
" TODO(bc): is it appropriate to define text properties in a syntax file?
|
|
" The highlight groups need to be defined before the text properties types
|
|
" are added, and when users have syntax enabled in their vimrc after
|
|
" filetype plugin on, the highlight groups won't be defined when
|
|
" ftplugin/go.vim is executed when the first go file is opened.
|
|
" See https://github.com/fatih/vim-go/issues/2658.
|
|
if has('textprop')
|
|
if empty(prop_type_get('goSameId'))
|
|
call prop_type_add('goSameId', {'highlight': 'goSameId'})
|
|
endif
|
|
if empty(prop_type_get('goDiagnosticError'))
|
|
call prop_type_add('goDiagnosticError', {'highlight': 'goDiagnosticError'})
|
|
endif
|
|
if empty(prop_type_get('goDiagnosticWarning'))
|
|
call prop_type_add('goDiagnosticWarning', {'highlight': 'goDiagnosticWarning'})
|
|
endif
|
|
endif
|
|
|
|
" :GoCoverage commands
|
|
hi def link goCoverageNormalText Comment
|
|
hi def goCoverageCovered ctermfg=green guifg=#A6E22E
|
|
hi def goCoverageUncover ctermfg=red guifg=#F92672
|
|
|
|
hi def link goDeclsFzfKeyword Keyword
|
|
hi def link goDeclsFzfFunction Function
|
|
hi def link goDeclsFzfSpecialComment SpecialComment
|
|
hi def link goDeclsFzfComment Comment
|
|
|
|
" :GoDebug commands
|
|
if exists('*go#config#HighlightDebug') && go#config#HighlightDebug()
|
|
hi def GoDebugBreakpoint term=standout ctermbg=117 ctermfg=0 guibg=#BAD4F5 guifg=Black
|
|
hi def GoDebugCurrent term=reverse ctermbg=12 ctermfg=7 guibg=DarkBlue guifg=White
|
|
endif
|
|
|
|
" }}} Vim-Go Compatibility
|
|
|
|
|
|
call s:Cleanup()
|
|
|
|
if !exists('main_syntax')
|
|
let b:current_syntax = 'go'
|
|
endif
|
|
|
|
" vim:tw=80:fdm=marker:fmr={{{,}}}:
|
|
" JASON
|
|
hi goFuncCall guifg=#8fa3b3 gui=bold
|
|
hi goField guifg=#b3a3d3 " method/field names after dot
|
|
hi goFuncName guifg=#8fa3b3 gui=bold " function declarations
|