/**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. ** Contact: https://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 https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 3 as published by the Free Software ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-3.0.html. ** ****************************************************************************/ #pragma once #include "CppDocument.h" #include "LookupItem.h" #include "AlreadyConsideredClassContainer.h" #include #include #include #include #include #include #include #include #include namespace CPlusPlus { namespace Internal { struct FullyQualifiedName { QList fqn; FullyQualifiedName(const QList &fqn) : fqn(fqn) {} }; } // namespace Internal; class CreateBindings; class CPLUSPLUS_EXPORT ClassOrNamespace { Q_DISABLE_COPY(ClassOrNamespace) ClassOrNamespace(CreateBindings *factory, ClassOrNamespace *parent); public: ~ClassOrNamespace(); const TemplateNameId *templateId() const; ClassOrNamespace *instantiationOrigin() const; ClassOrNamespace *parent() const; QList usings() const; QList unscopedEnums() const; QList symbols() const; ClassOrNamespace *globalNamespace() const; QList lookup(const Name *name); QList 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); Symbol *lookupInScope(const QList &fullName); /// The class this ClassOrNamespace is based on. Class *rootClass() const { return _rootClass; } private: typedef std::map Table; typedef std::map TemplateNameIdTable; typedef QHash Anonymouses; /// \internal void flush(); /// \internal ClassOrNamespace *findOrCreateType(const Name *name, ClassOrNamespace *origin = nullptr, Class *clazz = nullptr); ClassOrNamespace *findOrCreateNestedAnonymousType(const AnonymousNameId *anonymousNameId); void addTodo(Symbol *symbol); void addSymbol(Symbol *symbol); void addUnscopedEnum(Enum *e); void addUsing(ClassOrNamespace *u); void addNestedType(const Name *alias, ClassOrNamespace *e); QList lookup_helper(const Name *name, bool searchInEnclosingScope); void lookup_helper(const Name *name, ClassOrNamespace *binding, QList *result, QSet *processed, const TemplateNameId *templateId); ClassOrNamespace *lookupType_helper(const Name *name, QSet *processed, bool searchInEnclosingScope, ClassOrNamespace *origin); ClassOrNamespace *findBlock_helper(Block *block, QSet *processed, bool searchInEnclosingScope); ClassOrNamespace *nestedType(const Name *name, QSet *processed, ClassOrNamespace *origin); void instantiateNestedClasses(ClassOrNamespace *enclosingTemplateClass, Clone &cloner, Subst &subst, ClassOrNamespace *enclosingTemplateClassInstantiation); ClassOrNamespace *findSpecialization(const TemplateNameId *templId, const TemplateNameIdTable &specializations); CreateBindings *_factory; ClassOrNamespace *_parent; QList _symbols; QList _usings; Table _classOrNamespaces; QHash _blocks; QList _enums; QList _todo; QSharedPointer _control; TemplateNameIdTable _specializations; QMap _instantiations; Anonymouses _anonymouses; QSet _declaredOrTypedefedAnonymouses; QHash *_scopeLookupCache; // it's an instantiation. const TemplateNameId *_templateId; ClassOrNamespace *_instantiationOrigin; AlreadyConsideredClassContainer _alreadyConsideredClasses; AlreadyConsideredClassContainer _alreadyConsideredTemplates; Class *_rootClass; 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 &symbols) const; bool containsTemplateType(Declaration *declaration) const; bool containsTemplateType(Function *function) const; NamedType *findNamedType(Type *memberType) const; QSet _alreadyConsideredNestedClassInstantiations; CreateBindings *_factory; Clone &_cloner; Subst &_subst; }; public: const Name *_name; // For debug 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 = nullptr); ClassOrNamespace *lookupType(const QList &path, ClassOrNamespace *enclosingBinding = nullptr); /// Returns the Control that must be used to create temporary symbols. /// \internal QSharedPointer 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 *result, const TemplateNameId *templateId, ClassOrNamespace *binding); /// 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; QSet _processed; QList _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 bindings = QSharedPointer()); 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 lookup(const Name *name, Scope *scope) const; ClassOrNamespace *lookupType(const Name *name, Scope *scope, ClassOrNamespace *enclosingBinding = nullptr, QSet typedefsBeingResolved = QSet()) const; ClassOrNamespace *lookupType(Symbol *symbol, ClassOrNamespace *enclosingBinding = nullptr) const; ClassOrNamespace *lookupParent(Symbol *symbol) const; /// \internal QSharedPointer bindings() const { return _bindings; } static QList fullyQualifiedName(Symbol *symbol); static QList 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 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 _bindings; bool m_expandTemplates; }; bool CPLUSPLUS_EXPORT compareFullyQualifiedName(const QList &path, const QList &other); } // namespace CPlusPlus