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