source.zig.js

// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/ziglang/sublime-zig-language>
// and licensed `mit`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
 * @import {Grammar} from '@wooorm/starry-night'
 */

/** @type {Grammar} */
const grammar = {
  extensions: ['.zig', '.zig.zon'],
  names: ['zig'],
  patterns: [{include: '#dummy_main'}],
  repository: {
    block: {
      begin: '([a-zA-Z_][\\w.]*|@\\".+\\")?\\s*(\\{)',
      beginCaptures: {
        1: {name: 'storage.type.zig'},
        2: {name: 'punctuation.section.braces.begin.zig'}
      },
      end: '(\\})',
      endCaptures: {1: {name: 'punctuation.section.braces.end.zig'}},
      patterns: [{include: '#dummy_main'}]
    },
    character_escapes: {
      patterns: [
        {match: '\\\\n', name: 'constant.character.escape.newline.zig'},
        {match: '\\\\r', name: 'constant.character.escape.carrigereturn.zig'},
        {match: '\\\\t', name: 'constant.character.escape.tabulator.zig'},
        {match: '\\\\\\\\', name: 'constant.character.escape.backslash.zig'},
        {match: "\\\\'", name: 'constant.character.escape.single-quote.zig'},
        {match: '\\\\\\"', name: 'constant.character.escape.double-quote.zig'},
        {
          match: '\\\\x[a-fA-F\\d]{2}',
          name: 'constant.character.escape.hexidecimal.zig'
        },
        {
          match: '\\\\u\\{[a-fA-F\\d]{1,6}\\}',
          name: 'constant.character.escape.hexidecimal.zig'
        }
      ]
    },
    comments: {
      patterns: [
        {begin: '///', end: '$\\n?', name: 'comment.line.documentation.zig'},
        {begin: '//[^/]\\s*TODO', end: '$\\n?', name: 'comment.line.todo.zig'},
        {begin: '//[^/]*', end: '$\\n?', name: 'comment.line.zig'}
      ]
    },
    constants: {
      patterns: [
        {
          match: '\\b(null|undefined|true|false)\\b',
          name: 'constant.language.zig'
        },
        {
          match: '\\b(?<!\\.)(-?[\\d_]+)(?!\\.)\\b',
          name: 'constant.numeric.integer.zig'
        },
        {
          match: '\\b(?<!\\.)(0x[a-fA-F\\d_]+)(?!\\.)\\b',
          name: 'constant.numeric.integer.hexadecimal.zig'
        },
        {
          match: '\\b(?<!\\.)(0o[0-7_]+)(?!\\.)\\b',
          name: 'constant.numeric.integer.octal.zig'
        },
        {
          match: '\\b(?<!\\.)(0b[01_]+)(?!\\.)\\b',
          name: 'constant.numeric.integer.binary.zig'
        },
        {
          match:
            '(?<!\\.)(-?\\b[\\d_]+(?:\\.[\\d_]+)?(?:[eE][+-]?[\\d_]+)?)(?!\\.)\\b',
          name: 'constant.numeric.float.zig'
        },
        {
          match:
            '(?<!\\.)(-?\\b0x[a-fA-F\\d_]+(?:\\.[a-fA-F\\d_]+)?[pP]?(?:[+-]?[\\d_]+)?)(?!\\.)\\b',
          name: 'constant.numeric.float.hexadecimal.zig'
        }
      ]
    },
    container_decl: {
      patterns: [
        {
          match:
            '\\b(?!\\d)([a-zA-Z_]\\w*|@\\".+\\")?(?=\\s*=\\s*(?:extern|packed)?\\b\\s*(?:union)\\s*[(\\{])',
          name: 'entity.name.union.zig'
        },
        {
          match:
            '\\b(?!\\d)([a-zA-Z_]\\w*|@\\".+\\")?(?=\\s*=\\s*(?:extern|packed)?\\b\\s*(?:struct)\\s*[(\\{])',
          name: 'entity.name.struct.zig'
        },
        {
          match:
            '\\b(?!\\d)([a-zA-Z_]\\w*|@\\".+\\")?(?=\\s*=\\s*(?:extern|packed)?\\b\\s*(?:enum)\\s*[(\\{])',
          name: 'entity.name.enum.zig'
        },
        {
          match:
            '\\b(?!\\d)([a-zA-Z_]\\w*|@\\".+\\")?(?=\\s*=\\s*(?:error)\\s*[(\\{])',
          name: 'entity.name.error.zig'
        },
        {
          captures: {
            1: {name: 'storage.type.error.zig'},
            2: {name: 'punctuation.accessor.zig'},
            3: {name: 'entity.name.error.zig'}
          },
          match: '\\b(error)(\\.)([a-zA-Z_]\\w*|@\\".+\\")'
        }
      ]
    },
    dummy_main: {
      patterns: [
        {include: '#label'},
        {include: '#function_type'},
        {include: '#punctuation'},
        {include: '#storage_modifier'},
        {include: '#container_decl'},
        {include: '#constants'},
        {include: '#comments'},
        {include: '#strings'},
        {include: '#storage'},
        {include: '#keywords'},
        {include: '#operators'},
        {include: '#support'},
        {include: '#field_decl'},
        {include: '#block'},
        {include: '#function_def'},
        {include: '#function_call'},
        {include: '#enum_literal'},
        {include: '#variables'}
      ]
    },
    enum_literal: {
      match:
        '(?<!\\w|\\)|\\?|\\}|\\]|\\*)(\\.(?:[a-zA-Z_]\\w*\\b|@\\"[^\\"]*\\"))(?!\\(|\\s*=[^=>])',
      name: 'constant.language.enum'
    },
    field_decl: {
      begin: '([a-zA-Z_]\\w*|@\\".+\\")\\s*(:)\\s*',
      beginCaptures: {
        1: {name: 'variable.other.member.zig'},
        2: {name: 'punctuation.separator.zig'}
      },
      end: '([a-zA-Z_][\\w.]*|@\\".+\\")?\\s*(?:(,)|(=)|$)',
      endCaptures: {
        1: {name: 'storage.type.zig'},
        2: {name: 'punctuation.separator.zig'},
        3: {name: 'keyword.operator.assignment.zig'}
      },
      patterns: [{include: '#dummy_main'}]
    },
    function_call: {
      match: '(?<!fn)\\b([a-zA-Z_]\\w*|@\\".+\\")(?=\\s*\\()',
      name: 'variable.function.zig'
    },
    function_def: {
      begin: '(?<=fn)\\s+([a-zA-Z_]\\w*|@\\".+\\")(\\()',
      beginCaptures: {
        1: {name: 'entity.name.function'},
        2: {name: 'punctuation.section.parens.begin.zig'}
      },
      end: '(?<=\\)[^\\)])\\s*([a-zA-Z_][\\w.]*|@\\".+\\")?(!)?\\s*(?:([a-zA-Z_][\\w.]*|@\\".+\\")\\b(?!\\s*\\())?',
      endCaptures: {
        1: {name: 'storage.type.zig'},
        2: {name: 'keyword.operator.zig'},
        3: {name: 'storage.type.zig'}
      },
      patterns: [
        {include: '#label'},
        {include: '#param_list'},
        {match: '([a-zA-Z_][\\w.]*|@\\".+\\")', name: 'storage.type.zig'},
        {include: '#dummy_main'}
      ]
    },
    function_type: {
      begin: '\\b(fn)\\s*(\\()',
      beginCaptures: {
        1: {name: 'storage.type.function.zig'},
        2: {name: 'punctuation.section.parens.begin.zig'}
      },
      contentName: 'meta.function.parameters.zig',
      end: '(?<=\\)|\\})\\s*([a-zA-Z_][\\w.]*|@\\".+\\")?\\s*(!)?\\s*([a-zA-Z_][\\w.]*|@\\".+\\")',
      endCaptures: {
        1: {name: 'storage.type.zig'},
        2: {name: 'keyword.operator.zig'},
        3: {name: 'storage.type.zig'}
      },
      patterns: [
        {include: '#label'},
        {include: '#param_list'},
        {match: '([a-zA-Z_][\\w.]*|@\\".+\\")', name: 'storage.type.zig'},
        {include: '#dummy_main'}
      ]
    },
    keywords: {
      patterns: [
        {
          match:
            '\\b(while|for|break|return|continue|asm|defer|errdefer|unreachable)\\b',
          name: 'keyword.control.zig'
        },
        {
          match: '\\b(async|await|suspend|nosuspend|resume)\\b',
          name: 'keyword.control.async.zig'
        },
        {
          match: '\\b(if|else|switch|try|catch|orelse)\\b',
          name: 'keyword.control.conditional.zig'
        },
        {
          match: '(?<!\\w)(@import|@cImport|@cInclude)\\b',
          name: 'keyword.control.import.zig'
        },
        {
          match: '\\b(usingnamespace)\\b',
          name: 'keyword.other.usingnamespace.zig'
        }
      ]
    },
    label: {
      captures: {
        1: {name: 'keyword.control.zig'},
        2: {name: 'entity.name.label.zig'},
        3: {name: 'entity.name.label.zig'}
      },
      match:
        '\\b(break|continue)\\s*:\\s*([a-zA-Z_]\\w*|@\\".+\\")\\b|\\b(?!\\d)([a-zA-Z_]\\w*|@\\".+\\")\\b(?=\\s*:\\s*(?:\\{|while\\b))'
    },
    operators: {
      patterns: [
        {match: '\\b!\\b', name: 'keyword.operator.zig'},
        {match: '(==|(?:!|>|<)=?)', name: 'keyword.operator.logical.zig'},
        {match: '\\b(and|or)\\b', name: 'keyword.operator.word.zig'},
        {
          match: '((?:(?:\\+|-|\\*)\\%?|/|%|<<|>>|&|\\|(?=[^\\|])|\\^)?=)',
          name: 'keyword.operator.assignment.zig'
        },
        {
          match: '((?:\\+|-|\\*)\\%?|/(?!/)|%)',
          name: 'keyword.operator.arithmetic.zig'
        },
        {
          match: '(<<|>>|&(?=[a-zA-Z_]|@\\")|\\|(?=[^\\|])|\\^|~)',
          name: 'keyword.operator.bitwise.zig'
        },
        {
          match:
            '(\\+\\+|\\*\\*|->|\\.\\?|\\.\\*|&(?=[a-zA-Z_]|@\\")|\\?|\\|\\||\\.{2,3})',
          name: 'keyword.operator.other.zig'
        }
      ]
    },
    param_list: {
      begin: '([a-zA-Z_]\\w*|@\\".+\\")\\s*(:)\\s*',
      beginCaptures: {
        1: {name: 'variable.parameter.zig'},
        2: {name: 'punctuation.separator.zig'}
      },
      end: '([a-zA-Z_][\\w.]*|@\\".+\\")?\\s*(?:(,)|(\\)))',
      endCaptures: {
        1: {name: 'storage.type.zig'},
        2: {name: 'punctuation.separator.zig'},
        3: {name: 'punctuation.section.parens.end.zig'}
      },
      patterns: [
        {include: '#dummy_main'},
        {match: '([a-zA-Z_][\\w.]*|@\\".+\\")', name: 'storage.type.zig'}
      ]
    },
    punctuation: {
      patterns: [
        {match: ',', name: 'punctuation.separator.zig'},
        {match: ';', name: 'punctuation.terminator.zig'},
        {match: '(\\()', name: 'punctuation.section.parens.begin.zig'},
        {match: '(\\))', name: 'punctuation.section.parens.end.zig'}
      ]
    },
    storage: {
      patterns: [
        {
          match: '\\b(bool|void|noreturn|type|anyerror|anytype)\\b',
          name: 'storage.type.zig'
        },
        {
          match: '\\b(?<!\\.)([iu]\\d+|[iu]size|comptime_int)\\b',
          name: 'storage.type.integer.zig'
        },
        {
          match: '\\b(f16|f32|f64|f128|comptime_float)\\b',
          name: 'storage.type.float.zig'
        },
        {
          match:
            '\\b(c_short|c_ushort|c_int|c_uint|c_long|c_ulong|c_longlong|c_ulonglong|c_longdouble|c_void)\\b',
          name: 'storage.type.c_compat.zig'
        },
        {
          captures: {
            1: {name: 'storage.type.zig'},
            2: {name: 'keyword.operator.zig'},
            3: {name: 'storage.type.zig'}
          },
          match:
            '\\b(anyframe)\\b\\s*(->)?\\s*(?:([a-zA-Z_][\\w.]*|@\\".+\\")\\b(?!\\s*\\())?'
        },
        {match: '\\bfn\\b', name: 'storage.type.function.zig'},
        {match: '\\btest\\b', name: 'storage.type.test.zig'},
        {match: '\\bstruct\\b', name: 'storage.type.struct.zig'},
        {match: '\\benum\\b', name: 'storage.type.enum.zig'},
        {match: '\\bunion\\b', name: 'storage.type.union.zig'},
        {match: '\\berror\\b', name: 'storage.type.error.zig'}
      ]
    },
    storage_modifier: {
      match:
        '\\b(const|var|extern|packed|export|pub|noalias|inline|noinline|comptime|volatile|align|linksection|threadlocal|allowzero)\\b',
      name: 'storage.modifier.zig'
    },
    strings: {
      patterns: [
        {
          begin: "\\'",
          end: "\\'",
          name: 'string.quoted.single.zig',
          patterns: [
            {include: '#character_escapes'},
            {match: "\\\\[^\\'][^\\']*?", name: 'invalid.illegal.character.zig'}
          ]
        },
        {
          begin: 'c?\\"',
          end: '\\"',
          name: 'string.quoted.double.zig',
          patterns: [
            {include: '#character_escapes'},
            {match: "\\\\[^\\'][^\\']*?", name: 'invalid.illegal.character.zig'}
          ]
        },
        {begin: 'c?\\\\\\\\', end: '$\\n?', name: 'string.quoted.other.zig'}
      ]
    },
    support: {
      match: '(?<!\\w)@[^\\"\\d][a-zA-Z_]\\w*\\b',
      name: 'support.function.zig'
    },
    variables: {
      name: 'meta.variable.zig',
      patterns: [
        {match: '\\b[_A-Z][_A-Z0-9]+\\b', name: 'variable.constant.zig'},
        {match: '\\b[_a-zA-Z][_a-zA-Z0-9]*_t\\b', name: 'entity.name.type.zig'},
        {match: '\\b[A-Z][a-zA-Z0-9]*\\b', name: 'entity.name.type.zig'},
        {match: '\\b[_a-zA-Z][_a-zA-Z0-9]*\\b', name: 'variable.zig'}
      ]
    }
  },
  scopeName: 'source.zig'
}

export default grammar