Lines Matching defs:E
267 for (auto E = Record.size(); Record.getIdx() != E; ) {
482 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
483 VisitExpr(E);
484 E->KeywordLoc = readSourceLocation();
485 for (auto &SubExpr: E->SubExprs)
487 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
488 E->setIsImplicit(Record.readInt() != 0);
491 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
492 VisitExpr(E);
493 E->KeywordLoc = readSourceLocation();
494 for (auto &SubExpr: E->SubExprs)
496 E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
499 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
500 VisitExpr(E);
501 E->KeywordLoc = readSourceLocation();
502 for (auto &SubExpr: E->SubExprs)
515 E = S->capture_init_end();
516 I != E; ++I)
538 void ASTStmtReader::VisitExpr(Expr *E) {
539 VisitStmt(E);
541 E->setDependence(static_cast<ExprDependence>(
543 E->setValueKind(static_cast<ExprValueKind>(
545 E->setObjectKind(static_cast<ExprObjectKind>(
548 E->setType(Record.readType());
553 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
554 VisitExpr(E);
557 assert(E->getResultStorageKind() == StorageKind && "Wrong ResultKind!");
559 E->ConstantExprBits.APValueKind = Record.readInt();
560 E->ConstantExprBits.IsUnsigned = Record.readInt();
561 E->ConstantExprBits.BitWidth = Record.readInt();
562 E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
563 E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
570 E->Int64Result() = Record.readInt();
574 E->APValueResult() = Record.readAPValue();
575 if (E->APValueResult().needsCleanup()) {
576 E->ConstantExprBits.HasCleanup = true;
577 Record.getContext().addDestruction(&E->APValueResult());
582 E->setSubExpr(Record.readSubExpr());
585 void ASTStmtReader::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *E) {
586 VisitExpr(E);
587 E->setAsteriskLocation(readSourceLocation());
590 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
591 VisitExpr(E);
593 E->setLocation(readSourceLocation());
594 E->setLParenLocation(readSourceLocation());
595 E->setRParenLocation(readSourceLocation());
597 E->setTypeSourceInfo(Record.readTypeSourceInfo());
600 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
601 VisitExpr(E);
603 E->PredefinedExprBits.HasFunctionName = HasFunctionName;
604 E->PredefinedExprBits.Kind = Record.readInt();
605 E->PredefinedExprBits.IsTransparent = Record.readInt();
606 E->setLocation(readSourceLocation());
608 E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
611 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
612 VisitExpr(E);
615 E->DeclRefExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
616 E->DeclRefExprBits.RefersToEnclosingVariableOrCapture =
618 E->DeclRefExprBits.NonOdrUseReason =
620 E->DeclRefExprBits.IsImmediateEscalating = CurrentUnpackingBits->getNextBit();
621 E->DeclRefExprBits.HasFoundDecl = CurrentUnpackingBits->getNextBit();
622 E->DeclRefExprBits.HasQualifier = CurrentUnpackingBits->getNextBit();
623 E->DeclRefExprBits.HasTemplateKWAndArgsInfo =
625 E->DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false;
627 if (E->hasTemplateKWAndArgsInfo())
630 if (E->hasQualifier())
631 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
634 if (E->hasFoundDecl())
635 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
637 if (E->hasTemplateKWAndArgsInfo())
639 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
640 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
642 E->D = readDeclAs<ValueDecl>();
643 E->setLocation(readSourceLocation());
644 E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName());
647 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
648 VisitExpr(E);
649 E->setLocation(readSourceLocation());
650 E->setValue(Record.getContext(), Record.readAPInt());
653 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
654 VisitExpr(E);
655 E->setLocation(readSourceLocation());
656 E->setScale(Record.readInt());
657 E->setValue(Record.getContext(), Record.readAPInt());
660 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
661 VisitExpr(E);
662 E->setRawSemantics(
664 E->setExact(Record.readInt());
665 E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
666 E->setLocation(readSourceLocation());
669 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
670 VisitExpr(E);
671 E->setSubExpr(Record.readSubExpr());
674 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
675 VisitExpr(E);
682 assert((NumConcatenated == E->getNumConcatenated()) &&
684 assert((Length == E->getLength()) && "Wrong Length!");
685 assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
686 E->StringLiteralBits.Kind = Record.readInt();
687 E->StringLiteralBits.IsPascal = Record.readInt();
694 E->getKind())) &&
699 E->setStrTokenLoc(I, readSourceLocation());
702 char *StrData = E->getStrDataAsChar();
707 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
708 VisitExpr(E);
709 E->setValue(Record.readInt());
710 E->setLocation(readSourceLocation());
711 E->setKind(static_cast<CharacterLiteralKind>(Record.readInt()));
714 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
715 VisitExpr(E);
716 E->setIsProducedByFoldExpansion(Record.readInt());
717 E->setLParen(readSourceLocation());
718 E->setRParen(readSourceLocation());
719 E->setSubExpr(Record.readSubExpr());
722 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
723 VisitExpr(E);
725 assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
727 E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
728 E->LParenLoc = readSourceLocation();
729 E->RParenLoc = readSourceLocation();
732 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
733 VisitExpr(E);
735 assert(hasFP_Features == E->hasStoredFPFeatures());
736 E->setSubExpr(Record.readSubExpr());
737 E->setOpcode(
739 E->setOperatorLoc(readSourceLocation());
740 E->setCanOverflow(CurrentUnpackingBits->getNextBit());
742 E->setStoredFPFeatures(
746 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
747 VisitExpr(E);
748 assert(E->getNumComponents() == Record.peekInt());
750 assert(E->getNumExpressions() == Record.peekInt());
752 E->setOperatorLoc(readSourceLocation());
753 E->setRParenLoc(readSourceLocation());
754 E->setTypeSourceInfo(readTypeSourceInfo());
755 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
761 E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
765 E->setComponent(
770 E->setComponent(
778 E->setComponent(I, OffsetOfNode(Base));
784 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
785 E->setIndexExpr(I, Record.readSubExpr());
788 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
789 VisitExpr(E);
790 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
792 E->setArgument(Record.readSubExpr());
795 E->setArgument(readTypeSourceInfo());
797 E->setOperatorLoc(readSourceLocation());
798 E->setRParenLoc(readSourceLocation());
825 ConceptSpecializationExpr *E) {
826 VisitExpr(E);
827 E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>();
829 E->ConceptRef = Record.readConceptReference();
830 E->Satisfaction = E->isValueDependent() ? nullptr :
847 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
848 VisitExpr(E);
851 E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
852 E->RequiresExprBits.IsSatisfied = Record.readInt();
853 E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
858 E->getTrailingObjects<ParmVarDecl *>());
882 Expr *> E;
884 E = readSubstitutionDiagnostic(Record);
886 E = Record.readExpr();
915 if (Expr *Ex = E.dyn_cast<Expr *>())
921 cast<concepts::Requirement::SubstitutionDiagnostic *>(E),
935 Expr *E = Record.readExpr();
936 if (E->isInstantiationDependent())
937 R = new (C) concepts::NestedRequirement(E);
940 C, E, readConstraintSatisfaction(Record));
948 E->getTrailingObjects<concepts::Requirement *>());
949 E->LParenLoc = Record.readSourceLocation();
950 E->RParenLoc = Record.readSourceLocation();
951 E->RBraceLoc = Record.readSourceLocation();
954 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
955 VisitExpr(E);
956 E->setLHS(Record.readSubExpr());
957 E->setRHS(Record.readSubExpr());
958 E->setRBracketLoc(readSourceLocation());
961 void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
962 VisitExpr(E);
963 E->setBase(Record.readSubExpr());
964 E->setRowIdx(Record.readSubExpr());
965 E->setColumnIdx(Record.readSubExpr());
966 E->setRBracketLoc(readSourceLocation());
969 void ASTStmtReader::VisitArraySectionExpr(ArraySectionExpr *E) {
970 VisitExpr(E);
971 E->ASType = Record.readEnum<ArraySectionExpr::ArraySectionType>();
973 E->setBase(Record.readSubExpr());
974 E->setLowerBound(Record.readSubExpr());
975 E->setLength(Record.readSubExpr());
977 if (E->isOMPArraySection())
978 E->setStride(Record.readSubExpr());
980 E->setColonLocFirst(readSourceLocation());
982 if (E->isOMPArraySection())
983 E->setColonLocSecond(readSourceLocation());
985 E->setRBracketLoc(readSourceLocation());
988 void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
989 VisitExpr(E);
991 E->setBase(Record.readSubExpr());
995 E->setDimensions(Dims);
999 E->setBracketsRanges(SRs);
1000 E->setLParenLoc(readSourceLocation());
1001 E->setRParenLoc(readSourceLocation());
1004 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
1005 VisitExpr(E);
1007 E->setIteratorKwLoc(readSourceLocation());
1008 E->setLParenLoc(readSourceLocation());
1009 E->setRParenLoc(readSourceLocation());
1011 E->setIteratorDeclaration(I, Record.readDeclRef());
1012 E->setAssignmentLoc(I, readSourceLocation());
1020 E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step);
1027 E->setHelper(I, HD);
1031 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
1032 VisitExpr(E);
1036 E->setADLCallKind(
1039 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1040 E->setRParenLoc(readSourceLocation());
1041 E->setCallee(Record.readSubExpr());
1043 E->setArg(I, Record.readSubExpr());
1046 E->setStoredFPFeatures(
1050 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1051 VisitCallExpr(E);
1054 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1055 VisitExpr(E);
1063 E->Base = Record.readSubExpr();
1064 E->MemberDecl = Record.readDeclAs<ValueDecl>();
1065 E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
1066 E->MemberLoc = Record.readSourceLocation();
1067 E->MemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
1068 E->MemberExprBits.HasQualifier = HasQualifier;
1069 E->MemberExprBits.HasFoundDecl = HasFoundDecl;
1070 E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1071 E->MemberExprBits.HadMultipleCandidates = CurrentUnpackingBits->getNextBit();
1072 E->MemberExprBits.NonOdrUseReason =
1074 E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1077 new (E->getTrailingObjects<NestedNameSpecifierLoc>())
1083 *E->getTrailingObjects<DeclAccessPair>() = DeclAccessPair::make(FoundD, AS);
1088 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1089 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1092 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1093 VisitExpr(E);
1094 E->setBase(Record.readSubExpr());
1095 E->setIsaMemberLoc(readSourceLocation());
1096 E->setOpLoc(readSourceLocation());
1097 E->setArrow(Record.readInt());
1101 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1102 VisitExpr(E);
1103 E->Operand = Record.readSubExpr();
1104 E->setShouldCopy(Record.readInt());
1107 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1108 VisitExplicitCastExpr(E);
1109 E->LParenLoc = readSourceLocation();
1110 E->BridgeKeywordLoc = readSourceLocation();
1111 E->Kind = Record.readInt();
1114 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1115 VisitExpr(E);
1117 assert(NumBaseSpecs == E->path_size());
1120 E->setCastKind((CastKind)CurrentUnpackingBits->getNextBits(/*Width=*/7));
1122 assert(E->hasStoredFPFeatures() == HasFPFeatures);
1124 E->setSubExpr(Record.readSubExpr());
1126 CastExpr::path_iterator BaseI = E->path_begin();
1133 *E->getTrailingFPFeatures() =
1137 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1138 VisitExpr(E);
1140 E->setOpcode(
1143 E->setHasStoredFPFeatures(hasFP_Features);
1144 E->setExcludedOverflowPattern(CurrentUnpackingBits->getNextBit());
1145 E->setLHS(Record.readSubExpr());
1146 E->setRHS(Record.readSubExpr());
1147 E->setOperatorLoc(readSourceLocation());
1149 E->setStoredFPFeatures(
1153 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1154 VisitBinaryOperator(E);
1155 E->setComputationLHSType(Record.readType());
1156 E->setComputationResultType(Record.readType());
1159 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1160 VisitExpr(E);
1161 E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1162 E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1163 E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1164 E->QuestionLoc = readSourceLocation();
1165 E->ColonLoc = readSourceLocation();
1169 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1170 VisitExpr(E);
1171 E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
1172 E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1173 E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1174 E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1175 E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1176 E->QuestionLoc = readSourceLocation();
1177 E->ColonLoc = readSourceLocation();
1180 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1181 VisitCastExpr(E);
1182 E->setIsPartOfExplicitCast(CurrentUnpackingBits->getNextBit());
1185 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1186 VisitCastExpr(E);
1187 E->setTypeInfoAsWritten(readTypeSourceInfo());
1190 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1191 VisitExplicitCastExpr(E);
1192 E->setLParenLoc(readSourceLocation());
1193 E->setRParenLoc(readSourceLocation());
1196 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1197 VisitExpr(E);
1198 E->setLParenLoc(readSourceLocation());
1199 E->setTypeSourceInfo(readTypeSourceInfo());
1200 E->setInitializer(Record.readSubExpr());
1201 E->setFileScope(Record.readInt());
1204 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1205 VisitExpr(E);
1206 E->setBase(Record.readSubExpr());
1207 E->setAccessor(Record.readIdentifier());
1208 E->setAccessorLoc(readSourceLocation());
1211 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1212 VisitExpr(E);
1214 E->setSyntacticForm(SyntForm);
1215 E->setLBraceLoc(readSourceLocation());
1216 E->setRBraceLoc(readSourceLocation());
1221 E->ArrayFillerOrUnionFieldInit = filler;
1223 E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1224 E->sawArrayRangeDesignator(Record.readInt());
1226 E->reserveInits(Record.getContext(), NumInits);
1230 E->updateInit(Record.getContext(), I, init ? init : filler);
1234 E->updateInit(Record.getContext(), I, Record.readSubExpr());
1238 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1241 VisitExpr(E);
1243 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1245 E->setSubExpr(I, Record.readSubExpr());
1246 E->setEqualOrColonLoc(readSourceLocation());
1247 E->setGNUSyntax(Record.readInt());
1292 E->setDesignators(Record.getContext(),
1296 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1297 VisitExpr(E);
1298 E->setBase(Record.readSubExpr());
1299 E->setUpdater(Record.readSubExpr());
1302 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1303 VisitExpr(E);
1306 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1307 VisitExpr(E);
1308 E->SubExprs[0] = Record.readSubExpr();
1309 E->SubExprs[1] = Record.readSubExpr();
1312 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1313 VisitExpr(E);
1316 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1317 VisitExpr(E);
1320 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1321 VisitExpr(E);
1322 E->setSubExpr(Record.readSubExpr());
1323 E->setWrittenTypeInfo(readTypeSourceInfo());
1324 E->setBuiltinLoc(readSourceLocation());
1325 E->setRParenLoc(readSourceLocation());
1326 E->setIsMicrosoftABI(Record.readInt());
1329 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1330 VisitExpr(E);
1331 E->ParentContext = readDeclAs<DeclContext>();
1332 E->BuiltinLoc = readSourceLocation();
1333 E->RParenLoc = readSourceLocation();
1334 E->SourceLocExprBits.Kind = Record.readInt();
1337 void ASTStmtReader::VisitEmbedExpr(EmbedExpr *E) {
1338 VisitExpr(E);
1339 E->EmbedKeywordLoc = readSourceLocation();
1342 E->Data = Data;
1343 E->Begin = Record.readInt();
1344 E->NumOfElements = Record.readInt();
1347 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1348 VisitExpr(E);
1349 E->setAmpAmpLoc(readSourceLocation());
1350 E->setLabelLoc(readSourceLocation());
1351 E->setLabel(readDeclAs<LabelDecl>());
1354 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1355 VisitExpr(E);
1356 E->setLParenLoc(readSourceLocation());
1357 E->setRParenLoc(readSourceLocation());
1358 E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1359 E->StmtExprBits.TemplateDepth = Record.readInt();
1362 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1363 VisitExpr(E);
1364 E->setCond(Record.readSubExpr());
1365 E->setLHS(Record.readSubExpr());
1366 E->setRHS(Record.readSubExpr());
1367 E->setBuiltinLoc(readSourceLocation());
1368 E->setRParenLoc(readSourceLocation());
1369 E->setIsConditionTrue(Record.readInt());
1372 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1373 VisitExpr(E);
1374 E->setTokenLocation(readSourceLocation());
1377 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1378 VisitExpr(E);
1383 E->setExprs(Record.getContext(), Exprs);
1384 E->setBuiltinLoc(readSourceLocation());
1385 E->setRParenLoc(readSourceLocation());
1388 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1389 VisitExpr(E);
1390 E->BuiltinLoc = readSourceLocation();
1391 E->RParenLoc = readSourceLocation();
1392 E->TInfo = readTypeSourceInfo();
1393 E->SrcExpr = Record.readSubExpr();
1396 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1397 VisitExpr(E);
1398 E->setBlockDecl(readDeclAs<BlockDecl>());
1401 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1402 VisitExpr(E);
1405 assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1406 E->IsExprPredicate = Record.readInt();
1407 E->ResultIndex = Record.readInt();
1408 E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1409 E->DefaultLoc = readSourceLocation();
1410 E->RParenLoc = readSourceLocation();
1412 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1419 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1424 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1425 VisitExpr(E);
1427 assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1428 E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1431 E->getSubExprsBuffer()[0] = Record.readSubExpr();
1436 E->getSubExprsBuffer()[i+1] = subExpr;
1440 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1441 VisitExpr(E);
1442 E->Op = AtomicExpr::AtomicOp(Record.readInt());
1443 E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1444 for (unsigned I = 0; I != E->NumSubExprs; ++I)
1445 E->SubExprs[I] = Record.readSubExpr();
1446 E->BuiltinLoc = readSourceLocation();
1447 E->RParenLoc = readSourceLocation();
1453 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1454 VisitExpr(E);
1455 E->setString(cast<StringLiteral>(Record.readSubStmt()));
1456 E->setAtLoc(readSourceLocation());
1459 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1460 VisitExpr(E);
1462 E->SubExpr = Record.readSubStmt();
1463 E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1464 E->Range = readSourceRange();
1467 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1468 VisitExpr(E);
1470 assert(NumElements == E->getNumElements() && "Wrong number of elements");
1471 Expr **Elements = E->getElements();
1474 E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1475 E->Range = readSourceRange();
1478 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1479 VisitExpr(E);
1481 assert(NumElements == E->getNumElements() && "Wrong number of elements");
1483 assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1485 E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1487 E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1496 E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1497 E->Range = readSourceRange();
1500 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1501 VisitExpr(E);
1502 E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1503 E->setAtLoc(readSourceLocation());
1504 E->setRParenLoc(readSourceLocation());
1507 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1508 VisitExpr(E);
1509 E->setSelector(Record.readSelector());
1510 E->setAtLoc(readSourceLocation());
1511 E->setRParenLoc(readSourceLocation());
1514 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1515 VisitExpr(E);
1516 E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1517 E->setAtLoc(readSourceLocation());
1518 E->ProtoLoc = readSourceLocation();
1519 E->setRParenLoc(readSourceLocation());
1522 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1523 VisitExpr(E);
1524 E->setDecl(readDeclAs<ObjCIvarDecl>());
1525 E->setLocation(readSourceLocation());
1526 E->setOpLoc(readSourceLocation());
1527 E->setBase(Record.readSubExpr());
1528 E->setIsArrow(Record.readInt());
1529 E->setIsFreeIvar(Record.readInt());
1532 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1533 VisitExpr(E);
1539 E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1541 E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1543 E->setLocation(readSourceLocation());
1544 E->setReceiverLocation(readSourceLocation());
1547 E->setBase(Record.readSubExpr());
1550 E->setSuperReceiver(Record.readType());
1553 E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1558 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1559 VisitExpr(E);
1560 E->setRBracket(readSourceLocation());
1561 E->setBaseExpr(Record.readSubExpr());
1562 E->setKeyExpr(Record.readSubExpr());
1563 E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1564 E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1567 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1568 VisitExpr(E);
1569 assert(Record.peekInt() == E->getNumArgs());
1572 E->SelLocsKind = Record.readInt();
1573 E->setDelegateInitCall(Record.readInt());
1574 E->IsImplicit = Record.readInt();
1578 E->setInstanceReceiver(Record.readSubExpr());
1582 E->setClassReceiver(readTypeSourceInfo());
1589 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1594 assert(Kind == E->getReceiverKind());
1597 E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1599 E->setSelector(Record.readSelector());
1601 E->LBracLoc = readSourceLocation();
1602 E->RBracLoc = readSourceLocation();
1604 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1605 E->setArg(I, Record.readSubExpr());
1607 SourceLocation *Locs = E->getStoredSelLocs();
1668 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1669 VisitExpr(E);
1670 E->setValue(Record.readInt());
1671 E->setLocation(readSourceLocation());
1674 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1675 VisitExpr(E);
1677 E->AtLoc = R.getBegin();
1678 E->RParen = R.getEnd();
1679 E->VersionToCheck = Record.readVersionTuple();
1728 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1729 VisitCallExpr(E);
1730 E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1731 E->Range = Record.readSourceRange();
1735 CXXRewrittenBinaryOperator *E) {
1736 VisitExpr(E);
1737 E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1738 E->SemanticForm = Record.readSubExpr();
1741 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1742 VisitExpr(E);
1745 assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1747 E->CXXConstructExprBits.Elidable = Record.readInt();
1748 E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1749 E->CXXConstructExprBits.ListInitialization = Record.readInt();
1750 E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1751 E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1752 E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1753 E->CXXConstructExprBits.IsImmediateEscalating = Record.readInt();
1754 E->CXXConstructExprBits.Loc = readSourceLocation();
1755 E->Constructor = readDeclAs<CXXConstructorDecl>();
1756 E->ParenOrBraceRange = readSourceRange();
1759 E->setArg(I, Record.readSubExpr());
1762 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1763 VisitExpr(E);
1764 E->Constructor = readDeclAs<CXXConstructorDecl>();
1765 E->Loc = readSourceLocation();
1766 E->ConstructsVirtualBase = Record.readInt();
1767 E->InheritedFromVirtualBase = Record.readInt();
1770 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1771 VisitCXXConstructExpr(E);
1772 E->TSI = readTypeSourceInfo();
1775 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1776 VisitExpr(E);
1779 assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1780 E->IntroducerRange = readSourceRange();
1781 E->LambdaExprBits.CaptureDefault = Record.readInt();
1782 E->CaptureDefaultLoc = readSourceLocation();
1783 E->LambdaExprBits.ExplicitParams = Record.readInt();
1784 E->LambdaExprBits.ExplicitResultType = Record.readInt();
1785 E->ClosingBrace = readSourceLocation();
1788 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1789 CEnd = E->capture_init_end();
1798 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1799 VisitExpr(E);
1800 E->SubExpr = Record.readSubExpr();
1803 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1804 VisitExplicitCastExpr(E);
1806 E->Loc = R.getBegin();
1807 E->RParenLoc = R.getEnd();
1809 E->AngleBrackets = readSourceRange();
1812 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1813 return VisitCXXNamedCastExpr(E);
1816 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1817 return VisitCXXNamedCastExpr(E);
1820 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1821 return VisitCXXNamedCastExpr(E);
1824 void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1825 return VisitCXXNamedCastExpr(E);
1828 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1829 return VisitCXXNamedCastExpr(E);
1832 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1833 VisitExplicitCastExpr(E);
1834 E->setLParenLoc(readSourceLocation());
1835 E->setRParenLoc(readSourceLocation());
1838 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1839 VisitExplicitCastExpr(E);
1840 E->KWLoc = readSourceLocation();
1841 E->RParenLoc = readSourceLocation();
1844 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1845 VisitCallExpr(E);
1846 E->UDSuffixLoc = readSourceLocation();
1849 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1850 VisitExpr(E);
1851 E->setValue(Record.readInt());
1852 E->setLocation(readSourceLocation());
1855 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1856 VisitExpr(E);
1857 E->setLocation(readSourceLocation());
1860 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1861 VisitExpr(E);
1862 E->setSourceRange(readSourceRange());
1863 if (E->isTypeOperand())
1864 E->Operand = readTypeSourceInfo();
1866 E->Operand = Record.readSubExpr();
1869 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1870 VisitExpr(E);
1871 E->setLocation(readSourceLocation());
1872 E->setImplicit(Record.readInt());
1873 E->setCapturedByCopyInLambdaWithExplicitObjectParameter(Record.readInt());
1876 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1877 VisitExpr(E);
1878 E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1879 E->Operand = Record.readSubExpr();
1880 E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1883 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1884 VisitExpr(E);
1885 E->Param = readDeclAs<ParmVarDecl>();
1886 E->UsedContext = readDeclAs<DeclContext>();
1887 E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1888 E->CXXDefaultArgExprBits.HasRewrittenInit = Record.readInt();
1889 if (E->CXXDefaultArgExprBits.HasRewrittenInit)
1890 *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
1893 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1894 VisitExpr(E);
1895 E->CXXDefaultInitExprBits.HasRewrittenInit = Record.readInt();
1896 E->Field = readDeclAs<FieldDecl>();
1897 E->UsedContext = readDeclAs<DeclContext>();
1898 E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1899 if (E->CXXDefaultInitExprBits.HasRewrittenInit)
1900 *E->getTrailingObjects<Expr *>() = Record.readSubExpr();
1903 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1904 VisitExpr(E);
1905 E->setTemporary(Record.readCXXTemporary());
1906 E->setSubExpr(Record.readSubExpr());
1909 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1910 VisitExpr(E);
1911 E->TypeInfo = readTypeSourceInfo();
1912 E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1915 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1916 VisitExpr(E);
1923 E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1924 E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1925 E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1926 E->CXXNewExprBits.HasInitializer = Record.readInt();
1927 E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1929 assert((IsArray == E->isArray()) && "Wrong IsArray!");
1930 assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1931 assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1933 assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1938 E->setOperatorNew(readDeclAs<FunctionDecl>());
1939 E->setOperatorDelete(readDeclAs<FunctionDecl>());
1940 E->AllocatedTypeInfo = readTypeSourceInfo();
1942 E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1943 E->Range = readSourceRange();
1944 E->DirectInitRange = readSourceRange();
1947 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),
1948 N = E->raw_arg_end();
1953 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1954 VisitExpr(E);
1955 E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1956 E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1957 E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1958 E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1959 E->OperatorDelete = readDeclAs<FunctionDecl>();
1960 E->Argument = Record.readSubExpr();
1961 E->CXXDeleteExprBits.Loc = readSourceLocation();
1964 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1965 VisitExpr(E);
1967 E->Base = Record.readSubExpr();
1968 E->IsArrow = Record.readInt();
1969 E->OperatorLoc = readSourceLocation();
1970 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1971 E->ScopeType = readTypeSourceInfo();
1972 E->ColonColonLoc = readSourceLocation();
1973 E->TildeLoc = readSourceLocation();
1977 E->setDestroyedType(II, readSourceLocation());
1979 E->setDestroyedType(readTypeSourceInfo());
1982 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1983 VisitExpr(E);
1986 assert(NumObjects == E->getNumObjects());
1996 E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
1999 E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
2000 E->SubExpr = Record.readSubExpr();
2004 CXXDependentScopeMemberExpr *E) {
2005 VisitExpr(E);
2012 assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
2015 (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
2020 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2021 E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
2023 assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
2026 E->CXXDependentScopeMemberExprBits.IsArrow =
2029 E->BaseType = Record.readType();
2030 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2033 E->Base = Record.readSubExpr();
2035 E->Base = nullptr;
2037 E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
2040 *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
2042 E->MemberNameInfo = Record.readDeclarationNameInfo();
2046 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2047 VisitExpr(E);
2051 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
2052 E->getTrailingObjects<TemplateArgumentLoc>(),
2055 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2056 E->NameInfo = Record.readDeclarationNameInfo();
2060 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2061 VisitExpr(E);
2062 assert(Record.peekInt() == E->getNumArgs() &&
2065 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2066 E->setArg(I, Record.readSubExpr());
2067 E->TypeAndInitForm.setPointer(readTypeSourceInfo());
2068 E->setLParenLoc(readSourceLocation());
2069 E->setRParenLoc(readSourceLocation());
2070 E->TypeAndInitForm.setInt(Record.readInt());
2073 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
2074 VisitExpr(E);
2079 assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2080 assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2085 ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
2086 E->getTrailingTemplateArgumentLoc(),
2088 assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2099 DeclAccessPair *Results = E->getTrailingResults();
2105 E->NameInfo = Record.readDeclarationNameInfo();
2106 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2109 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2110 VisitOverloadExpr(E);
2111 E->UnresolvedMemberExprBits.IsArrow = CurrentUnpackingBits->getNextBit();
2112 E->UnresolvedMemberExprBits.HasUnresolvedUsing =
2116 E->Base = Record.readSubExpr();
2118 E->Base = nullptr;
2120 E->OperatorLoc = readSourceLocation();
2122 E->BaseType = Record.readType();
2125 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2126 VisitOverloadExpr(E);
2127 E->UnresolvedLookupExprBits.RequiresADL = CurrentUnpackingBits->getNextBit();
2128 E->NamingClass = readDeclAs<CXXRecordDecl>();
2131 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2132 VisitExpr(E);
2133 E->TypeTraitExprBits.NumArgs = Record.readInt();
2134 E->TypeTraitExprBits.Kind = Record.readInt();
2135 E->TypeTraitExprBits.Value = Record.readInt();
2137 E->Loc = Range.getBegin();
2138 E->RParenLoc = Range.getEnd();
2140 auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2141 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2145 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2146 VisitExpr(E);
2147 E->ATT = (ArrayTypeTrait)Record.readInt();
2148 E->Value = (unsigned int)Record.readInt();
2150 E->Loc = Range.getBegin();
2151 E->RParen = Range.getEnd();
2152 E->QueriedType = readTypeSourceInfo();
2153 E->Dimension = Record.readSubExpr();
2156 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2157 VisitExpr(E);
2158 E->ET = (ExpressionTrait)Record.readInt();
2159 E->Value = (bool)Record.readInt();
2161 E->QueriedExpression = Record.readSubExpr();
2162 E->Loc = Range.getBegin();
2163 E->RParen = Range.getEnd();
2166 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2167 VisitExpr(E);
2168 E->CXXNoexceptExprBits.Value = Record.readInt();
2169 E->Range = readSourceRange();
2170 E->Operand = Record.readSubExpr();
2173 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2174 VisitExpr(E);
2175 E->EllipsisLoc = readSourceLocation();
2176 E->NumExpansions = Record.readInt();
2177 E->Pattern = Record.readSubExpr();
2180 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2181 VisitExpr(E);
2183 E->OperatorLoc = readSourceLocation();
2184 E->PackLoc = readSourceLocation();
2185 E->RParenLoc = readSourceLocation();
2186 E->Pack = Record.readDeclAs<NamedDecl>();
2187 if (E->isPartiallySubstituted()) {
2188 assert(E->Length == NumPartialArgs);
2189 for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2190 *E = I + NumPartialArgs;
2191 I != E; ++I)
2193 } else if (!E->isValueDependent()) {
2194 E->Length = Record.readInt();
2198 void ASTStmtReader::VisitPackIndexingExpr(PackIndexingExpr *E) {
2199 VisitExpr(E);
2200 E->TransformedExpressions = Record.readInt();
2201 E->FullySubstituted = Record.readInt();
2202 E->EllipsisLoc = readSourceLocation();
2203 E->RSquareLoc = readSourceLocation();
2204 E->SubExprs[0] = Record.readStmt();
2205 E->SubExprs[1] = Record.readStmt();
2206 auto **Exprs = E->getTrailingObjects<Expr *>();
2207 for (unsigned I = 0; I < E->TransformedExpressions; ++I)
2212 ResolvedUnexpandedPackExpr *E) {
2213 VisitExpr(E);
2214 E->NumExprs = Record.readInt();
2215 E->BeginLoc = readSourceLocation();
2216 auto **Exprs = E->getTrailingObjects<Expr *>();
2217 for (unsigned I = 0; I < E->NumExprs; ++I)
2222 SubstNonTypeTemplateParmExpr *E) {
2223 VisitExpr(E);
2224 E->AssociatedDeclAndRef.setPointer(readDeclAs<Decl>());
2225 E->AssociatedDeclAndRef.setInt(CurrentUnpackingBits->getNextBit());
2226 E->Index = CurrentUnpackingBits->getNextBits(/*Width=*/12);
2228 E->PackIndex = Record.readInt();
2230 E->PackIndex = 0;
2231 E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2232 E->Replacement = Record.readSubExpr();
2236 SubstNonTypeTemplateParmPackExpr *E) {
2237 VisitExpr(E);
2238 E->AssociatedDecl = readDeclAs<Decl>();
2239 E->Index = Record.readInt();
2244 E->Arguments = ArgPack.pack_begin();
2245 E->NumArguments = ArgPack.pack_size();
2246 E->NameLoc = readSourceLocation();
2249 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2250 VisitExpr(E);
2251 E->NumParameters = Record.readInt();
2252 E->ParamPack = readDeclAs<ParmVarDecl>();
2253 E->NameLoc = readSourceLocation();
2254 auto **Parms = E->getTrailingObjects<VarDecl *>();
2255 for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2259 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2260 VisitExpr(E);
2263 E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
2265 E->State = Record.readSubExpr();
2268 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2269 VisitExpr(E);
2270 E->LParenLoc = readSourceLocation();
2271 E->EllipsisLoc = readSourceLocation();
2272 E->RParenLoc = readSourceLocation();
2273 E->NumExpansions = Record.readInt();
2274 E->SubExprs[0] = Record.readSubExpr();
2275 E->SubExprs[1] = Record.readSubExpr();
2276 E->SubExprs[2] = Record.readSubExpr();
2277 E->Opcode = (BinaryOperatorKind)Record.readInt();
2280 void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2281 VisitExpr(E);
2283 assert(E->NumExprs == ExpectedNumExprs &&
2286 E->NumUserSpecifiedExprs = Record.readInt();
2287 E->InitLoc = readSourceLocation();
2288 E->LParenLoc = readSourceLocation();
2289 E->RParenLoc = readSourceLocation();
2291 E->getTrailingObjects<Expr *>()[I] = Record.readSubExpr();
2297 E->setArrayFiller(Record.readSubExpr());
2299 E->setInitializedFieldInUnion(readDeclAs<FieldDecl>());
2302 E->updateDependence();
2305 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2306 VisitExpr(E);
2307 E->SourceExpr = Record.readSubExpr();
2308 E->OpaqueValueExprBits.Loc = readSourceLocation();
2309 E->setIsUnique(Record.readInt());
2312 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2316 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2317 VisitExpr(E);
2319 E->BeginLoc = readSourceLocation();
2320 E->EndLoc = readSourceLocation();
2322 std::distance(E->children().begin(), E->children().end())) &&
2325 for (Stmt *&Child : E->children())
2332 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2333 VisitExpr(E);
2334 E->IsArrow = (Record.readInt() != 0);
2335 E->BaseExpr = Record.readSubExpr();
2336 E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2337 E->MemberLoc = readSourceLocation();
2338 E->TheDecl = readDeclAs<MSPropertyDecl>();
2341 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2342 VisitExpr(E);
2343 E->setBase(Record.readSubExpr());
2344 E->setIdx(Record.readSubExpr());
2345 E->setRBracketLoc(readSourceLocation());
2348 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2349 VisitExpr(E);
2350 E->setSourceRange(readSourceRange());
2351 E->Guid = readDeclAs<MSGuidDecl>();
2352 if (E->isTypeOperand())
2353 E->Operand = readTypeSourceInfo();
2355 E->Operand = Record.readSubExpr();
2388 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2389 VisitCallExpr(E);
2390 E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2396 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2397 VisitExpr(E);
2398 E->BuiltinLoc = readSourceLocation();
2399 E->RParenLoc = readSourceLocation();
2400 E->SrcExpr = Record.readSubExpr();
2413 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2414 Record.readOMPChildren(E->Data);
2415 E->setLocStart(readSourceLocation());
2416 E->setLocEnd(readSourceLocation());