CPlusPlus: Modernize frontend generator

... and the generated code.

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

2 files changed, 291 insertions, 291 deletions

diff --git a/src/libs/3rdparty/cplusplus/AST.h b/src/libs/3rdparty/cplusplus/AST.h
index d013afa544..b3ed935bb8 100644
--- a/src/libs/3rdparty/cplusplus/AST.h
+++ b/src/libs/3rdparty/cplusplus/AST.h
@@ -123,168 +123,168 @@ public:
 
     virtual AST *clone(MemoryPool *pool) const = 0;
 
-    virtual AccessDeclarationAST *asAccessDeclaration() { return 0; }
-    virtual AliasDeclarationAST *asAliasDeclaration() { return 0; }
-    virtual AlignmentSpecifierAST *asAlignmentSpecifier() { return 0; }
-    virtual AlignofExpressionAST *asAlignofExpression() { return 0; }
-    virtual AnonymousNameAST *asAnonymousName() { return 0; }
-    virtual ArrayAccessAST *asArrayAccess() { return 0; }
-    virtual ArrayDeclaratorAST *asArrayDeclarator() { return 0; }
-    virtual ArrayInitializerAST *asArrayInitializer() { return 0; }
-    virtual AsmDefinitionAST *asAsmDefinition() { return 0; }
-    virtual AttributeSpecifierAST *asAttributeSpecifier() { return 0; }
-    virtual BaseSpecifierAST *asBaseSpecifier() { return 0; }
-    virtual BinaryExpressionAST *asBinaryExpression() { return 0; }
-    virtual BoolLiteralAST *asBoolLiteral() { return 0; }
-    virtual BracedInitializerAST *asBracedInitializer() { return 0; }
-    virtual BracketDesignatorAST *asBracketDesignator() { return 0; }
-    virtual BreakStatementAST *asBreakStatement() { return 0; }
-    virtual CallAST *asCall() { return 0; }
-    virtual CaptureAST *asCapture() { return 0; }
-    virtual CaseStatementAST *asCaseStatement() { return 0; }
-    virtual CastExpressionAST *asCastExpression() { return 0; }
-    virtual CatchClauseAST *asCatchClause() { return 0; }
-    virtual ClassSpecifierAST *asClassSpecifier() { return 0; }
-    virtual CompoundExpressionAST *asCompoundExpression() { return 0; }
-    virtual CompoundLiteralAST *asCompoundLiteral() { return 0; }
-    virtual CompoundStatementAST *asCompoundStatement() { return 0; }
-    virtual ConditionAST *asCondition() { return 0; }
-    virtual ConditionalExpressionAST *asConditionalExpression() { return 0; }
-    virtual ContinueStatementAST *asContinueStatement() { return 0; }
-    virtual ConversionFunctionIdAST *asConversionFunctionId() { return 0; }
-    virtual CoreDeclaratorAST *asCoreDeclarator() { return 0; }
-    virtual CppCastExpressionAST *asCppCastExpression() { return 0; }
-    virtual CtorInitializerAST *asCtorInitializer() { return 0; }
-    virtual DeclarationAST *asDeclaration() { return 0; }
-    virtual DeclarationStatementAST *asDeclarationStatement() { return 0; }
-    virtual DeclaratorAST *asDeclarator() { return 0; }
-    virtual DeclaratorIdAST *asDeclaratorId() { return 0; }
-    virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return 0; }
-    virtual DeleteExpressionAST *asDeleteExpression() { return 0; }
-    virtual DesignatedInitializerAST *asDesignatedInitializer() { return 0; }
-    virtual DesignatorAST *asDesignator() { return 0; }
-    virtual DestructorNameAST *asDestructorName() { return 0; }
-    virtual DoStatementAST *asDoStatement() { return 0; }
-    virtual DotDesignatorAST *asDotDesignator() { return 0; }
-    virtual DynamicExceptionSpecificationAST *asDynamicExceptionSpecification() { return 0; }
-    virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return 0; }
-    virtual EmptyDeclarationAST *asEmptyDeclaration() { return 0; }
-    virtual EnumSpecifierAST *asEnumSpecifier() { return 0; }
-    virtual EnumeratorAST *asEnumerator() { return 0; }
-    virtual ExceptionDeclarationAST *asExceptionDeclaration() { return 0; }
-    virtual ExceptionSpecificationAST *asExceptionSpecification() { return 0; }
-    virtual ExpressionAST *asExpression() { return 0; }
-    virtual ExpressionListParenAST *asExpressionListParen() { return 0; }
-    virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return 0; }
-    virtual ExpressionStatementAST *asExpressionStatement() { return 0; }
-    virtual ForStatementAST *asForStatement() { return 0; }
-    virtual ForeachStatementAST *asForeachStatement() { return 0; }
-    virtual FunctionDeclaratorAST *asFunctionDeclarator() { return 0; }
-    virtual FunctionDefinitionAST *asFunctionDefinition() { return 0; }
-    virtual GnuAttributeAST *asGnuAttribute() { return 0; }
-    virtual GnuAttributeSpecifierAST *asGnuAttributeSpecifier() { return 0; }
-    virtual GotoStatementAST *asGotoStatement() { return 0; }
-    virtual IdExpressionAST *asIdExpression() { return 0; }
-    virtual IfStatementAST *asIfStatement() { return 0; }
-    virtual LabeledStatementAST *asLabeledStatement() { return 0; }
-    virtual LambdaCaptureAST *asLambdaCapture() { return 0; }
-    virtual LambdaDeclaratorAST *asLambdaDeclarator() { return 0; }
-    virtual LambdaExpressionAST *asLambdaExpression() { return 0; }
-    virtual LambdaIntroducerAST *asLambdaIntroducer() { return 0; }
-    virtual LinkageBodyAST *asLinkageBody() { return 0; }
-    virtual LinkageSpecificationAST *asLinkageSpecification() { return 0; }
-    virtual MemInitializerAST *asMemInitializer() { return 0; }
-    virtual MemberAccessAST *asMemberAccess() { return 0; }
-    virtual NameAST *asName() { return 0; }
-    virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return 0; }
-    virtual NamespaceAST *asNamespace() { return 0; }
-    virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return 0; }
-    virtual NestedDeclaratorAST *asNestedDeclarator() { return 0; }
-    virtual NestedExpressionAST *asNestedExpression() { return 0; }
-    virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return 0; }
-    virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return 0; }
-    virtual NewExpressionAST *asNewExpression() { return 0; }
-    virtual NewTypeIdAST *asNewTypeId() { return 0; }
-    virtual NoExceptOperatorExpressionAST *asNoExceptOperatorExpression() { return 0; }
-    virtual NoExceptSpecificationAST *asNoExceptSpecification() { return 0; }
-    virtual NumericLiteralAST *asNumericLiteral() { return 0; }
-    virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return 0; }
-    virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return 0; }
-    virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return 0; }
-    virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return 0; }
-    virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return 0; }
-    virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return 0; }
-    virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return 0; }
-    virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return 0; }
-    virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return 0; }
-    virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return 0; }
-    virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return 0; }
-    virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return 0; }
-    virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return 0; }
-    virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return 0; }
-    virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return 0; }
-    virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return 0; }
-    virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return 0; }
-    virtual ObjCSelectorAST *asObjCSelector() { return 0; }
-    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return 0; }
-    virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return 0; }
-    virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return 0; }
-    virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return 0; }
-    virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return 0; }
-    virtual ObjCTypeNameAST *asObjCTypeName() { return 0; }
-    virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return 0; }
-    virtual OperatorAST *asOperator() { return 0; }
-    virtual OperatorFunctionIdAST *asOperatorFunctionId() { return 0; }
-    virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; }
-    virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return 0; }
-    virtual PointerAST *asPointer() { return 0; }
-    virtual PointerLiteralAST *asPointerLiteral() { return 0; }
-    virtual PointerToMemberAST *asPointerToMember() { return 0; }
-    virtual PostIncrDecrAST *asPostIncrDecr() { return 0; }
-    virtual PostfixAST *asPostfix() { return 0; }
-    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return 0; }
-    virtual PtrOperatorAST *asPtrOperator() { return 0; }
-    virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return 0; }
-    virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return 0; }
-    virtual QtInterfaceNameAST *asQtInterfaceName() { return 0; }
-    virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return 0; }
-    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return 0; }
-    virtual QtMethodAST *asQtMethod() { return 0; }
-    virtual QtObjectTagAST *asQtObjectTag() { return 0; }
-    virtual QtPrivateSlotAST *asQtPrivateSlot() { return 0; }
-    virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return 0; }
-    virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return 0; }
-    virtual QualifiedNameAST *asQualifiedName() { return 0; }
-    virtual RangeBasedForStatementAST *asRangeBasedForStatement() { return 0; }
-    virtual ReferenceAST *asReference() { return 0; }
-    virtual ReturnStatementAST *asReturnStatement() { return 0; }
-    virtual SimpleDeclarationAST *asSimpleDeclaration() { return 0; }
-    virtual SimpleNameAST *asSimpleName() { return 0; }
-    virtual SimpleSpecifierAST *asSimpleSpecifier() { return 0; }
-    virtual SizeofExpressionAST *asSizeofExpression() { return 0; }
-    virtual SpecifierAST *asSpecifier() { return 0; }
-    virtual StatementAST *asStatement() { return 0; }
-    virtual StaticAssertDeclarationAST *asStaticAssertDeclaration() { return 0; }
-    virtual StringLiteralAST *asStringLiteral() { return 0; }
-    virtual SwitchStatementAST *asSwitchStatement() { return 0; }
-    virtual TemplateDeclarationAST *asTemplateDeclaration() { return 0; }
-    virtual TemplateIdAST *asTemplateId() { return 0; }
-    virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return 0; }
-    virtual ThisExpressionAST *asThisExpression() { return 0; }
-    virtual ThrowExpressionAST *asThrowExpression() { return 0; }
-    virtual TrailingReturnTypeAST *asTrailingReturnType() { return 0; }
-    virtual TranslationUnitAST *asTranslationUnit() { return 0; }
-    virtual TryBlockStatementAST *asTryBlockStatement() { return 0; }
-    virtual TypeConstructorCallAST *asTypeConstructorCall() { return 0; }
-    virtual TypeIdAST *asTypeId() { return 0; }
-    virtual TypeidExpressionAST *asTypeidExpression() { return 0; }
-    virtual TypenameCallExpressionAST *asTypenameCallExpression() { return 0; }
-    virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return 0; }
-    virtual TypeofSpecifierAST *asTypeofSpecifier() { return 0; }
-    virtual UnaryExpressionAST *asUnaryExpression() { return 0; }
-    virtual UsingAST *asUsing() { return 0; }
-    virtual UsingDirectiveAST *asUsingDirective() { return 0; }
-    virtual WhileStatementAST *asWhileStatement() { return 0; }
+    virtual AccessDeclarationAST *asAccessDeclaration() { return nullptr; }
+    virtual AliasDeclarationAST *asAliasDeclaration() { return nullptr; }
+    virtual AlignmentSpecifierAST *asAlignmentSpecifier() { return nullptr; }
+    virtual AlignofExpressionAST *asAlignofExpression() { return nullptr; }
+    virtual AnonymousNameAST *asAnonymousName() { return nullptr; }
+    virtual ArrayAccessAST *asArrayAccess() { return nullptr; }
+    virtual ArrayDeclaratorAST *asArrayDeclarator() { return nullptr; }
+    virtual ArrayInitializerAST *asArrayInitializer() { return nullptr; }
+    virtual AsmDefinitionAST *asAsmDefinition() { return nullptr; }
+    virtual AttributeSpecifierAST *asAttributeSpecifier() { return nullptr; }
+    virtual BaseSpecifierAST *asBaseSpecifier() { return nullptr; }
+    virtual BinaryExpressionAST *asBinaryExpression() { return nullptr; }
+    virtual BoolLiteralAST *asBoolLiteral() { return nullptr; }
+    virtual BracedInitializerAST *asBracedInitializer() { return nullptr; }
+    virtual BracketDesignatorAST *asBracketDesignator() { return nullptr; }
+    virtual BreakStatementAST *asBreakStatement() { return nullptr; }
+    virtual CallAST *asCall() { return nullptr; }
+    virtual CaptureAST *asCapture() { return nullptr; }
+    virtual CaseStatementAST *asCaseStatement() { return nullptr; }
+    virtual CastExpressionAST *asCastExpression() { return nullptr; }
+    virtual CatchClauseAST *asCatchClause() { return nullptr; }
+    virtual ClassSpecifierAST *asClassSpecifier() { return nullptr; }
+    virtual CompoundExpressionAST *asCompoundExpression() { return nullptr; }
+    virtual CompoundLiteralAST *asCompoundLiteral() { return nullptr; }
+    virtual CompoundStatementAST *asCompoundStatement() { return nullptr; }
+    virtual ConditionAST *asCondition() { return nullptr; }
+    virtual ConditionalExpressionAST *asConditionalExpression() { return nullptr; }
+    virtual ContinueStatementAST *asContinueStatement() { return nullptr; }
+    virtual ConversionFunctionIdAST *asConversionFunctionId() { return nullptr; }
+    virtual CoreDeclaratorAST *asCoreDeclarator() { return nullptr; }
+    virtual CppCastExpressionAST *asCppCastExpression() { return nullptr; }
+    virtual CtorInitializerAST *asCtorInitializer() { return nullptr; }
+    virtual DeclarationAST *asDeclaration() { return nullptr; }
+    virtual DeclarationStatementAST *asDeclarationStatement() { return nullptr; }
+    virtual DeclaratorAST *asDeclarator() { return nullptr; }
+    virtual DeclaratorIdAST *asDeclaratorId() { return nullptr; }
+    virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return nullptr; }
+    virtual DeleteExpressionAST *asDeleteExpression() { return nullptr; }
+    virtual DesignatedInitializerAST *asDesignatedInitializer() { return nullptr; }
+    virtual DesignatorAST *asDesignator() { return nullptr; }
+    virtual DestructorNameAST *asDestructorName() { return nullptr; }
+    virtual DoStatementAST *asDoStatement() { return nullptr; }
+    virtual DotDesignatorAST *asDotDesignator() { return nullptr; }
+    virtual DynamicExceptionSpecificationAST *asDynamicExceptionSpecification() { return nullptr; }
+    virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return nullptr; }
+    virtual EmptyDeclarationAST *asEmptyDeclaration() { return nullptr; }
+    virtual EnumSpecifierAST *asEnumSpecifier() { return nullptr; }
+    virtual EnumeratorAST *asEnumerator() { return nullptr; }
+    virtual ExceptionDeclarationAST *asExceptionDeclaration() { return nullptr; }
+    virtual ExceptionSpecificationAST *asExceptionSpecification() { return nullptr; }
+    virtual ExpressionAST *asExpression() { return nullptr; }
+    virtual ExpressionListParenAST *asExpressionListParen() { return nullptr; }
+    virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return nullptr; }
+    virtual ExpressionStatementAST *asExpressionStatement() { return nullptr; }
+    virtual ForStatementAST *asForStatement() { return nullptr; }
+    virtual ForeachStatementAST *asForeachStatement() { return nullptr; }
+    virtual FunctionDeclaratorAST *asFunctionDeclarator() { return nullptr; }
+    virtual FunctionDefinitionAST *asFunctionDefinition() { return nullptr; }
+    virtual GnuAttributeAST *asGnuAttribute() { return nullptr; }
+    virtual GnuAttributeSpecifierAST *asGnuAttributeSpecifier() { return nullptr; }
+    virtual GotoStatementAST *asGotoStatement() { return nullptr; }
+    virtual IdExpressionAST *asIdExpression() { return nullptr; }
+    virtual IfStatementAST *asIfStatement() { return nullptr; }
+    virtual LabeledStatementAST *asLabeledStatement() { return nullptr; }
+    virtual LambdaCaptureAST *asLambdaCapture() { return nullptr; }
+    virtual LambdaDeclaratorAST *asLambdaDeclarator() { return nullptr; }
+    virtual LambdaExpressionAST *asLambdaExpression() { return nullptr; }
+    virtual LambdaIntroducerAST *asLambdaIntroducer() { return nullptr; }
+    virtual LinkageBodyAST *asLinkageBody() { return nullptr; }
+    virtual LinkageSpecificationAST *asLinkageSpecification() { return nullptr; }
+    virtual MemInitializerAST *asMemInitializer() { return nullptr; }
+    virtual MemberAccessAST *asMemberAccess() { return nullptr; }
+    virtual NameAST *asName() { return nullptr; }
+    virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return nullptr; }
+    virtual NamespaceAST *asNamespace() { return nullptr; }
+    virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return nullptr; }
+    virtual NestedDeclaratorAST *asNestedDeclarator() { return nullptr; }
+    virtual NestedExpressionAST *asNestedExpression() { return nullptr; }
+    virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return nullptr; }
+    virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return nullptr; }
+    virtual NewExpressionAST *asNewExpression() { return nullptr; }
+    virtual NewTypeIdAST *asNewTypeId() { return nullptr; }
+    virtual NoExceptOperatorExpressionAST *asNoExceptOperatorExpression() { return nullptr; }
+    virtual NoExceptSpecificationAST *asNoExceptSpecification() { return nullptr; }
+    virtual NumericLiteralAST *asNumericLiteral() { return nullptr; }
+    virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return nullptr; }
+    virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return nullptr; }
+    virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return nullptr; }
+    virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return nullptr; }
+    virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return nullptr; }
+    virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return nullptr; }
+    virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return nullptr; }
+    virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return nullptr; }
+    virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return nullptr; }
+    virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return nullptr; }
+    virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return nullptr; }
+    virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return nullptr; }
+    virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return nullptr; }
+    virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return nullptr; }
+    virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return nullptr; }
+    virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return nullptr; }
+    virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return nullptr; }
+    virtual ObjCSelectorAST *asObjCSelector() { return nullptr; }
+    virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return nullptr; }
+    virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return nullptr; }
+    virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return nullptr; }
+    virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return nullptr; }
+    virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return nullptr; }
+    virtual ObjCTypeNameAST *asObjCTypeName() { return nullptr; }
+    virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return nullptr; }
+    virtual OperatorAST *asOperator() { return nullptr; }
+    virtual OperatorFunctionIdAST *asOperatorFunctionId() { return nullptr; }
+    virtual ParameterDeclarationAST *asParameterDeclaration() { return nullptr; }
+    virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return nullptr; }
+    virtual PointerAST *asPointer() { return nullptr; }
+    virtual PointerLiteralAST *asPointerLiteral() { return nullptr; }
+    virtual PointerToMemberAST *asPointerToMember() { return nullptr; }
+    virtual PostIncrDecrAST *asPostIncrDecr() { return nullptr; }
+    virtual PostfixAST *asPostfix() { return nullptr; }
+    virtual PostfixDeclaratorAST *asPostfixDeclarator() { return nullptr; }
+    virtual PtrOperatorAST *asPtrOperator() { return nullptr; }
+    virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return nullptr; }
+    virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return nullptr; }
+    virtual QtInterfaceNameAST *asQtInterfaceName() { return nullptr; }
+    virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return nullptr; }
+    virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return nullptr; }
+    virtual QtMethodAST *asQtMethod() { return nullptr; }
+    virtual QtObjectTagAST *asQtObjectTag() { return nullptr; }
+    virtual QtPrivateSlotAST *asQtPrivateSlot() { return nullptr; }
+    virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return nullptr; }
+    virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return nullptr; }
+    virtual QualifiedNameAST *asQualifiedName() { return nullptr; }
+    virtual RangeBasedForStatementAST *asRangeBasedForStatement() { return nullptr; }
+    virtual ReferenceAST *asReference() { return nullptr; }
+    virtual ReturnStatementAST *asReturnStatement() { return nullptr; }
+    virtual SimpleDeclarationAST *asSimpleDeclaration() { return nullptr; }
+    virtual SimpleNameAST *asSimpleName() { return nullptr; }
+    virtual SimpleSpecifierAST *asSimpleSpecifier() { return nullptr; }
+    virtual SizeofExpressionAST *asSizeofExpression() { return nullptr; }
+    virtual SpecifierAST *asSpecifier() { return nullptr; }
+    virtual StatementAST *asStatement() { return nullptr; }
+    virtual StaticAssertDeclarationAST *asStaticAssertDeclaration() { return nullptr; }
+    virtual StringLiteralAST *asStringLiteral() { return nullptr; }
+    virtual SwitchStatementAST *asSwitchStatement() { return nullptr; }
+    virtual TemplateDeclarationAST *asTemplateDeclaration() { return nullptr; }
+    virtual TemplateIdAST *asTemplateId() { return nullptr; }
+    virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return nullptr; }
+    virtual ThisExpressionAST *asThisExpression() { return nullptr; }
+    virtual ThrowExpressionAST *asThrowExpression() { return nullptr; }
+    virtual TrailingReturnTypeAST *asTrailingReturnType() { return nullptr; }
+    virtual TranslationUnitAST *asTranslationUnit() { return nullptr; }
+    virtual TryBlockStatementAST *asTryBlockStatement() { return nullptr; }
+    virtual TypeConstructorCallAST *asTypeConstructorCall() { return nullptr; }
+    virtual TypeIdAST *asTypeId() { return nullptr; }
+    virtual TypeidExpressionAST *asTypeidExpression() { return nullptr; }
+    virtual TypenameCallExpressionAST *asTypenameCallExpression() { return nullptr; }
+    virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return nullptr; }
+    virtual TypeofSpecifierAST *asTypeofSpecifier() { return nullptr; }
+    virtual UnaryExpressionAST *asUnaryExpression() { return nullptr; }
+    virtual UsingAST *asUsing() { return nullptr; }
+    virtual UsingDirectiveAST *asUsingDirective() { return nullptr; }
+    virtual WhileStatementAST *asWhileStatement() { return nullptr; }
 
 protected:
     virtual void accept0(ASTVisitor *visitor) = 0;
diff --git a/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h b/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h
index 9270a3429c..f9ede8834d 100644
--- a/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h
+++ b/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h
@@ -49,7 +49,7 @@ public:
         return ast;
     }
 
-    ObjCSelectorAST *ObjCSelector(ObjCSelectorArgumentListAST *selector_argument_list = 0)
+    ObjCSelectorAST *ObjCSelector(ObjCSelectorArgumentListAST *selector_argument_list = nullptr)
     {
         ObjCSelectorAST *ast = new (&pool) ObjCSelectorAST;
         ast->selector_argument_list = selector_argument_list;
@@ -62,42 +62,42 @@ public:
         return ast;
     }
 
-    AlignmentSpecifierAST *AlignmentSpecifier(ExpressionAST *typeIdExprOrAlignmentExpr = 0)
+    AlignmentSpecifierAST *AlignmentSpecifier(ExpressionAST *typeIdExprOrAlignmentExpr = nullptr)
     {
         AlignmentSpecifierAST *ast = new (&pool) AlignmentSpecifierAST;
         ast->typeIdExprOrAlignmentExpr = typeIdExprOrAlignmentExpr;
         return ast;
     }
 
-    GnuAttributeSpecifierAST *GnuAttributeSpecifier(GnuAttributeListAST *attribute_list = 0)
+    GnuAttributeSpecifierAST *GnuAttributeSpecifier(GnuAttributeListAST *attribute_list = nullptr)
     {
         GnuAttributeSpecifierAST *ast = new (&pool) GnuAttributeSpecifierAST;
         ast->attribute_list = attribute_list;
         return ast;
     }
 
-    GnuAttributeAST *GnuAttribute(ExpressionListAST *expression_list = 0)
+    GnuAttributeAST *GnuAttribute(ExpressionListAST *expression_list = nullptr)
     {
         GnuAttributeAST *ast = new (&pool) GnuAttributeAST;
         ast->expression_list = expression_list;
         return ast;
     }
 
-    TypeofSpecifierAST *TypeofSpecifier(ExpressionAST *expression = 0)
+    TypeofSpecifierAST *TypeofSpecifier(ExpressionAST *expression = nullptr)
     {
         TypeofSpecifierAST *ast = new (&pool) TypeofSpecifierAST;
         ast->expression = expression;
         return ast;
     }
 
-    DecltypeSpecifierAST *DecltypeSpecifier(ExpressionAST *expression = 0)
+    DecltypeSpecifierAST *DecltypeSpecifier(ExpressionAST *expression = nullptr)
     {
         DecltypeSpecifierAST *ast = new (&pool) DecltypeSpecifierAST;
         ast->expression = expression;
         return ast;
     }
 
-    DeclaratorAST *Declarator(SpecifierListAST *attribute_list = 0, PtrOperatorListAST *ptr_operator_list = 0, CoreDeclaratorAST *core_declarator = 0, PostfixDeclaratorListAST *postfix_declarator_list = 0, SpecifierListAST *post_attribute_list = 0, ExpressionAST *initializer = 0)
+    DeclaratorAST *Declarator(SpecifierListAST *attribute_list = nullptr, PtrOperatorListAST *ptr_operator_list = nullptr, CoreDeclaratorAST *core_declarator = nullptr, PostfixDeclaratorListAST *postfix_declarator_list = nullptr, SpecifierListAST *post_attribute_list = nullptr, ExpressionAST *initializer = nullptr)
     {
         DeclaratorAST *ast = new (&pool) DeclaratorAST;
         ast->attribute_list = attribute_list;
@@ -109,7 +109,7 @@ public:
         return ast;
     }
 
-    SimpleDeclarationAST *SimpleDeclaration(SpecifierListAST *decl_specifier_list = 0, DeclaratorListAST *declarator_list = 0)
+    SimpleDeclarationAST *SimpleDeclaration(SpecifierListAST *decl_specifier_list = nullptr, DeclaratorListAST *declarator_list = nullptr)
     {
         SimpleDeclarationAST *ast = new (&pool) SimpleDeclarationAST;
         ast->decl_specifier_list = decl_specifier_list;
@@ -135,7 +135,7 @@ public:
         return ast;
     }
 
-    QtPrivateSlotAST *QtPrivateSlot(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0)
+    QtPrivateSlotAST *QtPrivateSlot(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr)
     {
         QtPrivateSlotAST *ast = new (&pool) QtPrivateSlotAST;
         ast->type_specifier_list = type_specifier_list;
@@ -143,14 +143,14 @@ public:
         return ast;
     }
 
-    QtPropertyDeclarationItemAST *QtPropertyDeclarationItem(ExpressionAST *expression = 0)
+    QtPropertyDeclarationItemAST *QtPropertyDeclarationItem(ExpressionAST *expression = nullptr)
     {
         QtPropertyDeclarationItemAST *ast = new (&pool) QtPropertyDeclarationItemAST;
         ast->expression = expression;
         return ast;
     }
 
-    QtPropertyDeclarationAST *QtPropertyDeclaration(ExpressionAST *expression = 0, ExpressionAST *type_id = 0, NameAST *property_name = 0, QtPropertyDeclarationItemListAST *property_declaration_item_list = 0)
+    QtPropertyDeclarationAST *QtPropertyDeclaration(ExpressionAST *expression = nullptr, ExpressionAST *type_id = nullptr, NameAST *property_name = nullptr, QtPropertyDeclarationItemListAST *property_declaration_item_list = nullptr)
     {
         QtPropertyDeclarationAST *ast = new (&pool) QtPropertyDeclarationAST;
         ast->expression = expression;
@@ -160,21 +160,21 @@ public:
         return ast;
     }
 
-    QtEnumDeclarationAST *QtEnumDeclaration(NameListAST *enumerator_list = 0)
+    QtEnumDeclarationAST *QtEnumDeclaration(NameListAST *enumerator_list = nullptr)
     {
         QtEnumDeclarationAST *ast = new (&pool) QtEnumDeclarationAST;
         ast->enumerator_list = enumerator_list;
         return ast;
     }
 
-    QtFlagsDeclarationAST *QtFlagsDeclaration(NameListAST *flag_enums_list = 0)
+    QtFlagsDeclarationAST *QtFlagsDeclaration(NameListAST *flag_enums_list = nullptr)
     {
         QtFlagsDeclarationAST *ast = new (&pool) QtFlagsDeclarationAST;
         ast->flag_enums_list = flag_enums_list;
         return ast;
     }
 
-    QtInterfaceNameAST *QtInterfaceName(NameAST *interface_name = 0, NameListAST *constraint_list = 0)
+    QtInterfaceNameAST *QtInterfaceName(NameAST *interface_name = nullptr, NameListAST *constraint_list = nullptr)
     {
         QtInterfaceNameAST *ast = new (&pool) QtInterfaceNameAST;
         ast->interface_name = interface_name;
@@ -182,7 +182,7 @@ public:
         return ast;
     }
 
-    QtInterfacesDeclarationAST *QtInterfacesDeclaration(QtInterfaceNameListAST *interface_name_list = 0)
+    QtInterfacesDeclarationAST *QtInterfacesDeclaration(QtInterfaceNameListAST *interface_name_list = nullptr)
     {
         QtInterfacesDeclarationAST *ast = new (&pool) QtInterfacesDeclarationAST;
         ast->interface_name_list = interface_name_list;
@@ -195,28 +195,28 @@ public:
         return ast;
     }
 
-    BaseSpecifierAST *BaseSpecifier(NameAST *name = 0)
+    BaseSpecifierAST *BaseSpecifier(NameAST *name = nullptr)
     {
         BaseSpecifierAST *ast = new (&pool) BaseSpecifierAST;
         ast->name = name;
         return ast;
     }
 
-    IdExpressionAST *IdExpression(NameAST *name = 0)
+    IdExpressionAST *IdExpression(NameAST *name = nullptr)
     {
         IdExpressionAST *ast = new (&pool) IdExpressionAST;
         ast->name = name;
         return ast;
     }
 
-    CompoundExpressionAST *CompoundExpression(CompoundStatementAST *statement = 0)
+    CompoundExpressionAST *CompoundExpression(CompoundStatementAST *statement = nullptr)
     {
         CompoundExpressionAST *ast = new (&pool) CompoundExpressionAST;
         ast->statement = statement;
         return ast;
     }
 
-    CompoundLiteralAST *CompoundLiteral(ExpressionAST *type_id = 0, ExpressionAST *initializer = 0)
+    CompoundLiteralAST *CompoundLiteral(ExpressionAST *type_id = nullptr, ExpressionAST *initializer = nullptr)
     {
         CompoundLiteralAST *ast = new (&pool) CompoundLiteralAST;
         ast->type_id = type_id;
@@ -224,21 +224,21 @@ public:
         return ast;
     }
 
-    QtMethodAST *QtMethod(DeclaratorAST *declarator = 0)
+    QtMethodAST *QtMethod(DeclaratorAST *declarator = nullptr)
     {
         QtMethodAST *ast = new (&pool) QtMethodAST;
         ast->declarator = declarator;
         return ast;
     }
 
-    QtMemberDeclarationAST *QtMemberDeclaration(ExpressionAST *type_id = 0)
+    QtMemberDeclarationAST *QtMemberDeclaration(ExpressionAST *type_id = nullptr)
     {
         QtMemberDeclarationAST *ast = new (&pool) QtMemberDeclarationAST;
         ast->type_id = type_id;
         return ast;
     }
 
-    BinaryExpressionAST *BinaryExpression(ExpressionAST *left_expression = 0, ExpressionAST *right_expression = 0)
+    BinaryExpressionAST *BinaryExpression(ExpressionAST *left_expression = nullptr, ExpressionAST *right_expression = nullptr)
     {
         BinaryExpressionAST *ast = new (&pool) BinaryExpressionAST;
         ast->left_expression = left_expression;
@@ -246,7 +246,7 @@ public:
         return ast;
     }
 
-    CastExpressionAST *CastExpression(ExpressionAST *type_id = 0, ExpressionAST *expression = 0)
+    CastExpressionAST *CastExpression(ExpressionAST *type_id = nullptr, ExpressionAST *expression = nullptr)
     {
         CastExpressionAST *ast = new (&pool) CastExpressionAST;
         ast->type_id = type_id;
@@ -254,7 +254,7 @@ public:
         return ast;
     }
 
-    ClassSpecifierAST *ClassSpecifier(SpecifierListAST *attribute_list = 0, NameAST *name = 0, BaseSpecifierListAST *base_clause_list = 0, DeclarationListAST *member_specifier_list = 0)
+    ClassSpecifierAST *ClassSpecifier(SpecifierListAST *attribute_list = nullptr, NameAST *name = nullptr, BaseSpecifierListAST *base_clause_list = nullptr, DeclarationListAST *member_specifier_list = nullptr)
     {
         ClassSpecifierAST *ast = new (&pool) ClassSpecifierAST;
         ast->attribute_list = attribute_list;
@@ -264,7 +264,7 @@ public:
         return ast;
     }
 
-    CaseStatementAST *CaseStatement(ExpressionAST *expression = 0, StatementAST *statement = 0)
+    CaseStatementAST *CaseStatement(ExpressionAST *expression = nullptr, StatementAST *statement = nullptr)
     {
         CaseStatementAST *ast = new (&pool) CaseStatementAST;
         ast->expression = expression;
@@ -272,14 +272,14 @@ public:
         return ast;
     }
 
-    CompoundStatementAST *CompoundStatement(StatementListAST *statement_list = 0)
+    CompoundStatementAST *CompoundStatement(StatementListAST *statement_list = nullptr)
     {
         CompoundStatementAST *ast = new (&pool) CompoundStatementAST;
         ast->statement_list = statement_list;
         return ast;
     }
 
-    ConditionAST *Condition(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0)
+    ConditionAST *Condition(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr)
     {
         ConditionAST *ast = new (&pool) ConditionAST;
         ast->type_specifier_list = type_specifier_list;
@@ -287,7 +287,7 @@ public:
         return ast;
     }
 
-    ConditionalExpressionAST *ConditionalExpression(ExpressionAST *condition = 0, ExpressionAST *left_expression = 0, ExpressionAST *right_expression = 0)
+    ConditionalExpressionAST *ConditionalExpression(ExpressionAST *condition = nullptr, ExpressionAST *left_expression = nullptr, ExpressionAST *right_expression = nullptr)
     {
         ConditionalExpressionAST *ast = new (&pool) ConditionalExpressionAST;
         ast->condition = condition;
@@ -296,7 +296,7 @@ public:
         return ast;
     }
 
-    CppCastExpressionAST *CppCastExpression(ExpressionAST *type_id = 0, ExpressionAST *expression = 0)
+    CppCastExpressionAST *CppCastExpression(ExpressionAST *type_id = nullptr, ExpressionAST *expression = nullptr)
     {
         CppCastExpressionAST *ast = new (&pool) CppCastExpressionAST;
         ast->type_id = type_id;
@@ -304,35 +304,35 @@ public:
         return ast;
     }
 
-    CtorInitializerAST *CtorInitializer(MemInitializerListAST *member_initializer_list = 0)
+    CtorInitializerAST *CtorInitializer(MemInitializerListAST *member_initializer_list = nullptr)
     {
         CtorInitializerAST *ast = new (&pool) CtorInitializerAST;
         ast->member_initializer_list = member_initializer_list;
         return ast;
     }
 
-    DeclarationStatementAST *DeclarationStatement(DeclarationAST *declaration = 0)
+    DeclarationStatementAST *DeclarationStatement(DeclarationAST *declaration = nullptr)
     {
         DeclarationStatementAST *ast = new (&pool) DeclarationStatementAST;
         ast->declaration = declaration;
         return ast;
     }
 
-    DeclaratorIdAST *DeclaratorId(NameAST *name = 0)
+    DeclaratorIdAST *DeclaratorId(NameAST *name = nullptr)
     {
         DeclaratorIdAST *ast = new (&pool) DeclaratorIdAST;
         ast->name = name;
         return ast;
     }
 
-    NestedDeclaratorAST *NestedDeclarator(DeclaratorAST *declarator = 0)
+    NestedDeclaratorAST *NestedDeclarator(DeclaratorAST *declarator = nullptr)
     {
         NestedDeclaratorAST *ast = new (&pool) NestedDeclaratorAST;
         ast->declarator = declarator;
         return ast;
     }
 
-    FunctionDeclaratorAST *FunctionDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = 0, SpecifierListAST *cv_qualifier_list = 0, ExceptionSpecificationAST *exception_specification = 0, TrailingReturnTypeAST *trailing_return_type = 0, ExpressionAST *as_cpp_initializer = 0)
+    FunctionDeclaratorAST *FunctionDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = nullptr, SpecifierListAST *cv_qualifier_list = nullptr, ExceptionSpecificationAST *exception_specification = nullptr, TrailingReturnTypeAST *trailing_return_type = nullptr, ExpressionAST *as_cpp_initializer = nullptr)
     {
         FunctionDeclaratorAST *ast = new (&pool) FunctionDeclaratorAST;
         ast->parameter_declaration_clause = parameter_declaration_clause;
@@ -343,21 +343,21 @@ public:
         return ast;
     }
 
-    ArrayDeclaratorAST *ArrayDeclarator(ExpressionAST *expression = 0)
+    ArrayDeclaratorAST *ArrayDeclarator(ExpressionAST *expression = nullptr)
     {
         ArrayDeclaratorAST *ast = new (&pool) ArrayDeclaratorAST;
         ast->expression = expression;
         return ast;
     }
 
-    DeleteExpressionAST *DeleteExpression(ExpressionAST *expression = 0)
+    DeleteExpressionAST *DeleteExpression(ExpressionAST *expression = nullptr)
     {
         DeleteExpressionAST *ast = new (&pool) DeleteExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    DoStatementAST *DoStatement(StatementAST *statement = 0, ExpressionAST *expression = 0)
+    DoStatementAST *DoStatement(StatementAST *statement = nullptr, ExpressionAST *expression = nullptr)
     {
         DoStatementAST *ast = new (&pool) DoStatementAST;
         ast->statement = statement;
@@ -365,14 +365,14 @@ public:
         return ast;
     }
 
-    NamedTypeSpecifierAST *NamedTypeSpecifier(NameAST *name = 0)
+    NamedTypeSpecifierAST *NamedTypeSpecifier(NameAST *name = nullptr)
     {
         NamedTypeSpecifierAST *ast = new (&pool) NamedTypeSpecifierAST;
         ast->name = name;
         return ast;
     }
 
-    ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifier(SpecifierListAST *attribute_list = 0, NameAST *name = 0)
+    ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifier(SpecifierListAST *attribute_list = nullptr, NameAST *name = nullptr)
     {
         ElaboratedTypeSpecifierAST *ast = new (&pool) ElaboratedTypeSpecifierAST;
         ast->attribute_list = attribute_list;
@@ -380,7 +380,7 @@ public:
         return ast;
     }
 
-    EnumSpecifierAST *EnumSpecifier(NameAST *name = 0, SpecifierListAST *type_specifier_list = 0, EnumeratorListAST *enumerator_list = 0)
+    EnumSpecifierAST *EnumSpecifier(NameAST *name = nullptr, SpecifierListAST *type_specifier_list = nullptr, EnumeratorListAST *enumerator_list = nullptr)
     {
         EnumSpecifierAST *ast = new (&pool) EnumSpecifierAST;
         ast->name = name;
@@ -389,14 +389,14 @@ public:
         return ast;
     }
 
-    EnumeratorAST *Enumerator(ExpressionAST *expression = 0)
+    EnumeratorAST *Enumerator(ExpressionAST *expression = nullptr)
     {
         EnumeratorAST *ast = new (&pool) EnumeratorAST;
         ast->expression = expression;
         return ast;
     }
 
-    ExceptionDeclarationAST *ExceptionDeclaration(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0)
+    ExceptionDeclarationAST *ExceptionDeclaration(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr)
     {
         ExceptionDeclarationAST *ast = new (&pool) ExceptionDeclarationAST;
         ast->type_specifier_list = type_specifier_list;
@@ -404,21 +404,21 @@ public:
         return ast;
     }
 
-    DynamicExceptionSpecificationAST *DynamicExceptionSpecification(ExpressionListAST *type_id_list = 0)
+    DynamicExceptionSpecificationAST *DynamicExceptionSpecification(ExpressionListAST *type_id_list = nullptr)
     {
         DynamicExceptionSpecificationAST *ast = new (&pool) DynamicExceptionSpecificationAST;
         ast->type_id_list = type_id_list;
         return ast;
     }
 
-    NoExceptSpecificationAST *NoExceptSpecification(ExpressionAST *expression = 0)
+    NoExceptSpecificationAST *NoExceptSpecification(ExpressionAST *expression = nullptr)
     {
         NoExceptSpecificationAST *ast = new (&pool) NoExceptSpecificationAST;
         ast->expression = expression;
         return ast;
     }
 
-    ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatement(ExpressionStatementAST *expression = 0, DeclarationStatementAST *declaration = 0)
+    ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatement(ExpressionStatementAST *expression = nullptr, DeclarationStatementAST *declaration = nullptr)
     {
         ExpressionOrDeclarationStatementAST *ast = new (&pool) ExpressionOrDeclarationStatementAST;
         ast->expression = expression;
@@ -426,14 +426,14 @@ public:
         return ast;
     }
 
-    ExpressionStatementAST *ExpressionStatement(ExpressionAST *expression = 0)
+    ExpressionStatementAST *ExpressionStatement(ExpressionAST *expression = nullptr)
     {
         ExpressionStatementAST *ast = new (&pool) ExpressionStatementAST;
         ast->expression = expression;
         return ast;
     }
 
-    FunctionDefinitionAST *FunctionDefinition(SpecifierListAST *decl_specifier_list = 0, DeclaratorAST *declarator = 0, CtorInitializerAST *ctor_initializer = 0, StatementAST *function_body = 0)
+    FunctionDefinitionAST *FunctionDefinition(SpecifierListAST *decl_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, CtorInitializerAST *ctor_initializer = nullptr, StatementAST *function_body = nullptr)
     {
         FunctionDefinitionAST *ast = new (&pool) FunctionDefinitionAST;
         ast->decl_specifier_list = decl_specifier_list;
@@ -443,7 +443,7 @@ public:
         return ast;
     }
 
-    ForeachStatementAST *ForeachStatement(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *initializer = 0, ExpressionAST *expression = 0, StatementAST *statement = 0)
+    ForeachStatementAST *ForeachStatement(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *initializer = nullptr, ExpressionAST *expression = nullptr, StatementAST *statement = nullptr)
     {
         ForeachStatementAST *ast = new (&pool) ForeachStatementAST;
         ast->type_specifier_list = type_specifier_list;
@@ -454,7 +454,7 @@ public:
         return ast;
     }
 
-    RangeBasedForStatementAST *RangeBasedForStatement(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *expression = 0, StatementAST *statement = 0)
+    RangeBasedForStatementAST *RangeBasedForStatement(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *expression = nullptr, StatementAST *statement = nullptr)
     {
         RangeBasedForStatementAST *ast = new (&pool) RangeBasedForStatementAST;
         ast->type_specifier_list = type_specifier_list;
@@ -464,7 +464,7 @@ public:
         return ast;
     }
 
-    ForStatementAST *ForStatement(StatementAST *initializer = 0, ExpressionAST *condition = 0, ExpressionAST *expression = 0, StatementAST *statement = 0)
+    ForStatementAST *ForStatement(StatementAST *initializer = nullptr, ExpressionAST *condition = nullptr, ExpressionAST *expression = nullptr, StatementAST *statement = nullptr)
     {
         ForStatementAST *ast = new (&pool) ForStatementAST;
         ast->initializer = initializer;
@@ -474,7 +474,7 @@ public:
         return ast;
     }
 
-    IfStatementAST *IfStatement(ExpressionAST *condition = 0, StatementAST *statement = 0, StatementAST *else_statement = 0)
+    IfStatementAST *IfStatement(ExpressionAST *condition = nullptr, StatementAST *statement = nullptr, StatementAST *else_statement = nullptr)
     {
         IfStatementAST *ast = new (&pool) IfStatementAST;
         ast->condition = condition;
@@ -483,35 +483,35 @@ public:
         return ast;
     }
 
-    ArrayInitializerAST *ArrayInitializer(ExpressionListAST *expression_list = 0)
+    ArrayInitializerAST *ArrayInitializer(ExpressionListAST *expression_list = nullptr)
     {
         ArrayInitializerAST *ast = new (&pool) ArrayInitializerAST;
         ast->expression_list = expression_list;
         return ast;
     }
 
-    LabeledStatementAST *LabeledStatement(StatementAST *statement = 0)
+    LabeledStatementAST *LabeledStatement(StatementAST *statement = nullptr)
     {
         LabeledStatementAST *ast = new (&pool) LabeledStatementAST;
         ast->statement = statement;
         return ast;
     }
 
-    LinkageBodyAST *LinkageBody(DeclarationListAST *declaration_list = 0)
+    LinkageBodyAST *LinkageBody(DeclarationListAST *declaration_list = nullptr)
     {
         LinkageBodyAST *ast = new (&pool) LinkageBodyAST;
         ast->declaration_list = declaration_list;
         return ast;
     }
 
-    LinkageSpecificationAST *LinkageSpecification(DeclarationAST *declaration = 0)
+    LinkageSpecificationAST *LinkageSpecification(DeclarationAST *declaration = nullptr)
     {
         LinkageSpecificationAST *ast = new (&pool) LinkageSpecificationAST;
         ast->declaration = declaration;
         return ast;
     }
 
-    MemInitializerAST *MemInitializer(NameAST *name = 0, ExpressionAST *expression = 0)
+    MemInitializerAST *MemInitializer(NameAST *name = nullptr, ExpressionAST *expression = nullptr)
     {
         MemInitializerAST *ast = new (&pool) MemInitializerAST;
         ast->name = name;
@@ -519,14 +519,14 @@ public:
         return ast;
     }
 
-    NestedNameSpecifierAST *NestedNameSpecifier(NameAST *class_or_namespace_name = 0)
+    NestedNameSpecifierAST *NestedNameSpecifier(NameAST *class_or_namespace_name = nullptr)
     {
         NestedNameSpecifierAST *ast = new (&pool) NestedNameSpecifierAST;
         ast->class_or_namespace_name = class_or_namespace_name;
         return ast;
     }
 
-    QualifiedNameAST *QualifiedName(NestedNameSpecifierListAST *nested_name_specifier_list = 0, NameAST *unqualified_name = 0)
+    QualifiedNameAST *QualifiedName(NestedNameSpecifierListAST *nested_name_specifier_list = nullptr, NameAST *unqualified_name = nullptr)
     {
         QualifiedNameAST *ast = new (&pool) QualifiedNameAST;
         ast->nested_name_specifier_list = nested_name_specifier_list;
@@ -534,14 +534,14 @@ public:
         return ast;
     }
 
-    OperatorFunctionIdAST *OperatorFunctionId(OperatorAST *op = 0)
+    OperatorFunctionIdAST *OperatorFunctionId(OperatorAST *op = nullptr)
     {
         OperatorFunctionIdAST *ast = new (&pool) OperatorFunctionIdAST;
         ast->op = op;
         return ast;
     }
 
-    ConversionFunctionIdAST *ConversionFunctionId(SpecifierListAST *type_specifier_list = 0, PtrOperatorListAST *ptr_operator_list = 0)
+    ConversionFunctionIdAST *ConversionFunctionId(SpecifierListAST *type_specifier_list = nullptr, PtrOperatorListAST *ptr_operator_list = nullptr)
     {
         ConversionFunctionIdAST *ast = new (&pool) ConversionFunctionIdAST;
         ast->type_specifier_list = type_specifier_list;
@@ -561,21 +561,21 @@ public:
         return ast;
     }
 
-    DestructorNameAST *DestructorName(NameAST *unqualified_name = 0)
+    DestructorNameAST *DestructorName(NameAST *unqualified_name = nullptr)
     {
         DestructorNameAST *ast = new (&pool) DestructorNameAST;
         ast->unqualified_name = unqualified_name;
         return ast;
     }
 
-    TemplateIdAST *TemplateId(ExpressionListAST *template_argument_list = 0)
+    TemplateIdAST *TemplateId(ExpressionListAST *template_argument_list = nullptr)
     {
         TemplateIdAST *ast = new (&pool) TemplateIdAST;
         ast->template_argument_list = template_argument_list;
         return ast;
     }
 
-    NamespaceAST *Namespace(SpecifierListAST *attribute_list = 0, DeclarationAST *linkage_body = 0)
+    NamespaceAST *Namespace(SpecifierListAST *attribute_list = nullptr, DeclarationAST *linkage_body = nullptr)
     {
         NamespaceAST *ast = new (&pool) NamespaceAST;
         ast->attribute_list = attribute_list;
@@ -583,14 +583,14 @@ public:
         return ast;
     }
 
-    NamespaceAliasDefinitionAST *NamespaceAliasDefinition(NameAST *name = 0)
+    NamespaceAliasDefinitionAST *NamespaceAliasDefinition(NameAST *name = nullptr)
     {
         NamespaceAliasDefinitionAST *ast = new (&pool) NamespaceAliasDefinitionAST;
         ast->name = name;
         return ast;
     }
 
-    AliasDeclarationAST *AliasDeclaration(NameAST *name = 0, TypeIdAST *typeId = 0)
+    AliasDeclarationAST *AliasDeclaration(NameAST *name = nullptr, TypeIdAST *typeId = nullptr)
     {
         AliasDeclarationAST *ast = new (&pool) AliasDeclarationAST;
         ast->name = name;
@@ -598,21 +598,21 @@ public:
         return ast;
     }
 
-    ExpressionListParenAST *ExpressionListParen(ExpressionListAST *expression_list = 0)
+    ExpressionListParenAST *ExpressionListParen(ExpressionListAST *expression_list = nullptr)
     {
         ExpressionListParenAST *ast = new (&pool) ExpressionListParenAST;
         ast->expression_list = expression_list;
         return ast;
     }
 
-    NewArrayDeclaratorAST *NewArrayDeclarator(ExpressionAST *expression = 0)
+    NewArrayDeclaratorAST *NewArrayDeclarator(ExpressionAST *expression = nullptr)
     {
         NewArrayDeclaratorAST *ast = new (&pool) NewArrayDeclaratorAST;
         ast->expression = expression;
         return ast;
     }
 
-    NewExpressionAST *NewExpression(ExpressionListParenAST *new_placement = 0, ExpressionAST *type_id = 0, NewTypeIdAST *new_type_id = 0, ExpressionAST *new_initializer = 0)
+    NewExpressionAST *NewExpression(ExpressionListParenAST *new_placement = nullptr, ExpressionAST *type_id = nullptr, NewTypeIdAST *new_type_id = nullptr, ExpressionAST *new_initializer = nullptr)
     {
         NewExpressionAST *ast = new (&pool) NewExpressionAST;
         ast->new_placement = new_placement;
@@ -622,7 +622,7 @@ public:
         return ast;
     }
 
-    NewTypeIdAST *NewTypeId(SpecifierListAST *type_specifier_list = 0, PtrOperatorListAST *ptr_operator_list = 0, NewArrayDeclaratorListAST *new_array_declarator_list = 0)
+    NewTypeIdAST *NewTypeId(SpecifierListAST *type_specifier_list = nullptr, PtrOperatorListAST *ptr_operator_list = nullptr, NewArrayDeclaratorListAST *new_array_declarator_list = nullptr)
     {
         NewTypeIdAST *ast = new (&pool) NewTypeIdAST;
         ast->type_specifier_list = type_specifier_list;
@@ -637,7 +637,7 @@ public:
         return ast;
     }
 
-    ParameterDeclarationAST *ParameterDeclaration(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *expression = 0)
+    ParameterDeclarationAST *ParameterDeclaration(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *expression = nullptr)
     {
         ParameterDeclarationAST *ast = new (&pool) ParameterDeclarationAST;
         ast->type_specifier_list = type_specifier_list;
@@ -646,14 +646,14 @@ public:
         return ast;
     }
 
-    ParameterDeclarationClauseAST *ParameterDeclarationClause(ParameterDeclarationListAST *parameter_declaration_list = 0)
+    ParameterDeclarationClauseAST *ParameterDeclarationClause(ParameterDeclarationListAST *parameter_declaration_list = nullptr)
     {
         ParameterDeclarationClauseAST *ast = new (&pool) ParameterDeclarationClauseAST;
         ast->parameter_declaration_list = parameter_declaration_list;
         return ast;
     }
 
-    CallAST *Call(ExpressionAST *base_expression = 0, ExpressionListAST *expression_list = 0)
+    CallAST *Call(ExpressionAST *base_expression = nullptr, ExpressionListAST *expression_list = nullptr)
     {
         CallAST *ast = new (&pool) CallAST;
         ast->base_expression = base_expression;
@@ -661,7 +661,7 @@ public:
         return ast;
     }
 
-    ArrayAccessAST *ArrayAccess(ExpressionAST *base_expression = 0, ExpressionAST *expression = 0)
+    ArrayAccessAST *ArrayAccess(ExpressionAST *base_expression = nullptr, ExpressionAST *expression = nullptr)
     {
         ArrayAccessAST *ast = new (&pool) ArrayAccessAST;
         ast->base_expression = base_expression;
@@ -669,14 +669,14 @@ public:
         return ast;
     }
 
-    PostIncrDecrAST *PostIncrDecr(ExpressionAST *base_expression = 0)
+    PostIncrDecrAST *PostIncrDecr(ExpressionAST *base_expression = nullptr)
     {
         PostIncrDecrAST *ast = new (&pool) PostIncrDecrAST;
         ast->base_expression = base_expression;
         return ast;
     }
 
-    MemberAccessAST *MemberAccess(ExpressionAST *base_expression = 0, NameAST *member_name = 0)
+    MemberAccessAST *MemberAccess(ExpressionAST *base_expression = nullptr, NameAST *member_name = nullptr)
     {
         MemberAccessAST *ast = new (&pool) MemberAccessAST;
         ast->base_expression = base_expression;
@@ -684,14 +684,14 @@ public:
         return ast;
     }
 
-    TypeidExpressionAST *TypeidExpression(ExpressionAST *expression = 0)
+    TypeidExpressionAST *TypeidExpression(ExpressionAST *expression = nullptr)
     {
         TypeidExpressionAST *ast = new (&pool) TypeidExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    TypenameCallExpressionAST *TypenameCallExpression(NameAST *name = 0, ExpressionAST *expression = 0)
+    TypenameCallExpressionAST *TypenameCallExpression(NameAST *name = nullptr, ExpressionAST *expression = nullptr)
     {
         TypenameCallExpressionAST *ast = new (&pool) TypenameCallExpressionAST;
         ast->name = name;
@@ -699,7 +699,7 @@ public:
         return ast;
     }
 
-    TypeConstructorCallAST *TypeConstructorCall(SpecifierListAST *type_specifier_list = 0, ExpressionAST *expression = 0)
+    TypeConstructorCallAST *TypeConstructorCall(SpecifierListAST *type_specifier_list = nullptr, ExpressionAST *expression = nullptr)
     {
         TypeConstructorCallAST *ast = new (&pool) TypeConstructorCallAST;
         ast->type_specifier_list = type_specifier_list;
@@ -707,7 +707,7 @@ public:
         return ast;
     }
 
-    PointerToMemberAST *PointerToMember(NestedNameSpecifierListAST *nested_name_specifier_list = 0, SpecifierListAST *cv_qualifier_list = 0)
+    PointerToMemberAST *PointerToMember(NestedNameSpecifierListAST *nested_name_specifier_list = nullptr, SpecifierListAST *cv_qualifier_list = nullptr)
     {
         PointerToMemberAST *ast = new (&pool) PointerToMemberAST;
         ast->nested_name_specifier_list = nested_name_specifier_list;
@@ -715,7 +715,7 @@ public:
         return ast;
     }
 
-    PointerAST *Pointer(SpecifierListAST *cv_qualifier_list = 0)
+    PointerAST *Pointer(SpecifierListAST *cv_qualifier_list = nullptr)
     {
         PointerAST *ast = new (&pool) PointerAST;
         ast->cv_qualifier_list = cv_qualifier_list;
@@ -746,21 +746,21 @@ public:
         return ast;
     }
 
-    ReturnStatementAST *ReturnStatement(ExpressionAST *expression = 0)
+    ReturnStatementAST *ReturnStatement(ExpressionAST *expression = nullptr)
     {
         ReturnStatementAST *ast = new (&pool) ReturnStatementAST;
         ast->expression = expression;
         return ast;
     }
 
-    SizeofExpressionAST *SizeofExpression(ExpressionAST *expression = 0)
+    SizeofExpressionAST *SizeofExpression(ExpressionAST *expression = nullptr)
     {
         SizeofExpressionAST *ast = new (&pool) SizeofExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    AlignofExpressionAST *AlignofExpression(TypeIdAST *typeId = 0)
+    AlignofExpressionAST *AlignofExpression(TypeIdAST *typeId = nullptr)
     {
         AlignofExpressionAST *ast = new (&pool) AlignofExpressionAST;
         ast->typeId = typeId;
@@ -791,14 +791,14 @@ public:
         return ast;
     }
 
-    NestedExpressionAST *NestedExpression(ExpressionAST *expression = 0)
+    NestedExpressionAST *NestedExpression(ExpressionAST *expression = nullptr)
     {
         NestedExpressionAST *ast = new (&pool) NestedExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    StaticAssertDeclarationAST *StaticAssertDeclaration(ExpressionAST *expression = 0, ExpressionAST *string_literal = 0)
+    StaticAssertDeclarationAST *StaticAssertDeclaration(ExpressionAST *expression = nullptr, ExpressionAST *string_literal = nullptr)
     {
         StaticAssertDeclarationAST *ast = new (&pool) StaticAssertDeclarationAST;
         ast->expression = expression;
@@ -806,14 +806,14 @@ public:
         return ast;
     }
 
-    StringLiteralAST *StringLiteral(StringLiteralAST *next = 0)
+    StringLiteralAST *StringLiteral(StringLiteralAST *next = nullptr)
     {
         StringLiteralAST *ast = new (&pool) StringLiteralAST;
         ast->next = next;
         return ast;
     }
 
-    SwitchStatementAST *SwitchStatement(ExpressionAST *condition = 0, StatementAST *statement = 0)
+    SwitchStatementAST *SwitchStatement(ExpressionAST *condition = nullptr, StatementAST *statement = nullptr)
     {
         SwitchStatementAST *ast = new (&pool) SwitchStatementAST;
         ast->condition = condition;
@@ -821,7 +821,7 @@ public:
         return ast;
     }
 
-    TemplateDeclarationAST *TemplateDeclaration(DeclarationListAST *template_parameter_list = 0, DeclarationAST *declaration = 0)
+    TemplateDeclarationAST *TemplateDeclaration(DeclarationListAST *template_parameter_list = nullptr, DeclarationAST *declaration = nullptr)
     {
         TemplateDeclarationAST *ast = new (&pool) TemplateDeclarationAST;
         ast->template_parameter_list = template_parameter_list;
@@ -829,28 +829,28 @@ public:
         return ast;
     }
 
-    ThrowExpressionAST *ThrowExpression(ExpressionAST *expression = 0)
+    ThrowExpressionAST *ThrowExpression(ExpressionAST *expression = nullptr)
     {
         ThrowExpressionAST *ast = new (&pool) ThrowExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    NoExceptOperatorExpressionAST *NoExceptOperatorExpression(ExpressionAST *expression = 0)
+    NoExceptOperatorExpressionAST *NoExceptOperatorExpression(ExpressionAST *expression = nullptr)
     {
         NoExceptOperatorExpressionAST *ast = new (&pool) NoExceptOperatorExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    TranslationUnitAST *TranslationUnit(DeclarationListAST *declaration_list = 0)
+    TranslationUnitAST *TranslationUnit(DeclarationListAST *declaration_list = nullptr)
     {
         TranslationUnitAST *ast = new (&pool) TranslationUnitAST;
         ast->declaration_list = declaration_list;
         return ast;
     }
 
-    TryBlockStatementAST *TryBlockStatement(StatementAST *statement = 0, CatchClauseListAST *catch_clause_list = 0)
+    TryBlockStatementAST *TryBlockStatement(StatementAST *statement = nullptr, CatchClauseListAST *catch_clause_list = nullptr)
     {
         TryBlockStatementAST *ast = new (&pool) TryBlockStatementAST;
         ast->statement = statement;
@@ -858,7 +858,7 @@ public:
         return ast;
     }
 
-    CatchClauseAST *CatchClause(ExceptionDeclarationAST *exception_declaration = 0, StatementAST *statement = 0)
+    CatchClauseAST *CatchClause(ExceptionDeclarationAST *exception_declaration = nullptr, StatementAST *statement = nullptr)
     {
         CatchClauseAST *ast = new (&pool) CatchClauseAST;
         ast->exception_declaration = exception_declaration;
@@ -866,7 +866,7 @@ public:
         return ast;
     }
 
-    TypeIdAST *TypeId(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0)
+    TypeIdAST *TypeId(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr)
     {
         TypeIdAST *ast = new (&pool) TypeIdAST;
         ast->type_specifier_list = type_specifier_list;
@@ -874,7 +874,7 @@ public:
         return ast;
     }
 
-    TypenameTypeParameterAST *TypenameTypeParameter(NameAST *name = 0, ExpressionAST *type_id = 0)
+    TypenameTypeParameterAST *TypenameTypeParameter(NameAST *name = nullptr, ExpressionAST *type_id = nullptr)
     {
         TypenameTypeParameterAST *ast = new (&pool) TypenameTypeParameterAST;
         ast->name = name;
@@ -882,7 +882,7 @@ public:
         return ast;
     }
 
-    TemplateTypeParameterAST *TemplateTypeParameter(DeclarationListAST *template_parameter_list = 0, NameAST *name = 0, ExpressionAST *type_id = 0)
+    TemplateTypeParameterAST *TemplateTypeParameter(DeclarationListAST *template_parameter_list = nullptr, NameAST *name = nullptr, ExpressionAST *type_id = nullptr)
     {
         TemplateTypeParameterAST *ast = new (&pool) TemplateTypeParameterAST;
         ast->template_parameter_list = template_parameter_list;
@@ -891,28 +891,28 @@ public:
         return ast;
     }
 
-    UnaryExpressionAST *UnaryExpression(ExpressionAST *expression = 0)
+    UnaryExpressionAST *UnaryExpression(ExpressionAST *expression = nullptr)
     {
         UnaryExpressionAST *ast = new (&pool) UnaryExpressionAST;
         ast->expression = expression;
         return ast;
     }
 
-    UsingAST *Using(NameAST *name = 0)
+    UsingAST *Using(NameAST *name = nullptr)
     {
         UsingAST *ast = new (&pool) UsingAST;
         ast->name = name;
         return ast;
     }
 
-    UsingDirectiveAST *UsingDirective(NameAST *name = 0)
+    UsingDirectiveAST *UsingDirective(NameAST *name = nullptr)
     {
         UsingDirectiveAST *ast = new (&pool) UsingDirectiveAST;
         ast->name = name;
         return ast;
     }
 
-    WhileStatementAST *WhileStatement(ExpressionAST *condition = 0, StatementAST *statement = 0)
+    WhileStatementAST *WhileStatement(ExpressionAST *condition = nullptr, StatementAST *statement = nullptr)
     {
         WhileStatementAST *ast = new (&pool) WhileStatementAST;
         ast->condition = condition;
@@ -920,7 +920,7 @@ public:
         return ast;
     }
 
-    ObjCClassForwardDeclarationAST *ObjCClassForwardDeclaration(SpecifierListAST *attribute_list = 0, NameListAST *identifier_list = 0)
+    ObjCClassForwardDeclarationAST *ObjCClassForwardDeclaration(SpecifierListAST *attribute_list = nullptr, NameListAST *identifier_list = nullptr)
     {
         ObjCClassForwardDeclarationAST *ast = new (&pool) ObjCClassForwardDeclarationAST;
         ast->attribute_list = attribute_list;
@@ -928,7 +928,7 @@ public:
         return ast;
     }
 
-    ObjCClassDeclarationAST *ObjCClassDeclaration(SpecifierListAST *attribute_list = 0, NameAST *class_name = 0, NameAST *category_name = 0, NameAST *superclass = 0, ObjCProtocolRefsAST *protocol_refs = 0, ObjCInstanceVariablesDeclarationAST *inst_vars_decl = 0, DeclarationListAST *member_declaration_list = 0)
+    ObjCClassDeclarationAST *ObjCClassDeclaration(SpecifierListAST *attribute_list = nullptr, NameAST *class_name = nullptr, NameAST *category_name = nullptr, NameAST *superclass = nullptr, ObjCProtocolRefsAST *protocol_refs = nullptr, ObjCInstanceVariablesDeclarationAST *inst_vars_decl = nullptr, DeclarationListAST *member_declaration_list = nullptr)
     {
         ObjCClassDeclarationAST *ast = new (&pool) ObjCClassDeclarationAST;
         ast->attribute_list = attribute_list;
@@ -941,7 +941,7 @@ public:
         return ast;
     }
 
-    ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclaration(SpecifierListAST *attribute_list = 0, NameListAST *identifier_list = 0)
+    ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclaration(SpecifierListAST *attribute_list = nullptr, NameListAST *identifier_list = nullptr)
     {
         ObjCProtocolForwardDeclarationAST *ast = new (&pool) ObjCProtocolForwardDeclarationAST;
         ast->attribute_list = attribute_list;
@@ -949,7 +949,7 @@ public:
         return ast;
     }
 
-    ObjCProtocolDeclarationAST *ObjCProtocolDeclaration(SpecifierListAST *attribute_list = 0, NameAST *name = 0, ObjCProtocolRefsAST *protocol_refs = 0, DeclarationListAST *member_declaration_list = 0)
+    ObjCProtocolDeclarationAST *ObjCProtocolDeclaration(SpecifierListAST *attribute_list = nullptr, NameAST *name = nullptr, ObjCProtocolRefsAST *protocol_refs = nullptr, DeclarationListAST *member_declaration_list = nullptr)
     {
         ObjCProtocolDeclarationAST *ast = new (&pool) ObjCProtocolDeclarationAST;
         ast->attribute_list = attribute_list;
@@ -959,21 +959,21 @@ public:
         return ast;
     }
 
-    ObjCProtocolRefsAST *ObjCProtocolRefs(NameListAST *identifier_list = 0)
+    ObjCProtocolRefsAST *ObjCProtocolRefs(NameListAST *identifier_list = nullptr)
     {
         ObjCProtocolRefsAST *ast = new (&pool) ObjCProtocolRefsAST;
         ast->identifier_list = identifier_list;
         return ast;
     }
 
-    ObjCMessageArgumentAST *ObjCMessageArgument(ExpressionAST *parameter_value_expression = 0)
+    ObjCMessageArgumentAST *ObjCMessageArgument(ExpressionAST *parameter_value_expression = nullptr)
     {
         ObjCMessageArgumentAST *ast = new (&pool) ObjCMessageArgumentAST;
         ast->parameter_value_expression = parameter_value_expression;
         return ast;
     }
 
-    ObjCMessageExpressionAST *ObjCMessageExpression(ExpressionAST *receiver_expression = 0, ObjCSelectorAST *selector = 0, ObjCMessageArgumentListAST *argument_list = 0)
+    ObjCMessageExpressionAST *ObjCMessageExpression(ExpressionAST *receiver_expression = nullptr, ObjCSelectorAST *selector = nullptr, ObjCMessageArgumentListAST *argument_list = nullptr)
     {
         ObjCMessageExpressionAST *ast = new (&pool) ObjCMessageExpressionAST;
         ast->receiver_expression = receiver_expression;
@@ -988,28 +988,28 @@ public:
         return ast;
     }
 
-    ObjCTypeNameAST *ObjCTypeName(ExpressionAST *type_id = 0)
+    ObjCTypeNameAST *ObjCTypeName(ExpressionAST *type_id = nullptr)
     {
         ObjCTypeNameAST *ast = new (&pool) ObjCTypeNameAST;
         ast->type_id = type_id;
         return ast;
     }
 
-    ObjCEncodeExpressionAST *ObjCEncodeExpression(ObjCTypeNameAST *type_name = 0)
+    ObjCEncodeExpressionAST *ObjCEncodeExpression(ObjCTypeNameAST *type_name = nullptr)
     {
         ObjCEncodeExpressionAST *ast = new (&pool) ObjCEncodeExpressionAST;
         ast->type_name = type_name;
         return ast;
     }
 
-    ObjCSelectorExpressionAST *ObjCSelectorExpression(ObjCSelectorAST *selector = 0)
+    ObjCSelectorExpressionAST *ObjCSelectorExpression(ObjCSelectorAST *selector = nullptr)
     {
         ObjCSelectorExpressionAST *ast = new (&pool) ObjCSelectorExpressionAST;
         ast->selector = selector;
         return ast;
     }
 
-    ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclaration(DeclarationListAST *instance_variable_list = 0)
+    ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclaration(DeclarationListAST *instance_variable_list = nullptr)
     {
         ObjCInstanceVariablesDeclarationAST *ast = new (&pool) ObjCInstanceVariablesDeclarationAST;
         ast->instance_variable_list = instance_variable_list;
@@ -1022,14 +1022,14 @@ public:
         return ast;
     }
 
-    ObjCPropertyAttributeAST *ObjCPropertyAttribute(ObjCSelectorAST *method_selector = 0)
+    ObjCPropertyAttributeAST *ObjCPropertyAttribute(ObjCSelectorAST *method_selector = nullptr)
     {
         ObjCPropertyAttributeAST *ast = new (&pool) ObjCPropertyAttributeAST;
         ast->method_selector = method_selector;
         return ast;
     }
 
-    ObjCPropertyDeclarationAST *ObjCPropertyDeclaration(SpecifierListAST *attribute_list = 0, ObjCPropertyAttributeListAST *property_attribute_list = 0, DeclarationAST *simple_declaration = 0)
+    ObjCPropertyDeclarationAST *ObjCPropertyDeclaration(SpecifierListAST *attribute_list = nullptr, ObjCPropertyAttributeListAST *property_attribute_list = nullptr, DeclarationAST *simple_declaration = nullptr)
     {
         ObjCPropertyDeclarationAST *ast = new (&pool) ObjCPropertyDeclarationAST;
         ast->attribute_list = attribute_list;
@@ -1038,7 +1038,7 @@ public:
         return ast;
     }
 
-    ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclaration(ObjCTypeNameAST *type_name = 0, SpecifierListAST *attribute_list = 0, NameAST *param_name = 0)
+    ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclaration(ObjCTypeNameAST *type_name = nullptr, SpecifierListAST *attribute_list = nullptr, NameAST *param_name = nullptr)
     {
         ObjCMessageArgumentDeclarationAST *ast = new (&pool) ObjCMessageArgumentDeclarationAST;
         ast->type_name = type_name;
@@ -1047,7 +1047,7 @@ public:
         return ast;
     }
 
-    ObjCMethodPrototypeAST *ObjCMethodPrototype(ObjCTypeNameAST *type_name = 0, ObjCSelectorAST *selector = 0, ObjCMessageArgumentDeclarationListAST *argument_list = 0, SpecifierListAST *attribute_list = 0)
+    ObjCMethodPrototypeAST *ObjCMethodPrototype(ObjCTypeNameAST *type_name = nullptr, ObjCSelectorAST *selector = nullptr, ObjCMessageArgumentDeclarationListAST *argument_list = nullptr, SpecifierListAST *attribute_list = nullptr)
     {
         ObjCMethodPrototypeAST *ast = new (&pool) ObjCMethodPrototypeAST;
         ast->type_name = type_name;
@@ -1057,7 +1057,7 @@ public:
         return ast;
     }
 
-    ObjCMethodDeclarationAST *ObjCMethodDeclaration(ObjCMethodPrototypeAST *method_prototype = 0, StatementAST *function_body = 0)
+    ObjCMethodDeclarationAST *ObjCMethodDeclaration(ObjCMethodPrototypeAST *method_prototype = nullptr, StatementAST *function_body = nullptr)
     {
         ObjCMethodDeclarationAST *ast = new (&pool) ObjCMethodDeclarationAST;
         ast->method_prototype = method_prototype;
@@ -1071,21 +1071,21 @@ public:
         return ast;
     }
 
-    ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclaration(ObjCSynthesizedPropertyListAST *property_identifier_list = 0)
+    ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclaration(ObjCSynthesizedPropertyListAST *property_identifier_list = nullptr)
     {
         ObjCSynthesizedPropertiesDeclarationAST *ast = new (&pool) ObjCSynthesizedPropertiesDeclarationAST;
         ast->property_identifier_list = property_identifier_list;
         return ast;
     }
 
-    ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclaration(NameListAST *property_identifier_list = 0)
+    ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclaration(NameListAST *property_identifier_list = nullptr)
     {
         ObjCDynamicPropertiesDeclarationAST *ast = new (&pool) ObjCDynamicPropertiesDeclarationAST;
         ast->property_identifier_list = property_identifier_list;
         return ast;
     }
 
-    ObjCFastEnumerationAST *ObjCFastEnumeration(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *initializer = 0, ExpressionAST *fast_enumeratable_expression = 0, StatementAST *statement = 0)
+    ObjCFastEnumerationAST *ObjCFastEnumeration(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *initializer = nullptr, ExpressionAST *fast_enumeratable_expression = nullptr, StatementAST *statement = nullptr)
     {
         ObjCFastEnumerationAST *ast = new (&pool) ObjCFastEnumerationAST;
         ast->type_specifier_list = type_specifier_list;
@@ -1096,7 +1096,7 @@ public:
         return ast;
     }
 
-    ObjCSynchronizedStatementAST *ObjCSynchronizedStatement(ExpressionAST *synchronized_object = 0, StatementAST *statement = 0)
+    ObjCSynchronizedStatementAST *ObjCSynchronizedStatement(ExpressionAST *synchronized_object = nullptr, StatementAST *statement = nullptr)
     {
         ObjCSynchronizedStatementAST *ast = new (&pool) ObjCSynchronizedStatementAST;
         ast->synchronized_object = synchronized_object;
@@ -1104,7 +1104,7 @@ public:
         return ast;
     }
 
-    LambdaExpressionAST *LambdaExpression(LambdaIntroducerAST *lambda_introducer = 0, LambdaDeclaratorAST *lambda_declarator = 0, StatementAST *statement = 0)
+    LambdaExpressionAST *LambdaExpression(LambdaIntroducerAST *lambda_introducer = nullptr, LambdaDeclaratorAST *lambda_declarator = nullptr, StatementAST *statement = nullptr)
     {
         LambdaExpressionAST *ast = new (&pool) LambdaExpressionAST;
         ast->lambda_introducer = lambda_introducer;
@@ -1113,28 +1113,28 @@ public:
         return ast;
     }
 
-    LambdaIntroducerAST *LambdaIntroducer(LambdaCaptureAST *lambda_capture = 0)
+    LambdaIntroducerAST *LambdaIntroducer(LambdaCaptureAST *lambda_capture = nullptr)
     {
         LambdaIntroducerAST *ast = new (&pool) LambdaIntroducerAST;
         ast->lambda_capture = lambda_capture;
         return ast;
     }
 
-    LambdaCaptureAST *LambdaCapture(CaptureListAST *capture_list = 0)
+    LambdaCaptureAST *LambdaCapture(CaptureListAST *capture_list = nullptr)
     {
         LambdaCaptureAST *ast = new (&pool) LambdaCaptureAST;
         ast->capture_list = capture_list;
         return ast;
     }
 
-    CaptureAST *Capture(NameAST *identifier = 0)
+    CaptureAST *Capture(NameAST *identifier = nullptr)
     {
         CaptureAST *ast = new (&pool) CaptureAST;
         ast->identifier = identifier;
         return ast;
     }
 
-    LambdaDeclaratorAST *LambdaDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = 0, SpecifierListAST *attributes = 0, ExceptionSpecificationAST *exception_specification = 0, TrailingReturnTypeAST *trailing_return_type = 0)
+    LambdaDeclaratorAST *LambdaDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = nullptr, SpecifierListAST *attributes = nullptr, ExceptionSpecificationAST *exception_specification = nullptr, TrailingReturnTypeAST *trailing_return_type = nullptr)
     {
         LambdaDeclaratorAST *ast = new (&pool) LambdaDeclaratorAST;
         ast->parameter_declaration_clause = parameter_declaration_clause;
@@ -1144,7 +1144,7 @@ public:
         return ast;
     }
 
-    TrailingReturnTypeAST *TrailingReturnType(SpecifierListAST *attributes = 0, SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0)
+    TrailingReturnTypeAST *TrailingReturnType(SpecifierListAST *attributes = nullptr, SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr)
     {
         TrailingReturnTypeAST *ast = new (&pool) TrailingReturnTypeAST;
         ast->attributes = attributes;
@@ -1153,7 +1153,7 @@ public:
         return ast;
     }
 
-    BracedInitializerAST *BracedInitializer(ExpressionListAST *expression_list = 0)
+    BracedInitializerAST *BracedInitializer(ExpressionListAST *expression_list = nullptr)
     {
         BracedInitializerAST *ast = new (&pool) BracedInitializerAST;
         ast->expression_list = expression_list;
@@ -1166,14 +1166,14 @@ public:
         return ast;
     }
 
-    BracketDesignatorAST *BracketDesignator(ExpressionAST *expression = 0)
+    BracketDesignatorAST *BracketDesignator(ExpressionAST *expression = nullptr)
     {
         BracketDesignatorAST *ast = new (&pool) BracketDesignatorAST;
         ast->expression = expression;
         return ast;
     }
 
-    DesignatedInitializerAST *DesignatedInitializer(DesignatorListAST *designator_list = 0, ExpressionAST *initializer = 0)
+    DesignatedInitializerAST *DesignatedInitializer(DesignatorListAST *designator_list = nullptr, ExpressionAST *initializer = nullptr)
     {
         DesignatedInitializerAST *ast = new (&pool) DesignatedInitializerAST;
         ast->designator_list = designator_list;