ducontext.h

Go to the documentation of this file.

/* This file is part of KDevelop
    Copyright 2006 Hamish Rodda <[email protected]>
    Copyright 2007-2009 David Nolden <[email protected]>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
#ifndef KDEVPLATFORM_DUCONTEXT_H
#define KDEVPLATFORM_DUCONTEXT_H
 
#include <QHash>
#include <QList>
#include <QSet>
#include <QVector>
 
#include <util/kdevvarlengtharray.h>
 
#include "identifier.h"
#include "duchainbase.h"
#include "types/abstracttype.h"
#include "duchainpointer.h"
#include "declarationid.h"
#include "indexedducontext.h"
 
#include "navigation/abstractnavigationwidget.h"
 
class QWidget;
 
namespace KDevelop {
class Declaration;
class DUChain;
class Use;
class TopDUContext;
class DUContext;
class DUContextData;
 
class KDEVPLATFORMLANGUAGE_EXPORT DUChainVisitor
{
public:
    virtual void visit(DUContext* context) = 0;
    virtual void visit(Declaration* declaration) = 0;
    virtual ~DUChainVisitor();
};
 
using DUContextPointer = DUChainPointer<DUContext>;
 
class KDEVPLATFORMLANGUAGE_EXPORT DUContext
    : public DUChainBase
{
    friend class Use;
    friend class Declaration;
    friend class DeclarationData;
    friend class DUContextData;
    friend class DUContextDynamicData;
    friend class Definition;
    friend class VisibleDeclarationIterator;
 
public:
    explicit DUContext(const RangeInRevision& range, DUContext* parent = nullptr, bool anonymous = false);
    explicit DUContext(DUContextData&);
 
    ~DUContext() override;
 
    DUContext& operator=(const DUContext& rhs) = delete;
 
    enum ContextType : quint8 {
        Global ,
        Namespace ,
        Class ,
        Function ,
        Template ,
        Enum ,
        Helper    ,
        Other 
    };
 
    enum SearchFlag {
        NoSearchFlags = 0 ,
        InImportedParentContext = 1 ,
        OnlyContainerTypes = 2 ,
        DontSearchInParent =
            4 ,
        NoUndefinedTemplateParams =
            8 ,
        DirectQualifiedLookup =
            16 ,
        NoFiltering =
            32 ,
        OnlyFunctions =
            64 ,
        NoImportsCheck =
            128 ,
        NoSelfLookUp =
            256 ,
        DontResolveAliases = 512 ,
        LastSearchFlag = 1024
    };
 
    Q_DECLARE_FLAGS(SearchFlags, SearchFlag)
 
    ContextType type() const;
    void setType(ContextType type);
 
    Declaration* owner() const;
    void setOwner(Declaration* decl);
 
    int depth() const;
 
    TopDUContext* topContext() const override;
 
    virtual void visit(DUChainVisitor& visitor);
 
    DUContext* findContextAt(const CursorInRevision& position, bool includeBorders = false) const;
 
    Declaration* findDeclarationAt(const CursorInRevision& position) const;
 
    DUContext* findContextIncluding(const RangeInRevision& range) const;
 
    QualifiedIdentifier scopeIdentifier(bool includeClasses = false) const;
 
    bool equalScopeIdentifier(const DUContext* rhs) const;
 
    QualifiedIdentifier localScopeIdentifier() const;
 
    IndexedQualifiedIdentifier indexedLocalScopeIdentifier() const;
 
    void setLocalScopeIdentifier(const QualifiedIdentifier& identifier);
 
    bool inSymbolTable() const;
 
    void setInSymbolTable(bool inSymbolTable);
 
    DUContext* parentContext() const;
 
    struct KDEVPLATFORMLANGUAGE_EXPORT Import
    {
        Import(DUContext* context, const DUContext* importer,
               const CursorInRevision& position = CursorInRevision::invalid());
        Import() : position(CursorInRevision::invalid()) { }
        explicit Import(const DeclarationId& id, const CursorInRevision& position = CursorInRevision::invalid());
 
        bool operator==(const Import& rhs) const
        {
            return m_context == rhs.m_context && m_declaration == rhs.m_declaration;
        }
 
        DUContext* context(const TopDUContext* topContext, bool instantiateIfRequired = true) const;
 
        uint topContextIndex() const
        {
            return m_context.topContextIndex();
        }
 
        IndexedDUContext indexedContext() const
        {
            return m_context;
        }
 
        bool isDirect() const;
 
        DeclarationId indirectDeclarationId() const
        {
            return m_declaration;
        }
 
        CursorInRevision position;
 
private:
        //Either we store m_declaration, or m_context. That way we can resolve specialized contexts.
        DeclarationId m_declaration;
        IndexedDUContext m_context;
    };
 
    virtual QVector<Import> importedParentContexts() const;
 
    virtual CursorInRevision importPosition(const DUContext* target) const;
 
    virtual bool imports(const DUContext* origin,
                         const CursorInRevision& position = CursorInRevision::invalid()) const;
 
    virtual void addImportedParentContext(DUContext* context,
                                          const CursorInRevision& position = CursorInRevision::invalid(),
                                          bool anonymous = false, bool temporary = false);
 
    bool addIndirectImport(const DUContext::Import& import);
 
    virtual void removeImportedParentContext(DUContext* context);
 
    virtual void clearImportedParentContexts();
 
    void setPropagateDeclarations(bool propagate);
 
    bool isPropagateDeclarations() const;
 
    virtual QVector<DUContext*> importers() const;
 
    KDevVarLengthArray<IndexedDUContext> indexedImporters() const;
 
    QVector<DUContext*> childContexts() const;
 
    void deleteChildContextsRecursively();
 
    void resortChildContexts();
 
    virtual bool inDUChain() const;
 
    virtual DUContext* specialize(const IndexedInstantiationInformation& specialization,
                                  const TopDUContext* topContext, int upDistance = 0);
 
    QList<Declaration*> findDeclarations(const QualifiedIdentifier& identifier,
                                         const CursorInRevision& position = CursorInRevision::invalid(),
                                         const AbstractType::Ptr& dataType = AbstractType::Ptr(),
                                         const TopDUContext* topContext = nullptr,
                                         SearchFlags flags = NoSearchFlags) const;
 
    QList<Declaration*> findDeclarations(const IndexedIdentifier& identifier,
                                         const CursorInRevision& position = CursorInRevision::invalid(),
                                         const TopDUContext* topContext = nullptr,
                                         SearchFlags flags = NoSearchFlags) const;
 
    QList<Declaration*> findDeclarations(const Identifier& identifier,
                                         const CursorInRevision& position = CursorInRevision::invalid(),
                                         const TopDUContext* topContext = nullptr,
                                         SearchFlags flags = NoSearchFlags) const;
 
    QList<Declaration*> findLocalDeclarations(const IndexedIdentifier& identifier,
                                              const CursorInRevision& position = CursorInRevision::invalid(),
                                              const TopDUContext* topContext = nullptr,
                                              const AbstractType::Ptr& dataType = AbstractType::Ptr(),
                                              SearchFlags flags = NoSearchFlags) const;
 
    QList<Declaration*> findLocalDeclarations(const Identifier& identifier,
                                              const CursorInRevision& position = CursorInRevision::invalid(),
                                              const TopDUContext* topContext = nullptr,
                                              const AbstractType::Ptr& dataType = AbstractType::Ptr(),
                                              SearchFlags flags = NoSearchFlags) const;
 
    QVector<Declaration*> clearLocalDeclarations();
 
    void deleteLocalDeclarations();
 
    virtual QVector<Declaration*> localDeclarations(const TopDUContext* source = nullptr) const;
 
    void resortLocalDeclarations();
 
    DUContext* findContext(const CursorInRevision& position, DUContext* parent = nullptr) const;
 
    bool parentContextOf(DUContext* context) const;
 
    QVector<QPair<Declaration*, int>> allDeclarations(const CursorInRevision& position,
                                                      const TopDUContext* topContext,
                                                      bool searchInParents = true) const;
 
    void cleanIfNotEncountered(const QSet<DUChainBase*>& encountered);
 
    const Use* uses() const;
 
    int usesCount() const;
 
    static bool declarationHasUses(Declaration* decl);
 
    int findUseAt(const CursorInRevision& position) const;
 
    void changeUseRange(int useIndex, const RangeInRevision& range);
 
    void setUseDeclaration(int useIndex, int declarationIndex);
 
    int createUse(int declarationIndex, const RangeInRevision& range, int insertBefore = -1);
 
    void deleteUse(int index);
 
    virtual void deleteUses();
 
    virtual void deleteUsesRecursively();
 
    virtual AbstractNavigationWidget*
    createNavigationWidget(Declaration* decl = nullptr, TopDUContext* topContext = nullptr,
                           AbstractNavigationWidget::DisplayHints hints = AbstractNavigationWidget::NoHints) const;
 
    enum {
        Identity = 2
    };
 
    struct KDEVPLATFORMLANGUAGE_EXPORT SearchItem
        : public QSharedData
    {
        using Ptr = QExplicitlySharedDataPointer<SearchItem>;
        using PtrList = KDevVarLengthArray<Ptr, 256>;
 
        explicit SearchItem(const QualifiedIdentifier& id, const Ptr& nextItem = Ptr(), int start = 0);
 
        SearchItem(const QualifiedIdentifier& id, const PtrList& nextItems, int start = 0);
 
        SearchItem(bool explicitlyGlobal, const IndexedIdentifier& id, const PtrList& nextItems);
        SearchItem(bool explicitlyGlobal, const IndexedIdentifier& id, const Ptr& nextItem);
 
        bool isEmpty() const;
        bool hasNext() const;
 
        void addToEachNode(const Ptr& item);
        void addToEachNode(const PtrList& items);
 
        bool match(const QualifiedIdentifier& id, int offset = 0) const;
 
        QVector<QualifiedIdentifier> toList(const QualifiedIdentifier& prefix = QualifiedIdentifier()) const;
 
        void addNext(const Ptr& other);
 
        bool isExplicitlyGlobal;
        IndexedIdentifier identifier;
        PtrList next;
    };
 
 
 
    using DeclarationList = QList<Declaration*>;
 
    virtual bool findDeclarationsInternal(const SearchItem::PtrList& identifiers,
                                          const CursorInRevision& position, const AbstractType::Ptr& dataType,
                                          DeclarationList& ret, const TopDUContext* source, SearchFlags flags,
                                          uint depth) const;
 
    QVector<QualifiedIdentifier> fullyApplyAliases(const QualifiedIdentifier& id,
                                                   const TopDUContext* source) const;
 
protected:
 
    virtual bool foundEnough(const DeclarationList& decls, SearchFlags flags) const;
 
    virtual void mergeDeclarationsInternal(QVector<QPair<Declaration*, int>>& definitions,
                                           const CursorInRevision& position,
                                           QHash<const DUContext*, bool>& hadContexts,
                                           const TopDUContext* source,
                                           bool searchInParents = true, int currentDepth = 0) const;
 
    void findLocalDeclarationsInternal(const Identifier& identifier,
                                       const CursorInRevision& position,
                                       const AbstractType::Ptr& dataType,
                                       DeclarationList& ret,
                                       const TopDUContext* source,
                                       SearchFlags flags) const;
 
    virtual void findLocalDeclarationsInternal(const IndexedIdentifier& identifier,
                                               const CursorInRevision& position,
                                               const AbstractType::Ptr& dataType,
                                               DeclarationList& ret,
                                               const TopDUContext* source,
                                               SearchFlags flags) const;
 
    void applyAliases(const SearchItem::PtrList& identifiers, SearchItem::PtrList& targetIdentifiers,
                      const CursorInRevision& position, bool canBeNamespace, bool onlyImports = false) const;
    virtual void applyUpwardsAliases(SearchItem::PtrList& identifiers, const TopDUContext* source) const;
 
    DUContext(DUContextData& dd, const RangeInRevision& range, DUContext* parent = nullptr, bool anonymous = false);
 
    DUContext(DUContext& useDataFrom);
 
    bool isAnonymous() const;
 
    virtual bool shouldSearchInParent(SearchFlags flags) const;
 
private:
    void initFromTopContext();
    void rebuildDynamicData(DUContext* parent, uint ownIndex) override;
 
    friend class TopDUContext;
    friend class IndexedDUContext;
    friend class LocalIndexedDUContext;
    friend class TopDUContextDynamicData;
 
    DUCHAIN_DECLARE_DATA(DUContext)
    class DUContextDynamicData* m_dynamicData;
};
 
KDEVPLATFORMLANGUAGE_EXPORT const Identifier& globalImportIdentifier();
 
KDEVPLATFORMLANGUAGE_EXPORT const Identifier& globalAliasIdentifier();
 
KDEVPLATFORMLANGUAGE_EXPORT const IndexedIdentifier& globalIndexedImportIdentifier();
 
KDEVPLATFORMLANGUAGE_EXPORT const IndexedIdentifier& globalIndexedAliasIdentifier();
 
KDEVPLATFORMLANGUAGE_EXPORT QVector<RangeInRevision> allUses(DUContext* context,
                                                             int declarationIndex,
                                                             bool noEmptyRanges = false);
}
 
Q_DECLARE_TYPEINFO(KDevelop::DUContext::Import, Q_MOVABLE_TYPE);
 
KDEVPLATFORMLANGUAGE_EXPORT QDebug operator<<(QDebug dbg, const KDevelop::DUContext::Import& import);
 
#endif // KDEVPLATFORM_DUCONTEXT_H