refactor: tests and format the world (#314)

tests/unit/Feature/SemanticTokenTests.cpp

@@ -0,0 +1,197 @@
+#include "Test/Test.h"
+#include "Test/Tester.h"
+#include "Feature/SemanticToken.h"
+
+namespace clice::testing {
+
+namespace {
+
+using enum SymbolKind::Kind;
+using enum SymbolModifiers::Kind;
+
+TEST_SUITE(SemanticToken) {
+
+Tester tester;
+feature::SemanticTokens tokens;
+
+void run(llvm::StringRef code) {
+    tester.clear();
+    tester.add_main("main.cpp", code);
+    ASSERT_TRUE(tester.compile_with_pch());
+    tokens = feature::semantic_tokens(*tester.unit);
+};
+
+void expect_token(llvm::StringRef pos,
+                  SymbolKind kind,
+                  SymbolModifiers modifiers = SymbolModifiers(),
+                  std::source_location loc = std::source_location::current()) {
+    auto range = tester.range(pos);
+
+    auto found = false;
+
+    for(auto& token: tokens) {
+        if(token.range == range) {
+            ASSERT_EQ(token.kind, kind);
+            ASSERT_EQ(token.modifiers, modifiers);
+            found = true;
+            break;
+        }
+    }
+
+    ASSERT_TRUE(found);
+};
+
+TEST_CASE(Include) {
+    run(R"cpp(
+ @0[#include] @1[<stddef.h>]
+ @2[#include] @3["stddef.h"]
+ @4[#] @5[include] @6["stddef.h"]
+ )cpp");
+
+    expect_token("0", Directive);
+    expect_token("1", Header);
+    expect_token("2", Directive);
+    expect_token("3", Header);
+    expect_token("4", Directive);
+    expect_token("5", Directive);
+    expect_token("6", Header);
+}
+
+TEST_CASE(Comment) {
+    run(R"cpp(
+@line[/// line comment]
+int x = 1;
+)cpp");
+
+    expect_token("line", Comment);
+}
+
+TEST_CASE(Keyword) {
+    run(R"cpp(
+@int[int] main() {
+    @return[return] 0;
+}
+)cpp");
+
+    expect_token("int", Keyword);
+    expect_token("return", Keyword);
+}
+
+TEST_CASE(Macro) {
+    run(R"cpp(
+@directive[#define] @macro[FOO]
+)cpp");
+
+    expect_token("directive", Directive);
+    expect_token("macro", Macro);
+}
+
+TEST_CASE(FinalAndOverride) {
+    run(R"cpp(
+struct A @final[final] {};
+
+struct B {
+    virtual void foo();
+};
+
+struct C : B {
+    void foo() @override[override];
+};
+
+struct D : C {
+    void foo() @final2[final];
+};
+)cpp");
+
+    expect_token("final", Keyword);
+    expect_token("override", Keyword);
+    expect_token("final2", Keyword);
+}
+
+TEST_CASE(VarDecl) {
+    run(R"cpp(
+extern int @x1[x];
+
+int @x2[x] = 1;
+
+template <typename T, typename U>
+extern int @y1[y];
+
+template <typename T, typename U>
+int @y2[y] = 2;
+
+template<typename T>
+extern int @y3[y]<T, int>;
+
+template<typename T>
+int @y4[y]<T, int> = 4;
+
+template<>
+int @y5[y]<int, int> = 5;
+
+int main() {
+    @x3[x] = 6;
+}
+)cpp");
+
+    expect_token("x1", Variable, Declaration);
+    expect_token("x2", Variable, Definition);
+    expect_token("y1", Variable, SymbolModifiers(Declaration, Templated));
+    expect_token("y2", Variable, SymbolModifiers(Definition, Templated));
+    expect_token("y3", Variable, SymbolModifiers(Declaration, Templated));
+    expect_token("y4", Variable, SymbolModifiers(Definition, Templated));
+    expect_token("y5", Variable, Definition);
+    expect_token("x3", Variable, SymbolModifiers());
+}
+
+TEST_CASE(FunctionDecl) {
+    run(R"cpp(
+extern int @foo1[foo]();
+
+int @foo2[foo]() {
+    return 0;
+}
+
+template <typename T>
+extern int @bar1[bar]();
+
+template <typename T>
+int @bar2[bar]() {
+    return 1;
+}
+)cpp");
+
+    expect_token("foo1", Function, Declaration);
+    expect_token("foo2", Function, Definition);
+    expect_token("bar1", Function, SymbolModifiers(Declaration, Templated));
+    expect_token("bar2", Function, SymbolModifiers(Definition, Templated));
+}
+
+TEST_CASE(RecordDecl) {
+    run(R"cpp(
+class @A1[A];
+
+class @A2[A] {};
+
+struct @B1[B];
+
+struct @B2[B] {};
+
+union @C1[C];
+
+union @C2[C] {};
+)cpp");
+
+    expect_token("A1", Class, Declaration);
+    expect_token("A2", Class, Definition);
+    expect_token("B1", Struct, Declaration);
+    expect_token("B2", Struct, Definition);
+    expect_token("C1", Union, Declaration);
+    expect_token("C2", Union, Definition);
+}
+
+};  // TEST_SUITE(SemanticToken)
+
+}  // namespace
+
+}  // namespace clice::testing