AstNode.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/InternedString.h"
#include "core/SourceLocation.h"
#include "core/SourceLocationIndex.h"
#include <nlohmann/json.hpp>
#include <unordered_map>
#include <vector>
 
namespace acav {
 
#ifdef ACAV_ENABLE_STRING_STATS
struct TypeDeduplicationStats {
  std::size_t totalTypeLookups;      
  std::size_t cacheHits;             
  std::size_t uniqueTypeNodes;       
  std::size_t totalTypeReferences;   
  std::size_t estimatedSavedNodes;   
  std::size_t estimatedSavedBytes;   
  double deduplicationRatio;         
  double savingsPercent;             
};
#endif

using AcavJson =
    nlohmann::basic_json<std::map, std::vector, InternedString, bool, int64_t,
                         uint64_t, double, std::allocator,
                         nlohmann::adl_serializer, std::vector<uint8_t>>;
 
// Forward declarations
class AstNode;
class AstViewNode;

class AstContext {
public:
  AstContext() = default;
  ~AstContext();
 
  AstContext(const AstContext &) = delete;
  AstContext &operator=(const AstContext &) = delete;
  AstContext(AstContext &&) = delete;
  AstContext &operator=(AstContext &&) = delete;

  AstNode *createAstNode(AcavJson properties, const SourceRange &range);

  AstViewNode *createAstViewNode(AstNode *node);

  AstNode *getOrCreateTypeNode(const void *typePtr, AcavJson properties,
                                const SourceRange &range);

  AstNode *findTypeNode(const void *typePtr) const;

  void indexNode(AstViewNode *node);

  void finalizeLocationIndex();

  const SourceLocationIndex &getLocationIndex() const { return locationIndex_; }

  std::size_t getAstNodeCount() const { return allAstNodes_.size(); }
  std::size_t getAstViewNodeCount() const { return allAstViewNodes_.size(); }
 
#ifdef ACAV_ENABLE_STRING_STATS
  TypeDeduplicationStats getTypeDeduplicationStats() const;
  void printTypeDeduplicationStats(const char *label = nullptr) const;
#endif
 
private:
  std::vector<AstNode *> allAstNodes_;
  std::vector<AstViewNode *> allAstViewNodes_;

  std::unordered_map<const void *, AstNode *> typeDeduplicationMap_;

  SourceLocationIndex locationIndex_;
 
#ifdef ACAV_ENABLE_STRING_STATS
  mutable std::size_t typeLookupCount_ = 0;
  mutable std::size_t typeCacheHits_ = 0;
#endif
};

class AstNode {
public:
  const AcavJson &getProperties() const { return properties_; }
  AcavJson &getProperties() { return properties_; }
  const SourceRange &getSourceRange() const { return sourceRange_; }

  std::size_t getUseCount() const { return refCount_; }
  void hold() { ++refCount_; }
  void release() {
    if (refCount_ > 0)
      --refCount_;
  }
 
private:
  // Constructor is private - only AstContext can create nodes
  AstNode(AcavJson properties, const SourceRange &sourceRange);
  friend class AstContext;
 
  AcavJson properties_;    // Node metadata (kind, name, type, etc.)
  SourceRange sourceRange_;  // Source location
  std::size_t refCount_ = 0; // Number of AstViewNodes using this
};

class AstViewNode {
public:
  ~AstViewNode();
 
  AstViewNode(const AstViewNode &) = delete;
  AstViewNode &operator=(const AstViewNode &) = delete;
  AstViewNode(AstViewNode &&) = delete;
  AstViewNode &operator=(AstViewNode &&) = delete;

  AstNode *getNode() const { return node_; }
  AstViewNode *getParent() const { return parent_; }
  const std::vector<AstViewNode *> &getChildren() const { return children_; }

  void setParent(AstViewNode *parent) { parent_ = parent; }
  void addChild(AstViewNode *child);

  const AcavJson &getProperties() const { return node_->getProperties(); }
  const SourceRange &getSourceRange() const { return node_->getSourceRange(); }
 
private:
  // Constructor is private - only AstContext can create nodes
  explicit AstViewNode(AstNode *node);
  friend class AstContext;
 
  AstNode *node_;                       // Pointer to data (may be shared)
  AstViewNode *parent_ = nullptr;       // Parent in tree
  std::vector<AstViewNode *> children_; // Children in tree (owned)
};
 
} // namespace acav