LookupContext.h 9.59 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
hjk's avatar
hjk committed
3 4
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
7
**
hjk's avatar
hjk committed
8 9 10 11 12 13 14
** 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 Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
15 16
**
** GNU Lesser General Public License Usage
hjk's avatar
hjk committed
17 18 19 20 21 22 23 24 25
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
con's avatar
con committed
26 27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
hjk's avatar
hjk committed
28
****************************************************************************/
29 30 31 32 33 34 35 36 37

#ifndef CPLUSPLUS_LOOKUPCONTEXT_H
#define CPLUSPLUS_LOOKUPCONTEXT_H

#include "CppDocument.h"
#include "LookupItem.h"
#include <FullySpecifiedType.h>
#include <Type.h>
#include <SymbolVisitor.h>
38
#include <Control.h>
39
#include <Name.h>
40
#include <QSet>
41 42
#include <map>
#include <functional>
43 44 45 46

namespace CPlusPlus {

class CreateBindings;
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
class Class;
template<typename T>
class AlreadyConsideredClassContainer
{
public:
    AlreadyConsideredClassContainer() : _class(0) {}
    void insert(const T *item)
    {
        if (_container.isEmpty())
            _class = item;
        _container.insert(item);
    }
    bool contains(const T *item)
    {
        return _container.contains(item);
    }

    void clear(const T *item)
    {
        if (_class != item)
            _container.clear();
    }

private:
    QSet<const T *> _container;
    const T * _class;
};
74 75 76 77 78 79

class CPLUSPLUS_EXPORT ClassOrNamespace
{
public:
    ClassOrNamespace(CreateBindings *factory, ClassOrNamespace *parent);

80
    const TemplateNameId *templateId() const;
81 82
    ClassOrNamespace *instantiationOrigin() const;

83
    ClassOrNamespace *parent() const;
84 85 86 87 88 89
    QList<ClassOrNamespace *> usings() const;
    QList<Enum *> enums() const;
    QList<Symbol *> symbols() const;

    ClassOrNamespace *globalNamespace() const;

90 91
    QList<LookupItem> lookup(const Name *name);
    QList<LookupItem> find(const Name *name);
92

93 94
    ClassOrNamespace *lookupType(const Name *name);
    ClassOrNamespace *findType(const Name *name);
95 96 97 98 99 100

private:
    /// \internal
    void flush();

    /// \internal
101
    ClassOrNamespace *findOrCreateType(const Name *name, ClassOrNamespace *origin = 0);
102

103 104 105 106
    void addTodo(Symbol *symbol);
    void addSymbol(Symbol *symbol);
    void addEnum(Enum *e);
    void addUsing(ClassOrNamespace *u);
Roberto Raggi's avatar
Roberto Raggi committed
107
    void addNestedType(const Name *alias, ClassOrNamespace *e);
108

109
    QList<LookupItem> lookup_helper(const Name *name, bool searchInEnclosingScope);
110

111
    void lookup_helper(const Name *name, ClassOrNamespace *binding,
112 113 114
                       QList<LookupItem> *result,
                       QSet<ClassOrNamespace *> *processed,
                       const TemplateNameId *templateId);
115

116
    ClassOrNamespace *lookupType_helper(const Name *name, QSet<ClassOrNamespace *> *processed,
117
                                        bool searchInEnclosingScope, ClassOrNamespace *origin);
118

119
    ClassOrNamespace *nestedType(const Name *name, ClassOrNamespace *origin);
120

121
private:
122
    typedef std::map<const Name *, ClassOrNamespace *, Name::Compare> Table;
123 124 125 126
    CreateBindings *_factory;
    ClassOrNamespace *_parent;
    QList<Symbol *> _symbols;
    QList<ClassOrNamespace *> _usings;
127
    Table _classOrNamespaces;
128 129
    QList<Enum *> _enums;
    QList<Symbol *> _todo;
130
    QSharedPointer<Control> _control;
131

132 133
    // it's an instantiation.
    const TemplateNameId *_templateId;
134
    ClassOrNamespace *_instantiationOrigin;
135

136 137 138
    AlreadyConsideredClassContainer<Class> _alreadyConsideredClasses;
    AlreadyConsideredClassContainer<TemplateNameId> _alreadyConsideredTemplates;

139 140 141 142 143 144 145 146
    friend class CreateBindings;
};

class CPLUSPLUS_EXPORT CreateBindings: protected SymbolVisitor
{
    Q_DISABLE_COPY(CreateBindings)

public:
147
    CreateBindings(Document::Ptr thisDocument, const Snapshot &snapshot, QSharedPointer<Control> control);
148 149
    virtual ~CreateBindings();

150
    /// Returns the binding for the global namespace.
151 152
    ClassOrNamespace *globalNamespace() const;

153
    /// Finds the binding associated to the given symbol.
Roberto Raggi's avatar
Roberto Raggi committed
154
    ClassOrNamespace *lookupType(Symbol *symbol);
155
    ClassOrNamespace *lookupType(const QList<const Name *> &path);
156 157

    /// Returns the Control that must be used to create temporary symbols.
158
    /// \internal
159
    QSharedPointer<Control> control() const;
160

161 162 163 164 165
    bool expandTemplates() const
    { return _expandTemplates; }
    void setExpandTemplates(bool expandTemplates)
    { _expandTemplates = expandTemplates; }

166 167
    /// Searches in \a scope for symbols with the given \a name.
    /// Store the result in \a results.
168
    /// \internal
169 170
    void lookupInScope(const Name *name, Scope *scope, QList<LookupItem> *result,
                            const TemplateNameId *templateId, ClassOrNamespace *binding);
171

172
    /// Create bindings for the symbols reachable from \a rootSymbol.
173
    /// \internal
174
    void process(Symbol *rootSymbol, ClassOrNamespace *classOrNamespace);
175

176
    /// Create an empty ClassOrNamespace binding with the given \a parent.
177
    /// \internal
Roberto Raggi's avatar
Roberto Raggi committed
178
    ClassOrNamespace *allocClassOrNamespace(ClassOrNamespace *parent);
179

180 181 182
protected:
    using SymbolVisitor::visit;

183
    /// Change the current ClassOrNamespace binding.
Roberto Raggi's avatar
Roberto Raggi committed
184
    ClassOrNamespace *switchCurrentClassOrNamespace(ClassOrNamespace *classOrNamespace);
185

186 187 188 189 190 191 192 193 194 195 196 197
    /// 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);
198

199
    virtual bool visit(Template *templ);
200 201 202 203 204 205 206 207
    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 *);
    virtual bool visit(BaseClass *b);
    virtual bool visit(UsingNamespaceDirective *u);
Roberto Raggi's avatar
Roberto Raggi committed
208
    virtual bool visit(UsingDeclaration *u);
209 210 211 212 213 214 215 216 217 218 219 220
    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:
    Snapshot _snapshot;
221
    QSharedPointer<Control> _control;
222 223 224 225
    QSet<Namespace *> _processed;
    QList<ClassOrNamespace *> _entities;
    ClassOrNamespace *_globalNamespace;
    ClassOrNamespace *_currentClassOrNamespace;
226
    bool _expandTemplates;
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
};

class CPLUSPLUS_EXPORT LookupContext
{
public:
    LookupContext();

    LookupContext(Document::Ptr thisDocument,
                  const Snapshot &snapshot);

    LookupContext(Document::Ptr expressionDocument,
                  Document::Ptr thisDocument,
                  const Snapshot &snapshot);

    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;

251
    QList<LookupItem> lookup(const Name *name, Scope *scope) const;
252 253
    ClassOrNamespace *lookupType(const Name *name, Scope *scope) const;
    ClassOrNamespace *lookupType(Symbol *symbol) const;
254
    ClassOrNamespace *lookupParent(Symbol *symbol) const;
255 256 257 258 259 260 261

    /// \internal
    QSharedPointer<CreateBindings> bindings() const;

    /// \internal
    void setBindings(QSharedPointer<CreateBindings> bindings);

262
    QSharedPointer<Control> control() const; // ### deprecate
263

264
    static QList<const Name *> fullyQualifiedName(Symbol *symbol);
265
    static QList<const Name *> path(Symbol *symbol);
266

267
    static const Name *minimalName(Symbol *symbol, ClassOrNamespace *target, Control *control);
268

269 270 271
    void setExpandTemplates(bool expandTemplates)
    { m_expandTemplates = expandTemplates; }

272 273 274 275 276 277 278 279 280 281 282 283
private:
    // The current expression.
    Document::Ptr _expressionDocument;

    // The current document.
    Document::Ptr _thisDocument;

    // All documents.
    Snapshot _snapshot;

    // Bindings
    mutable QSharedPointer<CreateBindings> _bindings;
284 285

    QSharedPointer<Control> _control;
286 287

    bool m_expandTemplates;
288 289
};

290
bool CPLUSPLUS_EXPORT compareName(const Name *name, const Name *other);
291 292 293 294
bool CPLUSPLUS_EXPORT compareFullyQualifiedName(const QList<const Name *> &path,
                                                const QList<const Name *> &other);


295
} // namespace CPlusPlus
296 297

#endif // CPLUSPLUS_LOOKUPCONTEXT_H