CPlusPlus: Modernize frontend generator

... and the generated code.

Change-Id: Ib04d98e9c16f7aae96575b3d0c4ee9f27651e138
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>

src/libs/3rdparty/cplusplus/AST.h

@@ -123,168 +123,168 @@ public:
 
     virtual AST *clone(MemoryPool *pool) const = 0;
 
-    virtual AccessDeclarationAST *asAccessDeclaration() { return 0; }
+    virtual AccessDeclarationAST *asAccessDeclaration() { return nullptr; }
-    virtual AliasDeclarationAST *asAliasDeclaration() { return 0; }
+    virtual AliasDeclarationAST *asAliasDeclaration() { return nullptr; }
-    virtual AlignmentSpecifierAST *asAlignmentSpecifier() { return 0; }
+    virtual AlignmentSpecifierAST *asAlignmentSpecifier() { return nullptr; }
-    virtual AlignofExpressionAST *asAlignofExpression() { return 0; }
+    virtual AlignofExpressionAST *asAlignofExpression() { return nullptr; }
-    virtual AnonymousNameAST *asAnonymousName() { return 0; }
+    virtual AnonymousNameAST *asAnonymousName() { return nullptr; }
-    virtual ArrayAccessAST *asArrayAccess() { return 0; }
+    virtual ArrayAccessAST *asArrayAccess() { return nullptr; }
-    virtual ArrayDeclaratorAST *asArrayDeclarator() { return 0; }
+    virtual ArrayDeclaratorAST *asArrayDeclarator() { return nullptr; }
-    virtual ArrayInitializerAST *asArrayInitializer() { return 0; }
+    virtual ArrayInitializerAST *asArrayInitializer() { return nullptr; }
-    virtual AsmDefinitionAST *asAsmDefinition() { return 0; }
+    virtual AsmDefinitionAST *asAsmDefinition() { return nullptr; }
-    virtual AttributeSpecifierAST *asAttributeSpecifier() { return 0; }
+    virtual AttributeSpecifierAST *asAttributeSpecifier() { return nullptr; }
-    virtual BaseSpecifierAST *asBaseSpecifier() { return 0; }
+    virtual BaseSpecifierAST *asBaseSpecifier() { return nullptr; }
-    virtual BinaryExpressionAST *asBinaryExpression() { return 0; }
+    virtual BinaryExpressionAST *asBinaryExpression() { return nullptr; }
-    virtual BoolLiteralAST *asBoolLiteral() { return 0; }
+    virtual BoolLiteralAST *asBoolLiteral() { return nullptr; }
-    virtual BracedInitializerAST *asBracedInitializer() { return 0; }
+    virtual BracedInitializerAST *asBracedInitializer() { return nullptr; }
-    virtual BracketDesignatorAST *asBracketDesignator() { return 0; }
+    virtual BracketDesignatorAST *asBracketDesignator() { return nullptr; }
-    virtual BreakStatementAST *asBreakStatement() { return 0; }
+    virtual BreakStatementAST *asBreakStatement() { return nullptr; }
-    virtual CallAST *asCall() { return 0; }
+    virtual CallAST *asCall() { return nullptr; }
-    virtual CaptureAST *asCapture() { return 0; }
+    virtual CaptureAST *asCapture() { return nullptr; }
-    virtual CaseStatementAST *asCaseStatement() { return 0; }
+    virtual CaseStatementAST *asCaseStatement() { return nullptr; }
-    virtual CastExpressionAST *asCastExpression() { return 0; }
+    virtual CastExpressionAST *asCastExpression() { return nullptr; }
-    virtual CatchClauseAST *asCatchClause() { return 0; }
+    virtual CatchClauseAST *asCatchClause() { return nullptr; }
-    virtual ClassSpecifierAST *asClassSpecifier() { return 0; }
+    virtual ClassSpecifierAST *asClassSpecifier() { return nullptr; }
-    virtual CompoundExpressionAST *asCompoundExpression() { return 0; }
+    virtual CompoundExpressionAST *asCompoundExpression() { return nullptr; }
-    virtual CompoundLiteralAST *asCompoundLiteral() { return 0; }
+    virtual CompoundLiteralAST *asCompoundLiteral() { return nullptr; }
-    virtual CompoundStatementAST *asCompoundStatement() { return 0; }
+    virtual CompoundStatementAST *asCompoundStatement() { return nullptr; }
-    virtual ConditionAST *asCondition() { return 0; }
+    virtual ConditionAST *asCondition() { return nullptr; }
-    virtual ConditionalExpressionAST *asConditionalExpression() { return 0; }
+    virtual ConditionalExpressionAST *asConditionalExpression() { return nullptr; }
-    virtual ContinueStatementAST *asContinueStatement() { return 0; }
+    virtual ContinueStatementAST *asContinueStatement() { return nullptr; }
-    virtual ConversionFunctionIdAST *asConversionFunctionId() { return 0; }
+    virtual ConversionFunctionIdAST *asConversionFunctionId() { return nullptr; }
-    virtual CoreDeclaratorAST *asCoreDeclarator() { return 0; }
+    virtual CoreDeclaratorAST *asCoreDeclarator() { return nullptr; }
-    virtual CppCastExpressionAST *asCppCastExpression() { return 0; }
+    virtual CppCastExpressionAST *asCppCastExpression() { return nullptr; }
-    virtual CtorInitializerAST *asCtorInitializer() { return 0; }
+    virtual CtorInitializerAST *asCtorInitializer() { return nullptr; }
-    virtual DeclarationAST *asDeclaration() { return 0; }
+    virtual DeclarationAST *asDeclaration() { return nullptr; }
-    virtual DeclarationStatementAST *asDeclarationStatement() { return 0; }
+    virtual DeclarationStatementAST *asDeclarationStatement() { return nullptr; }
-    virtual DeclaratorAST *asDeclarator() { return 0; }
+    virtual DeclaratorAST *asDeclarator() { return nullptr; }
-    virtual DeclaratorIdAST *asDeclaratorId() { return 0; }
+    virtual DeclaratorIdAST *asDeclaratorId() { return nullptr; }
-    virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return 0; }
+    virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return nullptr; }
-    virtual DeleteExpressionAST *asDeleteExpression() { return 0; }
+    virtual DeleteExpressionAST *asDeleteExpression() { return nullptr; }
-    virtual DesignatedInitializerAST *asDesignatedInitializer() { return 0; }
+    virtual DesignatedInitializerAST *asDesignatedInitializer() { return nullptr; }
-    virtual DesignatorAST *asDesignator() { return 0; }
+    virtual DesignatorAST *asDesignator() { return nullptr; }
-    virtual DestructorNameAST *asDestructorName() { return 0; }
+    virtual DestructorNameAST *asDestructorName() { return nullptr; }
-    virtual DoStatementAST *asDoStatement() { return 0; }
+    virtual DoStatementAST *asDoStatement() { return nullptr; }
-    virtual DotDesignatorAST *asDotDesignator() { return 0; }
+    virtual DotDesignatorAST *asDotDesignator() { return nullptr; }
-    virtual DynamicExceptionSpecificationAST *asDynamicExceptionSpecification() { return 0; }
+    virtual DynamicExceptionSpecificationAST *asDynamicExceptionSpecification() { return nullptr; }
-    virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return 0; }
+    virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return nullptr; }
-    virtual EmptyDeclarationAST *asEmptyDeclaration() { return 0; }
+    virtual EmptyDeclarationAST *asEmptyDeclaration() { return nullptr; }
-    virtual EnumSpecifierAST *asEnumSpecifier() { return 0; }
+    virtual EnumSpecifierAST *asEnumSpecifier() { return nullptr; }
-    virtual EnumeratorAST *asEnumerator() { return 0; }
+    virtual EnumeratorAST *asEnumerator() { return nullptr; }
-    virtual ExceptionDeclarationAST *asExceptionDeclaration() { return 0; }
+    virtual ExceptionDeclarationAST *asExceptionDeclaration() { return nullptr; }
-    virtual ExceptionSpecificationAST *asExceptionSpecification() { return 0; }
+    virtual ExceptionSpecificationAST *asExceptionSpecification() { return nullptr; }
-    virtual ExpressionAST *asExpression() { return 0; }
+    virtual ExpressionAST *asExpression() { return nullptr; }
-    virtual ExpressionListParenAST *asExpressionListParen() { return 0; }
+    virtual ExpressionListParenAST *asExpressionListParen() { return nullptr; }
-    virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return 0; }
+    virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return nullptr; }
-    virtual ExpressionStatementAST *asExpressionStatement() { return 0; }
+    virtual ExpressionStatementAST *asExpressionStatement() { return nullptr; }
-    virtual ForStatementAST *asForStatement() { return 0; }
+    virtual ForStatementAST *asForStatement() { return nullptr; }
-    virtual ForeachStatementAST *asForeachStatement() { return 0; }
+    virtual ForeachStatementAST *asForeachStatement() { return nullptr; }
-    virtual FunctionDeclaratorAST *asFunctionDeclarator() { return 0; }
+    virtual FunctionDeclaratorAST *asFunctionDeclarator() { return nullptr; }
-    virtual FunctionDefinitionAST *asFunctionDefinition() { return 0; }
+    virtual FunctionDefinitionAST *asFunctionDefinition() { return nullptr; }
-    virtual GnuAttributeAST *asGnuAttribute() { return 0; }
+    virtual GnuAttributeAST *asGnuAttribute() { return nullptr; }
-    virtual GnuAttributeSpecifierAST *asGnuAttributeSpecifier() { return 0; }
+    virtual GnuAttributeSpecifierAST *asGnuAttributeSpecifier() { return nullptr; }
-    virtual GotoStatementAST *asGotoStatement() { return 0; }
+    virtual GotoStatementAST *asGotoStatement() { return nullptr; }
-    virtual IdExpressionAST *asIdExpression() { return 0; }
+    virtual IdExpressionAST *asIdExpression() { return nullptr; }
-    virtual IfStatementAST *asIfStatement() { return 0; }
+    virtual IfStatementAST *asIfStatement() { return nullptr; }
-    virtual LabeledStatementAST *asLabeledStatement() { return 0; }
+    virtual LabeledStatementAST *asLabeledStatement() { return nullptr; }
-    virtual LambdaCaptureAST *asLambdaCapture() { return 0; }
+    virtual LambdaCaptureAST *asLambdaCapture() { return nullptr; }
-    virtual LambdaDeclaratorAST *asLambdaDeclarator() { return 0; }
+    virtual LambdaDeclaratorAST *asLambdaDeclarator() { return nullptr; }
-    virtual LambdaExpressionAST *asLambdaExpression() { return 0; }
+    virtual LambdaExpressionAST *asLambdaExpression() { return nullptr; }
-    virtual LambdaIntroducerAST *asLambdaIntroducer() { return 0; }
+    virtual LambdaIntroducerAST *asLambdaIntroducer() { return nullptr; }
-    virtual LinkageBodyAST *asLinkageBody() { return 0; }
+    virtual LinkageBodyAST *asLinkageBody() { return nullptr; }
-    virtual LinkageSpecificationAST *asLinkageSpecification() { return 0; }
+    virtual LinkageSpecificationAST *asLinkageSpecification() { return nullptr; }
-    virtual MemInitializerAST *asMemInitializer() { return 0; }
+    virtual MemInitializerAST *asMemInitializer() { return nullptr; }
-    virtual MemberAccessAST *asMemberAccess() { return 0; }
+    virtual MemberAccessAST *asMemberAccess() { return nullptr; }
-    virtual NameAST *asName() { return 0; }
+    virtual NameAST *asName() { return nullptr; }
-    virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return 0; }
+    virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return nullptr; }
-    virtual NamespaceAST *asNamespace() { return 0; }
+    virtual NamespaceAST *asNamespace() { return nullptr; }
-    virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return 0; }
+    virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return nullptr; }
-    virtual NestedDeclaratorAST *asNestedDeclarator() { return 0; }
+    virtual NestedDeclaratorAST *asNestedDeclarator() { return nullptr; }
-    virtual NestedExpressionAST *asNestedExpression() { return 0; }
+    virtual NestedExpressionAST *asNestedExpression() { return nullptr; }
-    virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return 0; }
+    virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return nullptr; }
-    virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return 0; }
+    virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return nullptr; }
-    virtual NewExpressionAST *asNewExpression() { return 0; }
+    virtual NewExpressionAST *asNewExpression() { return nullptr; }
-    virtual NewTypeIdAST *asNewTypeId() { return 0; }
+    virtual NewTypeIdAST *asNewTypeId() { return nullptr; }
-    virtual NoExceptOperatorExpressionAST *asNoExceptOperatorExpression() { return 0; }
+    virtual NoExceptOperatorExpressionAST *asNoExceptOperatorExpression() { return nullptr; }
-    virtual NoExceptSpecificationAST *asNoExceptSpecification() { return 0; }
+    virtual NoExceptSpecificationAST *asNoExceptSpecification() { return nullptr; }
-    virtual NumericLiteralAST *asNumericLiteral() { return 0; }
+    virtual NumericLiteralAST *asNumericLiteral() { return nullptr; }
-    virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return 0; }
+    virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return nullptr; }
-    virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return 0; }
+    virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return nullptr; }
-    virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return 0; }
+    virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return nullptr; }
-    virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return 0; }
+    virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return nullptr; }
-    virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return 0; }
+    virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return nullptr; }
-    virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return 0; }
+    virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return nullptr; }
-    virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return 0; }
+    virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return nullptr; }
-    virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return 0; }
+    virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return nullptr; }
-    virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return 0; }
+    virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return nullptr; }
-    virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return 0; }
+    virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return nullptr; }
-    virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return 0; }
+    virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return nullptr; }
-    virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return 0; }
+    virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return nullptr; }
-    virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return 0; }
+    virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return nullptr; }
-    virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return 0; }
+    virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return nullptr; }
-    virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return 0; }
+    virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return nullptr; }
-    virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return 0; }
+    virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return nullptr; }
-    virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return 0; }
+    virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return nullptr; }
-    virtual ObjCSelectorAST *asObjCSelector() { return 0; }
+    virtual ObjCSelectorAST *asObjCSelector() { return nullptr; }
-    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return 0; }
+    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return nullptr; }
-    virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return 0; }
+    virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return nullptr; }
-    virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return 0; }
+    virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return nullptr; }
-    virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return 0; }
+    virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return nullptr; }
-    virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return 0; }
+    virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return nullptr; }
-    virtual ObjCTypeNameAST *asObjCTypeName() { return 0; }
+    virtual ObjCTypeNameAST *asObjCTypeName() { return nullptr; }
-    virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return 0; }
+    virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return nullptr; }
-    virtual OperatorAST *asOperator() { return 0; }
+    virtual OperatorAST *asOperator() { return nullptr; }
-    virtual OperatorFunctionIdAST *asOperatorFunctionId() { return 0; }
+    virtual OperatorFunctionIdAST *asOperatorFunctionId() { return nullptr; }
-    virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; }
+    virtual ParameterDeclarationAST *asParameterDeclaration() { return nullptr; }
-    virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return 0; }
+    virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return nullptr; }
-    virtual PointerAST *asPointer() { return 0; }
+    virtual PointerAST *asPointer() { return nullptr; }
-    virtual PointerLiteralAST *asPointerLiteral() { return 0; }
+    virtual PointerLiteralAST *asPointerLiteral() { return nullptr; }
-    virtual PointerToMemberAST *asPointerToMember() { return 0; }
+    virtual PointerToMemberAST *asPointerToMember() { return nullptr; }
-    virtual PostIncrDecrAST *asPostIncrDecr() { return 0; }
+    virtual PostIncrDecrAST *asPostIncrDecr() { return nullptr; }
-    virtual PostfixAST *asPostfix() { return 0; }
+    virtual PostfixAST *asPostfix() { return nullptr; }
-    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return 0; }
+    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return nullptr; }
-    virtual PtrOperatorAST *asPtrOperator() { return 0; }
+    virtual PtrOperatorAST *asPtrOperator() { return nullptr; }
-    virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return 0; }
+    virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return nullptr; }
-    virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return 0; }
+    virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return nullptr; }
-    virtual QtInterfaceNameAST *asQtInterfaceName() { return 0; }
+    virtual QtInterfaceNameAST *asQtInterfaceName() { return nullptr; }
-    virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return 0; }
+    virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return nullptr; }
-    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return 0; }
+    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return nullptr; }
-    virtual QtMethodAST *asQtMethod() { return 0; }
+    virtual QtMethodAST *asQtMethod() { return nullptr; }
-    virtual QtObjectTagAST *asQtObjectTag() { return 0; }
+    virtual QtObjectTagAST *asQtObjectTag() { return nullptr; }
-    virtual QtPrivateSlotAST *asQtPrivateSlot() { return 0; }
+    virtual QtPrivateSlotAST *asQtPrivateSlot() { return nullptr; }
-    virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return 0; }
+    virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return nullptr; }
-    virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return 0; }
+    virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return nullptr; }
-    virtual QualifiedNameAST *asQualifiedName() { return 0; }
+    virtual QualifiedNameAST *asQualifiedName() { return nullptr; }
-    virtual RangeBasedForStatementAST *asRangeBasedForStatement() { return 0; }
+    virtual RangeBasedForStatementAST *asRangeBasedForStatement() { return nullptr; }
-    virtual ReferenceAST *asReference() { return 0; }
+    virtual ReferenceAST *asReference() { return nullptr; }
-    virtual ReturnStatementAST *asReturnStatement() { return 0; }
+    virtual ReturnStatementAST *asReturnStatement() { return nullptr; }
-    virtual SimpleDeclarationAST *asSimpleDeclaration() { return 0; }
+    virtual SimpleDeclarationAST *asSimpleDeclaration() { return nullptr; }
-    virtual SimpleNameAST *asSimpleName() { return 0; }
+    virtual SimpleNameAST *asSimpleName() { return nullptr; }
-    virtual SimpleSpecifierAST *asSimpleSpecifier() { return 0; }
+    virtual SimpleSpecifierAST *asSimpleSpecifier() { return nullptr; }
-    virtual SizeofExpressionAST *asSizeofExpression() { return 0; }
+    virtual SizeofExpressionAST *asSizeofExpression() { return nullptr; }
-    virtual SpecifierAST *asSpecifier() { return 0; }
+    virtual SpecifierAST *asSpecifier() { return nullptr; }
-    virtual StatementAST *asStatement() { return 0; }
+    virtual StatementAST *asStatement() { return nullptr; }
-    virtual StaticAssertDeclarationAST *asStaticAssertDeclaration() { return 0; }
+    virtual StaticAssertDeclarationAST *asStaticAssertDeclaration() { return nullptr; }
-    virtual StringLiteralAST *asStringLiteral() { return 0; }
+    virtual StringLiteralAST *asStringLiteral() { return nullptr; }
-    virtual SwitchStatementAST *asSwitchStatement() { return 0; }
+    virtual SwitchStatementAST *asSwitchStatement() { return nullptr; }
-    virtual TemplateDeclarationAST *asTemplateDeclaration() { return 0; }
+    virtual TemplateDeclarationAST *asTemplateDeclaration() { return nullptr; }
-    virtual TemplateIdAST *asTemplateId() { return 0; }
+    virtual TemplateIdAST *asTemplateId() { return nullptr; }
-    virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return 0; }
+    virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return nullptr; }
-    virtual ThisExpressionAST *asThisExpression() { return 0; }
+    virtual ThisExpressionAST *asThisExpression() { return nullptr; }
-    virtual ThrowExpressionAST *asThrowExpression() { return 0; }
+    virtual ThrowExpressionAST *asThrowExpression() { return nullptr; }
-    virtual TrailingReturnTypeAST *asTrailingReturnType() { return 0; }
+    virtual TrailingReturnTypeAST *asTrailingReturnType() { return nullptr; }
-    virtual TranslationUnitAST *asTranslationUnit() { return 0; }
+    virtual TranslationUnitAST *asTranslationUnit() { return nullptr; }
-    virtual TryBlockStatementAST *asTryBlockStatement() { return 0; }
+    virtual TryBlockStatementAST *asTryBlockStatement() { return nullptr; }
-    virtual TypeConstructorCallAST *asTypeConstructorCall() { return 0; }
+    virtual TypeConstructorCallAST *asTypeConstructorCall() { return nullptr; }
-    virtual TypeIdAST *asTypeId() { return 0; }
+    virtual TypeIdAST *asTypeId() { return nullptr; }
-    virtual TypeidExpressionAST *asTypeidExpression() { return 0; }
+    virtual TypeidExpressionAST *asTypeidExpression() { return nullptr; }
-    virtual TypenameCallExpressionAST *asTypenameCallExpression() { return 0; }
+    virtual TypenameCallExpressionAST *asTypenameCallExpression() { return nullptr; }
-    virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return 0; }
+    virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return nullptr; }
-    virtual TypeofSpecifierAST *asTypeofSpecifier() { return 0; }
+    virtual TypeofSpecifierAST *asTypeofSpecifier() { return nullptr; }
-    virtual UnaryExpressionAST *asUnaryExpression() { return 0; }
+    virtual UnaryExpressionAST *asUnaryExpression() { return nullptr; }
-    virtual UsingAST *asUsing() { return 0; }
+    virtual UsingAST *asUsing() { return nullptr; }
-    virtual UsingDirectiveAST *asUsingDirective() { return 0; }
+    virtual UsingDirectiveAST *asUsingDirective() { return nullptr; }
-    virtual WhileStatementAST *asWhileStatement() { return 0; }
+    virtual WhileStatementAST *asWhileStatement() { return nullptr; }
 
 protected:
     virtual void accept0(ASTVisitor *visitor) = 0;

src/tools/cplusplus-update-frontend/cplusplus-update-frontend.cpp

@@ -100,9 +100,7 @@ static void closeAndPrintFilePath(QFile &file)
 class ASTNodes
 {
 public:
-    ASTNodes(): base(0) {}
+    ClassSpecifierAST *base = nullptr; // points to "class AST"
-
-    ClassSpecifierAST *base; // points to "class AST"
     QList<ClassSpecifierAST *> deriveds; // n where n extends AST
     QList<QTextCursor> endOfPublicClassSpecifiers;
 };
@@ -156,7 +154,7 @@ protected:
     virtual bool visit(ClassSpecifierAST *ast)
     {
         Class *klass = ast->symbol;
-        Q_ASSERT(klass != 0);
+        Q_ASSERT(klass != nullptr);
 
         const QString className = oo(klass->name());
 
@@ -166,7 +164,7 @@ protected:
             else {
                 _nodes.deriveds.append(ast);
 
-                AccessDeclarationAST *accessDeclaration = 0;
+                AccessDeclarationAST *accessDeclaration = nullptr;
                 for (DeclarationListAST *it = ast->member_specifier_list; it; it = it->next) {
                     if (AccessDeclarationAST *decl = it->value->asAccessDeclaration()) {
                         if (tokenKind(decl->access_specifier_token) == T_PUBLIC)
@@ -177,7 +175,7 @@ protected:
                 if (! accessDeclaration)
                     qDebug() << "no access declaration for class:" << className;
 
-                Q_ASSERT(accessDeclaration != 0);
+                Q_ASSERT(accessDeclaration != nullptr);
 
                 QTextCursor tc = createCursor(translationUnit(), accessDeclaration, document);
                 tc.setPosition(tc.position());
@@ -198,11 +196,11 @@ private:
 class Accept0CG: protected ASTVisitor
 {
     QDir _cplusplusDir;
-    QTextStream *out;
+    QTextStream *out = nullptr;
 
 public:
     Accept0CG(const QDir &cplusplusDir, TranslationUnit *unit)
-        : ASTVisitor(unit), _cplusplusDir(cplusplusDir), out(0)
+        : ASTVisitor(unit), _cplusplusDir(cplusplusDir)
     { }
 
     QList<QByteArray> classes() const { return classMap.keys(); }
@@ -276,7 +274,7 @@ protected:
         for (int i = 0; i < klass->baseClassCount(); ++i) {
             const QByteArray baseClassName = klass->baseClassAt(i)->identifier()->chars();
 
-            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, 0))
+            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, nullptr))
                 visitMembers(baseClassSpec->symbol);
         }
     }
@@ -337,11 +335,11 @@ protected:
 class Match0CG: protected ASTVisitor
 {
     QDir _cplusplusDir;
-    QTextStream *out;
+    QTextStream *out = nullptr;
 
 public:
     Match0CG(const QDir &cplusplusDir, TranslationUnit *unit)
-        : ASTVisitor(unit), _cplusplusDir(cplusplusDir), out(0)
+        : ASTVisitor(unit), _cplusplusDir(cplusplusDir)
     { }
 
     void operator()(AST *ast)
@@ -448,11 +446,11 @@ protected:
 class MatcherCPPCG: protected ASTVisitor
 {
     QDir _cplusplusDir;
-    QTextStream *out;
+    QTextStream *out = nullptr;
 
 public:
     MatcherCPPCG(const QDir &cplusplusDir, TranslationUnit *unit)
-        : ASTVisitor(unit), _cplusplusDir(cplusplusDir), out(0)
+        : ASTVisitor(unit), _cplusplusDir(cplusplusDir)
     { }
 
     void operator()(AST *ast)
@@ -539,7 +537,7 @@ protected:
         for (int i = 0; i < klass->baseClassCount(); ++i) {
             const QByteArray baseClassName = klass->baseClassAt(i)->identifier()->chars();
 
-            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, 0))
+            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, nullptr))
                 visitMembers(baseClassSpec->symbol);
         }
     }
@@ -601,11 +599,11 @@ protected:
 class CloneCPPCG: protected ASTVisitor
 {
     QDir _cplusplusDir;
-    QTextStream *out;
+    QTextStream *out = nullptr;
 
 public:
     CloneCPPCG(const QDir &cplusplusDir, TranslationUnit *unit)
-        : ASTVisitor(unit), _cplusplusDir(cplusplusDir), out(0)
+        : ASTVisitor(unit), _cplusplusDir(cplusplusDir)
     { }
 
     void operator()(AST *ast)
@@ -681,7 +679,7 @@ protected:
         for (int i = 0; i < klass->baseClassCount(); ++i) {
             const QByteArray baseClassName = klass->baseClassAt(i)->identifier()->chars();
 
-            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, 0))
+            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, nullptr))
                 visitMembers(baseClassSpec->symbol);
         }
     }
@@ -813,7 +811,7 @@ protected:
         for (int i = 0; i < klass->baseClassCount(); ++i) {
             const QByteArray baseClassName = klass->baseClassAt(i)->identifier()->chars();
 
-            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, 0))
+            if (ClassSpecifierAST *baseClassSpec = classMap.value(baseClassName, nullptr))
                 visitMembers(baseClassSpec->symbol);
         }
     }
@@ -993,30 +991,21 @@ bool checkGenerated(const QTextCursor &cursor, int *doxyStart)
     return tokens.text(tokens.startToken() - 1).contains(QLatin1String("\\generated"));
 }
 
-struct GenInfo {
+struct GenInfo
-    GenInfo()
+{
-        : classAST(0)
+    ClassSpecifierAST *classAST = nullptr;
-        , start(0)
+    int start = 0;
-        , end(0)
+    int end = 0;
-        , firstToken(false)
+    bool firstToken = false;
-        , lastToken(false)
+    bool lastToken = false;
-        , remove(false)
+    bool remove = false;
-    {}
-
-    ClassSpecifierAST *classAST;
-    int start;
-    int end;
-    bool firstToken;
-    bool lastToken;
-    bool remove;
 };
 
 void generateFirstToken(QTextStream &os, const QString &className, const QStringList &fields)
 {
-    os << "int "<< className << "::firstToken() const" << endl
+    os << "int " << className << "::firstToken() const" << endl << "{" << endl;
-            << "{" << endl;
 
-    foreach (const QString &field, fields) {
+    for (const QString &field : fields) {
         os << "    if (" << field << ")" << endl;
 
         if (field.endsWith(QLatin1String("_token"))) {
@@ -1083,7 +1072,7 @@ void generateAST_cpp(const Snapshot &snapshot, const QDir &cplusplusDir)
     StringClassSpecifierASTMap classesNeedingLastToken;
 
     // find all classes with method declarations for firstToken/lastToken
-    foreach (ClassSpecifierAST *classAST, astNodes.deriveds) {
+    for (ClassSpecifierAST *classAST : qAsConst(astNodes.deriveds)) {
         const QString className = oo(classAST->symbol->name());
         if (className.isEmpty())
             continue;
@@ -1134,7 +1123,7 @@ void generateAST_cpp(const Snapshot &snapshot, const QDir &cplusplusDir)
                         ++end;
 
                     if (methodName == QLatin1String("firstToken")) {
-                        ClassSpecifierAST *classAST = classesNeedingFirstToken.value(className, 0);
+                        ClassSpecifierAST *classAST = classesNeedingFirstToken.value(className, nullptr);
                         GenInfo info;
                         info.end = end;
                         if (classAST) {
@@ -1149,7 +1138,7 @@ void generateAST_cpp(const Snapshot &snapshot, const QDir &cplusplusDir)
                         if (isGenerated)
                             todo.append(info);
                     } else if (methodName == QLatin1String("lastToken")) {
-                        ClassSpecifierAST *classAST = classesNeedingLastToken.value(className, 0);
+                        ClassSpecifierAST *classAST = classesNeedingLastToken.value(className, nullptr);
                         GenInfo info;
                         info.end = end;
                         if (classAST) {
@@ -1173,7 +1162,7 @@ void generateAST_cpp(const Snapshot &snapshot, const QDir &cplusplusDir)
     const int documentEnd = cpp_document.lastBlock().position() + cpp_document.lastBlock().length() - 1;
 
     Utils::ChangeSet changes;
-    foreach (GenInfo info, todo) {
+    for (GenInfo info : qAsConst(todo)) {
         if (info.end > documentEnd)
             info.end = documentEnd;
 
@@ -1209,7 +1198,7 @@ void generateAST_cpp(const Snapshot &snapshot, const QDir &cplusplusDir)
         const QStringList fields = collectFieldNames(it.value(), true);
         os << "/** \\generated */" << endl;
         generateFirstToken(os, className, fields);
-        if (ClassSpecifierAST *classAST = classesNeedingLastToken.value(className, 0)) {
+        if (ClassSpecifierAST *classAST = classesNeedingLastToken.value(className, nullptr)) {
             const QStringList fields = collectFieldNames(classAST, true);
             os << "/** \\generated */" << endl;
             generateLastToken(os, className, fields);
@@ -1301,14 +1290,12 @@ void generateASTVisitor_H(const Snapshot &, const QDir &cplusplusDir,
 "    virtual void postVisit(AST *) {}\n";
 
   out << "\n";
-  foreach (const QByteArray &klass, classes) {
+  for (const QByteArray &klass : classes)
     out << "    virtual bool visit(" << klass << " *) { return true; }\n";
-  }
 
   out << "\n";
-  foreach (const QByteArray &klass, classes) {
+  for (const QByteArray &klass : classes)
     out << "    virtual void endVisit(" << klass << " *) {}\n";
-  }
   out << "\n";
 
   out <<
@@ -1405,7 +1392,7 @@ QStringList generateAST_H(const Snapshot &snapshot, const QDir &cplusplusDir, co
                 = QString::fromLatin1("    virtual %1 *%2() { return this; }\n")
                     .arg(className, methodName);
         castMethods.append(
-                QString::fromLatin1("    virtual %1 *%2() { return 0; }\n")
+                QString::fromLatin1("    virtual %1 *%2() { return nullptr; }\n")
                     .arg(className, methodName));
         astDerivedClasses.append(className);
 
@@ -1540,9 +1527,8 @@ void generateASTFwd_h(const Snapshot &snapshot, const QDir &cplusplusDir, const
         cursors[i].removeSelectedText();
 
     QString replacement;
-    foreach (const QString &astDerivedClass, astDerivedClasses) {
+    for (const QString &astDerivedClass : astDerivedClasses)
-        replacement += QString(QLatin1String("class %1;\n")).arg(astDerivedClass);
+        replacement += QString("class %1;\n").arg(astDerivedClass);
-    }
 
     cursors.first().insertText(replacement);
 
@@ -1589,7 +1575,7 @@ void generateASTPatternBuilder_h(const QDir &cplusplusDir)
     Control *control = AST_h_document->control();
     QSet<QString> classesSet;
 
-    foreach (ClassSpecifierAST *classNode, astNodes.deriveds) {
+    for (ClassSpecifierAST *classNode : qAsConst(astNodes.deriveds)) {
         Class *klass = classNode->symbol;
 
         const Identifier *match0_id = control->identifier("match0");
@@ -1634,7 +1620,7 @@ void generateASTPatternBuilder_h(const QDir &cplusplusDir)
 
                 const QString memberName = oo(member->name());
 
-                out << tyName << " *" << memberName << " = 0";
+                out << tyName << " *" << memberName << " = nullptr";
                 args.append(qMakePair(tyName, memberName));
                 first = false;
             }
@@ -1646,9 +1632,8 @@ void generateASTPatternBuilder_h(const QDir &cplusplusDir)
                 << "        " << className << " *ast = new (&pool) " << className << ';' << endl;
 
 
-        foreach (const StringPair &p, args) {
+        for (const StringPair &p : qAsConst(args))
             out << "        ast->" << p.second << " = " << p.second << ';' << endl;
-        }
 
         out
                 << "        return ast;" << endl
@@ -1658,7 +1643,7 @@ void generateASTPatternBuilder_h(const QDir &cplusplusDir)
 
     QStringList classesList = classesSet.toList();
     Utils::sort(classesList);
-    foreach (const QString &className, classesList) {
+    for (const QString &className : qAsConst(classesList)) {
         const QString methodName = className.left(className.length() - 3);
         const QString elementName = className.left(className.length() - 7) + QLatin1String("AST");
         out