LookupContext.h 11.5 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
2
**
3
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
hjk's avatar
hjk committed
4
** 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

#ifndef CPLUSPLUS_LOOKUPCONTEXT_H
#define CPLUSPLUS_LOOKUPCONTEXT_H

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

namespace CPlusPlus {

48
49
50
51
52
53
54
55
56
57
58
namespace Internal {
struct FullyQualifiedName
{
    QList<const Name *> fqn;

    FullyQualifiedName(const QList<const Name *> &fqn)
        : fqn(fqn)
    {}
};
} // namespace Internal;

59
60
61
62
63
64
class CreateBindings;

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

67
    const TemplateNameId *templateId() const;
68
69
    ClassOrNamespace *instantiationOrigin() const;

70
    ClassOrNamespace *parent() const;
71
    QList<ClassOrNamespace *> usings() const;
72
    QList<Enum *> unscopedEnums() const;
73
74
75
76
    QList<Symbol *> symbols() const;

    ClassOrNamespace *globalNamespace() const;

77
78
    QList<LookupItem> lookup(const Name *name);
    QList<LookupItem> find(const Name *name);
79

80
81
    ClassOrNamespace *lookupType(const Name *name);
    ClassOrNamespace *findType(const Name *name);
82

83
84
    Symbol *lookupInScope(const QList<const Name *> &fullName);

85
private:
86
87
88
    typedef std::map<const Name *, ClassOrNamespace *, Name::Compare> Table;
    typedef std::map<const TemplateNameId *, ClassOrNamespace *, TemplateNameId::Compare> TemplateNameIdTable;

89
90
91
92
    /// \internal
    void flush();

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

95
96
    void addTodo(Symbol *symbol);
    void addSymbol(Symbol *symbol);
97
    void addUnscopedEnum(Enum *e);
98
    void addUsing(ClassOrNamespace *u);
Roberto Raggi's avatar
Roberto Raggi committed
99
    void addNestedType(const Name *alias, ClassOrNamespace *e);
100

101
    QList<LookupItem> lookup_helper(const Name *name, bool searchInEnclosingScope);
102

103
    void lookup_helper(const Name *name, ClassOrNamespace *binding,
104
105
106
                       QList<LookupItem> *result,
                       QSet<ClassOrNamespace *> *processed,
                       const TemplateNameId *templateId);
107

108
    ClassOrNamespace *lookupType_helper(const Name *name, QSet<ClassOrNamespace *> *processed,
109
                                        bool searchInEnclosingScope, ClassOrNamespace *origin);
110

111
    ClassOrNamespace *nestedType(const Name *name, ClassOrNamespace *origin);
112

113
114
115
116
117
    void instantiateNestedClasses(ClassOrNamespace *enclosingTemplateClass,
                                  Clone &cloner,
                                  Subst &subst,
                                  ClassOrNamespace *enclosingTemplateClassInstantiation);
    bool isInstantiateNestedClassNeeded(const QList<Symbol *>& symbols, const Subst &subst) const;
118
119
    ClassOrNamespace *findSpecializationWithPointer(const TemplateNameId *templId,
                                           const TemplateNameIdTable &specializations);
120

121
122
123
124
    CreateBindings *_factory;
    ClassOrNamespace *_parent;
    QList<Symbol *> _symbols;
    QList<ClassOrNamespace *> _usings;
125
    Table _classOrNamespaces;
126
127
    QList<Enum *> _enums;
    QList<Symbol *> _todo;
128
    QSharedPointer<Control> _control;
129
    TemplateNameIdTable _specializations;
130
    QMap<const TemplateNameId *, ClassOrNamespace *> _instantiations;
131

132
133
    QHash<Internal::FullyQualifiedName, Symbol *> *_scopeLookupCache;

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

138
139
140
    AlreadyConsideredClassContainer<Class> _alreadyConsideredClasses;
    AlreadyConsideredClassContainer<TemplateNameId> _alreadyConsideredTemplates;

141
142
143
144
145
146
147
148
149
150
151
152
153
154
    class NestedClassInstantiator
    {
    public:
        NestedClassInstantiator(CreateBindings *factory, Clone &cloner, Subst &subst)
            : _factory(factory)
            , _cloner(cloner)
            , _subst(subst)
        {}
        void instantiate(ClassOrNamespace *enclosingTemplateClass,
                         ClassOrNamespace *enclosingTemplateClassInstantiation);
    private:
        bool isInstantiateNestedClassNeeded(const QList<Symbol *> &symbols) const;
        bool containsTemplateType(Declaration *declaration) const;
        bool containsTemplateType(Function *function) const;
155
        NamedType *findNamedType(Type *memberType) const;
156
157
158
159
160
161
162

        QSet<ClassOrNamespace *> _alreadyConsideredNestedClassInstantiations;
        CreateBindings *_factory;
        Clone &_cloner;
        Subst &_subst;
    };

163
#ifdef DEBUG_LOOKUP
164
public:
165
166
167
    const Name *_name;
#endif // DEBUG_LOOKUP

168
169
170
171
172
173
174
175
    friend class CreateBindings;
};

class CPLUSPLUS_EXPORT CreateBindings: protected SymbolVisitor
{
    Q_DISABLE_COPY(CreateBindings)

public:
176
    CreateBindings(Document::Ptr thisDocument, const Snapshot &snapshot);
177
178
    virtual ~CreateBindings();

179
    /// Returns the binding for the global namespace.
180
181
    ClassOrNamespace *globalNamespace() const;

182
    /// Finds the binding associated to the given symbol.
183
184
185
186
    ClassOrNamespace *lookupType(Symbol *symbol,
                                 ClassOrNamespace* enclosingTemplateInstantiation = 0);
    ClassOrNamespace *lookupType(const QList<const Name *> &path,
                                 ClassOrNamespace* enclosingTemplateInstantiation = 0);
187
188

    /// Returns the Control that must be used to create temporary symbols.
189
    /// \internal
190
191
    QSharedPointer<Control> control() const
    { return _control; }
192

193
194
195
196
197
    bool expandTemplates() const
    { return _expandTemplates; }
    void setExpandTemplates(bool expandTemplates)
    { _expandTemplates = expandTemplates; }

198
199
    /// Searches in \a scope for symbols with the given \a name.
    /// Store the result in \a results.
200
    /// \internal
201
202
    void lookupInScope(const Name *name, Scope *scope, QList<LookupItem> *result,
                            const TemplateNameId *templateId, ClassOrNamespace *binding);
203

204
    /// Create bindings for the symbols reachable from \a rootSymbol.
205
    /// \internal
206
    void process(Symbol *rootSymbol, ClassOrNamespace *classOrNamespace);
207

208
    /// Create an empty ClassOrNamespace binding with the given \a parent.
209
    /// \internal
Roberto Raggi's avatar
Roberto Raggi committed
210
    ClassOrNamespace *allocClassOrNamespace(ClassOrNamespace *parent);
211

212
213
214
protected:
    using SymbolVisitor::visit;

215
    /// Change the current ClassOrNamespace binding.
Roberto Raggi's avatar
Roberto Raggi committed
216
    ClassOrNamespace *switchCurrentClassOrNamespace(ClassOrNamespace *classOrNamespace);
217

218
219
220
221
222
223
224
225
226
227
228
229
    /// 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);
230

231
    virtual bool visit(Template *templ);
232
233
234
235
236
237
238
239
    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
240
    virtual bool visit(UsingDeclaration *u);
241
242
243
244
245
246
247
248
249
250
251
252
    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;
253
    QSharedPointer<Control> _control;
254
255
256
257
    QSet<Namespace *> _processed;
    QList<ClassOrNamespace *> _entities;
    ClassOrNamespace *_globalNamespace;
    ClassOrNamespace *_currentClassOrNamespace;
258
    bool _expandTemplates;
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
};

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;

283
    QList<LookupItem> lookup(const Name *name, Scope *scope) const;
284
    ClassOrNamespace *lookupType(const Name *name, Scope *scope,
285
286
287
                                 ClassOrNamespace* enclosingTemplateInstantiation = 0,
                                 QSet<const Declaration *> typedefsBeingResolved
                                    = QSet<const Declaration *>()) const;
288
289
    ClassOrNamespace *lookupType(Symbol *symbol,
                                 ClassOrNamespace* enclosingTemplateInstantiation = 0) const;
290
    ClassOrNamespace *lookupParent(Symbol *symbol) const;
291
292
293
294
295
296
297

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

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

298
    static QList<const Name *> fullyQualifiedName(Symbol *symbol);
299
    static QList<const Name *> path(Symbol *symbol);
300

301
    static const Name *minimalName(Symbol *symbol, ClassOrNamespace *target, Control *control);
302

303
    void setExpandTemplates(bool expandTemplates)
304
305
306
307
308
    {
        if (_bindings)
            _bindings->setExpandTemplates(expandTemplates);
        m_expandTemplates = expandTemplates;
    }
309

310
311
312
313
314
315
316
317
318
319
320
321
private:
    // The current expression.
    Document::Ptr _expressionDocument;

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

    // All documents.
    Snapshot _snapshot;

    // Bindings
    mutable QSharedPointer<CreateBindings> _bindings;
322

323
    bool m_expandTemplates;
324
325
};

326
327
328
329
bool CPLUSPLUS_EXPORT compareFullyQualifiedName(const QList<const Name *> &path,
                                                const QList<const Name *> &other);


330
} // namespace CPlusPlus
331
332

#endif // CPLUSPLUS_LOOKUPCONTEXT_H