src/shared/cplusplus/ASTMatch0.cpp

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (info@qt.nokia.com)
   8 **
   9 **
  10 ** GNU Lesser General Public License Usage
  11 **
  12 ** This file may be used under the terms of the GNU Lesser General Public
  13 ** License version 2.1 as published by the Free Software Foundation and
  14 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
  15 ** Please review the following information to ensure the GNU Lesser General
  16 ** Public License version 2.1 requirements will be met:
  17 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  18 **
  19 ** In addition, as a special exception, Nokia gives you certain additional
  20 ** rights. These rights are described in the Nokia Qt LGPL Exception
  21 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  22 **
  23 ** Other Usage
  24 **
  25 ** Alternatively, this file may be used in accordance with the terms and
  26 ** conditions contained in a signed written agreement between you and Nokia.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **************************************************************************/
  32
  33 //
  34 //  W A R N I N G
  35 //  -------------
  36 //
  37 // This file is automatically generated.
  38 // Changes will be lost.
  39 //
  40
  41
  42 #include "AST.h"
  43 #include "ASTMatcher.h"
  44
  45 using namespace CPlusPlus;
  46
  47 bool ObjCSelectorArgumentAST::match0(AST *pattern, ASTMatcher *matcher)
  48 {
  49     if (ObjCSelectorArgumentAST *_other = pattern->asObjCSelectorArgument())
  50         return matcher->match(this, _other);
  51
  52     return false;
  53 }
  54
  55 bool ObjCSelectorAST::match0(AST *pattern, ASTMatcher *matcher)
  56 {
  57     if (ObjCSelectorAST *_other = pattern->asObjCSelector())
  58         return matcher->match(this, _other);
  59
  60     return false;
  61 }
  62
  63 bool SimpleSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
  64 {
  65     if (SimpleSpecifierAST *_other = pattern->asSimpleSpecifier())
  66         return matcher->match(this, _other);
  67
  68     return false;
  69 }
  70
  71 bool AttributeSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
  72 {
  73     if (AttributeSpecifierAST *_other = pattern->asAttributeSpecifier())
  74         return matcher->match(this, _other);
  75
  76     return false;
  77 }
  78
  79 bool AttributeAST::match0(AST *pattern, ASTMatcher *matcher)
  80 {
  81     if (AttributeAST *_other = pattern->asAttribute())
  82         return matcher->match(this, _other);
  83
  84     return false;
  85 }
  86
  87 bool TypeofSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
  88 {
  89     if (TypeofSpecifierAST *_other = pattern->asTypeofSpecifier())
  90         return matcher->match(this, _other);
  91
  92     return false;
  93 }
  94
  95 bool DeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
  96 {
  97     if (DeclaratorAST *_other = pattern->asDeclarator())
  98         return matcher->match(this, _other);
  99
 100     return false;
 101 }
 102
 103 bool SimpleDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 104 {
 105     if (SimpleDeclarationAST *_other = pattern->asSimpleDeclaration())
 106         return matcher->match(this, _other);
 107
 108     return false;
 109 }
 110
 111 bool EmptyDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 112 {
 113     if (EmptyDeclarationAST *_other = pattern->asEmptyDeclaration())
 114         return matcher->match(this, _other);
 115
 116     return false;
 117 }
 118
 119 bool AccessDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 120 {
 121     if (AccessDeclarationAST *_other = pattern->asAccessDeclaration())
 122         return matcher->match(this, _other);
 123
 124     return false;
 125 }
 126
 127 bool QtObjectTagAST::match0(AST *pattern, ASTMatcher *matcher)
 128 {
 129     if (QtObjectTagAST *_other = pattern->asQtObjectTag())
 130         return matcher->match(this, _other);
 131
 132     return false;
 133 }
 134
 135 bool QtPrivateSlotAST::match0(AST *pattern, ASTMatcher *matcher)
 136 {
 137     if (QtPrivateSlotAST *_other = pattern->asQtPrivateSlot())
 138         return matcher->match(this, _other);
 139
 140     return false;
 141 }
 142
 143 bool QtPropertyDeclarationItemAST::match0(AST *pattern, ASTMatcher *matcher)
 144 {
 145     if (QtPropertyDeclarationItemAST *_other = pattern->asQtPropertyDeclarationItem())
 146         return matcher->match(this, _other);
 147
 148     return false;
 149 }
 150
 151 bool QtPropertyDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 152 {
 153     if (QtPropertyDeclarationAST *_other = pattern->asQtPropertyDeclaration())
 154         return matcher->match(this, _other);
 155
 156     return false;
 157 }
 158
 159 bool QtEnumDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 160 {
 161     if (QtEnumDeclarationAST *_other = pattern->asQtEnumDeclaration())
 162         return matcher->match(this, _other);
 163
 164     return false;
 165 }
 166
 167 bool QtFlagsDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 168 {
 169     if (QtFlagsDeclarationAST *_other = pattern->asQtFlagsDeclaration())
 170         return matcher->match(this, _other);
 171
 172     return false;
 173 }
 174
 175 bool QtInterfaceNameAST::match0(AST *pattern, ASTMatcher *matcher)
 176 {
 177     if (QtInterfaceNameAST *_other = pattern->asQtInterfaceName())
 178         return matcher->match(this, _other);
 179
 180     return false;
 181 }
 182
 183 bool QtInterfacesDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 184 {
 185     if (QtInterfacesDeclarationAST *_other = pattern->asQtInterfacesDeclaration())
 186         return matcher->match(this, _other);
 187
 188     return false;
 189 }
 190
 191 bool AsmDefinitionAST::match0(AST *pattern, ASTMatcher *matcher)
 192 {
 193     if (AsmDefinitionAST *_other = pattern->asAsmDefinition())
 194         return matcher->match(this, _other);
 195
 196     return false;
 197 }
 198
 199 bool BaseSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
 200 {
 201     if (BaseSpecifierAST *_other = pattern->asBaseSpecifier())
 202         return matcher->match(this, _other);
 203
 204     return false;
 205 }
 206
 207 bool IdExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 208 {
 209     if (IdExpressionAST *_other = pattern->asIdExpression())
 210         return matcher->match(this, _other);
 211
 212     return false;
 213 }
 214
 215 bool CompoundExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 216 {
 217     if (CompoundExpressionAST *_other = pattern->asCompoundExpression())
 218         return matcher->match(this, _other);
 219
 220     return false;
 221 }
 222
 223 bool CompoundLiteralAST::match0(AST *pattern, ASTMatcher *matcher)
 224 {
 225     if (CompoundLiteralAST *_other = pattern->asCompoundLiteral())
 226         return matcher->match(this, _other);
 227
 228     return false;
 229 }
 230
 231 bool QtMethodAST::match0(AST *pattern, ASTMatcher *matcher)
 232 {
 233     if (QtMethodAST *_other = pattern->asQtMethod())
 234         return matcher->match(this, _other);
 235
 236     return false;
 237 }
 238
 239 bool QtMemberDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 240 {
 241     if (QtMemberDeclarationAST *_other = pattern->asQtMemberDeclaration())
 242         return matcher->match(this, _other);
 243
 244     return false;
 245 }
 246
 247 bool BinaryExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 248 {
 249     if (BinaryExpressionAST *_other = pattern->asBinaryExpression())
 250         return matcher->match(this, _other);
 251
 252     return false;
 253 }
 254
 255 bool CastExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 256 {
 257     if (CastExpressionAST *_other = pattern->asCastExpression())
 258         return matcher->match(this, _other);
 259
 260     return false;
 261 }
 262
 263 bool ClassSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
 264 {
 265     if (ClassSpecifierAST *_other = pattern->asClassSpecifier())
 266         return matcher->match(this, _other);
 267
 268     return false;
 269 }
 270
 271 bool CaseStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 272 {
 273     if (CaseStatementAST *_other = pattern->asCaseStatement())
 274         return matcher->match(this, _other);
 275
 276     return false;
 277 }
 278
 279 bool CompoundStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 280 {
 281     if (CompoundStatementAST *_other = pattern->asCompoundStatement())
 282         return matcher->match(this, _other);
 283
 284     return false;
 285 }
 286
 287 bool ConditionAST::match0(AST *pattern, ASTMatcher *matcher)
 288 {
 289     if (ConditionAST *_other = pattern->asCondition())
 290         return matcher->match(this, _other);
 291
 292     return false;
 293 }
 294
 295 bool ConditionalExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 296 {
 297     if (ConditionalExpressionAST *_other = pattern->asConditionalExpression())
 298         return matcher->match(this, _other);
 299
 300     return false;
 301 }
 302
 303 bool CppCastExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 304 {
 305     if (CppCastExpressionAST *_other = pattern->asCppCastExpression())
 306         return matcher->match(this, _other);
 307
 308     return false;
 309 }
 310
 311 bool CtorInitializerAST::match0(AST *pattern, ASTMatcher *matcher)
 312 {
 313     if (CtorInitializerAST *_other = pattern->asCtorInitializer())
 314         return matcher->match(this, _other);
 315
 316     return false;
 317 }
 318
 319 bool DeclarationStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 320 {
 321     if (DeclarationStatementAST *_other = pattern->asDeclarationStatement())
 322         return matcher->match(this, _other);
 323
 324     return false;
 325 }
 326
 327 bool DeclaratorIdAST::match0(AST *pattern, ASTMatcher *matcher)
 328 {
 329     if (DeclaratorIdAST *_other = pattern->asDeclaratorId())
 330         return matcher->match(this, _other);
 331
 332     return false;
 333 }
 334
 335 bool NestedDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
 336 {
 337     if (NestedDeclaratorAST *_other = pattern->asNestedDeclarator())
 338         return matcher->match(this, _other);
 339
 340     return false;
 341 }
 342
 343 bool FunctionDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
 344 {
 345     if (FunctionDeclaratorAST *_other = pattern->asFunctionDeclarator())
 346         return matcher->match(this, _other);
 347
 348     return false;
 349 }
 350
 351 bool ArrayDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
 352 {
 353     if (ArrayDeclaratorAST *_other = pattern->asArrayDeclarator())
 354         return matcher->match(this, _other);
 355
 356     return false;
 357 }
 358
 359 bool DeleteExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 360 {
 361     if (DeleteExpressionAST *_other = pattern->asDeleteExpression())
 362         return matcher->match(this, _other);
 363
 364     return false;
 365 }
 366
 367 bool DoStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 368 {
 369     if (DoStatementAST *_other = pattern->asDoStatement())
 370         return matcher->match(this, _other);
 371
 372     return false;
 373 }
 374
 375 bool NamedTypeSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
 376 {
 377     if (NamedTypeSpecifierAST *_other = pattern->asNamedTypeSpecifier())
 378         return matcher->match(this, _other);
 379
 380     return false;
 381 }
 382
 383 bool ElaboratedTypeSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
 384 {
 385     if (ElaboratedTypeSpecifierAST *_other = pattern->asElaboratedTypeSpecifier())
 386         return matcher->match(this, _other);
 387
 388     return false;
 389 }
 390
 391 bool EnumSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
 392 {
 393     if (EnumSpecifierAST *_other = pattern->asEnumSpecifier())
 394         return matcher->match(this, _other);
 395
 396     return false;
 397 }
 398
 399 bool EnumeratorAST::match0(AST *pattern, ASTMatcher *matcher)
 400 {
 401     if (EnumeratorAST *_other = pattern->asEnumerator())
 402         return matcher->match(this, _other);
 403
 404     return false;
 405 }
 406
 407 bool ExceptionDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 408 {
 409     if (ExceptionDeclarationAST *_other = pattern->asExceptionDeclaration())
 410         return matcher->match(this, _other);
 411
 412     return false;
 413 }
 414
 415 bool ExceptionSpecificationAST::match0(AST *pattern, ASTMatcher *matcher)
 416 {
 417     if (ExceptionSpecificationAST *_other = pattern->asExceptionSpecification())
 418         return matcher->match(this, _other);
 419
 420     return false;
 421 }
 422
 423 bool ExpressionOrDeclarationStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 424 {
 425     if (ExpressionOrDeclarationStatementAST *_other = pattern->asExpressionOrDeclarationStatement())
 426         return matcher->match(this, _other);
 427
 428     return false;
 429 }
 430
 431 bool ExpressionStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 432 {
 433     if (ExpressionStatementAST *_other = pattern->asExpressionStatement())
 434         return matcher->match(this, _other);
 435
 436     return false;
 437 }
 438
 439 bool FunctionDefinitionAST::match0(AST *pattern, ASTMatcher *matcher)
 440 {
 441     if (FunctionDefinitionAST *_other = pattern->asFunctionDefinition())
 442         return matcher->match(this, _other);
 443
 444     return false;
 445 }
 446
 447 bool ForeachStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 448 {
 449     if (ForeachStatementAST *_other = pattern->asForeachStatement())
 450         return matcher->match(this, _other);
 451
 452     return false;
 453 }
 454
 455 bool ForStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 456 {
 457     if (ForStatementAST *_other = pattern->asForStatement())
 458         return matcher->match(this, _other);
 459
 460     return false;
 461 }
 462
 463 bool IfStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 464 {
 465     if (IfStatementAST *_other = pattern->asIfStatement())
 466         return matcher->match(this, _other);
 467
 468     return false;
 469 }
 470
 471 bool ArrayInitializerAST::match0(AST *pattern, ASTMatcher *matcher)
 472 {
 473     if (ArrayInitializerAST *_other = pattern->asArrayInitializer())
 474         return matcher->match(this, _other);
 475
 476     return false;
 477 }
 478
 479 bool LabeledStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 480 {
 481     if (LabeledStatementAST *_other = pattern->asLabeledStatement())
 482         return matcher->match(this, _other);
 483
 484     return false;
 485 }
 486
 487 bool LinkageBodyAST::match0(AST *pattern, ASTMatcher *matcher)
 488 {
 489     if (LinkageBodyAST *_other = pattern->asLinkageBody())
 490         return matcher->match(this, _other);
 491
 492     return false;
 493 }
 494
 495 bool LinkageSpecificationAST::match0(AST *pattern, ASTMatcher *matcher)
 496 {
 497     if (LinkageSpecificationAST *_other = pattern->asLinkageSpecification())
 498         return matcher->match(this, _other);
 499
 500     return false;
 501 }
 502
 503 bool MemInitializerAST::match0(AST *pattern, ASTMatcher *matcher)
 504 {
 505     if (MemInitializerAST *_other = pattern->asMemInitializer())
 506         return matcher->match(this, _other);
 507
 508     return false;
 509 }
 510
 511 bool NestedNameSpecifierAST::match0(AST *pattern, ASTMatcher *matcher)
 512 {
 513     if (NestedNameSpecifierAST *_other = pattern->asNestedNameSpecifier())
 514         return matcher->match(this, _other);
 515
 516     return false;
 517 }
 518
 519 bool QualifiedNameAST::match0(AST *pattern, ASTMatcher *matcher)
 520 {
 521     if (QualifiedNameAST *_other = pattern->asQualifiedName())
 522         return matcher->match(this, _other);
 523
 524     return false;
 525 }
 526
 527 bool OperatorFunctionIdAST::match0(AST *pattern, ASTMatcher *matcher)
 528 {
 529     if (OperatorFunctionIdAST *_other = pattern->asOperatorFunctionId())
 530         return matcher->match(this, _other);
 531
 532     return false;
 533 }
 534
 535 bool ConversionFunctionIdAST::match0(AST *pattern, ASTMatcher *matcher)
 536 {
 537     if (ConversionFunctionIdAST *_other = pattern->asConversionFunctionId())
 538         return matcher->match(this, _other);
 539
 540     return false;
 541 }
 542
 543 bool SimpleNameAST::match0(AST *pattern, ASTMatcher *matcher)
 544 {
 545     if (SimpleNameAST *_other = pattern->asSimpleName())
 546         return matcher->match(this, _other);
 547
 548     return false;
 549 }
 550
 551 bool DestructorNameAST::match0(AST *pattern, ASTMatcher *matcher)
 552 {
 553     if (DestructorNameAST *_other = pattern->asDestructorName())
 554         return matcher->match(this, _other);
 555
 556     return false;
 557 }
 558
 559 bool TemplateIdAST::match0(AST *pattern, ASTMatcher *matcher)
 560 {
 561     if (TemplateIdAST *_other = pattern->asTemplateId())
 562         return matcher->match(this, _other);
 563
 564     return false;
 565 }
 566
 567 bool NamespaceAST::match0(AST *pattern, ASTMatcher *matcher)
 568 {
 569     if (NamespaceAST *_other = pattern->asNamespace())
 570         return matcher->match(this, _other);
 571
 572     return false;
 573 }
 574
 575 bool NamespaceAliasDefinitionAST::match0(AST *pattern, ASTMatcher *matcher)
 576 {
 577     if (NamespaceAliasDefinitionAST *_other = pattern->asNamespaceAliasDefinition())
 578         return matcher->match(this, _other);
 579
 580     return false;
 581 }
 582
 583 bool NewPlacementAST::match0(AST *pattern, ASTMatcher *matcher)
 584 {
 585     if (NewPlacementAST *_other = pattern->asNewPlacement())
 586         return matcher->match(this, _other);
 587
 588     return false;
 589 }
 590
 591 bool NewArrayDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
 592 {
 593     if (NewArrayDeclaratorAST *_other = pattern->asNewArrayDeclarator())
 594         return matcher->match(this, _other);
 595
 596     return false;
 597 }
 598
 599 bool NewExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 600 {
 601     if (NewExpressionAST *_other = pattern->asNewExpression())
 602         return matcher->match(this, _other);
 603
 604     return false;
 605 }
 606
 607 bool NewInitializerAST::match0(AST *pattern, ASTMatcher *matcher)
 608 {
 609     if (NewInitializerAST *_other = pattern->asNewInitializer())
 610         return matcher->match(this, _other);
 611
 612     return false;
 613 }
 614
 615 bool NewTypeIdAST::match0(AST *pattern, ASTMatcher *matcher)
 616 {
 617     if (NewTypeIdAST *_other = pattern->asNewTypeId())
 618         return matcher->match(this, _other);
 619
 620     return false;
 621 }
 622
 623 bool OperatorAST::match0(AST *pattern, ASTMatcher *matcher)
 624 {
 625     if (OperatorAST *_other = pattern->asOperator())
 626         return matcher->match(this, _other);
 627
 628     return false;
 629 }
 630
 631 bool ParameterDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 632 {
 633     if (ParameterDeclarationAST *_other = pattern->asParameterDeclaration())
 634         return matcher->match(this, _other);
 635
 636     return false;
 637 }
 638
 639 bool ParameterDeclarationClauseAST::match0(AST *pattern, ASTMatcher *matcher)
 640 {
 641     if (ParameterDeclarationClauseAST *_other = pattern->asParameterDeclarationClause())
 642         return matcher->match(this, _other);
 643
 644     return false;
 645 }
 646
 647 bool CallAST::match0(AST *pattern, ASTMatcher *matcher)
 648 {
 649     if (CallAST *_other = pattern->asCall())
 650         return matcher->match(this, _other);
 651
 652     return false;
 653 }
 654
 655 bool ArrayAccessAST::match0(AST *pattern, ASTMatcher *matcher)
 656 {
 657     if (ArrayAccessAST *_other = pattern->asArrayAccess())
 658         return matcher->match(this, _other);
 659
 660     return false;
 661 }
 662
 663 bool PostIncrDecrAST::match0(AST *pattern, ASTMatcher *matcher)
 664 {
 665     if (PostIncrDecrAST *_other = pattern->asPostIncrDecr())
 666         return matcher->match(this, _other);
 667
 668     return false;
 669 }
 670
 671 bool MemberAccessAST::match0(AST *pattern, ASTMatcher *matcher)
 672 {
 673     if (MemberAccessAST *_other = pattern->asMemberAccess())
 674         return matcher->match(this, _other);
 675
 676     return false;
 677 }
 678
 679 bool TypeidExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 680 {
 681     if (TypeidExpressionAST *_other = pattern->asTypeidExpression())
 682         return matcher->match(this, _other);
 683
 684     return false;
 685 }
 686
 687 bool TypenameCallExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 688 {
 689     if (TypenameCallExpressionAST *_other = pattern->asTypenameCallExpression())
 690         return matcher->match(this, _other);
 691
 692     return false;
 693 }
 694
 695 bool TypeConstructorCallAST::match0(AST *pattern, ASTMatcher *matcher)
 696 {
 697     if (TypeConstructorCallAST *_other = pattern->asTypeConstructorCall())
 698         return matcher->match(this, _other);
 699
 700     return false;
 701 }
 702
 703 bool PointerToMemberAST::match0(AST *pattern, ASTMatcher *matcher)
 704 {
 705     if (PointerToMemberAST *_other = pattern->asPointerToMember())
 706         return matcher->match(this, _other);
 707
 708     return false;
 709 }
 710
 711 bool PointerAST::match0(AST *pattern, ASTMatcher *matcher)
 712 {
 713     if (PointerAST *_other = pattern->asPointer())
 714         return matcher->match(this, _other);
 715
 716     return false;
 717 }
 718
 719 bool ReferenceAST::match0(AST *pattern, ASTMatcher *matcher)
 720 {
 721     if (ReferenceAST *_other = pattern->asReference())
 722         return matcher->match(this, _other);
 723
 724     return false;
 725 }
 726
 727 bool BreakStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 728 {
 729     if (BreakStatementAST *_other = pattern->asBreakStatement())
 730         return matcher->match(this, _other);
 731
 732     return false;
 733 }
 734
 735 bool ContinueStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 736 {
 737     if (ContinueStatementAST *_other = pattern->asContinueStatement())
 738         return matcher->match(this, _other);
 739
 740     return false;
 741 }
 742
 743 bool GotoStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 744 {
 745     if (GotoStatementAST *_other = pattern->asGotoStatement())
 746         return matcher->match(this, _other);
 747
 748     return false;
 749 }
 750
 751 bool ReturnStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 752 {
 753     if (ReturnStatementAST *_other = pattern->asReturnStatement())
 754         return matcher->match(this, _other);
 755
 756     return false;
 757 }
 758
 759 bool SizeofExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 760 {
 761     if (SizeofExpressionAST *_other = pattern->asSizeofExpression())
 762         return matcher->match(this, _other);
 763
 764     return false;
 765 }
 766
 767 bool NumericLiteralAST::match0(AST *pattern, ASTMatcher *matcher)
 768 {
 769     if (NumericLiteralAST *_other = pattern->asNumericLiteral())
 770         return matcher->match(this, _other);
 771
 772     return false;
 773 }
 774
 775 bool BoolLiteralAST::match0(AST *pattern, ASTMatcher *matcher)
 776 {
 777     if (BoolLiteralAST *_other = pattern->asBoolLiteral())
 778         return matcher->match(this, _other);
 779
 780     return false;
 781 }
 782
 783 bool ThisExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 784 {
 785     if (ThisExpressionAST *_other = pattern->asThisExpression())
 786         return matcher->match(this, _other);
 787
 788     return false;
 789 }
 790
 791 bool NestedExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 792 {
 793     if (NestedExpressionAST *_other = pattern->asNestedExpression())
 794         return matcher->match(this, _other);
 795
 796     return false;
 797 }
 798
 799 bool StringLiteralAST::match0(AST *pattern, ASTMatcher *matcher)
 800 {
 801     if (StringLiteralAST *_other = pattern->asStringLiteral())
 802         return matcher->match(this, _other);
 803
 804     return false;
 805 }
 806
 807 bool SwitchStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 808 {
 809     if (SwitchStatementAST *_other = pattern->asSwitchStatement())
 810         return matcher->match(this, _other);
 811
 812     return false;
 813 }
 814
 815 bool TemplateDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 816 {
 817     if (TemplateDeclarationAST *_other = pattern->asTemplateDeclaration())
 818         return matcher->match(this, _other);
 819
 820     return false;
 821 }
 822
 823 bool ThrowExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 824 {
 825     if (ThrowExpressionAST *_other = pattern->asThrowExpression())
 826         return matcher->match(this, _other);
 827
 828     return false;
 829 }
 830
 831 bool TranslationUnitAST::match0(AST *pattern, ASTMatcher *matcher)
 832 {
 833     if (TranslationUnitAST *_other = pattern->asTranslationUnit())
 834         return matcher->match(this, _other);
 835
 836     return false;
 837 }
 838
 839 bool TryBlockStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 840 {
 841     if (TryBlockStatementAST *_other = pattern->asTryBlockStatement())
 842         return matcher->match(this, _other);
 843
 844     return false;
 845 }
 846
 847 bool CatchClauseAST::match0(AST *pattern, ASTMatcher *matcher)
 848 {
 849     if (CatchClauseAST *_other = pattern->asCatchClause())
 850         return matcher->match(this, _other);
 851
 852     return false;
 853 }
 854
 855 bool TypeIdAST::match0(AST *pattern, ASTMatcher *matcher)
 856 {
 857     if (TypeIdAST *_other = pattern->asTypeId())
 858         return matcher->match(this, _other);
 859
 860     return false;
 861 }
 862
 863 bool TypenameTypeParameterAST::match0(AST *pattern, ASTMatcher *matcher)
 864 {
 865     if (TypenameTypeParameterAST *_other = pattern->asTypenameTypeParameter())
 866         return matcher->match(this, _other);
 867
 868     return false;
 869 }
 870
 871 bool TemplateTypeParameterAST::match0(AST *pattern, ASTMatcher *matcher)
 872 {
 873     if (TemplateTypeParameterAST *_other = pattern->asTemplateTypeParameter())
 874         return matcher->match(this, _other);
 875
 876     return false;
 877 }
 878
 879 bool UnaryExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 880 {
 881     if (UnaryExpressionAST *_other = pattern->asUnaryExpression())
 882         return matcher->match(this, _other);
 883
 884     return false;
 885 }
 886
 887 bool UsingAST::match0(AST *pattern, ASTMatcher *matcher)
 888 {
 889     if (UsingAST *_other = pattern->asUsing())
 890         return matcher->match(this, _other);
 891
 892     return false;
 893 }
 894
 895 bool UsingDirectiveAST::match0(AST *pattern, ASTMatcher *matcher)
 896 {
 897     if (UsingDirectiveAST *_other = pattern->asUsingDirective())
 898         return matcher->match(this, _other);
 899
 900     return false;
 901 }
 902
 903 bool WhileStatementAST::match0(AST *pattern, ASTMatcher *matcher)
 904 {
 905     if (WhileStatementAST *_other = pattern->asWhileStatement())
 906         return matcher->match(this, _other);
 907
 908     return false;
 909 }
 910
 911 bool ObjCClassForwardDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 912 {
 913     if (ObjCClassForwardDeclarationAST *_other = pattern->asObjCClassForwardDeclaration())
 914         return matcher->match(this, _other);
 915
 916     return false;
 917 }
 918
 919 bool ObjCClassDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 920 {
 921     if (ObjCClassDeclarationAST *_other = pattern->asObjCClassDeclaration())
 922         return matcher->match(this, _other);
 923
 924     return false;
 925 }
 926
 927 bool ObjCProtocolForwardDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 928 {
 929     if (ObjCProtocolForwardDeclarationAST *_other = pattern->asObjCProtocolForwardDeclaration())
 930         return matcher->match(this, _other);
 931
 932     return false;
 933 }
 934
 935 bool ObjCProtocolDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
 936 {
 937     if (ObjCProtocolDeclarationAST *_other = pattern->asObjCProtocolDeclaration())
 938         return matcher->match(this, _other);
 939
 940     return false;
 941 }
 942
 943 bool ObjCProtocolRefsAST::match0(AST *pattern, ASTMatcher *matcher)
 944 {
 945     if (ObjCProtocolRefsAST *_other = pattern->asObjCProtocolRefs())
 946         return matcher->match(this, _other);
 947
 948     return false;
 949 }
 950
 951 bool ObjCMessageArgumentAST::match0(AST *pattern, ASTMatcher *matcher)
 952 {
 953     if (ObjCMessageArgumentAST *_other = pattern->asObjCMessageArgument())
 954         return matcher->match(this, _other);
 955
 956     return false;
 957 }
 958
 959 bool ObjCMessageExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 960 {
 961     if (ObjCMessageExpressionAST *_other = pattern->asObjCMessageExpression())
 962         return matcher->match(this, _other);
 963
 964     return false;
 965 }
 966
 967 bool ObjCProtocolExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 968 {
 969     if (ObjCProtocolExpressionAST *_other = pattern->asObjCProtocolExpression())
 970         return matcher->match(this, _other);
 971
 972     return false;
 973 }
 974
 975 bool ObjCTypeNameAST::match0(AST *pattern, ASTMatcher *matcher)
 976 {
 977     if (ObjCTypeNameAST *_other = pattern->asObjCTypeName())
 978         return matcher->match(this, _other);
 979
 980     return false;
 981 }
 982
 983 bool ObjCEncodeExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 984 {
 985     if (ObjCEncodeExpressionAST *_other = pattern->asObjCEncodeExpression())
 986         return matcher->match(this, _other);
 987
 988     return false;
 989 }
 990
 991 bool ObjCSelectorExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
 992 {
 993     if (ObjCSelectorExpressionAST *_other = pattern->asObjCSelectorExpression())
 994         return matcher->match(this, _other);
 995
 996     return false;
 997 }
 998
 999 bool ObjCInstanceVariablesDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1000 {
1001     if (ObjCInstanceVariablesDeclarationAST *_other = pattern->asObjCInstanceVariablesDeclaration())
1002         return matcher->match(this, _other);
1003
1004     return false;
1005 }
1006
1007 bool ObjCVisibilityDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1008 {
1009     if (ObjCVisibilityDeclarationAST *_other = pattern->asObjCVisibilityDeclaration())
1010         return matcher->match(this, _other);
1011
1012     return false;
1013 }
1014
1015 bool ObjCPropertyAttributeAST::match0(AST *pattern, ASTMatcher *matcher)
1016 {
1017     if (ObjCPropertyAttributeAST *_other = pattern->asObjCPropertyAttribute())
1018         return matcher->match(this, _other);
1019
1020     return false;
1021 }
1022
1023 bool ObjCPropertyDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1024 {
1025     if (ObjCPropertyDeclarationAST *_other = pattern->asObjCPropertyDeclaration())
1026         return matcher->match(this, _other);
1027
1028     return false;
1029 }
1030
1031 bool ObjCMessageArgumentDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1032 {
1033     if (ObjCMessageArgumentDeclarationAST *_other = pattern->asObjCMessageArgumentDeclaration())
1034         return matcher->match(this, _other);
1035
1036     return false;
1037 }
1038
1039 bool ObjCMethodPrototypeAST::match0(AST *pattern, ASTMatcher *matcher)
1040 {
1041     if (ObjCMethodPrototypeAST *_other = pattern->asObjCMethodPrototype())
1042         return matcher->match(this, _other);
1043
1044     return false;
1045 }
1046
1047 bool ObjCMethodDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1048 {
1049     if (ObjCMethodDeclarationAST *_other = pattern->asObjCMethodDeclaration())
1050         return matcher->match(this, _other);
1051
1052     return false;
1053 }
1054
1055 bool ObjCSynthesizedPropertyAST::match0(AST *pattern, ASTMatcher *matcher)
1056 {
1057     if (ObjCSynthesizedPropertyAST *_other = pattern->asObjCSynthesizedProperty())
1058         return matcher->match(this, _other);
1059
1060     return false;
1061 }
1062
1063 bool ObjCSynthesizedPropertiesDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1064 {
1065     if (ObjCSynthesizedPropertiesDeclarationAST *_other = pattern->asObjCSynthesizedPropertiesDeclaration())
1066         return matcher->match(this, _other);
1067
1068     return false;
1069 }
1070
1071 bool ObjCDynamicPropertiesDeclarationAST::match0(AST *pattern, ASTMatcher *matcher)
1072 {
1073     if (ObjCDynamicPropertiesDeclarationAST *_other = pattern->asObjCDynamicPropertiesDeclaration())
1074         return matcher->match(this, _other);
1075
1076     return false;
1077 }
1078
1079 bool ObjCFastEnumerationAST::match0(AST *pattern, ASTMatcher *matcher)
1080 {
1081     if (ObjCFastEnumerationAST *_other = pattern->asObjCFastEnumeration())
1082         return matcher->match(this, _other);
1083
1084     return false;
1085 }
1086
1087 bool ObjCSynchronizedStatementAST::match0(AST *pattern, ASTMatcher *matcher)
1088 {
1089     if (ObjCSynchronizedStatementAST *_other = pattern->asObjCSynchronizedStatement())
1090         return matcher->match(this, _other);
1091
1092     return false;
1093 }
1094
1095 bool LambdaExpressionAST::match0(AST *pattern, ASTMatcher *matcher)
1096 {
1097     if (LambdaExpressionAST *_other = pattern->asLambdaExpression())
1098         return matcher->match(this, _other);
1099
1100     return false;
1101 }
1102
1103 bool LambdaIntroducerAST::match0(AST *pattern, ASTMatcher *matcher)
1104 {
1105     if (LambdaIntroducerAST *_other = pattern->asLambdaIntroducer())
1106         return matcher->match(this, _other);
1107
1108     return false;
1109 }
1110
1111 bool LambdaCaptureAST::match0(AST *pattern, ASTMatcher *matcher)
1112 {
1113     if (LambdaCaptureAST *_other = pattern->asLambdaCapture())
1114         return matcher->match(this, _other);
1115
1116     return false;
1117 }
1118
1119 bool CaptureAST::match0(AST *pattern, ASTMatcher *matcher)
1120 {
1121     if (CaptureAST *_other = pattern->asCapture())
1122         return matcher->match(this, _other);
1123
1124     return false;
1125 }
1126
1127 bool LambdaDeclaratorAST::match0(AST *pattern, ASTMatcher *matcher)
1128 {
1129     if (LambdaDeclaratorAST *_other = pattern->asLambdaDeclarator())
1130         return matcher->match(this, _other);
1131
1132     return false;
1133 }
1134
1135 bool TrailingReturnTypeAST::match0(AST *pattern, ASTMatcher *matcher)
1136 {
1137     if (TrailingReturnTypeAST *_other = pattern->asTrailingReturnType())
1138         return matcher->match(this, _other);
1139
1140     return false;
1141 }
1142
1143 bool BracedInitializerAST::match0(AST *pattern, ASTMatcher *matcher)
1144 {
1145     if (BracedInitializerAST *_other = pattern->asBracedInitializer())
1146         return matcher->match(this, _other);
1147
1148     return false;
1149 }
1150