refactor: introduce eventide and rewrite server architecture (#355)

tests/unit/compile/directive_tests.cpp

@@ -0,0 +1,205 @@
+#include "test/test.h"
+#include "test/tester.h"
+#include "support/filesystem.h"
+
+namespace clice::testing {
+
+namespace {
+
+TEST_SUITE(Directive) {
+
+Tester tester;
+std::vector<Include> includes;
+std::vector<HasInclude> has_includes;
+std::vector<Condition> conditions;
+std::vector<MacroRef> macros;
+std::vector<Pragma> pragmas;
+
+using u32 = std::uint32_t;
+
+void run(llvm::StringRef code) {
+    tester.clear();
+    tester.add_files("main.cpp", code);
+    ASSERT_TRUE(tester.compile("-std=c++23"));
+    auto fid = tester.unit->interested_file();
+    includes = tester.unit->directives()[fid].includes;
+    has_includes = tester.unit->directives()[fid].has_includes;
+    conditions = tester.unit->directives()[fid].conditions;
+    macros = tester.unit->directives()[fid].macros;
+    pragmas = tester.unit->directives()[fid].pragmas;
+}
+
+void expect_include(u32 index, llvm::StringRef position, llvm::StringRef path) {
+    auto& include = includes[index];
+    auto [_, offset] = tester.unit->decompose_location(include.location);
+    ASSERT_EQ(offset, tester.point(position));
+
+    /// FIXME: Implicit relative path ...
+    llvm::SmallString<64> target = include.skipped ? "" : tester.unit->file_path(include.fid);
+    path::remove_dots(target);
+
+    ASSERT_EQ(target, path);
+}
+
+void expect_has_inl(u32 index, llvm::StringRef position, llvm::StringRef path) {
+    auto& has_include = has_includes[index];
+    auto [_, offset] = tester.unit->decompose_location(has_include.location);
+    ASSERT_EQ(offset, tester.point(position));
+
+    /// FIXME:
+    llvm::SmallString<64> target =
+        has_include.fid.isValid() ? tester.unit->file_path(has_include.fid) : "";
+    path::remove_dots(target);
+
+    ASSERT_EQ(target, path);
+}
+
+void expect_con(u32 index, Condition::BranchKind kind, llvm::StringRef pos) {
+    auto& condition = conditions[index];
+    auto [_, offset] = tester.unit->decompose_location(condition.loc);
+    ASSERT_EQ(int(condition.kind), int(kind));
+    ASSERT_EQ(offset, tester.point(pos));
+}
+
+void expect_macro(u32 index, MacroRef::Kind kind, llvm::StringRef position) {
+    auto& macro = macros[index];
+    auto [_, offset] = tester.unit->decompose_location(macro.loc);
+    ASSERT_EQ(int(macro.kind), int(kind));
+    ASSERT_EQ(offset, tester.point(position));
+}
+
+void expect_pragma(u32 index, Pragma::Kind kind, llvm::StringRef pos, llvm::StringRef text) {
+    auto& pragma = pragmas[index];
+    auto [_, offset] = tester.unit->decompose_location(pragma.loc);
+    ASSERT_EQ(int(pragma.kind), int(kind));
+    ASSERT_EQ(pragma.stmt, text);
+    ASSERT_EQ(offset, tester.point(pos));
+}
+
+TEST_CASE(Include) {
+    run(R"cpp(
+#[test.h]
+
+#[pragma_once.h]
+#pragma once
+
+#[guard_macro.h]
+#ifndef TEST3_H
+#define TEST3_H
+#endif
+
+#[main.cpp]
+#$(0)include "test.h"
+#$(1)include "test.h"
+#$(2)include "pragma_once.h"
+#$(3)include "pragma_once.h"
+#$(4)include "guard_macro.h"
+#$(5)include "guard_macro.h"
+)cpp");
+
+    ASSERT_EQ(includes.size(), 6U);
+    expect_include(0, "0", "test.h");
+    expect_include(1, "1", "test.h");
+    expect_include(2, "2", "pragma_once.h");
+    expect_include(3, "3", "");
+    expect_include(4, "4", "guard_macro.h");
+    expect_include(5, "5", "");
+
+    /// TODO: test include source range.
+};
+
+TEST_CASE(HasInclude) {
+    run(R"cpp(
+#[test.h]
+
+#[main.cpp]
+#include "test.h"
+#if __has_include($(0)"test.h")
+#endif
+
+#if __has_include($(1)"test2.h")
+#endif
+)cpp");
+
+    ASSERT_EQ(has_includes.size(), 2U);
+    expect_has_inl(0, "0", "test.h");
+    expect_has_inl(1, "1", "");
+};
+
+TEST_CASE(Condition) {
+    run(R"cpp(
+#[main.cpp]
+#$(0)if 0
+#$(1)elif 1
+#$(2)else
+#$(3)endif
+
+#$(4)ifdef name
+#$(5)elifdef name
+#$(6)else
+#$(7)endif
+)cpp");
+
+    ASSERT_EQ(conditions.size(), 8U);
+    expect_con(0, Condition::BranchKind::If, "0");
+    expect_con(1, Condition::BranchKind::Elif, "1");
+    expect_con(2, Condition::BranchKind::Else, "2");
+    expect_con(3, Condition::BranchKind::EndIf, "3");
+    expect_con(4, Condition::BranchKind::Ifdef, "4");
+    expect_con(5, Condition::BranchKind::Elifdef, "5");
+    expect_con(6, Condition::BranchKind::Else, "6");
+    expect_con(7, Condition::BranchKind::EndIf, "7");
+};
+
+TEST_CASE(Macro) {
+    run(R"cpp(
+#[main.cpp]
+#define $(0)expr(v) v
+
+#ifdef $(1)expr
+int x = $(2)expr(1);
+#endif
+
+#undef $(3)expr
+
+#define $(4)expr(v) v
+
+#ifdef $(5)expr
+int y = $(6)expr($(7)expr(1));
+#endif
+
+#undef $(8)expr
+
+)cpp");
+
+    ASSERT_EQ(macros.size(), 9U);
+    expect_macro(0, MacroRef::Kind::Def, "0");
+    expect_macro(1, MacroRef::Kind::Ref, "1");
+    expect_macro(2, MacroRef::Kind::Ref, "2");
+    expect_macro(3, MacroRef::Kind::Undef, "3");
+    expect_macro(4, MacroRef::Kind::Def, "4");
+    expect_macro(5, MacroRef::Kind::Ref, "5");
+    expect_macro(6, MacroRef::Kind::Ref, "6");
+    expect_macro(7, MacroRef::Kind::Ref, "7");
+    expect_macro(8, MacroRef::Kind::Undef, "8");
+};
+
+TEST_CASE(Pragma) {
+    run(R"cpp(
+#[main.cpp]
+$(0)#pragma GCC poison printf sprintf fprintf
+$(1)#pragma region
+$(2)#pragma endregion
+)cpp");
+
+    ASSERT_EQ(pragmas.size(), 3U);
+    expect_pragma(0, Pragma::Kind::Other, "0", "#pragma GCC poison printf sprintf fprintf");
+    expect_pragma(1, Pragma::Kind::Region, "1", "#pragma region");
+    expect_pragma(2, Pragma::Kind::EndRegion, "2", "#pragma endregion");
+};
+
+};  // TEST_SUITE(Directive)
+
+}  // namespace
+
+}  // namespace clice::testing