Add bitwise not operator support with tests

crosstl/backend/DirectX/DirectxLexer.py

@@ -9,6 +9,7 @@
     [
         ("COMMENT_SINGLE", r"//.*"),
         ("COMMENT_MULTI", r"/\*[\s\S]*?\*/"),
+        ("BITWISE_NOT", r"~"),
         ("INCLUDE", r"\#include\b"),
         ("STRUCT", r"\bstruct\b"),
         ("CBUFFER", r"\bcbuffer\b"),

crosstl/backend/DirectX/DirectxParser.py

@@ -527,7 +527,7 @@ def parse_multiplicative(self):
         return left
 
     def parse_unary(self):
-        if self.current_token[0] in ["PLUS", "MINUS"]:
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
             op = self.current_token[1]
             self.eat(self.current_token[0])
             operand = self.parse_unary()

crosstl/backend/Metal/MetalLexer.py

@@ -8,6 +8,7 @@
     [
         ("COMMENT_SINGLE", r"//.*"),
         ("COMMENT_MULTI", r"/\*[\s\S]*?\*/"),
+        ("BITWISE_NOT", r"~"),
         ("PREPROCESSOR", r"#\w+"),
         ("STRUCT", r"\bstruct\b"),
         ("CONSTANT", r"\bconstant\b"),

crosstl/backend/Metal/MetalParser.py

@@ -460,7 +460,7 @@ def parse_multiplicative(self):
         return left
 
     def parse_unary(self):
-        if self.current_token[0] in ["PLUS", "MINUS"]:
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
             op = self.current_token[1]
             self.eat(self.current_token[0])
             operand = self.parse_unary()

crosstl/backend/Mojo/MojoLexer.py

@@ -8,6 +8,7 @@
     [
         ("COMMENT_SINGLE", r"#.*"),
         ("COMMENT_MULTI", r'"""[\s\S]*?"""'),
+        ("BITWISE_NOT", r"~"),
         ("STRUCT", r"\bstruct\b"),
         ("LET", r"\blet\b"),
         ("VAR", r"\bvar\b"),

crosstl/backend/Mojo/MojoParser.py

@@ -468,7 +468,7 @@ def parse_multiplicative(self):
         return left
 
     def parse_unary(self):
-        if self.current_token[0] in ["PLUS", "MINUS"]:
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
             op = self.current_token[1]
             self.eat(self.current_token[0])
             operand = self.parse_unary()

crosstl/backend/Opengl/OpenglParser.py

@@ -729,11 +729,11 @@ def parse_unary(self):
             ASTNode: An ASTNode object representing the unary expression
 
         """
-        if self.current_token[0] in ["PLUS", "MINUS"]:
-            op = self.current_token[0]
-            self.eat(op)
-            expr = self.parse_unary()
-            return UnaryOpNode(op, expr)
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
+            op = self.current_token[1]
+            self.eat(self.current_token[0])
+            operand = self.parse_unary()
+            return UnaryOpNode(op, operand)
         return self.parse_primary()
 
     def parse_primary(self):

crosstl/backend/Vulkan/VulkanLexer.py

@@ -8,6 +8,7 @@
     [
         ("COMMENT_SINGLE", r"//.*"),
         ("COMMENT_MULTI", r"/\*[\s\S]*?\*/"),
+        ("BITWISE_NOT", r"~"),
         ("WHITESPACE", r"\s+"),
         ("SEMANTIC", r":\w+"),
         ("PRE_INCREMENT", r"\+\+(?=\w)"),

crosstl/backend/Vulkan/VulkanParser.py

@@ -445,6 +445,11 @@ def parse_primary(self):
             value = self.parse_primary()
             return UnaryOpNode("-", value)
 
+        if self.current_token[0] == "BITWISE_NOT":
+            self.eat("BITWISE_NOT")
+            value = self.parse_primary()
+            return UnaryOpNode("~", value)
+
         if (
             self.current_token[0] == "IDENTIFIER"
             or self.current_token[1] in VALID_DATA_TYPES
@@ -663,3 +668,11 @@ def parse_uniform(self):
         self.eat("IDENTIFIER")
         self.eat("SEMICOLON")
         return UniformNode(name, var_type)
+
+    def parse_unary(self):
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
+            op = self.current_token[1]
+            self.eat(self.current_token[0])
+            operand = self.parse_unary()
+            return UnaryOpNode(op, operand)
+        return self.parse_primary()

crosstl/backend/slang/SlangLexer.py

@@ -8,6 +8,7 @@
     [
         ("COMMENT_SINGLE", r"//.*"),
         ("COMMENT_MULTI", r"/\*[\s\S]*?\*/"),
+        ("BITWISE_NOT", r"~"),
         ("STRUCT", r"\bstruct\b"),
         ("CBUFFER", r"\bcbuffer\b"),
         ("TYPE_SHADER", r'\[shader\("(vertex|fragment|compute)"\)\]'),

crosstl/backend/slang/SlangParser.py

@@ -497,7 +497,7 @@ def parse_multiplicative(self):
         return left
 
     def parse_unary(self):
-        if self.current_token[0] in ["PLUS", "MINUS"]:
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
             op = self.current_token[1]
             self.eat(self.current_token[0])
             operand = self.parse_unary()

crosstl/translator/lexer.py

@@ -7,6 +7,7 @@
         ("COMMENT_SINGLE", r"//.*"),
         ("COMMENT_MULTI", r"/\*[\s\S]*?\*/"),
         ("SHADER", r"\bshader\b"),
+        ("BITWISE_NOT", r"~"),
         ("VOID", r"\bvoid\b"),
         ("STRUCT", r"\bstruct\b"),
         ("CBUFFER", r"\bcbuffer\b"),

crosstl/translator/parser.py

@@ -690,11 +690,9 @@ def parse_unary(self):
         This method parses a unary expression in the shader code.
 
         Returns:
-
             ASTNode: An ASTNode object representing the unary expression
-
         """
-        if self.current_token[0] in ["PLUS", "MINUS"]:
+        if self.current_token[0] in ["PLUS", "MINUS", "BITWISE_NOT"]:
             op = self.current_token[0]
             self.eat(op)
             expr = self.parse_unary()

tests/test_backend/test_directx/test_codegen.py

@@ -718,5 +718,21 @@ def test_half_dtype_codegen():
         pytest.fail("half dtype parsing or code generation not implemented.")
 
 
+def test_bitwise_not_codegen():
+    code = """
+    void main() {
+        int a = 5;
+        int b = ~a;  // Bitwise NOT
+    }
+    """
+    try:
+        tokens = tokenize_code(code)
+        ast = parse_code(tokens)
+        generated_code = generate_code(ast)
+        print(generated_code)
+    except SyntaxError:
+        pytest.fail("Bitwise NOT operator code generation not implemented")
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_directx/test_lexer.py

@@ -299,5 +299,20 @@ def test_half_dtype_tokenization():
         pytest.fail("half dtype tokenization is not implemented.")
 
 
+def test_bitwise_not_tokenization():
+    code = """
+        int a = ~5;  // Bitwise NOT
+    """
+    tokens = tokenize_code(code)
+
+    has_not = False
+    for token in tokens:
+        if token == ("BITWISE_NOT", "~"):
+            has_not = True
+            break
+
+    assert has_not, "Bitwise NOT operator (~) not tokenized correctly"
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_directx/test_parser.py

@@ -415,5 +415,19 @@ def test_double_dtype_parsing():
         pytest.fail("half dtype not implemented.")
 
 
+def test_bitwise_not_parsing():
+    code = """
+    void main() {
+        int a = 5;
+        int b = ~a;  // Bitwise NOT
+    }
+    """
+    try:
+        tokens = tokenize_code(code)
+        parse_code(tokens)
+    except SyntaxError:
+        pytest.fail("Bitwise NOT operator parsing not implemented")
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_metal/test_codegen.py

@@ -331,5 +331,21 @@ def test_else_if():
     print(generated_code)
 
 
+def test_bitwise_not_codegen():
+    code = """
+    void main() {
+        int a = 5;
+        int b = ~a;  // Bitwise NOT
+    }
+    """
+    try:
+        tokens = tokenize_code(code)
+        ast = parse_code(tokens)
+        generated_code = generate_code(ast)
+        print(generated_code)
+    except SyntaxError:
+        pytest.fail("Bitwise NOT operator code generation not implemented")
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_metal/test_lexer.py

@@ -142,5 +142,20 @@ def test_mod_tokenization():
     assert has_mod, "Modulus operator (%) not tokenized correctly"
 
 
+def test_bitwise_not_tokenization():
+    code = """
+        int a = ~5;  // Bitwise NOT
+    """
+    tokens = tokenize_code(code)
+
+    has_not = False
+    for token in tokens:
+        if token == ("BITWISE_NOT", "~"):
+            has_not = True
+            break
+
+    assert has_not, "Bitwise NOT operator (~) not tokenized correctly"
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_metal/test_parser.py

@@ -167,5 +167,19 @@ def test_mod_parsing():
         pytest.fail("Modulus operator parsing not implemented")
 
 
+def test_bitwise_not_parsing():
+    code = """
+    void main() {
+        int a = 5;
+        int b = ~a;  // Bitwise NOT
+    }
+    """
+    try:
+        tokens = tokenize_code(code)
+        parse_code(tokens)
+    except SyntaxError:
+        pytest.fail("Bitwise NOT operator parsing not implemented")
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_mojo/test_lexer.py

@@ -25,5 +25,18 @@ def test_mod_tokenization():
     assert has_mod, "Modulus operator (%) not tokenized correctly"
 
 
+def test_bitwise_not_tokenization():
+    code = """
+        int a = ~5;  // Bitwise NOT
+    """
+    tokens = tokenize_code(code)
+    has_not = False
+    for token in tokens:
+        if token == ("BITWISE_NOT", "~"):
+            has_not = True
+            break
+    assert has_not, "Bitwise NOT operator (~) not tokenized correctly"
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_opengl/test_lexer.py

@@ -128,17 +128,27 @@ def test_mod_tokenization():
         int a = 10 % 3;  // Basic modulus
     """
     tokens = tokenize_code(code)
-
-    # Find the modulus operator in tokens
     has_mod = False
     for token in tokens:
         if token == ("MOD", "%"):
             has_mod = True
             break
-
     assert has_mod, "Modulus operator (%) not tokenized correctly"
 
 
+def test_bitwise_not_tokenization():
+    code = """
+        int a = ~5;  // Bitwise NOT
+    """
+    tokens = tokenize_code(code)
+    has_not = False
+    for token in tokens:
+        if token == ("BITWISE_NOT", "~"):
+            has_not = True
+            break
+    assert has_not, "Bitwise NOT operator (~) not tokenized correctly"
+
+
 def test_unsigned_int_dtype_tokenization():
     code = """
     double ComputeArea(double radius) {

tests/test_backend/test_slang/test_lexer.py

@@ -106,16 +106,26 @@ def test_mod_tokenization():
         int a = 10 % 3;  // Basic modulus
     """
     tokens = tokenize_code(code)
-
-    # Find the modulus operator in tokens
     has_mod = False
     for token in tokens:
         if token == ("MOD", "%"):
             has_mod = True
             break
-
     assert has_mod, "Modulus operator (%) not tokenized correctly"
 
 
+def test_bitwise_not_tokenization():
+    code = """
+        int a = ~5;  // Bitwise NOT
+    """
+    tokens = tokenize_code(code)
+    has_not = False
+    for token in tokens:
+        if token == ("BITWISE_NOT", "~"):
+            has_not = True
+            break
+    assert has_not, "Bitwise NOT operator (~) not tokenized correctly"
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_vulkan/test_lexer.py

@@ -25,5 +25,18 @@ def test_mod_tokenization():
     assert has_mod, "Modulus operator (%) not tokenized correctly"
 
 
+def test_bitwise_not_tokenization():
+    code = """
+        int a = ~5;  // Bitwise NOT
+    """
+    tokens = tokenize_code(code)
+    has_not = False
+    for token in tokens:
+        if token == ("BITWISE_NOT", "~"):
+            has_not = True
+            break
+    assert has_not, "Bitwise NOT operator (~) not tokenized correctly"
+
+
 if __name__ == "__main__":
     pytest.main()

tests/test_backend/test_vulkan/test_parser.py

@@ -36,5 +36,19 @@ def test_mod_parsing():
         pytest.fail("Modulus operator parsing not implemented")
 
 
+def test_bitwise_not_parsing():
+    code = """
+    void main() {
+        int a = 5;
+        int b = ~a;  // Bitwise NOT
+    }
+    """
+    try:
+        tokens = tokenize_code(code)
+        parse_code(tokens)
+    except SyntaxError:
+        pytest.fail("Bitwise NOT operator parsing not implemented")
+
+
 if __name__ == "__main__":
     pytest.main()