File indexing completed on 2024-05-12 04:37:57

 /*
     SPDX-FileCopyrightText: 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "codemodel.h"
 
 #include "appendedlist.h"
 #include <debug.h>
 #include <serialization/itemrepository.h>
 #include "identifier.h"
 #include <serialization/indexedstring.h>
 #include <serialization/referencecounting.h>
 #include <util/embeddedfreetree.h>
 
 #define ifDebug(x)
 
 namespace KDevelop {
 class CodeModelItemHandler
 {
 public:
     static int leftChild(const CodeModelItem& m_data)
     {
         return ( int )m_data.referenceCount;
     }
     static void setLeftChild(CodeModelItem& m_data, int child)
     {
         m_data.referenceCount = ( uint )child;
     }
     static int rightChild(const CodeModelItem& m_data)
     {
         return ( int )m_data.uKind;
     }
     static void setRightChild(CodeModelItem& m_data, int child)
     {
         m_data.uKind = ( uint )child;
     }
     //Copies this item into the given one
     static void copyTo(const CodeModelItem& m_data, CodeModelItem& data)
     {
         data = m_data;
     }
 
     static void createFreeItem(CodeModelItem& data)
     {
         data = CodeModelItem();
         data.referenceCount = (uint) - 1;
         data.uKind = (uint) - 1;
     }
 
     static bool isFree(const CodeModelItem& m_data)
     {
         return !m_data.id.isValid();
     }
 
     static const CodeModelItem& data(const CodeModelItem& m_data)
     {
         return m_data;
     }
 
     static bool equals(const CodeModelItem& m_data, const CodeModelItem& rhs)
     {
         return m_data.id == rhs.id;
     }
 };
 
 DEFINE_LIST_MEMBER_HASH(CodeModelRepositoryItem, items, CodeModelItem)
 
 class CodeModelRepositoryItem
 {
 public:
     CodeModelRepositoryItem()
     {
         initializeAppendedLists();
     }
     CodeModelRepositoryItem(const CodeModelRepositoryItem& rhs, bool dynamic = true) : file(rhs.file)
         , centralFreeItem(rhs.centralFreeItem)
     {
         initializeAppendedLists(dynamic);
         copyListsFrom(rhs);
     }
 
     ~CodeModelRepositoryItem()
     {
         freeAppendedLists();
     }
 
     CodeModelRepositoryItem& operator=(const CodeModelRepositoryItem& rhs) = delete;
 
     unsigned int hash() const
     {
         //We only compare the declaration. This allows us implementing a map, although the item-repository
         //originally represents a set.
         return file.index();
     }
 
     uint itemSize() const
     {
         return dynamicSize();
     }
 
     uint classSize() const
     {
         return sizeof(CodeModelRepositoryItem);
     }
 
     IndexedString file;
     int centralFreeItem = -1;
 
     START_APPENDED_LISTS(CodeModelRepositoryItem);
     APPENDED_LIST_FIRST(CodeModelRepositoryItem, CodeModelItem, items);
     END_APPENDED_LISTS(CodeModelRepositoryItem, items);
 };
 
 class CodeModelRequestItem
 {
 public:
 
     CodeModelRequestItem(const CodeModelRepositoryItem& item) : m_item(item)
     {
     }
     enum {
         AverageSize = 30 //This should be the approximate average size of an Item
     };
 
     unsigned int hash() const
     {
         return m_item.hash();
     }
 
     uint itemSize() const
     {
         return m_item.itemSize();
     }
 
     void createItem(CodeModelRepositoryItem* item) const
     {
         Q_ASSERT(shouldDoDUChainReferenceCounting(item));
         Q_ASSERT(shouldDoDUChainReferenceCounting(reinterpret_cast<char*>(item) + (itemSize() - 1)));
         new (item) CodeModelRepositoryItem(m_item, false);
     }
 
     static void destroy(CodeModelRepositoryItem* item, KDevelop::AbstractItemRepository&)
     {
         Q_ASSERT(shouldDoDUChainReferenceCounting(item));
 //     Q_ASSERT(shouldDoDUChainReferenceCounting(((char*)item) + (itemSize()-1)));
         item->~CodeModelRepositoryItem();
     }
 
     static bool persistent(const CodeModelRepositoryItem* item)
     {
         Q_UNUSED(item);
         return true;
     }
 
     bool equals(const CodeModelRepositoryItem* item) const
     {
         return m_item.file == item->file;
     }
 
     const CodeModelRepositoryItem& m_item;
 };
 
 // Maps declaration-ids to items
 using CodeModelRepo = ItemRepository<CodeModelRepositoryItem, CodeModelRequestItem>;
 template <>
 class ItemRepositoryFor<CodeModel>
 {
     friend struct LockedItemRepository;
     static CodeModelRepo& repo()
     {
         static QMutex mutex;
         static CodeModelRepo repo(QStringLiteral("Code Model"), &mutex);
         return repo;
     }
 };
 
 CodeModel::CodeModel()
 {
     LockedItemRepository::initialize<CodeModel>();
 }
 
 void CodeModel::addItem(const IndexedString& file, const IndexedQualifiedIdentifier& id, CodeModelItem::Kind kind)
 {
     ifDebug(qCDebug(LANGUAGE) << "addItem" << file.str() << id.identifier().toString() << id.index; )
 
     if (!id.isValid())
         return;
     CodeModelRepositoryItem item;
     item.file = file;
     CodeModelRequestItem request(item);
 
     CodeModelItem newItem;
     newItem.id = id;
     newItem.kind = kind;
     newItem.referenceCount = 1;
 
     LockedItemRepository::write<CodeModel>([&](CodeModelRepo& repo) {
         uint index = repo.findIndex(item);
 
         if (index) {
             const CodeModelRepositoryItem* oldItem = repo.itemFromIndex(index);
             EmbeddedTreeAlgorithms<CodeModelItem, CodeModelItemHandler> alg(oldItem->items(), oldItem->itemsSize(),
                                                                             oldItem->centralFreeItem);
 
             int listIndex = alg.indexOf(newItem);
 
             DynamicItem<CodeModelRepositoryItem, true> editableItem = repo.dynamicItemFromIndex(index);
             auto* items = const_cast<CodeModelItem*>(editableItem->items());
 
             if (listIndex != -1) {
                 // Only update the reference-count
                 ++items[listIndex].referenceCount;
                 items[listIndex].kind = kind;
                 return;
             } else {
                 // Add the item to the list
                 EmbeddedTreeAddItem<CodeModelItem, CodeModelItemHandler> add(items, editableItem->itemsSize(),
                                                                              editableItem->centralFreeItem, newItem);
 
                 if (add.newItemCount() != editableItem->itemsSize()) {
                     // The data needs to be transferred into a bigger list. That list is within "item".
 
                     item.itemsList().resize(add.newItemCount());
                     add.transferData(item.itemsList().data(), item.itemsList().size(), &item.centralFreeItem);
 
                     repo.deleteItem(index);
                 } else {
                     // We're fine: The item fits into the existing list.
                     return;
                 }
             }
         } else {
             // We're creating a new index
             item.itemsList().append(newItem);
         }
 
         Q_ASSERT(!repo.findIndex(request));
 
         // This inserts the changed item
         const uint newIndex = repo.index(request);
         Q_UNUSED(newIndex);
         ifDebug(qCDebug(LANGUAGE) << "new index" << newIndex;)
 
         Q_ASSERT(repo.findIndex(request));
     });
 }
 
 void CodeModel::updateItem(const IndexedString& file, const IndexedQualifiedIdentifier& id, CodeModelItem::Kind kind)
 {
     ifDebug(qCDebug(LANGUAGE) << file.str() << id.identifier().toString() << kind; )
 
     if (!id.isValid())
         return;
 
     CodeModelRepositoryItem item;
     item.file = file;
     CodeModelRequestItem request(item);
 
     CodeModelItem newItem;
     newItem.id = id;
     newItem.kind = kind;
     newItem.referenceCount = 1;
 
     LockedItemRepository::write<CodeModel>([&](CodeModelRepo& repo) {
         uint index = repo.findIndex(item);
 
         if (index) {
             // Check whether the item is already in the mapped list, else copy the list into the new created item
             DynamicItem<CodeModelRepositoryItem, true> oldItem = repo.dynamicItemFromIndex(index);
 
             EmbeddedTreeAlgorithms<CodeModelItem, CodeModelItemHandler> alg(oldItem->items(), oldItem->itemsSize(),
                                                                             oldItem->centralFreeItem);
             int listIndex = alg.indexOf(newItem);
             Q_ASSERT(listIndex != -1);
 
             auto* items = const_cast<CodeModelItem*>(oldItem->items());
 
             Q_ASSERT(items[listIndex].id == id);
             items[listIndex].kind = kind;
 
             return;
         }
 
         Q_ASSERT(0); // The updated item as not in the symbol table!
     });
 }
 
 void CodeModel::removeItem(const IndexedString& file, const IndexedQualifiedIdentifier& id)
 {
     if (!id.isValid())
         return;
 
     ifDebug(qCDebug(LANGUAGE) << "removeItem" << file.str() << id.identifier().toString(); )
     CodeModelRepositoryItem item;
     item.file = file;
     CodeModelRequestItem request(item);
 
     LockedItemRepository::write<CodeModel>([&](CodeModelRepo& repo) {
         uint index = repo.findIndex(item);
 
         if (index) {
             CodeModelItem searchItem;
             searchItem.id = id;
 
             DynamicItem<CodeModelRepositoryItem, true> oldItem = repo.dynamicItemFromIndex(index);
 
             EmbeddedTreeAlgorithms<CodeModelItem, CodeModelItemHandler> alg(oldItem->items(), oldItem->itemsSize(),
                                                                             oldItem->centralFreeItem);
 
             int listIndex = alg.indexOf(searchItem);
             if (listIndex == -1)
                 return;
 
             auto* items = const_cast<CodeModelItem*>(oldItem->items());
 
             --items[listIndex].referenceCount;
 
             if (oldItem->items()[listIndex].referenceCount)
                 return; // Nothing to remove, there's still a reference-count left
 
             // We have reduced the reference-count to zero, so remove the item from the list
 
             EmbeddedTreeRemoveItem<CodeModelItem, CodeModelItemHandler> remove(items, oldItem->itemsSize(),
                                                                                oldItem->centralFreeItem, searchItem);
 
             uint newItemCount = remove.newItemCount();
             if (newItemCount != oldItem->itemsSize()) {
                 if (newItemCount == 0) {
                     // Has become empty, delete the item
                     repo.deleteItem(index);
 
                     return;
                 } else {
                     // Make smaller
                     item.itemsList().resize(newItemCount);
                     remove.transferData(item.itemsList().data(), item.itemsSize(), &item.centralFreeItem);
 
                     // Delete the old list
                     repo.deleteItem(index);
                     // Add the new list
                     repo.index(request);
                     return;
                 }
             }
         }
     });
 }
 
 // FIXME: this API is unsafe, we should return a KDevVarLengthArray of values instead
 void CodeModel::items(const IndexedString& file, uint& count, const CodeModelItem*& items) const
 {
     ifDebug(qCDebug(LANGUAGE) << "items" << file.str(); )
 
     CodeModelRepositoryItem item;
     item.file = file;
     CodeModelRequestItem request(item);
 
     LockedItemRepository::read<CodeModel>([&](const CodeModelRepo& repo) {
         uint index = repo.findIndex(item);
 
         if (index) {
             const CodeModelRepositoryItem* repositoryItem = repo.itemFromIndex(index);
             ifDebug(qCDebug(LANGUAGE) << "found index" << index << repositoryItem->itemsSize();)
             count = repositoryItem->itemsSize();
             items = repositoryItem->items();
         } else {
             ifDebug(qCDebug(LANGUAGE) << "found no index";)
             count = 0;
             items = nullptr;
         }
     });
 }
 
 CodeModel& CodeModel::self()
 {
     static CodeModel ret;
     return ret;
 }
 }