@wooorm/starry-night
Version:
Syntax highlighting, like GitHub
1,272 lines (1,271 loc) • 80.3 kB
JavaScript
// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/ballerina-platform/ballerina-grammar>
// and licensed `apache-2.0`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
* @import {Grammar} from '@wooorm/starry-night'
*/
/** @type {Grammar} */
const grammar = {
extensions: ['.bal'],
names: ['ballerina'],
patterns: [{include: '#statements'}],
repository: {
'access-modifier': {
patterns: [
{
match:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(public|private)(?![_$[:alnum:]])(?:(?=\\.\\.\\.)|(?!\\.))',
name: 'storage.modifier.ballerina keyword.other.ballerina'
}
]
},
annotationAttachment: {
patterns: [
{
captures: {
1: {name: 'punctuation.decorator.ballerina'},
2: {name: 'support.type.ballerina'},
3: {name: 'punctuation.decorator.ballerina'},
4: {name: 'support.type.ballerina'}
},
match:
'(@)((?:[_$[:alpha:]][_$[:alnum:]]*))\\s*(:?)\\s*((?:[_$[:alpha:]][_$[:alnum:]]*)?)'
}
]
},
annotationDefinition: {
patterns: [
{
begin: '\\bannotation\\b',
beginCaptures: {0: {name: 'keyword.ballerina'}},
end: ';',
patterns: [{include: '#code'}]
}
]
},
'array-literal': {
begin: '\\s*(\\[)',
beginCaptures: {1: {name: 'meta.brace.square.ballerina'}},
end: '\\]',
endCaptures: {0: {name: 'meta.brace.square.ballerina'}},
name: 'meta.array.literal.ballerina',
patterns: [{include: '#expression'}, {include: '#punctuation-comma'}]
},
booleans: {
patterns: [
{
match: '\\b(true|false)\\b',
name: 'constant.language.boolean.ballerina'
}
]
},
butClause: {
patterns: [
{
begin: '=>',
beginCaptures: {
0: {
name: 'meta.arrow.ballerina storage.type.function.arrow.ballerina'
}
},
end: ',|(?=\\})',
patterns: [{include: '#code'}]
}
]
},
butExp: {
patterns: [
{
begin: '\\bbut\\b',
beginCaptures: {0: {name: 'keyword.ballerina'}},
end: '\\}',
endCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
patterns: [{include: '#butExpBody'}, {include: '#comment'}]
}
]
},
butExpBody: {
patterns: [
{
begin: '\\{',
beginCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
end: '(?=\\})',
endCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
patterns: [
{include: '#parameter'},
{include: '#butClause'},
{include: '#comment'}
]
}
]
},
call: {
patterns: [
{
match: "(?:\\')?([_$[:alpha:]][_$[:alnum:]]*)\\s*(?=\\()",
name: 'entity.name.function.ballerina'
}
]
},
callableUnitBody: {
patterns: [
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '(?=\\})',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [
{include: '#workerDef'},
{include: '#service-decl'},
{include: '#objectDec'},
{include: '#function-defn'},
{include: '#forkStatement'},
{include: '#code'}
]
}
]
},
'class-body': {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
name: 'meta.class.body.ballerina',
patterns: [
{include: '#comment'},
{include: '#mdDocumentation'},
{include: '#function-defn'},
{include: '#var-expr'},
{include: '#variable-initializer'},
{include: '#access-modifier'},
{include: '#keywords'},
{
begin: '(?<=:)\\s*',
end: '(?=\\s|[;),}\\]:\\-\\+]|;|^\\s*$|(?:^\\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|service|type|var)\\b))'
},
{include: '#decl-block'},
{include: '#expression'},
{include: '#punctuation-comma'},
{include: '#punctuation-semicolon'}
]
},
'class-defn': {
begin: '(\\s+)(class\\b)|^class\\b(?=\\s+|/[/*])',
beginCaptures: {
0: {name: 'storage.type.class.ballerina keyword.other.ballerina'}
},
end: '(?<=\\})',
name: 'meta.class.ballerina',
patterns: [
{include: '#keywords'},
{
captures: {0: {name: 'entity.name.type.class.ballerina'}},
match: '[_$[:alpha:]][_$[:alnum:]]*'
},
{include: '#class-body'}
]
},
code: {
patterns: [
{include: '#booleans'},
{include: '#matchStatement'},
{include: '#butExp'},
{include: '#xml'},
{include: '#stringTemplate'},
{include: '#keywords'},
{include: '#strings'},
{include: '#comment'},
{include: '#mdDocumentation'},
{include: '#annotationAttachment'},
{include: '#numbers'},
{include: '#maps'},
{include: '#paranthesised'},
{include: '#paranthesisedBracket'},
{include: '#regex'}
]
},
comment: {patterns: [{match: '\\/\\/.*', name: 'comment.ballerina'}]},
constrainType: {
patterns: [
{
begin: '<',
beginCaptures: {
0: {name: 'punctuation.definition.parameters.begin.ballerina'}
},
end: '>',
endCaptures: {
0: {name: 'punctuation.definition.parameters.end.ballerina'}
},
patterns: [
{include: '#comment'},
{include: '#constrainType'},
{
match: '\\b([_$[:alpha:]][_$[:alnum:]]*)\\b',
name: 'storage.type.ballerina'
}
]
}
]
},
'control-statement': {
patterns: [
{
begin:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(return)(?![_$[:alnum:]])(?:(?=\\.\\.\\.)|(?!\\.))',
beginCaptures: {0: {name: 'keyword.control.flow.ballerina'}},
end: '(?=[;}]|$|;|^\\s*$|(?:^\\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|service|type|var)\\b))',
patterns: [{include: '#expression'}]
},
{include: '#for-loop'},
{include: '#if-statement'},
{
match:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(else|if)(?![_$[:alnum:]])(?:(?=\\.\\.\\.)|(?!\\.))',
name: 'keyword.control.conditional.ballerina'
}
]
},
'decl-block': {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '(?=\\} external;)|(\\})',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
name: 'meta.block.ballerina',
patterns: [{include: '#statements'}, {include: '#mdDocumentation'}]
},
declaration: {
patterns: [
{include: '#import-declaration'},
{include: '#var-expr'},
{include: '#typeDefinition'},
{include: '#function-defn'},
{include: '#service-decl'},
{include: '#class-defn'},
{include: '#enum-decl'},
{include: '#source'},
{include: '#keywords'}
]
},
defaultValue: {
patterns: [
{
begin: '[=:]',
beginCaptures: {0: {name: 'keyword.operator.ballerina'}},
end: '(?=[,)])',
patterns: [{include: '#code'}]
}
]
},
defaultWithParentheses: {
patterns: [
{
begin: '\\(',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '\\)',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}}
}
]
},
documentationBody: {
patterns: [
{
begin: '\\{',
beginCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
end: '(?=\\})',
endCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
patterns: [
{
captures: {
1: {name: 'keyword.other.ballerina.documentation'},
2: {name: 'keyword.other.ballerina.documentation'},
3: {name: 'variable.parameter.ballerina.documentation'},
4: {name: 'keyword.other.ballerina.documentation'}
},
match: '(P|R|T|F|V)({{)(.*)(}})'
},
{
begin: '\\```',
end: '\\```',
name: 'comment.block.code.ballerina.documentation'
},
{
begin: '\\``',
end: '\\``',
name: 'comment.block.code.ballerina.documentation'
},
{
begin: '\\`',
end: '\\`',
name: 'comment.block.code.ballerina.documentation'
},
{match: '.', name: 'comment.block.ballerina.documentation'}
]
}
]
},
documentationDef: {
patterns: [
{
begin: '\\b(?:documentation|deprecated)\\b',
beginCaptures: {0: {name: 'keyword.ballerina'}},
end: '\\}',
endCaptures: {0: {name: 'delimiter.curly'}},
patterns: [{include: '#documentationBody'}, {include: '#comment'}]
}
]
},
'enum-decl': {
begin: '(?:\\b(const)\\s+)?\\b(enum)\\s+([_$[:alpha:]][_$[:alnum:]]*)',
beginCaptures: {
1: {name: 'storage.modifier.ballerina'},
2: {name: 'keyword.other.ballerina'},
3: {name: 'entity.name.type.enum.ballerina'}
},
end: '(?<=\\})',
name: 'meta.enum.declaration.ballerina',
patterns: [
{include: '#comment'},
{include: '#mdDocumentation'},
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [
{include: '#comment'},
{include: '#mdDocumentation'},
{
begin: '([_$[:alpha:]][_$[:alnum:]]*)',
beginCaptures: {0: {name: 'variable.other.enummember.ballerina'}},
end: '(?=,|\\}|$)',
patterns: [
{include: '#comment'},
{include: '#variable-initializer'}
]
},
{
begin:
'(?=((\\\'([^\\\'\\\\]|\\\\.)*\\\')|(\\"([^\\"\\\\]|\\\\.)*\\")|(\\`([^\\`\\\\]|\\\\.)*\\`)|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])+\\])))',
end: '(?=,|\\}|$)',
patterns: [
{include: '#string'},
{include: '#array-literal'},
{include: '#comment'},
{include: '#variable-initializer'}
]
},
{include: '#punctuation-comma'}
]
}
]
},
errorDestructure: {
patterns: [
{
begin: 'error',
beginCaptures: {0: {name: 'storage.type.ballerina'}},
end: '(?==>)',
patterns: [{include: '#code'}]
}
]
},
expression: {
patterns: [
{include: '#keywords'},
{include: '#expressionWithoutIdentifiers'},
{include: '#identifiers'},
{include: '#regex'}
]
},
'expression-operators': {
patterns: [
{
match: '\\*=|(?<!\\()/=|%=|\\+=|\\-=',
name: 'keyword.operator.assignment.compound.ballerina'
},
{
match: '\\&=|\\^=|<<=|>>=|>>>=|\\|=',
name: 'keyword.operator.assignment.compound.bitwise.ballerina'
},
{match: '<<|>>>|>>', name: 'keyword.operator.bitwise.shift.ballerina'},
{match: '===|!==|==|!=', name: 'keyword.operator.comparison.ballerina'},
{match: '<=|>=|<>|<|>', name: 'keyword.operator.relational.ballerina'},
{
captures: {
1: {name: 'keyword.operator.logical.ballerina'},
2: {name: 'keyword.operator.assignment.compound.ballerina'},
3: {name: 'keyword.operator.arithmetic.ballerina'}
},
match: '(?<=[_$[:alnum:]])(\\!)\\s*(?:(/=)|(?:(/)(?![/*])))'
},
{
match: '\\!|&&|\\|\\||\\?\\?',
name: 'keyword.operator.logical.ballerina'
},
{match: '\\&|~|\\^|\\|', name: 'keyword.operator.bitwise.ballerina'},
{match: '\\=', name: 'keyword.operator.assignment.ballerina'},
{match: '--', name: 'keyword.operator.decrement.ballerina'},
{match: '\\+\\+', name: 'keyword.operator.increment.ballerina'},
{match: '%|\\*|/|-|\\+', name: 'keyword.operator.arithmetic.ballerina'}
]
},
expressionWithoutIdentifiers: {
patterns: [
{include: '#xml'},
{include: '#string'},
{include: '#stringTemplate'},
{include: '#comment'},
{include: '#object-literal'},
{include: '#ternary-expression'},
{include: '#expression-operators'},
{include: '#literal'},
{include: '#paranthesised'},
{include: '#regex'}
]
},
'flags-on-off': {
name: 'meta.flags.regexp.ballerina',
patterns: [
{
begin: '(\\??)([imsx]*)(-?)([imsx]*)(:)',
beginCaptures: {
1: {
name: 'punctuation.other.non-capturing-group-begin.regexp.ballerina'
},
2: {
name: 'keyword.other.non-capturing-group.flags-on.regexp.ballerina'
},
3: {
name: 'punctuation.other.non-capturing-group.off.regexp.ballerina'
},
4: {
name: 'keyword.other.non-capturing-group.flags-off.regexp.ballerina'
},
5: {
name: 'punctuation.other.non-capturing-group-end.regexp.ballerina'
}
},
end: '()',
name: 'constant.other.flag.regexp.ballerina',
patterns: [
{include: '#regexp'},
{include: '#template-substitution-element'}
]
}
]
},
'for-loop': {
begin: '(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))foreach\\s*',
beginCaptures: {
0: {name: 'keyword.control.loop.ballerina'},
1: {name: 'support.type.primitive.ballerina'}
},
end: '(?=\\{)',
patterns: [
{match: '\\bin\\b', name: 'keyword.other.ballerina'},
{include: '#identifiers'},
{include: '#comment'},
{include: '#var-expr'},
{include: '#expression'}
]
},
forkBody: {
patterns: [
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '(?=\\})',
patterns: [{include: '#workerDef'}]
}
]
},
forkStatement: {
patterns: [
{
begin: '\\bfork\\b',
beginCaptures: {0: {name: 'keyword.control.ballerina'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [{include: '#forkBody'}]
}
]
},
'function-body': {
patterns: [
{include: '#comment'},
{include: '#functionParameters'},
{include: '#decl-block'},
{
begin: '\\=>',
beginCaptures: {
0: {
name: 'meta.arrow.ballerina storage.type.function.arrow.ballerina'
}
},
end: '(?=\\;)|(?=\\,)|(?=)(?=\\);)',
name: 'meta.block.ballerina',
patterns: [
{include: '#natural-expr'},
{include: '#statements'},
{include: '#punctuation-comma'}
]
},
{match: '\\*', name: 'keyword.generator.asterisk.ballerina'}
]
},
'function-defn': {
begin: '(?:(public|private)\\s+)?(function\\b)',
beginCaptures: {
1: {name: 'keyword.other.ballerina'},
2: {name: 'keyword.other.ballerina'}
},
end: '(?<=\\;)|(?<=\\})|(?<=\\,)|(?=)(?=\\);)',
name: 'meta.function.ballerina',
patterns: [
{match: '\\bexternal\\b', name: 'keyword.ballerina'},
{include: '#stringTemplate'},
{include: '#annotationAttachment'},
{include: '#functionReturns'},
{include: '#functionName'},
{include: '#functionParameters'},
{include: '#punctuation-semicolon'},
{include: '#function-body'},
{include: '#regex'}
]
},
'function-parameters-body': {
patterns: [
{include: '#comment'},
{include: '#numbers'},
{include: '#string'},
{include: '#annotationAttachment'},
{include: '#recordLiteral'},
{include: '#keywords'},
{include: '#parameter-name'},
{include: '#array-literal'},
{include: '#variable-initializer'},
{include: '#identifiers'},
{include: '#regex'},
{match: '\\,', name: 'punctuation.separator.parameter.ballerina'}
]
},
functionName: {
patterns: [
{match: '\\bfunction\\b', name: 'keyword.other.ballerina'},
{include: '#type-primitive'},
{include: '#self-literal'},
{include: '#string'},
{
captures: {
2: {name: 'variable.language.this.ballerina'},
3: {name: 'keyword.other.ballerina'},
4: {name: 'support.type.primitive.ballerina'},
5: {name: 'storage.type.ballerina'},
6: {
name: 'meta.definition.function.ballerina entity.name.function.ballerina'
}
},
match:
'\\s+(\\b(self)|\\b(is|new|isolated|null|function|in)\\b|(string|int|boolean|float|byte|decimal|json|xml|anydata)\\b|\\b(readonly|error|map)\\b|([_$[:alpha:]][_$[:alnum:]]*))'
}
]
},
functionParameters: {
begin: '\\(|\\[',
beginCaptures: {
0: {name: 'punctuation.definition.parameters.begin.ballerina'}
},
end: '\\)|\\]',
endCaptures: {
0: {name: 'punctuation.definition.parameters.end.ballerina'}
},
name: 'meta.parameters.ballerina',
patterns: [{include: '#function-parameters-body'}]
},
functionReturns: {
begin: '\\s*(returns)\\s*',
beginCaptures: {1: {name: 'keyword.other.ballerina'}},
end: '(?==>)|(\\=)|(?=\\{)|(\\))|(?=\\;)',
endCaptures: {1: {name: 'keyword.operator.ballerina'}},
name: 'meta.type.function.return.ballerina',
patterns: [
{include: '#comment'},
{include: '#string'},
{include: '#numbers'},
{include: '#keywords'},
{include: '#type-primitive'},
{
captures: {1: {name: 'support.type.primitive.ballerina'}},
match: '\\s*\\b(var)(?=\\s+|\\[|\\?)'
},
{match: '\\|', name: 'keyword.operator.ballerina'},
{match: '\\?', name: 'keyword.operator.optional.ballerina'},
{include: '#type-annotation'},
{include: '#type-tuple'},
{include: '#keywords'},
{
match: '[_$[:alpha:]][_$[:alnum:]]*',
name: 'variable.other.readwrite.ballerina'
}
]
},
functionType: {
patterns: [
{
begin: '\\bfunction\\b',
beginCaptures: {0: {name: 'keyword.ballerina'}},
end: '(?=\\,)|(?=\\|)|(?=\\:)|(?==>)|(?=\\))|(?=\\])',
patterns: [
{include: '#comment'},
{include: '#functionTypeParamList'},
{include: '#functionTypeReturns'}
]
}
]
},
functionTypeParamList: {
patterns: [
{
begin: '\\(',
beginCaptures: {0: {name: 'delimiter.parenthesis'}},
end: '\\)',
endCaptures: {0: {name: 'delimiter.parenthesis'}},
patterns: [
{match: 'public', name: 'keyword'},
{include: '#annotationAttachment'},
{include: '#recordLiteral'},
{include: '#record'},
{include: '#objectDec'},
{include: '#functionType'},
{include: '#constrainType'},
{include: '#parameterTuple'},
{include: '#functionTypeType'},
{include: '#comment'}
]
}
]
},
functionTypeReturns: {
patterns: [
{
begin: '\\breturns\\b',
beginCaptures: {0: {name: 'keyword'}},
end: '(?=\\,)|(?:\\|)|(?=\\])|(?=\\))',
patterns: [
{include: '#functionTypeReturnsParameter'},
{include: '#comment'}
]
}
]
},
functionTypeReturnsParameter: {
patterns: [
{
begin: '((?=record|object|function)|(?:[_$[:alpha:]][_$[:alnum:]]*))',
beginCaptures: {0: {name: 'storage.type.ballerina'}},
end: '(?=\\,)|(?:\\|)|(?:\\:)|(?==>)|(?=\\))|(?=\\])',
patterns: [
{include: '#record'},
{include: '#objectDec'},
{include: '#functionType'},
{include: '#constrainType'},
{include: '#defaultValue'},
{include: '#comment'},
{include: '#parameterTuple'},
{
match: '[_$[:alpha:]][_$[:alnum:]]*',
name: 'default.variable.parameter.ballerina'
}
]
}
]
},
functionTypeType: {
patterns: [
{
begin: '[_$[:alpha:]][_$[:alnum:]]*',
beginCaptures: {0: {name: 'storage.type.ballerina'}},
end: '(?=\\,)|(?:\\|)|(?=\\])|(?=\\))'
}
]
},
identifiers: {
patterns: [
{
captures: {
1: {name: 'punctuation.accessor.ballerina'},
2: {name: 'punctuation.accessor.optional.ballerina'},
3: {name: 'entity.name.function.ballerina'}
},
match:
'(?x)(?:(?:(\\.)|(\\?\\.(?!\\s*[[:digit:]])))\\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\\s*=\\s*(\n ((\n (function\\s*[(<*]) |\n (function\\s+) |\n ([_$[:alpha:]][_$[:alnum:]]*\\s*=>)\n )) |\n ((\n ((<\\s*$)|((<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<])*\\>)*\\>)*>\\s*)?[\\(]\\s*((([\\{\\[]\\s*)?$)|((\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})\\s*((:\\s*\\{?$)|((\\s*([^<>\\(\\)\\{\\}]|\\<([^<>]|\\<([^<>]|\\<[^<>]+\\>)+\\>)+\\>|\\([^\\(\\)]+\\)|\\{[^\\{\\}]+\\})+\\s*)?=\\s*)))|((\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\])\\s*((:\\s*\\[?$)|((\\s*([^<>\\(\\)\\{\\}]|\\<([^<>]|\\<([^<>]|\\<[^<>]+\\>)+\\>)+\\>|\\([^\\(\\)]+\\)|\\{[^\\{\\}]+\\})+\\s*)?=\\s*)))))) |\n # sure shot arrow functions even if => is on new line\n(\n (<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<])*\\>)*\\>)*>\\s*)?\n [(]\\s*(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*\n (\n ([)]\\s*:) | # ():\n ((\\.\\.\\.\\s*)?[_$[:alpha:]][_$[:alnum:]]*\\s*:) # [(]param: | [(]...param:\n )\n) |\n\n# arrow function possible to detect only with => on same line\n(\n (<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<])*\\>)*\\>)*>\\s*)? # typeparameters\n \\(\\s*(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*(([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\])|(\\.\\.\\.\\s*[_$[:alpha:]]))([^()\\\'\\"\\`]|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\\'([^\\\'\\\\]|\\\\.)*\\\')|(\\"([^\\"\\\\]|\\\\.)*\\")|(\\`([^\\`\\\\]|\\\\.)*\\`))*)?\\) # parameters\n (\\s*:\\s*([^<>\\(\\)\\{\\}]|\\<([^<>]|\\<([^<>]|\\<[^<>]+\\>)+\\>)+\\>|\\([^\\(\\)]+\\)|\\{[^\\{\\}]+\\})+)? # return type\n \\s*=> # arrow operator\n)\n ))\n))'
},
{
captures: {
1: {name: 'punctuation.accessor.ballerina'},
2: {name: 'punctuation.accessor.optional.ballerina'},
3: {name: 'entity.name.function.ballerina'}
},
match:
'(?:(\\.)|(\\?\\.(?!\\s*[[:digit:]])))\\s*(\\#?[_$[:alpha:]][_$[:alnum:]]*)\\s*(?=\\()'
},
{
captures: {
1: {name: 'punctuation.accessor.ballerina'},
2: {name: 'punctuation.accessor.optional.ballerina'},
3: {name: 'variable.other.property.ballerina'}
},
match:
'(?:(\\.)|(\\?\\.(?!\\s*[[:digit:]])))\\s*(\\#?[_$[:alpha:]][_$[:alnum:]]*)'
},
{include: '#type-primitive'},
{include: '#self-literal'},
{
match: '\\b(check|foreach|if|checkpanic)\\b',
name: 'keyword.control.ballerina'
},
{include: '#natural-expr'},
{include: '#call'},
{match: '\\b(var)\\b', name: 'support.type.primitive.ballerina'},
{
captures: {
1: {name: 'variable.other.readwrite.ballerina'},
3: {name: 'punctuation.accessor.ballerina'},
4: {name: 'entity.name.function.ballerina'},
5: {name: 'punctuation.definition.parameters.begin.ballerina'},
6: {name: 'punctuation.definition.parameters.end.ballerina'}
},
match:
'([_$[:alpha:]][_$[:alnum:]]*)((\\.)([_$[:alpha:]][_$[:alnum:]]*)(\\()(\\)))?'
},
{
match: "(\\')([_$[:alpha:]][_$[:alnum:]]*)",
name: 'variable.other.property.ballerina'
},
{include: '#type-annotation'}
]
},
'if-statement': {
patterns: [
{
begin:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(?=\\bif\\b\\s*(?!\\{))',
end: '(?<=\\})',
patterns: [
{include: '#comment'},
{
begin:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(if)\\s*(\\()?',
beginCaptures: {
1: {name: 'keyword.control.conditional.ballerina'},
2: {name: 'meta.brace.round.ballerina'}
},
end: '(\\))|(?=\\{)',
endCaptures: {1: {name: 'meta.brace.round.ballerina'}},
patterns: [
{include: '#decl-block'},
{include: '#keywords'},
{include: '#identifiers'},
{include: '#type-primitive'},
{include: '#xml'},
{include: '#string'},
{include: '#stringTemplate'},
{include: '#comment'},
{include: '#ternary-expression'},
{include: '#expression-operators'},
{include: '#literal'},
{include: '#paranthesised'},
{include: '#regex'}
]
},
{
begin: '(?<=\\))(?=\\s|\\=)',
end: '(?=\\{)',
patterns: [{include: '#literal'}, {include: '#keywords'}]
},
{include: '#decl-block'}
]
}
]
},
'import-clause': {
patterns: [
{include: '#comment'},
{
captures: {
1: {name: 'keyword.control.default.ballerina'},
3: {
name: 'variable.other.readwrite.ballerina meta.import.module.ballerina'
},
5: {name: 'keyword.control.default.ballerina'},
6: {name: 'variable.other.readwrite.alias.ballerina'}
},
match:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(?:(\\bdefault)|(\\*)|(\\b[_$[:alpha:]][_$[:alnum:]]*))'
},
{
match: '([_$[:alpha:]][_$[:alnum:]]*)',
name: 'variable.other.readwrite.alias.ballerina'
}
]
},
'import-declaration': {
begin: '\\bimport\\b',
beginCaptures: {0: {name: 'keyword.control.import.ballerina'}},
end: '\\;',
endCaptures: {0: {name: 'punctuation.terminator.statement.ballerina'}},
name: 'meta.import.ballerina',
patterns: [
{
match: "(\\')([_$[:alpha:]][_$[:alnum:]]*)",
name: 'variable.other.property.ballerina'
},
{include: '#keywords'},
{include: '#comment'},
{include: '#import-clause'},
{include: '#punctuation-accessor'}
]
},
keywords: {
patterns: [
{
match:
'\\b(fork|join|while|returns|transaction|transactional|retry|commit|rollback|typeof|enum|wait|match)\\b',
name: 'keyword.control.ballerina'
},
{
match:
'\\b(return|break|continue|check|checkpanic|panic|trap|from|where)\\b',
name: 'keyword.control.flow.ballerina'
},
{
match:
'\\b(public|private|external|return|record|object|remote|abstract|client|true|false|fail|import|version)\\b',
name: 'keyword.other.ballerina'
},
{
match:
'\\b(as|on|function|resource|listener|const|final|is|null|lock|annotation|source|worker|parameter|field|isolated|in)\\b',
name: 'keyword.other.ballerina'
},
{
match:
'\\b(xmlns|table|key|let|new|select|start|flush|default|do|base16|base64|conflict)\\b',
name: 'keyword.other.ballerina'
},
{
match:
'\\b(limit|outer|equals|order|by|ascending|descending|class|configurable|variable|module|service|group|collect)\\b',
name: 'keyword.other.ballerina'
},
{
match: '(=>)',
name: 'meta.arrow.ballerina storage.type.function.arrow.ballerina'
},
{
match:
'(!|%|\\+|\\-|~=|===|==|=|!=|!==|<|>|&|\\||\\?:|\\.\\.\\.|<=|>=|&&|\\|\\||~|>>|>>>)',
name: 'keyword.operator.ballerina'
},
{include: '#types'},
{include: '#self-literal'},
{include: '#type-primitive'}
]
},
literal: {
patterns: [
{include: '#booleans'},
{include: '#numbers'},
{include: '#strings'},
{include: '#maps'},
{include: '#self-literal'},
{include: '#array-literal'}
]
},
maps: {
patterns: [{begin: '\\{', end: '\\}', patterns: [{include: '#code'}]}]
},
matchBindingPattern: {
patterns: [
{
begin: 'var',
beginCaptures: {0: {name: 'storage.type.ballerina'}},
end: '(?==>)|,',
patterns: [
{include: '#errorDestructure'},
{include: '#code'},
{
match: '[_$[:alpha:]][_$[:alnum:]]*',
name: 'variable.parameter.ballerina'
}
]
}
]
},
matchStatement: {
patterns: [
{
begin: '\\bmatch\\b',
beginCaptures: {0: {name: 'keyword.control.ballerina'}},
end: '\\}',
patterns: [
{include: '#matchStatementBody'},
{include: '#comment'},
{include: '#code'}
]
}
]
},
matchStatementBody: {
patterns: [
{
begin: '\\{',
beginCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
end: '(?=\\})',
endCaptures: {
0: {name: 'punctuation.definition.block.ballerina.documentation'}
},
patterns: [
{include: '#literal'},
{include: '#matchBindingPattern'},
{include: '#matchStatementPatternClause'},
{include: '#comment'},
{include: '#code'}
]
}
]
},
matchStatementPatternClause: {
patterns: [
{
begin: '=>',
beginCaptures: {0: {name: 'keyword.ballerina'}},
end: '((\\})|;|,)',
patterns: [{include: '#callableUnitBody'}, {include: '#code'}]
}
]
},
mdDocumentation: {
begin: '\\#',
end: '[\\r\\n]+',
name: 'comment.mddocs.ballerina',
patterns: [
{include: '#mdDocumentationReturnParamDescription'},
{include: '#mdDocumentationParamDescription'}
]
},
mdDocumentationParamDescription: {
patterns: [
{
begin: "(\\+\\s+)(\\'?[_$[:alpha:]][_$[:alnum:]]*)(\\s*\\-\\s+)",
beginCaptures: {
1: {name: 'keyword.operator.ballerina'},
2: {name: 'variable.other.readwrite.ballerina'},
3: {name: 'keyword.operator.ballerina'}
},
end: '(?=[^#\\r\\n]|(?:# *?\\+))',
patterns: [{match: '#.*', name: 'comment.mddocs.paramdesc.ballerina'}]
}
]
},
mdDocumentationReturnParamDescription: {
patterns: [
{
begin: '(#)(?: *?)(\\+)(?: *)(return)(?: *)(-)?(.*)',
beginCaptures: {
1: {name: 'comment.mddocs.ballerina'},
2: {name: 'keyword.ballerina'},
3: {name: 'keyword.ballerina'},
4: {name: 'keyword.ballerina'},
5: {name: 'comment.mddocs.returnparamdesc.ballerina'}
},
end: '(?=[^#\\r\\n]|(?:# *?\\+))',
patterns: [
{match: '#.*', name: 'comment.mddocs.returnparamdesc.ballerina'}
]
}
]
},
multiType: {
patterns: [
{
match:
'(?<=\\|)([_$[:alpha:]][_$[:alnum:]]*)|([_$[:alpha:]][_$[:alnum:]]*)(?=\\|)',
name: 'storage.type.ballerina'
},
{match: '\\|', name: 'keyword.operator.ballerina'}
]
},
'natural-expr': {
patterns: [
{
begin: 'natural',
beginCaptures: {0: {name: 'keyword.other.ballerina'}},
end: '(?=\\})',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [{include: '#natural-expr-body'}]
}
]
},
'natural-expr-body': {
patterns: [
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
contentName: 'string.template.ballerina',
end: '(?=\\})',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [
{include: '#template-substitution-element'},
{include: '#string-character-escape'},
{include: '#templateVariable'}
]
}
]
},
numbers: {
patterns: [
{
match: '\\b0[xX][\\da-fA-F]+\\b|\\b\\d+(?:\\.(?:\\d+|$))?',
name: 'constant.numeric.decimal.ballerina'
}
]
},
'object-literal': {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
name: 'meta.objectliteral.ballerina',
patterns: [{include: '#object-member'}, {include: '#punctuation-comma'}]
},
'object-member': {
patterns: [
{include: '#comment'},
{include: '#function-defn'},
{include: '#literal'},
{include: '#keywords'},
{include: '#expression'},
{
begin: '(?=\\[)',
end: '(?=:)|((?<=[\\]])(?=\\s*[\\(\\<]))',
name: 'meta.object.member.ballerina meta.object-literal.key.ballerina',
patterns: [{include: '#comment'}]
},
{
begin: '(?=[\\\'\\"\\`])',
end: '(?=:)|((?<=[\\\'\\"\\`])(?=((\\s*[\\(\\<,}])|(\\n*})|(\\s+(as)\\s+))))',
name: 'meta.object.member.ballerina meta.object-literal.key.ballerina',
patterns: [{include: '#comment'}, {include: '#string'}]
},
{
begin:
'(?x)(?=(\\b(?<!\\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\\b(?!\\$))|(\\b(?<!\\$)0(?:b|B)[01][01_]*(n)?\\b(?!\\$))|(\\b(?<!\\$)0(?:o|O)?[0-7][0-7_]*(n)?\\b(?!\\$))|((?<!\\$)(?:\n (?:\\b[0-9][0-9_]*(\\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\\b)| # 1.1E+3\n (?:\\b[0-9][0-9_]*(\\.)[eE][+-]?[0-9][0-9_]*(n)?\\b)| # 1.E+3\n (?:\\B(\\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\\b)| # .1E+3\n (?:\\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\\b)| # 1E+3\n (?:\\b[0-9][0-9_]*(\\.)[0-9][0-9_]*(n)?\\b)| # 1.1\n (?:\\b[0-9][0-9_]*(\\.)(n)?\\B)| # 1.\n (?:\\B(\\.)[0-9][0-9_]*(n)?\\b)| # .1\n (?:\\b[0-9][0-9_]*(n)?\\b(?!\\.)) # 1\n)(?!\\$)))',
end: '(?=:)|(?=\\s*([\\(\\<,}])|(\\s+as\\s+))',
name: 'meta.object.member.ballerina meta.object-literal.key.ballerina',
patterns: [{include: '#comment'}, {include: '#numbers'}]
},
{
begin: '(?<=[\\]\\\'\\"\\`])(?=\\s*[\\(\\<])',
end: '(?=\\}|;|,)|(?<=\\})',
name: 'meta.method.declaration.ballerina',
patterns: [{include: '#function-body'}]
},
{
captures: {
0: {name: 'meta.object-literal.key.ballerina'},
1: {name: 'constant.numeric.decimal.ballerina'}
},
match:
'(?![_$[:alpha:]])([[:digit:]]+)\\s*(?=(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*:)',
name: 'meta.object.member.ballerina'
},
{
captures: {
0: {name: 'meta.object-literal.key.ballerina'},
1: {name: 'entity.name.function.ballerina'}
},
match:
'(?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\\s*(?=(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*:(\\s*\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/)*\\s*(\n ((\n (function\\s*[(<*]) |\n (function\\s+) |\n ([_$[:alpha:]][_$[:alnum:]]*\\s*=>)\n )) |\n ((\n ((<\\s*$)|((<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<])*\\>)*\\>)*>\\s*)?[\\(]\\s*((([\\{\\[]\\s*)?$)|((\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})\\s*((:\\s*\\{?$)|((\\s*([^<>\\(\\)\\{\\}]|\\<([^<>]|\\<([^<>]|\\<[^<>]+\\>)+\\>)+\\>|\\([^\\(\\)]+\\)|\\{[^\\{\\}]+\\})+\\s*)?=\\s*)))|((\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\])\\s*((:\\s*\\[?$)|((\\s*([^<>\\(\\)\\{\\}]|\\<([^<>]|\\<([^<>]|\\<[^<>]+\\>)+\\>)+\\>|\\([^\\(\\)]+\\)|\\{[^\\{\\}]+\\})+\\s*)?=\\s*)))))) |\n # sure shot arrow functions even if => is on new line\n(\n (<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<])*\\>)*\\>)*>\\s*)?\n [(]\\s*(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*\n (\n ([)]\\s*:) | # ():\n ((\\.\\.\\.\\s*)?[_$[:alpha:]][_$[:alnum:]]*\\s*:) # [(]param: | [(]...param:\n )\n) |\n\n# arrow function possible to detect only with => on same line\n(\n (<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<]|\\<\\s*([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\]))([^=<>]|=[^<])*\\>)*\\>)*>\\s*)? # typeparameters\n \\(\\s*(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*(([_$[:alpha:]]|(\\{([^\\{\\}]|(\\{([^\\{\\}]|\\{[^\\{\\}]*\\})*\\}))*\\})|(\\[([^\\[\\]]|(\\[([^\\[\\]]|\\[[^\\[\\]]*\\])*\\]))*\\])|(\\.\\.\\.\\s*[_$[:alpha:]]))([^()\\\'\\"\\`]|(\\(([^\\(\\)]|(\\(([^\\(\\)]|\\([^\\(\\)]*\\))*\\)))*\\))|(\\\'([^\\\'\\\\]|\\\\.)*\\\')|(\\"([^\\"\\\\]|\\\\.)*\\")|(\\`([^\\`\\\\]|\\\\.)*\\`))*)?\\) # parameters\n (\\s*:\\s*([^<>\\(\\)\\{\\}]|\\<([^<>]|\\<([^<>]|\\<[^<>]+\\>)+\\>)+\\>|\\([^\\(\\)]+\\)|\\{[^\\{\\}]+\\})+)? # return type\n \\s*=> # arrow operator\n)\n ))\n)))',
name: 'meta.object.member.ballerina'
},
{
captures: {0: {name: 'meta.object-literal.key.ballerina'}},
match:
'(?:[_$[:alpha:]][_$[:alnum:]]*)\\s*(?=(\\/\\*([^\\*]|(\\*[^\\/]))*\\*\\/\\s*)*:)',
name: 'meta.object.member.ballerina'
},
{
begin: '\\.\\.\\.',
beginCaptures: {0: {name: 'keyword.operator.spread.ballerina'}},
end: '(?=,|\\})',
name: 'meta.object.member.ballerina',
patterns: [{include: '#expression'}]
},
{
captures: {1: {name: 'variable.other.readwrite.ballerina'}},
match: '([_$[:alpha:]][_$[:alnum:]]*)\\s*(?=,|\\}|$|\\/\\/|\\/\\*)',
name: 'meta.object.member.ballerina'
},
{
captures: {
1: {name: 'keyword.control.as.ballerina'},
2: {name: 'storage.modifier.ballerina'}
},
match:
'(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(as)\\s+(const)(?=\\s*([,}]|$))',
name: 'meta.object.member.ballerina'
},
{
begin: '(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(as)\\s+',
beginCaptures: {1: {name: 'keyword.control.as.ballerina'}},
end: '(?=[;),}\\]:?\\-\\+\\>]|\\|\\||\\&\\&|\\!\\=\\=|$|^|((?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(as)\\s+))',
name: 'meta.object.member.ballerina'
},
{
begin: '(?=[_$[:alpha:]][_$[:alnum:]]*\\s*=)',
end: '(?=,|\\}|$|\\/\\/|\\/\\*)',
name: 'meta.object.member.ballerina',
patterns: [{include: '#expression'}]
}
]
},
objectDec: {
patterns: [
{
begin: '\\bobject\\b(?!:)',
beginCaptures: {0: {name: 'keyword.other.ballerina'}},
end: '(?<=\\})',
patterns: [{include: '#decl-block'}]
}
]
},
objectInitBody: {
patterns: [
{
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
end: '(?=\\})',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [{include: '#comment'}, {include: '#code'}]
}
]
},
objectInitParameters: {
patterns: [
{
begin: '\\(',
beginCaptures: {
0: {name: 'punctuation.definition.parameters.begin.ballerina'}
},
end: '\\)',
endCaptures: {
0: {name: 'punctuation.definition.parameters.end.ballerina'}
},
patterns: [
{include: '#code'},
{
match: '\\b([_$[:alpha:]][_$[:alnum:]]*)\\b',
name: 'variable.parameter.ballerina'
}
]
}
]
},
objectMemberFunctionDec: {
patterns: [
{
begin: '\\bfunction\\b',
beginCaptures: {0: {name: 'keyword.ballerina'}},
end: ';',
endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
patterns: [
{include: '#functionParameters'},
{match: '\\breturns\\b', name: 'keyword.ballerina'},
{include: '#code'}
]
}
]
},
parameter: {
patterns: [
{
begin:
'((?=record|object|function)|([_$[:alpha:]][_$[:alnum:]]*)(?=\\|)|(?:[_$[:alpha:]][_$[:alnum:]]*))',
beginCaptures: {0: {name: 'storage.type.ballerina'}},
end: '(?:\\,)|(?:\\|)|(?:\\:)|(?==>)|(?=\\))|(?=\\])',
patterns: [
{include: '#parameterWithDescriptor'},
{include: '#record'},
{include: '#objectDec'},
{include: '#functionType'},
{include: '#constrainType'},
{include: '#defaultValue'},
{include: '#comment'},
{include: '#parameterTuple'},
{
match: '[_$[:alpha:]][_$[:alnum:]]*',
name: 'default.variable.parameter.ballerina'
}
]
}
]
},
'parameter-name': {
patterns: [
{
captures: {1: {name: 'support.type.primitive.ballerina'}},
match: '\\s*\\b(var)\\s+'
},
{
captures: {
10: {name: 'keyword.operator.optional.ballerina'},
2: {name: 'keyword.operator.rest.ballerina'},
3: {name: 'support.type.primitive.ballerina'},
4: {name: 'keyword.other.ballerina'},
5: {name: 'constant.language.boolean.ballerina'},
6: {name: 'keyword.control.flow.ballerina'},
7: {name: 'storage.type.ballerina'},
8: {name: 'variable.parameter.ballerina'},
9: {name: 'variable.parameter.ballerina'}
},
match:
'(?x)(?:(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))\\s+)?(?:(\\.\\.\\.)\\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(?:(this)|(string|int|boolean|float|byte|decimal|json|xml|anydata)|\\b(is|new|isolated|null|function|in)\\b|\\b(true|false)\\b|\\b(check|foreach|if|checkpanic)\\b|\\b(readonly|error|map)\\b|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\\.\\.\\.)|(?!\\.))\\s*(\\??)'
}
]
},
parameterTuple: {
patterns: [
{
begin: '\\[',
end: '(?=\\,)|(?=\\|)|(?=\\:)|(?==>)|(?=\\))',
patterns: [
{include: '#record'},
{include: '#objectDec'},
{include: '#parameterTupleType'},
{include: '#parameterTupleEnd'},
{include: '#comment'}
]
}
]
},
parameterTupleEnd: {
patterns: [
{
begin: '\\]',
end: '(?=\\,)|(?=\\|)|(?=\\:)|(?==>)|(?=\\))',
patterns: