@wooorm/starry-night
Version:
Syntax highlighting, like GitHub
1,321 lines (1,320 loc) • 92.3 kB
JavaScript
// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/modularml/mojo-syntax>
// and licensed `mit`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
* @import {Grammar} from '@wooorm/starry-night'
*/
/** @type {Grammar} */
const grammar = {
extensions: ['.mojo'],
names: ['mojo'],
patterns: [{include: '#statement'}, {include: '#expression'}],
repository: {
'annotated-parameter': {
begin: '(?x)\n \\b\n ([[:alpha:]_]\\w*) \\s* (:)\n',
beginCaptures: {
1: {name: 'variable.parameter.function.language.python'},
2: {name: 'punctuation.separator.annotation.python'}
},
end: '(,)|(?=\\))',
endCaptures: {1: {name: 'punctuation.separator.parameters.python'}},
patterns: [
{include: '#expression'},
{match: '=(?!=)', name: 'keyword.operator.assignment.python'}
]
},
'assignment-operator': {
match:
'(?x)\n <<= | >>= | //= | \\*\\*=\n | \\+= | -= | /= | @=\n | \\*= | %= | ~= | \\^= | &= | \\|=\n | =(?!=)\n',
name: 'keyword.operator.assignment.python'
},
backticks: {
begin: '\\`',
end: '(?:\\`|(?<!\\\\)(\\n))',
name: 'string.quoted.single.python'
},
'builtin-callables': {
patterns: [
{include: '#illegal-names'},
{include: '#illegal-object-name'},
{include: '#builtin-exceptions'},
{include: '#builtin-functions'},
{include: '#builtin-types'}
]
},
'builtin-exceptions': {
match:
'(?x) (?<!\\.) \\b(\n (\n Arithmetic | Assertion | Attribute | Buffer | BlockingIO\n | BrokenPipe | ChildProcess\n | (Connection (Aborted | Refused | Reset)?)\n | EOF | Environment | FileExists | FileNotFound\n | FloatingPoint | IO | Import | Indentation | Index | Interrupted\n | IsADirectory | NotADirectory | Permission | ProcessLookup\n | Timeout\n | Key | Lookup | Memory | Name | NotImplemented | OS | Overflow\n | Reference | Runtime | Recursion | Syntax | System\n | Tab | Type | UnboundLocal | Unicode(Encode|Decode|Translate)?\n | Value | Windows | ZeroDivision | ModuleNotFound\n ) Error\n|\n ((Pending)?Deprecation | Runtime | Syntax | User | Future | Import\n | Unicode | Bytes | Resource\n )? Warning\n|\n SystemExit | Stop(Async)?Iteration\n | KeyboardInterrupt\n | GeneratorExit | (Base)?Exception\n)\\b\n',
name: 'support.type.exception.python'
},
'builtin-functions': {
patterns: [
{
match:
'(?x)\n (?<!\\.) \\b(\n __import__ | abs | aiter | all | any | anext | ascii | bin\n | breakpoint | callable | chr | compile | copyright | credits\n | delattr | dir | divmod | enumerate | eval | exec | exit\n | filter | format | getattr | globals | hasattr | hash | help\n | hex | id | input | isinstance | issubclass | iter | len\n | license | locals | map | max | memoryview | min | next\n | oct | open | ord | pow | print | quit | range | reload | repr\n | reversed | round | setattr | sorted | sum | vars | zip\n )\\b\n',
name: 'support.function.builtin.python'
},
{
match:
'(?x)\n (?<!\\.) \\b(\n file | reduce | intern | raw_input | unicode | cmp | basestring\n | execfile | long | xrange\n )\\b\n',
name: 'variable.legacy.builtin.python'
}
]
},
'builtin-possible-callables': {
patterns: [{include: '#builtin-callables'}, {include: '#magic-names'}]
},
'builtin-types': {
match:
"(?x)\n (?<!\\.) \\b(\n __mlir_attr | __mlir_op | __mlir_type | bool | bytearray | bytes | classmethod | complex | dict\n | float | frozenset | int | list | object | property\n | set | slice | staticmethod | str | tuple | type\n\n (?# Although 'super' is not a type, it's related to types,\n and is special enough to be highlighted differently from\n other built-ins)\n | super\n )\\b\n",
name: 'support.type.python'
},
'call-wrapper-inheritance': {
begin: '(?x)\n \\b(?=\n ([[:alpha:]_]\\w*) \\s* (\\()\n )\n',
end: '(\\))',
endCaptures: {1: {name: 'punctuation.definition.arguments.end.python'}},
name: 'meta.function-call.python',
patterns: [
{include: '#inheritance-name'},
{include: '#function-arguments'}
]
},
'class-declaration': {
patterns: [
{
begin:
'(?x)\n \\s*(class|struct|trait)\\s+\n (?=\n [[:alpha:]_]\\w* \\s* (:|\\()\n )\n',
beginCaptures: {1: {name: 'storage.type.class.python'}},
end: '(:)',
endCaptures: {1: {name: 'punctuation.section.class.begin.python'}},
name: 'meta.class.python',
patterns: [{include: '#class-name'}, {include: '#class-inheritance'}]
}
]
},
'class-inheritance': {
begin: '(\\()',
beginCaptures: {
1: {name: 'punctuation.definition.inheritance.begin.python'}
},
end: '(\\))',
endCaptures: {1: {name: 'punctuation.definition.inheritance.end.python'}},
name: 'meta.class.inheritance.python',
patterns: [
{
match: '(\\*\\*|\\*)',
name: 'keyword.operator.unpacking.arguments.python'
},
{match: ',', name: 'punctuation.separator.inheritance.python'},
{match: '=(?!=)', name: 'keyword.operator.assignment.python'},
{match: '\\bmetaclass\\b', name: 'support.type.metaclass.python'},
{include: '#illegal-names'},
{include: '#class-kwarg'},
{include: '#call-wrapper-inheritance'},
{include: '#expression-base'},
{include: '#member-access-class'},
{include: '#inheritance-identifier'}
]
},
'class-kwarg': {
captures: {
1: {
name: 'entity.other.inherited-class.python variable.parameter.class.python'
},
2: {name: 'keyword.operator.assignment.python'}
},
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\s*(=)(?!=)\n'
},
'class-name': {
patterns: [
{include: '#illegal-object-name'},
{include: '#builtin-possible-callables'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'entity.name.type.class.python'
}
]
},
codetags: {
captures: {1: {name: 'keyword.codetag.notation.python'}},
match: '(?:\\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\\b)'
},
comments: {
patterns: [
{
begin:
'(?x)\n (?:\n \\# \\s* (type:)\n \\s*+ (?# we want `\\s*+` which is possessive quantifier since\n we do not actually want to backtrack when matching\n whitespace here)\n (?! $ | \\#)\n )\n',
beginCaptures: {
0: {name: 'meta.typehint.comment.python'},
1: {name: 'comment.typehint.directive.notation.python'}
},
contentName: 'meta.typehint.comment.python',
end: '(?:$|(?=\\#))',
name: 'comment.line.number-sign.python',
patterns: [
{
match: '(?x)\n \\G ignore\n (?= \\s* (?: $ | \\#))\n',
name: 'comment.typehint.ignore.notation.python'
},
{
match:
'(?x)\n (?<!\\.)\\b(\n bool | bytes | float | int | object | str\n | List | Dict | Iterable | Sequence | Set\n | FrozenSet | Callable | Union | Tuple\n | Any | None\n )\\b\n',
name: 'comment.typehint.type.notation.python'
},
{
match: '([\\[\\]\\(\\),\\.\\=\\*]|(->))',
name: 'comment.typehint.punctuation.notation.python'
},
{
match: '([[:alpha:]_]\\w*)',
name: 'comment.typehint.variable.notation.python'
}
]
},
{include: '#comments-base'}
]
},
'comments-base': {
begin: '(\\#)',
beginCaptures: {1: {name: 'punctuation.definition.comment.python'}},
end: '($)',
name: 'comment.line.number-sign.python',
patterns: [{include: '#codetags'}]
},
'comments-string-double-three': {
begin: '(\\#)',
beginCaptures: {1: {name: 'punctuation.definition.comment.python'}},
end: '($|(?="""))',
name: 'comment.line.number-sign.python',
patterns: [{include: '#codetags'}]
},
'comments-string-single-three': {
begin: '(\\#)',
beginCaptures: {1: {name: 'punctuation.definition.comment.python'}},
end: "($|(?='''))",
name: 'comment.line.number-sign.python',
patterns: [{include: '#codetags'}]
},
'curly-braces': {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.dict.begin.python'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.definition.dict.end.python'}},
patterns: [
{match: ':', name: 'punctuation.separator.dict.python'},
{include: '#expression'}
]
},
decorator: {
begin: '(?x)\n ^\\s*\n ((@)) \\s* (?=[[:alpha:]_]\\w*)\n',
beginCaptures: {
1: {name: 'entity.name.function.decorator.python'},
2: {name: 'punctuation.definition.decorator.python'}
},
end: '(?x)\n ( \\) )\n # trailing whitespace and comments are legal\n (?: (.*?) (?=\\s*(?:\\#|$)) )\n | (?=\\n|\\#)\n',
endCaptures: {
1: {name: 'punctuation.definition.arguments.end.python'},
2: {name: 'invalid.illegal.decorator.python'}
},
name: 'meta.function.decorator.python',
patterns: [{include: '#decorator-name'}, {include: '#function-arguments'}]
},
'decorator-name': {
patterns: [
{include: '#builtin-callables'},
{include: '#illegal-object-name'},
{
captures: {2: {name: 'punctuation.separator.period.python'}},
match: '(?x)\n ([[:alpha:]_]\\w*) | (\\.)\n',
name: 'entity.name.function.decorator.python'
},
{include: '#line-continuation'},
{
captures: {1: {name: 'invalid.illegal.decorator.python'}},
match: '(?x)\n \\s* ([^([:alpha:]\\s_\\.#\\\\] .*?) (?=\\#|$)\n',
name: 'invalid.illegal.decorator.python'
}
]
},
'double-one-regexp-character-set': {
patterns: [
{match: '(?x)\n \\[ \\^? \\] (?! .*?\\])\n'},
{
begin: '(\\[)(\\^)?(\\])?',
beginCaptures: {
1: {
name: 'punctuation.character.set.begin.regexp constant.other.set.regexp'
},
2: {name: 'keyword.operator.negation.regexp'},
3: {name: 'constant.character.set.regexp'}
},
end: '(\\]|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'punctuation.character.set.end.regexp constant.other.set.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.character.set.regexp',
patterns: [
{include: '#regexp-charecter-set-escapes'},
{match: '[^\\n]', name: 'constant.character.set.regexp'}
]
}
]
},
'double-one-regexp-comments': {
begin: '\\(\\?#',
beginCaptures: {0: {name: 'punctuation.comment.begin.regexp'}},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {name: 'punctuation.comment.end.regexp'},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'comment.regexp',
patterns: [{include: '#codetags'}]
},
'double-one-regexp-conditional': {
begin: '(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)',
beginCaptures: {
0: {name: 'keyword.operator.conditional.regexp'},
1: {name: 'punctuation.parenthesis.conditional.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-expression': {
patterns: [
{include: '#regexp-base-expression'},
{include: '#double-one-regexp-character-set'},
{include: '#double-one-regexp-comments'},
{include: '#regexp-flags'},
{include: '#double-one-regexp-named-group'},
{include: '#regexp-backreference'},
{include: '#double-one-regexp-lookahead'},
{include: '#double-one-regexp-lookahead-negative'},
{include: '#double-one-regexp-lookbehind'},
{include: '#double-one-regexp-lookbehind-negative'},
{include: '#double-one-regexp-conditional'},
{include: '#double-one-regexp-parentheses-non-capturing'},
{include: '#double-one-regexp-parentheses'}
]
},
'double-one-regexp-lookahead': {
begin: '(\\()\\?=',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-lookahead-negative': {
begin: '(\\()\\?!',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-lookbehind': {
begin: '(\\()\\?<=',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-lookbehind-negative': {
begin: '(\\()\\?<!',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-named-group': {
begin: '(?x)\n (\\() (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n',
beginCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp'
},
2: {name: 'entity.name.tag.named.group.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.named.regexp',
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-parentheses': {
begin: '\\(',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp'
}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-parentheses-non-capturing': {
begin: '\\(\\?:',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp'
}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-three-regexp-character-set': {
patterns: [
{match: '(?x)\n \\[ \\^? \\] (?! .*?\\])\n'},
{
begin: '(\\[)(\\^)?(\\])?',
beginCaptures: {
1: {
name: 'punctuation.character.set.begin.regexp constant.other.set.regexp'
},
2: {name: 'keyword.operator.negation.regexp'},
3: {name: 'constant.character.set.regexp'}
},
end: '(\\]|(?="""))',
endCaptures: {
1: {
name: 'punctuation.character.set.end.regexp constant.other.set.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.character.set.regexp',
patterns: [
{include: '#regexp-charecter-set-escapes'},
{match: '[^\\n]', name: 'constant.character.set.regexp'}
]
}
]
},
'double-three-regexp-comments': {
begin: '\\(\\?#',
beginCaptures: {0: {name: 'punctuation.comment.begin.regexp'}},
end: '(\\)|(?="""))',
endCaptures: {
1: {name: 'punctuation.comment.end.regexp'},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'comment.regexp',
patterns: [{include: '#codetags'}]
},
'double-three-regexp-conditional': {
begin: '(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)',
beginCaptures: {
0: {name: 'keyword.operator.conditional.regexp'},
1: {name: 'punctuation.parenthesis.conditional.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-expression': {
patterns: [
{include: '#regexp-base-expression'},
{include: '#double-three-regexp-character-set'},
{include: '#double-three-regexp-comments'},
{include: '#regexp-flags'},
{include: '#double-three-regexp-named-group'},
{include: '#regexp-backreference'},
{include: '#double-three-regexp-lookahead'},
{include: '#double-three-regexp-lookahead-negative'},
{include: '#double-three-regexp-lookbehind'},
{include: '#double-three-regexp-lookbehind-negative'},
{include: '#double-three-regexp-conditional'},
{include: '#double-three-regexp-parentheses-non-capturing'},
{include: '#double-three-regexp-parentheses'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookahead': {
begin: '(\\()\\?=',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookahead-negative': {
begin: '(\\()\\?!',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookbehind': {
begin: '(\\()\\?<=',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookbehind-negative': {
begin: '(\\()\\?<!',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-named-group': {
begin: '(?x)\n (\\() (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n',
beginCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp'
},
2: {name: 'entity.name.tag.named.group.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.named.regexp',
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-parentheses': {
begin: '\\(',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp'
}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-parentheses-non-capturing': {
begin: '\\(\\?:',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp'
}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp'
},
2: {name: 'invalid.illegal.newline.python'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
ellipsis: {match: '\\.\\.\\.', name: 'constant.other.ellipsis.python'},
'escape-sequence': {
match:
'(?x)\n \\\\ (\n x[0-9A-Fa-f]{2}\n | [0-7]{1,3}\n | [\\\\"\'abfnrtv]\n )\n',
name: 'constant.character.escape.python'
},
'escape-sequence-unicode': {
patterns: [
{
match:
'(?x)\n \\\\ (\n u[0-9A-Fa-f]{4}\n | U[0-9A-Fa-f]{8}\n | N\\{[\\w\\s]+?\\}\n )\n',
name: 'constant.character.escape.python'
}
]
},
expression: {
patterns: [
{include: '#expression-base'},
{include: '#member-access'},
{match: '(?x) \\b ([[:alpha:]_]\\w*) \\b'}
]
},
'expression-bare': {
patterns: [
{include: '#backticks'},
{include: '#literal'},
{include: '#regexp'},
{include: '#string'},
{include: '#lambda'},
{include: '#generator'},
{include: '#illegal-operator'},
{include: '#operator'},
{include: '#curly-braces'},
{include: '#item-access'},
{include: '#list'},
{include: '#odd-function-call'},
{include: '#round-braces'},
{include: '#function-call'},
{include: '#builtin-functions'},
{include: '#builtin-types'},
{include: '#builtin-exceptions'},
{include: '#magic-names'},
{include: '#special-names'},
{include: '#illegal-names'},
{include: '#special-variables'},
{include: '#ellipsis'},
{include: '#punctuation'},
{include: '#line-continuation'}
]
},
'expression-base': {
patterns: [
{include: '#comments'},
{include: '#expression-bare'},
{include: '#line-continuation'}
]
},
'f-expression': {
patterns: [
{include: '#expression-bare'},
{include: '#member-access'},
{match: '(?x) \\b ([[:alpha:]_]\\w*) \\b'}
]
},
'fregexp-base-expression': {
patterns: [
{include: '#fregexp-quantifier'},
{include: '#fstring-formatting-braces'},
{match: '\\{.*?\\}'},
{include: '#regexp-base-common'}
]
},
'fregexp-quantifier': {
match: '(?x)\n \\{\\{(\n \\d+ | \\d+,(\\d+)? | ,\\d+\n )\\}\\}\n',
name: 'keyword.operator.quantifier.regexp'
},
'fstring-fnorm-quoted-multi-line': {
begin: '(\\b[fF])([bBuU])?(\'\'\'|""")',
beginCaptures: {
1: {
name: 'string.interpolated.python string.quoted.multi.python storage.type.string.python'
},
2: {name: 'invalid.illegal.prefix.python'},
3: {
name: 'punctuation.definition.string.begin.python string.interpolated.python string.quoted.multi.python'
}
},
end: '(\\3)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.fstring.python',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{include: '#fstring-multi-core'}
]
},
'fstring-fnorm-quoted-single-line': {
begin: '(\\b[fF])([bBuU])?(([\'"]))',
beginCaptures: {
1: {
name: 'string.interpolated.python string.quoted.single.python storage.type.string.python'
},
2: {name: 'invalid.illegal.prefix.python'},
3: {
name: 'punctuation.definition.string.begin.python string.interpolated.python string.quoted.single.python'
}
},
end: '(\\3)|((?<!\\\\)\\n)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.fstring.python',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{include: '#fstring-single-core'}
]
},
'fstring-formatting': {
patterns: [
{include: '#fstring-formatting-braces'},
{include: '#fstring-formatting-singe-brace'}
]
},
'fstring-formatting-braces': {
patterns: [
{
captures: {
1: {name: 'constant.character.format.placeholder.other.python'},
2: {name: 'invalid.illegal.brace.python'},
3: {name: 'constant.character.format.placeholder.other.python'}
},
match: '({)(\\s*?)(})'
},
{match: '({{|}})', name: 'constant.character.escape.python'}
]
},
'fstring-formatting-singe-brace': {
match: '(}(?!}))',
name: 'invalid.illegal.brace.python'
},
'fstring-guts': {
patterns: [
{include: '#escape-sequence-unicode'},
{include: '#escape-sequence'},
{include: '#string-line-continuation'},
{include: '#fstring-formatting'}
]
},
'fstring-illegal-multi-brace': {patterns: [{include: '#impossible'}]},
'fstring-illegal-single-brace': {
begin: '(\\{)(?=[^\\n}]*$\\n?)',
beginCaptures: {
1: {name: 'constant.character.format.placeholder.other.python'}
},
end: '(\\})|(?=\\n)',
endCaptures: {
1: {name: 'constant.character.format.placeholder.other.python'}
},
patterns: [
{include: '#fstring-terminator-single'},
{include: '#f-expression'}
]
},
'fstring-multi-brace': {
begin: '(\\{)',
beginCaptures: {
1: {name: 'constant.character.format.placeholder.other.python'}
},
end: '(?x)\n (\\})\n',
endCaptures: {
1: {name: 'constant.character.format.placeholder.other.python'}
},
patterns: [
{include: '#fstring-terminator-multi'},
{include: '#f-expression'}
]
},
'fstring-multi-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|\'\'\'|""")\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.python string.quoted.multi.python'
},
'fstring-normf-quoted-multi-line': {
begin: '(\\b[bBuU])([fF])(\'\'\'|""")',
beginCaptures: {
1: {name: 'invalid.illegal.prefix.python'},
2: {
name: 'string.interpolated.python string.quoted.multi.python storage.type.string.python'
},
3: {
name: 'punctuation.definition.string.begin.python string.quoted.multi.python'
}
},
end: '(\\3)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.fstring.python',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{include: '#fstring-multi-core'}
]
},
'fstring-normf-quoted-single-line': {
begin: '(\\b[bBuU])([fF])(([\'"]))',
beginCaptures: {
1: {name: 'invalid.illegal.prefix.python'},
2: {
name: 'string.interpolated.python string.quoted.single.python storage.type.string.python'
},
3: {
name: 'punctuation.definition.string.begin.python string.quoted.single.python'
}
},
end: '(\\3)|((?<!\\\\)\\n)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.fstring.python',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{include: '#fstring-single-core'}
]
},
'fstring-raw-guts': {
patterns: [
{include: '#string-consume-escape'},
{include: '#fstring-formatting'}
]
},
'fstring-raw-multi-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|\'\'\'|""")\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.python string.quoted.raw.multi.python'
},
'fstring-raw-quoted-multi-line': {
begin: '(\\b(?:[rR][fF]|[fF][rR]))(\'\'\'|""")',
beginCaptures: {
1: {
name: 'string.interpolated.python string.quoted.raw.multi.python storage.type.string.python'
},
2: {
name: 'punctuation.definition.string.begin.python string.quoted.raw.multi.python'
}
},
end: '(\\2)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.multi.python'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.fstring.python',
patterns: [
{include: '#fstring-raw-guts'},
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{include: '#fstring-raw-multi-core'}
]
},
'fstring-raw-quoted-single-line': {
begin: '(\\b(?:[rR][fF]|[fF][rR]))(([\'"]))',
beginCaptures: {
1: {
name: 'string.interpolated.python string.quoted.raw.single.python storage.type.string.python'
},
2: {
name: 'punctuation.definition.string.begin.python string.quoted.raw.single.python'
}
},
end: '(\\2)|((?<!\\\\)\\n)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.single.python'
},
2: {name: 'invalid.illegal.newline.python'}
},
name: 'meta.fstring.python',
patterns: [
{include: '#fstring-raw-guts'},
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{include: '#fstring-raw-single-core'}
]
},
'fstring-raw-single-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|([\'"])|((?<!\\\\)\\n))\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.python string.quoted.raw.single.python'
},
'fstring-single-brace': {
begin: '(\\{)',
beginCaptures: {
1: {name: 'constant.character.format.placeholder.other.python'}
},
end: '(?x)\n (\\})|(?=\\n)\n',
endCaptures: {
1: {name: 'constant.character.format.placeholder.other.python'}
},
patterns: [
{include: '#fstring-terminator-single'},
{include: '#f-expression'}
]
},
'fstring-single-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|([\'"])|((?<!\\\\)\\n))\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.python string.quoted.single.python'
},
'fstring-terminator-multi': {
patterns: [
{match: '(=(![rsa])?)(?=})', name: 'storage.type.format.python'},
{match: '(=?![rsa])(?=})', name: 'storage.type.format.python'},
{
captures: {
1: {name: 'storage.type.format.python'},
2: {name: 'storage.type.format.python'}
},
match:
'(?x)\n ( (?: =?) (?: ![rsa])? )\n ( : \\w? [<>=^]? [-+ ]? \\#?\n \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n'
},
{include: '#fstring-terminator-multi-tail'}
]
},
'fstring-terminator-multi-tail': {
begin: '((?:=?)(?:![rsa])?)(:)(?=.*?{)',
beginCaptures: {
1: {name: 'storage.type.format.python'},
2: {name: 'storage.type.format.python'}
},
end: '(?=})',
patterns: [
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{match: '([bcdeEfFgGnosxX%])(?=})', name: 'storage.type.format.python'},
{match: '(\\.\\d+)', name: 'storage.type.format.python'},
{match: '(,)', name: 'storage.type.format.python'},
{match: '(\\d+)', name: 'storage.type.format.python'},
{match: '(\\#)', name: 'storage.type.format.python'},
{match: '([-+ ])', name: 'storage.type.format.python'},
{match: '([<>=^])', name: 'storage.type.format.python'},
{match: '(\\w)', name: 'storage.type.format.python'}
]
},
'fstring-terminator-single': {
patterns: [
{match: '(=(![rsa])?)(?=})', name: 'storage.type.format.python'},
{match: '(=?![rsa])(?=})', name: 'storage.type.format.python'},
{
captures: {
1: {name: 'storage.type.format.python'},
2: {name: 'storage.type.format.python'}
},
match:
'(?x)\n ( (?: =?) (?: ![rsa])? )\n ( : \\w? [<>=^]? [-+ ]? \\#?\n \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n'
},
{include: '#fstring-terminator-single-tail'}
]
},
'fstring-terminator-single-tail': {
begin: '((?:=?)(?:![rsa])?)(:)(?=.*?{)',
beginCaptures: {
1: {name: 'storage.type.format.python'},
2: {name: 'storage.type.format.python'}
},
end: '(?=})|(?=\\n)',
patterns: [
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{match: '([bcdeEfFgGnosxX%])(?=})', name: 'storage.type.format.python'},
{match: '(\\.\\d+)', name: 'storage.type.format.python'},
{match: '(,)', name: 'storage.type.format.python'},
{match: '(\\d+)', name: 'storage.type.format.python'},
{match: '(\\#)', name: 'storage.type.format.python'},
{match: '([-+ ])', name: 'storage.type.format.python'},
{match: '([<>=^])', name: 'storage.type.format.python'},
{match: '(\\w)', name: 'storage.type.format.python'}
]
},
'function-arguments': {
begin: '(\\()',
beginCaptures: {
1: {name: 'punctuation.definition.arguments.begin.python'}
},
contentName: 'meta.function-call.arguments.python',
end: '(?=\\))(?!\\)\\s*\\()',
patterns: [
{match: '(,)', name: 'punctuation.separator.arguments.python'},
{
captures: {1: {name: 'keyword.operator.unpacking.arguments.python'}},
match: '(?x)\n (?:(?<=[,(])|^) \\s* (\\*{1,2})\n'
},
{include: '#lambda-incomplete'},
{include: '#illegal-names'},
{
captures: {
1: {name: 'variable.parameter.function-call.python'},
2: {name: 'keyword.operator.assignment.python'}
},
match: '\\b([[:alpha:]_]\\w*)\\s*(=)(?!=)'
},
{match: '=(?!=)', name: 'keyword.operator.assignment.python'},
{include: '#expression'},
{
captures: {
1: {name: 'punctuation.definition.arguments.end.python'},
2: {name: 'punctuation.definition.arguments.begin.python'}
},
match: '\\s*(\\))\\s*(\\()'
}
]
},
'function-call': {
begin: '(?x)\n \\b(?=\n ([[:alpha:]_]\\w*) \\s* (\\()\n )\n',
end: '(\\))',
endCaptures: {1: {name: 'punctuation.definition.arguments.end.python'}},
name: 'meta.function-call.python',
patterns: [
{include: '#special-variables'},
{include: '#function-name'},
{include: '#function-arguments'}
]
},
'function-declaration': {
begin:
'(?x)\n \\s*\n (?:\\b(async) \\s+)? \\b(def|fn)\\s+\n (?=\n [[:alpha:]_][[:word:]]* \\s* [\\(\\[]\n )\n',
beginCaptures: {
1: {name: 'storage.type.function.async.python'},
2: {name: 'storage.type.function.python'}
},
end: '(:|(?=[#\'"\\n]))',
endCaptures: {1: {name: 'punctuation.section.function.begin.python'}},
name: 'meta.function.python',
patterns: [
{include: '#function-modifier'},
{include: '#function-def-name'},
{include: '#parameters'},
{include: '#meta_parameters'},
{include: '#line-continuation'},
{include: '#return-annotation'}
]
},
'function-def-name': {
patterns: [
{include: '#illegal-object-name'},
{include: '#builtin-possible-callables'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'entity.name.function.python'
}
]
},
'function-modifier': {
match: '(raises|capturing)',
name: 'storage.modifier'
},
'function-name': {
patterns: [
{include: '#builtin-possible-callables'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'meta.function-call.generic.python'
}
]
},
generator: {
begin: '\\bfor\\b',
beginCaptures: {0: {name: 'keyword.control.flow.python'}},
end: '\\bin\\b',
endCaptures: {0: {name: 'keyword.control.flow.python'}},
patterns: [{include: '#expression'}]
},
'illegal-names': {
captures: {
1: {name: 'keyword.control.flow.python'},
2: {name: 'storage.type.function.python'},
3: {name: 'keyword.control.import.python'}
},
match:
'(?x)\n \\b(?:\n (\n and | assert | async | await | break | class | struct | trait | continue | del | elif | else | except | finally | for | from | global\n | if | in | is | (?<=\\.)lambda | lambda(?=\\s*[\\.=])\n | nonlocal | not | or | pass | raise | return | try | while | with\n | yield\n ) | (def | fn | capturing | raises) | (\n as | import\n )\n )\\b\n'
},
'illegal-object-name': {
match: '\\b(True|False|None)\\b',
name: 'keyword.illegal.name.python'
},
'illegal-operator': {
patterns: [
{match: '&&|\\|\\||--|\\+\\+', name: 'invalid.illegal.operator.python'},
{match: '[?$]', name: 'invalid.illegal.operator.python'},
{match: '!\\b', name: 'invalid.illegal.operator.python'}
]
},
import: {
patterns: [
{
begin: '\\b(?<!\\.)(from)\\b(?=.+import)',
beginCaptures: {1: {name: 'keyword.control.import.python'}},
end: '$|(?=import)',
patterns: [
{match: '\\.+', name: 'punctuation.separator.period.python'},
{include: '#expression'}
]
},
{
begin: '\\b(?<!\\.)(import)\\b',
beginCaptures: {1: {name: 'keyword.control.import.python'}},
end: '$',
patterns: [
{match: '\\b(?<!\\.)as\\b', name: 'keyword.control.import.python'},
{include: '#expression'}
]
}
]
},
impossible: {match: '$.^'},
'inheritance-identifier': {
captures: {1: {name: 'entity.other.inherited-class.python'}},
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n'
},
'inheritance-name': {
patterns: [
{include: '#lambda-incomplete'},
{include: '#builtin-possible-callables'},
{include: '#inheritance-identifier'}
]
},
'item-access': {
patterns: [
{
begin: '(?x)\n \\b(?=\n [[:alpha:]_]\\w* \\s* \\[\n )\n',
end: '(\\])',
endCaptures: {
1: {name: 'punctuation.definition.arguments.end.python'}
},
name: 'meta.item-access.python',
patterns: [
{include: '#item-name'},
{include: '#item-index'},
{include: '#expression'}
]
}
]
},
'item-index': {
begin: '(\\[)',
beginCaptures: {
1: {name: 'punctuation.definition.arguments.begin.python'}
},
contentName: 'meta.item-access.arguments.python',
end: '(?=\\])',
patterns: [
{match: ':', name: 'punctuation.separator.slice.python'},
{include: '#expression'}
]
},
'item-name': {
patterns: [
{include: '#special-variables'},
{include: '#builtin-functions'},
{include: '#special-names'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'meta.indexed-name.python'
}
]
},
lambda: {
patterns: [
{
captures: {1: {name: 'keyword.control.flow.python'}},
match: '((?<=\\.)lambda|lambda(?=\\s*[\\.=]))'
},
{
captures: {1: {name: 'storage.type.function.lambda.python'}},
match: '\\b(lambda)\\s*?(?=[,\\n]|$)'
},
{
begin: '(?x)\n \\b (lambda) \\b\n',
beginCaptures: {1: {name: 'storage.type.function.lambda.python'}},
contentName: 'meta.function.lambda.parameters.python',
end: '(:)|(\\n)',
endCaptures: {
1: {name: 'punctuation.section.function.lambda.begin.python'}
},
name: 'meta.lambda-function.python',
patterns: [
{match: '\\b(owned|borrowed|inout)\\b', name: 'storage.modifier'},
{match: '/', name: 'keyword.operator.positional.parameter.python'},
{
match: '(\\*\\*|\\*)',
name: 'keyword.operator.unpacking.parameter.python'
},
{include: '#lambda-nested-incomplete'},
{include: '#illegal-names'},
{
captures: {
1: {name: 'variable.parameter.function.language.python'},
2: {name: 'punctuation.separator.parameters.python'}
},
match: '([[:alpha:]_]\\w*)\\s*(?:(,)|(?=:|$))'
},
{include: '#comments'},
{include: '#backticks'},
{include: '#lambda-parameter-with-default'},
{include: '#line-continuation'},
{include: '#illegal-operator'}
]
}
]
},
'lambda-incomplete': {
match: '\\blambda(?=\\s*[,)])',
name: 'storage.type.function.lambda.python'
},
'lambda-nested-incomplete': {
match: '\\blambda(?=\\s*[:,)])',
name: 'storage.type.function.lambda.python'
},
'lambda-parameter-with-default': {
begin: '(?x)\n \\b\n ([[:alpha:]_]\\w*) \\s* (=)\n',
beginCaptures: {
1: {name: 'variable.parameter.function.language.python'},
2: {name: 'keyword.operator.python'}
},
end: '(,)|(?=:|$)',
endCaptures: {1: {name: 'punctuation.separator.parameters.python'}},
patterns: [{include: '#expression'}]
},
'line-continuation': {
patterns: [
{
captures: {
1: {name: 'punctuation.separator.continuation.line.python'},
2: {name: 'invalid.illegal.line.continuation.python'}
},
match: '(\\\\)\\s*(\\S.*$\\n?)'
},
{
begin: '(\\\\)\\s*$\\n?',
beginCaptures: {
1: {name: 'punctuation.separator.continuation.line.python'}
},
end: "(?x)\n (?=^\\s*$)\n |\n (?! (\\s* [rR]? (\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))\n |\n (\\G $) (?# '\\G' is necessary for ST)\n )\n",
patterns: [{include: '#regexp'}, {include: '#string'}]
}
]
},
list: {
begin: '\\[',
beginCaptures: {0: {name: 'punctuation.definition.list.begin.python'}},
end: '\\]',
endCaptures: {0: {name: 'punctuation.definition.list.end.python'}},
patterns: [{include: '#expression'}]
},
literal: {
patterns: [
{
match: '\\b(True|False|None|NotImplemented|Ellipsis)\\b',
name: 'constant.language.python'
},
{include: '#number'}
]
},
'loose-default': {
begin: '(=)',
beginCaptures: {1: {name: 'keyword.operator.python'}},
end: '(,)|(?=\\))',
endCaptures: {1: {name: 'punctuation.separator.parameters.python'}},
patterns: [{include: '#expression'}]
},
'magic-function-names': {
captures: {1: {name: 'support.function.magic.python'}},
match:
'(?x)\n \\b(\n __(?:\n abs | add | aenter | aexit | aiter | and | anext\n | await | bool | call | ceil | class_getitem\n | cmp | coerce | complex | contains | copy\n | deepcopy | del | delattr | delete | delitem\n | delslice | dir | div | divmod | enter | eq\n | exit | float | floor | floord