Add Rust syntax highlighting

src/Highlighter.php

@@ -28,6 +28,7 @@
 use Tempest\Highlight\Languages\Php\PhpLanguage;
 use Tempest\Highlight\Languages\Python\PythonLanguage;
 use Tempest\Highlight\Languages\Ruby\RubyLanguage;
+use Tempest\Highlight\Languages\Rust\RustLanguage;
 use Tempest\Highlight\Languages\Scss\ScssLanguage;
 use Tempest\Highlight\Languages\Sema\SemaLanguage;
 use Tempest\Highlight\Languages\Sql\SqlLanguage;
@@ -87,6 +88,7 @@ public function __construct(
             ->addLanguage(new PhpLanguage())
             ->addLanguage(new PythonLanguage())
             ->addLanguage(new RubyLanguage())
+            ->addLanguage(new RustLanguage())
             ->addLanguage(new ScssLanguage())
             ->addLanguage(new SemaLanguage())
             ->addLanguage(new SqlLanguage())

src/Languages/Rust/Patterns/RustAttributePattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '#[derive(Debug)]', output: '#[derive')]
+#[PatternTest(input: '#![allow(dead_code)]', output: '#![allow')]
+final readonly class RustAttributePattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '(?<match>#!?\[\s*+(?:r#)?[A-Za-z_][\w:]*)';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::ATTRIBUTE;
+    }
+}

src/Languages/Rust/Patterns/RustCharacterPattern.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '\'\\u{41}\'', output: '\'\\u{41}\'')]
+#[PatternTest(input: '\'é\'', output: '\'é\'')]
+#[PatternTest(input: '\'x\'', output: '\'x\'')]
+#[PatternTest(input: '\'\\n\'', output: '\'\\n\'')]
+#[PatternTest(input: 'b\'x\'', output: 'b\'x\'')]
+final readonly class RustCharacterPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return "(?<match>b?'(?:\\\\u\\{[0-9A-Fa-f_]{1,6}\\}|\\\\x[0-9A-Fa-f]{2}|\\\\.|[^'\\\\]|[\\xC2-\\xDF][\\x80-\\xBF]|[\\xE0-\\xEF][\\x80-\\xBF]{2}|[\\xF0-\\xF4][\\x80-\\xBF]{3})')";
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::VALUE;
+    }
+}

src/Languages/Rust/Patterns/RustCommentPattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '// note', output: '// note')]
+#[PatternTest(input: '/* outer /* inner */ outer */', output: '/* outer /* inner */ outer */')]
+final readonly class RustCommentPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '/(?<match>\/\/[^\r\n]*|(?&block))(?(DEFINE)(?<block>\/\*(?:[^*\/]++|\/(?!\*)|\*(?!\/)|(?&block))*\*\/))/s';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::COMMENT;
+    }
+}

src/Languages/Rust/Patterns/RustFunctionPattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: 'run()', output: 'run')]
+#[PatternTest(input: 'collect::<Vec<_>>()', output: 'collect')]
+final readonly class RustFunctionPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '\b(?<match>(?:r#)?[A-Za-z_]\w*)(?=\s*+(?:::\s*+)?(?:<(?:(?:->|-(?!>)|[^<>;{}&|\-]++)|<(?:(?:->|-(?!>)|[^<>;{}&|\-]++)|<(?:(?:->|-(?!>)|[^<>;{}&|\-]++)|<(?:->|-(?!>)|[^<>;{}&|\-]++)*+>)*+>)*+>)*+>\s*+)?\()';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::PROPERTY;
+    }
+}

src/Languages/Rust/Patterns/RustKeywordPattern.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: 'async fn run()', output: 'async')]
+#[PatternTest(input: 'let value = 1;', output: 'let')]
+final readonly class RustKeywordPattern implements Pattern
+{
+    use IsPattern;
+
+    private const array KEYWORDS = [
+        'abstract', 'as', 'async', 'await', 'become', 'box', 'break', 'const',
+        'continue', 'crate', 'do', 'dyn', 'else', 'enum', 'extern', 'final',
+        'fn', 'for', 'gen', 'if', 'impl', 'in', 'let', 'loop', 'macro', 'match',
+        'mod', 'move', 'mut', 'override', 'priv', 'pub', 'ref', 'return', 'static',
+        'self', 'Self', 'struct', 'super', 'trait', 'try', 'type', 'typeof',
+        'union', 'unsafe', 'unsized', 'use', 'virtual', 'where', 'while', 'yield',
+    ];
+
+    public function getPattern(): string
+    {
+        return '\b(?<match>' . implode('|', self::KEYWORDS) . ')\b';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::KEYWORD;
+    }
+}

src/Languages/Rust/Patterns/RustLifetimePattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '&\'a str', output: '\'a')]
+#[PatternTest(input: '<\'static>', output: '\'static')]
+final readonly class RustLifetimePattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return "(?<!\\w)(?<match>'[A-Za-z_]\\w*)(?!')\\b";
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::TYPE;
+    }
+}

src/Languages/Rust/Patterns/RustLiteralPattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: 'true', output: 'true')]
+#[PatternTest(input: 'false', output: 'false')]
+final readonly class RustLiteralPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '\b(?<match>true|false)\b';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::LITERAL;
+    }
+}

src/Languages/Rust/Patterns/RustMacroPattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: 'println!()', output: 'println!')]
+#[PatternTest(input: 'vec![1, 2]', output: 'vec!')]
+final readonly class RustMacroPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '\b(?<match>(?:r#)?[A-Za-z_]\w*!)';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::PROPERTY;
+    }
+}

src/Languages/Rust/Patterns/RustNumberPattern.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '42_u8', output: '42_u8')]
+#[PatternTest(input: '0xFF', output: '0xFF')]
+#[PatternTest(input: '1.5_f64', output: '1.5_f64')]
+final readonly class RustNumberPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '(?<!\w)(?<match>(?:0x[\dA-Fa-f_]+|0o[0-7_]+|0b[01_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?[\d_]+)?)(?:f32|f64|i(?:8|16|32|64|128|size)|u(?:8|16|32|64|128|size))?)\b';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::NUMBER;
+    }
+}

src/Languages/Rust/Patterns/RustOperatorPattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: 'a -> b', output: '->')]
+#[PatternTest(input: 'a => b', output: '=>')]
+final readonly class RustOperatorPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '(?<match>::|<<=?|>>=?|->|=>|\.\.[=.]?|&&|\|\||==|!=|<=|>=|[-+*\/%&|^!]=?|=(?!=|>)|[<>?.:@])';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::OPERATOR;
+    }
+}

src/Languages/Rust/Patterns/RustPunctuationPattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '{', output: '{')]
+#[PatternTest(input: ';', output: ';')]
+final readonly class RustPunctuationPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '(?<match>[{}()\[\],;])';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::OPERATOR;
+    }
+}

src/Languages/Rust/Patterns/RustStringPattern.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: '"hello"', output: '"hello"')]
+#[PatternTest(input: 'r#"hello"#', output: 'r#"hello"#')]
+#[PatternTest(input: 'c"hello"', output: 'c"hello"')]
+final readonly class RustStringPattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '/(?<match>[bc]?r(?<hashes>#{0,255})".*?"\k<hashes>|[bc]?"(?:\\\\.|[^"\\\\])*")/s';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::VALUE;
+    }
+}

src/Languages/Rust/Patterns/RustTypePattern.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Highlight\Languages\Rust\Patterns;
+
+use Tempest\Highlight\IsPattern;
+use Tempest\Highlight\Pattern;
+use Tempest\Highlight\PatternTest;
+use Tempest\Highlight\Tokens\TokenTypeEnum;
+
+#[PatternTest(input: 'String', output: 'String')]
+#[PatternTest(input: 'i32', output: 'i32')]
+final readonly class RustTypePattern implements Pattern
+{
+    use IsPattern;
+
+    public function getPattern(): string
+    {
+        return '(?<!\w)(?<match>bool|char|str|f32|f64|i(?:8|16|32|64|128|size)|u(?:8|16|32|64|128|size)|[A-Z][\w]*)(?![\w!])';
+    }
+
+    public function getTokenType(): TokenTypeEnum
+    {
+        return TokenTypeEnum::TYPE;
+    }
+}