topducontext.h

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2006 Hamish Rodda <[email protected]>
    SPDX-FileCopyrightText: 2007-2009 David Nolden <[email protected]>
 
    SPDX-License-Identifier: LGPL-2.0-only
*/
 
#ifndef KDEVPLATFORM_TOPDUCONTEXT_H
#define KDEVPLATFORM_TOPDUCONTEXT_H
 
#include "ducontext.h"
#include <language/util/setrepository.h>
#include <QMetaType>
 
template <class T>
class QExplicitlySharedDataPointer;
 
namespace KDevelop {
class IAstContainer;
class QualifiedIdentifier;
class DUChain;
class ParsingEnvironmentFile;
class TopDUContextData;
class TopDUContextLocalPrivate;
class IndexedTopDUContext;
//   class TopDUContextDynamicData;
class Problem;
class DeclarationChecker;
class TopDUContext;
 
struct KDEVPLATFORMLANGUAGE_EXPORT RecursiveImportRepository
{
    static Utils::BasicSetRepository* repository();
};
 
using RecursiveImports = QHash<const TopDUContext*, QPair<int, const TopDUContext*>>;
 
using TopDUContextPointer = DUChainPointer<TopDUContext>;
 
using ProblemPointer = QExplicitlySharedDataPointer<Problem>;
 
class KDEVPLATFORMLANGUAGE_EXPORT ReferencedTopDUContext
{
public:
    ReferencedTopDUContext(TopDUContext* context = nullptr);
    ReferencedTopDUContext(const ReferencedTopDUContext& rhs);
    ~ReferencedTopDUContext();
 
    ReferencedTopDUContext& operator=(const ReferencedTopDUContext& rhs);
 
    inline TopDUContext* data() const
    {
        return m_topContext;
    }
 
    inline operator TopDUContext*() const {
        return m_topContext;
    }
 
    inline bool operator==(const ReferencedTopDUContext& rhs) const
    {
        return m_topContext == rhs.m_topContext;
    }
 
    inline bool operator!=(const ReferencedTopDUContext& rhs) const
    {
        return m_topContext != rhs.m_topContext;
    }
 
    inline TopDUContext* operator->() const
    {
        return m_topContext;
    }
 
    inline uint hash() const
    {
        return ( uint )((( quint64 )m_topContext) * 37);
    }
 
private:
    TopDUContext* m_topContext;
};
 
class KDEVPLATFORMLANGUAGE_EXPORT TopDUContext
    : public DUContext
{
public:
    explicit TopDUContext(const IndexedString& url, const RangeInRevision& range,
                          ParsingEnvironmentFile* file = nullptr);
    explicit TopDUContext(TopDUContextData& data);
 
    TopDUContext& operator=(const TopDUContext& rhs) = delete;
 
    TopDUContext* topContext() const override;
 
    IndexedTopDUContext indexed() const;
 
    uint ownIndex() const;
 
    IndexedString url() const override;
 
    QExplicitlySharedDataPointer<ParsingEnvironmentFile> parsingEnvironmentFile() const;
 
    bool deleting() const;
 
    bool inDUChain() const override;
    void setInDuChain(bool);
 
    bool isOnDisk() const;
 
    QList<ProblemPointer> problems() const;
 
    void addProblem(const ProblemPointer& problem);
 
    void clearProblems();
 
    void setProblems(const QList<ProblemPointer>& pointers);
 
    bool imports(const DUContext* origin, const CursorInRevision& position) const override;
 
    enum {
        Identity = 4
    };
 
    enum Feature : quint16 {
        Empty = 0, //Only the top-context structure (imports etc.) is built, but no declarations and no contexts
        SimplifiedVisibleDeclarationsAndContexts = 2, //The top-context should only contain publically simplified accessible declarations and contexts, without doing type look-up,
        //without extended information like function-argument declarations, etc., imported contexts can be parsed with 'Empty' features
        //This flag essentially leads to a ctags-like processing level.
        VisibleDeclarationsAndContexts = SimplifiedVisibleDeclarationsAndContexts + 4, //Default: The top-context should only contain publically accessible declarations and contexts
        AllDeclarationsAndContexts = VisibleDeclarationsAndContexts + 8, //The top-context should also contain non-public declarations and contexts, but no uses
        AllDeclarationsContextsAndUses = 16 + AllDeclarationsAndContexts, //The top-context should contain uses and all declarations + contexts
        AST = 32,         //Signalizes that the ast() should be filled
        AllDeclarationsContextsUsesAndAST = AST | AllDeclarationsContextsAndUses, //Convenience flag, combining AST and AllDeclarationsContextsAndUses
 
        Recursive = 64, //Request the given features on all recursively imported contexts. Only the features are applied recursively (including AST)
        ForceUpdate = 128, //Enforce updating the top-context
        ForceUpdateRecursive = ForceUpdate | 256, //Enforce updating the top-context and all its imports
 
        LastFeature = 512
    };
    Q_DECLARE_FLAGS(Features, Feature)
 
    
    Features features() const;
    void setFeatures(Features);
 
    int indexForUsedDeclaration(Declaration* declaration, bool create = true);
 
    Declaration* usedDeclarationForIndex(unsigned int declarationIndex) const;
 
    void clearUsedDeclarationIndices();
 
    void deleteUsesRecursively() override;
 
    QExplicitlySharedDataPointer<IAstContainer> ast() const;
 
    void setAst(const QExplicitlySharedDataPointer<IAstContainer>& ast);
 
    void clearAst();
 
    void addImportedParentContext(DUContext* context,
                                  const CursorInRevision& position = CursorInRevision(), bool anonymous = false,
                                  bool temporary = false) override;
    virtual void addImportedParentContexts(const QVector<QPair<TopDUContext*, CursorInRevision>>& contexts,
                                           bool temporary = false);
 
    void removeImportedParentContext(DUContext* context) override;
    virtual void removeImportedParentContexts(const QList<TopDUContext*>& contexts);
 
    void clearImportedParentContexts() override;
 
    using IndexedRecursiveImports = Utils::StorableSet<IndexedTopDUContext, IndexedTopDUContextIndexConversion, RecursiveImportRepository,
        true>;
 
    QVector<Import> importedParentContexts() const override;
 
    QVector<DUContext*> importers() const override;
 
    virtual QList<DUContext*> loadedImporters() const;
 
    CursorInRevision importPosition(const DUContext* target) const override;
 
    const IndexedRecursiveImports& recursiveImportIndices() const;
 
    void updateImportsCache();
 
    bool usingImportsCache() const;
 
    bool findDeclarationsInternal(const SearchItem::PtrList& identifiers, const CursorInRevision& position,
                                  const AbstractType::Ptr& dataType, DeclarationList& ret, const TopDUContext* source,
                                  SearchFlags flags, uint depth) const override;
 
protected:
    void setParsingEnvironmentFile(ParsingEnvironmentFile*);
 
    template <class Acceptor>
    void applyAliases(const SearchItem::PtrList& identifiers, Acceptor& accept, const CursorInRevision& position,
                      bool canBeNamespace) const;
 
protected:
    ~TopDUContext() override;
 
    void clearFeaturesSatisfied();
    void rebuildDynamicData(DUContext* parent, uint ownIndex) override;
    //Must be called after all imported top-contexts were loaded into the du-chain
    void rebuildDynamicImportStructure();
 
    struct AliasChainElement;
    struct FindDeclarationsAcceptor;
    struct DeclarationChecker;
    struct ApplyAliasesBuddyInfo;
 
    template <class Acceptor>
    bool applyAliases(const QualifiedIdentifier& previous, const SearchItem::Ptr& identifier, Acceptor& acceptor,
                      const CursorInRevision& position, bool canBeNamespace, ApplyAliasesBuddyInfo* buddy,
                      uint recursionDepth) const;
    //Same as imports, without the slow access-check, for internal usage
    bool importsPrivate(const DUContext* origin, const CursorInRevision& position) const;
    DUCHAIN_DECLARE_DATA(TopDUContext)
 
    
    void deleteSelf();
 
    //Most of these classes need access to m_dynamicData
    friend class DUChain;
    friend class DUChainPrivate;
    friend class TopDUContextData;
    friend class TopDUContextLocalPrivate;
    friend class TopDUContextDynamicData;
    friend class Declaration;
    friend class DUContext;
    friend class Problem;
    friend class IndexedDeclaration;
    friend class IndexedDUContext;
    friend class LocalIndexedDeclaration;
    friend class LocalIndexedDUContext;
    friend class LocalIndexedProblem;
    friend class DeclarationId;
    friend class ParsingEnvironmentFile;
 
    TopDUContextLocalPrivate* m_local;
 
    class TopDUContextDynamicData* m_dynamicData;
};
 
KDEVPLATFORMLANGUAGE_EXPORT QVector<RangeInRevision> allUses(TopDUContext* context, Declaration* declaration,
                                                             bool noEmptyRanges = false);
 
inline uint qHash(const ReferencedTopDUContext& ctx)
{
    return ctx.hash();
}
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
Q_DECLARE_OPERATORS_FOR_FLAGS(TopDUContext::Features)
#endif
 
}
 
#if QT_VERSION < QT_VERSION_CHECK(5, 12, 0)
Q_DECLARE_OPERATORS_FOR_FLAGS(KDevelop::TopDUContext::Features)
#endif
 
Q_DECLARE_TYPEINFO(KDevelop::ReferencedTopDUContext, Q_MOVABLE_TYPE);
Q_DECLARE_METATYPE(KDevelop::ReferencedTopDUContext)
 
#endif // KDEVPLATFORM_TOPDUCONTEXT_H