Vyper.sublime-syntax

%YAML 1.2
---
name: Vyper
file_extensions:
  - vy
scope: source.vyper
# Vyper sublime syntax file, adapted from the default python

variables:
  # We support unicode here because Python 3 is the future
  identifier_continue: '[[:alnum:]_]'
  identifier: '\b[[:alpha:]_]{{identifier_continue}}*\b'
  digitpart: (?:\d(?:_?\d)*)
  path: '({{identifier}} *\. *)*{{identifier}}'
  illegal_names: (?:and|as|assert|break|class|continue|def|del|elif|else|except|finally|for|froim|global|if|import|in|is|not|or|pass|raise|return|try|while|with|yield)
  format_spec: |-
    (?x:
      (?:.? [<>=^])?     # fill align
      [ +-]?             # sign
      \#?                # alternate form
      # technically, octal and hexadecimal integers are also supported as 'width', but rarely used
      \d*                # width
      ,?                 # thousands separator
      (?:\.\d+)?         # precision
      [bcdeEfFgGnosxX%]? # type
    )
  strftime_spec: '(?:%(?:[aAwdbBGmyYHIpMSfzZjuUVWcxX%]|-[dmHIMSj]))'
contexts:
  main:
    - include: statements

  statements:
    - include: line-statements
    - include: block-statements
    - include: classes
    - include: functions
    - include: modifiers
    - include: assignments
    - match: ;
      scope: punctuation.terminator.statement.vyper
    - include: line-expressions

  line-statements:
    - include: imports
    - include: decorators
    - match: \b(assert)\b
      scope: keyword.other.assert.python
    - match: \b(return)\b
      scope: keyword.control.flow.return.python
    - match: \b(break)\b
      scope: keyword.control.flow.break.python
    - match: \b(continue)\b
      scope: keyword.control.flow.continue.python
    - match: \b(pass)\b

  block-statements:
    - match: \bif\b
      scope: keyword.control.flow.conditional.vyper
      push:
        - meta_scope: meta.statement.if.vyper
        - include: line-continuation-or-pop
        - match: ':'
          scope: punctuation.section.block.conditional.vyper
          pop: true
        - include: expressions
    - match: \bwhile\b
      scope: keyword.control.flow.while.vyper
      push:
        - meta_scope: meta.statement.while.vyper
        - include: line-continuation-or-pop
        - match: ':'
          scope: punctuation.section.block.while.vyper
          pop: true
        - include: expressions
    - match: \b(elif|else)\b(?:\s*(:))?
      scope: meta.statement.conditional.vyper
      captures:
        1: keyword.control.flow.conditional.vyper
        2: punctuation.section.block.vyper
    - match: \b(try)\b(?:\s*(:))?
      scope: meta.statement.try.vyper
      captures:
        1: keyword.control.flow.try.vyper
        2: punctuation.section.block.try.vyper
    - match: \b(finally)\b(?:\s*(:))?
      scope: meta.statement.finally.vyper
      captures:
        1: keyword.control.flow.finally.vyper
        2: punctuation.section.block.finally.vyper

  expressions-common:
    - include: comments
    - include: constants
    - include: numbers
    - include: operators
    - match: \b(await)\b
      scope: keyword.other.await.vyper
    - include: inline-if
    - include: strings
    - include: function-calls
    - include: item-access
    - include: groups
    - match: \)
      scope: invalid.illegal.stray.brace.round.vyper
    - match: \]
      scope: invalid.illegal.stray.brace.square.vyper
    - match: \}
      scope: invalid.illegal.stray.brace.curly.vyper
    - include: lists
    - include: dictionaries-and-sets
    - include: line-continuation

  line-expressions: # Always include this last!
    - include: expressions-common
    - include: qualified-name

  expressions: # Always include this last!
    # Differs from the line scope in that invalid-name matches will pop the current context
    # and matches accessors continued on a different line
    - include: expressions-common
    - include: illegal-names-pop
    - include: qualified-name
    - match: '(\.) *(?={{identifier}})'
      captures:
        1: punctuation.accessor.dot.vyper
      push:
        - include: magic-function-names
        - include: magic-variable-names
        - include: illegal-names
        - include: generic-names
        - match: ''
          pop: true

  after-expression:
    # direct function call
    - match: '\s*(\()'
      captures:
        1: punctuation.section.arguments.begin.vyper
      push:
        - meta_scope: meta.function-call.vyper
        - meta_content_scope: meta.function-call.arguments.vyper
        - match: \)
          scope: punctuation.section.arguments.end.vyper
          pop: true
        - include: arguments
    # item access
    - match: '\s*(\[)'
      captures:
        1: meta.item-access.vyper punctuation.section.brackets.begin.vyper
      push:
        - meta_content_scope: meta.item-access.arguments.vyper
        - match: \]
          scope: meta.item-access.vyper punctuation.section.brackets.end.vyper
          pop: true
        - match: ':'
          scope: punctuation.separator.slice.vyper
        - include: expressions
    # indirect function call following attribute access
    - include: function-calls
    # arbitrary attribute access
    - match: '\s*(\.)'
      captures:
        1: punctuation.accessor.dot.vyper
      push:
        - include: magic-function-names
        - include: magic-variable-names
        - include: illegal-names
        - include: generic-names
        - match: ''
          pop: true
    - match: ''
      pop: true

  comments:
    - match: "#"
      scope: punctuation.definition.comment.vyper
      push:
        - meta_scope: comment.line.number-sign.vyper
        - match: \n
          pop: true

  constants:
    - match: \b(None|True|False|Ellipsis|NotImplemented|__debug__)\b
      scope: constant.language.vyper
    - match: \.{3}(?!\w)
      scope: constant.language.vyper

  numbers:
    # https://docs.python.org/3/reference/lexical_analysis.html#numeric-literals
    # hexadecimal
    - match: \b(?i)(0x)(_?\h)+
      scope: constant.numeric.integer.hexadecimal.vyper
      captures:
        1: punctuation.definition.numeric.hexadecimal.vyper
    # octal
    - match: \b(?i)(0o)(_?[0-7])+
      scope: constant.numeric.integer.octal.vyper
      captures:
        1: punctuation.definition.numeric.octal.vyper
    # binary
    - match: \b(?i)(0b)(_?[01])*
      scope: constant.numeric.integer.binary.vyper
      captures:
        1: punctuation.definition.numeric.binary.vyper
    # complex
    - match: (?i){{digitpart}}?(\.){{digitpart}}(?:e[\-\+]?{{digitpart}})?(j) # mandatory fraction
      scope: constant.numeric.complex.vyper
      captures:
        1: punctuation.separator.decimal.vyper
        2: storage.type.numeric.complex.vyper
    - match: \b(?i)(?:{{digitpart}}(?:(\.){{digitpart}}?)?|(\.){{digitpart}})(?:e[\-\+]?{{digitpart}})(j) # mandatory exponent
      scope: constant.numeric.complex.vyper
      captures:
        1: punctuation.separator.decimal.vyper
        2: punctuation.separator.decimal.vyper
        3: storage.type.numeric.complex.vyper
    - match: (?i){{digitpart}}(\.)?(j) # mandatory digitpart
      scope: constant.numeric.complex.vyper
      captures:
        1: punctuation.separator.decimal.vyper
        2: storage.type.numeric.complex.vyper
    # floating point
    - match: (?i){{digitpart}}?(\.){{digitpart}}(?:e[\-\+]?{{digitpart}})? # mandatory fraction
      scope: constant.numeric.float.vyper
      captures:
        1: punctuation.separator.decimal.vyper
    - match: \b(?i)(?:{{digitpart}}(?:(\.){{digitpart}}?)?|(\.){{digitpart}})(?:e[\-\+]?{{digitpart}}) # mandatory exponent
      scope: constant.numeric.float.vyper
      captures:
        1: punctuation.separator.decimal.vyper
        2: punctuation.separator.decimal.vyper
    - match: (?i){{digitpart}}(\.) # mandatory digitpart
      scope: constant.numeric.float.vyper
      captures:
        1: punctuation.separator.decimal.vyper
    - match: \b(?i)([1-9][\d_]*|0)\b
      scope: constant.numeric.integer.decimal.vyper

  modifiers:
    - match: \b(?:(global)|(nonlocal))\b
      captures:
        1: storage.modifier.global.vyper
        2: storage.modifier.nonlocal.vyper
      push:
        - include: line-continuation-or-pop
        - match: ','
          scope: punctuation.separator.storage-list.vyper
        - include: name
        - match: \S+
          scope: invalid.illegal.name.storage.vyper

  assignments:
    - match: \+=|-=|\*=|/=|//=|%=|@=|&=|\|=|\^=|>>=|<<=|\*\*=
      scope: keyword.operator.assignment.augmented.vyper
    - match: '=(?!=)'
      scope: keyword.operator.assignment.vyper

  operators:
    - match: <>
      scope: invalid.deprecated.operator.vyper
    - match: <\=|>\=|\=\=|<|>|\!\=
      scope: keyword.operator.comparison.vyper
    - match: \+|\-|\*|\*\*|/|//|%|<<|>>|&|\||\^|~
      scope: keyword.operator.arithmetic.vyper
    - match: \b(and|in|is|not|or)\b
      comment: keyword operators that evaluate to True or False
      scope: keyword.operator.logical.vyper
    - match: '@'
      scope: keyword.operator.matrix.vyper

  allow-unpack-operators:
    # Match unpacking operators, if present
    - include: comments
    - match: \*{3,}
      scope: invalid.illegal.syntax.vyper
      pop: true
    - match: \*\*
      scope: keyword.operator.unpacking.mapping.vyper
      pop: true
    - match: \*
      scope: keyword.operator.unpacking.sequence.vyper
      pop: true
    - match: (?=\S)
      pop: true

  classes:
    - match: '^\s*(class|contract|struct)\b'
      captures:
        1: storage.type.class.vyper
      push:
        - meta_scope: meta.class.vyper
        - include: line-continuation-or-pop
        - match: ':'
          scope: punctuation.section.class.begin.vyper
          pop: true
        - match: "(?={{identifier}})"
          push:
            - meta_content_scope: entity.name.class.vyper
            - include: entity-name-class
            - match: ''
              pop: true
        - match: \(
          scope: punctuation.section.inheritance.begin.vyper
          set:
            - meta_scope: meta.class.inheritance.vyper
            - match: \)
              scope: punctuation.section.inheritance.end.vyper
              set:
                - include: line-continuation-or-pop
                - match: ':'
                  scope: meta.class.vyper punctuation.section.class.begin.vyper
                  pop: true
                - match: (?=\S)
                  pop: true
            - match: ':'
              scope: invalid.illegal.no-closing-parens.vyper
              pop: true
            - match: ','
              scope: punctuation.separator.inheritance.vyper
            - include: illegal-names-pop
            - match: ({{identifier}}) *(=)
              captures:
                1: variable.parameter.class-inheritance.vyper
                2: keyword.operator.assignment.vyper
            - match: (?={{path}})
              push:
                - meta_scope: entity.other.inherited-class.vyper
                - match: '{{identifier}}(?: *(\.) *)?'
                  captures:
                    1: punctuation.accessor.dot.vyper
                - match: ''
                  pop: true
            - include: expressions

  functions:
    - match: '^\s*?(def)\b'
      captures:
        2: storage.type.function.vyper
      push:
        - meta_scope: meta.function.vyper
        - include: line-continuation-or-pop
        - match: ':'
          scope: punctuation.section.function.begin.vyper
          pop: true
        - match: "(?={{identifier}})"
          push:
            - meta_content_scope: entity.name.function.vyper
            - include: entity-name-function
            - match: ''
              pop: true
        - match: '(?=\()'
          set:
            - match: \(
              scope: meta.function.parameters.vyper punctuation.section.parameters.begin.vyper
              set: [function-parameters, allow-unpack-operators]

  function-parameters:
    - meta_content_scope: meta.function.parameters.vyper
    - match: \)
      scope: punctuation.section.parameters.end.vyper
      set: function-after-parameters
    - include: comments
    - match: ','
      scope: punctuation.separator.parameters.vyper
      push: allow-unpack-operators
    - match: '(?==)'
      set:
        - match: '='
          scope: keyword.operator.assignment.vyper
          set:
            - meta_scope: meta.function.parameters.default-value.vyper
            - match: '(?=[,)])'
              set: [function-parameters, allow-unpack-operators]
            - include: expressions
    - match: '(?=:)'
      set:
        - match: ':'
          scope: punctuation.separator.annotation.parameter.vyper
          set:
            - meta_scope: meta.function.parameters.annotation.vyper
            - match: '(?=[,)=])'
              set: function-parameters
            - include: expressions
    - include: illegal-names
    - match: '{{identifier}}'
      scope: variable.parameter.vyper
    - include: line-continuation

  function-after-parameters:
    - meta_content_scope: meta.function.vyper
    - match: '(?=->)'
      set:
        - meta_content_scope: meta.function.annotation.return.vyper
        - match: ->
          scope: punctuation.separator.annotation.return.vyper
        - match: '(?=:)'
          set: function-after-parameters
        - include: line-continuation-or-pop
        - include: expressions
    - match: ':'
      scope: meta.function.vyper punctuation.section.function.begin.vyper
      pop: true
    - include: comments
    - match: (?=\S)
      pop: true

  imports:
    - match: \b(import)\b
      scope: keyword.control.import.python
      push:
        - meta_scope: meta.statement.import.python
        - include: line-continuation-or-pop
        - match: ','
          scope: punctuation.separator.import-list.python
        - match: \.
          scope: invalid.illegal.unexpected-relative-import.python
        - include: import-alias
        - include: qualified-name
        - match: (?=\S)
          pop: true
    - match: \b(from)\b
      scope: keyword.control.import.from.python
      push:
        - meta_scope: meta.statement.import.python
        - meta_content_scope: meta.import-source.python
        - include: line-continuation-or-pop
        - match: \b(import)\b
          scope: keyword.control.import.python
          set:
            - meta_scope: meta.statement.import.python
            - include: line-continuation-or-pop
            - match: ' *(\()'
              captures:
                1: punctuation.section.import-list.begin.python
              set:
                - meta_scope: meta.statement.import.python
                - include: comments
                - match: \)
                  scope: punctuation.section.import-list.end.python
                  pop: true
                - include: import-name-list
                - match: (?=\S)
                  pop: true
            - match: ''
              set:
                - meta_scope: meta.statement.import.python
                - include: line-continuation-or-pop
                - include: import-name-list
                - match: (?=\S)
                  pop: true
            - match: (?=\S)
              pop: true
        - include: import-from-name
        - match: (?=\S)
          pop: true

  import-name-list:
    - match: ','
      scope: punctuation.separator.import-list.python
    - include: import-alias
    - include: name
    - match: \*
      scope: constant.language.import-all.python
    - match: \S+
      scope: invalid.illegal.name.import.python

  import-alias:
    - match: \b(as)\b
      scope: keyword.control.import.as.python

  import-from-name:
    - match: \.+
      scope: meta.import-path.python keyword.control.import.relative.python
    - match: (?={{path}})
      push:
        - meta_scope: meta.import-path.python
        - match: '{{illegal_names}}\b'
          scope: invalid.illegal.name.python
        - match: '{{identifier}}'
          scope: meta.import-name.python
        - match: \s*(\.) *(?:({{illegal_names}}\b)|({{identifier}}))
          captures:
            1: punctuation.accessor.dot.python
            2: invalid.illegal.name.python
            3: meta.import-name.python
        - match: \ *(\. *\S+) # matches and consumes the remainder of "abc.123" or "abc.+"
          captures:
            1: invalid.illegal.name.python
          pop: true
        - match: ''
          pop: true

  decorators:
    - match: ^\s*(?=@)
      push:
        # Due to line continuations, we don't know whether this is a "function call" yet
        - meta_content_scope: meta.annotation.vyper
        - match: '@'
          scope: punctuation.definition.annotation.vyper
        - match: $
          pop: true
        - include: line-continuation-or-pop
        - match: (?=\.?\s*{{path}}\s*\() # now we do
          set: [decorator-function-call-wrapper, qualified-name-until-leaf]
        - match: (?=\.?\s*{{path}})
          push: [decorator-wrapper, qualified-name-until-leaf]
        - match: \S
          scope: invalid.illegal.character.vyper
          pop: true

  decorator-wrapper:
    - match: '{{identifier}}'
      scope: meta.qualified-name.vyper variable.annotation.vyper
    - match: ''
      pop: true

  decorator-function-call-wrapper:
    - meta_scope: meta.annotation.function.vyper
    - match: '{{identifier}}'
      scope: meta.qualified-name.vyper variable.annotation.function.vyper
    - match: \)
      scope: punctuation.section.arguments.end.vyper
      set: after-expression
    - match: \(
      scope: punctuation.section.arguments.begin.vyper
      push:
        - meta_content_scope: meta.annotation.arguments.vyper
        - match: (?=\))
          pop: true
        - include: arguments

  item-access:
    - match: '(?={{path}}\s*\[)'
      push:
        - match: \]
          scope: meta.item-access.vyper punctuation.section.brackets.end.vyper
          set: after-expression
        - match: '(?={{path}}\s*\[)'
          push:
            - meta_content_scope: meta.item-access.vyper
            - match: '(?=\s*\[)'
              pop: true
            - include: qualified-name
        - match: \[
          scope: meta.item-access.vyper punctuation.section.brackets.begin.vyper
          push:
            - meta_content_scope: meta.item-access.arguments.vyper
            - match: '(?=\])'
              pop: true
            - match: ':'
              scope: punctuation.separator.slice.vyper
            - include: expressions

  function-calls:
    - match: '(?=(\.\s*)?{{path}}\s*\()'
      push: [function-call-wrapper, qualified-name-until-leaf]

  function-call-wrapper:
    - meta_scope: meta.function-call.vyper
    - match: '{{identifier}}'
      scope: meta.qualified-name.vyper variable.function.vyper
    - match: \)
      scope: punctuation.section.arguments.end.vyper
      set: after-expression
    - match: \(
      scope: punctuation.section.arguments.begin.vyper
      push:
        - meta_content_scope: meta.function-call.arguments.vyper
        - match: (?=\))
          pop: true
        - include: arguments

  arguments:
    - include: keyword-arguments
    - match: ','
      scope: punctuation.separator.arguments.vyper
      push: allow-unpack-operators
    - include: inline-for
    - include: expressions

  keyword-arguments:
    - match: '(?={{identifier}}\s*=(?!=))'
      push:
        - include: line-continuation-or-pop
        - match: '='
          scope: keyword.operator.assignment.vyper
          set:
            - match: (?=\s*[,):])
              pop: true
            - include: expressions
        - include: illegal-names
        - match: '{{identifier}}'
          scope: variable.parameter.vyper

  groups:
    - match: \(
      scope: punctuation.section.group.begin.vyper
      push:
        - meta_scope: meta.group.vyper
        - match: \)
          scope: punctuation.section.group.end.vyper
          set: after-expression
        - match: ','
          scope: punctuation.separator.tuple.vyper
        - include: inline-for
        - include: expressions

  lists:
    - match: '(\[)(\s*(\]))\b'
      captures:
        1: punctuation.section.list.begin.vyper
        2: meta.empty-list.vyper
        3: punctuation.section.list.end.vyper
    - match: \[
      scope: punctuation.section.list.begin.vyper
      push:
        - meta_scope: meta.structure.list.vyper
        - match: \]
          scope: punctuation.section.list.end.vyper
          set: after-expression
        - match: ','
          scope: punctuation.separator.list.vyper
          push: allow-unpack-operators
        - include: inline-for
        - include: expressions

  dictionaries-and-sets:
    - match: '(\{)(\s*(\}))'
      scope: meta.structure.dictionary.vyper
      captures:
        1: punctuation.section.dictionary.begin.vyper
        2: meta.empty-dictionary.vyper
        3: punctuation.section.dictionary.end.vyper
    - match: \{
      scope: punctuation.section.dictionary-or-set.begin.vyper
      push:
        - meta_scope: meta.structure.dictionary-or-set.vyper
        - match: \}
          scope: punctuation.section.dictionary-or-set.end.vyper
          set: after-expression
        - match: ','
          scope: punctuation.separator.dictionary-or-set.vyper
          push: allow-unpack-operators
        - match: ':'
          scope: punctuation.separator.key-value.vyper
        - include: inline-for
        - include: expressions

  builtin-functions:
    - match: |-
        (?x)\b(
          as_unitless_number|as_wei_value|bitwise_and|bitwise_not|bitwise_or|
          bitwise_xor|blockhash|ceil|concat|convert|create_with_code_of|ecadd|
          ecmul|ecrecover|extract32|floor|keccak256|len|max|method_id|min|
          raw_call|RLPList|sha3|shift|slice|uint256_addmod|uint256_mulmod|sha256
          event|log
        )\b
      scope: support.function.builtin.vyper
  builtin-types:
    - match: |-
        (?x)\b(
          address|bool|decimal|bytes32|int128|uint256|bytes|string
        )\b
      scope: support.type.vyper
  name:
    - match: '(?={{identifier}})'
      push:
        - include: name-specials
        - match: '\b_*\p{Lu}{3,}[\p{Lu}_]*\b' # require 3 upper-case letters for undotted names
          scope: variable.other.constant.vyper
        - include: generic-names
        - match: ''
          pop: true

  dotted-name:
    - match: '\s*(\.)\s*(?={{identifier}})'
      captures:
        1: punctuation.accessor.dot.vyper
      push:
        - include: dotted-name-specials
        - match: '\b_*\p{Lu}+[\p{Lu}_]*\b'
          scope: variable.other.constant.vyper
        - include: generic-names
        - match: ''
          pop: true

  qualified-name:
    - match: '(?={{path}})'
      push:
        - meta_scope: meta.qualified-name.vyper
        - include: name
        - include: dotted-name
        - match: ''
          pop: true

  qualified-name-until-leaf:
    # Push this together with another context to match a qualified name
    # until the last non-special identifier (if any).
    # This allows the leaf to be scoped individually.
    - meta_scope: meta.qualified-name.vyper
    - include: name-specials
    # If a line continuation follows, this may or may not be the last leaf (most likley not though)
    - match: '{{identifier}}(?=\s*\\)'
      scope: meta.generic-name.vyper
    - match: (?={{identifier}}\s*\.)
      push:
        - include: name-specials
        - include: generic-names
        - match: ''
          pop: true
    - match: (\.)\s*(?={{identifier}}\s*\.)
      captures:
        1: punctuation.accessor.dot.vyper
      push:
        - include: dotted-name-specials
        - include: generic-names
        - match: ''
          pop: true
    - match: (\.)\s*(?={{identifier}})
      captures:
        1: punctuation.accessor.dot.vyper
      set:
        - include: dotted-name-specials
        - match: ''
          pop: true
    - match: (?=\S|$)
      pop: true

  name-specials:
    - include: builtin-functions
    - include: builtin-types
    - include: illegal-names
    - include: magic-function-names
    - include: magic-variable-names
    - include: language-variables

  dotted-name-specials:
    - include: magic-function-names
    - include: magic-variable-names
    - include: illegal-names

  entity-name-class:
    - include: illegal-names
    - include: generic-names

  entity-name-function:
    - include: magic-function-names
    - include: illegal-names
    - include: generic-names

  generic-names:
    - match: '{{identifier}}'
      scope: meta.generic-name.vyper

  illegal-names:
    - match: \b{{illegal_names}}\b
      scope: invalid.illegal.name.vyper

  illegal-names-pop:
    - match: \b{{illegal_names}}\b
      scope: invalid.illegal.name.vyper
      pop: true

  language-variables:
    - match: \b(self)\b
      scope: variable.language.vyper
    - match: _(?!{{identifier_continue}})
      scope: variable.language.vyper

  line-continuation:
    - match: (\\)(.*)$\n?
      captures:
        1: punctuation.separator.continuation.line.vyper
        2: invalid.illegal.unexpected-text.vyper
    # make sure to resume parsing at next line
      push:
        # This prevents strings after a continuation from being a docstring
        - include: strings
        - match: (?=\S|^\s*$|\n)  # '\n' for when we matched a string earlier
          pop: true

  line-continuation-or-pop:
    - include: line-continuation
    - match: (?=\s*($|;|#))
      pop: true

  magic-function-names:
    # https://docs.vyper.org/2/reference/datamodel.html
    # https://docs.vyper.org/3/reference/datamodel.html
    - match: |-
        (?x)\b__(?:
          # unary operators
          invert|neg|pos|abs|
          # binary operators
          add|and|div|divmod|floordiv|lshift|mod|mul|or|pow|rshift|sub|truediv|xor|
          contains|
          # right-hand binary operators
          radd|rand|rdiv|rdivmod|rfloordiv|rlshift|rmod|rmul|ror|rpow|rrshift|rsub|rtruediv|rxor|
          # in-place operator assignments
          iadd|iand|idiv|ifloordiv|ilshift|imod|imul|ior|ipow|irshift|isub|itruediv|ixor|
          # comparisons
          eq|ge|gt|le|lt|ne|
          # primary coercion
          bool|str|
          # number coercion (converts something to a number)
          bytes|complex|float|index|int|round|
          # other "coercion"
          format|len|length_hint|hash|repr|reversed|
          fspath|
          # iterator (and 'await')
          iter|next|
          aiter|anext|
          await|
          # attribute and item access
          delattr|delitem|delslice|
          getattr|getattribute|getitem|getslice|
          setattr|setitem|setslice|
          dir|missing|
          # context manager
          enter|exit|
          aenter|aexit|
          # other class magic
          call|del|init|default|new|init_subclass|
          instancecheck|subclasscheck|
          # pickling
          getnewargs|getnewargs_ex|getstate|setstate|reduce|reduce_ex|
          # descriptors
          delete|get|set|set_name|
          # class-specific
          subclasses
        )__\b
      comment: these methods have magic interpretation by python and are generally called indirectly through syntactic constructs
      scope: support.function.magic.vyper
  magic-variable-names:
    # magic variables which a class/module/object may have.
    # https://docs.vyper.org/3/library/inspect.html#types-and-members
    # https://docs.vyper.org/3/reference/datamodel.html#object.__slots__
    # https://docs.vyper.org/3/reference/datamodel.html#preparing-the-class-namespace
    - match: |-
        (?x)\b__(?:
          # generic object
          class|dict|doc|module|name|
          # module-specific / global
          all|file|package|
          # functions & methods
          annotations|closure|code|defaults|func|globals|kwdefaults|self|qualname|
          # classes (attributes)
          bases|prepare|slots|metaclass|mro|
        )__\b
      scope: support.variable.magic.vyper

  escaped-char:
    - match: '(\\x\h{2})|(\\[0-7]{3})|(\\[\\"''abfnrtv])'
      captures:
        1: constant.character.escape.hex.vyper
        2: constant.character.escape.octal.vyper
        3: constant.character.escape.vyper
    - match: \\.  # deprecated in 3.6 and will eventually be a syntax error
      scope: invalid.deprecated.character.escape.vyper

  escaped-unicode-char:
    - match: '(\\U\h{8})|(\\u\h{4})|(\\N\{[a-zA-Z ]+\})'
      captures:
        1: constant.character.escape.unicode.16-bit-hex.vyper
        2: constant.character.escape.unicode.32-bit-hex.vyper
        3: constant.character.escape.unicode.name.vyper

  line-continuation-inside-string:
    - match: (\\)$\n?
      captures:
        1: punctuation.separator.continuation.line.vyper
    - match: \n
      scope: invalid.illegal.unclosed-string.vyper
      set: after-expression

  constant-placeholder:
    - match: |- # printf style
        (?x)
        %
          ( \( ({{identifier}}) \) )? # mapping key
          \#?            # alternate form
          0?             # pad with zeros
          \-?            # left-adjust
          \ ?            # implicit sign
          [+-]?          # sign
          (\d*|\*)       # width
          (\. (\d*|\*))? # precision
          [hlL]?         # length modifier (but ignored)
          [acdeEfFgGiorsuxX%]
      scope: constant.other.placeholder.vyper
      captures:
        2: variable.other.placeholder.vyper
    - match: '{{strftime_spec}}'
      scope: constant.other.placeholder.vyper
    - match: '\{\{|\}\}'
      scope: constant.character.escape.vyper
    - include: formatting-syntax

  formatting-syntax:
    # https://docs.vyper.org/3.6/library/string.html#formatstrings
    - match: |- # simple form
        (?x)
        (\{)
          (?: [\w.\[\]]+)?             # field_name
          (   ! [ars])?                # conversion
          (   : (?:{{format_spec}}|    # format_spec OR
                   [^}%]*%.[^}]*)      # any format-like string
          )?
        (\})
      scope: constant.other.placeholder.vyper
      captures:
        1: punctuation.definition.placeholder.begin.vyper
        2: storage.modifier.conversion.vyper
        3: constant.other.format-spec.vyper
        4: punctuation.definition.placeholder.end.vyper
    - match: \{(?=[^\}"']+\{[^"']*\}) # complex (nested) form
      scope: punctuation.definition.placeholder.begin.vyper
      push:
        - meta_scope: constant.other.placeholder.vyper
        - match: \}
          scope: punctuation.definition.placeholder.end.vyper
          pop: true
        - match: '[\w.\[\]]+'
        - match: '![ars]'
          scope: storage.modifier.conversion.vyper
        - match: ':'
          push:
            - meta_scope: meta.format-spec.vyper constant.other.format-spec.vyper
            - match: (?=\})
              pop: true
            - include: formatting-syntax

  f-string-content:
    # https://www.vyper.org/dev/peps/pep-0498/
    # https://docs.vyper.org/3.6/reference/lexical_analysis.html#f-strings
    - match: \{\{|\}\}
      scope: constant.character.escape.vyper
    - match: \{\s*\}
      scope: invalid.illegal.empty-expression.vyper
    - match: (?=\{)
      push: f-string-replacement
    - match: \}
      scope: invalid.illegal.stray-brace.vyper

  f-string-replacement:
    - clear_scopes: 1
    - match: \}
      scope: meta.interpolation.vyper punctuation.section.interpolation.end.vyper
      pop: true
    - match: \{
      scope: punctuation.section.interpolation.begin.vyper
      push:
        - meta_scope: meta.interpolation.vyper
        - match: (?=\})
          pop: true
        - match: '![ars]'
          scope: storage.modifier.conversion.vyper
        - match: ':'
          push:
            - meta_scope: meta.format-spec.vyper constant.other.format-spec.vyper
            # Because replacements can also be used *within* the format-spec,
            # basically any character is valid and matching {{format_spec}} is useless.
            # - match: '{{format_spec}}'
            - match: (?=\})
              pop: true
            - include: f-string-content
        - match: ''
          push:
            - meta_content_scope: source.vyper.embedded
            - match: (?=![^=]|:|\})
              pop: true
            - match: \\
              scope: invalid.illegal.backslash-in-fstring.vyper
            - include: inline-for
            - include: expressions

  string-quoted-double-block:
    # Triple-quoted capital R raw string, unicode or not, no syntax embedding
    - match: '([uU]?R)(""")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.block.vyper
        - match: '"""'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-unicode-char
    # Triple-quoted capital R raw string, bytes, no syntax embedding
    - match: '([bB]R|R[bB])(""")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.block.vyper
        - match: '"""'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
    # Triple-quoted raw string, unicode or not, will detect SQL, otherwise regex
    - match: '([uU]?r)(""")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.block.vyper
        - match: '(?=\S)'
          set:
            - meta_scope: meta.string.vyper string.quoted.double.block.vyper
            - match: '"""'
              scope: punctuation.definition.string.end.vyper
              set: after-expression
            - match: ''
              push: scope:source.regexp.vyper
              with_prototype:
                - match: '(?=""")'
                  pop: true
                - include: escaped-unicode-char
    # Triple-quoted raw string, bytes, will use regex
    - match: '([bB]r|r[bB])(""")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.block.vyper
        - match: '"""'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - match: ''
          embed: scope:source.regexp.vyper
          escape: (?=""")
    # Triple-quoted raw f-string
    - match: ((?i)fr|rf)(""")
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.double.block.vyper
        - match: '"""'
          scope: punctuation.definition.string.begin.vyper
          set: after-expression
        - include: f-string-content
    # Triple-quoted f-string
    - match: ((?i)f|f)(""")
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.double.block.vyper
        - match: '"""'
          scope: punctuation.definition.string.begin.vyper
          set: after-expression
        - include: escaped-unicode-char
        - include: escaped-char
        - include: f-string-content
    # Triple-quoted string, unicode or not, will detect SQL
    - match: '([uU]?)(""")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.block.vyper
        - match: '(?=\S)'
          set:
            - meta_scope: meta.string.vyper string.quoted.double.block.vyper
            - match: '"""'
              scope: punctuation.definition.string.end.vyper
              set: after-expression
            - include: escaped-unicode-char
            - include: escaped-char
            - include: constant-placeholder
    # Triple-quoted string, bytes, no syntax embedding
    - match: '([bB])(""")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.block.vyper
        - match: '"""'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-char
        - include: constant-placeholder

  string-quoted-double:
    # Single-line capital R raw string, unicode or not, no syntax embedding
    - match: '([uU]?R)(")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
    # Single-line capital R raw string, bytes, no syntax embedding
    - match: '([bB]R|R[bB])(")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
    # Single-line raw string, unicode or not, treated as regex
    - match: '([uU]?r)(")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
        - match: ''
          push: scope:source.regexp.vyper
          with_prototype:
            - match: '(?="|\n)'
              pop: true
            - include: line-continuation-inside-string
    # Single-line raw string, bytes, treated as regex
    - match: '([bB]r|r[bB])(")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
        - match: ''
          embed: scope:source.regexp.vyper
          escape: (?="|\n)
    # Single-line raw f-string
    - match: ((?i)fr|rf)(")
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
        - include: f-string-content
    # Single-line f-string
    - match: ((?i)f|f)(")
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-unicode-char
        - include: escaped-char
        - include: line-continuation-inside-string
        - include: f-string-content
    # Single-line string, unicode or not
    - match: '([uU]?)(")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-unicode-char
        - include: escaped-char
        - include: line-continuation-inside-string
        - include: constant-placeholder
    # Single-line string, bytes
    - match: '([bB])(")'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.double.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.double.vyper
        - match: '"'
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-char
        - include: line-continuation-inside-string
        - include: constant-placeholder

  string-quoted-single-block:
    # Triple-quoted capital R raw string, unicode or not, no syntax embedding
    - match: ([uU]?R)(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.block.vyper
        - match: "'''"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
    # Triple-quoted capital R raw string, bytes, no syntax embedding
    - match: ([bB]R|R[bB])(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.block.vyper
        - match: "'''"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
    # Triple-quoted raw string, unicode or not, will detect SQL, otherwise regex
    - match: ([uU]?r)(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.block.vyper
        - match: '(?=\S)'
          set:
            - meta_scope: meta.string.vyper string.quoted.single.block.vyper
            - match: "'''"
              scope: punctuation.definition.string.end.vyper
              set: after-expression
            - match: ''
              push: scope:source.regexp.vyper
              with_prototype:
                - match: (?=''')
                  pop: true
                - include: escaped-unicode-char
    # Triple-quoted raw string, bytes, will use regex
    - match: ([bB]r|r[bB])(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.block.vyper
        - match: "'''"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - match: ''
          embed: scope:source.regexp.vyper
          escape: (?=''')
    # Triple-quoted raw f-string
    - match: ((?i)fr|rf)(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.single.block.vyper
        - match: "'''"
          scope: punctuation.definition.string.begin.vyper
          set: after-expression
        - include: f-string-content
    # Triple-quoted f-string
    - match: ([fF])(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.single.block.vyper
        - match: "'''"
          scope: punctuation.definition.string.begin.vyper
          set: after-expression
        - include: escaped-unicode-char
        - include: escaped-char
        - include: f-string-content
    # Triple-quoted string, unicode or not, will detect SQL
    - match: ([uU]?)(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.block.vyper
        - match: '(?=\S)'
          set:
            - meta_scope: meta.string.vyper string.quoted.single.block.vyper
            - match: "'''"
              scope: punctuation.definition.string.end.vyper
              set: after-expression
            - include: escaped-unicode-char
            - include: escaped-char
            - include: constant-placeholder
    # Triple-quoted string, bytes, no syntax embedding
    - match: ([bB])(''')
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.block.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.block.vyper
        - match: "'''"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-char
        - include: constant-placeholder

  string-quoted-single:
    # Single-line capital R raw string, unicode or not, no syntax embedding
    - match: '([uU]?R)('')'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
    # Single-line capital R raw string, bytes, no syntax embedding
    - match: '([bB]R|R[bB])('')'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
    # Single-line raw string, bytes, treated as regex
    - match: '([bB]r|r[bB])('')'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
        - match: ''
          push: scope:source.regexp.vyper
          with_prototype:
            - match: '(?=''|\n)'
              pop: true
            - include: line-continuation-inside-string
    # Single-line raw f-string
    - match: ((?i)fr|rf)(')
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: line-continuation-inside-string
        - include: f-string-content
    # Single-line f-string
    - match: ((?i)f|f)(')
      captures:
        1: storage.type.string.vyper
        2: meta.string.interpolated.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.interpolated.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-unicode-char
        - include: escaped-char
        - include: line-continuation-inside-string
        - include: f-string-content
    # Single-line string, unicode or not
    - match: '([uU]?)('')'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-unicode-char
        - include: escaped-char
        - include: line-continuation-inside-string
        - include: constant-placeholder
    # Single-line string, bytes
    - match: '([bB])('')'
      captures:
        1: storage.type.string.vyper
        2: meta.string.vyper string.quoted.single.vyper punctuation.definition.string.begin.vyper
      push:
        - meta_content_scope: meta.string.vyper string.quoted.single.vyper
        - match: "'"
          scope: punctuation.definition.string.end.vyper
          set: after-expression
        - include: escaped-char
        - include: line-continuation-inside-string
        - include: constant-placeholder

  strings:
    # block versions must be matched first
    - include: string-quoted-double-block
    - include: string-quoted-double
    - include: string-quoted-single-block
    - include: string-quoted-single

  inline-for:
    - match: \b(for)\b
      captures:
        2: keyword.control.flow.for.generator.vyper
      push:
        - include: comments
        - meta_scope: meta.expression.generator.vyper
        - match: \b(in)\b
          scope: keyword.control.flow.for.in.vyper
          pop: true
        - match: '(?=[)\]}])'
          scope: invalid.illegal.missing-in.vyper
          pop: true
        - include: illegal-names-pop
        - include: target-list

  inline-if:
    - match: \b(if)\b
      scope: keyword.control.flow.if.inline.vyper
    - match: \b(else)\b
      scope: keyword.control.flow.else.inline.vyper

  target-list:
    - match: ','
      scope: punctuation.separator.target-list.vyper
    - match: \(
      scope: punctuation.section.target-list.begin.vyper
      push:
        - include: comments
        - match: ','
          scope: punctuation.separator.target-list.vyper
        - match: \)
          scope: punctuation.section.target-list.end.vyper
          pop: true
        - include: target-list
        - include: name
    - include: name