AstExtractorRunner.h

Go to the documentation of this file.

/*$!{
* Aurora Clang AST Viewer (ACAV)
* 
* Copyright (c) 2026 Min Liu
* Copyright (c) 2026 Michael David Adams
* 
* SPDX-License-Identifier: GPL-2.0-or-later
* 
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
* 
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
* 
* You should have received a copy of the GNU General Public License along
* with this program; if not, see <https://www.gnu.org/licenses/>.
}$!*/

#pragma once
 
#include "common/FileManager.h"
#include "core/AstNode.h"
#include "core/LogEntry.h"
#include <QObject>
#include <QString>
#include <QStringList>
#include <atomic>
#include <cstddef>
#include <functional>
#include <memory>
#include <string>
 
namespace clang {
class ASTUnit;
} // namespace clang
 
namespace acav {
 
class AstContext; // Forward declaration
struct DiagnosticMessage; // Forward declaration

struct AstExtractionStats {
  std::size_t totalCount = 0;              // Total nodes visited
  std::size_t declCount = 0;               // Declaration nodes
  std::size_t stmtCount = 0;               // Statement nodes
  std::size_t typeCount = 0;               // Type nodes (deduplicated)
  std::size_t typeLocCount = 0;            // TypeLoc nodes
  std::size_t attrCount = 0;               // Attribute nodes
  std::size_t conceptRefCount = 0;         // ConceptReference nodes
  std::size_t cxxBaseSpecCount = 0;        // CXXBaseSpecifier nodes
  std::size_t ctorInitCount = 0;           // CXXCtorInitializer nodes
  std::size_t lambdaCaptureCount = 0;      // LambdaCapture nodes
  std::size_t nestedNameSpecCount = 0;     // NestedNameSpecifier nodes
  std::size_t nestedNameSpecLocCount = 0;  // NestedNameSpecifierLoc nodes
  std::size_t tempArgCount = 0;            // TemplateArgument nodes
  std::size_t tempArgLocCount = 0;         // TemplateArgumentLoc nodes
  std::size_t tempNameCount = 0;           // TemplateName nodes
  std::size_t commentCount = 0;            // Comment nodes
};

class AstExtractorRunner : public QObject {
  Q_OBJECT
 
public:
  using AstLoader = std::function<std::unique_ptr<clang::ASTUnit>(
      const std::string &astFilePath, std::string &errorOut,
      const std::string &compilationDbPath, const std::string &sourcePath)>;

  explicit AstExtractorRunner(AstContext *context, FileManager &fileManager,
                              QObject *parent = nullptr);

  explicit AstExtractorRunner(AstContext *context, FileManager &fileManager,
                              AstLoader loader, QObject *parent = nullptr);
 
  ~AstExtractorRunner() override;
 
  // Non-copyable, non-movable
  AstExtractorRunner(const AstExtractorRunner &) = delete;
  AstExtractorRunner &operator=(const AstExtractorRunner &) = delete;
  AstExtractorRunner(AstExtractorRunner &&) = delete;
  AstExtractorRunner &operator=(AstExtractorRunner &&) = delete;

  void run(const QString &astFilePath, const QStringList &tuFilePaths,
           const QString &compilationDbPath = QString());

  void setCommentExtractionEnabled(bool enabled);
 
  bool commentExtractionEnabled() const { return commentExtractionEnabled_.load(); }
 
signals:
  void started(const QString &astFilePath);
  void progress(const QString &message);
  void statsUpdated(const AstExtractionStats &stats);
  void finished(AstViewNode *root);
  void error(const QString &message);
  void logMessage(const LogEntry &entry);
 
private:
  void registerInputFiles(const QStringList &tuFilePaths);
  AstViewNode *buildTreeFromASTUnit(clang::ASTUnit &astUnit);
  void buildLocationIndex(AstViewNode *node);
 
  AstContext *context_;      // Not owned
  FileManager &fileManager_; // Not owned
  AstLoader astLoader_;
  std::function<void(const DiagnosticMessage &)> diagnosticCallback_;
  std::chrono::steady_clock::time_point start_;
  std::atomic<bool> commentExtractionEnabled_{false};
};
 
} // namespace acav