@wooorm/starry-night
Version:
Syntax highlighting, like GitHub
1,168 lines (1,166 loc) • 124 kB
JavaScript
// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/dotnet/csharp-tmLanguage>
// and licensed `mit`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
* @import {Grammar} from '@wooorm/starry-night'
*/
/** @type {Grammar} */
const grammar = {
extensions: ['.bf', '.cake', '.cs', '.cs.pp', '.csx', '.eq', '.linq', '.uno'],
names: ['beef', 'c#', 'cake', 'cakescript', 'csharp', 'eq', 'uno'],
patterns: [
{include: '#preprocessor'},
{include: '#comment'},
{include: '#directives'},
{include: '#declarations'},
{include: '#script-top-level'}
],
repository: {
'accessor-getter': {
patterns: [
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.curlybrace.open.cs'}},
contentName: 'meta.accessor.getter.cs',
end: '\\}',
endCaptures: {0: {name: 'punctuation.curlybrace.close.cs'}},
patterns: [{include: '#statement'}]
},
{include: '#accessor-getter-expression'},
{include: '#punctuation-semicolon'}
]
},
'accessor-getter-expression': {
begin: '=>',
beginCaptures: {0: {name: 'keyword.operator.arrow.cs'}},
contentName: 'meta.accessor.getter.cs',
end: '(?=;|\\})',
patterns: [{include: '#ref-modifier'}, {include: '#expression'}]
},
'accessor-setter': {
patterns: [
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.curlybrace.open.cs'}},
contentName: 'meta.accessor.setter.cs',
end: '\\}',
endCaptures: {0: {name: 'punctuation.curlybrace.close.cs'}},
patterns: [{include: '#statement'}]
},
{
begin: '=>',
beginCaptures: {0: {name: 'keyword.operator.arrow.cs'}},
contentName: 'meta.accessor.setter.cs',
end: '(?=;|\\})',
patterns: [{include: '#ref-modifier'}, {include: '#expression'}]
},
{include: '#punctuation-semicolon'}
]
},
'anonymous-method-expression': {
patterns: [
{
begin:
'(?x)\n((?:\\b(?:async|static)\\b\\s*)*)\n(?:\n (@?[_[:alpha:]][_[:alnum:]]*)\\b|\n (\\()\n (?<tuple>(?:[^()]|\\(\\g<tuple>\\))*)\n (\\))\n)\\s*\n(=>)',
beginCaptures: {
1: {
patterns: [
{match: 'async|static', name: 'storage.modifier.$0.cs'}
]
},
2: {name: 'entity.name.variable.parameter.cs'},
3: {name: 'punctuation.parenthesis.open.cs'},
4: {
patterns: [
{include: '#comment'},
{include: '#explicit-anonymous-function-parameter'},
{include: '#implicit-anonymous-function-parameter'},
{include: '#default-argument'},
{include: '#punctuation-comma'}
]
},
5: {name: 'punctuation.parenthesis.close.cs'},
6: {name: 'keyword.operator.arrow.cs'}
},
end: '(?=[,;)}])',
patterns: [
{include: '#intrusive'},
{
begin: '(?={)',
end: '(?=[,;)}])',
patterns: [{include: '#block'}, {include: '#intrusive'}]
},
{
begin: '\\b(ref)\\b|(?=\\S)',
beginCaptures: {1: {name: 'storage.modifier.ref.cs'}},
end: '(?=[,;)}])',
patterns: [{include: '#expression'}]
}
]
},
{
begin:
'(?x)\n((?:\\b(?:async|static)\\b\\s*)*)\n\\b(delegate)\\b\\s*',
beginCaptures: {
1: {
patterns: [
{match: 'async|static', name: 'storage.modifier.$0.cs'}
]
},
2: {name: 'storage.type.delegate.cs'}
},
end: '(?<=})|(?=[,;)}])',
patterns: [
{include: '#intrusive'},
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{include: '#intrusive'},
{include: '#explicit-anonymous-function-parameter'},
{include: '#punctuation-comma'}
]
},
{include: '#block'}
]
}
]
},
'anonymous-object-creation-expression': {
begin: '\\b(new)\\b\\s*(?=\\{|//|/\\*|$)',
beginCaptures: {1: {name: 'keyword.operator.expression.new.cs'}},
end: '(?<=\\})',
patterns: [{include: '#comment'}, {include: '#initializer-expression'}]
},
argument: {
patterns: [
{match: '\\b(ref|in)\\b', name: 'storage.modifier.$1.cs'},
{
begin: '\\b(out)\\b',
beginCaptures: {1: {name: 'storage.modifier.out.cs'}},
end: '(?=,|\\)|\\])',
patterns: [
{include: '#declaration-expression-local'},
{include: '#expression'}
]
},
{include: '#expression'}
]
},
'argument-list': {
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{include: '#named-argument'},
{include: '#argument'},
{include: '#punctuation-comma'}
]
},
'array-creation-expression': {
begin:
'(?x)\n\\b(new|stackalloc)\\b\\s*\n(?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\*\\s*)* # pointer suffix?\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)?\\s*\n(?=\\[)',
beginCaptures: {
1: {name: 'keyword.operator.expression.$1.cs'},
2: {patterns: [{include: '#type'}]}
},
end: '(?<=\\])',
patterns: [{include: '#bracketed-argument-list'}]
},
'as-expression': {
captures: {
1: {name: 'keyword.operator.expression.as.cs'},
2: {patterns: [{include: '#type'}]}
},
match:
'(?x)\n(?<!\\.)\\b(as)\\b\\s*\n(?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?(?!\\?))? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n \\s*(?:,\\s*)* # commata for multi-dimensional arrays\n \\]\n (?:\\s*\\?(?!\\?))? # arrays can be nullable reference types\n )*\n )\n)?'
},
'assignment-expression': {
begin: '(?:\\*|/|%|\\+|-|\\?\\?|\\&|\\^|<<|>>>?|\\|)?=(?!=|>)',
beginCaptures: {0: {patterns: [{include: '#assignment-operators'}]}},
end: '(?=[,\\)\\];}])',
patterns: [{include: '#ref-modifier'}, {include: '#expression'}]
},
'assignment-operators': {
patterns: [
{
match: '\\*=|/=|%=|\\+=|-=|\\?\\?=',
name: 'keyword.operator.assignment.compound.cs'
},
{
match: '\\&=|\\^=|<<=|>>>?=|\\|=',
name: 'keyword.operator.assignment.compound.bitwise.cs'
},
{match: '\\=', name: 'keyword.operator.assignment.cs'}
]
},
attribute: {
patterns: [
{include: '#type-name'},
{include: '#type-arguments'},
{include: '#attribute-arguments'}
]
},
'attribute-arguments': {
begin: '(\\()',
beginCaptures: {1: {name: 'punctuation.parenthesis.open.cs'}},
end: '(\\))',
endCaptures: {1: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{include: '#attribute-named-argument'},
{include: '#expression'},
{include: '#punctuation-comma'}
]
},
'attribute-named-argument': {
begin: '(@?[_[:alpha:]][_[:alnum:]]*)\\s*(?==)',
beginCaptures: {1: {name: 'entity.name.variable.property.cs'}},
end: '(?=(,|\\)))',
patterns: [{include: '#operator-assignment'}, {include: '#expression'}]
},
'attribute-section': {
begin:
'(\\[)(assembly|module|field|event|method|param|property|return|typevar|type)?(\\:)?',
beginCaptures: {
1: {name: 'punctuation.squarebracket.open.cs'},
2: {name: 'keyword.other.attribute-specifier.cs'},
3: {name: 'punctuation.separator.colon.cs'}
},
end: '(\\])',
endCaptures: {1: {name: 'punctuation.squarebracket.close.cs'}},
patterns: [
{include: '#comment'},
{include: '#attribute'},
{include: '#punctuation-comma'}
]
},
'await-expression': {name: 'keyword.operator.expression.await.cs'},
'await-statement': {
beginCaptures: {1: {name: 'keyword.operator.expression.await.cs'}},
end: '(?<=})|(?=;|})',
patterns: [
{include: '#foreach-statement'},
{include: '#using-statement'},
{include: '#expression'}
]
},
'base-class-constructor-call': {
begin:
'(?x)\n(?:\n (@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\.) # qualified name part\n)*\n(@?[_[:alpha:]][_[:alnum:]]*)\\s* # type name\n(\n <\n (?<type_args>\n [^<>()]|\n \\((?:[^<>()]|<[^<>()]*>|\\([^<>()]*\\))*\\)|\n <\\g<type_args>*>\n )*\n >\\s*\n)? # optional type arguments\n(?=\\() # followed by argument list',
beginCaptures: {
1: {name: 'entity.name.type.cs'},
2: {name: 'punctuation.accessor.cs'},
3: {name: 'entity.name.type.cs'},
4: {patterns: [{include: '#type-arguments'}]}
},
end: '(?<=\\))',
patterns: [{include: '#argument-list'}]
},
'base-types': {
begin: ':',
beginCaptures: {0: {name: 'punctuation.separator.colon.cs'}},
end: '(?=\\{|where|;)',
patterns: [
{include: '#base-class-constructor-call'},
{include: '#type'},
{include: '#punctuation-comma'},
{include: '#preprocessor'}
]
},
block: {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.curlybrace.open.cs'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.curlybrace.close.cs'}},
patterns: [{include: '#statement'}]
},
'boolean-literal': {
patterns: [
{
match: '(?<!\\.)\\btrue\\b',
name: 'constant.language.boolean.true.cs'
},
{
match: '(?<!\\.)\\bfalse\\b',
name: 'constant.language.boolean.false.cs'
}
]
},
'bracketed-argument-list': {
begin: '\\[',
beginCaptures: {0: {name: 'punctuation.squarebracket.open.cs'}},
end: '\\]',
endCaptures: {0: {name: 'punctuation.squarebracket.close.cs'}},
patterns: [
{include: '#named-argument'},
{include: '#argument'},
{include: '#punctuation-comma'}
]
},
'bracketed-parameter-list': {
begin: '(?=(\\[))',
beginCaptures: {1: {name: 'punctuation.squarebracket.open.cs'}},
end: '(?=(\\]))',
endCaptures: {1: {name: 'punctuation.squarebracket.close.cs'}},
patterns: [
{
begin: '(?<=\\[)',
end: '(?=\\])',
patterns: [
{include: '#comment'},
{include: '#attribute-section'},
{include: '#parameter'},
{include: '#punctuation-comma'},
{include: '#variable-initializer'}
]
}
]
},
'break-or-continue-statement': {
match: '(?<!\\.)\\b(break|continue)\\b',
name: 'keyword.control.flow.$1.cs'
},
'case-guard': {
patterns: [
{include: '#parenthesized-expression'},
{include: '#expression'}
]
},
'cast-expression': {
captures: {
1: {name: 'punctuation.parenthesis.open.cs'},
2: {patterns: [{include: '#type'}]},
7: {name: 'punctuation.parenthesis.close.cs'}
},
match:
'(?x)\n(\\()\\s*\n(?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)\\s*\n(\\))(?=\\s*-*!*@?[_[:alnum:]\\(])'
},
'casted-constant-pattern': {
begin:
'(?x)\n(\\()\n ([\\s.:@_[:alnum:]]+)\n(\\))\n(?=[\\s+\\-!~]*@?[_[:alnum:](\'"]+)',
beginCaptures: {
1: {name: 'punctuation.parenthesis.open.cs'},
2: {patterns: [{include: '#type-builtin'}, {include: '#type-name'}]},
3: {name: 'punctuation.parenthesis.close.cs'}
},
end: '(?=[)}\\],;:?=&|^]|!=|\\b(and|or|when)\\b)',
patterns: [
{include: '#casted-constant-pattern'},
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [{include: '#constant-pattern'}]
},
{include: '#constant-pattern'},
{
captures: {
1: {name: 'entity.name.type.alias.cs'},
2: {name: 'punctuation.separator.coloncolon.cs'}
},
match: '(@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\:\\:)'
},
{
captures: {
1: {name: 'entity.name.type.cs'},
2: {name: 'punctuation.accessor.cs'}
},
match: '(@?[_[:alpha:]][_[:alnum:]]*)\\s*(\\.)'
},
{
match: '\\@?[_[:alpha:]][_[:alnum:]]*',
name: 'variable.other.constant.cs'
}
]
},
'catch-clause': {
begin: '(?<!\\.)\\b(catch)\\b',
beginCaptures: {1: {name: 'keyword.control.exception.catch.cs'}},
end: '(?<=\\})',
patterns: [
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{
captures: {
1: {patterns: [{include: '#type'}]},
6: {name: 'entity.name.variable.local.cs'}
},
match:
'(?x)\n(?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)\\s*\n(?:(\\g<identifier>)\\b)?'
}
]
},
{include: '#when-clause'},
{include: '#comment'},
{include: '#block'}
]
},
'char-character-escape': {
match: '\\\\(x[0-9a-fA-F]{1,4}|u[0-9a-fA-F]{4}|.)',
name: 'constant.character.escape.cs'
},
'char-literal': {
begin: "'",
beginCaptures: {0: {name: 'punctuation.definition.char.begin.cs'}},
end: "(\\')|((?:[^\\\\\\n])$)",
endCaptures: {
1: {name: 'punctuation.definition.char.end.cs'},
2: {name: 'invalid.illegal.newline.cs'}
},
name: 'string.quoted.single.cs',
patterns: [{include: '#char-character-escape'}]
},
'class-declaration': {
begin: '(?=(\\brecord\\b\\s+)?\\bclass\\b)',
end: '(?<=\\})|(?=;)',
patterns: [
{
begin:
'(?x)\n(\\b(record)\\b\\s+)?\n\\b(class)\\b\\s+\n(@?[_[:alpha:]][_[:alnum:]]*)\\s*',
beginCaptures: {
2: {name: 'storage.type.record.cs'},
3: {name: 'storage.type.class.cs'},
4: {name: 'entity.name.type.class.cs'}
},
end: '(?=\\{)|(?=;)',
patterns: [
{include: '#comment'},
{include: '#type-parameter-list'},
{include: '#parenthesized-parameter-list'},
{include: '#base-types'},
{include: '#generic-constraints'}
]
},
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.curlybrace.open.cs'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.curlybrace.close.cs'}},
patterns: [{include: '#class-or-struct-members'}]
},
{include: '#preprocessor'},
{include: '#comment'}
]
},
'class-or-struct-members': {
patterns: [
{include: '#preprocessor'},
{include: '#comment'},
{include: '#storage-modifier'},
{include: '#type-declarations'},
{include: '#constructor-declaration'},
{include: '#property-declaration'},
{include: '#fixed-size-buffer-declaration'},
{include: '#field-declaration'},
{include: '#event-declaration'},
{include: '#indexer-declaration'},
{include: '#variable-initializer'},
{include: '#destructor-declaration'},
{include: '#operator-declaration'},
{include: '#conversion-operator-declaration'},
{include: '#method-declaration'},
{include: '#attribute-section'},
{include: '#punctuation-semicolon'}
]
},
'combinator-pattern': {
match: '\\b(and|or|not)\\b',
name: 'keyword.operator.expression.pattern.combinator.$1.cs'
},
comment: {
patterns: [
{
begin: '(^\\s+)?(///)(?!/)',
captures: {
1: {name: 'punctuation.whitespace.comment.leading.cs'},
2: {name: 'punctuation.definition.comment.cs'}
},
name: 'comment.block.documentation.cs',
patterns: [{include: '#xml-doc-comment'}],
while: '^(\\s*)(///)(?!/)'
},
{
begin: '(^\\s+)?(/\\*\\*)(?!/)',
captures: {
1: {name: 'punctuation.whitespace.comment.leading.cs'},
2: {name: 'punctuation.definition.comment.cs'}
},
end: '(^\\s+)?(\\*/)',
name: 'comment.block.documentation.cs',
patterns: [
{
patterns: [{include: '#xml-doc-comment'}],
whileCaptures: {
1: {name: 'punctuation.whitespace.comment.leading.cs'},
2: {name: 'punctuation.definition.comment.cs'}
}
},
{include: '#xml-doc-comment'}
]
},
{
begin: '(^\\s+)?(//).*$',
captures: {
1: {name: 'punctuation.whitespace.comment.leading.cs'},
2: {name: 'punctuation.definition.comment.cs'}
},
name: 'comment.line.double-slash.cs',
while: '^(\\s*)(//).*$'
},
{
begin: '/\\*',
captures: {0: {name: 'punctuation.definition.comment.cs'}},
end: '\\*/',
name: 'comment.block.cs'
}
]
},
'conditional-operator': {
patterns: [
{
match: '\\?(?!\\?|\\s*[.\\[])',
name: 'keyword.operator.conditional.question-mark.cs'
},
{match: ':', name: 'keyword.operator.conditional.colon.cs'}
]
},
'constant-pattern': {
patterns: [
{include: '#boolean-literal'},
{include: '#null-literal'},
{include: '#numeric-literal'},
{include: '#char-literal'},
{include: '#string-literal'},
{include: '#raw-string-literal'},
{include: '#verbatim-string-literal'},
{include: '#type-operator-expression'},
{include: '#expression-operator-expression'},
{include: '#expression-operators'},
{include: '#casted-constant-pattern'}
]
},
'constructor-declaration': {
begin: '(@?[_[:alpha:]][_[:alnum:]]*)\\s*(?=\\(|$)',
beginCaptures: {1: {name: 'entity.name.function.cs'}},
end: '(?<=\\})|(?=;)',
patterns: [
{
begin: '(:)',
beginCaptures: {1: {name: 'punctuation.separator.colon.cs'}},
end: '(?=\\{|=>)',
patterns: [{include: '#constructor-initializer'}]
},
{include: '#parenthesized-parameter-list'},
{include: '#preprocessor'},
{include: '#comment'},
{include: '#expression-body'},
{include: '#block'}
]
},
'constructor-initializer': {
begin: '\\b(base|this)\\b\\s*(?=\\()',
beginCaptures: {1: {name: 'variable.language.$1.cs'}},
end: '(?<=\\))',
patterns: [{include: '#argument-list'}]
},
'context-control-paren-statement': {
patterns: [
{include: '#fixed-statement'},
{include: '#lock-statement'},
{include: '#using-statement'}
]
},
'context-control-statement': {
match: '\\b(checked|unchecked|unsafe)\\b(?!\\s*[@_[:alpha:](])',
name: 'keyword.control.context.$1.cs'
},
'conversion-operator-declaration': {
begin:
'(?x)\n(?<explicit_or_implicit_keyword>(?:\\b(?:explicit|implicit)))\\s*\n(?<operator_keyword>(?:\\b(?:operator)))\\s*\n(?<type_name>\n (?:\n (?:ref\\s+(?:readonly\\s+)?)? # ref return\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)\\s*\n(?=\\()',
beginCaptures: {
1: {
patterns: [
{
captures: {1: {name: 'storage.modifier.explicit.cs'}},
match: '\\b(explicit)\\b'
},
{
captures: {1: {name: 'storage.modifier.implicit.cs'}},
match: '\\b(implicit)\\b'
}
]
},
2: {name: 'storage.type.operator.cs'},
3: {patterns: [{include: '#type'}]}
},
end: '(?<=\\})|(?=;)',
patterns: [
{include: '#comment'},
{include: '#parenthesized-parameter-list'},
{include: '#expression-body'},
{include: '#block'}
]
},
'declaration-expression-local': {
captures: {
1: {name: 'storage.type.var.cs'},
2: {patterns: [{include: '#type'}]},
7: {name: 'entity.name.variable.local.cs'}
},
match:
'(?x) # e.g. int x OR var x\n(?:\n \\b(var)\\b|\n (?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n )\n)\\s+\n(\\g<identifier>)\\b\\s*\n(?=[,)\\]])'
},
'declaration-expression-tuple': {
captures: {
1: {name: 'storage.type.var.cs'},
2: {patterns: [{include: '#type'}]},
7: {name: 'entity.name.variable.tuple-element.cs'}
},
match:
'(?x) # e.g. int x OR var x\n(?:\n \\b(var)\\b|\n (?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n )\n)\\s+\n(\\g<identifier>)\\b\\s*\n(?=[,)])'
},
declarations: {
patterns: [
{include: '#namespace-declaration'},
{include: '#type-declarations'},
{include: '#punctuation-semicolon'}
]
},
'default-argument': {
begin: '=',
beginCaptures: {0: {name: 'keyword.operator.assignment.cs'}},
end: '(?=,|\\))',
patterns: [{include: '#expression'}]
},
'default-literal-expression': {
captures: {1: {name: 'keyword.operator.expression.default.cs'}},
match: '\\b(default)\\b'
},
'delegate-declaration': {
begin:
'(?x)\n(?:\\b(delegate)\\b)\\s+\n(?<type_name>\n (?:\n (?:ref\\s+(?:readonly\\s+)?)? # ref return\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)\\s+\n(\\g<identifier>)\\s*\n(<([^<>]+)>)?\\s*\n(?=\\()',
beginCaptures: {
1: {name: 'storage.type.delegate.cs'},
2: {patterns: [{include: '#type'}]},
7: {name: 'entity.name.type.delegate.cs'},
8: {patterns: [{include: '#type-parameter-list'}]}
},
end: '(?=;)',
patterns: [
{include: '#comment'},
{include: '#parenthesized-parameter-list'},
{include: '#generic-constraints'}
]
},
'designation-pattern': {
patterns: [
{include: '#intrusive'},
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{include: '#punctuation-comma'},
{include: '#designation-pattern'}
]
},
{include: '#simple-designation-pattern'}
]
},
'destructor-declaration': {
begin: '(~)(@?[_[:alpha:]][_[:alnum:]]*)\\s*(?=\\()',
beginCaptures: {
1: {name: 'punctuation.tilde.cs'},
2: {name: 'entity.name.function.cs'}
},
end: '(?<=\\})|(?=;)',
patterns: [
{include: '#comment'},
{include: '#parenthesized-parameter-list'},
{include: '#expression-body'},
{include: '#block'}
]
},
directives: {
patterns: [
{include: '#extern-alias-directive'},
{include: '#using-directive'},
{include: '#attribute-section'},
{include: '#punctuation-semicolon'}
]
},
'discard-pattern': {
match: '_(?![_[:alnum:]])',
name: 'variable.language.discard.cs'
},
'do-statement': {
begin: '(?<!\\.)\\b(do)\\b',
beginCaptures: {1: {name: 'keyword.control.loop.do.cs'}},
end: '(?=;|})',
patterns: [{include: '#statement'}]
},
'double-raw-interpolation': {
begin: '(?<=[^\\{][^\\{]|^)((?:\\{)*)(\\{\\{)(?=[^\\{])',
beginCaptures: {
1: {name: 'string.quoted.double.cs'},
2: {name: 'punctuation.definition.interpolation.begin.cs'}
},
end: '\\}\\}',
endCaptures: {0: {name: 'punctuation.definition.interpolation.end.cs'}},
name: 'meta.embedded.interpolation.cs',
patterns: [{include: '#expression'}]
},
'element-access-expression': {
begin:
'(?x)\n(?:\n (?:(\\?)\\s*)? # preceding null-conditional operator?\n (\\.)\\s*| # preceding dot?\n (->)\\s* # preceding pointer arrow?\n)?\n(?:(@?[_[:alpha:]][_[:alnum:]]*)\\s*)? # property name\n(?:(\\?)\\s*)? # null-conditional operator?\n(?=\\[) # open bracket of argument list',
beginCaptures: {
1: {name: 'keyword.operator.null-conditional.cs'},
2: {name: 'punctuation.accessor.cs'},
3: {name: 'punctuation.accessor.pointer.cs'},
4: {name: 'variable.other.object.property.cs'},
5: {name: 'keyword.operator.null-conditional.cs'}
},
end: '(?<=\\])(?!\\s*\\[)',
patterns: [{include: '#bracketed-argument-list'}]
},
'else-part': {
begin: '(?<!\\.)\\b(else)\\b',
beginCaptures: {1: {name: 'keyword.control.conditional.else.cs'}},
end: '(?<=})|(?=;)',
patterns: [{include: '#statement'}]
},
'enum-declaration': {
begin: '(?=\\benum\\b)',
end: '(?<=\\})|(?=;)',
patterns: [
{
begin: '(?=enum)',
end: '(?=\\{)|(?=;)',
patterns: [
{include: '#comment'},
{
captures: {
1: {name: 'storage.type.enum.cs'},
2: {name: 'entity.name.type.enum.cs'}
},
match: '(enum)\\s+(@?[_[:alpha:]][_[:alnum:]]*)'
},
{
begin: ':',
beginCaptures: {0: {name: 'punctuation.separator.colon.cs'}},
end: '(?=\\{)',
patterns: [{include: '#type'}]
}
]
},
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.curlybrace.open.cs'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.curlybrace.close.cs'}},
patterns: [
{include: '#preprocessor'},
{include: '#comment'},
{include: '#attribute-section'},
{include: '#punctuation-comma'},
{
begin: '@?[_[:alpha:]][_[:alnum:]]*',
beginCaptures: {0: {name: 'entity.name.variable.enum-member.cs'}},
end: '(?=(,|\\}))',
patterns: [
{include: '#comment'},
{include: '#variable-initializer'}
]
}
]
},
{include: '#preprocessor'},
{include: '#comment'}
]
},
'event-accessors': {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.curlybrace.open.cs'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.curlybrace.close.cs'}},
patterns: [
{include: '#comment'},
{include: '#attribute-section'},
{
begin: '\\b(add|remove)\\b\\s*(?=\\{|;|=>|//|/\\*|$)',
beginCaptures: {1: {name: 'storage.type.accessor.$1.cs'}},
end: '(?<=\\}|;)|(?=\\})',
patterns: [{include: '#accessor-setter'}]
}
]
},
'event-declaration': {
begin:
'(?x)\n\\b(event)\\b\\s*\n(?<return_type>\n (?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n )\\s+\n)\n(?<interface_name>\\g<type_name>\\s*\\.\\s*)?\n(\\g<identifier>)\\s* # first event name\n(?=\\{|;|,|=|//|/\\*|$)',
beginCaptures: {
1: {name: 'storage.type.event.cs'},
2: {patterns: [{include: '#type'}]},
8: {patterns: [{include: '#type'}, {include: '#punctuation-accessor'}]},
9: {name: 'entity.name.variable.event.cs'}
},
end: '(?<=\\})|(?=;)',
patterns: [
{include: '#comment'},
{include: '#event-accessors'},
{
match: '@?[_[:alpha:]][_[:alnum:]]*',
name: 'entity.name.variable.event.cs'
},
{include: '#punctuation-comma'},
{
begin: '=',
beginCaptures: {0: {name: 'keyword.operator.assignment.cs'}},
end: '(?<=,)|(?=;)',
patterns: [{include: '#expression'}, {include: '#punctuation-comma'}]
}
]
},
'explicit-anonymous-function-parameter': {
captures: {
1: {name: 'storage.modifier.$1.cs'},
2: {patterns: [{include: '#type'}]},
7: {name: 'entity.name.variable.parameter.cs'}
},
match:
'(?x)\n(?:\\b(ref|params|out|in)\\b\\s*)?\n(?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args><(?:[^<>]|\\g<type_args>)*>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^()]|\\g<tuple>)*\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)\\s*\n\\b(\\g<identifier>)\\b'
},
expression: {
patterns: [
{include: '#preprocessor'},
{include: '#comment'},
{include: '#expression-operator-expression'},
{include: '#type-operator-expression'},
{include: '#default-literal-expression'},
{include: '#throw-expression'},
{include: '#raw-interpolated-string'},
{include: '#interpolated-string'},
{include: '#verbatim-interpolated-string'},
{include: '#type-builtin'},
{include: '#language-variable'},
{include: '#switch-statement-or-expression'},
{include: '#with-expression'},
{include: '#conditional-operator'},
{include: '#assignment-expression'},
{include: '#expression-operators'},
{include: '#await-expression'},
{include: '#query-expression'},
{include: '#as-expression'},
{include: '#is-expression'},
{include: '#boolean-literal'},
{include: '#null-literal'},
{include: '#anonymous-method-expression'},
{include: '#object-creation-expression'},
{include: '#array-creation-expression'},
{include: '#anonymous-object-creation-expression'},
{include: '#invocation-expression'},
{include: '#member-access-expression'},
{include: '#element-access-expression'},
{include: '#cast-expression'},
{include: '#literal'},
{include: '#parenthesized-expression'},
{include: '#tuple-deconstruction-assignment'},
{include: '#initializer-expression'},
{include: '#identifier'}
]
},
'expression-body': {
begin: '=>',
beginCaptures: {0: {name: 'keyword.operator.arrow.cs'}},
end: '(?=[,\\);}])',
patterns: [{include: '#ref-modifier'}, {include: '#expression'}]
},
'expression-operator-expression': {
begin: '\\b(checked|unchecked|nameof)\\s*(\\()',
beginCaptures: {
1: {name: 'keyword.operator.expression.$1.cs'},
2: {name: 'punctuation.parenthesis.open.cs'}
},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [{include: '#expression'}]
},
'expression-operators': {
patterns: [
{match: '<<|>>>?', name: 'keyword.operator.bitwise.shift.cs'},
{match: '==|!=', name: 'keyword.operator.comparison.cs'},
{match: '<=|>=|<|>', name: 'keyword.operator.relational.cs'},
{match: '\\!|&&|\\|\\|', name: 'keyword.operator.logical.cs'},
{match: '\\&|~|\\^|\\|', name: 'keyword.operator.bitwise.cs'},
{match: '--', name: 'keyword.operator.decrement.cs'},
{match: '\\+\\+', name: 'keyword.operator.increment.cs'},
{match: '\\+|-(?!>)|\\*|/|%', name: 'keyword.operator.arithmetic.cs'},
{match: '\\?\\?', name: 'keyword.operator.null-coalescing.cs'},
{match: '\\.\\.', name: 'keyword.operator.range.cs'}
]
},
'extern-alias-directive': {
begin: '\\b(extern)\\s+(alias)\\b',
beginCaptures: {
1: {name: 'keyword.other.directive.extern.cs'},
2: {name: 'keyword.other.directive.alias.cs'}
},
end: '(?=;)',
patterns: [
{
match: '\\@?[_[:alpha:]][_[:alnum:]]*',
name: 'variable.other.alias.cs'
}
]
},
'field-declaration': {
begin:
'(?x)\n(?<type_name>\n (?:\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n)\\s+\n(\\g<identifier>)\\s* # first field name\n(?!=>|==)(?=,|;|=|$)',
beginCaptures: {
1: {patterns: [{include: '#type'}]},
6: {name: 'entity.name.variable.field.cs'}
},
end: '(?=;)',
patterns: [
{
match: '@?[_[:alpha:]][_[:alnum:]]*',
name: 'entity.name.variable.field.cs'
},
{include: '#punctuation-comma'},
{include: '#comment'},
{include: '#variable-initializer'},
{include: '#class-or-struct-members'}
]
},
'finally-clause': {
begin: '(?<!\\.)\\b(finally)\\b',
beginCaptures: {1: {name: 'keyword.control.exception.finally.cs'}},
end: '(?<=\\})',
patterns: [{include: '#comment'}, {include: '#block'}]
},
'fixed-size-buffer-declaration': {
begin:
'(?x)\n\\b(fixed)\\b\\s+\n(?<type_name>\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* # Are there any more names being dotted into?\n )\n)\\s+\n(\\g<identifier>)\\s* # buffer name\n(?=\\[)',
beginCaptures: {
1: {name: 'storage.modifier.fixed.cs'},
2: {patterns: [{include: '#type'}]},
6: {name: 'entity.name.variable.field.cs'}
},
end: '(?=;)',
patterns: [{include: '#bracketed-argument-list'}, {include: '#comment'}]
},
'fixed-statement': {
begin: '\\b(fixed)\\b',
beginCaptures: {1: {name: 'keyword.control.context.fixed.cs'}},
end: '(?<=\\))|(?=;|})',
patterns: [
{include: '#intrusive'},
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{include: '#intrusive'},
{include: '#local-variable-declaration'}
]
}
]
},
'for-statement': {
begin: '\\b(for)\\b',
beginCaptures: {1: {name: 'keyword.control.loop.for.cs'}},
end: '(?<=\\))|(?=;|})',
patterns: [
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{
begin: '(?=[^;\\)])',
end: '(?=;|\\))',
patterns: [
{include: '#intrusive'},
{include: '#local-variable-declaration'},
{include: '#local-tuple-var-deconstruction'},
{include: '#tuple-deconstruction-assignment'},
{include: '#expression'}
]
},
{
begin: '(?=;)',
end: '(?=\\))',
patterns: [
{include: '#intrusive'},
{include: '#expression'},
{include: '#punctuation-comma'},
{include: '#punctuation-semicolon'}
]
}
]
}
]
},
'foreach-statement': {
begin: '\\b(foreach)\\b',
beginCaptures: {1: {name: 'keyword.control.loop.foreach.cs'}},
end: '(?<=\\))|(?=;|})',
patterns: [
{include: '#intrusive'},
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [
{include: '#intrusive'},
{
captures: {
1: {name: 'storage.modifier.ref.cs'},
2: {name: 'storage.type.var.cs'},
3: {patterns: [{include: '#type'}]},
8: {name: 'entity.name.variable.local.cs'},
9: {name: 'keyword.control.loop.in.cs'}
},
match:
'(?x)\n(?:\n (?:(\\bref)\\s+)?(\\bvar\\b)| # ref local\n (?<type_name>\n (?:\n (?:ref\\s+)? # ref local\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n )\n)\\s+\n(\\g<identifier>)\\s+\n\\b(in)\\b'
},
{
captures: {
1: {name: 'storage.type.var.cs'},
2: {
patterns: [
{include: '#tuple-declaration-deconstruction-element-list'}
]
},
3: {name: 'keyword.control.loop.in.cs'}
},
match:
'(?x) # match foreach (var (x, y) in ...)\n(?:\\b(var)\\b\\s*)?\n(?<tuple>\\((?:[^\\(\\)]|\\g<tuple>)+\\))\\s+\n\\b(in)\\b'
},
{include: '#expression'}
]
}
]
},
'generic-constraints': {
begin: '(where)\\s+(@?[_[:alpha:]][_[:alnum:]]*)\\s*(:)',
beginCaptures: {
1: {name: 'storage.modifier.where.cs'},
2: {name: 'entity.name.type.type-parameter.cs'},
3: {name: 'punctuation.separator.colon.cs'}
},
end: '(?=\\{|where|;|=>)',
patterns: [
{match: '\\bclass\\b', name: 'storage.type.class.cs'},
{match: '\\bstruct\\b', name: 'storage.type.struct.cs'},
{match: '\\bdefault\\b', name: 'keyword.other.constraint.default.cs'},
{match: '\\bnotnull\\b', name: 'keyword.other.constraint.notnull.cs'},
{
match: '\\bunmanaged\\b',
name: 'keyword.other.constraint.unmanaged.cs'
},
{
captures: {
1: {name: 'keyword.operator.expression.new.cs'},
2: {name: 'punctuation.parenthesis.open.cs'},
3: {name: 'punctuation.parenthesis.close.cs'}
},
match: '(new)\\s*(\\()\\s*(\\))'
},
{include: '#type'},
{include: '#punctuation-comma'},
{include: '#generic-constraints'}
]
},
'goto-statement': {
begin: '(?<!\\.)\\b(goto)\\b',
beginCaptures: {1: {name: 'keyword.control.flow.goto.cs'}},
end: '(?=[;}])',
patterns: [
{
begin: '\\b(case)\\b',
beginCaptures: {1: {name: 'keyword.control.conditional.case.cs'}},
end: '(?=[;}])',
patterns: [{include: '#expression'}]
},
{
captures: {1: {name: 'keyword.control.conditional.default.cs'}},
match: '\\b(default)\\b'
},
{match: '@?[_[:alpha:]][_[:alnum:]]*', name: 'entity.name.label.cs'}
]
},
'group-by': {
captures: {1: {name: 'keyword.operator.expression.query.by.cs'}},
match: '\\b(by)\\b\\s*'
},
'group-clause': {
begin: '\\b(group)\\b\\s*',
beginCaptures: {1: {name: 'keyword.operator.expression.query.group.cs'}},
end: '(?=;|\\))',
patterns: [
{include: '#group-by'},
{include: '#group-into'},
{include: '#query-body'},
{include: '#expression'}
]
},
'group-into': {
captures: {
1: {name: 'keyword.operator.expression.query.into.cs'},
2: {name: 'entity.name.variable.range-variable.cs'}
},
match: '(?x)\n\\b(into)\\b\\s*\n(@?[_[:alpha:]][_[:alnum:]]*)\\b\\s*'
},
identifier: {
match: '@?[_[:alpha:]][_[:alnum:]]*',
name: 'variable.other.readwrite.cs'
},
'if-statement': {
begin: '(?<!\\.)\\b(if)\\b\\s*(?=\\()',
beginCaptures: {1: {name: 'keyword.control.conditional.if.cs'}},
end: '(?<=})|(?=;)',
patterns: [
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.parenthesis.open.cs'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.parenthesis.close.cs'}},
patterns: [{include: '#expression'}]
},
{include: '#statement'}
]
},
'implicit-anonymous-function-parameter': {
match: '\\@?[_[:alpha:]][_[:alnum:]]*\\b',
name: 'entity.name.variable.parameter.cs'
},
'indexer-declaration': {
begin:
'(?x)\n(?<return_type>\n (?<type_name>\n (?:\n (?:ref\\s+(?:readonly\\s+)?)? # ref return\n (?:\n (?:(?<identifier>@?[_[:alpha:]][_[:alnum:]]*)\\s*\\:\\:\\s*)? # alias-qualification\n (?<name_and_type_args> # identifier + type arguments (if any)\n \\g<identifier>\\s*\n (?<type_args>\\s*<(?:[^<>]|\\g<type_args>)+>\\s*)?\n )\n (?:\\s*\\.\\s*\\g<name_and_type_args>)* | # Are there any more names being dotted into?\n (?<tuple>\\s*\\((?:[^\\(\\)]|\\g<tuple>)+\\))\n )\n (?:\\s*\\?\\s*)? # nullable suffix?\n (?:\\s* # array suffix?\n \\[\n (?:\\s*,\\s*)* # commata for multi-dimensional arrays\n \\]\n \\s*\n (?:\\?)? # arrays can be nullable reference types\n \\s*\n )*\n )\n )\\s+\n)\n(?<interface_name>\\g<type_name>\\s*\\.\\s*)?\n(?<indexer_name>this)\\s*\n(?=\\[)',
beginCaptures: {
1: {patterns: [{include: '#type'}]},
7: {patterns: [{include: '#type'}, {include: '#punctuation-accessor'}]},
8: {name: 'variable.language.this.cs'}
},
end: '(?<=\\})|(?=;)',
patterns: [
{include: '#comment'},
{include: '#bracketed-parameter-list'},
{include: '#property-accessors'},
{include: '#accessor-getter-expression'},
{include: '#variable-initializer'}
]