RustEnhanced.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: Rust Enhanced
file_extensions:
  - rs
scope: source.rust
variables:
  identifier: '(?:[[:alpha:]][_[:alnum:]]*|_[_[:alnum:]]+)'
  escaped_byte: '\\(x\h{2}|n|r|t|0|"|''|\\)'
  escaped_char: '\\(x\h{2}|n|r|t|0|"|''|\\|u\{\h{1,6}\})'
  int_suffixes: '[iu](?:8|16|32|64|size)'
contexts:
  main:
    - include: statements

  prototype:
    # Macro metavariables. Ideally we would do this as a with_prototype,
    # however then we run into infinite recursion. It needs to be a prototype
    # since macro_rules! allows constructing new code, thus the metavariables
    # can be inserted in just about any position in the syntax.
    - match: '\${{identifier}}'
      scope: variable.other.rust

  statements:

    - match: ';'
      scope: punctuation.terminator

    - match: '''({{identifier}})\s*(:)'
      captures:
        1: entity.name.label.rust
        2: punctuation.separator.rust

    - match: '''{{identifier}}(?!\'')\b'
      scope: storage.modifier.lifetime.rust

    - match: '\b(?:(pub)\s+)?\b(mod)\s+({{identifier}})\b'
      captures:
        1: storage.modifier.rust
        2: storage.type.module.rust
        3: entity.name.module.rust
      push:
        - meta_scope: meta.module.rust
        - match: ';'
          set: after-operator
        - include: statements-block

    - match: '\b({{identifier}})\s*(=)\s*(?=\|)'
      captures:
        1: entity.name.function.rust
        2: keyword.operator.rust
      push: closure

    - match: '\b(?:(pub)\s+)?\b(fn)\s+(?={{identifier}})'
      scope: meta.function.rust
      captures:
        1: storage.modifier.rust
        2: storage.type.function.rust
      push: fn-definition

    - match: '\b(?:(pub)\s+)?(struct)\s+'
      scope: meta.struct.rust
      captures:
        1: storage.modifier.rust
        2: storage.type.struct.rust
      push: struct-identifier

    - match: '\b(?:(pub)\s+)?(type)\s+({{identifier}})\b'
      captures:
        1: storage.modifier.rust
        2: storage.type.type.rust
        3: entity.name.type.rust
      push:
      - match: '=(?!=)'
        scope: keyword.operator.rust
        push: after-operator
      - match: '(?=\S)'
        pop: true

    - match: '\b(?:(pub)\s+)?(trait)\s+({{identifier}})\b'
      captures:
        1: storage.modifier.rust
        2: storage.type.trait.rust
        3: entity.name.trait.rust
      push:
        - meta_scope: meta.trait.rust
        - include: statements-block

    - match: '\bimpl\b'
      scope: storage.type.impl.rust
      push: impl-definition

    - match: '\b(?:(pub)\s+)?(enum)\s+({{identifier}})\b'
      captures:
        1: storage.modifier.rust
        2: storage.type.enum.rust
        3: entity.name.enum.rust
      push:
        - meta_scope: meta.enum.rust
        - include: statements-block

    - match: \b(let|const|static)\b
      scope: storage.type.rust keyword.other.rust

    - match: \bfn\b
      scope: storage.type.function.rust

    - match: \bmod\b
      scope: storage.type.module.rust

    - match: \bstruct\b
      scope: storage.type.struct.rust

    - match: \bimpl\b
      scope: storage.type.impl.rust

    - match: \benum\b
      scope: storage.type.enum.rust

    - match: \btype\b
      scope: storage.type.type.rust

    - match: \btrait\b
      scope: storage.type.trait.rust

    - match: \b(mut|pub|unsafe|move|ref)\b
      scope: storage.modifier.rust

    - match: \b(crate|extern|use|where)\b
      scope: keyword.other.rust

    - match: \b(break|else|for|if|loop|match|while|continue|yield)\b
      scope: keyword.control.rust

    - match: \breturn\b
      scope: keyword.control.rust

    - match: \b(as|in|box)\b
      scope: keyword.operator.rust

    - match: \b(virtual|proc|alignof|become|offsetof|priv|pure|sizeof|typeof|unsized|yield|do|abstract|final|override|macro)\b
      scope: invalid.illegal.rust

    - match: \b(true|false)\b
      scope: constant.language.rust

    - include: type

    - match: '\b(macro_rules!)\s+([[:alpha:]_][[:alnum:]_]*)\b'
      captures:
        1: support.function.rust
        2: entity.name.macro.rust
      push: macro-block

    - include: comments
    - include: attribute
    - include: strings
    - include: chars

    - match: '\b[[:lower:]_][[:lower:][:digit:]_]*(?=\()'
      scope: support.function.rust

    - match: '\b((?:format|print|println|panic|format_args|unreachable)!)\s*(\()'
      captures:
        1: support.macro.rust
        2: meta.group.rust punctuation.definition.group.begin.rust
      push:
        - meta_content_scope: meta.group.rust
        - include: comments
        - include: format-string
        - include: format-raw-string
        - match: '(?=\S)'
          set: group-tail

    - match: '\b((?:write|writeln)!)\s*(\()'
      captures:
        1: support.macro.rust
        2: meta.group.rust punctuation.definition.group.begin.rust
      push:
        - meta_scope: meta.group.rust
        - include: comments
        - match: ','
          set:
            - meta_content_scope: meta.group.rust
            - include: format-string
            - include: format-raw-string
            - match: '(?=\S)'
              set: group-tail
        - include: group-tail

    - match: '\b[[:lower:]_][[:lower:][:digit:]_]*!(?=\s*(\(|\{|\[))'
      scope: support.macro.rust

    - include: support-type

    - include: basic-identifiers
    - include: numbers

    - match: '(?=\{)'
      push: block

    - match: '(?=\()'
      push: group

    - match: '\['
      scope: punctuation.definition.group.begin.rust
      push:
        - meta_scope: meta.group.rust
        - match: '\]'
          scope: punctuation.definition.group.end.rust
          pop: true
        - include: statements

    - include: return-type

    # Making this an operator helps visually break up large
    # match blocks containing just enums
    - match: '=>'
      scope: keyword.operator.rust

    - match: '=(?!=)'
      scope: keyword.operator.rust

    - match: '[;,]'

    - match: ':'
      scope: punctuation.separator.rust

    - match: '\.\.\.'
      scope: keyword.operator.rust

    - match: '\.\.'
      scope: keyword.operator.rust

    - match: '<<=|>>=|<<|>>'
      scope: keyword.operator.rust

    - match: '>=|<=|==|!=|&&|\|\|'
      scope: keyword.operator.rust

    - match: '\*=|/=|+=|-=|%=|\^='
      scope: keyword.operator.rust

    - match: '[-=<>&|!~@?+*/%^''#$]'
      scope: keyword.operator.rust

  attribute:
    - match: '#!?\['
      push:
        # https://github.com/sublimehq/Packages/issues/709#issuecomment-266835130
        - meta_scope: meta.annotation.rust
        - include: statements
        - match: '\]'
          pop: true

  block:
    - match: '\}'
      scope: meta.block.rust punctuation.definition.block.end.rust
      pop: true
    - match: '\{'
      scope: punctuation.definition.block.begin.rust
      push: [block-body, try-closure]

  block-body:
    - meta_scope: meta.block.rust
    - match: '(?=\})'
      pop: true
    - include: statements
    - include: attribute

  group:
    - match: '\)'
      scope: meta.group.rust punctuation.definition.group.end.rust
      pop: true
    - match: '\('
      scope: punctuation.definition.group.begin.rust
      push: [group-body, try-closure]

  group-body:
    - meta_scope: meta.group.rust
    - match: '(?=\))'
      pop: true
    - include: statements

  group-tail:
    - meta_scope: meta.group.rust
    - match: '\)'
      scope: punctuation.definition.group.end.rust
      pop: true
    - include: statements

  after-operator:
    - match: '(?=<)'
      set: generic-angles
    - include: try-closure

  try-closure:
    - match: '\s*(?=\|)'
      set: closure
    # Exit the context if we didn't find a closure
    - match: '(?=\S)'
      pop: true

  support-type:
    - match: '(Vec|Option|Result|BTreeMap|HashMap|Box|Rc|Arc|AsRef|AsMut|Into|From)\s*(?=<)'
      scope: support.type.rust
      push: generic-angles
    - match: '[?]?(?=\bSized\b)'
      scope: keyword.operator.rust
    - match: '[!]?(?=\bSync|Send\b)'
      scope: keyword.operator.rust
    - match: \b(Copy|Send|Sized|Sync|Drop|Fn|FnMut|FnOnce|Box|ToOwned|Clone|PartialEq|PartialOrd|Eq|Ord|AsRef|AsMut|Into|From|Default|Iterator|Extend|IntoIterator|DoubleEndedIterator|ExactSizeIterator|Option|Some|None|Result|Ok|Err|SliceConcatExt|String|ToString|Vec)\b 
      scope: support.type.rust 

  return-type:
    - match: '\bimpl\b'
      scope: storage.type.impl.rust
      push:
        - include: comments
        - include: impl-generic
        - match: '(?=\S)'
          pop: true
    - match: '->'
      scope: punctuation.separator.rust
      push:
        - meta_scope: meta.function.return-type.rust
        - match: '(?=\s*\{|\bwhere\b)'
          pop: true
        - match: '(?=<)'
          push: generic-angles
        - include: type-any-identifier
        - match: '{{identifier}}'
        # Escape for incomplete expression
        - match: '(?=\S)'
          pop: true

  closure:
    - meta_content_scope: meta.function.closure.rust
    - match: '\|'
      scope: punctuation.definition.parameters.begin.rust
      set: [closure-return, closure-parameters]

  closure-parameters:
    - meta_scope: meta.function.parameters.rust
    # If the user has just typed a |, exit the params
    # scope as soon as we hit something that it not a
    # valid part so the whole rest of the document isn't
    # highlighted using the params scope
    - match: '(?=\()'
      push: group
    - match: '(?=[};)\]\n])'
      pop: true
    - match: '\|'
      scope: punctuation.definition.parameters.end.rust
      pop: true
    - match: \bself\b
      scope: variable.parameter.rust
    - match: '({{identifier}})\s*(?:(:(?!:))|(?=\||,))'
      captures:
        1: variable.parameter.rust
        2: punctuation.separator.rust
      push:
        - match: (?=,|\|)
          pop: true
        - include: type-any-identifier
    - match: '&'
      scope: keyword.operator.rust
    - match: \b(mut|ref)\b
      scope: storage.modifier.rust
    - match: '''{{identifier}}(?!\'')\b'
      scope: storage.modifier.lifetime.rust

  closure-return:
    - meta_content_scope: meta.function.closure.rust
    - include: return-type
    - match: (?=\S)
      set: closure-body

  closure-body:
    - match: '(?=\{)'
      set: closure-explicit-body
    - match: (?=\S)
      set:
        - meta_scope: meta.function.closure.rust
        - match: '(?=[};)\]\n])'
          pop: true
        - include: statements

  closure-explicit-body:
    - meta_scope: meta.function.closure.rust
    - include: block

  type:
    - match: '{{identifier}}(?=<)'
      push: generic-angles
    - match: \b(Self|i8|i16|i32|i64|isize|u8|u16|u32|u64|usize|f32|f64|bool|char|str)\b
      scope: storage.type.rust

  generic-angles:
    - meta_scope: meta.generic.rust
    # -> to cover https://doc.rust-lang.org/std/boxed/trait.FnBox.html
    - include: support-type
    - match: '>'
      scope: punctuation.definition.generic.end.rust
      pop: true
    - match: '<'
      scope: punctuation.definition.generic.begin.rust
      push: generic-angles-contents
    # Alert the user of a broken generic construct
    - match: '.'
      scope: invalid.illegal.rust
      pop: true

  generic-angles-contents:
    - include: comments
    - match: \bextern\b
      scope: keyword.other.rust
      push:
        - include: strings
        - match: '(?=\S)'
          pop: true
    - match: '\['
      scope: punctuation.definition.group.begin.rust
      push:
        - match: '\]'
          scope: punctuation.definition.group.end.rust
          pop: true
        - include: type-any-identifier
    - match: '(?=>)'
      pop: true
    - match: '<'
      scope: punctuation.definition.generic.begin.rust
      push:
        - match: '>'
          scope: punctuation.definition.generic.begin.rust
          pop: true
        - include: generic-angles-contents
    - include: type-any-identifier
    - match: '{{identifier}}'
    - match: ':|,'
      scope: punctuation.separator.rust
    - match: '\+|\bas\b|='
      scope: keyword.operator.rust
    - match: '\S'
      scope: invalid.illegal.rust
      pop: true

  type-any-identifier:
    - include: comments
    - include: support-type
    - include: return-type
    - match: '&'
      scope: keyword.operator.rust
    - match: \b(mut|ref)\b
      scope: storage.modifier.rust
    - match: \b(fn)\b(\()
      captures:
        1: storage.type.function.rust
        2: meta.group.rust punctuation.definition.group.begin.rust
      push:
        - meta_content_scope: meta.group.rust
        - match: \)
          scope: meta.group.rust punctuation.definition.group.end.rust
          set:
            - include: return-type
            - match: '(?=\S)'
              pop: true
        - include: type-any-identifier
    - match: '''{{identifier}}(?!\'')\b'
      scope: storage.modifier.lifetime.rust
    - match: '\b([[:upper:]]|_*[[:upper:]][[:alnum:]_]*[[:lower:]][[:alnum:]_]*)\b::'
      scope: meta.path.rust storage.type.rust
      captures:
        1: storage.type.rust
    - match: '{{identifier}}::'
      scope: meta.path.rust
    - match: '::(?={{identifier}})'
      scope: meta.path.rust
    - match: '(?=<)'
      push: generic-angles
    - match: '\('
      scope: punctuation.definition.type.begin.rust
      push:
        - match: '\)'
          scope: punctuation.definition.type.end.rust
          pop: true
        - include: type-any-identifier
    - include: type
    - match: '\b_\b'
      scope: keyword.operator.rust

  struct-identifier:
    - match: '{{identifier}}(?=<)'
      scope: entity.name.struct.rust
      set:
        - meta_scope: meta.struct.rust meta.generic.rust
        - match: '(?=<)'
          push: generic-angles
        - match: ''
          set: struct-body
    - match: '{{identifier}}'
      scope: entity.name.struct.rust
      set: struct-body

  struct-body:
    - meta_scope: meta.struct.rust
    - include: comments
    - match: '(?=\bwhere\b)'
      push: impl-where
    - match: '(?=\()'
      push: struct-tuple
    - match: '(?=\{)'
      set: struct-classic
    - match: '(?=;)'
      pop: true

  struct-tuple:
    - meta_scope: meta.struct.rust
    - match: '\)'
      scope: punctuation.definition.group.end.rust
      pop: true
    - match: '\('
      scope: punctuation.definition.group.begin.rust
      # Ensure that we end the tuple at the next ) to
      # prevent odd highlighting as the user is typing
      with_prototype:
        - match: '(?=\))'
          pop: true
      push:
        - meta_scope: meta.group.rust
        - include: comments
        - include: type-any-identifier

  struct-classic:
    - meta_scope: meta.struct.rust
    - match: '\}'
      scope: meta.block.rust punctuation.definition.block.end.rust
      pop: true
    - match: '\{'
      scope: punctuation.definition.block.begin.rust
      push:
        - meta_scope: meta.block.rust
        - match: '(?=\})'
          pop: true
        - include: comments
        - include: attribute
        - match: \bpub\b
          scope: storage.modifier.rust
        - match: '{{identifier}}(?=\s*:)'
          scope: variable.other.member.rust
          push:
            - match: ',|(?=\})'
              pop: true
            - include: comments
            - match: ':'
              scope: punctuation.separator.rust
            - include: type-any-identifier

  macro-block:
    - meta_scope: meta.macro.rust
    - match: '\}'
      scope: meta.block.rust punctuation.definition.block.end.rust
      pop: true
    - match: '[\])]'
      scope: punctuation.definition.ground.end.rust
      pop: true
    - match: '\{'
      scope: punctuation.definition.block.begin.rust
      push:
        - meta_scope: meta.block.rust
        - match: '(?=\})'
          pop: true
        - include: macro-block-contents
    - match: '\['
      scope: punctuation.definition.group.begin.rust
      push:
        - meta_scope: meta.group.rust
        - match: '(?=\])'
          pop: true
        - include: macro-block-contents
    - match: '\('
      scope: punctuation.definition.group.begin.rust
      push:
        - meta_scope: meta.group.rust
        - match: '(?=\))'
          pop: true
        - include: macro-block-contents

  macro-block-contents:
    - include: comments
    - match: '\('
      scope: punctuation.definition.group.begin.rust
      push: macro-matcher
    - match: ';'
      pop: true

  macro-matcher:
    - meta_include_prototype: false
    - meta_scope: meta.group.rust
    - match: '\)'
      scope: punctuation.definition.group.end.rust
      set: macro-match-operator
    - match: '(\$)(\()'
      captures:
        1: keyword.operator.rust
        2: punctuation.definition.group.begin.rust
      push:
        - match: '(\))[^*+]?([*+])'
          captures:
            1: punctuation.definition.group.end.rust
            2: keyword.operator.rust
          pop: true
        - include: macro-metavariable
    - include: macro-metavariable

  macro-match-operator:
    - match: '=>'
      scope: keyword.operator.rust
    - match: '\{'
      scope: punctuation.definition.block.begin.rust
      set:
        - meta_scope: meta.block.rust
        - match: '\}'
          scope: punctuation.definition.block.end.rust
          pop: true
        - include: statements
    - match: '\('
      scope: punctuation.definition.group.begin.rust
      set:
        - meta_scope: meta.group.rust
        - match: '\)'
          scope: punctuation.definition.group.end.rust
          pop: true
        - include: statements
    - match: '\['
      scope: punctuation.definition.group.begin.rust
      set:
        - meta_scope: meta.group.rust
        - match: '\]'
          scope: punctuation.definition.group.end.rust
          pop: true
        - include: statements

  macro-metavariable:
    - match: '(\${{identifier}})(:)(ident|path|expr|ty|pat|stmt|block|item|meta|tt)'
      captures:
        1: variable.parameter.rust
        2: punctuation.separator.rust
        3: storage.type.rust

  impl-definition:
    - meta_scope: meta.impl.rust
    - include: comments
    - match: '(?=<)'
      set: [impl-for, impl-generic]
    - match: (?=\S)
      set: impl-for

  impl-generic:
    - meta_scope: meta.impl.rust
    - match: '(?=<)'
      push: generic-angles
    - match: ''
      pop: true

  impl-for:
    - match: '(?=\s*(?:::|{{identifier}}|\$|<)+(<.*?>)?\s+for\s+)'
      set:
        - meta_scope: meta.impl.rust
        - include: comments
        - match: \bfor\b
          scope: keyword.other.rust
          set: impl-identifier
        - include: type-any-identifier
    - match: ''
      set: impl-identifier

  impl-identifier:
    - meta_content_scope: meta.impl.rust
    - include: comments
    - match: '(?=\{)'
      set: impl-body
    - match: '(?=\bwhere\b)'
      push: impl-where
    - match: '{{identifier}}(?=<)'
      scope: entity.name.impl.rust
      push: generic-angles
    - match: '{{identifier}}'
      scope: entity.name.impl.rust
    - match: '&'
      scope: keyword.operator.rust
    - match: \b(mut|ref)\b
      scope: storage.modifier.rust
    - match: '''{{identifier}}(?!\'')\b'
      scope: storage.modifier.lifetime.rust

  impl-where:
    - meta_scope: meta.where.rust
    - include: comments
    - match: '(?=(\{|;))'
      pop: true
    - match: \bwhere\b
      scope: keyword.other.rust
    - match: \bfor\b
      scope: keyword.other.rust
      push:
        - match: '(?=<)'
          push: generic-angles
        - include: type-any-identifier
        - match: '&'
          scope: keyword.operator.rust
        - match: '''{{identifier}}(?!\'')\b'
          scope: storage.modifier.lifetime.rust
        - match: '(?=\S)'
          pop: true
    - include: type-any-identifier
    - match: ':'
      scope: punctuation.separator.rust

  impl-body:
    - meta_scope: meta.impl.rust
    - include: statements-block

  fn-definition:
    - meta_scope: meta.function.rust
    - include: comments
    - match: '{{identifier}}'
      scope: entity.name.function.rust
      set: fn-generic

  fn-generic:
    - include: comments
    - match: '(?=<)'
      push: generic-angles
    - match: '(?=\()'
      set: fn-parameters
    - match: \bwhere\b
      set: fn-where
    # Escape for incomplete expression
    - match: '(?=;)'
      pop: true

  fn-parameters:
    - meta_scope: meta.function.rust
    - match: '\)'
      scope: meta.function.parameters.rust punctuation.definition.parameters.end.rust
      set: fn-return
    - match: '\('
      scope: punctuation.definition.parameters.begin.rust
      push:
        - meta_scope: meta.function.parameters.rust
        - include: comments
        - match: '(?=\))'
          pop: true
        - match: \bself\b
          scope: variable.parameter.rust
        - match: '({{identifier}})\s*(:(?!:))'
          captures:
            1: variable.parameter.rust
            2: punctuation.separator.rust
        - include: type-any-identifier

  fn-return:
    - meta_scope: meta.function.rust
    - include: comments
    - match: '(?=\{)'
      set: fn-body
    - match: '(?=\bwhere\b)'
      set: fn-where
    - include: return-type
    # Escape for incomplete expression
    - match: '(?=\S)'
      pop: true

  fn-where:
    - meta_scope: meta.function.rust meta.where.rust
    - include: comments
    - match: '(?=\{)'
      set: fn-body
    - match: \bwhere\b
      scope: keyword.other.rust
    - match: \bfor\b
      scope: keyword.other.rust
      push:
        - match: '(?=<)'
          push: generic-angles
        - include: type-any-identifiers
        - match: '&'
          scope: keyword.operator.rust
        - match: '''{{identifier}}(?!\'')\b'
          scope: storage.modifier.lifetime.rust
        - match: '(?=\S)'
          pop: true
    - include: type-any-identifiers
    - match: ':'
      scope: punctuation.separator.rust
    - match: ';'
      pop: true

  fn-body:
    - meta_scope: meta.function.rust
    - match: '\}'
      scope: meta.block.rust punctuation.definition.block.end.rust
      pop: true
    - match: '\{'
      scope: punctuation.definition.block.begin.rust
      push:
        - meta_scope: meta.block.rust
        - match: '(?=\})'
          pop: true
        - include: statements

  statements-block:
    - include: comments
    - match: '\}'
      scope: meta.block.rust punctuation.definition.block.end.rust
      pop: true
    - match: '\{'
      scope: punctuation.definition.block.begin.rust
      push: [block-body, try-closure]

  comments:
    - include: block-comments
    - match: "//[!/]"
      push:
        - meta_scope: comment.line.documentation.rust
        - match: $\n?
          pop: true
    - match: //
      push:
        - meta_scope: comment.line.double-slash.rust
        - match: $\n?
          pop: true

  block-comments:
    - match: '/\*[!\*][^\*/]'
      push:
        - meta_scope: comment.block.documentation.rust
        - match: \*/
          pop: true
        - include: block-comments
    - match: /\*
      push:
        - meta_scope: comment.block.rust
        - match: \*/
          pop: true
        - include: block-comments

  strings:
    - include: byte-string
    - include: raw-byte-string
    - include: string
    - include: raw-string

  chars:
    - include: char
    - include: byte

  escaped-byte:
    - match: '{{escaped_byte}}'
      scope: constant.character.escape.rust

  byte:
    - match: "(b)(')(?=([^'\\\\]|{{escaped_byte}})')"
      captures:
        1: storage.type.string.rust
        2: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.single.rust
        - match: \'
          scope: punctuation.definition.string.end.rust
          pop: true
        - include: escaped-byte

  byte-string:
    - match: '(b)(")'
      captures:
        1: storage.type.string.rust
        2: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.rust
        - match: '"'
          scope: punctuation.definition.string.end.rust
          pop: true
        - include: escaped-byte

  raw-byte-string:
    - match: (br)(#*)"
      captures:
        1: storage.type.string.rust
        2: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.raw.rust
        - match: '"\2'
          scope: punctuation.definition.string.end.rust
          pop: true

  escaped-char:
    - match: '{{escaped_char}}'
      scope: constant.character.escape.rust

  char:
    - match: "'(?=([^'\\\\]|{{escaped_char}})')"
      scope: punctuation.definition.string.begin.rust
      push:
        - meta_scope: string.quoted.single.rust
        - match: \'
          scope: punctuation.definition.string.end.rust
          pop: true
        - include: escaped-char

  string:
    - match: '"'
      scope: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.rust
        - match: '"'
          scope: punctuation.definition.string.end.rust
          pop: true
        - include: escaped-char

  raw-string:
    - match: (r)(#*)"
      captures:
        1: storage.type.string.rust
        2: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.raw.rust
        - match: '"\2'
          scope: punctuation.definition.string.end.rust
          pop: true

  format-string:
    - match: '"'
      scope: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.rust
        - match: '"'
          scope: punctuation.definition.string.end.rust
          pop: true
        - include: escaped-char
        - include: format-escapes

  format-raw-string:
    - match: (r)(#*)"
      captures:
        1: storage.type.string.rust
        2: punctuation.definition.string.begin.rust
      push:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.raw.rust
        - match: '"\2'
          scope: punctuation.definition.string.end.rust
          pop: true
        - include: format-escapes

  format-escapes:
    - match: '\{\{|\}\}'
      scope: constant.character.escape.rust
    - match: |-
        (?x)                      # Spec from http://doc.rust-lang.org/std/fmt/
        \{
          (\d+|{{identifier}})?
          (
            :                     # format_spec delimiter
            (.?[<>^])?            # [[fill]align]
            [+-]?                 # [sign]
            \#?                   # ['#']
            0?                    # [0]
            (\d\$?)?              # [width]
            (\.(\d\$?|\*)?)?      # ['.' precision]
            (\?|{{identifier}})?  # [type]
          )?
        \}
      scope: constant.other.placeholder.rust

  numbers:
    - match: '\b((?:\d[\d_]*)?\d\.)(\d[\d_]*(?:[eE][+-]?[\d_]*\d[\d_]*)?)(f32|f64)?'
      captures:
        1: constant.numeric.float.rust
        2: constant.numeric.float.rust
        3: storage.type.numeric.rust
    - match: '\b((?:\d[\d_]*)?\d\.)(?!\.)'
      scope: constant.numeric.float.rust
    - match: '\b(\d[\d_]*)(f32|f64)\b'
      captures:
        1: constant.numeric.float.rust
        2: storage.type.numeric.rust
    - match: '\b(\d[\d_]*)({{int_suffixes}})?\b'
      captures:
        1: constant.numeric.integer.decimal.rust
        2: storage.type.numeric.rust
    - match: '\b(0x[\h_]*\h[\h_]*)({{int_suffixes}})?\b'
      captures:
        1: constant.numeric.integer.hexadecimal.rust
        2: storage.type.numeric.rust
    - match: '\b(0o[0-7_]*[0-7][0-7_]*)({{int_suffixes}})?\b'
      captures:
        1: constant.numeric.integer.octal.rust
        2: storage.type.numeric.rust
    - match: '\b(0b[0-1_]*[0-1][0-1_]*)({{int_suffixes}})?\b'
      captures:
        1: constant.numeric.integer.binary.rust
        2: storage.type.numeric.rust

  basic-identifiers:
    - match: '\b([[:upper:]_][[:upper:][:digit:]_]+)\b'
      scope: constant.other.rust
    - match: '\b(c_[[:lower:][:digit:]_]+|[[:lower:]_][[:lower:][:digit:]_]*_t)\b'
      scope: storage.type.rust
    - match: '\b_*[A-Z][a-zA-Z0-9_]*[a-z][a-zA-Z0-9_]*\b'
      scope: storage.type.source.rust
    - match: '(?={{identifier}}::)'
      push:
        - meta_scope: meta.path.rust
        - include: no-path-identifiers
        - match: '::'
          set: no-type-names
    - match: '{{identifier}}::'
      scope: meta.path.rust
      push: no-type-names
    - match: '::(?={{identifier}})'
      scope: meta.path.rust
      push: no-type-names
    - include: no-path-identifiers

  no-path-identifiers:
    - match: \b(self)\b
      scope: variable.language.rust
    - match: \b(super)\b
      scope: keyword.other.rust

  no-type-names:
      # This push state prevents highlighting basic types like
      # i32, etc when following ::
      - include: comments
      - include: basic-identifiers
      - match: '{{identifier}}'
      - match: '(?=<)'
        push: generic-angles
      - match: ''
        pop: true