feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

CPlusPlus: Modernize frontend generator

Browse Source 
... and the generated code.

Change-Id: Ib04d98e9c16f7aae96575b3d0c4ee9f27651e138
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
This commit is contained in:
hjk
2019-07-26 11:20:19 +02:00
parent 9ebe05fd4e
commit 3885807817
3 changed files with 331 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
src/libs/3rdparty/cplusplus/AST.h vendored
View File

@@ -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;

258
src/libs/3rdparty/cplusplus/ASTPatternBuilder.h vendored
View File

File diff suppressed because it is too large Load Diff