update syntax highlighting to more closely match existing languages

[Techatrix]

The current syntax highlighting that is provided for various keywords is in complete disconnect from any conventions established by syntax highlighting configurations from other languages. Here are some examples:

• var, const, comptime and threadlocal are mapped to the "Function" highlighting group by default
• defer, errdefer and extern are mapped to the "Macro" highlighting group by default
• volatile, linksection and allowzero are mapped to the "Type" highlighting group by default
• return, break and continue are mapped to the "Special" highlighting group by default

Having looked at the syntax highlighting of languages like C, C#, Rust, JavaScript, Java and Go, I haven't found a single languages with as many unusual choices as this plugin. My guess is that this syntax highlighting has been developed with some kind of flawed methodology of choosing whatever gives the desired highlighting on some specific colorscheme.

Syntax highlighting configurations and colorschemes do not existing in isolation. We should try our best to match existing configuration of other languages and only deviate from them if we have a good reason for doing so. I ended up changing the configuration for many different keywords. The reasoning for these changes is explained in the individual commit messages.

Here is how these changes affect some popular colorschemes:

Show Images

Before	After
folke/tokyonight.nvim	folke/tokyonight.nvim
morhetz/gruvbox	morhetz/gruvbox
catppuccin/catppuccin	catppuccin/catppuccin
navarasu/onedark.nvim	navarasu/onedark.nvim
Neovim's "vim" colorscheme	Neovim's "vim" colorscheme

const some_const: type = anyframe;
extern var some_var: u32;

pub const some_pub: []const u8 = "hello\\nworld!";
threadlocal var another_var: [*]allowzero align(8) u8 = undefined;

/// Some comment
const SomeStruct = packed struct {
    foo: u32,
    usingnamespace SomeStruct;
    fn copy(self: @This()) SomeStruct {
        return self;
    }
};

fn func(some: anytype) error{OutOfBrain}!void {
    var foo: u32 = 5;
    blk: while (some != 5) : (foo += 2) {
        if (1 != 2 or 2 != 1) {
            break;
        } else {
            continue :blk;
        }
    }
    errdefer comptime unreachable;
    return {};
}

test func {
    const result: SomeStruct = await func() catch unreachable;
    defer _ = result.copy();
    nosuspend {
        @import("std").debug.print("Hello {s}\\n", .{"World"});
    }
    return error.SkipZigTest;
}

pub export fn fanc(comptime T: type) callconv(.c) *anyopaque {
    inline for (0..5) |i| {
        switch (i) {
            .bar => |params| try T.member(params) orelse return,
            else => {},
        }
    }
}

noinline fn syscall1(noalias number: usize, arg1: usize) usize {
    return asm volatile ("syscall"
        : [ret] "={rax}" (-> usize),
        : [number] "{rax}" (number),
          [arg1] "{rdi}" (arg1),
        : "rcx", "r11"
    );
}