CPlusPlus: Inline some simple central functions

Depending on context, callgrind sees contributions of >8% to
the total cost of project parsing for these functions. The
functional are actualy executed executed out-of-line, often
for a function body of one "payload" instruction only.

Inlining removes the call/endbr64/ret overhead.

Change-Id: I6886f08e322fcaa4e0f54d424279e0a8c24e4718
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

20 files changed, 379 insertions, 1060 deletions

diff --git a/src/libs/3rdparty/cplusplus/Bind.cpp b/src/libs/3rdparty/cplusplus/Bind.cpp
index 9a9cf34cbc..2a911fb0da 100644
--- a/src/libs/3rdparty/cplusplus/Bind.cpp
+++ b/src/libs/3rdparty/cplusplus/Bind.cpp
@@ -2024,7 +2024,7 @@ bool Bind::visit(SimpleDeclarationAST *ast)
                 decl->setInitializer(asStringLiteral(initializer));
         }
 
-        if (_scope->isClass()) {
+        if (_scope->asClass()) {
             decl->setVisibility(_visibility);
 
             if (Function *funTy = decl->type()->asFunctionType()) {
@@ -2050,7 +2050,7 @@ bool Bind::visit(EmptyDeclarationAST *ast)
 {
     (void) ast;
     int semicolon_token = ast->semicolon_token;
-    if (_scope && (_scope->isClass() || _scope->isNamespace())) {
+    if (_scope && (_scope->asClass() || _scope->asNamespace())) {
         const Token &tk = tokenAt(semicolon_token);
 
         if (! tk.generated())
@@ -2227,7 +2227,7 @@ bool Bind::visit(AliasDeclarationAST *ast)
     decl->setType(ty);
     decl->setStorage(Symbol::Typedef);
     ast->symbol = decl;
-    if (_scope->isClass())
+    if (_scope->asClass())
         decl->setVisibility(_visibility);
     _scope->addMember(decl);
 
@@ -2299,7 +2299,7 @@ bool Bind::visit(FunctionDefinitionAST *ast)
         setDeclSpecifiers(fun, declSpecifiers);
         fun->setEndOffset(tokenAt(ast->lastToken() - 1).utf16charsEnd());
 
-        if (_scope->isClass()) {
+        if (_scope->asClass()) {
             fun->setVisibility(_visibility);
             fun->setMethodKey(methodKey);
         }
@@ -3147,7 +3147,7 @@ bool Bind::visit(ClassSpecifierAST *ast)
     klass->setEndOffset(tokenAt(ast->lastToken() - 1).utf16charsEnd());
     _scope->addMember(klass);
 
-    if (_scope->isClass())
+    if (_scope->asClass())
         klass->setVisibility(_visibility);
 
     // set the class key
@@ -3210,7 +3210,7 @@ bool Bind::visit(EnumSpecifierAST *ast)
     ast->symbol = e;
     _scope->addMember(e);
 
-    if (_scope->isClass())
+    if (_scope->asClass())
         e->setVisibility(_visibility);
 
     Scope *previousScope = switchScope(e);
@@ -3398,7 +3398,7 @@ void Bind::ensureValidClassName(const Name **name, int sourceLocation)
     const QualifiedNameId *qName = (*name)->asQualifiedNameId();
     const Name *uqName = qName ? qName->name() : *name;
 
-    if (!uqName->isNameId() && !uqName->isTemplateNameId()) {
+    if (!uqName->asNameId() && !uqName->asTemplateNameId()) {
         translationUnit()->error(sourceLocation, "expected a class-name");
 
         *name = uqName->identifier();
diff --git a/src/libs/3rdparty/cplusplus/FullySpecifiedType.cpp b/src/libs/3rdparty/cplusplus/FullySpecifiedType.cpp
index 81c608a3dc..7333f30629 100644
--- a/src/libs/3rdparty/cplusplus/FullySpecifiedType.cpp
+++ b/src/libs/3rdparty/cplusplus/FullySpecifiedType.cpp
@@ -33,17 +33,9 @@ FullySpecifiedType::FullySpecifiedType(Type *type) :
         _type = UndefinedType::instance();
 }
 
-FullySpecifiedType::~FullySpecifiedType()
-{ }
-
 bool FullySpecifiedType::isValid() const
 { return _type != UndefinedType::instance(); }
 
-Type *FullySpecifiedType::type() const
-{ return _type; }
-
-void FullySpecifiedType::setType(Type *type)
-{ _type = type; }
 
 FullySpecifiedType FullySpecifiedType::qualifiedType() const
 {
@@ -215,12 +207,6 @@ FullySpecifiedType FullySpecifiedType::simplified() const
     return *this;
 }
 
-unsigned FullySpecifiedType::flags() const
-{ return _flags; }
-
-void FullySpecifiedType::setFlags(unsigned flags)
-{ _flags = flags; }
-
 bool FullySpecifiedType::match(const FullySpecifiedType &otherTy, Matcher *matcher) const
 {
     static const unsigned flagsMask = [](){
diff --git a/src/libs/3rdparty/cplusplus/FullySpecifiedType.h b/src/libs/3rdparty/cplusplus/FullySpecifiedType.h
index a8462d503a..ec54b8bdd9 100644
--- a/src/libs/3rdparty/cplusplus/FullySpecifiedType.h
+++ b/src/libs/3rdparty/cplusplus/FullySpecifiedType.h
@@ -25,17 +25,17 @@
 
 namespace CPlusPlus {
 
-class CPLUSPLUS_EXPORT FullySpecifiedType
+class CPLUSPLUS_EXPORT FullySpecifiedType final
 {
 public:
     FullySpecifiedType(Type *type = nullptr);
-    ~FullySpecifiedType();
+    ~FullySpecifiedType() = default;
 
     bool isValid() const;
     explicit operator bool() const;
 
-    Type *type() const;
-    void setType(Type *type);
+    Type *type() const { return _type; }
+    void setType(Type *type) { _type = type; }
 
     FullySpecifiedType qualifiedType() const;
 
@@ -109,8 +109,8 @@ public:
 
     FullySpecifiedType simplified() const;
 
-    unsigned flags() const;
-    void setFlags(unsigned flags);
+    unsigned flags() const { return _flags; }
+    void setFlags(unsigned flags) { _flags = flags; }
 
 private:
     Type *_type;
diff --git a/src/libs/3rdparty/cplusplus/Literals.h b/src/libs/3rdparty/cplusplus/Literals.h
index f15fa5a804..d4f59d9987 100644
--- a/src/libs/3rdparty/cplusplus/Literals.h
+++ b/src/libs/3rdparty/cplusplus/Literals.h
@@ -105,7 +105,7 @@ private:
     };
 };
 
-class CPLUSPLUS_EXPORT Identifier: public Literal, public Name
+class CPLUSPLUS_EXPORT Identifier final : public Literal, public Name
 {
 public:
     Identifier(const char *chars, int size)
@@ -114,8 +114,7 @@ public:
 
     const Identifier *identifier() const override { return this; }
 
-    const Identifier *asNameId() const override
-    { return this; }
+    const Identifier *asNameId() const override { return this; }
 
 protected:
     void accept0(NameVisitor *visitor) const override;
diff --git a/src/libs/3rdparty/cplusplus/Name.cpp b/src/libs/3rdparty/cplusplus/Name.cpp
index 05ef8277f6..7236a21954 100644
--- a/src/libs/3rdparty/cplusplus/Name.cpp
+++ b/src/libs/3rdparty/cplusplus/Name.cpp
@@ -35,30 +35,6 @@ Name::Name()
 Name::~Name()
 { }
 
-bool Name::isNameId() const
-{ return asNameId() != nullptr; }
-
-bool Name::isAnonymousNameId() const
-{ return asAnonymousNameId() != nullptr; }
-
-bool Name::isTemplateNameId() const
-{ return asTemplateNameId() != nullptr; }
-
-bool Name::isDestructorNameId() const
-{ return asDestructorNameId() != nullptr; }
-
-bool Name::isOperatorNameId() const
-{ return asOperatorNameId() != nullptr; }
-
-bool Name::isConversionNameId() const
-{ return asConversionNameId() != nullptr; }
-
-bool Name::isQualifiedNameId() const
-{ return asQualifiedNameId() != nullptr; }
-
-bool Name::isSelectorNameId() const
-{ return asSelectorNameId() != nullptr; }
-
 void Name::accept(NameVisitor *visitor) const
 {
     if (visitor->preVisit(this))
diff --git a/src/libs/3rdparty/cplusplus/Name.h b/src/libs/3rdparty/cplusplus/Name.h
index 1806a1e4cb..d1ba99ae36 100644
--- a/src/libs/3rdparty/cplusplus/Name.h
+++ b/src/libs/3rdparty/cplusplus/Name.h
@@ -35,15 +35,6 @@ public:
 
     virtual const Identifier *identifier() const = 0;
 
-    bool isNameId() const;
-    bool isAnonymousNameId() const;
-    bool isTemplateNameId() const;
-    bool isDestructorNameId() const;
-    bool isOperatorNameId() const;
-    bool isConversionNameId() const;
-    bool isQualifiedNameId() const;
-    bool isSelectorNameId() const;
-
     virtual const Identifier *asNameId() const { return nullptr; }
     virtual const AnonymousNameId *asAnonymousNameId() const { return nullptr; }
     virtual const TemplateNameId *asTemplateNameId() const { return nullptr; }
diff --git a/src/libs/3rdparty/cplusplus/Names.cpp b/src/libs/3rdparty/cplusplus/Names.cpp
index 0d3029ae5d..d240ac536b 100644
--- a/src/libs/3rdparty/cplusplus/Names.cpp
+++ b/src/libs/3rdparty/cplusplus/Names.cpp
@@ -171,9 +171,6 @@ bool OperatorNameId::match0(const Name *otherName, Matcher *matcher) const
 OperatorNameId::Kind OperatorNameId::kind() const
 { return _kind; }
 
-const Identifier *OperatorNameId::identifier() const
-{ return nullptr; }
-
 ConversionNameId::ConversionNameId(const FullySpecifiedType &type)
     : _type(type)
 { }
@@ -191,11 +188,7 @@ bool ConversionNameId::match0(const Name *otherName, Matcher *matcher) const
     return false;
 }
 
-FullySpecifiedType ConversionNameId::type() const
-{ return _type; }
 
-const Identifier *ConversionNameId::identifier() const
-{ return nullptr; }
 
 SelectorNameId::~SelectorNameId()
 { }
@@ -249,5 +242,4 @@ bool AnonymousNameId::match0(const Name *otherName, Matcher *matcher) const
     return false;
 }
 
-const Identifier *AnonymousNameId::identifier() const
-{ return nullptr; }
+
diff --git a/src/libs/3rdparty/cplusplus/Names.h b/src/libs/3rdparty/cplusplus/Names.h
index 5b915bdfb4..7913c9b0bc 100644
--- a/src/libs/3rdparty/cplusplus/Names.h
+++ b/src/libs/3rdparty/cplusplus/Names.h
@@ -234,10 +234,8 @@ public:
 
     Kind kind() const;
 
-    const Identifier *identifier() const override;
-
-    const OperatorNameId *asOperatorNameId() const override
-    { return this; }
+    const Identifier *identifier() const override { return nullptr; }
+    const OperatorNameId *asOperatorNameId() const override { return this; }
 
 protected:
     void accept0(NameVisitor *visitor) const override;
@@ -253,12 +251,9 @@ public:
     ConversionNameId(const FullySpecifiedType &type);
     virtual ~ConversionNameId();
 
-    FullySpecifiedType type() const;
-
-    const Identifier *identifier() const override;
-
-    const ConversionNameId *asConversionNameId() const override
-    { return this; }
+    FullySpecifiedType type() const { return _type; }
+    const Identifier *identifier() const override { return nullptr; }
+    const ConversionNameId *asConversionNameId() const override { return this; }
 
 protected:
     void accept0(NameVisitor *visitor) const override;
@@ -300,7 +295,7 @@ private:
     bool _hasArguments;
 };
 
-class CPLUSPLUS_EXPORT AnonymousNameId: public Name
+class CPLUSPLUS_EXPORT AnonymousNameId final : public Name
 {
 public:
     AnonymousNameId(int classTokenIndex);
@@ -308,10 +303,9 @@ public:
 
     int classTokenIndex() const;
 
-    const Identifier *identifier() const override;
+    const Identifier *identifier() const override { return nullptr; }
 
-    const AnonymousNameId *asAnonymousNameId() const override
-    { return this; }
+    const AnonymousNameId *asAnonymousNameId() const override { return this; }
 
 protected:
     void accept0(NameVisitor *visitor) const override;
diff --git a/src/libs/3rdparty/cplusplus/Scope.cpp b/src/libs/3rdparty/cplusplus/Scope.cpp
index dcafc0c066..23fa2aad67 100644
--- a/src/libs/3rdparty/cplusplus/Scope.cpp
+++ b/src/libs/3rdparty/cplusplus/Scope.cpp
@@ -154,7 +154,7 @@ Symbol *SymbolTable::lookat(const Identifier *id) const
         } else if (const DestructorNameId *d = identity->asDestructorNameId()) {
             if (d->identifier()->match(id))
                 break;
-        } else if (identity->isQualifiedNameId()) {
+        } else if (identity->asQualifiedNameId()) {
             return nullptr;
         } else if (const SelectorNameId *selectorNameId = identity->asSelectorNameId()) {
             if (selectorNameId->identifier()->match(id))
diff --git a/src/libs/3rdparty/cplusplus/Symbol.cpp b/src/libs/3rdparty/cplusplus/Symbol.cpp
index 05254e9d96..01410ecea9 100644
--- a/src/libs/3rdparty/cplusplus/Symbol.cpp
+++ b/src/libs/3rdparty/cplusplus/Symbol.cpp
@@ -142,23 +142,7 @@ void Symbol::visitSymbol(Symbol *symbol, SymbolVisitor *visitor)
     symbol->visitSymbol(visitor);
 }
 
-int Symbol::sourceLocation() const
-{ return _sourceLocation; }
 
-bool Symbol::isGenerated() const
-{ return _isGenerated; }
-
-bool Symbol::isDeprecated() const
-{ return _isDeprecated; }
-
-void Symbol::setDeprecated(bool isDeprecated)
-{ _isDeprecated = isDeprecated; }
-
-bool Symbol::isUnavailable() const
-{ return _isUnavailable; }
-
-void Symbol::setUnavailable(bool isUnavailable)
-{ _isUnavailable = isUnavailable; }
 
 void Symbol::setSourceLocation(int sourceLocation, TranslationUnit *translationUnit)
 {
@@ -176,21 +160,6 @@ void Symbol::setSourceLocation(int sourceLocation, TranslationUnit *translationU
     }
 }
 
-int Symbol::line() const
-{
-    return _line;
-}
-
-int Symbol::column() const
-{
-    return _column;
-}
-
-const StringLiteral *Symbol::fileId() const
-{
-    return _fileId;
-}
-
 const char *Symbol::fileName() const
 { return _fileId ? _fileId->chars() : ""; }
 
@@ -208,9 +177,6 @@ const Name *Symbol::unqualifiedName() const
     return _name;
 }
 
-const Name *Symbol::name() const
-{ return _name; }
-
 void Symbol::setName(const Name *name)
 {
     _name = name;
@@ -231,9 +197,6 @@ const Identifier *Symbol::identifier() const
     return nullptr;
 }
 
-Scope *Symbol::enclosingScope() const
-{ return _enclosingScope; }
-
 void Symbol::setEnclosingScope(Scope *scope)
 {
     CPP_CHECK(! _enclosingScope);
@@ -299,126 +262,6 @@ Block *Symbol::enclosingBlock() const
     return nullptr;
 }
 
-unsigned Symbol::index() const
-{ return _index; }
-
-Symbol *Symbol::next() const
-{ return _next; }
-
-unsigned Symbol::hashCode() const
-{ return _hashCode; }
-
-int Symbol::storage() const
-{ return _storage; }
-
-void Symbol::setStorage(int storage)
-{ _storage = storage; }
-
-int Symbol::visibility() const
-{ return _visibility; }
-
-void Symbol::setVisibility(int visibility)
-{ _visibility = visibility; }
-
-bool Symbol::isFriend() const
-{ return _storage == Friend; }
-
-bool Symbol::isRegister() const
-{ return _storage == Register; }
-
-bool Symbol::isStatic() const
-{ return _storage == Static; }
-
-bool Symbol::isExtern() const
-{ return _storage == Extern; }
-
-bool Symbol::isMutable() const
-{ return _storage == Mutable; }
-
-bool Symbol::isTypedef() const
-{ return _storage == Typedef; }
-
-bool Symbol::isPublic() const
-{ return _visibility == Public; }
-
-bool Symbol::isProtected() const
-{ return _visibility == Protected; }
-
-bool Symbol::isPrivate() const
-{ return _visibility == Private; }
-
-bool Symbol::isScope() const
-{ return asScope() != nullptr; }
-
-bool Symbol::isEnum() const
-{ return asEnum()  != nullptr; }
-
-bool Symbol::isFunction() const
-{ return asFunction() != nullptr; }
-
-bool Symbol::isNamespace() const
-{ return asNamespace() != nullptr; }
-
-bool Symbol::isTemplate() const
-{ return asTemplate() != nullptr; }
-
-bool Symbol::isClass() const
-{ return asClass() != nullptr; }
-
-bool Symbol::isForwardClassDeclaration() const
-{ return asForwardClassDeclaration() != nullptr; }
-
-bool Symbol::isQtPropertyDeclaration() const
-{ return asQtPropertyDeclaration() != nullptr; }
-
-bool Symbol::isQtEnum() const
-{ return asQtEnum() != nullptr; }
-
-bool Symbol::isBlock() const
-{ return asBlock() != nullptr; }
-
-bool Symbol::isUsingNamespaceDirective() const
-{ return asUsingNamespaceDirective() != nullptr; }
-
-bool Symbol::isUsingDeclaration() const
-{ return asUsingDeclaration() != nullptr; }
-
-bool Symbol::isDeclaration() const
-{ return asDeclaration() != nullptr; }
-
-bool Symbol::isArgument() const
-{ return asArgument() != nullptr; }
-
-bool Symbol::isTypenameArgument() const
-{ return asTypenameArgument() != nullptr; }
-
-bool Symbol::isBaseClass() const
-{ return asBaseClass() != nullptr; }
-
-bool Symbol::isObjCBaseClass() const
-{ return asObjCBaseClass() != nullptr; }
-
-bool Symbol::isObjCBaseProtocol() const
-{ return asObjCBaseProtocol() != nullptr; }
-
-bool Symbol::isObjCClass() const
-{ return asObjCClass() != nullptr; }
-
-bool Symbol::isObjCForwardClassDeclaration() const
-{ return asObjCForwardClassDeclaration() != nullptr; }
-
-bool Symbol::isObjCProtocol() const
-{ return asObjCProtocol() != nullptr; }
-
-bool Symbol::isObjCForwardProtocolDeclaration() const
-{ return asObjCForwardProtocolDeclaration() != nullptr; }
-
-bool Symbol::isObjCMethod() const
-{ return asObjCMethod() != nullptr; }
-
-bool Symbol::isObjCPropertyDeclaration() const
-{ return asObjCPropertyDeclaration() != nullptr; }
-
 void Symbol::copy(Symbol *other)
 {
     _sourceLocation = other->_sourceLocation;
diff --git a/src/libs/3rdparty/cplusplus/Symbol.h b/src/libs/3rdparty/cplusplus/Symbol.h
index 3e1b525a62..33fe77d80d 100644
--- a/src/libs/3rdparty/cplusplus/Symbol.h
+++ b/src/libs/3rdparty/cplusplus/Symbol.h
@@ -61,16 +61,16 @@ public:
     virtual ~Symbol();
 
     /// Returns this Symbol's source location.
-    int sourceLocation() const;
+    int sourceLocation() const { return _sourceLocation; }
 
     /// \returns this Symbol's line number. The line number is 1-based.
-    int line() const;
+    int line() const { return _line; }
 
     /// \returns this Symbol's column number. The column number is 1-based.
-    int column() const;
+    int column() const { return _column; }
 
     /// Returns this Symbol's file name.
-    const StringLiteral *fileId() const;
+    const StringLiteral *fileId() const { return _fileId; }
 
     /// Returns this Symbol's file name.
     const char *fileName() const;
@@ -79,7 +79,7 @@ public:
     int fileNameLength() const;
 
     /// Returns this Symbol's name.
-    const Name *name() const;
+    const Name *name() const { return _name; }
 
     /// Sets this Symbol's name.
     void setName(const Name *name); // ### dangerous
@@ -88,115 +88,46 @@ public:
     const Identifier *identifier() const;
 
     /// Returns this Symbol's storage class specifier.
-    int storage() const;
+    int storage() const { return _storage; }
 
     /// Sets this Symbol's storage class specifier.
-    void setStorage(int storage);
+    void setStorage(int storage) { _storage = storage; }
 
     /// Returns this Symbol's visibility.
-    int visibility() const;
+    int visibility() const { return _visibility; }
 
     /// Sets this Symbol's visibility.
-    void setVisibility(int visibility);
+    void setVisibility(int visibility) { _visibility = visibility; }
 
     /// Returns the next chained Symbol.
-    Symbol *next() const;
+    Symbol *next() const { return _next; }
 
     /// Returns true if this Symbol has friend storage specifier.
-    bool isFriend() const;
+    bool isFriend() const { return _storage == Friend; }
 
     /// Returns true if this Symbol has register storage specifier.
-    bool isRegister() const;
+    bool isRegister() const { return _storage == Register; }
 
     /// Returns true if this Symbol has static storage specifier.
-    bool isStatic() const;
+    bool isStatic() const { return _storage == Static; }
 
     /// Returns true if this Symbol has extern storage specifier.
-    bool isExtern() const;
+    bool isExtern() const { return _storage == Extern; }
 
     /// Returns true if this Symbol has mutable storage specifier.
-    bool isMutable() const;
+    bool isMutable() const { return _storage == Mutable; }
 
     /// Returns true if this Symbol has typedef storage specifier.
-    bool isTypedef() const;
+    bool isTypedef() const { return _storage == Typedef; }
 
     /// Returns true if this Symbol's visibility is public.
-    bool isPublic() const;
+    bool isPublic() const { return _visibility == Public; }
 
     /// Returns true if this Symbol's visibility is protected.
-    bool isProtected() const;
+    bool isProtected() const { return _visibility == Protected; }
 
     /// Returns true if this Symbol's visibility is private.
-    bool isPrivate() const;
-
-    /// Returns true if this Symbol is a Scope.
-    bool isScope() const;
-
-    /// Returns true if this Symbol is an Enum.
-    bool isEnum() const;
-
-    /// Returns true if this Symbol is an Function.
-    bool isFunction() const;
-
-    /// Returns true if this Symbol is a Namespace.
-    bool isNamespace() const;
-
-    /// Returns true if this Symbol is a Template.
-    bool isTemplate() const;
-
-    /// Returns true if this Symbol is a Class.
-    bool isClass() const;
-
-    /// Returns true if this Symbol is a Block.
-    bool isBlock() const;
-
-    /// Returns true if this Symbol is a UsingNamespaceDirective.
-    bool isUsingNamespaceDirective() const;
-
-    /// Returns true if this Symbol is a UsingDeclaration.
-    bool isUsingDeclaration() const;
-
-    /// Returns true if this Symbol is a Declaration.
-    bool isDeclaration() const;
-
-    /// Returns true if this Symbol is an Argument.
-    bool isArgument() const;
-
-    /// Returns true if this Symbol is a Typename argument.
-    bool isTypenameArgument() const;
-
-    /// Returns true if this Symbol is a BaseClass.
-    bool isBaseClass() const;
-
-    /// Returns true if this Symbol is a ForwardClassDeclaration.
-    bool isForwardClassDeclaration() const;
-
-    /// Returns true if this Symbol is a QtPropertyDeclaration.
-    bool isQtPropertyDeclaration() const;
-
-    /// Returns true if this Symbol is a QtEnum.
-    bool isQtEnum() const;
-
-    bool isObjCBaseClass() const;
-    bool isObjCBaseProtocol() const;
-
-    /// Returns true if this Symbol is an Objective-C Class declaration.
-    bool isObjCClass() const;
-
-    /// Returns true if this Symbol is an Objective-C Class forward declaration.
-    bool isObjCForwardClassDeclaration() const;
-
-    /// Returns true if this Symbol is an Objective-C Protocol declaration.
-    bool isObjCProtocol() const;
-
-    /// Returns true if this Symbol is an Objective-C Protocol forward declaration.
-    bool isObjCForwardProtocolDeclaration() const;
-
-    /// Returns true if this Symbol is an Objective-C method declaration.
-    bool isObjCMethod() const;
-
-    /// Returns true if this Symbol is an Objective-C @property declaration.
-    bool isObjCPropertyDeclaration() const;
+    bool isPrivate() const { return _visibility == Private; }
 
     Utils::Link toLink() const;
 
@@ -226,53 +157,98 @@ public:
     virtual const ObjCMethod *asObjCMethod() const { return nullptr; }
     virtual const ObjCPropertyDeclaration *asObjCPropertyDeclaration() const { return nullptr; }
 
+    /// Returns this Symbol as a Scope.
     virtual Scope *asScope() { return nullptr; }
+
+    /// Returns this Symbol as an Enum.
     virtual Enum *asEnum() { return nullptr; }
+
+    /// Returns this Symbol as an Function.
     virtual Function *asFunction() { return nullptr; }
+
+    /// Returns this Symbol as a Namespace.
     virtual Namespace *asNamespace() { return nullptr; }
+
+    /// Returns this Symbol as a Template.
     virtual Template *asTemplate() { return nullptr; }
+
     virtual NamespaceAlias *asNamespaceAlias() { return nullptr; }
+
+    /// Returns this Symbol as a Class.
     virtual Class *asClass() { return nullptr; }
+
+    /// Returns this Symbol as a Block.
     virtual Block *asBlock() { return nullptr; }
+
+    /// Returns this Symbol as a UsingNamespaceDirective.
     virtual UsingNamespaceDirective *asUsingNamespaceDirective() { return nullptr; }
+
+    /// Returns this Symbol as a UsingDeclaration.
     virtual UsingDeclaration *asUsingDeclaration() { return nullptr; }
+
+    /// Returns this Symbol as a Declaration.
     virtual Declaration *asDeclaration() { return nullptr; }
+
+    /// Returns this Symbol as an Argument.
     virtual Argument *asArgument() { return nullptr; }
+
+    /// Returns this Symbol as a Typename argument.
     virtual TypenameArgument *asTypenameArgument() { return nullptr; }
+
+    /// Returns this Symbol as a BaseClass.
     virtual BaseClass *asBaseClass() { return nullptr; }
+
+    /// Returns this Symbol as a ForwardClassDeclaration.
     virtual ForwardClassDeclaration *asForwardClassDeclaration() { return nullptr; }
+
+    /// Returns this Symbol as a QtPropertyDeclaration.
     virtual QtPropertyDeclaration *asQtPropertyDeclaration() { return nullptr; }
+
+    /// Returns this Symbol as a QtEnum.
     virtual QtEnum *asQtEnum() { return nullptr; }
+
     virtual ObjCBaseClass *asObjCBaseClass() { return nullptr; }
     virtual ObjCBaseProtocol *asObjCBaseProtocol() { return nullptr; }
+
+    /// Returns this Symbol as an Objective-C Class declaration.
     virtual ObjCClass *asObjCClass() { return nullptr; }
+
+    /// Returns this Symbol as an Objective-C Class forward declaration.
     virtual ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() { return nullptr; }
+
+    /// Returns this Symbol as an Objective-C Protocol declaration.
     virtual ObjCProtocol *asObjCProtocol() { return nullptr; }
+
+    /// Returns this Symbol as an Objective-C Protocol forward declaration.
     virtual ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() { return nullptr; }
+
+    /// Returns this Symbol as an Objective-C method declaration.
     virtual ObjCMethod *asObjCMethod() { return nullptr; }
+
+    /// Returns this Symbol as an Objective-C @property declaration.
     virtual ObjCPropertyDeclaration *asObjCPropertyDeclaration() { return nullptr; }
 
     /// Returns this Symbol's type.
     virtual FullySpecifiedType type() const = 0;
 
     /// Returns this Symbol's hash value.
-    unsigned hashCode() const;
+    unsigned hashCode() const { return _hashCode; }
 
     /// Returns this Symbol's index.
-    unsigned index() const;
+    unsigned index() const { return _index; }
 
     const Name *unqualifiedName() const;
 
-    bool isGenerated() const;
+    bool isGenerated() const { return _isGenerated; }
 
-    bool isDeprecated() const;
-    void setDeprecated(bool isDeprecated);
+    bool isDeprecated() const { return _isDeprecated; }
+    void setDeprecated(bool isDeprecated) { _isDeprecated = isDeprecated; }
 
-    bool isUnavailable() const;
-    void setUnavailable(bool isUnavailable);
+    bool isUnavailable() const { return _isUnavailable; }
+    void setUnavailable(bool isUnavailable) { _isUnavailable = isUnavailable; }
 
     /// Returns this Symbol's eclosing scope.
-    Scope *enclosingScope() const;
+    Scope *enclosingScope() const { return _enclosingScope; }
 
     /// Returns the eclosing namespace scope.
     Namespace *enclosingNamespace() const;
diff --git a/src/libs/3rdparty/cplusplus/Symbols.cpp b/src/libs/3rdparty/cplusplus/Symbols.cpp
index a6a96192bc..0a14375aed 100644
--- a/src/libs/3rdparty/cplusplus/Symbols.cpp
+++ b/src/libs/3rdparty/cplusplus/Symbols.cpp
@@ -42,15 +42,13 @@ UsingNamespaceDirective::UsingNamespaceDirective(Clone *clone, Subst *subst, Usi
     : Symbol(clone, subst, original)
 { }
 
-UsingNamespaceDirective::~UsingNamespaceDirective()
-{ }
-
 FullySpecifiedType UsingNamespaceDirective::type() const
 { return FullySpecifiedType(); }
 
 void UsingNamespaceDirective::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
+
 NamespaceAlias::NamespaceAlias(TranslationUnit *translationUnit,
                                int sourceLocation, const Name *name)
     : Symbol(translationUnit, sourceLocation, name), _namespaceName(nullptr)
@@ -61,15 +59,6 @@ NamespaceAlias::NamespaceAlias(Clone *clone, Subst *subst, NamespaceAlias *origi
     , _namespaceName(clone->name(original->_namespaceName, subst))
 { }
 
-NamespaceAlias::~NamespaceAlias()
-{ }
-
-const Name *NamespaceAlias::namespaceName() const
-{ return _namespaceName; }
-
-void NamespaceAlias::setNamespaceName(const Name *namespaceName)
-{ _namespaceName = namespaceName; }
-
 FullySpecifiedType NamespaceAlias::type() const
 { return FullySpecifiedType(); }
 
@@ -86,15 +75,13 @@ UsingDeclaration::UsingDeclaration(Clone *clone, Subst *subst, UsingDeclaration
     : Symbol(clone, subst, original)
 { }
 
-UsingDeclaration::~UsingDeclaration()
-{ }
-
 FullySpecifiedType UsingDeclaration::type() const
 { return FullySpecifiedType(); }
 
-void UsingDeclaration::visitSymbol0(SymbolVisitor *visitor)
+void CPlusPlus::UsingDeclaration::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
+
 Declaration::Declaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
     : Symbol(translationUnit, sourceLocation, name)
     , _initializer(nullptr)
@@ -204,41 +191,16 @@ Declaration::Declaration(Clone *clone, Subst *subst, Declaration *original)
         _type = newType;
 }
 
-Declaration::~Declaration()
-{ }
-
-void Declaration::setType(const FullySpecifiedType &type)
-{ _type = type; }
-
-void Declaration::setInitializer(const StringLiteral *initializer)
-{
-    _initializer = initializer;
-}
-
-FullySpecifiedType Declaration::type() const
-{ return _type; }
-
-const StringLiteral *Declaration::getInitializer() const
-{
-    return _initializer;
-}
-
 void Declaration::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
+
 EnumeratorDeclaration::EnumeratorDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
     : Declaration(translationUnit, sourceLocation, name)
     , _constantValue(nullptr)
 {}
 
-EnumeratorDeclaration::~EnumeratorDeclaration()
-{}
 
-const StringLiteral *EnumeratorDeclaration::constantValue() const
-{ return _constantValue; }
-
-void EnumeratorDeclaration::setConstantValue(const StringLiteral *constantValue)
-{ _constantValue = constantValue; }
 
 Argument::Argument(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
     : Symbol(translationUnit, sourceLocation, name),
@@ -251,27 +213,10 @@ Argument::Argument(Clone *clone, Subst *subst, Argument *original)
     , _type(clone->type(original->_type, subst))
 { }
 
-Argument::~Argument()
-{ }
-
-bool Argument::hasInitializer() const
-{ return _initializer != nullptr; }
-
-const StringLiteral *Argument::initializer() const
-{ return _initializer; }
-
-void Argument::setInitializer(const StringLiteral *initializer)
-{ _initializer = initializer; }
-
-void Argument::setType(const FullySpecifiedType &type)
-{ _type = type; }
-
-FullySpecifiedType Argument::type() const
-{ return _type; }
-
 void Argument::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
+
 TypenameArgument::TypenameArgument(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
     : Symbol(translationUnit, sourceLocation, name)
     , _isClassDeclarator(false)
@@ -283,18 +228,10 @@ TypenameArgument::TypenameArgument(Clone *clone, Subst *subst, TypenameArgument
     , _isClassDeclarator(original->_isClassDeclarator)
 { }
 
-TypenameArgument::~TypenameArgument()
-{ }
-
-void TypenameArgument::setType(const FullySpecifiedType &type)
-{ _type = type; }
-
-FullySpecifiedType TypenameArgument::type() const
-{ return _type; }
-
 void TypenameArgument::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
+
 Function::Function(TranslationUnit *translationUnit, int sourceLocation, const Name *name)
     : Scope(translationUnit, sourceLocation, name),
       _flags(0)
@@ -307,27 +244,6 @@ Function::Function(Clone *clone, Subst *subst, Function *original)
     , _flags(original->_flags)
 { }
 
-Function::~Function()
-{ }
-
-bool Function::isNormal() const
-{ return f._methodKey == NormalMethod; }
-
-bool Function::isSignal() const
-{ return f._methodKey == SignalMethod; }
-
-bool Function::isSlot() const
-{ return f._methodKey == SlotMethod; }
-
-bool Function::isInvokable() const
-{ return f._methodKey == InvokableMethod; }
-
-int Function::methodKey() const
-{ return f._methodKey; }
-
-void Function::setMethodKey(int key)
-{ f._methodKey = key; }
-
 bool Function::isSignatureEqualTo(const Function *other, Matcher *matcher) const
 {
     if (! other)
@@ -409,12 +325,6 @@ FullySpecifiedType Function::type() const
     return ty;
 }
 
-FullySpecifiedType Function::returnType() const
-{ return _returnType; }
-
-void Function::setReturnType(const FullySpecifiedType &returnType)
-{ _returnType = returnType; }
-
 bool Function::hasReturnType() const
 {
     const FullySpecifiedType ty = returnType();
@@ -431,7 +341,7 @@ int Function::argumentCount() const
     // arguments with a lambda as default argument will also have more blocks.
     int argc = 0;
     for (int it = 0; it < memCnt; ++it)
-        if (memberAt(it)->isArgument())
+        if (memberAt(it)->asArgument())
             ++argc;
     return argc;
 }
@@ -470,66 +380,6 @@ int Function::minimumArgumentCount() const
     return index;
 }
 
-bool Function::isVirtual() const
-{ return f._isVirtual; }
-
-void Function::setVirtual(bool isVirtual)
-{ f._isVirtual = isVirtual; }
-
-bool Function::isOverride() const
-{ return f._isOverride; }
-
-void Function::setOverride(bool isOverride)
-{ f._isOverride = isOverride; }
-
-bool Function::isFinal() const
-{ return f._isFinal; }
-
-void Function::setFinal(bool isFinal)
-{ f._isFinal = isFinal; }
-
-bool Function::isVariadic() const
-{ return f._isVariadic; }
-
-void Function::setVariadic(bool isVariadic)
-{ f._isVariadic = isVariadic; }
-
-bool Function::isVariadicTemplate() const
-{ return f._isVariadicTemplate; }
-
-void Function::setVariadicTemplate(bool isVariadicTemplate)
-{ f._isVariadicTemplate = isVariadicTemplate; }
-
-bool Function::isConst() const
-{ return f._isConst; }
-
-void Function::setConst(bool isConst)
-{ f._isConst = isConst; }
-
-bool Function::isVolatile() const
-{ return f._isVolatile; }
-
-void Function::setVolatile(bool isVolatile)
-{ f._isVolatile = isVolatile; }
-
-bool Function::isPureVirtual() const
-{ return f._isPureVirtual; }
-
-void Function::setPureVirtual(bool isPureVirtual)
-{ f._isPureVirtual = isPureVirtual; }
-
-Function::RefQualifier Function::refQualifier() const
-{ return static_cast<RefQualifier>(f._refQualifier); }
-
-void Function::setRefQualifier(Function::RefQualifier refQualifier)
-{ f._refQualifier = refQualifier; }
-
-bool Function::isAmbiguous() const
-{ return f._isAmbiguous; }
-
-void Function::setAmbiguous(bool isAmbiguous)
-{ f._isAmbiguous = isAmbiguous; }
-
 void Function::visitSymbol0(SymbolVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -569,11 +419,6 @@ bool Function::maybeValidPrototype(int actualArgumentCount) const
     return true;
 }
 
-const StringLiteral *Function::exceptionSpecification()
-{ return _exceptionSpecification; }
-
-void Function::setExceptionSpecification(const StringLiteral *spec)
-{ _exceptionSpecification = spec; }
 
 Block::Block(TranslationUnit *translationUnit, int sourceLocation)
     : Scope(translationUnit, sourceLocation, /*name = */ nullptr)
@@ -583,9 +428,6 @@ Block::Block(Clone *clone, Subst *subst, Block *original)
     : Scope(clone, subst, original)
 { }
 
-Block::~Block()
-{ }
-
 FullySpecifiedType Block::type() const
 { return FullySpecifiedType(); }
 
@@ -608,21 +450,9 @@ Enum::Enum(Clone *clone, Subst *subst, Enum *original)
     , _isScoped(original->isScoped())
 { }
 
-Enum::~Enum()
-{ }
-
 FullySpecifiedType Enum::type() const
 { return FullySpecifiedType(const_cast<Enum *>(this)); }
 
-bool Enum::isScoped() const
-{
-    return _isScoped;
-}
-
-void Enum::setScoped(bool scoped)
-{
-    _isScoped = scoped;
-}
 
 void Enum::accept0(TypeVisitor *visitor)
 { visitor->visit(this); }
@@ -652,9 +482,6 @@ Template::Template(Clone *clone, Subst *subst, Template *original)
     : Scope(clone, subst, original)
 { }
 
-Template::~Template()
-{ }
-
 int Template::templateParameterCount() const
 {
     if (declaration() != nullptr)
@@ -663,17 +490,14 @@ int Template::templateParameterCount() const
     return 0;
 }
 
-Symbol *Template::templateParameterAt(int index) const
-{ return memberAt(index); }
-
 Symbol *Template::declaration() const
 {
     if (isEmpty())
         return nullptr;
 
     if (Symbol *s = memberAt(memberCount() - 1)) {
-        if (s->isClass() || s->isForwardClassDeclaration() ||
-            s->isTemplate() || s->isFunction() || s->isDeclaration())
+        if (s->asClass() || s->asForwardClassDeclaration() ||
+            s->asTemplate() || s->asFunction() || s->asDeclaration())
             return s;
     }
 
@@ -712,9 +536,6 @@ Namespace::Namespace(Clone *clone, Subst *subst, Namespace *original)
     , _isInline(original->_isInline)
 { }
 
-Namespace::~Namespace()
-{ }
-
 void Namespace::accept0(TypeVisitor *visitor)
 { visitor->visit(this); }
 
@@ -749,30 +570,10 @@ BaseClass::BaseClass(Clone *clone, Subst *subst, BaseClass *original)
     , _type(clone->type(original->_type, subst))
 { }
 
-BaseClass::~BaseClass()
-{ }
-
-FullySpecifiedType BaseClass::type() const
-{ return _type; }
-
-void BaseClass::setType(const FullySpecifiedType &type)
-{ _type = type; }
-
-bool BaseClass::isVirtual() const
-{ return _isVirtual; }
-
-void BaseClass::setVirtual(bool isVirtual)
-{ _isVirtual = isVirtual; }
-
-bool BaseClass::isVariadic() const
-{ return _isVariadic; }
-
-void BaseClass::setVariadic(bool isVariadic)
-{ _isVariadic = isVariadic; }
-
 void BaseClass::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
+
 ForwardClassDeclaration::ForwardClassDeclaration(TranslationUnit *translationUnit,
                                                  int sourceLocation, const Name *name)
     : Symbol(translationUnit, sourceLocation, name)
@@ -782,9 +583,6 @@ ForwardClassDeclaration::ForwardClassDeclaration(Clone *clone, Subst *subst, For
     : Symbol(clone, subst, original)
 { }
 
-ForwardClassDeclaration::~ForwardClassDeclaration()
-{ }
-
 FullySpecifiedType ForwardClassDeclaration::type() const
 { return FullySpecifiedType(const_cast<ForwardClassDeclaration *>(this)); }
 
@@ -815,24 +613,6 @@ Class::Class(Clone *clone, Subst *subst, Class *original)
         addBaseClass(clone->symbol(original->_baseClasses.at(i), subst)->asBaseClass());
 }
 
-Class::~Class()
-{ }
-
-bool Class::isClass() const
-{ return _key == ClassKey; }
-
-bool Class::isStruct() const
-{ return _key == StructKey; }
-
-bool Class::isUnion() const
-{ return _key == UnionKey; }
-
-Class::Key Class::classKey() const
-{ return _key; }
-
-void Class::setClassKey(Key key)
-{ _key = key; }
-
 void Class::accept0(TypeVisitor *visitor)
 { visitor->visit(this); }
 
@@ -880,21 +660,6 @@ QtPropertyDeclaration::QtPropertyDeclaration(Clone *clone, Subst *subst, QtPrope
     , _flags(original->_flags)
 { }
 
-QtPropertyDeclaration::~QtPropertyDeclaration()
-{ }
-
-void QtPropertyDeclaration::setType(const FullySpecifiedType &type)
-{ _type = type; }
-
-void QtPropertyDeclaration::setFlags(int flags)
-{ _flags = flags; }
-
-int QtPropertyDeclaration::flags() const
-{ return _flags; }
-
-FullySpecifiedType QtPropertyDeclaration::type() const
-{ return _type; }
-
 void QtPropertyDeclaration::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
@@ -907,12 +672,6 @@ QtEnum::QtEnum(Clone *clone, Subst *subst, QtEnum *original)
     : Symbol(clone, subst, original)
 { }
 
-QtEnum::~QtEnum()
-{ }
-
-FullySpecifiedType QtEnum::type() const
-{ return FullySpecifiedType(); }
-
 void QtEnum::visitSymbol0(SymbolVisitor *visitor)
 { visitor->visit(this); }
 
@@ -925,8 +684,6 @@ ObjCBaseClass::ObjCBaseClass(Clone *clone, Subst *subst, ObjCBaseClass *original
     : Symbol(clone, subst, original)
 { }
 
-ObjCBaseClass::~ObjCBaseClass()
-{ }
 
 FullySpecifiedType ObjCBaseClass::type() const
 { return FullySpecifiedType(); }
@@ -942,9 +699,6 @@ ObjCBaseProtocol::ObjCBaseProtocol(Clone *clone, Subst *subst, ObjCBaseProtocol
     : Symbol(clone, subst, original)
 { }
 
-ObjCBaseProtocol::~ObjCBaseProtocol()
-{ }
-
 FullySpecifiedType ObjCBaseProtocol::type() const
 { return FullySpecifiedType(); }
 
@@ -970,30 +724,6 @@ ObjCClass::ObjCClass(Clone *clone, Subst *subst, ObjCClass *original)
         addProtocol(clone->symbol(original->_protocols.at(i), subst)->asObjCBaseProtocol());
 }
 
-ObjCClass::~ObjCClass()
-{}
-
-bool ObjCClass::isInterface() const
-{ return _isInterface; }
-
-void ObjCClass::setInterface(bool isInterface)
-{ _isInterface = isInterface; }
-
-bool ObjCClass::isCategory() const
-{ return _categoryName != nullptr; }
-
-const Name *ObjCClass::categoryName() const
-{ return _categoryName; }
-
-void ObjCClass::setCategoryName(const Name *categoryName)
-{ _categoryName = categoryName; }
-
-ObjCBaseClass *ObjCClass::baseClass() const
-{ return _baseClass; }
-
-void ObjCClass::setBaseClass(ObjCBaseClass *baseClass)
-{ _baseClass = baseClass; }
-
 int ObjCClass::protocolCount() const
 { return int(_protocols.size()); }
 
@@ -1043,9 +773,6 @@ ObjCProtocol::ObjCProtocol(Clone *clone, Subst *subst, ObjCProtocol *original)
         addProtocol(clone->symbol(original->_protocols.at(i), subst)->asObjCBaseProtocol());
 }
 
-ObjCProtocol::~ObjCProtocol()
-{}
-
 int ObjCProtocol::protocolCount() const
 { return int(_protocols.size()); }
 
@@ -1087,9 +814,6 @@ ObjCForwardClassDeclaration::ObjCForwardClassDeclaration(Clone *clone, Subst *su
     : Symbol(clone, subst, original)
 { }
 
-ObjCForwardClassDeclaration::~ObjCForwardClassDeclaration()
-{}
-
 FullySpecifiedType ObjCForwardClassDeclaration::type() const
 { return FullySpecifiedType(); }
 
@@ -1117,9 +841,6 @@ ObjCForwardProtocolDeclaration::ObjCForwardProtocolDeclaration(Clone *clone, Sub
     : Symbol(clone, subst, original)
 { }
 
-ObjCForwardProtocolDeclaration::~ObjCForwardProtocolDeclaration()
-{}
-
 FullySpecifiedType ObjCForwardProtocolDeclaration::type() const
 { return FullySpecifiedType(); }
 
@@ -1148,9 +869,6 @@ ObjCMethod::ObjCMethod(Clone *clone, Subst *subst, ObjCMethod *original)
     , _flags(original->_flags)
 { }
 
-ObjCMethod::~ObjCMethod()
-{ }
-
 void ObjCMethod::accept0(TypeVisitor *visitor)
 { visitor->visit(this); }
 
@@ -1165,12 +883,6 @@ bool ObjCMethod::match0(const Type *otherType, Matcher *matcher) const
 FullySpecifiedType ObjCMethod::type() const
 { return FullySpecifiedType(const_cast<ObjCMethod *>(this)); }
 
-FullySpecifiedType ObjCMethod::returnType() const
-{ return _returnType; }
-
-void ObjCMethod::setReturnType(const FullySpecifiedType &returnType)
-{ _returnType = returnType; }
-
 bool ObjCMethod::hasReturnType() const
 {
     const FullySpecifiedType ty = returnType();
@@ -1180,7 +892,7 @@ bool ObjCMethod::hasReturnType() const
 int ObjCMethod::argumentCount() const
 {
     const int c = memberCount();
-    if (c > 0 && memberAt(c - 1)->isBlock())
+    if (c > 0 && memberAt(c - 1)->asBlock())
         return c - 1;
     return c;
 }
@@ -1196,12 +908,6 @@ bool ObjCMethod::hasArguments() const
               (argumentCount() == 1 && argumentAt(0)->type()->isVoidType()));
 }
 
-bool ObjCMethod::isVariadic() const
-{ return f._isVariadic; }
-
-void ObjCMethod::setVariadic(bool isVariadic)
-{ f._isVariadic = isVariadic; }
-
 void ObjCMethod::visitSymbol0(SymbolVisitor *visitor)
 {
     if (visitor->visit(this)) {
@@ -1228,39 +934,6 @@ ObjCPropertyDeclaration::ObjCPropertyDeclaration(Clone *clone, Subst *subst, Obj
     , _propertyAttributes(original->_propertyAttributes)
 { }
 
-ObjCPropertyDeclaration::~ObjCPropertyDeclaration()
-{}
-
-bool ObjCPropertyDeclaration::hasAttribute(int attribute) const
-{ return _propertyAttributes & attribute; }
-
-void ObjCPropertyDeclaration::setAttributes(int attributes)
-{ _propertyAttributes = attributes; }
-
-bool ObjCPropertyDeclaration::hasGetter() const
-{ return hasAttribute(Getter); }
-
-bool ObjCPropertyDeclaration::hasSetter() const
-{ return hasAttribute(Setter); }
-
-const Name *ObjCPropertyDeclaration::getterName() const
-{ return _getterName; }
-
-void ObjCPropertyDeclaration::setGetterName(const Name *getterName)
-{ _getterName = getterName; }
-
-const Name *ObjCPropertyDeclaration::setterName() const
-{ return _setterName; }
-
-void ObjCPropertyDeclaration::setSetterName(const Name *setterName)
-{ _setterName = setterName; }
-
-void ObjCPropertyDeclaration::setType(const FullySpecifiedType &type)
-{ _type = type; }
-
-FullySpecifiedType ObjCPropertyDeclaration::type() const
-{ return _type; }
-
 void ObjCPropertyDeclaration::visitSymbol0(SymbolVisitor *visitor)
 {
     if (visitor->visit(this)) {
diff --git a/src/libs/3rdparty/cplusplus/Symbols.h b/src/libs/3rdparty/cplusplus/Symbols.h
index eb926a1b86..da29692e7b 100644
--- a/src/libs/3rdparty/cplusplus/Symbols.h
+++ b/src/libs/3rdparty/cplusplus/Symbols.h
@@ -31,64 +31,55 @@ namespace CPlusPlus {
 
 class StringLiteral;
 
-class CPLUSPLUS_EXPORT UsingNamespaceDirective: public Symbol
+class CPLUSPLUS_EXPORT UsingNamespaceDirective final : public Symbol
 {
 public:
     UsingNamespaceDirective(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     UsingNamespaceDirective(Clone *clone, Subst *subst, UsingNamespaceDirective *original);
-    virtual ~UsingNamespaceDirective();
+    ~UsingNamespaceDirective() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const UsingNamespaceDirective *asUsingNamespaceDirective() const override
-    { return this; }
-
-    UsingNamespaceDirective *asUsingNamespaceDirective() override
-    { return this; }
+    const UsingNamespaceDirective *asUsingNamespaceDirective() const override { return this; }
+    UsingNamespaceDirective *asUsingNamespaceDirective() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
-class CPLUSPLUS_EXPORT UsingDeclaration: public Symbol
+class CPLUSPLUS_EXPORT UsingDeclaration final : public Symbol
 {
 public:
     UsingDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     UsingDeclaration(Clone *clone, Subst *subst, UsingDeclaration *original);
-    virtual ~UsingDeclaration();
+    ~UsingDeclaration() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const UsingDeclaration *asUsingDeclaration() const override
-    { return this; }
-
-    UsingDeclaration *asUsingDeclaration() override
-    { return this; }
+    const UsingDeclaration *asUsingDeclaration() const override { return this; }
+    UsingDeclaration *asUsingDeclaration() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
-class CPLUSPLUS_EXPORT NamespaceAlias: public Symbol
+class CPLUSPLUS_EXPORT NamespaceAlias final : public Symbol
 {
 public:
     NamespaceAlias(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     NamespaceAlias(Clone *clone, Subst *subst, NamespaceAlias *original);
-    virtual ~NamespaceAlias();
+    ~NamespaceAlias() override = default;
 
-    const Name *namespaceName() const;
-    void setNamespaceName(const Name *namespaceName);
+    const Name *namespaceName() const { return _namespaceName; }
+    void setNamespaceName(const Name *namespaceName) { _namespaceName = namespaceName; }
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const NamespaceAlias *asNamespaceAlias() const override
-    { return this; }
-
-    NamespaceAlias *asNamespaceAlias() override
-    { return this; }
+    const NamespaceAlias *asNamespaceAlias() const override { return this; }
+    NamespaceAlias *asNamespaceAlias() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -97,31 +88,25 @@ private:
     const Name *_namespaceName;
 };
 
-class CPLUSPLUS_EXPORT Declaration: public Symbol
+class CPLUSPLUS_EXPORT Declaration : public Symbol
 {
 public:
     Declaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Declaration(Clone *clone, Subst *subst, Declaration *original);
-    virtual ~Declaration();
+    ~Declaration() override = default;
 
-    void setType(const FullySpecifiedType &type);
-    void setInitializer(StringLiteral const* initializer);
+    void setType(const FullySpecifiedType &type) { _type = type; }
+    void setInitializer(StringLiteral const* initializer) { _initializer = initializer; }
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
-    const StringLiteral *getInitializer() const;
+    FullySpecifiedType type() const override { return _type; }
+    const StringLiteral *getInitializer() const { return _initializer; }
 
-    const Declaration *asDeclaration() const override
-    { return this; }
+    const Declaration *asDeclaration() const override { return this; }
+    Declaration *asDeclaration() override { return this; }
 
-    Declaration *asDeclaration() override
-    { return this; }
-
-    virtual EnumeratorDeclaration *asEnumeratorDeclarator()
-    { return nullptr; }
-
-    virtual const EnumeratorDeclaration *asEnumeratorDeclarator() const
-    { return nullptr; }
+    virtual EnumeratorDeclaration *asEnumeratorDeclarator() { return nullptr; }
+    virtual const EnumeratorDeclaration *asEnumeratorDeclarator() const { return nullptr; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -131,47 +116,41 @@ private:
     const StringLiteral *_initializer;
 };
 
-class CPLUSPLUS_EXPORT EnumeratorDeclaration: public Declaration
+class CPLUSPLUS_EXPORT EnumeratorDeclaration final : public Declaration
 {
 public:
     EnumeratorDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
-    virtual ~EnumeratorDeclaration();
-
-    const StringLiteral *constantValue() const;
-    void setConstantValue(const StringLiteral *constantValue);
+    ~EnumeratorDeclaration() override = default;
 
-    EnumeratorDeclaration *asEnumeratorDeclarator() override
-    { return this; }
+    const StringLiteral *constantValue() const { return _constantValue; }
+    void setConstantValue(const StringLiteral *constantValue) { _constantValue = constantValue; }
 
-    const EnumeratorDeclaration *asEnumeratorDeclarator() const override
-    { return this; }
+    EnumeratorDeclaration *asEnumeratorDeclarator() override { return this; }
+    const EnumeratorDeclaration *asEnumeratorDeclarator() const override { return this; }
 
 private:
     const StringLiteral *_constantValue;
 };
 
-class CPLUSPLUS_EXPORT Argument: public Symbol
+class CPLUSPLUS_EXPORT Argument final : public Symbol
 {
 public:
     Argument(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Argument(Clone *clone, Subst *subst, Argument *original);
-    virtual ~Argument();
+    ~Argument() override = default;
 
-    void setType(const FullySpecifiedType &type);
+    void setType(const FullySpecifiedType &type) { _type = type; }
 
-    bool hasInitializer() const;
+    bool hasInitializer() const { return _initializer != nullptr; }
 
-    const StringLiteral *initializer() const;
-    void setInitializer(const StringLiteral *initializer);
+    const StringLiteral *initializer() const { return _initializer; }
+    void setInitializer(const StringLiteral *initializer) { _initializer = initializer; }
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
-
-    const Argument *asArgument() const override
-    { return this; }
+    FullySpecifiedType type() const override { return _type; }
 
-    Argument *asArgument() override
-    { return this; }
+    const Argument *asArgument() const override { return this; }
+    Argument *asArgument() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -181,25 +160,22 @@ private:
     FullySpecifiedType _type;
 };
 
-class CPLUSPLUS_EXPORT TypenameArgument: public Symbol
+class CPLUSPLUS_EXPORT TypenameArgument final : public Symbol
 {
 public:
     TypenameArgument(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     TypenameArgument(Clone *clone, Subst *subst, TypenameArgument *original);
-    virtual ~TypenameArgument();
+    ~TypenameArgument() = default;
 
-    void setType(const FullySpecifiedType &type);
+    void setType(const FullySpecifiedType &type) { _type = type; }
     void setClassDeclarator(bool isClassDecl) { _isClassDeclarator = isClassDecl; }
     bool isClassDeclarator() const { return _isClassDeclarator; }
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
+    FullySpecifiedType type() const override { return _type; }
 
-    const TypenameArgument *asTypenameArgument() const override
-    { return this; }
-
-    TypenameArgument *asTypenameArgument() override
-    { return this; }
+    const TypenameArgument *asTypenameArgument() const override { return this; }
+    TypenameArgument *asTypenameArgument() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -209,12 +185,12 @@ private:
     bool _isClassDeclarator;
 };
 
-class CPLUSPLUS_EXPORT Block: public Scope
+class CPLUSPLUS_EXPORT Block final : public Scope
 {
 public:
     Block(TranslationUnit *translationUnit, int sourceLocation);
     Block(Clone *clone, Subst *subst, Block *original);
-    virtual ~Block();
+    ~Block() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
@@ -229,28 +205,22 @@ protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
-class CPLUSPLUS_EXPORT ForwardClassDeclaration: public Symbol, public Type
+class CPLUSPLUS_EXPORT ForwardClassDeclaration final : public Symbol, public Type
 {
 public:
     ForwardClassDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ForwardClassDeclaration(Clone *clone, Subst *subst, ForwardClassDeclaration *original);
-    virtual ~ForwardClassDeclaration();
+    ~ForwardClassDeclaration() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ForwardClassDeclaration *asForwardClassDeclaration() const override
-    { return this; }
-
-    ForwardClassDeclaration *asForwardClassDeclaration() override
-    { return this; }
+    const ForwardClassDeclaration *asForwardClassDeclaration() const override { return this; }
+    ForwardClassDeclaration *asForwardClassDeclaration() override { return this; }
 
     // Type's interface
-    const ForwardClassDeclaration *asForwardClassDeclarationType() const override
-    { return this; }
-
-    ForwardClassDeclaration *asForwardClassDeclarationType() override
-    { return this; }
+    const ForwardClassDeclaration *asForwardClassDeclarationType() const override { return this; }
+    ForwardClassDeclaration *asForwardClassDeclarationType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -258,31 +228,25 @@ protected:
     bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
-class CPLUSPLUS_EXPORT Enum: public Scope, public Type
+class CPLUSPLUS_EXPORT Enum final : public Scope, public Type
 {
 public:
     Enum(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Enum(Clone *clone, Subst *subst, Enum *original);
-    virtual ~Enum();
+    ~Enum() override = default;
 
-    bool isScoped() const;
-    void setScoped(bool scoped);
+    bool isScoped() const { return _isScoped; }
+    void setScoped(bool scoped) { _isScoped = scoped; }
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const Enum *asEnum() const override
-    { return this; }
-
-    Enum *asEnum() override
-    { return this; }
+    const Enum *asEnum() const override { return this; }
+    Enum *asEnum() override { return this; }
 
     // Type's interface
-    const Enum *asEnumType() const override
-    { return this; }
-
-    Enum *asEnumType() override
-    { return this; }
+    const Enum *asEnumType() const override { return this; }
+    Enum *asEnumType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -293,7 +257,7 @@ private:
     bool _isScoped;
 };
 
-class CPLUSPLUS_EXPORT Function: public Scope, public Type
+class CPLUSPLUS_EXPORT Function final : public Scope, public Type
 {
 public:
     enum MethodKey {
@@ -312,17 +276,18 @@ public:
 public:
     Function(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Function(Clone *clone, Subst *subst, Function *original);
-    virtual ~Function();
+    ~Function() override = default;
+
+    bool isNormal() const { return f._methodKey == NormalMethod; }
+    bool isSignal() const { return f._methodKey == SignalMethod; }
+    bool isSlot() const { return f._methodKey == SlotMethod; }
+    bool isInvokable() const { return f._methodKey == InvokableMethod; }
 
-    bool isNormal() const;
-    bool isSignal() const;
-    bool isSlot() const;
-    bool isInvokable() const;
-    int methodKey() const;
-    void setMethodKey(int key);
+    int methodKey() const { return f._methodKey; }
+    void setMethodKey(int key) { f._methodKey = key; }
 
-    FullySpecifiedType returnType() const;
-    void setReturnType(const FullySpecifiedType &returnType);
+    FullySpecifiedType returnType() const { return _returnType; }
+    void setReturnType(const FullySpecifiedType &returnType) { _returnType = returnType; }
 
     /** Convenience function that returns whether the function returns something (including void). */
     bool hasReturnType() const;
@@ -334,61 +299,55 @@ public:
     bool hasArguments() const;
     int minimumArgumentCount() const;
 
-    bool isVirtual() const;
-    void setVirtual(bool isVirtual);
+    bool isVirtual() const { return f._isVirtual; }
+    void setVirtual(bool isVirtual) { f._isVirtual = isVirtual; }
 
-    bool isOverride() const;
-    void setOverride(bool isOverride);
+    bool isOverride() const { return f._isOverride; }
+    void setOverride(bool isOverride) { f._isOverride = isOverride; }
 
-    bool isFinal() const;
-    void setFinal(bool isFinal);
+    bool isFinal() const { return f._isFinal; }
+    void setFinal(bool isFinal) { f._isFinal = isFinal; }
 
-    bool isVariadic() const;
-    void setVariadic(bool isVariadic);
+    bool isVariadic() const { return f._isVariadic; }
+    void setVariadic(bool isVariadic) { f._isVariadic = isVariadic; }
 
-    bool isVariadicTemplate() const;
-    void setVariadicTemplate(bool isVariadicTemplate);
+    bool isVariadicTemplate() const { return f._isVariadicTemplate; }
+    void setVariadicTemplate(bool isVariadicTemplate) { f._isVariadicTemplate = isVariadicTemplate; }
 
-    bool isConst() const;
-    void setConst(bool isConst);
+    bool isConst() const { return f._isConst; }
+    void setConst(bool isConst) { f._isConst = isConst; }
 
     bool isStatic() const { return f._isStatic; }
     void setStatic(bool isStatic) { f._isStatic = isStatic; }
 
-    bool isVolatile() const;
-    void setVolatile(bool isVolatile);
+    bool isVolatile() const { return f._isVolatile; }
+    void setVolatile(bool isVolatile) { f._isVolatile = isVolatile; }
 
-    bool isPureVirtual() const;
-    void setPureVirtual(bool isPureVirtual);
+    bool isPureVirtual() const { return f._isPureVirtual; }
+    void setPureVirtual(bool isPureVirtual) { f._isPureVirtual = isPureVirtual; }
 
-    RefQualifier refQualifier() const;
-    void setRefQualifier(RefQualifier refQualifier);
+    RefQualifier refQualifier() const { return static_cast<RefQualifier>(f._refQualifier); }
+    void setRefQualifier(RefQualifier refQualifier) { f._refQualifier = refQualifier; }
 
     bool isSignatureEqualTo(const Function *other, Matcher *matcher = nullptr) const;
 
-    bool isAmbiguous() const; // internal
-    void setAmbiguous(bool isAmbiguous); // internal
+    bool isAmbiguous() const { return f._isAmbiguous; } // internal
+    void setAmbiguous(bool isAmbiguous) { f._isAmbiguous = isAmbiguous; } // internal
 
     bool maybeValidPrototype(int actualArgumentCount) const;
 
-    const StringLiteral *exceptionSpecification();
-    void setExceptionSpecification(const StringLiteral *spec);
+    const StringLiteral *exceptionSpecification() { return _exceptionSpecification; }
+    void setExceptionSpecification(const StringLiteral *spec) { _exceptionSpecification = spec; }
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const Function *asFunction() const override
-    { return this; }
-
-    Function *asFunction() override
-    { return this; }
+    const Function *asFunction() const override { return this; }
+    Function *asFunction() override { return this; }
 
     // Type's interface
-    const Function *asFunctionType() const override
-    { return this; }
-
-    Function *asFunctionType() override
-    { return this; }
+    const Function *asFunctionType() const override { return this; }
+    Function *asFunctionType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -418,32 +377,26 @@ private:
     };
 };
 
-class CPLUSPLUS_EXPORT Template: public Scope, public Type
+class CPLUSPLUS_EXPORT Template final : public Scope, public Type
 {
 public:
     Template(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Template(Clone *clone, Subst *subst, Template *original);
-    virtual ~Template();
+    ~Template() override = default;
 
     int templateParameterCount() const;
-    Symbol *templateParameterAt(int index) const;
+    Symbol *templateParameterAt(int index) const { return memberAt(index); }
     Symbol *declaration() const;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const Template *asTemplate() const override
-    { return this; }
-
-    Template *asTemplate() override
-    { return this; }
+    const Template *asTemplate() const override { return this; }
+    Template *asTemplate() override { return this; }
 
     // Type's interface
-    const Template *asTemplateType() const override
-    { return this; }
-
-    Template *asTemplateType() override
-    { return this; }
+    const Template *asTemplateType() const override { return this; }
+    Template *asTemplateType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -452,34 +405,25 @@ protected:
 };
 
 
-class CPLUSPLUS_EXPORT Namespace: public Scope, public Type
+class CPLUSPLUS_EXPORT Namespace final : public Scope, public Type
 {
 public:
     Namespace(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Namespace(Clone *clone, Subst *subst, Namespace *original);
-    virtual ~Namespace();
+    ~Namespace() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const Namespace *asNamespace() const override
-    { return this; }
-
-    Namespace *asNamespace() override
-    { return this; }
+    const Namespace *asNamespace() const override { return this; }
+    Namespace *asNamespace() override { return this; }
 
     // Type's interface
-    const Namespace *asNamespaceType() const override
-    { return this; }
-
-    Namespace *asNamespaceType() override
-    { return this; }
+    const Namespace *asNamespaceType() const override { return this; }
+    Namespace *asNamespaceType() override { return this; }
 
-    bool isInline() const
-    { return _isInline; }
-
-    void setInline(bool onoff)
-    { _isInline = onoff; }
+    bool isInline() const { return _isInline; }
+    void setInline(bool onoff) { _isInline = onoff; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -490,28 +434,25 @@ private:
     bool _isInline;
 };
 
-class CPLUSPLUS_EXPORT BaseClass: public Symbol
+class CPLUSPLUS_EXPORT BaseClass final : public Symbol
 {
 public:
     BaseClass(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     BaseClass(Clone *clone, Subst *subst, BaseClass *original);
-    virtual ~BaseClass();
+    ~BaseClass() override = default;
 
-    bool isVirtual() const;
-    void setVirtual(bool isVirtual);
+    bool isVirtual() const { return _isVirtual; }
+    void setVirtual(bool isVirtual) { _isVirtual = isVirtual; }
 
-    bool isVariadic() const;
-    void setVariadic(bool isVariadic);
+    bool isVariadic() const { return _isVariadic; }
+    void setVariadic(bool isVariadic) { _isVariadic = isVariadic; }
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
-    void setType(const FullySpecifiedType &type);
-
-    const BaseClass *asBaseClass() const override
-    { return this; }
+    FullySpecifiedType type() const override { return _type; }
+    void setType(const FullySpecifiedType &type) { _type = type; }
 
-    BaseClass *asBaseClass() override
-    { return this; }
+    const BaseClass *asBaseClass() const override { return this; }
+    BaseClass *asBaseClass() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -522,12 +463,12 @@ private:
     FullySpecifiedType _type;
 };
 
-class CPLUSPLUS_EXPORT Class: public Scope, public Type
+class CPLUSPLUS_EXPORT Class final : public Scope, public Type
 {
 public:
     Class(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     Class(Clone *clone, Subst *subst, Class *original);
-    virtual ~Class();
+    ~Class() override = default;
 
     enum Key {
         ClassKey,
@@ -535,11 +476,12 @@ public:
         UnionKey
     };
 
-    bool isClass() const;
-    bool isStruct() const;
-    bool isUnion() const;
-    Key classKey() const;
-    void setClassKey(Key key);
+    bool isClass() const { return _key == ClassKey; }
+    bool isStruct() const { return _key == StructKey; }
+    bool isUnion() const { return _key == UnionKey; }
+
+    Key classKey() const { return _key; }
+    void setClassKey(Key key) { _key = key; }
 
     int baseClassCount() const;
     BaseClass *baseClassAt(int index) const;
@@ -549,18 +491,12 @@ public:
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const Class *asClass() const override
-    { return this; }
-
-    Class *asClass() override
-    { return this; }
+    const Class *asClass() const override { return this; }
+    Class *asClass() override { return this; }
 
     // Type's interface
-    const Class *asClassType() const override
-    { return this; }
-
-    Class *asClassType() override
-    { return this; }
+    const Class *asClassType() const override { return this; }
+    Class *asClassType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -572,7 +508,7 @@ private:
     std::vector<BaseClass *> _baseClasses;
 };
 
-class CPLUSPLUS_EXPORT QtPropertyDeclaration: public Symbol
+class CPLUSPLUS_EXPORT QtPropertyDeclaration final : public Symbol
 {
 public:
     enum Flag {
@@ -597,21 +533,17 @@ public:
 public:
     QtPropertyDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     QtPropertyDeclaration(Clone *clone, Subst *subst, QtPropertyDeclaration *original);
-    virtual ~QtPropertyDeclaration();
-
-    void setType(const FullySpecifiedType &type);
+    ~QtPropertyDeclaration() = default;
 
-    void setFlags(int flags);
-    int flags() const;
+    void setType(const FullySpecifiedType &type) { _type = type; }
+    void setFlags(int flags) { _flags = flags; }
+    int flags() const { return _flags; }
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
+    FullySpecifiedType type() const override { return _type; }
 
-    const QtPropertyDeclaration *asQtPropertyDeclaration() const override
-    { return this; }
-
-    QtPropertyDeclaration *asQtPropertyDeclaration() override
-    { return this; }
+    const QtPropertyDeclaration *asQtPropertyDeclaration() const override { return this; }
+    QtPropertyDeclaration *asQtPropertyDeclaration() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -621,88 +553,73 @@ private:
     int _flags;
 };
 
-class CPLUSPLUS_EXPORT QtEnum: public Symbol
+class CPLUSPLUS_EXPORT QtEnum final : public Symbol
 {
 public:
     QtEnum(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     QtEnum(Clone *clone, Subst *subst, QtEnum *original);
-    virtual ~QtEnum();
+    ~QtEnum() override = default;
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
+    FullySpecifiedType type() const override { return FullySpecifiedType(); }
 
-    const QtEnum *asQtEnum() const override
-    { return this; }
-
-    QtEnum *asQtEnum() override
-    { return this; }
+    const QtEnum *asQtEnum() const override { return this; }
+    QtEnum *asQtEnum() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
-class CPLUSPLUS_EXPORT ObjCBaseClass: public Symbol
+class CPLUSPLUS_EXPORT ObjCBaseClass final : public Symbol
 {
 public:
     ObjCBaseClass(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCBaseClass(Clone *clone, Subst *subst, ObjCBaseClass *original);
-    virtual ~ObjCBaseClass();
+    ~ObjCBaseClass() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCBaseClass *asObjCBaseClass() const override
-    { return this; }
-
-    ObjCBaseClass *asObjCBaseClass() override
-    { return this; }
+    const ObjCBaseClass *asObjCBaseClass() const override { return this; }
+    ObjCBaseClass *asObjCBaseClass() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
-class CPLUSPLUS_EXPORT ObjCBaseProtocol: public Symbol
+class CPLUSPLUS_EXPORT ObjCBaseProtocol final : public Symbol
 {
 public:
     ObjCBaseProtocol(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCBaseProtocol(Clone *clone, Subst *subst, ObjCBaseProtocol *original);
-    virtual ~ObjCBaseProtocol();
+    ~ObjCBaseProtocol() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCBaseProtocol *asObjCBaseProtocol() const override
-    { return this; }
-
-    ObjCBaseProtocol *asObjCBaseProtocol() override
-    { return this; }
+    const ObjCBaseProtocol *asObjCBaseProtocol() const override { return this; }
+    ObjCBaseProtocol *asObjCBaseProtocol() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
 };
 
-class CPLUSPLUS_EXPORT ObjCForwardProtocolDeclaration: public Symbol, public Type
+class CPLUSPLUS_EXPORT ObjCForwardProtocolDeclaration final : public Symbol, public Type
 {
 public:
     ObjCForwardProtocolDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCForwardProtocolDeclaration(Clone *clone, Subst *subst, ObjCForwardProtocolDeclaration *original);
-    virtual ~ObjCForwardProtocolDeclaration();
+    ~ObjCForwardProtocolDeclaration() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() const override
-    { return this; }
-
-    ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() override
-    { return this; }
+    const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() const override { return this; }
+    ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclaration() override { return this; }
 
     // Type's interface
-    const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() const override
-    { return this; }
-
-    ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() override
-    { return this; }
+    const ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() const override { return this; }
+    ObjCForwardProtocolDeclaration *asObjCForwardProtocolDeclarationType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -710,12 +627,12 @@ protected:
     bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
-class CPLUSPLUS_EXPORT ObjCProtocol: public Scope, public Type
+class CPLUSPLUS_EXPORT ObjCProtocol final : public Scope, public Type
 {
 public:
     ObjCProtocol(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCProtocol(Clone *clone, Subst *subst, ObjCProtocol *original);
-    virtual ~ObjCProtocol();
+    ~ObjCProtocol() override = default;
 
     int protocolCount() const;
     ObjCBaseProtocol *protocolAt(int index) const;
@@ -724,18 +641,12 @@ public:
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCProtocol *asObjCProtocol() const override
-    { return this; }
-
-    ObjCProtocol *asObjCProtocol() override
-    { return this; }
+    const ObjCProtocol *asObjCProtocol() const override { return this; }
+    ObjCProtocol *asObjCProtocol() override { return this; }
 
     // Type's interface
-    const ObjCProtocol *asObjCProtocolType() const override
-    { return this; }
-
-    ObjCProtocol *asObjCProtocolType() override
-    { return this; }
+    const ObjCProtocol *asObjCProtocolType() const override { return this; }
+    ObjCProtocol *asObjCProtocolType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -746,28 +657,22 @@ private:
     std::vector<ObjCBaseProtocol *> _protocols;
 };
 
-class CPLUSPLUS_EXPORT ObjCForwardClassDeclaration: public Symbol, public Type
+class CPLUSPLUS_EXPORT ObjCForwardClassDeclaration final : public Symbol, public Type
 {
 public:
     ObjCForwardClassDeclaration(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCForwardClassDeclaration(Clone *clone, Subst *subst, ObjCForwardClassDeclaration *original);
-    virtual ~ObjCForwardClassDeclaration();
+    ~ObjCForwardClassDeclaration() override = default;
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() const override
-    { return this; }
-
-    ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() override
-    { return this; }
+    const ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() const override { return this; }
+    ObjCForwardClassDeclaration *asObjCForwardClassDeclaration() override { return this; }
 
     // Type's interface
-    const ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() const override
-    { return this; }
-
-    ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() override
-    { return this; }
+    const ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() const override { return this; }
+    ObjCForwardClassDeclaration *asObjCForwardClassDeclarationType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -775,22 +680,22 @@ protected:
     bool match0(const Type *otherType, Matcher *matcher) const override;
 };
 
-class CPLUSPLUS_EXPORT ObjCClass: public Scope, public Type
+class CPLUSPLUS_EXPORT ObjCClass final : public Scope, public Type
 {
 public:
     ObjCClass(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCClass(Clone *clone, Subst *subst, ObjCClass *original);
-    virtual ~ObjCClass();
+    ~ObjCClass() override = default;
 
-    bool isInterface() const;
-    void setInterface(bool isInterface);
+    bool isInterface() const { return _isInterface; }
+    void setInterface(bool isInterface) { _isInterface = isInterface; }
 
-    bool isCategory() const;
-    const Name *categoryName() const;
-    void setCategoryName(const Name *categoryName);
+    bool isCategory() const { return _categoryName != nullptr; }
+    const Name *categoryName() const { return _categoryName; }
+    void setCategoryName(const Name *categoryName) { _categoryName = categoryName; }
 
-    ObjCBaseClass *baseClass() const;
-    void setBaseClass(ObjCBaseClass *baseClass);
+    ObjCBaseClass *baseClass() const { return _baseClass; }
+    void setBaseClass(ObjCBaseClass *baseClass) { _baseClass = baseClass; }
 
     int protocolCount() const;
     ObjCBaseProtocol *protocolAt(int index) const;
@@ -799,18 +704,12 @@ public:
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCClass *asObjCClass() const override
-    { return this; }
-
-    ObjCClass *asObjCClass() override
-    { return this; }
+    const ObjCClass *asObjCClass() const override { return this; }
+    ObjCClass *asObjCClass() override { return this; }
 
     // Type's interface
-    const ObjCClass *asObjCClassType() const override
-    { return this; }
-
-    ObjCClass *asObjCClassType() override
-    { return this; }
+    const ObjCClass *asObjCClassType() const override { return this; }
+    ObjCClass *asObjCClassType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -824,15 +723,15 @@ private:
     bool _isInterface;
 };
 
-class CPLUSPLUS_EXPORT ObjCMethod: public Scope, public Type
+class CPLUSPLUS_EXPORT ObjCMethod final : public Scope, public Type
 {
 public:
     ObjCMethod(TranslationUnit *translationUnit, int sourceLocation, const Name *name);
     ObjCMethod(Clone *clone, Subst *subst, ObjCMethod *original);
-    virtual ~ObjCMethod();
+    ~ObjCMethod() override = default;
 
-    FullySpecifiedType returnType() const;
-    void setReturnType(const FullySpecifiedType &returnType);
+    FullySpecifiedType returnType() const { return _returnType; }
+    void setReturnType(const FullySpecifiedType &returnType) { _returnType = returnType; }
 
     /** Convenience function that returns whether the function returns something (including void). */
     bool hasReturnType() const;
@@ -843,24 +742,18 @@ public:
     /** Convenience function that returns whether the function receives any arguments. */
     bool hasArguments() const;
 
-    bool isVariadic() const;
-    void setVariadic(bool isVariadic);
+    bool isVariadic() const { return f._isVariadic; }
+    void setVariadic(bool isVariadic) { f._isVariadic = isVariadic; }
 
     // Symbol's interface
     FullySpecifiedType type() const override;
 
-    const ObjCMethod *asObjCMethod() const override
-    { return this; }
-
-    ObjCMethod *asObjCMethod() override
-    { return this; }
+    const ObjCMethod *asObjCMethod() const override { return this; }
+    ObjCMethod *asObjCMethod() override { return this; }
 
     // Type's interface
-    const ObjCMethod *asObjCMethodType() const override
-    { return this; }
-
-    ObjCMethod *asObjCMethodType() override
-    { return this; }
+    const ObjCMethod *asObjCMethodType() const override { return this; }
+    ObjCMethod *asObjCMethodType() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
@@ -878,7 +771,7 @@ private:
     };
 };
 
-class CPLUSPLUS_EXPORT ObjCPropertyDeclaration: public Symbol
+class CPLUSPLUS_EXPORT ObjCPropertyDeclaration final : public Symbol
 {
 public:
     enum PropertyAttributes {
@@ -901,31 +794,27 @@ public:
                             int sourceLocation,
                             const Name *name);
     ObjCPropertyDeclaration(Clone *clone, Subst *subst, ObjCPropertyDeclaration *original);
-    virtual ~ObjCPropertyDeclaration();
+    ~ObjCPropertyDeclaration() override = default;
 
-    bool hasAttribute(int attribute) const;
-    void setAttributes(int attributes);
+    bool hasAttribute(int attribute) const { return _propertyAttributes & attribute; }
+    void setAttributes(int attributes) { _propertyAttributes = attributes; }
 
-    bool hasGetter() const;
-    bool hasSetter() const;
+    bool hasGetter() const { return hasAttribute(Getter); }
+    bool hasSetter() const { return hasAttribute(Setter); }
 
-    const Name *getterName() const;
+    const Name *getterName() const { return _getterName; }
+    void setGetterName(const Name *getterName) { _getterName = getterName; }
 
-    void setGetterName(const Name *getterName);
+    const Name *setterName() const { return _setterName; }
+    void setSetterName(const Name *setterName) { _setterName = setterName; }
 
-    const Name *setterName() const;
-    void setSetterName(const Name *setterName);
-
-    void setType(const FullySpecifiedType &type);
+    void setType(const FullySpecifiedType &type) { _type = type; }
 
     // Symbol's interface
-    FullySpecifiedType type() const override;
+    FullySpecifiedType type() const override { return _type; }
 
-    const ObjCPropertyDeclaration *asObjCPropertyDeclaration() const override
-    { return this; }
-
-    ObjCPropertyDeclaration *asObjCPropertyDeclaration() override
-    { return this; }
+    const ObjCPropertyDeclaration *asObjCPropertyDeclaration() const override { return this; }
+    ObjCPropertyDeclaration *asObjCPropertyDeclaration() override { return this; }
 
 protected:
     void visitSymbol0(SymbolVisitor *visitor) override;
diff --git a/src/libs/cplusplus/CppDocument.cpp b/src/libs/cplusplus/CppDocument.cpp
index 90660f2b55..4db9109084 100644
--- a/src/libs/cplusplus/CppDocument.cpp
+++ b/src/libs/cplusplus/CppDocument.cpp
@@ -174,7 +174,7 @@ protected:
     bool visit(Template *symbol) override
     {
         if (Symbol *decl = symbol->declaration()) {
-            if (decl->isFunction() || decl->isClass() || decl->isDeclaration())
+            if (decl->asFunction() || decl->asClass() || decl->asDeclaration())
                 return process(symbol);
         }
         return true;
@@ -522,7 +522,7 @@ QString Document::functionAt(int line, int column, int *lineOpeningDeclaratorPar
     if (!scope)
         scope = symbol->enclosingScope();
 
-    while (scope && !scope->isFunction() )
+    while (scope && !scope->asFunction() )
         scope = scope->enclosingScope();
 
     if (!scope)
diff --git a/src/libs/cplusplus/CppRewriter.cpp b/src/libs/cplusplus/CppRewriter.cpp
index 14d738da79..e10d9aeec2 100644
--- a/src/libs/cplusplus/CppRewriter.cpp
+++ b/src/libs/cplusplus/CppRewriter.cpp
@@ -458,8 +458,8 @@ FullySpecifiedType UseMinimalNames::apply(const Name *name, Rewrite *rewrite) co
     SubstitutionEnvironment *env = rewrite->env;
     Scope *scope = env->scope();
 
-    if (name->isTemplateNameId() ||
-            (name->isQualifiedNameId() && name->asQualifiedNameId()->name()->isTemplateNameId()))
+    if (name->asTemplateNameId() ||
+            (name->asQualifiedNameId() && name->asQualifiedNameId()->name()->asTemplateNameId()))
         return FullySpecifiedType();
 
     if (! scope)
diff --git a/src/libs/cplusplus/FindUsages.cpp b/src/libs/cplusplus/FindUsages.cpp
index c82bbbf1fc..8ec65c021a 100644
--- a/src/libs/cplusplus/FindUsages.cpp
+++ b/src/libs/cplusplus/FindUsages.cpp
@@ -514,7 +514,7 @@ QString FindUsages::matchingLine(const Token &tk) const
 bool FindUsages::isLocalScope(Scope *scope)
 {
     if (scope) {
-        if (scope->isBlock() || scope->isTemplate() || scope->isFunction())
+        if (scope->asBlock() || scope->asTemplate() || scope->asFunction())
             return true;
     }
 
@@ -527,7 +527,7 @@ bool FindUsages::checkCandidates(const QList<LookupItem> &candidates) const
         const LookupItem &r = candidates.at(i);
 
         if (Symbol *s = r.declaration()) {
-            if (_declSymbol->isTypenameArgument()) {
+            if (_declSymbol->asTypenameArgument()) {
                 if (s != _declSymbol)
                     return false;
             }
@@ -535,8 +535,8 @@ bool FindUsages::checkCandidates(const QList<LookupItem> &candidates) const
             Scope *declEnclosingScope = _declSymbol->enclosingScope();
             Scope *enclosingScope = s->enclosingScope();
             if (isLocalScope(declEnclosingScope) || isLocalScope(enclosingScope)) {
-                if (_declSymbol->isClass() && declEnclosingScope->isTemplate()
-                        && s->isClass() && enclosingScope->isTemplate()) {
+                if (_declSymbol->asClass() && declEnclosingScope->asTemplate()
+                        && s->asClass() && enclosingScope->asTemplate()) {
                     // for definition of functions of class defined outside the class definition
                     Scope *templEnclosingDeclSymbol = declEnclosingScope;
                     Scope *scopeOfTemplEnclosingDeclSymbol
@@ -547,9 +547,9 @@ bool FindUsages::checkCandidates(const QList<LookupItem> &candidates) const
 
                     if (scopeOfTemplEnclosingCandidateSymbol != scopeOfTemplEnclosingDeclSymbol)
                         return false;
-                } else if (_declSymbol->isClass() && declEnclosingScope->isTemplate()
-                        && enclosingScope->isClass()
-                        && enclosingScope->enclosingScope()->isTemplate()) {
+                } else if (_declSymbol->asClass() && declEnclosingScope->asTemplate()
+                        && enclosingScope->asClass()
+                        && enclosingScope->enclosingScope()->asTemplate()) {
                     // for declaration inside template class
                     Scope *templEnclosingDeclSymbol = declEnclosingScope;
                     Scope *scopeOfTemplEnclosingDeclSymbol
@@ -560,18 +560,18 @@ bool FindUsages::checkCandidates(const QList<LookupItem> &candidates) const
 
                     if (scopeOfTemplEnclosingCandidateSymbol !=  scopeOfTemplEnclosingDeclSymbol)
                         return false;
-                } else if (enclosingScope->isTemplate() && ! _declSymbol->isTypenameArgument()) {
-                    if (declEnclosingScope->isTemplate()) {
+                } else if (enclosingScope->asTemplate() && ! _declSymbol->asTypenameArgument()) {
+                    if (declEnclosingScope->asTemplate()) {
                         if (enclosingScope->enclosingScope() != declEnclosingScope->enclosingScope())
                             return false;
                     } else {
                         if (enclosingScope->enclosingScope() != declEnclosingScope)
                             return false;
                     }
-                } else if (declEnclosingScope->isTemplate() && s->isTemplate()) {
+                } else if (declEnclosingScope->asTemplate() && s->asTemplate()) {
                     if (declEnclosingScope->enclosingScope() != enclosingScope)
                         return false;
-                } else if (! s->isUsingDeclaration()
+                } else if (! s->asUsingDeclaration()
                            && enclosingScope != declEnclosingScope) {
                     return false;
                 }
@@ -854,7 +854,7 @@ void FindUsages::memInitializer(MemInitializerAST *ast)
     if (! ast)
         return;
 
-    if (_currentScope->isFunction()) {
+    if (_currentScope->asFunction()) {
         Class *classScope = _currentScope->enclosingClass();
         if (! classScope) {
             if (ClassOrNamespace *binding = _context.lookupType(_currentScope)) {
diff --git a/src/libs/cplusplus/Icons.cpp b/src/libs/cplusplus/Icons.cpp
index e0d681563b..aaf258b557 100644
--- a/src/libs/cplusplus/Icons.cpp
+++ b/src/libs/cplusplus/Icons.cpp
@@ -57,7 +57,7 @@ Utils::CodeModelIcon::Type iconTypeForSymbol(const Symbol *symbol)
     }
 
     FullySpecifiedType symbolType = symbol->type();
-    if (symbol->isFunction() || (symbol->isDeclaration() && symbolType &&
+    if (symbol->asFunction() || (symbol->asDeclaration() && symbolType &&
                                  symbolType->isFunctionType()))
     {
         const Function *function = symbol->asFunction();
@@ -80,9 +80,9 @@ Utils::CodeModelIcon::Type iconTypeForSymbol(const Symbol *symbol)
         } else if (symbol->isPrivate()) {
             return symbol->isStatic() ? FuncPrivateStatic : FuncPrivate;
         }
-    } else if (symbol->enclosingScope() && symbol->enclosingScope()->isEnum()) {
+    } else if (symbol->enclosingScope() && symbol->enclosingScope()->asEnum()) {
         return Enumerator;
-    } else if (symbol->isDeclaration() || symbol->isArgument()) {
+    } else if (symbol->asDeclaration() || symbol->asArgument()) {
         if (symbol->isPublic()) {
             return symbol->isStatic() ? VarPublicStatic : VarPublic;
         } else if (symbol->isProtected()) {
@@ -90,26 +90,26 @@ Utils::CodeModelIcon::Type iconTypeForSymbol(const Symbol *symbol)
         } else if (symbol->isPrivate()) {
             return symbol->isStatic() ? VarPrivateStatic : VarPrivate;
         }
-    } else if (symbol->isEnum()) {
+    } else if (symbol->asEnum()) {
         return Utils::CodeModelIcon::Enum;
-    } else if (symbol->isForwardClassDeclaration()) {
+    } else if (symbol->asForwardClassDeclaration()) {
         return Utils::CodeModelIcon::Class; // TODO: Store class key in ForwardClassDeclaration
     } else if (const Class *klass = symbol->asClass()) {
         return klass->isStruct() ? Struct : Utils::CodeModelIcon::Class;
-    } else if (symbol->isObjCClass() || symbol->isObjCForwardClassDeclaration()) {
+    } else if (symbol->asObjCClass() || symbol->asObjCForwardClassDeclaration()) {
         return Utils::CodeModelIcon::Class;
-    } else if (symbol->isObjCProtocol() || symbol->isObjCForwardProtocolDeclaration()) {
+    } else if (symbol->asObjCProtocol() || symbol->asObjCForwardProtocolDeclaration()) {
         return Utils::CodeModelIcon::Class;
-    } else if (symbol->isObjCMethod()) {
+    } else if (symbol->asObjCMethod()) {
         return FuncPublic;
-    } else if (symbol->isNamespace()) {
+    } else if (symbol->asNamespace()) {
         return Utils::CodeModelIcon::Namespace;
-    } else if (symbol->isTypenameArgument()) {
+    } else if (symbol->asTypenameArgument()) {
         return Utils::CodeModelIcon::Class;
-    } else if (symbol->isQtPropertyDeclaration() || symbol->isObjCPropertyDeclaration()) {
+    } else if (symbol->asQtPropertyDeclaration() || symbol->asObjCPropertyDeclaration()) {
         return Property;
-    } else if (symbol->isUsingNamespaceDirective() ||
-               symbol->isUsingDeclaration()) {
+    } else if (symbol->asUsingNamespaceDirective() ||
+               symbol->asUsingDeclaration()) {
         // TODO: Might be nice to have a different icons for these things
         return Utils::CodeModelIcon::Namespace;
     }
diff --git a/src/libs/cplusplus/LookupContext.cpp b/src/libs/cplusplus/LookupContext.cpp
index 3aa39ea867..b3d3882ca0 100644
--- a/src/libs/cplusplus/LookupContext.cpp
+++ b/src/libs/cplusplus/LookupContext.cpp
@@ -56,7 +56,7 @@ static void addNames(const Name *name, QList<const Name *> *names, bool addAllNa
     if (const QualifiedNameId *q = name->asQualifiedNameId()) {
         addNames(q->base(), names);
         addNames(q->name(), names, addAllNames);
-    } else if (addAllNames || name->isNameId() || name->isTemplateNameId() || name->isAnonymousNameId()) {
+    } else if (addAllNames || name->asNameId() || name->asTemplateNameId() || name->asAnonymousNameId()) {
         names->append(name);
     }
 }
@@ -71,7 +71,7 @@ static void path_helper(Symbol *symbol,
     path_helper(symbol->enclosingScope(), names, policy);
 
     if (symbol->name()) {
-        if (symbol->isClass() || symbol->isNamespace()) {
+        if (symbol->asClass() || symbol->asNamespace()) {
             if (policy == LookupContext::HideInlineNamespaces) {
                 auto ns = symbol->asNamespace();
                 if (ns && ns->isInline())
@@ -79,12 +79,12 @@ static void path_helper(Symbol *symbol,
             }
             addNames(symbol->name(), names);
 
-        } else if (symbol->isObjCClass() || symbol->isObjCBaseClass() || symbol->isObjCProtocol()
-                || symbol->isObjCForwardClassDeclaration() || symbol->isObjCForwardProtocolDeclaration()
-                || symbol->isForwardClassDeclaration()) {
+        } else if (symbol->asObjCClass() || symbol->asObjCBaseClass() || symbol->asObjCProtocol()
+                || symbol->asObjCForwardClassDeclaration() || symbol->asObjCForwardProtocolDeclaration()
+                || symbol->asForwardClassDeclaration()) {
             addNames(symbol->name(), names);
 
-        } else if (symbol->isFunction()) {
+        } else if (symbol->asFunction()) {
             if (const QualifiedNameId *q = symbol->name()->asQualifiedNameId())
                 addNames(q->base(), names);
         } else if (Enum *e = symbol->asEnum()) {
@@ -316,7 +316,7 @@ QList<LookupItem> LookupContext::lookupByUsing(const Name *name,
 {
     QList<LookupItem> candidates;
     // if it is a nameId there can be a using declaration for it
-    if (name->isNameId() || name->isTemplateNameId()) {
+    if (name->asNameId() || name->asTemplateNameId()) {
         const QList<Symbol *> symbols = bindingScope->symbols();
         for (Symbol *s : symbols) {
             if (Scope *scope = s->asScope()) {
@@ -409,7 +409,7 @@ ClassOrNamespace *LookupContext::lookupType(const Name *name, Scope *scope,
                     }
                 }
             } else if (UsingDeclaration *ud = m->asUsingDeclaration()) {
-                if (name->isNameId()) {
+                if (name->asNameId()) {
                     if (const Name *usingDeclarationName = ud->name()) {
                         if (const QualifiedNameId *q = usingDeclarationName->asQualifiedNameId()) {
                             if (q->name() && q->name()->match(name))
@@ -433,7 +433,7 @@ ClassOrNamespace *LookupContext::lookupType(const Name *name, Scope *scope,
     } else if (ClassOrNamespace *b = bindings()->lookupType(scope, enclosingBinding)) {
         return b->lookupType(name);
     } else if (Class *scopeAsClass = scope->asClass()) {
-        if (scopeAsClass->enclosingScope()->isBlock()) {
+        if (scopeAsClass->enclosingScope()->asBlock()) {
             if (ClassOrNamespace *b = lookupType(scopeAsClass->name(),
                                                  scopeAsClass->enclosingScope(),
                                                  enclosingBinding,
@@ -460,13 +460,13 @@ QList<LookupItem> LookupContext::lookup(const Name *name, Scope *scope) const
         return candidates;
 
     for (; scope; scope = scope->enclosingScope()) {
-        if (name->identifier() != nullptr && scope->isBlock()) {
+        if (name->identifier() != nullptr && scope->asBlock()) {
             bindings()->lookupInScope(name, scope, &candidates, /*templateId = */ nullptr, /*binding=*/ nullptr);
 
             if (! candidates.isEmpty()) {
                 // it's a local.
                 //for qualified it can be outside of the local scope
-                if (name->isQualifiedNameId())
+                if (name->asQualifiedNameId())
                     continue;
                 else
                     break;
@@ -502,13 +502,13 @@ QList<LookupItem> LookupContext::lookup(const Name *name, Scope *scope) const
             if (! candidates.isEmpty()) {
                 // it's an argument or a template parameter.
                 //for qualified it can be outside of the local scope
-                if (name->isQualifiedNameId())
+                if (name->asQualifiedNameId())
                     continue;
                 else
                     break;
             }
 
-            if (fun->name() && fun->name()->isQualifiedNameId()) {
+            if (fun->name() && fun->name()->asQualifiedNameId()) {
                 if (ClassOrNamespace *binding = bindings()->lookupType(fun)) {
                     candidates = binding->find(name);
 
@@ -540,7 +540,7 @@ QList<LookupItem> LookupContext::lookup(const Name *name, Scope *scope) const
             if (! candidates.isEmpty()) {
                 // it's a template parameter.
                 //for qualified it can be outside of the local scope
-                if (name->isQualifiedNameId())
+                if (name->asQualifiedNameId())
                     continue;
                 else
                     break;
@@ -572,7 +572,7 @@ QList<LookupItem> LookupContext::lookup(const Name *name, Scope *scope) const
             if (! candidates.isEmpty())
                 return candidates;
 
-        } else if (scope->isObjCClass() || scope->isObjCProtocol()) {
+        } else if (scope->asObjCClass() || scope->asObjCProtocol()) {
             if (ClassOrNamespace *binding = bindings()->lookupType(scope))
                 candidates = binding->find(name);
 
@@ -740,7 +740,7 @@ void ClassOrNamespace::lookup_helper(const Name *name, ClassOrNamespace *binding
         for (Symbol *s : symbols) {
             if (s->isFriend())
                 continue;
-            else if (s->isUsingNamespaceDirective())
+            else if (s->asUsingNamespaceDirective())
                 continue;
 
 
@@ -825,11 +825,11 @@ void CreateBindings::lookupInScope(const Name *name, Scope *scope,
         for (Symbol *s = scope->find(id); s; s = s->next()) {
             if (s->isFriend())
                 continue; // skip friends
-            else if (s->isUsingNamespaceDirective())
+            else if (s->asUsingNamespaceDirective())
                 continue; // skip using namespace directives
             else if (! id->match(s->identifier()))
                 continue;
-            else if (s->name() && s->name()->isQualifiedNameId())
+            else if (s->name() && s->name()->asQualifiedNameId())
                 continue; // skip qualified ids.
 
             if (Q_UNLIKELY(debug)) {
@@ -851,7 +851,7 @@ void CreateBindings::lookupInScope(const Name *name, Scope *scope,
                 }
             }
 
-            if (templateId && (s->isDeclaration() || s->isFunction())) {
+            if (templateId && (s->asDeclaration() || s->asFunction())) {
                 FullySpecifiedType ty = DeprecatedGenTemplateInstance::instantiate(templateId, s, control());
                 item.setType(ty); // override the type.
             }
@@ -991,7 +991,7 @@ ClassOrNamespace *ClassOrNamespace::lookupType_helper(const Name *name,
     } else if (! processed->contains(this)) {
         processed->insert(this);
 
-        if (name->isNameId() || name->isTemplateNameId() || name->isAnonymousNameId()) {
+        if (name->asNameId() || name->asTemplateNameId() || name->asAnonymousNameId()) {
             flush();
 
             const QList<Symbol *> symbolList = symbols();
@@ -1136,7 +1136,7 @@ ClassOrNamespace *ClassOrNamespace::nestedType(const Name *name,
                                                ClassOrNamespace *origin)
 {
     Q_ASSERT(name != nullptr);
-    Q_ASSERT(name->isNameId() || name->isTemplateNameId() || name->isAnonymousNameId());
+    Q_ASSERT(name->asNameId() || name->asTemplateNameId() || name->asAnonymousNameId());
 
     const_cast<ClassOrNamespace *>(this)->flush();
 
@@ -1255,7 +1255,7 @@ ClassOrNamespace *ClassOrNamespace::nestedType(const Name *name,
             return reference;
     }
 
-    if (!name->isTemplateNameId())
+    if (!name->asTemplateNameId())
         _alreadyConsideredClasses.insert(referenceClass);
 
     QSet<ClassOrNamespace *> knownUsings = Utils::toSet(reference->usings());
@@ -1270,7 +1270,7 @@ ClassOrNamespace *ClassOrNamespace::nestedType(const Name *name,
         instantiation->_templateId = templId;
 
         QSet<ClassOrNamespace *> otherProcessed;
-        while (!origin->_symbols.isEmpty() && origin->_symbols[0]->isBlock()) {
+        while (!origin->_symbols.isEmpty() && origin->_symbols[0]->asBlock()) {
             if (otherProcessed.contains(origin))
                 break;
             otherProcessed.insert(origin);
@@ -1634,7 +1634,7 @@ ClassOrNamespace *ClassOrNamespace::findOrCreateType(const Name *name, ClassOrNa
 
         return findOrCreateType(q->base(), origin)->findOrCreateType(q->name(), origin, clazz);
 
-    } else if (name->isNameId() || name->isTemplateNameId() || name->isAnonymousNameId()) {
+    } else if (name->asNameId() || name->asTemplateNameId() || name->asAnonymousNameId()) {
         QSet<ClassOrNamespace *> processed;
         ClassOrNamespace *e = nestedType(name, &processed, origin);
 
@@ -1791,7 +1791,7 @@ bool CreateBindings::visit(Class *klass)
     ClassOrNamespace *previous = _currentClassOrNamespace;
     ClassOrNamespace *binding = nullptr;
 
-    if (klass->name() && klass->name()->isQualifiedNameId())
+    if (klass->name() && klass->name()->asQualifiedNameId())
         binding = _currentClassOrNamespace->lookupType(klass->name());
 
     if (! binding)
@@ -1956,7 +1956,7 @@ bool CreateBindings::visit(NamespaceAlias *a)
         return false;
 
     } else if (ClassOrNamespace *e = _currentClassOrNamespace->lookupType(a->namespaceName())) {
-        if (a->name()->isNameId() || a->name()->isTemplateNameId() || a->name()->isAnonymousNameId())
+        if (a->name()->asNameId() || a->name()->asTemplateNameId() || a->name()->asAnonymousNameId())
             _currentClassOrNamespace->addNestedType(a->name(), e);
 
     } else if (false) {
@@ -2042,12 +2042,12 @@ Symbol *CreateBindings::instantiateTemplateFunction(const Name *instantiationNam
                                                     Template *specialization) const
 {
     if (!specialization || !specialization->declaration()
-        || !specialization->declaration()->isFunction())
+        || !specialization->declaration()->asFunction())
         return nullptr;
 
     int argumentCountOfInstantiation = 0;
     const TemplateNameId *instantiation = nullptr;
-    if (instantiationName->isTemplateNameId()) {
+    if (instantiationName->asTemplateNameId()) {
         instantiation = instantiationName->asTemplateNameId();
         argumentCountOfInstantiation = instantiation->templateArgumentCount();
     } else {
diff --git a/src/libs/cplusplus/ResolveExpression.cpp b/src/libs/cplusplus/ResolveExpression.cpp
index 4ff023624e..6803194ec6 100644
--- a/src/libs/cplusplus/ResolveExpression.cpp
+++ b/src/libs/cplusplus/ResolveExpression.cpp
@@ -1045,7 +1045,7 @@ ClassOrNamespace *ResolveExpression::findClass(const FullySpecifiedType &origina
     ClassOrNamespace *binding = nullptr;
 
     if (Class *klass = ty->asClassType()) {
-        if (scope->isBlock())
+        if (scope->asBlock())
             binding = _context.lookupType(klass->name(), scope, enclosingBinding);
         if (!binding)
             binding = _context.lookupType(klass, enclosingBinding);
@@ -1135,7 +1135,7 @@ ClassOrNamespace *ResolveExpression::baseExpression(const QList<LookupItem> &bas
                             instantiatedFunction = overloadTy->asFunctionType();
                         } else if (overloadType->isTemplateType()
                                    && overloadType->asTemplateType()->declaration()
-                                   && overloadType->asTemplateType()->declaration()->isFunction()) {
+                                   && overloadType->asTemplateType()->declaration()->asFunction()) {
                             instantiatedFunction = overloadType->asTemplateType()->declaration()->asFunction();
                         }
 
diff --git a/src/libs/cplusplus/SymbolNameVisitor.cpp b/src/libs/cplusplus/SymbolNameVisitor.cpp
index b34bf2f42a..83fe82a9de 100644
--- a/src/libs/cplusplus/SymbolNameVisitor.cpp
+++ b/src/libs/cplusplus/SymbolNameVisitor.cpp
@@ -41,7 +41,7 @@ void SymbolNameVisitor::accept(Symbol *symbol)
         if (Scope *scope = symbol->enclosingScope())
             accept(scope);
 
-        if (! symbol->isTemplate()) {
+        if (! symbol->asTemplate()) {
             if (const Name *name = symbol->name()) {
                 std::swap(_symbol, symbol);
                 accept(name);