contrib/llvm/tools/clang/lib/Serialization/ASTWriterStmt.cpp

   1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements serialization for Statements and Expressions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Serialization/ASTWriter.h"
  15 #include "clang/AST/DeclCXX.h"
  16 #include "clang/AST/DeclObjC.h"
  17 #include "clang/AST/DeclTemplate.h"
  18 #include "clang/AST/StmtVisitor.h"
  19 #include "llvm/Bitcode/BitstreamWriter.h"
  20 using namespace clang;
  21
  22 //===----------------------------------------------------------------------===//
  23 // Statement/expression serialization
  24 //===----------------------------------------------------------------------===//
  25
  26 namespace clang {
  27   class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
  28     ASTWriter &Writer;
  29     ASTWriter::RecordData &Record;
  30
  31   public:
  32     serialization::StmtCode Code;
  33
  34     ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
  35       : Writer(Writer), Record(Record) { }
  36
  37     void
  38     AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args);
  39
  40     void VisitStmt(Stmt *S);
  41     void VisitNullStmt(NullStmt *S);
  42     void VisitCompoundStmt(CompoundStmt *S);
  43     void VisitSwitchCase(SwitchCase *S);
  44     void VisitCaseStmt(CaseStmt *S);
  45     void VisitDefaultStmt(DefaultStmt *S);
  46     void VisitLabelStmt(LabelStmt *S);
  47     void VisitIfStmt(IfStmt *S);
  48     void VisitSwitchStmt(SwitchStmt *S);
  49     void VisitWhileStmt(WhileStmt *S);
  50     void VisitDoStmt(DoStmt *S);
  51     void VisitForStmt(ForStmt *S);
  52     void VisitGotoStmt(GotoStmt *S);
  53     void VisitIndirectGotoStmt(IndirectGotoStmt *S);
  54     void VisitContinueStmt(ContinueStmt *S);
  55     void VisitBreakStmt(BreakStmt *S);
  56     void VisitReturnStmt(ReturnStmt *S);
  57     void VisitDeclStmt(DeclStmt *S);
  58     void VisitAsmStmt(AsmStmt *S);
  59     void VisitExpr(Expr *E);
  60     void VisitPredefinedExpr(PredefinedExpr *E);
  61     void VisitDeclRefExpr(DeclRefExpr *E);
  62     void VisitIntegerLiteral(IntegerLiteral *E);
  63     void VisitFloatingLiteral(FloatingLiteral *E);
  64     void VisitImaginaryLiteral(ImaginaryLiteral *E);
  65     void VisitStringLiteral(StringLiteral *E);
  66     void VisitCharacterLiteral(CharacterLiteral *E);
  67     void VisitParenExpr(ParenExpr *E);
  68     void VisitParenListExpr(ParenListExpr *E);
  69     void VisitUnaryOperator(UnaryOperator *E);
  70     void VisitOffsetOfExpr(OffsetOfExpr *E);
  71     void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
  72     void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
  73     void VisitCallExpr(CallExpr *E);
  74     void VisitMemberExpr(MemberExpr *E);
  75     void VisitCastExpr(CastExpr *E);
  76     void VisitBinaryOperator(BinaryOperator *E);
  77     void VisitCompoundAssignOperator(CompoundAssignOperator *E);
  78     void VisitConditionalOperator(ConditionalOperator *E);
  79     void VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
  80     void VisitImplicitCastExpr(ImplicitCastExpr *E);
  81     void VisitExplicitCastExpr(ExplicitCastExpr *E);
  82     void VisitCStyleCastExpr(CStyleCastExpr *E);
  83     void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
  84     void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
  85     void VisitInitListExpr(InitListExpr *E);
  86     void VisitDesignatedInitExpr(DesignatedInitExpr *E);
  87     void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
  88     void VisitVAArgExpr(VAArgExpr *E);
  89     void VisitAddrLabelExpr(AddrLabelExpr *E);
  90     void VisitStmtExpr(StmtExpr *E);
  91     void VisitChooseExpr(ChooseExpr *E);
  92     void VisitGNUNullExpr(GNUNullExpr *E);
  93     void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
  94     void VisitBlockExpr(BlockExpr *E);
  95     void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
  96     void VisitGenericSelectionExpr(GenericSelectionExpr *E);
  97
  98     // Objective-C Expressions
  99     void VisitObjCStringLiteral(ObjCStringLiteral *E);
 100     void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
 101     void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
 102     void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
 103     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
 104     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
 105     void VisitObjCMessageExpr(ObjCMessageExpr *E);
 106     void VisitObjCIsaExpr(ObjCIsaExpr *E);
 107
 108     // Objective-C Statements
 109     void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
 110     void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
 111     void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
 112     void VisitObjCAtTryStmt(ObjCAtTryStmt *);
 113     void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
 114     void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
 115
 116     // C++ Statements
 117     void VisitCXXCatchStmt(CXXCatchStmt *S);
 118     void VisitCXXTryStmt(CXXTryStmt *S);
 119     void VisitCXXForRangeStmt(CXXForRangeStmt *);
 120
 121     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
 122     void VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
 123     void VisitCXXConstructExpr(CXXConstructExpr *E);
 124     void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
 125     void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
 126     void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
 127     void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
 128     void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
 129     void VisitCXXConstCastExpr(CXXConstCastExpr *E);
 130     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
 131     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
 132     void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
 133     void VisitCXXTypeidExpr(CXXTypeidExpr *E);
 134     void VisitCXXUuidofExpr(CXXUuidofExpr *E);
 135     void VisitCXXThisExpr(CXXThisExpr *E);
 136     void VisitCXXThrowExpr(CXXThrowExpr *E);
 137     void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
 138     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
 139
 140     void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
 141     void VisitCXXNewExpr(CXXNewExpr *E);
 142     void VisitCXXDeleteExpr(CXXDeleteExpr *E);
 143     void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
 144
 145     void VisitExprWithCleanups(ExprWithCleanups *E);
 146     void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
 147     void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
 148     void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
 149
 150     void VisitOverloadExpr(OverloadExpr *E);
 151     void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
 152     void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
 153
 154     void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
 155     void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E);
 156     void VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
 157     void VisitExpressionTraitExpr(ExpressionTraitExpr *E);
 158     void VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
 159     void VisitPackExpansionExpr(PackExpansionExpr *E);
 160     void VisitSizeOfPackExpr(SizeOfPackExpr *E);
 161     void VisitSubstNonTypeTemplateParmPackExpr(
 162                                            SubstNonTypeTemplateParmPackExpr *E);
 163     void VisitOpaqueValueExpr(OpaqueValueExpr *E);
 164
 165     // CUDA Expressions
 166     void VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E);
 167   };
 168 }
 169
 170 void ASTStmtWriter::
 171 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args) {
 172   Writer.AddSourceLocation(Args.LAngleLoc, Record);
 173   Writer.AddSourceLocation(Args.RAngleLoc, Record);
 174   for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
 175     Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record);
 176 }
 177
 178 void ASTStmtWriter::VisitStmt(Stmt *S) {
 179 }
 180
 181 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
 182   VisitStmt(S);
 183   Writer.AddSourceLocation(S->getSemiLoc(), Record);
 184   Writer.AddSourceLocation(S->LeadingEmptyMacro, Record);
 185   Code = serialization::STMT_NULL;
 186 }
 187
 188 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
 189   VisitStmt(S);
 190   Record.push_back(S->size());
 191   for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
 192        CS != CSEnd; ++CS)
 193     Writer.AddStmt(*CS);
 194   Writer.AddSourceLocation(S->getLBracLoc(), Record);
 195   Writer.AddSourceLocation(S->getRBracLoc(), Record);
 196   Code = serialization::STMT_COMPOUND;
 197 }
 198
 199 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
 200   VisitStmt(S);
 201   Record.push_back(Writer.getSwitchCaseID(S));
 202 }
 203
 204 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
 205   VisitSwitchCase(S);
 206   Writer.AddStmt(S->getLHS());
 207   Writer.AddStmt(S->getRHS());
 208   Writer.AddStmt(S->getSubStmt());
 209   Writer.AddSourceLocation(S->getCaseLoc(), Record);
 210   Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
 211   Writer.AddSourceLocation(S->getColonLoc(), Record);
 212   Code = serialization::STMT_CASE;
 213 }
 214
 215 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
 216   VisitSwitchCase(S);
 217   Writer.AddStmt(S->getSubStmt());
 218   Writer.AddSourceLocation(S->getDefaultLoc(), Record);
 219   Writer.AddSourceLocation(S->getColonLoc(), Record);
 220   Code = serialization::STMT_DEFAULT;
 221 }
 222
 223 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
 224   VisitStmt(S);
 225   Writer.AddDeclRef(S->getDecl(), Record);
 226   Writer.AddStmt(S->getSubStmt());
 227   Writer.AddSourceLocation(S->getIdentLoc(), Record);
 228   Code = serialization::STMT_LABEL;
 229 }
 230
 231 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
 232   VisitStmt(S);
 233   Writer.AddDeclRef(S->getConditionVariable(), Record);
 234   Writer.AddStmt(S->getCond());
 235   Writer.AddStmt(S->getThen());
 236   Writer.AddStmt(S->getElse());
 237   Writer.AddSourceLocation(S->getIfLoc(), Record);
 238   Writer.AddSourceLocation(S->getElseLoc(), Record);
 239   Code = serialization::STMT_IF;
 240 }
 241
 242 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
 243   VisitStmt(S);
 244   Writer.AddDeclRef(S->getConditionVariable(), Record);
 245   Writer.AddStmt(S->getCond());
 246   Writer.AddStmt(S->getBody());
 247   Writer.AddSourceLocation(S->getSwitchLoc(), Record);
 248   Record.push_back(S->isAllEnumCasesCovered());
 249   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
 250        SC = SC->getNextSwitchCase())
 251     Record.push_back(Writer.RecordSwitchCaseID(SC));
 252   Code = serialization::STMT_SWITCH;
 253 }
 254
 255 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
 256   VisitStmt(S);
 257   Writer.AddDeclRef(S->getConditionVariable(), Record);
 258   Writer.AddStmt(S->getCond());
 259   Writer.AddStmt(S->getBody());
 260   Writer.AddSourceLocation(S->getWhileLoc(), Record);
 261   Code = serialization::STMT_WHILE;
 262 }
 263
 264 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
 265   VisitStmt(S);
 266   Writer.AddStmt(S->getCond());
 267   Writer.AddStmt(S->getBody());
 268   Writer.AddSourceLocation(S->getDoLoc(), Record);
 269   Writer.AddSourceLocation(S->getWhileLoc(), Record);
 270   Writer.AddSourceLocation(S->getRParenLoc(), Record);
 271   Code = serialization::STMT_DO;
 272 }
 273
 274 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
 275   VisitStmt(S);
 276   Writer.AddStmt(S->getInit());
 277   Writer.AddStmt(S->getCond());
 278   Writer.AddDeclRef(S->getConditionVariable(), Record);
 279   Writer.AddStmt(S->getInc());
 280   Writer.AddStmt(S->getBody());
 281   Writer.AddSourceLocation(S->getForLoc(), Record);
 282   Writer.AddSourceLocation(S->getLParenLoc(), Record);
 283   Writer.AddSourceLocation(S->getRParenLoc(), Record);
 284   Code = serialization::STMT_FOR;
 285 }
 286
 287 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
 288   VisitStmt(S);
 289   Writer.AddDeclRef(S->getLabel(), Record);
 290   Writer.AddSourceLocation(S->getGotoLoc(), Record);
 291   Writer.AddSourceLocation(S->getLabelLoc(), Record);
 292   Code = serialization::STMT_GOTO;
 293 }
 294
 295 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 296   VisitStmt(S);
 297   Writer.AddSourceLocation(S->getGotoLoc(), Record);
 298   Writer.AddSourceLocation(S->getStarLoc(), Record);
 299   Writer.AddStmt(S->getTarget());
 300   Code = serialization::STMT_INDIRECT_GOTO;
 301 }
 302
 303 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
 304   VisitStmt(S);
 305   Writer.AddSourceLocation(S->getContinueLoc(), Record);
 306   Code = serialization::STMT_CONTINUE;
 307 }
 308
 309 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
 310   VisitStmt(S);
 311   Writer.AddSourceLocation(S->getBreakLoc(), Record);
 312   Code = serialization::STMT_BREAK;
 313 }
 314
 315 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
 316   VisitStmt(S);
 317   Writer.AddStmt(S->getRetValue());
 318   Writer.AddSourceLocation(S->getReturnLoc(), Record);
 319   Writer.AddDeclRef(S->getNRVOCandidate(), Record);
 320   Code = serialization::STMT_RETURN;
 321 }
 322
 323 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
 324   VisitStmt(S);
 325   Writer.AddSourceLocation(S->getStartLoc(), Record);
 326   Writer.AddSourceLocation(S->getEndLoc(), Record);
 327   DeclGroupRef DG = S->getDeclGroup();
 328   for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
 329     Writer.AddDeclRef(*D, Record);
 330   Code = serialization::STMT_DECL;
 331 }
 332
 333 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
 334   VisitStmt(S);
 335   Record.push_back(S->getNumOutputs());
 336   Record.push_back(S->getNumInputs());
 337   Record.push_back(S->getNumClobbers());
 338   Writer.AddSourceLocation(S->getAsmLoc(), Record);
 339   Writer.AddSourceLocation(S->getRParenLoc(), Record);
 340   Record.push_back(S->isVolatile());
 341   Record.push_back(S->isSimple());
 342   Record.push_back(S->isMSAsm());
 343   Writer.AddStmt(S->getAsmString());
 344
 345   // Outputs
 346   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
 347     Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
 348     Writer.AddStmt(S->getOutputConstraintLiteral(I));
 349     Writer.AddStmt(S->getOutputExpr(I));
 350   }
 351
 352   // Inputs
 353   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
 354     Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
 355     Writer.AddStmt(S->getInputConstraintLiteral(I));
 356     Writer.AddStmt(S->getInputExpr(I));
 357   }
 358
 359   // Clobbers
 360   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
 361     Writer.AddStmt(S->getClobber(I));
 362
 363   Code = serialization::STMT_ASM;
 364 }
 365
 366 void ASTStmtWriter::VisitExpr(Expr *E) {
 367   VisitStmt(E);
 368   Writer.AddTypeRef(E->getType(), Record);
 369   Record.push_back(E->isTypeDependent());
 370   Record.push_back(E->isValueDependent());
 371   Record.push_back(E->containsUnexpandedParameterPack());
 372   Record.push_back(E->getValueKind());
 373   Record.push_back(E->getObjectKind());
 374 }
 375
 376 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
 377   VisitExpr(E);
 378   Writer.AddSourceLocation(E->getLocation(), Record);
 379   Record.push_back(E->getIdentType()); // FIXME: stable encoding
 380   Code = serialization::EXPR_PREDEFINED;
 381 }
 382
 383 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
 384   VisitExpr(E);
 385
 386   Record.push_back(E->hasQualifier());
 387   Record.push_back(E->getDecl() != E->getFoundDecl());
 388   Record.push_back(E->hasExplicitTemplateArgs());
 389
 390   if (E->hasExplicitTemplateArgs()) {
 391     unsigned NumTemplateArgs = E->getNumTemplateArgs();
 392     Record.push_back(NumTemplateArgs);
 393   }
 394
 395   if (E->hasQualifier())
 396     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
 397
 398   if (E->getDecl() != E->getFoundDecl())
 399     Writer.AddDeclRef(E->getFoundDecl(), Record);
 400
 401   if (E->hasExplicitTemplateArgs())
 402     AddExplicitTemplateArgumentList(E->getExplicitTemplateArgs());
 403
 404   Writer.AddDeclRef(E->getDecl(), Record);
 405   Writer.AddSourceLocation(E->getLocation(), Record);
 406   Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
 407   Code = serialization::EXPR_DECL_REF;
 408 }
 409
 410 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
 411   VisitExpr(E);
 412   Writer.AddSourceLocation(E->getLocation(), Record);
 413   Writer.AddAPInt(E->getValue(), Record);
 414   Code = serialization::EXPR_INTEGER_LITERAL;
 415 }
 416
 417 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
 418   VisitExpr(E);
 419   Writer.AddAPFloat(E->getValue(), Record);
 420   Record.push_back(E->isExact());
 421   Writer.AddSourceLocation(E->getLocation(), Record);
 422   Code = serialization::EXPR_FLOATING_LITERAL;
 423 }
 424
 425 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 426   VisitExpr(E);
 427   Writer.AddStmt(E->getSubExpr());
 428   Code = serialization::EXPR_IMAGINARY_LITERAL;
 429 }
 430
 431 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
 432   VisitExpr(E);
 433   Record.push_back(E->getByteLength());
 434   Record.push_back(E->getNumConcatenated());
 435   Record.push_back(E->isWide());
 436   Record.push_back(E->isPascal());
 437   // FIXME: String data should be stored as a blob at the end of the
 438   // StringLiteral. However, we can't do so now because we have no
 439   // provision for coping with abbreviations when we're jumping around
 440   // the AST file during deserialization.
 441   Record.append(E->getString().begin(), E->getString().end());
 442   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 443     Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
 444   Code = serialization::EXPR_STRING_LITERAL;
 445 }
 446
 447 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
 448   VisitExpr(E);
 449   Record.push_back(E->getValue());
 450   Writer.AddSourceLocation(E->getLocation(), Record);
 451   Record.push_back(E->isWide());
 452   Code = serialization::EXPR_CHARACTER_LITERAL;
 453 }
 454
 455 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
 456   VisitExpr(E);
 457   Writer.AddSourceLocation(E->getLParen(), Record);
 458   Writer.AddSourceLocation(E->getRParen(), Record);
 459   Writer.AddStmt(E->getSubExpr());
 460   Code = serialization::EXPR_PAREN;
 461 }
 462
 463 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
 464   VisitExpr(E);
 465   Record.push_back(E->NumExprs);
 466   for (unsigned i=0; i != E->NumExprs; ++i)
 467     Writer.AddStmt(E->Exprs[i]);
 468   Writer.AddSourceLocation(E->LParenLoc, Record);
 469   Writer.AddSourceLocation(E->RParenLoc, Record);
 470   Code = serialization::EXPR_PAREN_LIST;
 471 }
 472
 473 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
 474   VisitExpr(E);
 475   Writer.AddStmt(E->getSubExpr());
 476   Record.push_back(E->getOpcode()); // FIXME: stable encoding
 477   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 478   Code = serialization::EXPR_UNARY_OPERATOR;
 479 }
 480
 481 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
 482   VisitExpr(E);
 483   Record.push_back(E->getNumComponents());
 484   Record.push_back(E->getNumExpressions());
 485   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 486   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 487   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
 488   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 489     const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I);
 490     Record.push_back(ON.getKind()); // FIXME: Stable encoding
 491     Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
 492     Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
 493     switch (ON.getKind()) {
 494     case OffsetOfExpr::OffsetOfNode::Array:
 495       Record.push_back(ON.getArrayExprIndex());
 496       break;
 497
 498     case OffsetOfExpr::OffsetOfNode::Field:
 499       Writer.AddDeclRef(ON.getField(), Record);
 500       break;
 501
 502     case OffsetOfExpr::OffsetOfNode::Identifier:
 503       Writer.AddIdentifierRef(ON.getFieldName(), Record);
 504       break;
 505
 506     case OffsetOfExpr::OffsetOfNode::Base:
 507       Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
 508       break;
 509     }
 510   }
 511   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 512     Writer.AddStmt(E->getIndexExpr(I));
 513   Code = serialization::EXPR_OFFSETOF;
 514 }
 515
 516 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
 517   VisitExpr(E);
 518   Record.push_back(E->getKind());
 519   if (E->isArgumentType())
 520     Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
 521   else {
 522     Record.push_back(0);
 523     Writer.AddStmt(E->getArgumentExpr());
 524   }
 525   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 526   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 527   Code = serialization::EXPR_SIZEOF_ALIGN_OF;
 528 }
 529
 530 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 531   VisitExpr(E);
 532   Writer.AddStmt(E->getLHS());
 533   Writer.AddStmt(E->getRHS());
 534   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
 535   Code = serialization::EXPR_ARRAY_SUBSCRIPT;
 536 }
 537
 538 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
 539   VisitExpr(E);
 540   Record.push_back(E->getNumArgs());
 541   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 542   Writer.AddStmt(E->getCallee());
 543   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
 544        Arg != ArgEnd; ++Arg)
 545     Writer.AddStmt(*Arg);
 546   Code = serialization::EXPR_CALL;
 547 }
 548
 549 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
 550   // Don't call VisitExpr, we'll write everything here.
 551
 552   Record.push_back(E->hasQualifier());
 553   if (E->hasQualifier())
 554     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
 555
 556   Record.push_back(E->hasExplicitTemplateArgs());
 557   if (E->hasExplicitTemplateArgs()) {
 558     unsigned NumTemplateArgs = E->getNumTemplateArgs();
 559     Record.push_back(NumTemplateArgs);
 560     Writer.AddSourceLocation(E->getLAngleLoc(), Record);
 561     Writer.AddSourceLocation(E->getRAngleLoc(), Record);
 562     for (unsigned i=0; i != NumTemplateArgs; ++i)
 563       Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
 564   }
 565
 566   DeclAccessPair FoundDecl = E->getFoundDecl();
 567   Writer.AddDeclRef(FoundDecl.getDecl(), Record);
 568   Record.push_back(FoundDecl.getAccess());
 569
 570   Writer.AddTypeRef(E->getType(), Record);
 571   Record.push_back(E->getValueKind());
 572   Record.push_back(E->getObjectKind());
 573   Writer.AddStmt(E->getBase());
 574   Writer.AddDeclRef(E->getMemberDecl(), Record);
 575   Writer.AddSourceLocation(E->getMemberLoc(), Record);
 576   Record.push_back(E->isArrow());
 577   Writer.AddDeclarationNameLoc(E->MemberDNLoc,
 578                                E->getMemberDecl()->getDeclName(), Record);
 579   Code = serialization::EXPR_MEMBER;
 580 }
 581
 582 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 583   VisitExpr(E);
 584   Writer.AddStmt(E->getBase());
 585   Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
 586   Record.push_back(E->isArrow());
 587   Code = serialization::EXPR_OBJC_ISA;
 588 }
 589
 590 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
 591   VisitExpr(E);
 592   Record.push_back(E->path_size());
 593   Writer.AddStmt(E->getSubExpr());
 594   Record.push_back(E->getCastKind()); // FIXME: stable encoding
 595
 596   for (CastExpr::path_iterator
 597          PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
 598     Writer.AddCXXBaseSpecifier(**PI, Record);
 599 }
 600
 601 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
 602   VisitExpr(E);
 603   Writer.AddStmt(E->getLHS());
 604   Writer.AddStmt(E->getRHS());
 605   Record.push_back(E->getOpcode()); // FIXME: stable encoding
 606   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 607   Code = serialization::EXPR_BINARY_OPERATOR;
 608 }
 609
 610 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 611   VisitBinaryOperator(E);
 612   Writer.AddTypeRef(E->getComputationLHSType(), Record);
 613   Writer.AddTypeRef(E->getComputationResultType(), Record);
 614   Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
 615 }
 616
 617 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
 618   VisitExpr(E);
 619   Writer.AddStmt(E->getCond());
 620   Writer.AddStmt(E->getLHS());
 621   Writer.AddStmt(E->getRHS());
 622   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
 623   Writer.AddSourceLocation(E->getColonLoc(), Record);
 624   Code = serialization::EXPR_CONDITIONAL_OPERATOR;
 625 }
 626
 627 void
 628 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 629   VisitExpr(E);
 630   Writer.AddStmt(E->getOpaqueValue());
 631   Writer.AddStmt(E->getCommon());
 632   Writer.AddStmt(E->getCond());
 633   Writer.AddStmt(E->getTrueExpr());
 634   Writer.AddStmt(E->getFalseExpr());
 635   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
 636   Writer.AddSourceLocation(E->getColonLoc(), Record);
 637   Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
 638 }
 639
 640 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 641   VisitCastExpr(E);
 642   Code = serialization::EXPR_IMPLICIT_CAST;
 643 }
 644
 645 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 646   VisitCastExpr(E);
 647   Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
 648 }
 649
 650 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
 651   VisitExplicitCastExpr(E);
 652   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 653   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 654   Code = serialization::EXPR_CSTYLE_CAST;
 655 }
 656
 657 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 658   VisitExpr(E);
 659   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 660   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
 661   Writer.AddStmt(E->getInitializer());
 662   Record.push_back(E->isFileScope());
 663   Code = serialization::EXPR_COMPOUND_LITERAL;
 664 }
 665
 666 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 667   VisitExpr(E);
 668   Writer.AddStmt(E->getBase());
 669   Writer.AddIdentifierRef(&E->getAccessor(), Record);
 670   Writer.AddSourceLocation(E->getAccessorLoc(), Record);
 671   Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
 672 }
 673
 674 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
 675   VisitExpr(E);
 676   Writer.AddStmt(E->getSyntacticForm());
 677   Writer.AddSourceLocation(E->getLBraceLoc(), Record);
 678   Writer.AddSourceLocation(E->getRBraceLoc(), Record);
 679   bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
 680   Record.push_back(isArrayFiller);
 681   if (isArrayFiller)
 682     Writer.AddStmt(E->getArrayFiller());
 683   else
 684     Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
 685   Record.push_back(E->hadArrayRangeDesignator());
 686   Record.push_back(E->getNumInits());
 687   if (isArrayFiller) {
 688     // ArrayFiller may have filled "holes" due to designated initializer.
 689     // Replace them by 0 to indicate that the filler goes in that place.
 690     Expr *filler = E->getArrayFiller();
 691     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
 692       Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : 0);
 693   } else {
 694     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
 695       Writer.AddStmt(E->getInit(I));
 696   }
 697   Code = serialization::EXPR_INIT_LIST;
 698 }
 699
 700 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 701   VisitExpr(E);
 702   Record.push_back(E->getNumSubExprs());
 703   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 704     Writer.AddStmt(E->getSubExpr(I));
 705   Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
 706   Record.push_back(E->usesGNUSyntax());
 707   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
 708                                              DEnd = E->designators_end();
 709        D != DEnd; ++D) {
 710     if (D->isFieldDesignator()) {
 711       if (FieldDecl *Field = D->getField()) {
 712         Record.push_back(serialization::DESIG_FIELD_DECL);
 713         Writer.AddDeclRef(Field, Record);
 714       } else {
 715         Record.push_back(serialization::DESIG_FIELD_NAME);
 716         Writer.AddIdentifierRef(D->getFieldName(), Record);
 717       }
 718       Writer.AddSourceLocation(D->getDotLoc(), Record);
 719       Writer.AddSourceLocation(D->getFieldLoc(), Record);
 720     } else if (D->isArrayDesignator()) {
 721       Record.push_back(serialization::DESIG_ARRAY);
 722       Record.push_back(D->getFirstExprIndex());
 723       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
 724       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
 725     } else {
 726       assert(D->isArrayRangeDesignator() && "Unknown designator");
 727       Record.push_back(serialization::DESIG_ARRAY_RANGE);
 728       Record.push_back(D->getFirstExprIndex());
 729       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
 730       Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
 731       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
 732     }
 733   }
 734   Code = serialization::EXPR_DESIGNATED_INIT;
 735 }
 736
 737 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 738   VisitExpr(E);
 739   Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
 740 }
 741
 742 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
 743   VisitExpr(E);
 744   Writer.AddStmt(E->getSubExpr());
 745   Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
 746   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 747   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 748   Code = serialization::EXPR_VA_ARG;
 749 }
 750
 751 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
 752   VisitExpr(E);
 753   Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
 754   Writer.AddSourceLocation(E->getLabelLoc(), Record);
 755   Writer.AddDeclRef(E->getLabel(), Record);
 756   Code = serialization::EXPR_ADDR_LABEL;
 757 }
 758
 759 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
 760   VisitExpr(E);
 761   Writer.AddStmt(E->getSubStmt());
 762   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 763   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 764   Code = serialization::EXPR_STMT;
 765 }
 766
 767 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
 768   VisitExpr(E);
 769   Writer.AddStmt(E->getCond());
 770   Writer.AddStmt(E->getLHS());
 771   Writer.AddStmt(E->getRHS());
 772   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 773   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 774   Code = serialization::EXPR_CHOOSE;
 775 }
 776
 777 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
 778   VisitExpr(E);
 779   Writer.AddSourceLocation(E->getTokenLocation(), Record);
 780   Code = serialization::EXPR_GNU_NULL;
 781 }
 782
 783 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 784   VisitExpr(E);
 785   Record.push_back(E->getNumSubExprs());
 786   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 787     Writer.AddStmt(E->getExpr(I));
 788   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 789   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 790   Code = serialization::EXPR_SHUFFLE_VECTOR;
 791 }
 792
 793 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
 794   VisitExpr(E);
 795   Writer.AddDeclRef(E->getBlockDecl(), Record);
 796   Code = serialization::EXPR_BLOCK;
 797 }
 798
 799 void ASTStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
 800   VisitExpr(E);
 801   Writer.AddDeclRef(E->getDecl(), Record);
 802   Writer.AddSourceLocation(E->getLocation(), Record);
 803   Record.push_back(E->isByRef());
 804   Record.push_back(E->isConstQualAdded());
 805   Code = serialization::EXPR_BLOCK_DECL_REF;
 806 }
 807
 808 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
 809   VisitExpr(E);
 810   Record.push_back(E->getNumAssocs());
 811
 812   Writer.AddStmt(E->getControllingExpr());
 813   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
 814     Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
 815     Writer.AddStmt(E->getAssocExpr(I));
 816   }
 817   Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
 818
 819   Writer.AddSourceLocation(E->getGenericLoc(), Record);
 820   Writer.AddSourceLocation(E->getDefaultLoc(), Record);
 821   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 822   Code = serialization::EXPR_GENERIC_SELECTION;
 823 }
 824
 825 //===----------------------------------------------------------------------===//
 826 // Objective-C Expressions and Statements.
 827 //===----------------------------------------------------------------------===//
 828
 829 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 830   VisitExpr(E);
 831   Writer.AddStmt(E->getString());
 832   Writer.AddSourceLocation(E->getAtLoc(), Record);
 833   Code = serialization::EXPR_OBJC_STRING_LITERAL;
 834 }
 835
 836 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 837   VisitExpr(E);
 838   Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
 839   Writer.AddSourceLocation(E->getAtLoc(), Record);
 840   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 841   Code = serialization::EXPR_OBJC_ENCODE;
 842 }
 843
 844 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 845   VisitExpr(E);
 846   Writer.AddSelectorRef(E->getSelector(), Record);
 847   Writer.AddSourceLocation(E->getAtLoc(), Record);
 848   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 849   Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
 850 }
 851
 852 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 853   VisitExpr(E);
 854   Writer.AddDeclRef(E->getProtocol(), Record);
 855   Writer.AddSourceLocation(E->getAtLoc(), Record);
 856   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 857   Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
 858 }
 859
 860 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 861   VisitExpr(E);
 862   Writer.AddDeclRef(E->getDecl(), Record);
 863   Writer.AddSourceLocation(E->getLocation(), Record);
 864   Writer.AddStmt(E->getBase());
 865   Record.push_back(E->isArrow());
 866   Record.push_back(E->isFreeIvar());
 867   Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
 868 }
 869
 870 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 871   VisitExpr(E);
 872   Record.push_back(E->isImplicitProperty());
 873   if (E->isImplicitProperty()) {
 874     Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
 875     Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
 876   } else {
 877     Writer.AddDeclRef(E->getExplicitProperty(), Record);
 878   }
 879   Writer.AddSourceLocation(E->getLocation(), Record);
 880   Writer.AddSourceLocation(E->getReceiverLocation(), Record);
 881   if (E->isObjectReceiver()) {
 882     Record.push_back(0);
 883     Writer.AddStmt(E->getBase());
 884   } else if (E->isSuperReceiver()) {
 885     Record.push_back(1);
 886     Writer.AddTypeRef(E->getSuperReceiverType(), Record);
 887   } else {
 888     Record.push_back(2);
 889     Writer.AddDeclRef(E->getClassReceiver(), Record);
 890   }
 891
 892   Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
 893 }
 894
 895 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 896   VisitExpr(E);
 897   Record.push_back(E->getNumArgs());
 898   Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
 899   switch (E->getReceiverKind()) {
 900   case ObjCMessageExpr::Instance:
 901     Writer.AddStmt(E->getInstanceReceiver());
 902     break;
 903
 904   case ObjCMessageExpr::Class:
 905     Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
 906     break;
 907
 908   case ObjCMessageExpr::SuperClass:
 909   case ObjCMessageExpr::SuperInstance:
 910     Writer.AddTypeRef(E->getSuperType(), Record);
 911     Writer.AddSourceLocation(E->getSuperLoc(), Record);
 912     break;
 913   }
 914
 915   if (E->getMethodDecl()) {
 916     Record.push_back(1);
 917     Writer.AddDeclRef(E->getMethodDecl(), Record);
 918   } else {
 919     Record.push_back(0);
 920     Writer.AddSelectorRef(E->getSelector(), Record);
 921   }
 922
 923   Writer.AddSourceLocation(E->getLeftLoc(), Record);
 924   Writer.AddSourceLocation(E->getRightLoc(), Record);
 925   Writer.AddSourceLocation(E->getSelectorLoc(), Record);
 926
 927   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
 928        Arg != ArgEnd; ++Arg)
 929     Writer.AddStmt(*Arg);
 930   Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
 931 }
 932
 933 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
 934   VisitStmt(S);
 935   Writer.AddStmt(S->getElement());
 936   Writer.AddStmt(S->getCollection());
 937   Writer.AddStmt(S->getBody());
 938   Writer.AddSourceLocation(S->getForLoc(), Record);
 939   Writer.AddSourceLocation(S->getRParenLoc(), Record);
 940   Code = serialization::STMT_OBJC_FOR_COLLECTION;
 941 }
 942
 943 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
 944   Writer.AddStmt(S->getCatchBody());
 945   Writer.AddDeclRef(S->getCatchParamDecl(), Record);
 946   Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
 947   Writer.AddSourceLocation(S->getRParenLoc(), Record);
 948   Code = serialization::STMT_OBJC_CATCH;
 949 }
 950
 951 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
 952   Writer.AddStmt(S->getFinallyBody());
 953   Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
 954   Code = serialization::STMT_OBJC_FINALLY;
 955 }
 956
 957 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
 958   Record.push_back(S->getNumCatchStmts());
 959   Record.push_back(S->getFinallyStmt() != 0);
 960   Writer.AddStmt(S->getTryBody());
 961   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
 962     Writer.AddStmt(S->getCatchStmt(I));
 963   if (S->getFinallyStmt())
 964     Writer.AddStmt(S->getFinallyStmt());
 965   Writer.AddSourceLocation(S->getAtTryLoc(), Record);
 966   Code = serialization::STMT_OBJC_AT_TRY;
 967 }
 968
 969 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
 970   Writer.AddStmt(S->getSynchExpr());
 971   Writer.AddStmt(S->getSynchBody());
 972   Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
 973   Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
 974 }
 975
 976 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
 977   Writer.AddStmt(S->getThrowExpr());
 978   Writer.AddSourceLocation(S->getThrowLoc(), Record);
 979   Code = serialization::STMT_OBJC_AT_THROW;
 980 }
 981
 982 //===----------------------------------------------------------------------===//
 983 // C++ Expressions and Statements.
 984 //===----------------------------------------------------------------------===//
 985
 986 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
 987   VisitStmt(S);
 988   Writer.AddSourceLocation(S->getCatchLoc(), Record);
 989   Writer.AddDeclRef(S->getExceptionDecl(), Record);
 990   Writer.AddStmt(S->getHandlerBlock());
 991   Code = serialization::STMT_CXX_CATCH;
 992 }
 993
 994 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
 995   VisitStmt(S);
 996   Record.push_back(S->getNumHandlers());
 997   Writer.AddSourceLocation(S->getTryLoc(), Record);
 998   Writer.AddStmt(S->getTryBlock());
 999   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1000     Writer.AddStmt(S->getHandler(i));
1001   Code = serialization::STMT_CXX_TRY;
1002 }
1003
1004 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1005   VisitStmt(S);
1006   Writer.AddSourceLocation(S->getForLoc(), Record);
1007   Writer.AddSourceLocation(S->getColonLoc(), Record);
1008   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1009   Writer.AddStmt(S->getRangeStmt());
1010   Writer.AddStmt(S->getBeginEndStmt());
1011   Writer.AddStmt(S->getCond());
1012   Writer.AddStmt(S->getInc());
1013   Writer.AddStmt(S->getLoopVarStmt());
1014   Writer.AddStmt(S->getBody());
1015   Code = serialization::STMT_CXX_FOR_RANGE;
1016 }
1017
1018 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1019   VisitCallExpr(E);
1020   Record.push_back(E->getOperator());
1021   Code = serialization::EXPR_CXX_OPERATOR_CALL;
1022 }
1023
1024 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1025   VisitCallExpr(E);
1026   Code = serialization::EXPR_CXX_MEMBER_CALL;
1027 }
1028
1029 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1030   VisitExpr(E);
1031   Record.push_back(E->getNumArgs());
1032   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1033     Writer.AddStmt(E->getArg(I));
1034   Writer.AddDeclRef(E->getConstructor(), Record);
1035   Writer.AddSourceLocation(E->getLocation(), Record);
1036   Record.push_back(E->isElidable());
1037   Record.push_back(E->requiresZeroInitialization());
1038   Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1039   Writer.AddSourceRange(E->getParenRange(), Record);
1040   Code = serialization::EXPR_CXX_CONSTRUCT;
1041 }
1042
1043 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1044   VisitCXXConstructExpr(E);
1045   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1046   Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1047 }
1048
1049 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1050   VisitExplicitCastExpr(E);
1051   Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
1052                         Record);
1053 }
1054
1055 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1056   VisitCXXNamedCastExpr(E);
1057   Code = serialization::EXPR_CXX_STATIC_CAST;
1058 }
1059
1060 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1061   VisitCXXNamedCastExpr(E);
1062   Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1063 }
1064
1065 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1066   VisitCXXNamedCastExpr(E);
1067   Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1068 }
1069
1070 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1071   VisitCXXNamedCastExpr(E);
1072   Code = serialization::EXPR_CXX_CONST_CAST;
1073 }
1074
1075 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1076   VisitExplicitCastExpr(E);
1077   Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
1078   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1079   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1080 }
1081
1082 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1083   VisitExpr(E);
1084   Record.push_back(E->getValue());
1085   Writer.AddSourceLocation(E->getLocation(), Record);
1086   Code = serialization::EXPR_CXX_BOOL_LITERAL;
1087 }
1088
1089 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1090   VisitExpr(E);
1091   Writer.AddSourceLocation(E->getLocation(), Record);
1092   Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1093 }
1094
1095 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1096   VisitExpr(E);
1097   Writer.AddSourceRange(E->getSourceRange(), Record);
1098   if (E->isTypeOperand()) {
1099     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1100     Code = serialization::EXPR_CXX_TYPEID_TYPE;
1101   } else {
1102     Writer.AddStmt(E->getExprOperand());
1103     Code = serialization::EXPR_CXX_TYPEID_EXPR;
1104   }
1105 }
1106
1107 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1108   VisitExpr(E);
1109   Writer.AddSourceRange(E->getSourceRange(), Record);
1110   if (E->isTypeOperand()) {
1111     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1112     Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1113   } else {
1114     Writer.AddStmt(E->getExprOperand());
1115     Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1116   }
1117 }
1118
1119 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1120   VisitExpr(E);
1121   Writer.AddSourceLocation(E->getLocation(), Record);
1122   Record.push_back(E->isImplicit());
1123   Code = serialization::EXPR_CXX_THIS;
1124 }
1125
1126 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1127   VisitExpr(E);
1128   Writer.AddSourceLocation(E->getThrowLoc(), Record);
1129   Writer.AddStmt(E->getSubExpr());
1130   Code = serialization::EXPR_CXX_THROW;
1131 }
1132
1133 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1134   VisitExpr(E);
1135
1136   bool HasOtherExprStored = E->Param.getInt();
1137   // Store these first, the reader reads them before creation.
1138   Record.push_back(HasOtherExprStored);
1139   if (HasOtherExprStored)
1140     Writer.AddStmt(E->getExpr());
1141   Writer.AddDeclRef(E->getParam(), Record);
1142   Writer.AddSourceLocation(E->getUsedLocation(), Record);
1143
1144   Code = serialization::EXPR_CXX_DEFAULT_ARG;
1145 }
1146
1147 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1148   VisitExpr(E);
1149   Writer.AddCXXTemporary(E->getTemporary(), Record);
1150   Writer.AddStmt(E->getSubExpr());
1151   Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1152 }
1153
1154 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1155   VisitExpr(E);
1156   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1157   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1158   Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1159 }
1160
1161 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1162   VisitExpr(E);
1163   Record.push_back(E->isGlobalNew());
1164   Record.push_back(E->hasInitializer());
1165   Record.push_back(E->doesUsualArrayDeleteWantSize());
1166   Record.push_back(E->isArray());
1167   Record.push_back(E->getNumPlacementArgs());
1168   Record.push_back(E->getNumConstructorArgs());
1169   Writer.AddDeclRef(E->getOperatorNew(), Record);
1170   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1171   Writer.AddDeclRef(E->getConstructor(), Record);
1172   Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1173   Writer.AddSourceRange(E->getTypeIdParens(), Record);
1174   Writer.AddSourceLocation(E->getStartLoc(), Record);
1175   Writer.AddSourceLocation(E->getEndLoc(), Record);
1176   Writer.AddSourceLocation(E->getConstructorLParen(), Record);
1177   Writer.AddSourceLocation(E->getConstructorRParen(), Record);
1178   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1179        I != e; ++I)
1180     Writer.AddStmt(*I);
1181
1182   Code = serialization::EXPR_CXX_NEW;
1183 }
1184
1185 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1186   VisitExpr(E);
1187   Record.push_back(E->isGlobalDelete());
1188   Record.push_back(E->isArrayForm());
1189   Record.push_back(E->isArrayFormAsWritten());
1190   Record.push_back(E->doesUsualArrayDeleteWantSize());
1191   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1192   Writer.AddStmt(E->getArgument());
1193   Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1194
1195   Code = serialization::EXPR_CXX_DELETE;
1196 }
1197
1198 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1199   VisitExpr(E);
1200
1201   Writer.AddStmt(E->getBase());
1202   Record.push_back(E->isArrow());
1203   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1204   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1205   Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1206   Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1207   Writer.AddSourceLocation(E->getTildeLoc(), Record);
1208
1209   // PseudoDestructorTypeStorage.
1210   Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1211   if (E->getDestroyedTypeIdentifier())
1212     Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1213   else
1214     Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1215
1216   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1217 }
1218
1219 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1220   VisitExpr(E);
1221   Record.push_back(E->getNumTemporaries());
1222   for (unsigned i = 0, e = E->getNumTemporaries(); i != e; ++i)
1223     Writer.AddCXXTemporary(E->getTemporary(i), Record);
1224
1225   Writer.AddStmt(E->getSubExpr());
1226   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1227 }
1228
1229 void
1230 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1231   VisitExpr(E);
1232
1233   // Don't emit anything here, hasExplicitTemplateArgs() must be
1234   // emitted first.
1235
1236   Record.push_back(E->hasExplicitTemplateArgs());
1237   if (E->hasExplicitTemplateArgs()) {
1238     const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1239     Record.push_back(Args.NumTemplateArgs);
1240     AddExplicitTemplateArgumentList(Args);
1241   }
1242
1243   if (!E->isImplicitAccess())
1244     Writer.AddStmt(E->getBase());
1245   else
1246     Writer.AddStmt(0);
1247   Writer.AddTypeRef(E->getBaseType(), Record);
1248   Record.push_back(E->isArrow());
1249   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1250   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1251   Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1252   Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1253   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1254 }
1255
1256 void
1257 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1258   VisitExpr(E);
1259
1260   // Don't emit anything here, hasExplicitTemplateArgs() must be
1261   // emitted first.
1262   Record.push_back(E->hasExplicitTemplateArgs());
1263   if (E->hasExplicitTemplateArgs()) {
1264     const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1265     Record.push_back(Args.NumTemplateArgs);
1266     AddExplicitTemplateArgumentList(Args);
1267   }
1268
1269   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1270   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1271   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1272 }
1273
1274 void
1275 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1276   VisitExpr(E);
1277   Record.push_back(E->arg_size());
1278   for (CXXUnresolvedConstructExpr::arg_iterator
1279          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1280     Writer.AddStmt(*ArgI);
1281   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1282   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1283   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1284   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1285 }
1286
1287 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1288   VisitExpr(E);
1289
1290   // Don't emit anything here, hasExplicitTemplateArgs() must be emitted first.
1291   Record.push_back(E->hasExplicitTemplateArgs());
1292   if (E->hasExplicitTemplateArgs()) {
1293     const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1294     Record.push_back(Args.NumTemplateArgs);
1295     AddExplicitTemplateArgumentList(Args);
1296   }
1297
1298   Record.push_back(E->getNumDecls());
1299   for (OverloadExpr::decls_iterator
1300          OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1301     Writer.AddDeclRef(OvI.getDecl(), Record);
1302     Record.push_back(OvI.getAccess());
1303   }
1304
1305   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1306   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1307 }
1308
1309 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1310   VisitOverloadExpr(E);
1311   Record.push_back(E->isArrow());
1312   Record.push_back(E->hasUnresolvedUsing());
1313   Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0);
1314   Writer.AddTypeRef(E->getBaseType(), Record);
1315   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1316   Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1317 }
1318
1319 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1320   VisitOverloadExpr(E);
1321   Record.push_back(E->requiresADL());
1322   if (E->requiresADL())
1323     Record.push_back(E->isStdAssociatedNamespace());
1324   Record.push_back(E->isOverloaded());
1325   Writer.AddDeclRef(E->getNamingClass(), Record);
1326   Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1327 }
1328
1329 void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1330   VisitExpr(E);
1331   Record.push_back(E->getTrait());
1332   Record.push_back(E->getValue());
1333   Writer.AddSourceRange(E->getSourceRange(), Record);
1334   Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1335   Code = serialization::EXPR_CXX_UNARY_TYPE_TRAIT;
1336 }
1337
1338 void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1339   VisitExpr(E);
1340   Record.push_back(E->getTrait());
1341   Record.push_back(E->getValue());
1342   Writer.AddSourceRange(E->getSourceRange(), Record);
1343   Writer.AddTypeSourceInfo(E->getLhsTypeSourceInfo(), Record);
1344   Writer.AddTypeSourceInfo(E->getRhsTypeSourceInfo(), Record);
1345   Code = serialization::EXPR_BINARY_TYPE_TRAIT;
1346 }
1347
1348 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1349   VisitExpr(E);
1350   Record.push_back(E->getTrait());
1351   Record.push_back(E->getValue());
1352   Writer.AddSourceRange(E->getSourceRange(), Record);
1353   Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1354   Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1355 }
1356
1357 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1358   VisitExpr(E);
1359   Record.push_back(E->getTrait());
1360   Record.push_back(E->getValue());
1361   Writer.AddSourceRange(E->getSourceRange(), Record);
1362   Writer.AddStmt(E->getQueriedExpression());
1363   Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1364 }
1365
1366 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1367   VisitExpr(E);
1368   Record.push_back(E->getValue());
1369   Writer.AddSourceRange(E->getSourceRange(), Record);
1370   Writer.AddStmt(E->getOperand());
1371   Code = serialization::EXPR_CXX_NOEXCEPT;
1372 }
1373
1374 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1375   VisitExpr(E);
1376   Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1377   Record.push_back(E->NumExpansions);
1378   Writer.AddStmt(E->getPattern());
1379   Code = serialization::EXPR_PACK_EXPANSION;
1380 }
1381
1382 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1383   VisitExpr(E);
1384   Writer.AddSourceLocation(E->OperatorLoc, Record);
1385   Writer.AddSourceLocation(E->PackLoc, Record);
1386   Writer.AddSourceLocation(E->RParenLoc, Record);
1387   Record.push_back(E->Length);
1388   Writer.AddDeclRef(E->Pack, Record);
1389   Code = serialization::EXPR_SIZEOF_PACK;
1390 }
1391
1392 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1393                                           SubstNonTypeTemplateParmPackExpr *E) {
1394   VisitExpr(E);
1395   Writer.AddDeclRef(E->Param, Record);
1396   Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1397   Writer.AddSourceLocation(E->NameLoc, Record);
1398   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1399 }
1400
1401 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1402   VisitExpr(E);
1403   Record.push_back(Writer.getOpaqueValueID(E));
1404   Writer.AddSourceLocation(E->getLocation(), Record);
1405   Code = serialization::EXPR_OPAQUE_VALUE;
1406 }
1407
1408 //===----------------------------------------------------------------------===//
1409 // CUDA Expressions and Statements.
1410 //===----------------------------------------------------------------------===//
1411
1412 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1413   VisitCallExpr(E);
1414   Writer.AddStmt(E->getConfig());
1415   Code = serialization::EXPR_CUDA_KERNEL_CALL;
1416 }
1417
1418 //===----------------------------------------------------------------------===//
1419 // ASTWriter Implementation
1420 //===----------------------------------------------------------------------===//
1421
1422 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
1423   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
1424          "SwitchCase recorded twice");
1425   unsigned NextID = SwitchCaseIDs.size();
1426   SwitchCaseIDs[S] = NextID;
1427   return NextID;
1428 }
1429
1430 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
1431   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
1432          "SwitchCase hasn't been seen yet");
1433   return SwitchCaseIDs[S];
1434 }
1435
1436 void ASTWriter::ClearSwitchCaseIDs() {
1437   SwitchCaseIDs.clear();
1438 }
1439
1440 unsigned ASTWriter::getOpaqueValueID(OpaqueValueExpr *e) {
1441   unsigned &entry = OpaqueValues[e];
1442   if (!entry) entry = OpaqueValues.size();
1443   return entry;
1444 }
1445
1446 /// \brief Write the given substatement or subexpression to the
1447 /// bitstream.
1448 void ASTWriter::WriteSubStmt(Stmt *S) {
1449   RecordData Record;
1450   ASTStmtWriter Writer(*this, Record);
1451   ++NumStatements;
1452
1453   if (!S) {
1454     Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
1455     return;
1456   }
1457
1458   // Redirect ASTWriter::AddStmt to collect sub stmts.
1459   llvm::SmallVector<Stmt *, 16> SubStmts;
1460   CollectedStmts = &SubStmts;
1461
1462   Writer.Code = serialization::STMT_NULL_PTR;
1463   Writer.Visit(S);
1464
1465 #ifndef NDEBUG
1466   if (Writer.Code == serialization::STMT_NULL_PTR) {
1467     SourceManager &SrcMgr
1468       = DeclIDs.begin()->first->getASTContext().getSourceManager();
1469     S->dump(SrcMgr);
1470     assert(0 && "Unhandled sub statement writing AST file");
1471   }
1472 #endif
1473
1474   // Revert ASTWriter::AddStmt.
1475   CollectedStmts = &StmtsToEmit;
1476
1477   // Write the sub stmts in reverse order, last to first. When reading them back
1478   // we will read them in correct order by "pop"ing them from the Stmts stack.
1479   // This simplifies reading and allows to store a variable number of sub stmts
1480   // without knowing it in advance.
1481   while (!SubStmts.empty())
1482     WriteSubStmt(SubStmts.pop_back_val());
1483
1484   Stream.EmitRecord(Writer.Code, Record);
1485 }
1486
1487 /// \brief Flush all of the statements that have been added to the
1488 /// queue via AddStmt().
1489 void ASTWriter::FlushStmts() {
1490   RecordData Record;
1491
1492   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
1493     WriteSubStmt(StmtsToEmit[I]);
1494
1495     assert(N == StmtsToEmit.size() &&
1496            "Substatement written via AddStmt rather than WriteSubStmt!");
1497
1498     // Note that we are at the end of a full expression. Any
1499     // expression records that follow this one are part of a different
1500     // expression.
1501     Stream.EmitRecord(serialization::STMT_STOP, Record);
1502   }
1503
1504   StmtsToEmit.clear();
1505 }