Nextflow.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: Nextflow
file_extensions:
  - nf
  - nextflow
variables:
  unicode_letter: |-
    (?:(?xi)
      # Valid unicode letters according to:
      # http://groovy-lang.org/syntax.html#_normal_identifiers
      #   Literal Unicode         Escaped Unicode
          [\x{00C0}-\x{00D6}]  |  \\u00C[0-9A-F] | \\u00D[0-6]
        | [\x{00D8}-\x{00F6}]  |  \\u00D[89A-F]  | \\u00E[0-9A-F] | \\u00F[0-6]
        | [\x{00F8}-\x{00FF}]  |  \\u00F[89A-F]
        | [\x{0100}-\x{FFFE}]  |  \\u0[1-9A-F][0-9A-F]{2} | \\u(?!FFFF)[1-9A-F][0-9A-F]{3}
    )

  # dollars aren't allowed in the single dollar interpolated identifiers
  # (dotted expressions), but they are supposed to be valid characters
  # in identifiers in other contexts
  # e.g. `"$$a"` is invalid, but `"${$a}"` is fine.
  single_dollar_interpolation_identifier: (?:{{unicode_letter}}|[a-zA-Z_])(?:{{unicode_letter}}|[a-zA-Z0-9_])*
scope: source.nextflow
contexts:
  # else-pop and immediately-pop from https://forum.sublimetext.com/t/syntax-definitions-how-to-force-pop-out-of-the-stack/36376/4
  # convenience contexts for popping context off stack
  else-pop:
    - match: (?=\S)
      pop: true
  immediately-pop:
    - match: ''
      pop: true
  main:
    - match: ^(#!).+$\n
      scope: comment.line.hashbang.nextflow
      captures:
        1: punctuation.definition.comment.nextflow
    - match: '^\s*(package)\s+([^ ;]+)'
      scope: meta.package.nextflow
      captures:
        1: keyword.other.package.nextflow
        2: storage.type.package.nextflow
    - include: nextflow
  import-modules:
    - match: \b(include)\b
      scope: keyword.control.include-module.nextflow
      push:
        - meta_scope: meta.import-module.nextflow
        - include: import-modules-include-body
        - include: import-modules-from
        - include: import-modules-addparams
        - match: $
          pop: true
  import-modules-addparams:
    - match: \b(addParams)\b
      scope: keyword.other.addparams.nextflow
    - match: \(
      push:
        - meta_scope: meta.import-module.addparams-call.nextflow
        - match: \)
          pop: true
        - match: '\b(\w+)(:)'
          captures:
            1: variable.other.addparams-key.nextflow
            2: punctuation.separator.annotation.parameter.nextflow
        - include: nextflow-code-minus-map-keys
  import-modules-from:
    - match: \b(from)\b
      scope: keyword.control.include-module.from.nextflow
    - include: import-from-path
  import-from-path:
    - match: "'"
      scope: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.single.relative-import-path.nextflow
        - match: (?<=')(\.)
          scope: punctuation.definition.relative-import-path.nextflow
        - match: (?<=')([^\.])
          scope: invalid.illegal.relative-import-path.nextflow
        - match: "'"
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - match: '\n'
          scope: invalid.illegal.unclosed-string.nextflow
          pop: true
        - include: string-escape-sequences
  import-modules-include-body:
    - meta_scope: meta.statement.include-module.nextflow
    - match: \{
      scope: punctuation.section.module-include-block.begin.nextflow
      push:
        - meta_scope: meta.module-include-block.nextflow
        - match: \}
          scope: punctuation.section.module-include-block.end.nextflow
          pop: true
        - match: \b(as)\b
          scope: keyword.operator.as.nextflow
        - match: ';'
          scope: punctuation.separator.include-module-list.nextflow
        - match: \b(\w+)\b
          scope: entity.name.class.module-import.nextflow
        - match: \s*$
          scope: invalid.illegal.unclosed-include-body.nextflow
          pop: true
  import-modules-from-body:
    - meta_scope: meta.statement.include-module.nextflow
    - meta_content_scope: meta.include-source.nextflow
  class-object:
    - match: |-
        (?x)
            \b(
              (?:[a-z]\w*\.)* # Optional package specification
              [A-Z]\w+\b # Class name
              (?:<(?:[\w, ]*)>)? # Optional Generics
              (?:\[\s*\])* # Optional brackets (array)
            )\b
      scope: storage.type.class.nextflow
  classes:
    - match: |-
        (?x)^\s*
        (?:(?:\b(?:(public|private|protected)|(static)|(final)|(native|synchronized|abstract|threadsafe|transient))\b\s*)*) # modifier
        (class)\s+
        (\w+)\s* # identifier
      captures:
        1: storage.modifier.access-control.nextflow
        2: storage.modifier.static.nextflow
        3: storage.modifier.final.nextflow
        4: storage.modifier.other.nextflow
        5: storage.type.class.nextflow
        6: entity.name.type.class.nextflow
      push:
        - meta_scope: meta.definition.class.nextflow
        - match: $
          captures:
            1: storage.modifier.access-control.nextflow
            2: storage.modifier.static.nextflow
            3: storage.modifier.final.nextflow
            4: storage.modifier.other.nextflow
            5: storage.type.class.nextflow
            6: entity.name.type.class.nextflow
          pop: true
        - match: '(extends)\s+([a-zA-Z0-9_\.]+(?:<(?:[a-zA-Z0-9_, ])+>)?)\s*'
          scope: meta.definition.class.inherited.classes.nextflow
          captures:
            1: storage.modifier.extends.nextflow
            2: entity.other.inherited-class.nextflow
        - match: (implements)\s
          captures:
            1: storage.modifier.implements.nextflow
          push:
            - meta_scope: meta.definition.class.implemented.interfaces.nextflow
            - match: '(?=\s*extends|$|\{)'
              pop: true
            - match: '((?:[a-z]\w*.)*[A-Z]\w*)\s*(?:(,)|$|\{)'
              captures:
                1: entity.other.inherited-class.interface.nextflow
                2: punctuation.definition.implemented.interfaces.separator.nextflow
  comment-block:
    - match: /\*
      scope: punctuation.definition.comment.nextflow
      push:
        - meta_scope: comment.block.nextflow
        - match: \*/
          scope: punctuation.definition.comment.nextflow
          pop: true
  comments:
    - match: /\*\*/
      scope: comment.block.empty.nextflow punctuation.definition.comment.nextflow
    - include: scope:text.html.javadoc
    - include: comment-block
    - match: (//).*$\n?
      scope: comment.line.double-slash.nextflow
      captures:
        1: punctuation.definition.comment.nextflow
  constants:
    - match: '\b([A-Z][A-Z0-9_]+)\b'
      scope: constant.other.nextflow
    - match: \b(true|false|null)\b
      scope: constant.language.nextflow
  nextflow:
    - include: classes
    - include: methods
    - include: nextflow-code
  nextflow-code:
    - include: nextflow-code-minus-map-keys
    - include: map-keys
    - include: block
  nextflow-code-minus-map-keys:
    - include: import-modules
    - include: comments
    - include: support-functions
    - include: keyword-language
    - include: values
    - include: keyword-operator
    - include: storage-types
    - include: storage-modifiers
  keyword:
    - include: keyword-operator
    - include: keyword-language
  keyword-language:
    - match: \b(try|catch|finally|throw)\b
      scope: keyword.control.exception.nextflow
    - match: \b(return|break|continue|default|do|while|for|switch|if|else)\b
      scope: keyword.control.nextflow
    - match: \bcase\b
      scope: keyword.control.nextflow
      push:
        - meta_scope: meta.case.nextflow
        - match: ":"
          scope: punctuation.definition.case-terminator.nextflow
          pop: true
        - include: nextflow-code-minus-map-keys
    - match: \b(new)\b
      scope: keyword.other.new.nextflow
    - match: \b(assert)\s
      captures:
        1: keyword.control.assert.nextflow
      push:
        - meta_scope: meta.declaration.assertion.nextflow
        - match: $
          pop: true
        - match: ":"
          scope: keyword.operator.assert.expression-separator.nextflow
        - include: nextflow-code-minus-map-keys
    - match: \b(throws)\b
      scope: keyword.other.throws.nextflow
  keyword-operator:
    - match: \b(as)\b
      scope: keyword.operator.as.nextflow
    - match: \b(is)\b
      scope: keyword.operator.is.nextflow
    - match: '\?\:'
      scope: keyword.operator.elvis.nextflow
    - match: \.\.
      scope: keyword.operator.range.nextflow
    - match: \->
      scope: keyword.operator.arrow.nextflow
    - match: "<<"
      scope: keyword.operator.leftshift.nextflow
    - match: (?<=\S)\.(?=\S)
      scope: punctuation.accessor.dot.nextflow
    - match: (?<=\S)\?\.(?=\S)
      scope: punctuation.accessor.nextflow
    - match: \?
      scope: keyword.operator.ternary.nextflow
      push:
        - meta_scope: meta.evaluation.ternary.nextflow
        - match: ":"
          scope: keyword.operator.ternary.expression-separator.nextflow
        - match: \}
          pop: true
        - match: $
          pop: true
        - include: nextflow-code
        - include: else-pop
    - match: "==~"
      scope: keyword.operator.match.nextflow
    - match: "=~"
      scope: keyword.operator.find.nextflow
    - match: \b(instanceof)\b
      scope: keyword.operator.instanceof.nextflow
    - match: (===|==|!=|<=|>=|<=>|<>|<|>|<<)
      scope: keyword.operator.comparison.nextflow
    - match: "="
      scope: keyword.operator.assignment.nextflow
    - match: (\-\-|\+\+)
      scope: keyword.operator.increment-decrement.nextflow
    - match: (\-|\+|\*|\/|%)
      scope: keyword.operator.arithmetic.nextflow
    - match: (!|&&|\|\|)
      scope: keyword.operator.logical.nextflow
  map-keys:
    - match: (\w+)\s*(:)
      captures:
        1: constant.other.key.nextflow
        2: punctuation.definition.separator.key-value.nextflow
  method-call:
    - match: (\w+)(\()
      captures:
        1: meta.method.nextflow
        2: punctuation.definition.method-parameters.begin.nextflow
      push:
        - meta_scope: meta.method-call.nextflow
        - match: \)
          scope: punctuation.definition.method-parameters.end.nextflow
          pop: true
        - match: ","
          scope: punctuation.definition.separator.parameter.nextflow
        - include: nextflow-code
  process-def:
    - match: ^\s*(process)\s+(\w+|"[^"]+"|'[^']+')\s*(\{)
      captures:
        1: storage.type.return-type.def.nextflow
        2: entity.name.class.process.nextflow
        3: punctuation.definition.process.begin.nextflow
      push:
        - meta_scope: meta.definition.process.nextflow
        - match: \}
          captures:
            1: punctuation.definition.process.end.nextflow
          pop: true
        - include: process-script-def
        - include: process-script-single-quote
        - include: process-script-double-quote
        - include: process-output
        - include: process-input
        - include: directives
        - include: nextflow-code
  directives: 
    - match: '^\s+(afterScript|beforeScript|cache|cpus|container|containerOptions|clusterOptions|disk|echo|errorStrategy|executor|ext|label|maxErrors|maxForks|maxRetries|memory|module|penv|pod|publishDir|queue|scratch|stageInMode|stageOutMode|storeDir|tag|time|validExitStatus):'
      scope: invalid.illegal.directive-with.nextflow
    - match: ^\s+(afterScript|beforeScript|cache|cpus|container|containerOptions|clusterOptions|disk|echo|errorStrategy|executor|ext|label|maxErrors|maxForks|maxRetries|memory|module|penv|pod|publishDir|queue|scratch|stageInMode|stageOutMode|storeDir|tag|time|validExitStatus)\b
      captures: 
        1: support.type.nextflow
    - match: '^\s*(conda)\s+'
      captures:
        1: support.type.conda.nextflow
      push:
        - meta_scope: meta.definition.conda-directive.nextflow
        - include: nextflow-code
        - match: '$'
          pop: true
  process-script-def:
    - match: '^\s*(script|shell|exec):'
      captures:
        1: keyword.other.process-script-def.nextflow
  process-input:
    - match: '^\s*(input)\:'
      captures:
        1: keyword.other.process-input.nextflow
      push:
        - meta_scope: meta.definition.process-input.nextflow
        - include: process-input-channel
        - include: nextflow-code
        - match: '(?=^\s*output\:)'
          pop: true
        - include: popping-process-input-or-output
  process-output:
    - match: '^\s*(output)\:'
      captures: 
        1: keyword.other.process-output.nextflow
      push:
        - meta_scope: meta.definition.process-output.nextflow
        - include: process-output-channel
        - include: nextflow-code
        - include: popping-process-input-or-output
  popping-process-input-or-output:
    - match: (?=^\s*''')
      pop: true
    - match: (?=^\s*""")
      pop: true
    - match: (?=^\s*when\:)
      pop: true
    - match: (?=^\s*(script|shell|exec)\:)
      pop: true
  process-input-channel:
    - match: '^\s*(?=tuple|set|file|path|val)'
      push:
        - meta_scope: meta.definition.process-input-channel.nextflow
        - include: process-tuple-operator
        - include: process-set-operator
        - include: process-val
        - include: process-path
        - include: process-file
        - match: \b(from)\b
          scope: keyword.operator.from.nextflow
        - match: \b(into)\b
          scope: invalid.illegal.into.nextflow
        - match: '\b[^a-zA-Z0-9_]\s$'
          scope: invalid.illegal.process-input-channel.nextflow
          pop: true
        - match: $
          pop: true
  process-output-channel:
    - match: '^\s*(?=tuple|set|file|path|val)'
      push:
        - meta_scope: meta.definition.process-output-channel.nextflow
        - include: process-tuple-operator
        - include: process-set-operator
        - include: process-val
        - include: process-path
        - include: process-file
        - include: process-output-emit
        - match: \b(into)\b
          scope: keyword.operator.into.nextflow
        - match: \b(from)\b
          scope: invalid.illegal.from.nextflow
        - match: '\b[^a-zA-Z0-9_]\s$'
          scope: invalid.illegal.process-output-channel.nextflow
          pop: true
        - match: $
          pop: true
  process-output-emit:
    - match: (,)\s*(emit)(:)\s*(\w+)
      captures:
        1: punctuation.separator.process-output-channel.nextflow
        2: keyword.other.process-output-emit.nextflow
        3: punctuation.separator.process-output-emit.nextflow
        4: variable.other.process-output-emit.nextflow
      pop: true
  process-set-operator:
    - match: \b(set)\b
      captures: 
        1: keyword.other.channel.set.nextflow
  process-tuple-operator:
    - match: \b(tuple)\b
      captures:
        1: keyword.other.channel.tuple.nextflow
  process-val:
    - match: \b(val)\b
      scope: support.function.val.nextflow
      push:
        - meta_scope: meta.function-call.process-val.nextflow
        - include: popping-process-channel-func
  process-path:
    - match: \b(path)\b
      scope: support.function.path.nextflow
      push:
        - meta_scope: meta.function-call.process-path.nextflow
        - include: popping-process-channel-func
  process-file:
    - match: \b(file)\b
      scope: support.function.file.nextflow
      push:
        - meta_scope: meta.function-call.process-file.nextflow
        - include: popping-process-channel-func
  popping-process-channel-func:
    - match: \)
      pop: true
    - match: \b(?=from|into)\b
      pop: true
    - match: (?=,)
      pop: true
    - include: string-quoted-double
    - include: string-quoted-single
    - match: '\b(\w+)\b'
      scope: variable.other.process.nextflow
    - match: $
      pop: true
  process-script-double-quote:
    - match: ^\s*(""")
      captures:
        1: punctuation.definition.string.begin.nextflow
      push:
          - meta_scope: string.quoted.double.block.nextflow
          - match: '""""'
            scope: invalid.illegal
            pop: true
          - match: '"""'
            scope: punctuation.definition.string.end.nextflow
            pop: true
          - match: '(?=#!/usr/bin/env python)'
            push: Packages/Python/Python.sublime-syntax
            with_prototype:
              - match: (?=""")
                pop: true
          - include: string-escape-sequences
          - include: single-dollar-string-interpolation
          - match: '\$\{'
            scope: punctuation.section.embedded.nextflow
            push:
              - meta_scope: source.nextflow.embedded.source
              - match: '\}'
                scope: punctuation.section.embedded.nextflow
                pop: true
              - include: escaped-end-of-line
              - include: nextflow-code
              - match: (task)\.(\w+)
                captures: 
                  1: support.variable.task.nextflow
                  2: entity.name.task-param.nextflow
          # anything else following a dollar sign is not a valid interpolation
          - match: \$(?=")
            scope: invalid.illegal.nextflow
          - match: \$[^"]+
            scope: invalid.illegal.nextflow
  process-script-single-quote:
    - match: ^\s*(''')
      captures:
        1: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.single.block.nextflow
        - match: "'''"
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - include: string-escape-sequences
  conditional-block:
    - match: \(
      push:
      - meta_scope: meta.statement.conditional.nextflow
      - match: \)
        pop: true
      - include: nextflow-code-minus-map-keys

  workflow-conditionals:
    - match: \b(if)\b
      scope: keyword.control.conditional.if.nextflow
    - include: conditional-block
    - match: \{
      push:
        - meta_scope: meta.conditional-block.nextflow
        - match: \}
          pop: true
        - include: workflow-stuff
  workflow-process:
    - match: \b([A-Z][A-Z0-9\_]+)
      scope: entity.name.class.process.nextflow
    - match: \(
      scope: punctuation.section.process-call.begin.nextflow
      push:
        - meta_scope: meta.process-call.nextflow
        - match: \)
          scope: punctuation.section.arguments.end.nextflow
          pop: true
        - include: workflow-process
        - include: nextflow-code
    - match: \.(out)
      scope: keyword.process.out.nextflow
      push:
        - match: \s*
        - match: (\.)?(\w+)?
          captures:
            1: punctuation.accessor.dot.process-out.nextflow
            2: variable.channel.process-output-emit.nextflow
          pop: true
  workflow-def:
    - match: ^\s*(workflow)\s*(\w+)?.*(\{)
      captures:
        1: keyword.declaration.workflow.nextflow
        2: entity.name.workflow.nextflow
        3: punctuation.definition.workflow.begin.nextflow
      push:
        - meta_scope: meta.definition.workflow.nextflow
        - include: workflow-stuff
  workflow-stuff:
    - match: \}
      captures:
        1: punctuation.definition.workflow.end.nextflow
      pop: true
    - include: workflow-process
    - include: workflow-process-call
    - include: workflow-conditionals
    - include: nextflow-code

  method-declaration-remainder:
    - match: \(
      scope: punctuation.definition.parameters.begin.nextflow
      push:
        - meta_content_scope: meta.definition.method.parameters.nextflow
        - match: \)
          scope: punctuation.definition.parameters.end.nextflow
          pop: true
        - match: |-
            (?x)\s*
              (
                (?:boolean|byte|char|short|int|float|long|double|(?:\w+\.)*[A-Z]\w*\b(?:<(?:[\w, ]*)>)?(?:\[\s*\])*)
              )?
              \s*
              ([a-z_][A-Za-z0-9_]*) # variable
          scope: meta.definition.method.parameter.nextflow
          captures:
            1: storage.type.parameter.nextflow
            2: variable.parameter.nextflow
        - match: '(boolean|byte|char|short|int|float|long|double|(?:\w+\.)*[A-Z]\w*\b(?:<(?:[\w, ]*)>)?(?:\[\s*\])*)'
          scope: meta.definition.method.parameter.nextflow
          captures:
            1: storage.type.parameter.nextflow
        - match: ","
          scope: punctuation.definition.parameters.separator.nextflow
        - include: comment-block
    - match: (?<=\))\s*(throws)\s
      captures:
        1: storage.modifier.throws.nextflow
      push:
        - meta_scope: meta.definition.method.throwables.nextflow
        - match: '(?=$|\{)'
          captures:
            1: storage.modifier.throws.nextflow
          pop: true
        - match: '((?:[a-z]\w*.)*[A-Z]\w*)\s*(?:(,)|$|\{)'
          captures:
            1: storage.type.throwable.nextflow
            2: punctuation.definition.throwables.separator.nextflow
  methods:
    - match: |-
        (?x)^\s*
          (?: # zero or more modifiers
            (?:
              (public|private|protected)|(final)|(native|synchronized|abstract|threadsafe|transient)
            )
            \s+
          )?
          \s*
          ([A-Z](?:[a-zA-Z0-9_])+) # constructor/class name
          \s*
          (?=\()
      captures:
        1: storage.modifier.access-control.nextflow
        2: storage.modifier.final.nextflow
        3: storage.modifier.other.nextflow
        4: entity.name.function.constructor.nextflow
        5: punctuation.definition.parameters.begin.nextflow
      push:
        - meta_scope: meta.definition.constructor.nextflow
        - match: '{|$\n?'
          pop: true
        - include: method-declaration-remainder
    - match: |-
        (?x)^\s*
          (?:
            (?: # or modifier and optional type
              (?:(?:\b(public|private|protected)|(static)|(final)|(native|synchronized|abstract|threadsafe|transient))\b\s+)+\s* # modifier
              (?:\b
                (void\b)
                |
                ((?:boolean|byte|char|short|int|float|long|double)\b) # primitive
                |
                ( # or class type
                  (?:\w+\.)*[A-Z]\w+\b # Class name
                  (?:<(?:[\w, ]*)>)? # optional Generic type
                  (?:\[\s*\])* # zero or more square brackets (array)
                )
              )?
            )
            |
            (?:\b # or type by itself
              (def\b)
              |
              (void\b)
              |
              ((?:boolean|byte|char|short|int|float|long|double)\b) # primitive
              |
              ( # or class type
                (?:\w+\.)*[A-Z]\w+\b # Class name
                (?:<(?:[\w, ]*)>)? # optional generics info
                (?:\[\s*\])* # zero or more square brackets (array)
              )
            )
          )
          \s*
          (\w+) # method name
          \s*
          (?=\() # opening parens
      captures:
        1: storage.modifier.access-control.nextflow
        2: storage.modifier.static.nextflow
        3: storage.modifier.final.nextflow
        4: storage.modifier.other.nextflow
        5: storage.type.return-type.void.nextflow
        6: storage.type.return-type.primitive.nextflow
        7: storage.type.return-type.class.nextflow
        8: storage.type.return-type.def.nextflow
        9: storage.type.return-type.void.nextflow
        10: storage.type.return-type.primitive.nextflow
        11: storage.type.return-type.class.nextflow
        12: entity.name.function.nextflow
      push:
        - meta_scope: meta.definition.method.nextflow
        - match: '{|$\n?'
          pop: true
        - include: method-declaration-remainder
  block:
    - match: '\{'
      scope: punctuation.section.block.begin.nextflow
      push:
        - meta_scope: meta.block.nextflow
        - match: '\}'
          scope: punctuation.section.block.end.nextflow
          pop: true
        - include: nextflow-code
  numbers:
    - match: '((0(x|X)[0-9a-fA-F]*)|(\+|-)?\b(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)([LlFfUuDd]|UL|ul)?\b'
      scope: constant.numeric.nextflow
  regexp:
    - match: "/(?=[^/]+/)"
      scope: punctuation.definition.string.regexp.begin.nextflow
      push:
        - meta_scope: string.regexp.nextflow
        - match: /
          scope: punctuation.definition.string.regexp.end.nextflow
          pop: true
        # backslashes only escape forward slashes and newlines (and unicode)
        - match: \\/
          scope: constant.character.escape.nextflow
        - include: escaped-end-of-line
        - include: unicode-escape-sequence
        - include: single-dollar-string-interpolation
        - match: '\$\{'
          scope: punctuation.section.embedded.nextflow
          push:
            - meta_scope: source.nextflow.embedded.source
            - match: '\}'
              scope: punctuation.section.embedded.nextflow
              pop: true
            - include: escaped-end-of-line
            # newlines are invalid inside the interpolation
            # but outside of a nested multiline string
            - match: '\n'
              scope: invalid.illegal.newline.nextflow
              pop: true
            - include: nextflow-code
  storage-modifiers:
    - match: \b(private|protected|public)\b
      scope: storage.modifier.access-control.nextflow
    - match: \b(static)\b
      scope: storage.modifier.static.nextflow
    - match: \b(final)\b
      scope: storage.modifier.final.nextflow
    - match: \b(native|synchronized|abstract|threadsafe|transient)\b
      scope: storage.modifier.other.nextflow
  storage-types:
    - match: '(@[^ (]+)(\()'
      captures:
        1: storage.type.annotation.nextflow
        2: punctuation.definition.annotation-arguments.begin.nextflow
      push:
        - meta_scope: meta.declaration.annotation.nextflow
        - match: (\))
          captures:
            1: punctuation.definition.annotation-arguments.end.nextflow
          pop: true
        - match: (\w*)\s*(=)
          captures:
            1: constant.other.key.nextflow
            2: keyword.operator.assignment.nextflow
        - include: values
        - match: ","
          scope: punctuation.definition.separator.nextflow
    - match: '@\S+'
      scope: storage.type.annotation.nextflow
    - match: \b(def)\b
      scope: storage.type.def.nextflow
    - match: '\b(boolean|byte|char|short|int|float|long|double)(?:\[\s*\])*\b'
      scope: storage.type.primitive.nextflow
  single-dollar-string-interpolation:
    - match: \${{single_dollar_interpolation_identifier}}
      scope: variable.other.interpolated.nextflow
      push:
        - match: \.(?={{single_dollar_interpolation_identifier}})
          scope: punctuation.accessor.dot.nextflow
        - match: '{{single_dollar_interpolation_identifier}}'
          scope: variable.other.interpolated.nextflow
        - match: \b
          pop: true
  unicode-escape-sequence:
    - match: \\u\h{4}
      scope: constant.character.escape.nextflow
    - match: \\u(?!\h{4}).{4}
      scope: invalid.illegal.escape.nextflow
  escaped-end-of-line:
    - match: \\\n
      scope: constant.character.escape.nextflow
  string-escape-sequences:
    - include: unicode-escape-sequence
    - include: escaped-end-of-line
    - match: |-
        \\[nrtbf\$\\'"]
      scope: constant.character.escape.nextflow
    - match: \\.
      scope: invalid.illegal.escape.nextflow
  string-quoted-double:
    - match: '"'
      scope: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.double.nextflow
        - match: '"'
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - match: '\n'
          scope: invalid.illegal.unclosed-string.nextflow
          pop: true
        - include: string-escape-sequences
        - include: single-dollar-string-interpolation
        - match: '\$\{'
          scope: punctuation.section.embedded.nextflow
          push:
            - meta_scope: source.nextflow.embedded.source
            - match: '\}'
              scope: punctuation.section.embedded.nextflow
              pop: true
            - include: escaped-end-of-line
            # we don't consume the newline here, so that
            # the outer scope handles it and pops correctly
            - match: '(?=\n)'
              pop: true
            - include: nextflow-code
        # anything else following a dollar sign is not a valid interpolation
        - match: \$(?=")
          scope: invalid.illegal.identifier.nextflow
        - match: \$[^"]+
          scope: invalid.illegal.identifier.nextflow
  string-quoted-single:
    - match: "'"
      scope: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.single.nextflow
        - match: "'"
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - match: '\n'
          scope: invalid.illegal.unclosed-string.nextflow
          pop: true
        - include: string-escape-sequences
  string-quoted-triple-single:
    - match: "'''"
      scope: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.single.block.nextflow
        - match: "'''"
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - include: string-escape-sequences
  string-quoted-triple-double:
    - match: '"""'
      scope: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.double.block.nextflow
        - match: '""""'
          scope: invalid.illegal
          pop: true
        - match: '"""'
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - include: string-escape-sequences
        - include: single-dollar-string-interpolation
        - match: '\$\{'
          scope: punctuation.section.embedded.nextflow
          push:
            - meta_scope: source.nextflow.embedded.source
            - match: '\}'
              scope: punctuation.section.embedded.nextflow
              pop: true
            - include: escaped-end-of-line
            - include: nextflow-code
        # anything else following a dollar sign is not a valid interpolation
        - match: \$(?=")
          scope: invalid.illegal.nextflow
        - match: \$[^"]+
          scope: invalid.illegal.nextflow
  string-dollar-slashy:
    - clear_scopes: 1
    - match: '\$/'
      scope: punctuation.definition.string.begin.nextflow
      push:
        - meta_scope: string.quoted.other.dollar-slashy.nextflow
        - match: '/\$'
          scope: punctuation.definition.string.end.nextflow
          pop: true
        - match: '\$/|\$\$'
          scope: constant.character.escape.nextflow
        # backslashes only escape newlines (and unicode)
        - include: escaped-end-of-line
        - include: unicode-escape-sequence
        - include: single-dollar-string-interpolation
        - match: '\$\{'
          scope: punctuation.section.embedded.nextflow
          push:
            - meta_scope: source.nextflow.embedded.source
            - match: '\}'
              scope: punctuation.section.embedded.nextflow
              pop: true
            - include: escaped-end-of-line
            - include: nextflow-code
  strings:
    - include: string-quoted-triple-double
    - include: string-quoted-triple-single
    - include: string-quoted-double
    - include: string-quoted-single
    - include: regexp
    - include: string-dollar-slashy
  structures:
    - match: '\['
      scope: punctuation.definition.structure.begin.nextflow
      push:
        - meta_scope: meta.structure.nextflow
        - match: '\]'
          scope: punctuation.definition.structure.end.nextflow
          pop: true
        - include: nextflow-code
        - match: ","
          scope: punctuation.definition.separator.nextflow
  support-functions:
    - match: (?x)\b(?:sprintf|print(?:f|ln)?)\b
      scope: support.function.print.nextflow
    - match: |-
        (?x)\b(?:shouldFail|fail(?:NotEquals)?|ass(?:ume|ert(?:S(?:cript|ame)|N(?:ot(?:Same|
        Null)|ull)|Contains|T(?:hat|oString|rue)|Inspect|Equals|False|Length|
        ArrayEquals)))\b
      scope: support.function.testing.nextflow
    - match: (?x)\b(?:sleep|inspect|dump|use|with)\b
      scope: support.function.other.nextflow
  values:
    - include: variables
    - include: built-ins
    - include: strings
    - include: numbers
    - include: constants
    - include: class-object
    - include: structures
    - include: method-call
    - include: process-def
    - include: workflow-def
    - include: channel-operators
    - include: channels
  channel-combining-operators:
    - match: \s*(\.)(cross|collectFile|combine|concat|into|join|merge|mix|phase|spread|tap)\s*\(
      captures: 
        1: punctuation.accessor.channel.nextflow
        2: keyword.operator.channel-combining-operator.nextflow
        3: punctuation.section.channel-operator-call.begin.nextflow
      push:
        - meta_scope: meta.channel-operator-call
        - match: \)
          scope: punctuation.section.channel-operator-call.end.nextflow
          pop: true
        - include: workflow-process
        - include: nextflow

  channel-operators:
    - match: \.(create|empty|fromFilePairs|fromPath|from|value|watchPath)
      captures:
        1: support.function.channel-factory.nextflow
    - match: \s+\.(distinct|filter|first|last|randomSample|take|unique|until)
      captures:
        1: keyword.operator.channel-filtering-operator.nextflow
    - match: \s*\.(buffer|collate|collect|flatten|flatMap|groupBy|groupTuple|map|reduce|toList|toSortedList|transpose)
      captures: 
        1: keyword.operator.channel-transforming-operator.nextflow
    - match: \s*\.(splitCsv|splitFasta|splitFastq|splitText)
      captures: 
        1: keyword.operator.channel-splitting-operator.nextflow
    - include: channel-combining-operators
    - match: \s*\.(choice|separate|route)
      captures:
        1: keyword.operator.channel-forking-operator.nextflow
    - match: \s*\.(toInteger|countBy|count|min|max|sum)
      captures:
        1: keyword.operator.channel-maths-operator.nextflow
    - match: \s*\.(close|dump|ifEmpty|println|print|set|view)\b
      captures: 
        1: keyword.operator.channel-other-operator.nextflow
  built-ins:
    - match: \b(file)\b
      scope: support.function.file.nextflow
    - match: \b(log)\.\b
      captures:
        1: support.variable.log.nextflow
    - match: \b(workflow)\.\b
      captures:
        1: support.variable.workflow.nextflow
    - match: \b(params)(\.)(\w+)\b
      captures:
        1: support.variable.params.nextflow
        2: punctuation.params.dot
        3: entity.name.parameter.nextflow
    - match: \b(params)(\.)
      captures:
        1: support.variable.params.nextflow
        2: punctuation.params.dot
    - match: ^\s*(exit)\s+(\d+)\b
      captures:
        1: support.function.exit.nextflow
        2: constant.numeric.nextflow
  variables:
    - match: \b(this|super|it)\b
      scope: variable.language.nextflow
  channels:
    - match: \b(ch_\w+)\b
      scope: variable.parameter.channel.nextflow