Lines Matching defs:E
266 for (auto E = Record.size(); Record.getIdx() != E; ) {
481 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
482 VisitExpr(E);
483 E->KeywordLoc = readSourceLocation();
484 for (auto &SubExpr: E->SubExprs)
486 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
487 E->setIsImplicit(Record.readInt() != 0);
490 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
491 VisitExpr(E);
492 E->KeywordLoc = readSourceLocation();
493 for (auto &SubExpr: E->SubExprs)
495 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
498 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
499 VisitExpr(E);
500 E->KeywordLoc = readSourceLocation();
501 for (auto &SubExpr: E->SubExprs)
514 E = S->capture_init_end();
515 I != E; ++I)
531 void ASTStmtReader::VisitExpr(Expr *E) {
532 VisitStmt(E);
534 E->setDependence(static_cast<ExprDependence>(
536 E->setValueKind(static_cast<ExprValueKind>(
538 E->setObjectKind(static_cast<ExprObjectKind>(
541 E->setType(Record.readType());
546 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
547 VisitExpr(E);
550 assert(E->getResultStorageKind() == StorageKind && "Wrong ResultKind!");
552 E->ConstantExprBits.APValueKind = Record.readInt();
553 E->ConstantExprBits.IsUnsigned = Record.readInt();
554 E->ConstantExprBits.BitWidth = Record.readInt();
555 E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
556 E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
563 E->Int64Result() = Record.readInt();
567 E->APValueResult() = Record.readAPValue();
568 if (E->APValueResult().needsCleanup()) {
569 E->ConstantExprBits.HasCleanup = true;
570 Record.getContext().addDestruction(&E->APValueResult());
575 E->setSubExpr(Record.readSubExpr());
578 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
579 VisitExpr(E);
581 E->setLocation(readSourceLocation());
582 E->setLParenLocation(readSourceLocation());
583 E->setRParenLocation(readSourceLocation());
585 E->setTypeSourceInfo(Record.readTypeSourceInfo());
588 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
589 VisitExpr(E);
591 E->PredefinedExprBits.HasFunctionName = HasFunctionName;
592 E->PredefinedExprBits.Kind = Record.readInt();
593 E->PredefinedExprBits.IsTransparent = Record.readInt();
594 E->setLocation(readSourceLocation());
596 E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
599 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
600 VisitExpr(E);
603 E->DeclRefExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
604 E->DeclRefExprBits.RefersToEnclosingVariableOrCapture =
606 E->DeclRefExprBits.NonOdrUseReason =
608 E->DeclRefExprBits.IsImmediateEscalating = CurrentUnpackingBits->getNextBit();
609 E->DeclRefExprBits.HasFoundDecl = CurrentUnpackingBits->getNextBit();
610 E->DeclRefExprBits.HasQualifier = CurrentUnpackingBits->getNextBit();
611 E->DeclRefExprBits.HasTemplateKWAndArgsInfo =
613 E->DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false;
615 if (E->hasTemplateKWAndArgsInfo())
618 if (E->hasQualifier())
619 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
622 if (E->hasFoundDecl())
623 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
625 if (E->hasTemplateKWAndArgsInfo())
627 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
628 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
630 E->D = readDeclAs<ValueDecl>();
631 E->setLocation(readSourceLocation());
632 E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName());
635 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
636 VisitExpr(E);
637 E->setLocation(readSourceLocation());
638 E->setValue(Record.getContext(), Record.readAPInt());
641 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
642 VisitExpr(E);
643 E->setLocation(readSourceLocation());
644 E->setScale(Record.readInt());
645 E->setValue(Record.getContext(), Record.readAPInt());
648 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
649 VisitExpr(E);
650 E->setRawSemantics(
652 E->setExact(Record.readInt());
653 E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
654 E->setLocation(readSourceLocation());
657 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
658 VisitExpr(E);
659 E->setSubExpr(Record.readSubExpr());
662 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
663 VisitExpr(E);
670 assert((NumConcatenated == E->getNumConcatenated()) &&
672 assert((Length == E->getLength()) && "Wrong Length!");
673 assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
674 E->StringLiteralBits.Kind = Record.readInt();
675 E->StringLiteralBits.IsPascal = Record.readInt();
682 E->getKind())) &&
687 E->setStrTokenLoc(I, readSourceLocation());
690 char *StrData = E->getStrDataAsChar();
695 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
696 VisitExpr(E);
697 E->setValue(Record.readInt());
698 E->setLocation(readSourceLocation());
699 E->setKind(static_cast<CharacterLiteralKind>(Record.readInt()));
702 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
703 VisitExpr(E);
704 E->setLParen(readSourceLocation());
705 E->setRParen(readSourceLocation());
706 E->setSubExpr(Record.readSubExpr());
709 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
710 VisitExpr(E);
712 assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
714 E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
715 E->LParenLoc = readSourceLocation();
716 E->RParenLoc = readSourceLocation();
719 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
720 VisitExpr(E);
722 assert(hasFP_Features == E->hasStoredFPFeatures());
723 E->setSubExpr(Record.readSubExpr());
724 E->setOpcode(
726 E->setOperatorLoc(readSourceLocation());
727 E->setCanOverflow(CurrentUnpackingBits->getNextBit());
729 E->setStoredFPFeatures(
733 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
734 VisitExpr(E);
735 assert(E->getNumComponents() == Record.peekInt());
737 assert(E->getNumExpressions() == Record.peekInt());
739 E->setOperatorLoc(readSourceLocation());
740 E->setRParenLoc(readSourceLocation());
741 E->setTypeSourceInfo(readTypeSourceInfo());
742 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
748 E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
752 E->setComponent(
757 E->setComponent(
765 E->setComponent(I, OffsetOfNode(Base));
771 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
772 E->setIndexExpr(I, Record.readSubExpr());
775 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
776 VisitExpr(E);
777 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
779 E->setArgument(Record.readSubExpr());
782 E->setArgument(readTypeSourceInfo());
784 E->setOperatorLoc(readSourceLocation());
785 E->setRParenLoc(readSourceLocation());
812 ConceptSpecializationExpr *E) {
813 VisitExpr(E);
814 E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>();
816 E->ConceptRef = Record.readConceptReference();
817 E->Satisfaction = E->isValueDependent() ? nullptr :
834 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
835 VisitExpr(E);
838 E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
839 E->RequiresExprBits.IsSatisfied = Record.readInt();
840 E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
845 E->getTrailingObjects<ParmVarDecl *>());
869 Expr *> E;
871 E = readSubstitutionDiagnostic(Record);
873 E = Record.readExpr();
902 if (Expr *Ex = E.dyn_cast<Expr *>())
908 E.get<concepts::Requirement::SubstitutionDiagnostic *>(),
922 Expr *E = Record.readExpr();
923 if (E->isInstantiationDependent())
924 R = new (C) concepts::NestedRequirement(E);
927 C, E, readConstraintSatisfaction(Record));
935 E->getTrailingObjects<concepts::Requirement *>());
936 E->LParenLoc = Record.readSourceLocation();
937 E->RParenLoc = Record.readSourceLocation();
938 E->RBraceLoc = Record.readSourceLocation();
941 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
942 VisitExpr(E);
943 E->setLHS(Record.readSubExpr());
944 E->setRHS(Record.readSubExpr());
945 E->setRBracketLoc(readSourceLocation());
948 void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
949 VisitExpr(E);
950 E->setBase(Record.readSubExpr());
951 E->setRowIdx(Record.readSubExpr());
952 E->setColumnIdx(Record.readSubExpr());
953 E->setRBracketLoc(readSourceLocation());
956 void ASTStmtReader::VisitArraySectionExpr(ArraySectionExpr *E) {
957 VisitExpr(E);
958 E->ASType = Record.readEnum<ArraySectionExpr::ArraySectionType>();
960 E->setBase(Record.readSubExpr());
961 E->setLowerBound(Record.readSubExpr());
962 E->setLength(Record.readSubExpr());
964 if (E->isOMPArraySection())
965 E->setStride(Record.readSubExpr());
967 E->setColonLocFirst(readSourceLocation());
969 if (E->isOMPArraySection())
970 E->setColonLocSecond(readSourceLocation());
972 E->setRBracketLoc(readSourceLocation());
975 void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
976 VisitExpr(E);
978 E->setBase(Record.readSubExpr());
982 E->setDimensions(Dims);
986 E->setBracketsRanges(SRs);
987 E->setLParenLoc(readSourceLocation());
988 E->setRParenLoc(readSourceLocation());
991 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
992 VisitExpr(E);
994 E->setIteratorKwLoc(readSourceLocation());
995 E->setLParenLoc(readSourceLocation());
996 E->setRParenLoc(readSourceLocation());
998 E->setIteratorDeclaration(I, Record.readDeclRef());
999 E->setAssignmentLoc(I, readSourceLocation());
1007 E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step);
1014 E->setHelper(I, HD);
1018 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
1019 VisitExpr(E);
1023 E->setADLCallKind(
1026 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1027 E->setRParenLoc(readSourceLocation());
1028 E->setCallee(Record.readSubExpr());
1030 E->setArg(I, Record.readSubExpr());
1033 E->setStoredFPFeatures(
1037 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1038 VisitCallExpr(E);
1041 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1042 VisitExpr(E);
1050 E->Base = Record.readSubExpr();
1051 E->MemberDecl = Record.readDeclAs<ValueDecl>();
1052 E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
1053 E->MemberLoc = Record.readSourceLocation();
1054 E->MemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
1055 E->MemberExprBits.HasQualifier = HasQualifier;
1056 E->MemberExprBits.HasFoundDecl = HasFoundDecl;
1057 E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1058 E->MemberExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
1059 E->MemberExprBits.NonOdrUseReason =
1061 E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1064 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
1070 *E->getTrailingObjects<DeclAccessPair>() = DeclAccessPair::make(FoundD, AS);
1075 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1076 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1079 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1080 VisitExpr(E);
1081 E->setBase(Record.readSubExpr());
1082 E->setIsaMemberLoc(readSourceLocation());
1083 E->setOpLoc(readSourceLocation());
1084 E->setArrow(Record.readInt());
1088 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1089 VisitExpr(E);
1090 E->Operand = Record.readSubExpr();
1091 E->setShouldCopy(Record.readInt());
1094 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1095 VisitExplicitCastExpr(E);
1096 E->LParenLoc = readSourceLocation();
1097 E->BridgeKeywordLoc = readSourceLocation();
1098 E->Kind = Record.readInt();
1101 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1102 VisitExpr(E);
1104 assert(NumBaseSpecs == E->path_size());
1107 E->setCastKind((CastKind)CurrentUnpackingBits->getNextBits(/*Width=*/7));
1109 assert(E->hasStoredFPFeatures() == HasFPFeatures);
1111 E->setSubExpr(Record.readSubExpr());
1113 CastExpr::path_iterator BaseI = E->path_begin();
1120 *E->getTrailingFPFeatures() =
1124 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1125 VisitExpr(E);
1127 E->setOpcode(
1130 E->setHasStoredFPFeatures(hasFP_Features);
1131 E->setLHS(Record.readSubExpr());
1132 E->setRHS(Record.readSubExpr());
1133 E->setOperatorLoc(readSourceLocation());
1135 E->setStoredFPFeatures(
1139 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1140 VisitBinaryOperator(E);
1141 E->setComputationLHSType(Record.readType());
1142 E->setComputationResultType(Record.readType());
1145 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1146 VisitExpr(E);
1147 E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1148 E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1149 E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1150 E->QuestionLoc = readSourceLocation();
1151 E->ColonLoc = readSourceLocation();
1155 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1156 VisitExpr(E);
1157 E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
1158 E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1159 E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1160 E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1161 E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1162 E->QuestionLoc = readSourceLocation();
1163 E->ColonLoc = readSourceLocation();
1166 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1167 VisitCastExpr(E);
1168 E->setIsPartOfExplicitCast(CurrentUnpackingBits->getNextBit());
1171 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1172 VisitCastExpr(E);
1173 E->setTypeInfoAsWritten(readTypeSourceInfo());
1176 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1177 VisitExplicitCastExpr(E);
1178 E->setLParenLoc(readSourceLocation());
1179 E->setRParenLoc(readSourceLocation());
1182 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1183 VisitExpr(E);
1184 E->setLParenLoc(readSourceLocation());
1185 E->setTypeSourceInfo(readTypeSourceInfo());
1186 E->setInitializer(Record.readSubExpr());
1187 E->setFileScope(Record.readInt());
1190 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1191 VisitExpr(E);
1192 E->setBase(Record.readSubExpr());
1193 E->setAccessor(Record.readIdentifier());
1194 E->setAccessorLoc(readSourceLocation());
1197 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1198 VisitExpr(E);
1200 E->setSyntacticForm(SyntForm);
1201 E->setLBraceLoc(readSourceLocation());
1202 E->setRBraceLoc(readSourceLocation());
1207 E->ArrayFillerOrUnionFieldInit = filler;
1209 E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1210 E->sawArrayRangeDesignator(Record.readInt());
1212 E->reserveInits(Record.getContext(), NumInits);
1216 E->updateInit(Record.getContext(), I, init ? init : filler);
1220 E->updateInit(Record.getContext(), I, Record.readSubExpr());
1224 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1227 VisitExpr(E);
1229 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1231 E->setSubExpr(I, Record.readSubExpr());
1232 E->setEqualOrColonLoc(readSourceLocation());
1233 E->setGNUSyntax(Record.readInt());
1278 E->setDesignators(Record.getContext(),
1282 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1283 VisitExpr(E);
1284 E->setBase(Record.readSubExpr());
1285 E->setUpdater(Record.readSubExpr());
1288 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1289 VisitExpr(E);
1292 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1293 VisitExpr(E);
1294 E->SubExprs[0] = Record.readSubExpr();
1295 E->SubExprs[1] = Record.readSubExpr();
1298 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1299 VisitExpr(E);
1302 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1303 VisitExpr(E);
1306 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1307 VisitExpr(E);
1308 E->setSubExpr(Record.readSubExpr());
1309 E->setWrittenTypeInfo(readTypeSourceInfo());
1310 E->setBuiltinLoc(readSourceLocation());
1311 E->setRParenLoc(readSourceLocation());
1312 E->setIsMicrosoftABI(Record.readInt());
1315 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1316 VisitExpr(E);
1317 E->ParentContext = readDeclAs<DeclContext>();
1318 E->BuiltinLoc = readSourceLocation();
1319 E->RParenLoc = readSourceLocation();
1320 E->SourceLocExprBits.Kind = Record.readInt();
1323 void ASTStmtReader::VisitEmbedExpr(EmbedExpr *E) {
1324 VisitExpr(E);
1325 E->EmbedKeywordLoc = readSourceLocation();
1328 E->Data = Data;
1329 E->Begin = Record.readInt();
1330 E->NumOfElements = Record.readInt();
1333 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1334 VisitExpr(E);
1335 E->setAmpAmpLoc(readSourceLocation());
1336 E->setLabelLoc(readSourceLocation());
1337 E->setLabel(readDeclAs<LabelDecl>());
1340 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1341 VisitExpr(E);
1342 E->setLParenLoc(readSourceLocation());
1343 E->setRParenLoc(readSourceLocation());
1344 E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1345 E->StmtExprBits.TemplateDepth = Record.readInt();
1348 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1349 VisitExpr(E);
1350 E->setCond(Record.readSubExpr());
1351 E->setLHS(Record.readSubExpr());
1352 E->setRHS(Record.readSubExpr());
1353 E->setBuiltinLoc(readSourceLocation());
1354 E->setRParenLoc(readSourceLocation());
1355 E->setIsConditionTrue(Record.readInt());
1358 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1359 VisitExpr(E);
1360 E->setTokenLocation(readSourceLocation());
1363 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1364 VisitExpr(E);
1369 E->setExprs(Record.getContext(), Exprs);
1370 E->setBuiltinLoc(readSourceLocation());
1371 E->setRParenLoc(readSourceLocation());
1374 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1375 VisitExpr(E);
1376 E->BuiltinLoc = readSourceLocation();
1377 E->RParenLoc = readSourceLocation();
1378 E->TInfo = readTypeSourceInfo();
1379 E->SrcExpr = Record.readSubExpr();
1382 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1383 VisitExpr(E);
1384 E->setBlockDecl(readDeclAs<BlockDecl>());
1387 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1388 VisitExpr(E);
1391 assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1392 E->IsExprPredicate = Record.readInt();
1393 E->ResultIndex = Record.readInt();
1394 E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1395 E->DefaultLoc = readSourceLocation();
1396 E->RParenLoc = readSourceLocation();
1398 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1405 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1410 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1411 VisitExpr(E);
1413 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1414 E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1417 E->getSubExprsBuffer()[0] = Record.readSubExpr();
1422 E->getSubExprsBuffer()[i+1] = subExpr;
1426 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1427 VisitExpr(E);
1428 E->Op = AtomicExpr::AtomicOp(Record.readInt());
1429 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1430 for (unsigned I = 0; I != E->NumSubExprs; ++I)
1431 E->SubExprs[I] = Record.readSubExpr();
1432 E->BuiltinLoc = readSourceLocation();
1433 E->RParenLoc = readSourceLocation();
1439 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1440 VisitExpr(E);
1441 E->setString(cast<StringLiteral>(Record.readSubStmt()));
1442 E->setAtLoc(readSourceLocation());
1445 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1446 VisitExpr(E);
1448 E->SubExpr = Record.readSubStmt();
1449 E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1450 E->Range = readSourceRange();
1453 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1454 VisitExpr(E);
1456 assert(NumElements == E->getNumElements() && "Wrong number of elements");
1457 Expr **Elements = E->getElements();
1460 E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1461 E->Range = readSourceRange();
1464 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1465 VisitExpr(E);
1467 assert(NumElements == E->getNumElements() && "Wrong number of elements");
1469 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1471 E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1473 E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1482 E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1483 E->Range = readSourceRange();
1486 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1487 VisitExpr(E);
1488 E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1489 E->setAtLoc(readSourceLocation());
1490 E->setRParenLoc(readSourceLocation());
1493 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1494 VisitExpr(E);
1495 E->setSelector(Record.readSelector());
1496 E->setAtLoc(readSourceLocation());
1497 E->setRParenLoc(readSourceLocation());
1500 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1501 VisitExpr(E);
1502 E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1503 E->setAtLoc(readSourceLocation());
1504 E->ProtoLoc = readSourceLocation();
1505 E->setRParenLoc(readSourceLocation());
1508 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1509 VisitExpr(E);
1510 E->setDecl(readDeclAs<ObjCIvarDecl>());
1511 E->setLocation(readSourceLocation());
1512 E->setOpLoc(readSourceLocation());
1513 E->setBase(Record.readSubExpr());
1514 E->setIsArrow(Record.readInt());
1515 E->setIsFreeIvar(Record.readInt());
1518 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1519 VisitExpr(E);
1525 E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1527 E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1529 E->setLocation(readSourceLocation());
1530 E->setReceiverLocation(readSourceLocation());
1533 E->setBase(Record.readSubExpr());
1536 E->setSuperReceiver(Record.readType());
1539 E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1544 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1545 VisitExpr(E);
1546 E->setRBracket(readSourceLocation());
1547 E->setBaseExpr(Record.readSubExpr());
1548 E->setKeyExpr(Record.readSubExpr());
1549 E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1550 E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1553 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1554 VisitExpr(E);
1555 assert(Record.peekInt() == E->getNumArgs());
1558 E->SelLocsKind = Record.readInt();
1559 E->setDelegateInitCall(Record.readInt());
1560 E->IsImplicit = Record.readInt();
1564 E->setInstanceReceiver(Record.readSubExpr());
1568 E->setClassReceiver(readTypeSourceInfo());
1575 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1580 assert(Kind == E->getReceiverKind());
1583 E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1585 E->setSelector(Record.readSelector());
1587 E->LBracLoc = readSourceLocation();
1588 E->RBracLoc = readSourceLocation();
1590 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1591 E->setArg(I, Record.readSubExpr());
1593 SourceLocation *Locs = E->getStoredSelLocs();
1654 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1655 VisitExpr(E);
1656 E->setValue(Record.readInt());
1657 E->setLocation(readSourceLocation());
1660 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1661 VisitExpr(E);
1663 E->AtLoc = R.getBegin();
1664 E->RParen = R.getEnd();
1665 E->VersionToCheck = Record.readVersionTuple();
1714 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1715 VisitCallExpr(E);
1716 E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1717 E->Range = Record.readSourceRange();
1721 CXXRewrittenBinaryOperator *E) {
1722 VisitExpr(E);
1723 E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1724 E->SemanticForm = Record.readSubExpr();
1727 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1728 VisitExpr(E);
1731 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1733 E->CXXConstructExprBits.Elidable = Record.readInt();
1734 E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1735 E->CXXConstructExprBits.ListInitialization = Record.readInt();
1736 E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1737 E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1738 E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1739 E->CXXConstructExprBits.IsImmediateEscalating = Record.readInt();
1740 E->CXXConstructExprBits.Loc = readSourceLocation();
1741 E->Constructor = readDeclAs<CXXConstructorDecl>();
1742 E->ParenOrBraceRange = readSourceRange();
1745 E->setArg(I, Record.readSubExpr());
1748 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1749 VisitExpr(E);
1750 E->Constructor = readDeclAs<CXXConstructorDecl>();
1751 E->Loc = readSourceLocation();
1752 E->ConstructsVirtualBase = Record.readInt();
1753 E->InheritedFromVirtualBase = Record.readInt();
1756 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1757 VisitCXXConstructExpr(E);
1758 E->TSI = readTypeSourceInfo();
1761 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1762 VisitExpr(E);
1765 assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1766 E->IntroducerRange = readSourceRange();
1767 E->LambdaExprBits.CaptureDefault = Record.readInt();
1768 E->CaptureDefaultLoc = readSourceLocation();
1769 E->LambdaExprBits.ExplicitParams = Record.readInt();
1770 E->LambdaExprBits.ExplicitResultType = Record.readInt();
1771 E->ClosingBrace = readSourceLocation();
1774 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1775 CEnd = E->capture_init_end();
1784 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1785 VisitExpr(E);
1786 E->SubExpr = Record.readSubExpr();
1789 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1790 VisitExplicitCastExpr(E);
1792 E->Loc = R.getBegin();
1793 E->RParenLoc = R.getEnd();
1795 E->AngleBrackets = readSourceRange();
1798 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1799 return VisitCXXNamedCastExpr(E);
1802 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1803 return VisitCXXNamedCastExpr(E);
1806 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1807 return VisitCXXNamedCastExpr(E);
1810 void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1811 return VisitCXXNamedCastExpr(E);
1814 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1815 return VisitCXXNamedCastExpr(E);
1818 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1819 VisitExplicitCastExpr(E);
1820 E->setLParenLoc(readSourceLocation());
1821 E->setRParenLoc(readSourceLocation());
1824 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1825 VisitExplicitCastExpr(E);
1826 E->KWLoc = readSourceLocation();
1827 E->RParenLoc = readSourceLocation();
1830 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1831 VisitCallExpr(E);
1832 E->UDSuffixLoc = readSourceLocation();
1835 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1836 VisitExpr(E);
1837 E->setValue(Record.readInt());
1838 E->setLocation(readSourceLocation());
1841 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1842 VisitExpr(E);
1843 E->setLocation(readSourceLocation());
1846 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1847 VisitExpr(E);
1848 E->setSourceRange(readSourceRange());
1849 if (E->isTypeOperand())
1850 E->Operand = readTypeSourceInfo();
1852 E->Operand = Record.readSubExpr();
1855 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1856 VisitExpr(E);
1857 E->setLocation(readSourceLocation());
1858 E->setImplicit(Record.readInt());
1859 E->setCapturedByCopyInLambdaWithExplicitObjectParameter(Record.readInt());
1862 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1863 VisitExpr(E);
1864 E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1865 E->Operand = Record.readSubExpr();
1866 E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1869 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1870 VisitExpr(E);
1871 E->Param = readDeclAs<ParmVarDecl>();
1872 E->UsedContext = readDeclAs<DeclContext>();
1873 E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1874 E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt();
1875 if (E->CXXDefaultArgExprBits.HasRewrittenInit)
1876 *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
1879 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1880 VisitExpr(E);
1881 E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt();
1882 E->Field = readDeclAs<FieldDecl>();
1883 E->UsedContext = readDeclAs<DeclContext>();
1884 E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1885 if (E->CXXDefaultInitExprBits.HasRewrittenInit)
1886 *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
1889 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1890 VisitExpr(E);
1891 E->setTemporary(Record.readCXXTemporary());
1892 E->setSubExpr(Record.readSubExpr());
1895 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1896 VisitExpr(E);
1897 E->TypeInfo = readTypeSourceInfo();
1898 E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1901 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1902 VisitExpr(E);
1909 E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1910 E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1911 E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1912 E->CXXNewExprBits.HasInitializer = Record.readInt();
1913 E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1915 assert((IsArray == E->isArray()) && "Wrong IsArray!");
1916 assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1917 assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1919 assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1924 E->setOperatorNew(readDeclAs<FunctionDecl>());
1925 E->setOperatorDelete(readDeclAs<FunctionDecl>());
1926 E->AllocatedTypeInfo = readTypeSourceInfo();
1928 E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1929 E->Range = readSourceRange();
1930 E->DirectInitRange = readSourceRange();
1933 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),
1934 N = E->raw_arg_end();
1939 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1940 VisitExpr(E);
1941 E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1942 E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1943 E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1944 E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1945 E->OperatorDelete = readDeclAs<FunctionDecl>();
1946 E->Argument = Record.readSubExpr();
1947 E->CXXDeleteExprBits.Loc = readSourceLocation();
1950 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1951 VisitExpr(E);
1953 E->Base = Record.readSubExpr();
1954 E->IsArrow = Record.readInt();
1955 E->OperatorLoc = readSourceLocation();
1956 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1957 E->ScopeType = readTypeSourceInfo();
1958 E->ColonColonLoc = readSourceLocation();
1959 E->TildeLoc = readSourceLocation();
1963 E->setDestroyedType(II, readSourceLocation());
1965 E->setDestroyedType(readTypeSourceInfo());
1968 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1969 VisitExpr(E);
1972 assert(NumObjects == E->getNumObjects());
1982 E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
1985 E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1986 E->SubExpr = Record.readSubExpr();
1990 CXXDependentScopeMemberExpr *E) {
1991 VisitExpr(E);
1998 assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
2001 (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
2006 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2007 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
2009 assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
2012 E->CXXDependentScopeMemberExprBits.IsArrow =
2015 E->BaseType = Record.readType();
2016 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2019 E->Base = Record.readSubExpr();
2021 E->Base = nullptr;
2023 E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
2026 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
2028 E->MemberNameInfo = Record.readDeclarationNameInfo();
2032 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2033 VisitExpr(E);
2037 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2038 E->getTrailingObjects<TemplateArgumentLoc>(),
2041 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2042 E->NameInfo = Record.readDeclarationNameInfo();
2046 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2047 VisitExpr(E);
2048 assert(Record.peekInt() == E->getNumArgs() &&
2051 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2052 E->setArg(I, Record.readSubExpr());
2053 E->TypeAndInitForm.setPointer(readTypeSourceInfo());
2054 E->setLParenLoc(readSourceLocation());
2055 E->setRParenLoc(readSourceLocation());
2056 E->TypeAndInitForm.setInt(Record.readInt());
2059 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
2060 VisitExpr(E);
2065 assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2066 assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2071 ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
2072 E->getTrailingTemplateArgumentLoc(),
2074 assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2085 DeclAccessPair *Results = E->getTrailingResults();
2091 E->NameInfo = Record.readDeclarationNameInfo();
2092 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2095 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2096 VisitOverloadExpr(E);
2097 E->UnresolvedMemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
2098 E->UnresolvedMemberExprBits.HasUnresolvedUsing =
2102 E->Base = Record.readSubExpr();
2104 E->Base = nullptr;
2106 E->OperatorLoc = readSourceLocation();
2108 E->BaseType = Record.readType();
2111 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2112 VisitOverloadExpr(E);
2113 E->UnresolvedLookupExprBits.RequiresADL = CurrentUnpackingBits->getNextBit();
2114 E->NamingClass = readDeclAs<CXXRecordDecl>();
2117 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2118 VisitExpr(E);
2119 E->TypeTraitExprBits.NumArgs = Record.readInt();
2120 E->TypeTraitExprBits.Kind = Record.readInt();
2121 E->TypeTraitExprBits.Value = Record.readInt();
2123 E->Loc = Range.getBegin();
2124 E->RParenLoc = Range.getEnd();
2126 auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2127 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2131 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2132 VisitExpr(E);
2133 E->ATT = (ArrayTypeTrait)Record.readInt();
2134 E->Value = (unsigned int)Record.readInt();
2136 E->Loc = Range.getBegin();
2137 E->RParen = Range.getEnd();
2138 E->QueriedType = readTypeSourceInfo();
2139 E->Dimension = Record.readSubExpr();
2142 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2143 VisitExpr(E);
2144 E->ET = (ExpressionTrait)Record.readInt();
2145 E->Value = (bool)Record.readInt();
2147 E->QueriedExpression = Record.readSubExpr();
2148 E->Loc = Range.getBegin();
2149 E->RParen = Range.getEnd();
2152 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2153 VisitExpr(E);
2154 E->CXXNoexceptExprBits.Value = Record.readInt();
2155 E->Range = readSourceRange();
2156 E->Operand = Record.readSubExpr();
2159 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2160 VisitExpr(E);
2161 E->EllipsisLoc = readSourceLocation();
2162 E->NumExpansions = Record.readInt();
2163 E->Pattern = Record.readSubExpr();
2166 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2167 VisitExpr(E);
2169 E->OperatorLoc = readSourceLocation();
2170 E->PackLoc = readSourceLocation();
2171 E->RParenLoc = readSourceLocation();
2172 E->Pack = Record.readDeclAs<NamedDecl>();
2173 if (E->isPartiallySubstituted()) {
2174 assert(E->Length == NumPartialArgs);
2175 for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2176 *E = I + NumPartialArgs;
2177 I != E; ++I)
2179 } else if (!E->isValueDependent()) {
2180 E->Length = Record.readInt();
2184 void ASTStmtReader::VisitPackIndexingExpr(PackIndexingExpr *E) {
2185 VisitExpr(E);
2186 E->TransformedExpressions = Record.readInt();
2187 E->ExpandedToEmptyPack = Record.readInt();
2188 E->EllipsisLoc = readSourceLocation();
2189 E->RSquareLoc = readSourceLocation();
2190 E->SubExprs[0] = Record.readStmt();
2191 E->SubExprs[1] = Record.readStmt();
2192 auto **Exprs = E->getTrailingObjects<Expr *>();
2193 for (unsigned I = 0; I < E->TransformedExpressions; ++I)
2198 SubstNonTypeTemplateParmExpr *E) {
2199 VisitExpr(E);
2200 E->AssociatedDeclAndRef.setPointer(readDeclAs<Decl>());
2201 E->AssociatedDeclAndRef.setInt(CurrentUnpackingBits->getNextBit());
2202 E->Index = CurrentUnpackingBits->getNextBits(/*Width=*/12);
2204 E->PackIndex = Record.readInt();
2206 E->PackIndex = 0;
2207 E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2208 E->Replacement = Record.readSubExpr();
2212 SubstNonTypeTemplateParmPackExpr *E) {
2213 VisitExpr(E);
2214 E->AssociatedDecl = readDeclAs<Decl>();
2215 E->Index = Record.readInt();
2220 E->Arguments = ArgPack.pack_begin();
2221 E->NumArguments = ArgPack.pack_size();
2222 E->NameLoc = readSourceLocation();
2225 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2226 VisitExpr(E);
2227 E->NumParameters = Record.readInt();
2228 E->ParamPack = readDeclAs<ParmVarDecl>();
2229 E->NameLoc = readSourceLocation();
2230 auto **Parms = E->getTrailingObjects<VarDecl *>();
2231 for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2235 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2236 VisitExpr(E);
2239 E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
2241 E->State = Record.readSubExpr();
2244 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2245 VisitExpr(E);
2246 E->LParenLoc = readSourceLocation();
2247 E->EllipsisLoc = readSourceLocation();
2248 E->RParenLoc = readSourceLocation();
2249 E->NumExpansions = Record.readInt();
2250 E->SubExprs[0] = Record.readSubExpr();
2251 E->SubExprs[1] = Record.readSubExpr();
2252 E->SubExprs[2] = Record.readSubExpr();
2253 E->Opcode = (BinaryOperatorKind)Record.readInt();
2256 void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2257 VisitExpr(E);
2259 assert(E->NumExprs == ExpectedNumExprs &&
2262 E->NumUserSpecifiedExprs = Record.readInt();
2263 E->InitLoc = readSourceLocation();
2264 E->LParenLoc = readSourceLocation();
2265 E->RParenLoc = readSourceLocation();
2267 E->getTrailingObjects<Expr *>()[I] = Record.readSubExpr();
2273 E->setArrayFiller(Record.readSubExpr());
2275 E->setInitializedFieldInUnion(readDeclAs<FieldDecl>());
2278 E->updateDependence();
2281 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2282 VisitExpr(E);
2283 E->SourceExpr = Record.readSubExpr();
2284 E->OpaqueValueExprBits.Loc = readSourceLocation();
2285 E->setIsUnique(Record.readInt());
2288 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2292 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2293 VisitExpr(E);
2295 E->BeginLoc = readSourceLocation();
2296 E->EndLoc = readSourceLocation();
2298 std::distance(E->children().begin(), E->children().end())) &&
2301 for (Stmt *&Child : E->children())
2308 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2309 VisitExpr(E);
2310 E->IsArrow = (Record.readInt() != 0);
2311 E->BaseExpr = Record.readSubExpr();
2312 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2313 E->MemberLoc = readSourceLocation();
2314 E->TheDecl = readDeclAs<MSPropertyDecl>();
2317 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2318 VisitExpr(E);
2319 E->setBase(Record.readSubExpr());
2320 E->setIdx(Record.readSubExpr());
2321 E->setRBracketLoc(readSourceLocation());
2324 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2325 VisitExpr(E);
2326 E->setSourceRange(readSourceRange());
2327 E->Guid = readDeclAs<MSGuidDecl>();
2328 if (E->isTypeOperand())
2329 E->Operand = readTypeSourceInfo();
2331 E->Operand = Record.readSubExpr();
2364 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2365 VisitCallExpr(E);
2366 E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2372 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2373 VisitExpr(E);
2374 E->BuiltinLoc = readSourceLocation();
2375 E->RParenLoc = readSourceLocation();
2376 E->SrcExpr = Record.readSubExpr();
2389 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2390 Record.readOMPChildren(E->Data);
2391 E->setLocStart(readSourceLocation());
2392 E->setLocEnd(readSourceLocation());
2393 E->setMappedDirective(Record.readEnum<OpenMPDirectiveKind>());