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

95
src/tools/cplusplus-update-frontend/cplusplus-update-frontend.cpp
View File

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