myst.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: Myst
comment: Sublime Syntax highlighting for the Myst programming language.
file_extensions:
  - mt
first_line_match: ^#!/.*\bmyst
scope: source.myst
variables:
  def_op: '\!|\+|\-|\*|\/|\%|\[\]=?|==|!='
  identifier: '([a-zA-Z][a-zA-Z0-9]*|_[a-zA-Z0-9]*)'
  constant: '[A-Z][_a-zA-Z0-9]*'
  magic_constants: '__LINE__|__FILE__|__DIR__'
contexts:
  main:
    - include: comments
    - match: '\b(end)\b'
      scope: keyword.control.myst
    - match: '\b(do)\b'
      scope: keyword.control.myst
      push: block
    - match: '\b(rescue)\b'
      scope: keyword.control.exceptions.myst
      push: rescue
    - match: '\b(ensure)\b'
      scope: keyword.control.exceptions.myst
      push: exception_handler
    - match: '\b(when|unless|else)\b'
      scope: keyword.conditional.myst
      push: conditional
    - match: '\b(while|until)\b'
      scope: keyword.loop.myst
      push: loop
    - match: \b(require|include|extend|raise)\b
      scope: keyword.control.import.myst
    - match: \b(break|return|next)\b
      scope: keyword.control.flow.myst
    - match: '(\%)([A-Z][_a-zA-Z0-9]*)'
      captures:
        1: punctuation.definition.arguments.type.myst
        2: variable.type.parameter.myst
    - match: (<=?|==|!=|>=?)
      scope: keyword.operator.comparison.myst
    - match: '(\+|\-|\*|\/|\%)'
      scope: keyword.operator.arithmetic.myst
    - match: '(\|\|=|\&\&=|\+=|\-=|\*=|\/=)'
      scope: keyword.operator.assignment.augmented.myst
    - match: '(=:?)'
      scope: keyword.operator.assignment.myst
    - match: '(\|\||&&)'
      scope: keyword.operator.logical.myst
    - match: '\.\b'
      scope: puncuation.accessor.myst
    - match: '\['
      scope: meta.brackets punctuation.section.brackets.begin.myst
      push: list_literal
    - match: '\{'
      scope: meta.brackets punctuation.section.brackets.begin.myst
      push: map_literal
    - match: self|{{magic_constants}}
      scope: variable.language.myst
    - match: '\b[0-9][_0-9]*\.[0-9][_0-9]*\b'
      scope: constant.numeric.float.myst
    - match: '\b[0-9][_0-9]*\b'
      scope: constant.numeric.integer.myst
    - match: true|false|nil
      scope: constant.language.myst
    - match: '\:[_a-zA-Z0-9]+'
      scope: constant.other.symbol.myst
    - match: \"
      scope: punctuation.definition.string.begin.myst
      push: string
    - match: '(@)([_a-z][_a-zA-Z0-9]*)'
      captures:
        1: punctuation.definition.variable.myst
        2: variable.other.instance.myst
    - match: \b_[_a-zA-Z0-9]*\b
      scope: variable.other.ignored.myst
    - match: \b[A-Z][_a-zA-Z0-9]*\b
      scope: variable.other.myst
    - match: \b(def|defstatic)\W([a-z][_a-zA-Z0-9]*(!|\?)?|{{def_op}})(\()?
      scope: meta.function.identifier.myst
      captures:
        1: keyword.control.function.myst
        2: entity.name.function.public.myst
        4: punctuation.definition.parameters.begin.myst
      push: function_parameters
    - match: \bfn\b
      scope: keyword.control.anonymous.myst
      push: anonymous_function
    - match: ^\s*(deftype|defmodule)\W([A-Z][_a-zA-Z0-9]*)
      captures:
        1: keyword.control.type.myst
        # Both `type` and `class` are added so that Sublime sees type
        # definitions in the symbol list, but themes also decide to highlight
        # the constant properly.
        2: meta.type.identifier.myst entity.name.type.myst entity.name.class.myst
      push:
        - meta_scope: meta.type.body.myst
        - include: main
        - match: \bend\b
          pop: true

  list_literal:
    - include: main
    - match: '\,'
      scope: punctuation.separator
    - match: '\]'
      scope: punctuation.section.brackets.end.myst
      pop: true

  map_literal:
    - match: '{{identifier}}\:'
      scope: constant.other.symbol.myst
    - include: main
    - match: '\,'
      scope: punctuation.separator
    - match: '\}'
      scope: punctuation.section.brackets.end.myst
      pop: true

  parameter:
    - include: list_literal
    - include: map_literal
    - match: '(&)[a-z][_a-zA-Z0-9]*\b'
      scope: variable.parameter.function.block.myst
      captures:
        1: punctuation.definition.parameter.type
    - match: '(\*)[a-z][_a-zA-Z0-9]*\b'
      scope: variable.parameter.function.block.myst
      captures:
        1: punctuation.definition.parameter.type
    - match: '(\%)([A-Z][_a-z0-9]*)'
      captures:
        1: punctuation.definition.arguments.type.myst
        2: variable.type.parameter.myst
    - match: \b[a-z][_a-zA-Z0-9]*\b
      scope: variable.parameter.function.myst
    - match: \b_[_a-zA-Z0-9]*\b
      scope: variable.parameter.function.ignored.myst
    - match: ':'
      scope: punctuation.definition.parameters.type.myst
    - match: '(=:?)'
      scope: keyword.operator.assignment.myst
    - match: ([A-Z][_a-zA-Z0-9]*)
      scope: entity.name.class.myst

  inline_parameter:
    - match: $
      pop: true
    - include: parameter

  function_parameters:
    - include: parameter
    - meta_scope: meta.function.body.myst
    - match: ;
      pop: true
    - match: $
      pop: true
    - match: ','
      scope: punctuation.separator.parameter.myst
    - match: \)$
      scope: punctuation.definition.parameters.end.myst
      pop: true

  comments:
    - match: \#.*
      scope: comment.line.number-sign

  conditional:
    - match: \b(when|unless|else)\b
      scope: keyword.conditional.myst
    - match: \b(end)\b
      scope: keyword.conditional.end.myst
      pop: true
    - include: main

  exception_handler:
    - match: \b(rescue)\b
      scope: keyword.control.exceptions.myst
      set: rescue
    - match: \b(ensure)\b
      scope: keyword.control.exceptions.myst
    - match: \b(end)\b
      scope: keyword.control.exceptions.end.myst
      pop: true
    - include: main

  # Rescues may have a single parameter given inline. Ensures do not allow
  # parameters. To accomodate this, `rescue` is handled separately from
  # other exception handlers _until the line with the `rescue` ends_. After
  # that point, it is treated like a normal exception handler.
  rescue:
    - include: parameter
    - match: $
      set: exception_handler
    - include: main

  loop:
    - match: \b(end)\b
      scope: keyword.loop.end.myst
      pop: true
    - include: main

  block:
    - match: \|
      scope: punctuation.definition.parameters.begin.myst
      push: block_parameters
    - match: end
      scope: keyword.control.myst
      pop: true
    - include: main

  block_parameters:
    - include: parameter
    - match: \|
      scope: punctuation.definition.parameters.myst
      pop: true

  string:
    - meta_scope: string.quoted.double.myst
    - match: \\t
      scope: constant.character.escape.tab.myst
    - match: \\n
      scope: constant.character.escape.newline.myst
    - match: \\r
      scope: constant.character.escape.return.myst
    - match: \\0
      scope: constant.character.escape.null.myst
    - match: \\\\
      scope: constant.character.escape.backslash.myst
    - match: \"
      pop: true
    - match: \<\(
      scope: punctuation.section.embedded.begin.myst
      push: interpolation

  interpolation:
    - meta_scope: source.myst.embedded.source
    - include: main
    - match: \)\>
      scope: punctuation.section.embedded.end.myst
      pop: true

  anonymous_function:
    - meta_scope: meta.function.body.myst
    - match: -\>
      # TODO: This needs a better scope name
      scope: keyword.operator.assignment.stab.myst
    - match: '\('
      push: function_parameters
    - include: main