utils/pygments/swift.py

#!/usr/bin/env python

import re

from pygments.lexer import (
    RegexLexer,
    bygroups,
    default,
    include,
)
from pygments.token import (
    Comment,
    Generic,
    Keyword,
    Name,
    Number,
    Operator,
    Punctuation,
    String,
    Text,
    Whitespace,
)

__all__ = ['SwiftLexer', 'SILLexer', 'SwiftConsoleLexer']


class SwiftLexer(RegexLexer):
    name = 'Swift'
    aliases = ['swift']
    filenames = ['*.swift']

    flags = re.MULTILINE | re.DOTALL

    _isa = r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(:)(\s*)([A-Z0-9_][a-zA-Z0-9_]*)'
    _isa_comma = r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(:)(\s*)' + \
                 r'([A-Z0-9_][a-zA-Z0-9_]*)(,\s?)'
    _name = u'([@a-zA-Z_\U00000100-\U00100000]' + \
            u'[a-zA-Z0-9_\U00000100-\U00100000]*)'

    tokens = {

        'root': [
            (r'^', Punctuation, 'root2'),
        ],

        'root2': [
            (r'\n', Text, '#pop'),
            include('func-class-list'),
            (r'\bimport\s+', Keyword.Namespace, 'import'),
            (r'\b(class|struct|protocol|extension)\s',
             Keyword.Declaration, 'class-decl'),
            include('body'),
        ],

        'func-class-list': [
            (r'\b(func|init|deinit|class func|public func)\s',
             Keyword.Declaration, 'func-decl'),
        ],

        'comment': [
            (r'//.*?\n', Comment.Single, '#pop'),
            (r'/\*', Comment.Multiline, 'comment-multiline'),
        ],

        'token-list': [
            (r'\$([0-9]+)', Name.Variable),   # Tokens
        ],

        'body': [
            include('comment'),
            include('name'),
            (r'\.{3}', Generic.Emph),  # emphasize ellipses
            (r'[\~\^\*!%&<>+=/?-]|\.{2}', Operator),
            include('token-list'),
            (r'[\[\]\(\)\{\}\|:;,.#]', Punctuation),
            (r'[0-9]+\.[0-9]+', Number.Float),
            (r'0x[0-9a-fA-F]+', Number.Hex),
            (r'[0-9]+', Number.Integer),
            (r'\s', Whitespace),
            (r'\(', Punctuation, 'tuple'),
            (r'(\b[A-Z][a-zA-Z0-9_]*\s?)(\()',
             bygroups(Name.Constant, Punctuation), 'type-cast'),
            (r'(\b[A-Z][a-zA-Z0-9_]*)(\.)([a-z][a-zA-Z0-9_]*)',
             bygroups(Name.Constant, Punctuation, Name), 'arg-list'),
            (r'"', String, 'string'),
            (r'\'', String.Char, 'string'),
            (r'(\bnew\b\s?)', Keyword.Reserved, 'class-name'),
            (r'\b(true|false)\b', Keyword.Reserved),
            (r'\b(if|else)\s', Keyword.Reserved),
            (r'\b(return|break)\b', Keyword.Reserved),
            (r'(\bset\b)(\s?)(\()', bygroups(
                Keyword.Declaration, Whitespace, Punctuation), 'arg-list'),
            (r'(set|get)(:)', bygroups(Keyword.Reserved, Punctuation)),
            (r'\b(self|Self)\b', Name.Builtin.Pseudo),
            (r'\bid\b', Name.Builtin),
            (r'\b(var|let)\s', Keyword.Declaration, 'var-decl'),
            (r'\bfor\s', Keyword.Reserved, 'for-loop'),
        ],

        'body2': [
            (r'}', Punctuation, '#pop'),
            include('body'),
        ],

        'isa': [
            (_isa, bygroups(
                Name,
                Whitespace,
                Punctuation,
                Whitespace,
                Name.Constant)),
        ],

        'class-isa': [
            (_isa, bygroups(Name.Class, Whitespace,
                            Punctuation, Whitespace, Name.Constant)),
        ],

        'var-isa': [
            (_isa, bygroups(Name.Variable, Whitespace,
                            Punctuation, Whitespace, Name.Constant)),
        ],

        'var-isa-pop': [
            (_isa, bygroups(Name.Variable, Whitespace,
                            Punctuation, Whitespace, Name.Constant), '#pop'),
        ],

        'var-isa-comma': [
            (_isa_comma, bygroups(Name.Variable, Whitespace,
                                  Punctuation, Whitespace,
                                  Name.Constant, Punctuation)),
        ],

        'var-name': [
            (r'[a-zA-Z_][a-zA-Z0-9_?]*', Name.Variable),
        ],

        'tuple': [
            (r'\(', Punctuation, 'in-tuple'),
        ],

        'in-tuple': [
            (r'\)', Punctuation, '#pop'),
            include('class-name'),
            include('name'),
            include('isa'),
            include('root2'),
        ],

        'name': [
            (_name, Name),
            (r'`[^\n`]*`', Name),
            (r'@_specialize', Name),
        ],

        'comment-multiline': [
            (r'[^*/]', Comment.Multiline),
            (r'/\*', Comment.Multiline, '#push'),
            (r'\*/', Comment.Multiline, '#pop'),
            (r'[*/]', Comment.Multiline),
        ],

        'import': [
            (_name, Name.Namespace),
            (r'(func|var|class)\s+', Keyword.Declaration),
            (r'\.', Punctuation),
            (r',\s*', Punctuation),
            (r'\(', Punctuation, 'import'),
            (r'\)', Punctuation, '#pop'),
            (r'=', Operator),
            (r' ', Text.Whitespace),
            default('#pop'),
            # ('\n', Punctuation, '#pop'),
        ],

        'generic-type': [
            (r'\s', Whitespace),
            (r'>', Punctuation, '#pop'),
            include('class-name'),
            include('isa'),
            include('root2'),
        ],

        'class-name': [
            (r'[_A-Z][a-zA-Z0-9_?]*', Name.Constant),
            (r'(\[)([0-9]+)(\])',
             bygroups(Operator, Number.Integer, Operator)),
            (r'<', Punctuation, 'generic-type'),
            (r'\.\(', Punctuation, 'arg-list'),
            (r'\(', Punctuation, 'type-cast'),
            (r'\)', Punctuation, '#pop'),
        ],

        'label': [
            (r'[a-zA-Z_][a-zA-Z0-9_]*:(?=\s*\n)', Name.Label),
        ],

        'ws-pop': [
            (r'\s?[\s\n]', Whitespace, '#pop'),
        ],

        'var-decl': [
            (r'(\[)([\w\s,]*)(\])(\s+)', bygroups(
                Punctuation,
                Name.Attribute,
                Punctuation,
                Whitespace)),
            (r':\s*', Punctuation),
            include('tuple'),
            include('var-isa-comma'),
            include('var-isa-pop'),
            include('var-name'),
            (r',\s+', Punctuation, 'var-decl'),
            include('ws-pop'),
        ],

        'for-loop': [
            (r'\sin\s', Keyword.Reserved),
            include('isa'),
            include('name'),
            include('ws-pop'),
            include('root2'),
        ],

        'func-decl': [
            (r'(\[)([\w\s,]*)(\])(\s+)', bygroups(
                Punctuation,
                Name.Attribute,
                Punctuation,
                Whitespace)),
            (r'\s?\bthrows\b', Keyword.Reserved),
            (r'\s?\brethrows\b', Keyword.Reserved),
            (r'\s?\breturn\b', Keyword.Reserved, 'root2'),
            (r'<', Punctuation, 'generic-type'),
            (r'\(\s?', Punctuation, 'arg-list'),
            (r'\s?->\s?', Operator, 'return-type'),
            (r'\s?(\w+|[\*\+\-\=]{1,2})(\s*)', bygroups(
                Name.Function, Punctuation)),
            (r'\s?' + _name + r'(\s*)', bygroups(
                Name.Function, Punctuation)),
            (r'\s?\{', Punctuation, '#pop'),
            default('#pop'),
        ],

        'return-type': [
            include('tuple'),
            include('class-name'),
            (r'\bid\b', Name.Builtin),
            (r'\s?\)', Punctuation, '#pop'),
            (r'\s?\[', Punctuation),
            (r'\s?\]\s*', Punctuation, '#pop'),
            default('#pop'),
        ],

        'name-list': [
            (_name, Name.Namespace),
            (r',\s*', Punctuation),
            (r' ', Text.Whitespace),
            (r'(\()(\d+\.\d+)(\))', bygroups(
             Punctuation, Number.Float, Punctuation)),
            default('#pop'),
        ],

        'class-decl': [
            (r'\{', Punctuation, '#pop'),
            (r'(\[)([\w\s,]*)(\])(\s+)', bygroups(
                Punctuation,
                Name.Attribute,
                Punctuation,
                Whitespace)),
            include('class-isa'),
            (r'(\*?)([a-zA-Z_][a-zA-Z0-9_?]*)', bygroups(
             Punctuation, Name.Class)),
            (r'\.', Punctuation),
            (r'<', Punctuation, 'generic-type'),
            (r':', Punctuation, 'name-list'),
            (r'\s', Whitespace),
            (r'\s?(,)(\s*)([A-Z0-9_][a-zA-Z0-9_]*)', bygroups(
             Punctuation, Whitespace, Name.Constant)),
            (r'<', Punctuation, 'generic-type'),
            (r'where', Keyword.Reserved),
            default("#pop"),
        ],

        'arg-list': [
            (r',\s?', Punctuation),
            (r'\)', Punctuation, '#pop'),
            (r'\s?\bthrows\b', Keyword.Reserved),
            (r'\s?\brethrows\b', Keyword.Reserved),
            include('isa'),
            (r'\s?->\s?', Operator, 'return-type'),
            include('root2'),
        ],

        'type-cast': [
            (r'\)', Punctuation, '#pop'),
            include('root2'),
        ],

        'in-interpolated': [
            (r'\)', String.Interpol, '#pop'),
            include('root2'),
        ],

        'string': [
            (r'"', String, '#pop'),
            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})',
             String.Escape),
            (r'\\\(', String.Interpol, 'in-interpolated'),
            (r'[^\\"]+', String),
            (r'\\', String),
        ],
    }


class SILLexer(RegexLexer):
    name = 'SIL'
    aliases = ['sil']
    filenames = ['*.sil']

    flags = re.MULTILINE | re.DOTALL

    _isa = SwiftLexer._isa
    _isa_comma = SwiftLexer._isa_comma

    _name = SwiftLexer._name

    tokens = SwiftLexer.tokens.copy()
    tokens['token-list'] = [
        (r'[%]([a-zA-Z0-9]+)', Name.Variable),   # Tokens
        (r'\$[*]?([a-zA-Z0-9]+)', Name.Variable),   # Tokens
        (r'\$[*]?\(([a-zA-Z0-9, ]+\))', Name.Variable),   # Tokens
    ]


class SwiftConsoleLexer(RegexLexer):
    name = 'SwiftConsole'
    aliases = ['swift-console']
    filenames = ['*.swiftc']

    flags = re.MULTILINE | re.DOTALL

    _isa = SwiftLexer._isa
    _isa_comma = SwiftLexer._isa_comma

    _name = SwiftLexer._name

    tokens = SwiftLexer.tokens.copy()
    tokens['root'] = [
        (r'Welcome to swift.  Type \':help\' for assistance.', Generic.Prompt),
        (r'(\(swift\) |        )', Generic.Prompt, 'root2'),
        (r'\(swift\)', Generic.Prompt),
        (r'       ', Generic.Prompt),
        (r'//.*?\n', Generic.Output),
        (r'<REPL Buffer>:[0-9]*:[0-9]*:.*?\n', Generic.Heading),
        (r'~*?\^\s?~*?\n', Generic.Heading),
        (r'.*?\n', Generic.Output),
    ]