Increase coverage and support FFI (e.g., for integration into my new bridle-ctl)

Author: SamuelMarks

type_correct/CMakeLists.txt

@@ -25,6 +25,7 @@ set(Header_Files
     "StructAnalyzer.h"
     "TypeSolver.h"
     "CTU/FactManager.h"
+    "TypeCorrectCAPI.h"
 ) 
 source_group("Header Files" FILES "${Header_Files}") 
 
@@ -35,6 +36,7 @@ set(Source_Files
     "StructAnalyzer.cpp"
     "TypeSolver.cpp"
     "CTU/FactManager.cpp"
+    "TypeCorrectCAPI.cpp"
 ) 
 source_group("Source Files" FILES "${Source_Files}") 
 
@@ -159,5 +161,5 @@ install(FILES "${_export_file}" ${Header_Files}
 install(EXPORT "${LIBRARY_NAME}Targets" DESTINATION "${CMAKE_INSTALL_DATADIR}/${LIBRARY_NAME}") 
 
 # Redundant explicit install for verification (keeps original logic intact). 
-install(FILES "${Header_Files}" "${Cli_Header_Files}" "${_export_file}" 
+install(FILES ${Header_Files} ${Cli_Header_Files} "${_export_file}" 
         TYPE "INCLUDE")

type_correct/TypeCorrect.cpp

@@ -37,10 +37,12 @@ TypeLoc GetBaseTypeLoc(TypeLoc TL) {
       TL = QTL.getUnqualifiedLoc();
       continue;
     }
-    if (auto ETL = TL.getAs<ElaboratedTypeLoc>()) {
+#if LLVM_VERSION_MAJOR < 19
+    if (auto ETL = TL.getAs<clang::ElaboratedTypeLoc>()) {
       TL = ETL.getNamedTypeLoc();
       continue;
     }
+#endif
     if (auto ATL = TL.getAs<AttributedTypeLoc>()) {
       TL = ATL.getModifiedLoc();
       continue;

type_correct/TypeCorrectCAPI.cpp

@@ -0,0 +1,56 @@
+#include "TypeCorrectCAPI.h"
+#include "TypeCorrectMain.h"
+
+#include <clang/Tooling/CompilationDatabase.h>
+#include <clang/Tooling/Refactoring.h>
+#include <clang/Tooling/Tooling.h>
+#include <iostream>
+#include <vector>
+
+namespace {
+class CAPIActionFactory : public clang::tooling::FrontendActionFactory {
+    bool AuditMode;
+    bool InPlace;
+public:
+    CAPIActionFactory(bool AuditMode, bool InPlace) 
+        : AuditMode(AuditMode), InPlace(InPlace) {}
+
+    std::unique_ptr<clang::FrontendAction> create() override {
+        return std::make_unique<TypeCorrectPluginAction>(
+            "", "", InPlace, false, AuditMode, 
+            type_correct::Phase::Standalone, "", "");
+    }
+};
+} // namespace
+
+extern "C" TYPE_CORRECT_EXPORT int type_correct_audit(const char* target_path) {
+    if (!target_path) return -1;
+
+    std::vector<std::string> CommandLine;
+    auto Compilations = std::make_unique<clang::tooling::FixedCompilationDatabase>(".", CommandLine);
+
+    std::vector<std::string> SourcePaths = { target_path };
+    clang::tooling::RefactoringTool Tool(*Compilations, SourcePaths);
+
+    CAPIActionFactory Factory(true /* AuditMode */, false /* InPlace */);
+    return Tool.run(&Factory);
+}
+
+extern "C" TYPE_CORRECT_EXPORT int type_correct_fix(const char* target_path, bool dry_run) {
+    if (!target_path) return -1;
+
+    std::vector<std::string> CommandLine;
+    auto Compilations = std::make_unique<clang::tooling::FixedCompilationDatabase>(".", CommandLine);
+
+    std::vector<std::string> SourcePaths = { target_path };
+    clang::tooling::RefactoringTool Tool(*Compilations, SourcePaths);
+
+    bool InPlace = !dry_run;
+    CAPIActionFactory Factory(false /* AuditMode */, InPlace);
+
+    if (dry_run) {
+        return Tool.run(&Factory);
+    } else {
+        return Tool.runAndSave(&Factory);
+    }
+}

type_correct/TypeCorrectCAPI.h

@@ -0,0 +1,40 @@
+/**
+ * @file TypeCorrectCAPI.h
+ * @brief Foreign Function Interface (FFI) for type-correct.
+ *
+ * Exposes core logic to external tooling (e.g., bridle-ctl) over C ABI.
+ */
+
+#ifndef TYPE_CORRECT_CAPI_H
+#define TYPE_CORRECT_CAPI_H
+
+#include "type_correct_export.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Audits a target file using type-correct without applying changes.
+ *
+ * @param target_path The absolute or relative path to the C/C++ file to audit.
+ * @return 0 on success, non-zero if issues were found or if an error occurred.
+ */
+TYPE_CORRECT_EXPORT int type_correct_audit(const char *target_path);
+
+/**
+ * @brief Fixes a target file using type-correct.
+ *
+ * @param target_path The absolute or relative path to the C/C++ file to fix.
+ * @param dry_run If true, outputs the would-be changes instead of writing them
+ * to disk.
+ * @return 0 on success, non-zero if an error occurred.
+ */
+TYPE_CORRECT_EXPORT int type_correct_fix(const char *target_path, bool dry_run);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TYPE_CORRECT_CAPI_H */

type_correct/TypeCorrectMain.h

@@ -16,6 +16,7 @@
 #include "TypeCorrect.h"
 #include "type_correct_export.h"
 #include <clang/Frontend/CompilerInstance.h>
+#include <clang/Frontend/FrontendAction.h>
 #include <clang/Rewrite/Core/Rewriter.h>
 
 //===----------------------------------------------------------------------===//

type_correct/tests/CMakeLists.txt

@@ -31,6 +31,7 @@ set(EXEC_NAME "test_type_correct")
 set(Source_Files
     "${EXEC_NAME}.cpp"
     "test_coverage.cpp"
+    "test_capi.cpp"
 ) 
 source_group("${EXEC_NAME} Source Files" FILES "${Source_Files}") 
 

type_correct/tests/test_capi.cpp

@@ -0,0 +1,49 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "../TypeCorrectCAPI.h"
+#include <fstream>
+#include <llvm/Support/FileSystem.h>
+
+TEST(TypeCorrectCAPI, AuditTest) {
+    // Create a dummy file
+    llvm::SmallString<128> tempPath;
+    llvm::sys::fs::createTemporaryFile("test_audit", "cpp", tempPath);
+    
+    std::ofstream out(tempPath.c_str());
+    out << "int main() { return 0; }\n";
+    out.close();
+
+    // Run audit
+    int res = type_correct_audit(tempPath.c_str());
+    EXPECT_EQ(res, 0);
+
+    // Run audit with null
+    res = type_correct_audit(nullptr);
+    EXPECT_EQ(res, -1);
+
+    llvm::sys::fs::remove(tempPath);
+}
+
+TEST(TypeCorrectCAPI, FixTest) {
+    // Create a dummy file
+    llvm::SmallString<128> tempPath;
+    llvm::sys::fs::createTemporaryFile("test_fix", "cpp", tempPath);
+    
+    std::ofstream out(tempPath.c_str());
+    out << "int main() { return 0; }\n";
+    out.close();
+
+    // Run fix dry_run
+    int res = type_correct_fix(tempPath.c_str(), true);
+    EXPECT_EQ(res, 0);
+
+    // Run fix in_place
+    res = type_correct_fix(tempPath.c_str(), false);
+    EXPECT_EQ(res, 0);
+
+    // Run fix with null
+    res = type_correct_fix(nullptr, false);
+    EXPECT_EQ(res, -1);
+
+    llvm::sys::fs::remove(tempPath);
+}

type_correct/tests/test_coverage.cpp

@@ -357,8 +357,8 @@ GTEST_TEST(Coverage, TypeSolverPaths) {
     EXPECT_TRUE(Solver.GetResolvedType(nullptr).isNull());
     EXPECT_FALSE(Solver.GetResolvedType(A).isNull());
 
-    QualType IncompleteTy = Ctx.getRecordType(Incomplete);
-    QualType CompleteTy = Ctx.getRecordType(Complete);
+    QualType IncompleteTy = Ctx.getCanonicalTagType(Incomplete);
+    QualType CompleteTy = Ctx.getCanonicalTagType(Complete);
     EXPECT_FALSE(Solver.GetWider(QualType(), Ctx.IntTy, &Ctx).isNull());
     Solver.GetWider(Ctx.IntTy, QualType(), &Ctx);
     Solver.GetWider(Ctx.IntTy, Ctx.IntTy, &Ctx);
@@ -972,8 +972,8 @@ GTEST_TEST(Coverage, TypeCorrectHelperFunctions) {
     const RecordDecl *FooRec = FindRecordDecl(Ctx, "Foo");
     ASSERT_NE(Fwd, nullptr);
     ASSERT_NE(FooRec, nullptr);
-    QualType IncompleteTy = Ctx.getRecordType(Fwd);
-    QualType CompleteTy = Ctx.getRecordType(FooRec);
+    QualType IncompleteTy = Ctx.getCanonicalTagType(Fwd);
+    QualType CompleteTy = Ctx.getCanonicalTagType(FooRec);
 
     type_correct::test_support::GetWiderTypeForTest(QualType(), Ctx.IntTy, Ctx);
     type_correct::test_support::GetWiderTypeForTest(Ctx.IntTy, QualType(), Ctx);