forked from qt-creator/qt-creator
2f3d2a2490
Makes it easier to add features to ClassOrNamespace without rebuilding half of the project. Change-Id: I7ac646e8ad08fc8da6f7ed43ff184fb17edbd6b7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
269 lines
8.9 KiB
C++
269 lines
8.9 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2015 The Qt Company Ltd.
|
|
** Contact: http://www.qt.io/licensing
|
|
**
|
|
** This file is part of Qt Creator.
|
|
**
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms and
|
|
** conditions see http://www.qt.io/terms-conditions. For further information
|
|
** use the contact form at http://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 2.1 or version 3 as published by the Free
|
|
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
|
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
|
** following information to ensure the GNU Lesser General Public License
|
|
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** In addition, as a special exception, The Qt Company gives you certain additional
|
|
** rights. These rights are described in The Qt Company LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef CPLUSPLUS_LOOKUPCONTEXT_H
|
|
#define CPLUSPLUS_LOOKUPCONTEXT_H
|
|
|
|
#include "CppDocument.h"
|
|
#include "LookupItem.h"
|
|
#include "AlreadyConsideredClassContainer.h"
|
|
|
|
#include <cplusplus/FullySpecifiedType.h>
|
|
#include <cplusplus/Type.h>
|
|
#include <cplusplus/SymbolVisitor.h>
|
|
#include <cplusplus/Control.h>
|
|
#include <cplusplus/Name.h>
|
|
|
|
#include <QSet>
|
|
#include <QMap>
|
|
|
|
#include <map>
|
|
#include <functional>
|
|
|
|
namespace CPlusPlus {
|
|
|
|
namespace Internal {
|
|
struct FullyQualifiedName
|
|
{
|
|
QList<const Name *> fqn;
|
|
|
|
FullyQualifiedName(const QList<const Name *> &fqn)
|
|
: fqn(fqn)
|
|
{}
|
|
};
|
|
class ClassOrNamespacePrivate;
|
|
class Instantiator;
|
|
} // namespace Internal;
|
|
|
|
class CreateBindings;
|
|
|
|
class CPLUSPLUS_EXPORT ClassOrNamespace
|
|
{
|
|
Q_DISABLE_COPY(ClassOrNamespace)
|
|
|
|
ClassOrNamespace(CreateBindings *factory, ClassOrNamespace *parent);
|
|
|
|
public:
|
|
~ClassOrNamespace();
|
|
|
|
ClassOrNamespace *instantiationOrigin() const;
|
|
|
|
ClassOrNamespace *parent() const;
|
|
QList<ClassOrNamespace *> usings() const;
|
|
QList<Enum *> unscopedEnums() const;
|
|
QList<Symbol *> symbols() const;
|
|
|
|
QList<LookupItem> lookup(const Name *name);
|
|
QList<LookupItem> find(const Name *name);
|
|
|
|
ClassOrNamespace *lookupType(const Name *name);
|
|
ClassOrNamespace *lookupType(const Name *name, Block *block);
|
|
ClassOrNamespace *findType(const Name *name);
|
|
ClassOrNamespace *findBlock(Block *block);
|
|
|
|
/// The class this ClassOrNamespace is based on.
|
|
Class *rootClass() const;
|
|
|
|
private:
|
|
Internal::ClassOrNamespacePrivate *d;
|
|
|
|
friend class Internal::ClassOrNamespacePrivate;
|
|
friend class Internal::Instantiator;
|
|
friend class CreateBindings;
|
|
};
|
|
|
|
class CPLUSPLUS_EXPORT CreateBindings: protected SymbolVisitor
|
|
{
|
|
Q_DISABLE_COPY(CreateBindings)
|
|
|
|
public:
|
|
CreateBindings(Document::Ptr thisDocument, const Snapshot &snapshot);
|
|
virtual ~CreateBindings();
|
|
|
|
/// Returns the binding for the global namespace.
|
|
ClassOrNamespace *globalNamespace() const;
|
|
|
|
/// Finds the binding associated to the given symbol.
|
|
ClassOrNamespace *lookupType(Symbol *symbol, ClassOrNamespace *enclosingBinding = 0);
|
|
ClassOrNamespace *lookupType(const QList<const Name *> &path,
|
|
ClassOrNamespace *enclosingBinding = 0);
|
|
|
|
/// Returns the Control that must be used to create temporary symbols.
|
|
/// \internal
|
|
QSharedPointer<Control> control() const
|
|
{ return _control; }
|
|
|
|
bool expandTemplates() const
|
|
{ return _expandTemplates; }
|
|
void setExpandTemplates(bool expandTemplates)
|
|
{ _expandTemplates = expandTemplates; }
|
|
|
|
/// Searches in \a scope for symbols with the given \a name.
|
|
/// Store the result in \a results.
|
|
/// \internal
|
|
void lookupInScope(const Name *name, Scope *scope, QList<LookupItem> *result,
|
|
ClassOrNamespace *binding = 0);
|
|
|
|
/// Create bindings for the symbols reachable from \a rootSymbol.
|
|
/// \internal
|
|
void process(Symbol *rootSymbol, ClassOrNamespace *classOrNamespace);
|
|
|
|
/// Create an empty ClassOrNamespace binding with the given \a parent.
|
|
/// \internal
|
|
ClassOrNamespace *allocClassOrNamespace(ClassOrNamespace *parent);
|
|
|
|
protected:
|
|
using SymbolVisitor::visit;
|
|
|
|
/// Change the current ClassOrNamespace binding.
|
|
ClassOrNamespace *switchCurrentClassOrNamespace(ClassOrNamespace *classOrNamespace);
|
|
|
|
/// Enters the ClassOrNamespace binding associated with the given \a symbol.
|
|
ClassOrNamespace *enterClassOrNamespaceBinding(Symbol *symbol);
|
|
|
|
/// Enters a ClassOrNamespace binding for the given \a symbol in the global
|
|
/// namespace binding.
|
|
ClassOrNamespace *enterGlobalClassOrNamespace(Symbol *symbol);
|
|
|
|
/// Creates bindings for the given \a document.
|
|
void process(Document::Ptr document);
|
|
|
|
/// Creates bindings for the symbols reachable from the \a root symbol.
|
|
void process(Symbol *root);
|
|
|
|
virtual bool visit(Template *templ);
|
|
virtual bool visit(Namespace *ns);
|
|
virtual bool visit(Class *klass);
|
|
virtual bool visit(ForwardClassDeclaration *klass);
|
|
virtual bool visit(Enum *e);
|
|
virtual bool visit(Declaration *decl);
|
|
virtual bool visit(Function *function);
|
|
virtual bool visit(Block *block);
|
|
|
|
virtual bool visit(BaseClass *b);
|
|
virtual bool visit(UsingNamespaceDirective *u);
|
|
virtual bool visit(UsingDeclaration *u);
|
|
virtual bool visit(NamespaceAlias *a);
|
|
|
|
virtual bool visit(ObjCClass *klass);
|
|
virtual bool visit(ObjCBaseClass *b);
|
|
virtual bool visit(ObjCForwardClassDeclaration *klass);
|
|
virtual bool visit(ObjCProtocol *proto);
|
|
virtual bool visit(ObjCBaseProtocol *b);
|
|
virtual bool visit(ObjCForwardProtocolDeclaration *proto);
|
|
virtual bool visit(ObjCMethod *);
|
|
|
|
private:
|
|
Symbol *instantiateTemplateFunction(const TemplateNameId *instantiation,
|
|
Template *specialization) const;
|
|
|
|
Snapshot _snapshot;
|
|
QSharedPointer<Control> _control;
|
|
QSet<Namespace *> _processed;
|
|
QList<ClassOrNamespace *> _entities;
|
|
ClassOrNamespace *_globalNamespace;
|
|
ClassOrNamespace *_currentClassOrNamespace;
|
|
bool _expandTemplates;
|
|
};
|
|
|
|
class CPLUSPLUS_EXPORT LookupContext
|
|
{
|
|
public:
|
|
LookupContext();
|
|
|
|
LookupContext(Document::Ptr thisDocument,
|
|
const Snapshot &snapshot);
|
|
|
|
LookupContext(Document::Ptr expressionDocument,
|
|
Document::Ptr thisDocument,
|
|
const Snapshot &snapshot,
|
|
QSharedPointer<CreateBindings> bindings = QSharedPointer<CreateBindings>());
|
|
|
|
LookupContext(const LookupContext &other);
|
|
LookupContext &operator = (const LookupContext &other);
|
|
|
|
Document::Ptr expressionDocument() const;
|
|
Document::Ptr thisDocument() const;
|
|
Document::Ptr document(const QString &fileName) const;
|
|
Snapshot snapshot() const;
|
|
|
|
ClassOrNamespace *globalNamespace() const;
|
|
|
|
QList<LookupItem> lookup(const Name *name, Scope *scope) const;
|
|
ClassOrNamespace *lookupType(const Name *name, Scope *scope,
|
|
ClassOrNamespace *enclosingBinding = 0,
|
|
QSet<const Declaration *> typedefsBeingResolved
|
|
= QSet<const Declaration *>()) const;
|
|
ClassOrNamespace *lookupType(Symbol *symbol,
|
|
ClassOrNamespace *enclosingBinding = 0) const;
|
|
ClassOrNamespace *lookupParent(Symbol *symbol) const;
|
|
|
|
/// \internal
|
|
QSharedPointer<CreateBindings> bindings() const
|
|
{ return _bindings; }
|
|
|
|
static QList<const Name *> fullyQualifiedName(Symbol *symbol);
|
|
static QList<const Name *> path(Symbol *symbol);
|
|
|
|
static const Name *minimalName(Symbol *symbol, ClassOrNamespace *target, Control *control);
|
|
|
|
void setExpandTemplates(bool expandTemplates)
|
|
{
|
|
if (_bindings)
|
|
_bindings->setExpandTemplates(expandTemplates);
|
|
m_expandTemplates = expandTemplates;
|
|
}
|
|
|
|
private:
|
|
QList<LookupItem> lookupByUsing(const Name *name, ClassOrNamespace *bindingScope) const;
|
|
|
|
// The current expression.
|
|
Document::Ptr _expressionDocument;
|
|
|
|
// The current document.
|
|
Document::Ptr _thisDocument;
|
|
|
|
// All documents.
|
|
Snapshot _snapshot;
|
|
|
|
// Bindings
|
|
QSharedPointer<CreateBindings> _bindings;
|
|
|
|
bool m_expandTemplates;
|
|
};
|
|
|
|
bool CPLUSPLUS_EXPORT compareFullyQualifiedName(const QList<const Name *> &path,
|
|
const QList<const Name *> &other);
|
|
|
|
|
|
} // namespace CPlusPlus
|
|
|
|
#endif // CPLUSPLUS_LOOKUPCONTEXT_H
|